Skip to content

张云鹏 / moss-statistic

Go to a project
Toggle navigation
Toggle navigation pinning
Commit 7fbec8e7 7fbec8e7d8d6cdc4f2466d8693205fe961df511b by xianghan
Options

init

0 parents
Expand all
Inline Side-by-side
Showing 85 changed files with 4011 additions and 0 deletions
/.idea/
/logs/
/target/
*.iml
<?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>redis-transfer-project</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>
<!--redisson-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.1.0</version>
</dependency>
<!--代码生成器-->
<dependency>
<groupId>com.topdraw</groupId>
<artifactId>cronos-system</artifactId>
<version>1.1.0</version>
</dependency>
<!--Mysql依赖包，版本差异，需单独引入-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.26</version>
</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>redis-transfer-project</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.base.BaseRepositoryFactory;
import com.topdraw.utils.SpringContextHolder;
import org.springframework.beans.factory.annotation.Autowired;
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.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
* @author ：
* @description：
* @function :
* @date ：Created in 2022/2/10 16:17
* @version: ：
* @modified By：
* @since : modified in 2022/2/10 16:17
*/
@EnableJpaAuditing
@EnableAsync
@SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
@EnableTransactionManagement
@EnableJpaRepositories(repositoryFactoryBeanClass = BaseRepositoryFactory.class)
public class RedisTransferApplication extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(RedisTransferApplication.class);
}
public static void main(String[] args) {
SpringApplication.run(RedisTransferApplication.class, args);
}
@Bean
public SpringContextHolder springContextHolder() {
return new SpringContextHolder();
}
}
package com.topdraw.business.module.activitybtn.all.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 2022-02-26
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="act_tpl_param_click")
public class ActTplParamClick implements Serializable {
// ID
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 营销活动ID
@Column(name = "marketing_activity_id", nullable = false)
private Long marketingActivityId;
// 活动事件id
@Column(name = "activity_id", nullable = false)
private Long activityId;
// 活动按钮id
@Column(name = "template_param_value_id", nullable = false)
private Long templateParamValueId;
// 显示用名称，表示哪个按钮或者内容
@Column(name = "name", nullable = false)
private String name;
// pv值
@Column(name = "pv", nullable = false)
private Integer pv;
// uv值
@Column(name = "uv", nullable = false)
private Integer uv;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(ActTplParamClick source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.module.activitybtn.all.repository;
import com.topdraw.business.module.activitybtn.all.domain.ActTplParamClick;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.Optional;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface ActivityBtnPvUvRepository extends JpaRepository<ActTplParamClick, Long>, JpaSpecificationExecutor<ActTplParamClick> {
Optional<ActTplParamClick> findByMarketingActivityIdAndActivityIdAndTemplateParamValueId(Long marketingActivityId, Long activityId, Long templateParamValueId);
}
package com.topdraw.business.module.activitybtn.all.service;
import com.topdraw.business.module.activitybtn.all.domain.ActTplParamClick;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface ActivityBtnPvUvService {
void create(ActTplParamClick resources);
void update(ActTplParamClick resources);
ActTplParamClick findByMarketingActivityIdAndActivityIdAndTemplateParamValueId(Long marketingActivityId, Long activityId, Long templateParamValueId);
}
package com.topdraw.business.module.activitybtn.all.service.dto;
import lombok.Data;
import javax.persistence.Column;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Data
public class ActTplParamClickDTO implements Serializable {
// ID
private Long id;
// 营销活动ID
private Long marketingActivityId;
// 活动事件id
private Long activityId;
// 活动按钮id
private Long templateParamValueId;
// 显示用名称，表示哪个按钮或者内容
private String name;
// pv值
private Long pv;
// uv值
private Long uv;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.module.activitybtn.all.service.impl;
import com.topdraw.business.module.activitybtn.all.domain.ActTplParamClick;
import com.topdraw.business.module.activitybtn.all.repository.ActivityBtnPvUvRepository;
import com.topdraw.business.module.activitybtn.all.service.ActivityBtnPvUvService;
import com.topdraw.utils.ValidationUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class ActivityBtnPvUvServiceImpl implements ActivityBtnPvUvService {
@Autowired
private ActivityBtnPvUvRepository PvUvRepository;
@Override
@Transactional(rollbackFor = Exception.class)
public void create(ActTplParamClick resources) {
PvUvRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(ActTplParamClick resources) {
ActTplParamClick PvUv = PvUvRepository.findById(resources.getId()).orElseGet(ActTplParamClick::new);
ValidationUtil.isNull( PvUv.getId(),"PvUv","id",resources.getId());
PvUv.copy(resources);
PvUvRepository.save(PvUv);
}
@Override
public ActTplParamClick findByMarketingActivityIdAndActivityIdAndTemplateParamValueId(Long marketingActivityId, Long activityId, Long templateParamValueId) {
return PvUvRepository.findByMarketingActivityIdAndActivityIdAndTemplateParamValueId(marketingActivityId, activityId, templateParamValueId).orElseGet(ActTplParamClick::new);
}
}
package com.topdraw.business.module.activitybtn.day.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 2022-02-26
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="act_tpl_param_click_day")
public class ActTplParamClickDay implements Serializable {
// ID
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 营销活动ID
@Column(name = "marketing_activity_id", nullable = false)
private Long marketingActivityId;
// 活动事件id
@Column(name = "activity_id", nullable = false)
private Long activityId;
// 显示用名称，表示哪个按钮或者内容
@Column(name = "name", nullable = false)
private String name;
// 活动按钮id
@Column(name = "template_param_value_id", nullable = false)
private Long templateParamValueId;
// 日期
@Column(name = "day", nullable = false)
private String day;
// pv值
@Column(name = "pv", nullable = false)
private Integer pv;
// uv值
@Column(name = "uv", nullable = false)
private Integer uv;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(ActTplParamClickDay source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.module.activitybtn.day.repository;
import com.topdraw.business.module.activitybtn.day.domain.ActTplParamClickDay;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.Optional;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface ActivityBtnPvUvDayRepository extends JpaRepository<ActTplParamClickDay, Long>, JpaSpecificationExecutor<ActTplParamClickDay> {
Optional<ActTplParamClickDay> findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDay(Long marketingActivityId, Long activityId, Long paramValueId, String day);
}
package com.topdraw.business.module.activitybtn.day.service;
import com.topdraw.business.module.activitybtn.day.domain.ActTplParamClickDay;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface ActivityBtnPvUvDayService {
void create(ActTplParamClickDay resources);
void update(ActTplParamClickDay resources);
ActTplParamClickDay findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDay(Long marketingActivityId, Long activityId, Long templateParamValueId, String toString);
}
package com.topdraw.business.module.activitybtn.day.service.dto;
import lombok.Data;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Data
public class ActTplParamClickDTO implements Serializable {
// ID
private Long id;
// 营销活动ID
private Long marketingActivityId;
// 活动事件id
private Long activityId;
// 活动按钮id
private Long templateParamValueId;
// 显示用名称，表示哪个按钮或者内容
private String name;
// 日期
private String day;
// pv值
private Integer pv;
// uv值
private Integer uv;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.module.activitybtn.day.service.impl;
import com.topdraw.business.module.activitybtn.day.domain.ActTplParamClickDay;
import com.topdraw.business.module.activitybtn.day.repository.ActivityBtnPvUvDayRepository;
import com.topdraw.business.module.activitybtn.day.service.ActivityBtnPvUvDayService;
import com.topdraw.utils.ValidationUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class ActivityBtnPvUvDayServiceImpl implements ActivityBtnPvUvDayService {
@Autowired
private ActivityBtnPvUvDayRepository pvUvDayRepository;
@Override
@Transactional(rollbackFor = Exception.class)
public void create(ActTplParamClickDay resources) {
pvUvDayRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(ActTplParamClickDay resources) {
ActTplParamClickDay PvUvDay = pvUvDayRepository.findById(resources.getId()).orElseGet(ActTplParamClickDay::new);
ValidationUtil.isNull( PvUvDay.getId(),"PvUvDay","id",resources.getId());
PvUvDay.copy(resources);
pvUvDayRepository.save(PvUvDay);
}
@Override
public ActTplParamClickDay findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDay(Long marketingActivityId, Long activityId, Long templateParamValueId, String day) {
return this.pvUvDayRepository.findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDay(marketingActivityId,
activityId, templateParamValueId, day).orElseGet(ActTplParamClickDay::new);
}
}
package com.topdraw.business.module.activitybtn.hour.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 2022-02-26
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="act_tpl_param_click_hour")
public class ActTplParamClickHour implements Serializable {
// ID
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 营销活动ID
@Column(name = "marketing_activity_id", nullable = false)
private Long marketingActivityId;
// 活动事件id
@Column(name = "activity_id", nullable = false)
private Long activityId;
// 显示用名称，表示哪个按钮或者内容
@Column(name = "name", nullable = false)
private String name;
// 活动按钮id
@Column(name = "template_param_value_id", nullable = false)
private Long templateParamValueId;
// 日期
@Column(name = "day", nullable = false)
private String day;
// 小时（0-23）
@Column(name = "hour", nullable = false)
private Integer hour;
// pv值
@Column(name = "pv", nullable = false)
private Integer pv;
// uv值
@Column(name = "uv", nullable = false)
private Integer uv;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(ActTplParamClickHour source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.module.activitybtn.hour.repository;
import com.topdraw.business.module.activitybtn.hour.domain.ActTplParamClickHour;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.Optional;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface ActivityBtnPvUvHourRepository extends JpaRepository<ActTplParamClickHour, Long>, JpaSpecificationExecutor<ActTplParamClickHour> {
Optional<ActTplParamClickHour> findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDayAndHour(Long marketingActivityId, Long activityId, Long paramValueId, String day, int hour);
}
package com.topdraw.business.module.activitybtn.hour.service;
import com.topdraw.business.module.activitybtn.hour.domain.ActTplParamClickHour;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface ActivityBtnPvUvHourService {
void create(ActTplParamClickHour resources);
void update(ActTplParamClickHour resources);
ActTplParamClickHour findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDayAndHour(Long marketingActivityId, Long activityId, Long paramValueId, String day, int hour);
}
package com.topdraw.business.module.activitybtn.hour.service.dto;
import lombok.Data;
import javax.persistence.Column;
import java.io.Serializable;
import java.sql.Timestamp;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Data
public class ActTplParamClickHourDTO implements Serializable {
// ID
private Long id;
// 营销活动ID
private Long marketingActivityId;
// 活动事件id
private Long activityId;
// 活动按钮id
private Long templateParamValueId;
// 显示用名称，表示哪个按钮或者内容
private String name;
// 日期
private String day;
// 小时（0-23）
private Integer hour;
// pv值
private Integer pv;
// uv值
private Integer uv;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.module.activitybtn.hour.service.impl;
import com.topdraw.business.module.activitybtn.hour.domain.ActTplParamClickHour;
import com.topdraw.business.module.activitybtn.hour.repository.ActivityBtnPvUvHourRepository;
import com.topdraw.business.module.activitybtn.hour.service.ActivityBtnPvUvHourService;
import com.topdraw.utils.ValidationUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class ActivityBtnPvUvHourServiceImpl implements ActivityBtnPvUvHourService {
@Autowired
private ActivityBtnPvUvHourRepository PvUvHourRepository;
@Override
@Transactional(rollbackFor = Exception.class)
public void create(ActTplParamClickHour resources) {
PvUvHourRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(ActTplParamClickHour resources) {
ActTplParamClickHour PvUvHour = PvUvHourRepository.findById(resources.getId()).orElseGet(ActTplParamClickHour::new);
ValidationUtil.isNull( PvUvHour.getId(),"PvUvHour","id",resources.getId());
PvUvHour.copy(resources);
PvUvHourRepository.save(PvUvHour);
}
@Override
public ActTplParamClickHour findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDayAndHour(Long marketingActivityId,
Long activityId, Long paramValueId,
String day, int hour) {
return PvUvHourRepository.findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDayAndHour(marketingActivityId, activityId,
paramValueId, day, hour).
orElseGet(ActTplParamClickHour::new);
}
}
package com.topdraw.business.module.subscribe.all.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="act_subscribe_pv_uv")
public class SubscribePvUv implements Serializable {
// ID
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 营销活动ID
@Column(name = "marketing_activity_id", nullable = false)
private Long marketingActivityId;
// 营销活动标识
@Column(name = "marketing_activity_code", nullable = false)
private String marketingActivityCode;
// 产品包id
@Column(name = "package_id", nullable = false)
private String packageId;
// 产品包标识
@Column(name = "package_code")
private String packageCode;
// 产品包名称
@Column(name = "package_name")
private String packageName;
// 订购按钮总点击量
@Column(name = "btn_click_pv", nullable = false)
private Long btnClickPv;
// 订购按钮总点击人数
@Column(name = "btn_click_uv", nullable = false)
private Long btnClickUv;
// 订购成功人数
@Column(name = "subscribe_num", nullable = false)
private Long subscribeNum;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(SubscribePvUv source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.module.subscribe.all.repository;
import com.topdraw.business.module.subscribe.all.domain.SubscribePvUv;
import com.topdraw.business.module.subscribe.day.domain.SubscribePvUvDay;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.Optional;
/**
* @author XiangHan
* @date 2022-04-20
*/
public interface SubscribePvUvRepository extends JpaRepository<SubscribePvUv, Long>, JpaSpecificationExecutor<SubscribePvUv> {
Optional<SubscribePvUv> findByMarketingActivityCodeAndPackageId(String code, String packageId);
}
package com.topdraw.business.module.subscribe.all.service;
import com.topdraw.business.module.subscribe.all.domain.SubscribePvUv;
import com.topdraw.business.module.subscribe.all.service.dto.SubscribePvUvDTO;
/**
* @author XiangHan
* @date 2022-04-20
*/
public interface SubscribePvUvService {
/**
* 根据ID查询
* @param id ID
* @return SubscribePvUvDTO
*/
SubscribePvUvDTO findById(Long id);
void create(SubscribePvUv resources);
void update(SubscribePvUv resources);
void delete(Long id);
SubscribePvUv findByMarketingActivityCodeAndPackageId(String code, String packageId);
}
package com.topdraw.business.module.subscribe.all.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Data
public class SubscribePvUvDTO implements Serializable {
// ID
private Long id;
// 营销活动ID
private Long marketingActivityId;
// 营销活动标识
private String marketingActivityCode;
// 产品包id
private String packageId;
// 产品包标识
private String packageCode;
// 产品包名称
private String packageName;
// 订购按钮总点击量
private Long btnClickPv;
// 订购按钮总点击人数
private Long btnClickUv;
// 订购成功人数
private Long subscribeNum;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.module.subscribe.all.service.impl;
import com.topdraw.business.module.subscribe.all.domain.SubscribePvUv;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.business.module.subscribe.all.repository.SubscribePvUvRepository;
import com.topdraw.business.module.subscribe.all.service.SubscribePvUvService;
import com.topdraw.business.module.subscribe.all.service.dto.SubscribePvUvDTO;
import com.topdraw.business.module.subscribe.all.service.mapper.SubscribePvUvMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.util.Assert;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class SubscribePvUvServiceImpl implements SubscribePvUvService {
@Autowired
private SubscribePvUvRepository SubscribePvUvRepository;
@Autowired
private SubscribePvUvMapper SubscribePvUvMapper;
@Override
public SubscribePvUvDTO findById(Long id) {
SubscribePvUv SubscribePvUv = SubscribePvUvRepository.findById(id).orElseGet(SubscribePvUv::new);
ValidationUtil.isNull(SubscribePvUv.getId(),"SubscribePvUv","id",id);
return SubscribePvUvMapper.toDto(SubscribePvUv);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(SubscribePvUv resources) {
SubscribePvUvRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(SubscribePvUv resources) {
SubscribePvUv SubscribePvUv = SubscribePvUvRepository.findById(resources.getId()).orElseGet(SubscribePvUv::new);
ValidationUtil.isNull( SubscribePvUv.getId(),"SubscribePvUv","id",resources.getId());
SubscribePvUv.copy(resources);
SubscribePvUvRepository.save(SubscribePvUv);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
SubscribePvUv SubscribePvUv = SubscribePvUvRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", SubscribePvUv.class, id), 1));
SubscribePvUvRepository.delete(SubscribePvUv);
}
@Override
public SubscribePvUv findByMarketingActivityCodeAndPackageId(String code, String packageId) {
SubscribePvUv SubscribePvUvDay =
SubscribePvUvRepository.findByMarketingActivityCodeAndPackageId(code, packageId).orElseGet(SubscribePvUv::new);
return SubscribePvUvDay;
}
}
package com.topdraw.business.module.subscribe.all.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.module.subscribe.all.domain.SubscribePvUv;
import com.topdraw.business.module.subscribe.all.service.dto.SubscribePvUvDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface SubscribePvUvMapper extends BaseMapper<SubscribePvUvDTO, SubscribePvUv> {
}
package com.topdraw.business.module.subscribe.day.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="act_subscribe_pv_uv_day")
public class SubscribePvUvDay implements Serializable {
// ID
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 营销活动ID
@Column(name = "marketing_activity_id", nullable = false)
private Long marketingActivityId;
// 营销活动标识
@Column(name = "marketing_activity_code", nullable = false)
private String marketingActivityCode;
// 产品包id
@Column(name = "package_id", nullable = false)
private String packageId;
// 产品包标识
@Column(name = "package_code")
private String packageCode;
// 产品包名称
@Column(name = "package_name")
private String packageName;
// 日期
@Column(name = "day", nullable = false)
private String day;
// 订购按钮总点击量
@Column(name = "btn_click_pv", nullable = false)
private Long btnClickPv;
// 订购按钮总点击人数
@Column(name = "btn_click_uv", nullable = false)
private Long btnClickUv;
// 订购成功人数
@Column(name = "subscribe_num", nullable = false)
private Long subscribeNum;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(SubscribePvUvDay source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.module.subscribe.day.repository;
import com.topdraw.business.module.subscribe.day.domain.SubscribePvUvDay;
import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.Optional;
/**
* @author XiangHan
* @date 2022-04-20
*/
public interface SubscribePvUvDayRepository extends JpaRepository<SubscribePvUvDay, Long>, JpaSpecificationExecutor<SubscribePvUvDay> {
Optional<SubscribePvUvDay> findByMarketingActivityCodeAndPackageIdAndDay(String code, String packageId, String day);
}
package com.topdraw.business.module.subscribe.day.service;
import com.topdraw.business.module.subscribe.day.domain.SubscribePvUvDay;
import com.topdraw.business.module.subscribe.day.service.dto.SubscribePvUvDayDTO;
import com.topdraw.business.module.subscribe.day.service.dto.SubscribePvUvDayQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author XiangHan
* @date 2022-04-20
*/
public interface SubscribePvUvDayService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(SubscribePvUvDayQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<SubscribePvUvDayDTO>
*/
List<SubscribePvUvDayDTO> queryAll(SubscribePvUvDayQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return SubscribePvUvDayDTO
*/
SubscribePvUvDayDTO findById(Long id);
void create(SubscribePvUvDay resources);
void update(SubscribePvUvDay resources);
void delete(Long id);
SubscribePvUvDay findByMarketingActivityCodeAndPackageIdAndDay(String code, String packageId, String day);
void updateByMarketingActivityCodeAndDayAndPackageId(SubscribePvUvDay subscribePvUvDay);
}
package com.topdraw.business.module.subscribe.day.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Data
public class SubscribePvUvDayDTO implements Serializable {
// ID
private Long id;
// 营销活动ID
private Long marketingActivityId;
// 营销活动标识
private String marketingActivityCode;
// 产品包id
private String packageId;
// 产品包标识
private String packageCode;
// 产品包名称
private String packageName;
// 日期
private String day;
// 订购按钮总点击量
private Long btnClickPv;
// 订购按钮总点击人数
private Long btnClickUv;
// 订购成功人数
private Long subscribeNum;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.module.subscribe.day.service.dto;
import lombok.Data;
import com.topdraw.annotation.Query;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Data
public class SubscribePvUvDayQueryCriteria{
}
package com.topdraw.business.module.subscribe.day.service.impl;
import com.topdraw.business.module.subscribe.day.domain.SubscribePvUvDay;
import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.utils.FileUtil;
import com.topdraw.business.module.subscribe.day.repository.SubscribePvUvDayRepository;
import com.topdraw.business.module.subscribe.day.service.SubscribePvUvDayService;
import com.topdraw.business.module.subscribe.day.service.dto.SubscribePvUvDayDTO;
import com.topdraw.business.module.subscribe.day.service.dto.SubscribePvUvDayQueryCriteria;
import com.topdraw.business.module.subscribe.day.service.mapper.SubscribePvUvDayMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.LinkedHashMap;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class SubscribePvUvDayServiceImpl implements SubscribePvUvDayService {
@Autowired
private SubscribePvUvDayRepository SubscribePvUvDayRepository;
@Autowired
private SubscribePvUvDayMapper SubscribePvUvDayMapper;
@Override
public Map<String, Object> queryAll(SubscribePvUvDayQueryCriteria criteria, Pageable pageable) {
Page<SubscribePvUvDay> page = SubscribePvUvDayRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(SubscribePvUvDayMapper::toDto));
}
@Override
public List<SubscribePvUvDayDTO> queryAll(SubscribePvUvDayQueryCriteria criteria) {
return SubscribePvUvDayMapper.toDto(SubscribePvUvDayRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public SubscribePvUvDayDTO findById(Long id) {
SubscribePvUvDay SubscribePvUvDay = SubscribePvUvDayRepository.findById(id).orElseGet(SubscribePvUvDay::new);
ValidationUtil.isNull(SubscribePvUvDay.getId(),"SubscribePvUvDay","id",id);
return SubscribePvUvDayMapper.toDto(SubscribePvUvDay);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(SubscribePvUvDay resources) {
SubscribePvUvDayRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(SubscribePvUvDay resources) {
SubscribePvUvDay SubscribePvUvDay = SubscribePvUvDayRepository.findById(resources.getId()).orElseGet(SubscribePvUvDay::new);
ValidationUtil.isNull( SubscribePvUvDay.getId(),"SubscribePvUvDay","id",resources.getId());
SubscribePvUvDay.copy(resources);
SubscribePvUvDayRepository.save(SubscribePvUvDay);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
SubscribePvUvDay SubscribePvUvDay = SubscribePvUvDayRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", SubscribePvUvDay.class, id), 1));
SubscribePvUvDayRepository.delete(SubscribePvUvDay);
}
@Override
public SubscribePvUvDay findByMarketingActivityCodeAndPackageIdAndDay(String code, String packageId, String day) {
SubscribePvUvDay SubscribePvUvDay =
SubscribePvUvDayRepository.findByMarketingActivityCodeAndPackageIdAndDay(code, packageId, day).orElseGet(SubscribePvUvDay::new);
return SubscribePvUvDay;
}
@Override
public void updateByMarketingActivityCodeAndDayAndPackageId(SubscribePvUvDay subscribePvUvDay) {
}
}
package com.topdraw.business.module.subscribe.day.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.module.subscribe.day.domain.SubscribePvUvDay;
import com.topdraw.business.module.subscribe.day.service.dto.SubscribePvUvDayDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface SubscribePvUvDayMapper extends BaseMapper<SubscribePvUvDayDTO, SubscribePvUvDay> {
}
package com.topdraw.business.module.subscribe.hour.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="act_subscribe_pv_uv_hour")
public class SubscribePvUvHour implements Serializable {
// ID
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 营销活动ID
@Column(name = "marketing_activity_id", nullable = false)
private Long marketingActivityId;
// 营销活动标识
@Column(name = "marketing_activity_code", nullable = false)
private String marketingActivityCode;
// 产品包id
@Column(name = "package_id", nullable = false)
private String packageId;
// 产品包标识
@Column(name = "package_code")
private String packageCode;
// 产品包名称
@Column(name = "package_name")
private String packageName;
// 日期
@Column(name = "day", nullable = false)
private String day;
// 小时（0-23）
@Column(name = "hour", nullable = false)
private Integer hour;
// 订购按钮总点击量
@Column(name = "btn_click_pv", nullable = false)
private Long btnClickPv;
// 订购按钮总点击人数
@Column(name = "btn_click_uv", nullable = false)
private Long btnClickUv;
// 订购成功人数
@Column(name = "subscribe_num", nullable = false)
private Long subscribeNum;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(SubscribePvUvHour source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.module.subscribe.hour.repository;
import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
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 2022-04-20
*/
public interface SubscribePvUvHourRepository extends JpaRepository<SubscribePvUvHour, Long>, JpaSpecificationExecutor<SubscribePvUvHour> {
Optional<SubscribePvUvHour> findByMarketingActivityCodeAndPackageIdAndDayAndHour(String code, String packageId, String day, int hour);
}
package com.topdraw.business.module.subscribe.hour.service;
import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
import com.topdraw.business.module.subscribe.hour.service.dto.SubscribePvUvHourDTO;
import com.topdraw.business.module.subscribe.hour.service.dto.SubscribePvUvHourQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author XiangHan
* @date 2022-04-20
*/
public interface SubscribePvUvHourService {
/**
* 根据ID查询
* @param id ID
* @return SubscribePvUvHourDTO
*/
SubscribePvUvHourDTO findById(Long id);
void create(SubscribePvUvHour resources);
void update(SubscribePvUvHour resources);
void delete(Long id);
SubscribePvUvHour findByMarketingActivityCodeAndPackageIdAndDayAndHour(String code, String packageId, String toString, int hour);
void updateByMarketingActivityCodeAndDayAndHourAndPackageId(SubscribePvUvHour subscribePvUvHour);
}
package com.topdraw.business.module.subscribe.hour.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Data
public class SubscribePvUvHourDTO implements Serializable {
// ID
private Long id;
// 营销活动ID
private Long marketingActivityId;
// 营销活动标识
private String marketingActivityCode;
// 产品包id
private String packageId;
// 产品包标识
private String packageCode;
// 产品包名称
private String packageName;
// 日期
private String day;
// 小时（0-23）
private Integer hour;
// 订购按钮总点击量
private Long btnClickPv;
// 订购按钮总点击人数
private Long btnClickUv;
// 订购成功人数
private Long subscribeNum;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.module.subscribe.hour.service.dto;
import lombok.Data;
import com.topdraw.annotation.Query;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Data
public class SubscribePvUvHourQueryCriteria{
}
package com.topdraw.business.module.subscribe.hour.service.impl;
import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.utils.FileUtil;
import com.topdraw.business.module.subscribe.hour.repository.SubscribePvUvHourRepository;
import com.topdraw.business.module.subscribe.hour.service.SubscribePvUvHourService;
import com.topdraw.business.module.subscribe.hour.service.dto.SubscribePvUvHourDTO;
import com.topdraw.business.module.subscribe.hour.service.dto.SubscribePvUvHourQueryCriteria;
import com.topdraw.business.module.subscribe.hour.service.mapper.SubscribePvUvHourMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.LinkedHashMap;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class SubscribePvUvHourServiceImpl implements SubscribePvUvHourService {
@Autowired
private SubscribePvUvHourRepository SubscribePvUvHourRepository;
@Autowired
private SubscribePvUvHourMapper SubscribePvUvHourMapper;
@Override
public SubscribePvUvHourDTO findById(Long id) {
SubscribePvUvHour SubscribePvUvHour = SubscribePvUvHourRepository.findById(id).orElseGet(SubscribePvUvHour::new);
ValidationUtil.isNull(SubscribePvUvHour.getId(),"SubscribePvUvHour","id",id);
return SubscribePvUvHourMapper.toDto(SubscribePvUvHour);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(SubscribePvUvHour resources) {
SubscribePvUvHourRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(SubscribePvUvHour resources) {
SubscribePvUvHour SubscribePvUvHour = SubscribePvUvHourRepository.findById(resources.getId()).orElseGet(SubscribePvUvHour::new);
ValidationUtil.isNull( SubscribePvUvHour.getId(),"SubscribePvUvHour","id",resources.getId());
SubscribePvUvHour.copy(resources);
SubscribePvUvHourRepository.save(SubscribePvUvHour);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
SubscribePvUvHour SubscribePvUvHour = SubscribePvUvHourRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", SubscribePvUvHour.class, id), 1));
SubscribePvUvHourRepository.delete(SubscribePvUvHour);
}
@Override
public SubscribePvUvHour findByMarketingActivityCodeAndPackageIdAndDayAndHour(String code, String packageId, String day, int hour) {
SubscribePvUvHour SubscribePvUvHour =
SubscribePvUvHourRepository.findByMarketingActivityCodeAndPackageIdAndDayAndHour(code, packageId, day, hour).orElseGet(SubscribePvUvHour::new);
return SubscribePvUvHour;
}
@Override
public void updateByMarketingActivityCodeAndDayAndHourAndPackageId(SubscribePvUvHour subscribePvUvHour) {
}
}
package com.topdraw.business.module.subscribe.hour.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
import com.topdraw.business.module.subscribe.hour.service.dto.SubscribePvUvHourDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2022-04-20
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface SubscribePvUvHourMapper extends BaseMapper<SubscribePvUvHourDTO, SubscribePvUvHour> {
}
package com.topdraw.business.module.uv.all.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="act_pv_uv")
public class PvUv implements Serializable {
// ID
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 营销活动ID
@Column(name = "marketing_activity_id", nullable = false)
private Long marketingActivityId;
// 营销活动标识
@Column(name = "marketing_activity_code", nullable = false)
private String marketingActivityCode;
// pv值
@Column(name = "pv", nullable = false)
private Integer pv;
// uv值
@Column(name = "uv", nullable = false)
private Integer uv;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(PvUv source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.module.uv.all.repository;
import com.topdraw.business.module.uv.all.domain.PvUv;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;
import java.util.Optional;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface PvUvRepository extends JpaRepository<PvUv, Long>, JpaSpecificationExecutor<PvUv> {
@Modifying
@Transactional
@Query(value = "update act_pv_uv set pv = :#{#resources.pv} , uv = :#{#resources.uv} , " +
"update_time = :#{#resources.updateTime} where marketing_activity_code = :#{#resources.marketingActivityCode} " , nativeQuery = true)
void updateByMarketingActivityId(@Param("resources") PvUv resources);
Optional<PvUv> findByMarketingActivityCode(String marketingActivityCode);
Optional<PvUv> findByMarketingActivityId(Long mActivityId);
}
package com.topdraw.business.module.uv.all.service;
import com.topdraw.business.module.uv.all.domain.PvUv;
import com.topdraw.business.module.uv.all.service.dto.PvUvDTO;
import com.topdraw.business.module.uv.all.service.dto.PvUvQueryCriteria;
import org.springframework.data.domain.Pageable;
import org.springframework.transaction.annotation.Transactional;
import java.util.Map;
import java.util.List;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface PvUvService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(PvUvQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<PvUvDTO>
*/
List<PvUvDTO> queryAll(PvUvQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return PvUvDTO
*/
PvUvDTO findById(Long id);
void create(PvUv resources);
@Transactional(rollbackFor = Exception.class)
void updateByMarketingActivityId(PvUv resources);
void update(PvUv resources);
void delete(Long id);
PvUv findByMarketingActivityCode(String code);
PvUv findByMarketingActivityId(Long parseLong);
}
package com.topdraw.business.module.uv.all.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Data
public class PvUvDTO implements Serializable {
// ID
private Long id;
// 营销活动ID
private Long marketingActivityId;
// 营销活动标识
private String marketingActivityCode;
// pv值
private Long pv;
// uv值
private Long uv;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.module.uv.all.service.dto;
import lombok.Data;
import com.topdraw.annotation.Query;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Data
public class PvUvQueryCriteria{
}
package com.topdraw.business.module.uv.all.service.impl;
import com.topdraw.business.module.uv.all.domain.PvUv;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.utils.FileUtil;
import com.topdraw.business.module.uv.all.repository.PvUvRepository;
import com.topdraw.business.module.uv.all.service.PvUvService;
import com.topdraw.business.module.uv.all.service.dto.PvUvDTO;
import com.topdraw.business.module.uv.all.service.dto.PvUvQueryCriteria;
import com.topdraw.business.module.uv.all.service.mapper.PvUvMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.LinkedHashMap;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class PvUvServiceImpl implements PvUvService {
@Autowired
private PvUvRepository PvUvRepository;
@Autowired
private PvUvMapper PvUvMapper;
@Override
public Map<String, Object> queryAll(PvUvQueryCriteria criteria, Pageable pageable) {
Page<PvUv> page = PvUvRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(PvUvMapper::toDto));
}
@Override
public List<PvUvDTO> queryAll(PvUvQueryCriteria criteria) {
return PvUvMapper.toDto(PvUvRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public PvUvDTO findById(Long id) {
PvUv PvUv = PvUvRepository.findById(id).orElseGet(PvUv::new);
ValidationUtil.isNull(PvUv.getId(),"PvUv","id",id);
return PvUvMapper.toDto(PvUv);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(PvUv resources) {
PvUvRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateByMarketingActivityId(PvUv resources) {
PvUvRepository.updateByMarketingActivityId(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(PvUv resources) {
PvUv PvUv = PvUvRepository.findById(resources.getId()).orElseGet(PvUv::new);
ValidationUtil.isNull( PvUv.getId(),"PvUv","id",resources.getId());
PvUv.copy(resources);
PvUvRepository.save(PvUv);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
PvUv PvUv = PvUvRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", PvUv.class, id), 1));
PvUvRepository.delete(PvUv);
}
@Override
public PvUv findByMarketingActivityCode(String code) {
PvUv PvUv = PvUvRepository.findByMarketingActivityCode(code).orElseGet(PvUv::new);
return PvUv;
}
@Override
public PvUv findByMarketingActivityId(Long mActivityId) {
return PvUvRepository.findByMarketingActivityId(mActivityId).orElseGet(PvUv::new);
}
}
package com.topdraw.business.module.uv.all.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.module.uv.all.domain.PvUv;
import com.topdraw.business.module.uv.all.service.dto.PvUvDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface PvUvMapper extends BaseMapper<PvUvDTO, PvUv> {
}
package com.topdraw.business.module.uv.day.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="act_pv_uv_day")
public class PvUvDay implements Serializable {
// ID
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 营销活动ID
@Column(name = "marketing_activity_id", nullable = false)
private Long marketingActivityId;
// 营销活动标识
@Column(name = "marketing_activity_code", nullable = false)
private String marketingActivityCode;
// 日期
@Column(name = "day", nullable = false)
private String day;
// pv值
@Column(name = "pv", nullable = false)
private Integer pv;
// uv值
@Column(name = "uv", nullable = false)
private Integer uv;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(PvUvDay source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.module.uv.day.repository;
import com.topdraw.business.module.uv.day.domain.PvUvDay;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;
import java.util.Optional;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface PvUvDayRepository extends JpaRepository<PvUvDay, Long>, JpaSpecificationExecutor<PvUvDay> {
Optional<PvUvDay> findByMarketingActivityCodeAndDay(String marketingActivityCode, String day);
@Modifying
@Transactional
@Query(value = "update act_pv_uv_day set pv = :#{#resources.pv} , uv = :#{#resources.uv} , " +
" update_time = :#{#resources.updateTime} where marketing_activity_code = :#{#resources.marketingActivityCode} and " +
" `day` = :#{#resources.day}" , nativeQuery = true)
void updateByMarketingActivityCodeAndDay(@Param("resources") PvUvDay pvUvDay);
Optional<PvUvDay> findByMarketingActivityIdAndDay(Long mActivityId, String day);
}
package com.topdraw.business.module.uv.day.service;
import com.topdraw.business.module.uv.day.domain.PvUvDay;
import com.topdraw.business.module.uv.day.service.dto.PvUvDayDTO;
import com.topdraw.business.module.uv.day.service.dto.PvUvDayQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface PvUvDayService {
/**
* 查询数据分页
* @param criteria 条件参数
* @param pageable 分页参数
* @return Map<String,Object>
*/
Map<String,Object> queryAll(PvUvDayQueryCriteria criteria, Pageable pageable);
/**
* 查询所有数据不分页
* @param criteria 条件参数
* @return List<PvUvDayDTO>
*/
List<PvUvDayDTO> queryAll(PvUvDayQueryCriteria criteria);
/**
* 根据ID查询
* @param id ID
* @return PvUvDayDTO
*/
PvUvDayDTO findById(Long id);
void create(PvUvDay resources);
void update(PvUvDay resources);
void delete(Long id);
PvUvDay findByMarketingActivityCodeAndDay(String code, String day);
void updateByMarketingActivityCodeAndDay(PvUvDay pvUvDay);
PvUvDay findByMarketingActivityIdAndDay(Long mActivityId, String day);
}
package com.topdraw.business.module.uv.day.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Data
public class PvUvDayDTO implements Serializable {
// ID
private Long id;
// 营销活动ID
private Long marketingActivityId;
// 营销活动标识
private String marketingActivityCode;
// 日期
private String day;
// pv值
private Integer pv;
// uv值
private Integer uv;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.module.uv.day.service.dto;
import lombok.Data;
import com.topdraw.annotation.Query;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Data
public class PvUvDayQueryCriteria{
}
package com.topdraw.business.module.uv.day.service.impl;
import com.topdraw.business.module.uv.day.domain.PvUvDay;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.utils.FileUtil;
import com.topdraw.business.module.uv.day.repository.PvUvDayRepository;
import com.topdraw.business.module.uv.day.service.PvUvDayService;
import com.topdraw.business.module.uv.day.service.dto.PvUvDayDTO;
import com.topdraw.business.module.uv.day.service.dto.PvUvDayQueryCriteria;
import com.topdraw.business.module.uv.day.service.mapper.PvUvDayMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.LinkedHashMap;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class PvUvDayServiceImpl implements PvUvDayService {
@Autowired
private PvUvDayRepository PvUvDayRepository;
@Autowired
private PvUvDayMapper PvUvDayMapper;
@Override
public Map<String, Object> queryAll(PvUvDayQueryCriteria criteria, Pageable pageable) {
Page<PvUvDay> page = PvUvDayRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
return PageUtil.toPage(page.map(PvUvDayMapper::toDto));
}
@Override
public List<PvUvDayDTO> queryAll(PvUvDayQueryCriteria criteria) {
return PvUvDayMapper.toDto(PvUvDayRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
}
@Override
public PvUvDayDTO findById(Long id) {
PvUvDay PvUvDay = PvUvDayRepository.findById(id).orElseGet(PvUvDay::new);
ValidationUtil.isNull(PvUvDay.getId(),"PvUvDay","id",id);
return PvUvDayMapper.toDto(PvUvDay);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(PvUvDay resources) {
PvUvDayRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(PvUvDay resources) {
PvUvDay PvUvDay = PvUvDayRepository.findById(resources.getId()).orElseGet(PvUvDay::new);
ValidationUtil.isNull( PvUvDay.getId(),"PvUvDay","id",resources.getId());
PvUvDay.copy(resources);
PvUvDayRepository.save(PvUvDay);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
PvUvDay PvUvDay = PvUvDayRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", PvUvDay.class, id), 1));
PvUvDayRepository.delete(PvUvDay);
}
@Override
public PvUvDay findByMarketingActivityCodeAndDay(String code, String day) {
PvUvDay PvUvDay = PvUvDayRepository.findByMarketingActivityCodeAndDay(code,day).orElseGet(PvUvDay::new);
return PvUvDay;
}
@Override
public void updateByMarketingActivityCodeAndDay(PvUvDay pvUvDay) {
PvUvDayRepository.updateByMarketingActivityCodeAndDay(pvUvDay);
}
@Override
public PvUvDay findByMarketingActivityIdAndDay(Long mActivityId, String day) {
return PvUvDayRepository.findByMarketingActivityIdAndDay(mActivityId, day).orElseGet(PvUvDay::new);
}
}
package com.topdraw.business.module.uv.day.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.module.uv.day.domain.PvUvDay;
import com.topdraw.business.module.uv.day.service.dto.PvUvDayDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface PvUvDayMapper extends BaseMapper<PvUvDayDTO, PvUvDay> {
}
package com.topdraw.business.module.uv.hour.domain;
import lombok.Data;
import lombok.experimental.Accessors;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import javax.persistence.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Entity
@Data
@EntityListeners(AuditingEntityListener.class)
@Accessors(chain = true)
@Table(name="act_pv_uv_hour")
public class PvUvHour implements Serializable {
// ID
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
// 营销活动ID
@Column(name = "marketing_activity_id", nullable = false)
private Long marketingActivityId;
// 营销活动标识
@Column(name = "marketing_activity_code", nullable = false)
private String marketingActivityCode;
// 日期
@Column(name = "day", nullable = false)
private String day;
// 小时（0-23）
@Column(name = "hour", nullable = false)
private Integer hour;
// pv值
@Column(name = "pv", nullable = false)
private Integer pv;
// uv值
@Column(name = "uv", nullable = false)
private Integer uv;
// 创建时间
@CreatedDate
@Column(name = "create_time")
private Timestamp createTime;
// 更新时间
@LastModifiedDate
@Column(name = "update_time")
private Timestamp updateTime;
public void copy(PvUvHour source){
BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
}
}
package com.topdraw.business.module.uv.hour.repository;
import com.topdraw.business.module.uv.hour.domain.PvUvHour;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.transaction.annotation.Transactional;
import java.util.Optional;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface PvUvHourRepository extends JpaRepository<PvUvHour, Long>, JpaSpecificationExecutor<PvUvHour> {
Optional<PvUvHour> findByMarketingActivityCodeAndDayAndHour(String code, String day, int hour);
Optional<PvUvHour> findByMarketingActivityIdAndDayAndHour(Long id, String day, int hour);
@Modifying
@Transactional
@Query(value = "update act_pv_uv_hour set pv = :#{#resources.pv} , uv = :#{#resources.uv} , " +
"update_time = :#{#resources.updateTime} where marketing_activity_code = :#{#resources.marketingActivityCode} and " +
" `day` = :#{#resources.day} and `hour` = :#{#resources.hour}" , nativeQuery = true)
void updateByMarketingActivityCodeAndDayAndHour(@Param("resources") PvUvHour pvUvHour);
@Query(value = "select SUM(pv) pv ,SUM(uv) pv from (\n" +
"select pv,uv from act_pv_uv_hour where `marketing_activity_code` = ?1 and `day` = ?2 and `hour` = ?3) t " , nativeQuery = true)
Integer calculatePvDay(@Param("code") String code, @Param("day") String day, @Param("hour") int hour);
}
package com.topdraw.business.module.uv.hour.service;
import com.topdraw.business.module.uv.hour.domain.PvUvHour;
import com.topdraw.business.module.uv.hour.service.dto.PvUvHourDTO;
import com.topdraw.business.module.uv.hour.service.dto.PvUvHourQueryCriteria;
import org.springframework.data.domain.Pageable;
import java.util.Map;
import java.util.List;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
/**
* @author XiangHan
* @date 2022-02-26
*/
public interface PvUvHourService {
/**
* 根据ID查询
* @param id ID
* @return PvUvHourDTO
*/
PvUvHourDTO findById(Long id);
void create(PvUvHour resources);
void update(PvUvHour resources);
void delete(Long id);
PvUvHour findByMarketingActivityCodeAndDayAndHour(String code, String toString, int hour);
void updateByMarketingActivityCodeAndDayAndHour(PvUvHour pvUvHour);
Integer calculatePvDay(String code, String toString, int hour);
PvUvHour findByMarketingActivityIdAndDayAndHour(Long parseLong, String toString, int hour);
}
package com.topdraw.business.module.uv.hour.service.dto;
import lombok.Data;
import java.sql.Timestamp;
import java.io.Serializable;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Data
public class PvUvHourDTO implements Serializable {
// ID
private Long id;
// 营销活动ID
private Long marketingActivityId;
// 营销活动标识
private String marketingActivityCode;
// 日期
private String day;
// 小时（0-23）
private Integer hour;
// pv值
private Integer pv;
// uv值
private Integer uv;
// 创建时间
private Timestamp createTime;
// 更新时间
private Timestamp updateTime;
}
package com.topdraw.business.module.uv.hour.service.dto;
import lombok.Data;
import com.topdraw.annotation.Query;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Data
public class PvUvHourQueryCriteria{
}
package com.topdraw.business.module.uv.hour.service.impl;
import com.topdraw.business.module.uv.hour.domain.PvUvHour;
import com.topdraw.utils.ValidationUtil;
import com.topdraw.utils.FileUtil;
import com.topdraw.business.module.uv.hour.repository.PvUvHourRepository;
import com.topdraw.business.module.uv.hour.service.PvUvHourService;
import com.topdraw.business.module.uv.hour.service.dto.PvUvHourDTO;
import com.topdraw.business.module.uv.hour.service.dto.PvUvHourQueryCriteria;
import com.topdraw.business.module.uv.hour.service.mapper.PvUvHourMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.util.Assert;
import com.topdraw.utils.PageUtil;
import com.topdraw.utils.QueryHelp;
import com.topdraw.utils.StringUtils;
import java.util.List;
import java.util.Map;
import java.io.IOException;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.LinkedHashMap;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Service
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
public class PvUvHourServiceImpl implements PvUvHourService {
@Autowired
private PvUvHourRepository PvUvHourRepository;
@Autowired
private PvUvHourMapper PvUvHourMapper;
@Override
public PvUvHourDTO findById(Long id) {
PvUvHour PvUvHour = PvUvHourRepository.findById(id).orElseGet(PvUvHour::new);
ValidationUtil.isNull(PvUvHour.getId(),"PvUvHour","id",id);
return PvUvHourMapper.toDto(PvUvHour);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void create(PvUvHour resources) {
PvUvHourRepository.save(resources);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void update(PvUvHour resources) {
PvUvHour PvUvHour = PvUvHourRepository.findById(resources.getId()).orElseGet(PvUvHour::new);
ValidationUtil.isNull( PvUvHour.getId(),"PvUvHour","id",resources.getId());
PvUvHour.copy(resources);
PvUvHourRepository.save(PvUvHour);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delete(Long id) {
Assert.notNull(id, "The given id must not be null!");
PvUvHour PvUvHour = PvUvHourRepository.findById(id).orElseThrow(
() -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", PvUvHour.class, id), 1));
PvUvHourRepository.delete(PvUvHour);
}
@Override
public PvUvHour findByMarketingActivityCodeAndDayAndHour(String code, String day, int hour) {
PvUvHour PvUvHour = PvUvHourRepository.findByMarketingActivityCodeAndDayAndHour(code,day,hour).orElseGet(PvUvHour::new);
return PvUvHour;
}
@Override
public void updateByMarketingActivityCodeAndDayAndHour(PvUvHour pvUvHour) {
PvUvHourRepository.updateByMarketingActivityCodeAndDayAndHour(pvUvHour);
}
@Override
public Integer calculatePvDay(String code, String day, int hour) {
Integer count = PvUvHourRepository.calculatePvDay(code,day,hour);
return count;
}
@Override
public PvUvHour findByMarketingActivityIdAndDayAndHour(Long mActivityId, String day, int hour) {
return PvUvHourRepository.findByMarketingActivityIdAndDayAndHour(mActivityId, day, hour).orElseGet(PvUvHour::new);
}
}
package com.topdraw.business.module.uv.hour.service.mapper;
import com.topdraw.base.BaseMapper;
import com.topdraw.business.module.uv.hour.domain.PvUvHour;
import com.topdraw.business.module.uv.hour.service.dto.PvUvHourDTO;
import org.mapstruct.Mapper;
import org.mapstruct.ReportingPolicy;
/**
* @author XiangHan
* @date 2022-02-26
*/
@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface PvUvHourMapper extends BaseMapper<PvUvHourDTO, PvUvHour> {
}
package com.topdraw.redis.config;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.data.redis.connection.*;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.util.StringUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;
import javax.annotation.Resource;
import java.util.HashSet;
import java.util.Set;
/**
* @author ：
* @description：
* @function :
* @date ：Created in 2022/2/27 10:39
* @version: ：
* @modified By：
* @since : modified in 2022/2/27 10:39
*/
@Configuration
@Slf4j
public class MyJedisConfig {
/***生产环境要打开此配置*/
@Value("${spring.redis.sentinel.master}")
private String master;
@Value("${spring.redis.sentinel.nodes}")
private String sentinelHost;
@Bean
public Jedis jedisPool(JedisPoolConfig jedisPoolConfig) {
String[] split = sentinelHost.split(",");
Set<String> sentinels = new HashSet<>();
for (int i = 0; i < split.length; i++) {
String s = split[i];
sentinels.add(s);
}
JedisSentinelPool jedisPool = new JedisSentinelPool(master, sentinels, jedisPoolConfig);
Jedis jedis = jedisPool.getResource();
return jedis;
}
@Bean
public JedisPoolConfig jedisPoolConfig() {
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxTotal(15);
jedisPoolConfig.setMaxIdle(10);
jedisPoolConfig.setMinIdle(5);
jedisPoolConfig.setMaxWaitMillis(10000);
jedisPoolConfig.setTestOnBorrow(true);
return jedisPoolConfig;
}
/*@Bean
public Jedis jedisPool(@Value("${spring.redis.host}") String host,
@Value("${spring.redis.port}") int port,
@Value("${spring.redis.timeout}") int timeout,
// @Value("${spring.redis.password}") String password,
JedisPoolConfig jedisPoolConfig) {
// JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout,"redis123");
JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout);
return jedisPool.getResource();
}*/
}
package com.topdraw.schedule;
import com.topdraw.business.process.calculate.task.ActivityBtnClickPvUcCalculateTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* @author ：
* @description：
* @function :
* @date ：Created in 2022/2/26 19:44
* @version: ：
* @modified By：
* @since : modified in 2022/2/26 19:44
*/
@Component
@Slf4j
@EnableScheduling
public class TransferActivityBtnClickPvUvScheduleTask {
@Autowired
private ActivityBtnClickPvUcCalculateTask activityBtnClickPvUcCalculateTask;
@Value("${cronActivityBtn:50 0/5 * * * ?}")
private String cron;
public String cron(){
return cron;
}
/**
* 统计订购转换数据
*/
@Scheduled(cron = "#{transferActivityBtnClickPvUvScheduleTask.cron()}")
public void calculateSubscribe2Mysql(){
log.info("活动按钮点击次数统计 ===>>> 开始 !!!" + LocalDateTime.now());
this.activityBtnClickPvUcCalculateTask.calculateRedisData2Mysql();
}
}
package com.topdraw.schedule;
import com.topdraw.business.process.calculate.task.PvUvCalculateTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* @author ：
* @description：
* @function :
* @date ：Created in 2022/2/26 19:44
* @version: ：
* @modified By：
* @since : modified in 2022/2/26 19:44
*/
@Component
@Slf4j
@EnableScheduling
public class TransferScheduleTask {
@Autowired
private PvUvCalculateTask pvUvCalculateTask;
@Value("${cron:50 0/5 * * * ?}")
private String cron;
public String cron(){
return cron;
}
/**
* 统计pv、uv
*/
@Scheduled(cron = "#{transferScheduleTask.cron()}")
public void calculatePvUv2Mysql(){
log.info("pv、uv统计 ===>>> 开始 !!!" + LocalDateTime.now());
this.pvUvCalculateTask.calculateRedisData2Mysql();
}
}
package com.topdraw.schedule;
import com.topdraw.business.process.calculate.task.SubscribeCalculateTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
/**
* @author ：
* @description：
* @function :
* @date ：Created in 2022/2/26 19:44
* @version: ：
* @modified By：
* @since : modified in 2022/2/26 19:44
*/
@Component
@Slf4j
@EnableScheduling
public class TransferSubscribeScheduleTask {
@Autowired
private SubscribeCalculateTask subscribeCalculateTask;
@Value("${cronSubscribe:50 0/5 * * * ?}")
// @Value("0/5 * * * * ?")
private String cron;
public String cron(){
return cron;
}
/**
* 统计订购转换数据
*/
@Scheduled(cron = "#{transferSubscribeScheduleTask.cron()}")
// @Scheduled(cron = "0/5 * * * * ?")
public void calculateSubscribe2Mysql(){
log.info("订购数据统计 ===>>> 开始 !!!" + LocalDateTime.now());
this.subscribeCalculateTask.calculateSubscribe2Mysql();
}
}
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")).toEpochMilli();
return new Timestamp(epochSecond);
}
public static long localDateTime2long(LocalDateTime localDateTime){
return localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
}
public static Timestamp localDateTime2Timestamp(LocalDateTime localDateTime){
long epochSecond = localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
return long2Timestamp(epochSecond);
}
public static Timestamp long2Timestamp(long timestamp){
return Timestamp.from(Instant.ofEpochMilli(timestamp));
}
public static long timestamp2long(Timestamp timestamp){
return timestamp.toInstant().toEpochMilli();
}
public static LocalDateTime long2LocalDateTime(Long expireTime) {
return LocalDateTime.ofInstant(Instant.ofEpochMilli(expireTime),ZoneOffset.of("+8"));
}
}
___________ .___
\__ ___/___ ______ __| _/___________ __ _ __
| | / _ \\____ \ / __ |\_ __ \__ \\ \/ \/ /
| |( <_> ) |_> > /_/ | | | \// __ \\ /
|____| \____/| __/\____ | |__| (____ /\/\_/
|__| \/ \/
:: UserCenter :: Spring Boot - ${spring-boot.version}
spring:
# 数据源
datasource:
# 数据源地址
url: jdbc:log4jdbc:mysql://139.196.145.150:3306/moss_test?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
# 用户名
username: root
# 密码
password: Tjlh@2021
# 驱动程序
driverClassName: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
# 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:
properties:
hibernate:
# 数据库类型
dialect: org.hibernate.dialect.MySQL5InnoDBDialect
hibernate:
# 生产环境设置成 none，避免程序运行时自动更新数据库结构
ddl-auto: none
open-in-view: true
show-sql: false
# redis
redis:
#数据库索引
database: 0
host: 122.112.214.149
# host: 139.196.192.242
port: 6379
#连接超时时间
timeout: 5000
password: redis123
#缓存过期时间
expire-minutes: 5
# sentinel:
# master: mymaster
# nodes: 122.112.214.149:6379,122.112.214.149:6379
# 服务器
server:
# 服务端口号
port: 8558
spring:
# 服务
application:
# 服务名
name: moss-statistic
# 配置文件
profiles:
# 启动具体的配置文件
active: dev
cron: "0/10 * * * * ?"
cronSubscribe: "* 0/60 * * * ?"
cronActivityBtn: "0/60 * * * * ?"
#数据库类型转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="OFF" 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>