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
1 /.idea/
2 /logs/
3 /target/
4 *.iml
1 <?xml version="1.0" encoding="UTF-8"?>
2 <project xmlns="http://maven.apache.org/POM/4.0.0"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5 <modelVersion>4.0.0</modelVersion>
6
7 <groupId>com.topdraw</groupId>
8 <artifactId>redis-transfer-project</artifactId>
9 <version>0.0.1-SNAPSHOT</version>
10
11 <properties>
12 <maven.compiler.source>8</maven.compiler.source>
13 <maven.compiler.target>8</maven.compiler.target>
14 <jjwt.version>0.9.1</jjwt.version>
15 </properties>
16
17 <parent>
18 <groupId>org.springframework.boot</groupId>
19 <artifactId>spring-boot-starter-parent</artifactId>
20 <version>2.2.10.RELEASE</version>
21 <relativePath/>
22 </parent>
23
24 <dependencies>
25
26 <!--redisson-->
27 <dependency>
28 <groupId>redis.clients</groupId>
29 <artifactId>jedis</artifactId>
30 <version>3.1.0</version>
31 </dependency>
32
33 <!--代码生成器-->
34 <dependency>
35 <groupId>com.topdraw</groupId>
36 <artifactId>cronos-system</artifactId>
37 <version>1.1.0</version>
38 </dependency>
39
40 <!--Mysql依赖包，版本差异，需单独引入-->
41 <dependency>
42 <groupId>mysql</groupId>
43 <artifactId>mysql-connector-java</artifactId>
44 <version>8.0.26</version>
45 </dependency>
46
47 <dependency>
48 <groupId>commons-codec</groupId>
49 <artifactId>commons-codec</artifactId>
50 <version>1.9</version>
51 </dependency>
52
53 </dependencies>
54
55
56 <profiles>
57 <profile>
58 <!-- 本地开发环境 -->
59 <id>dev</id>
60 <properties>
61 <profiles.active>dev</profiles.active>
62 </properties>
63 <activation>
64 <!-- 默认的，不加参数时执行这个profile -->
65 <activeByDefault>true</activeByDefault>
66 </activation>
67 </profile>
68 <profile>
69 <!-- 生产环境 -->
70 <id>prod</id>
71 <properties>
72 <profiles.active>prod</profiles.active>
73 <modifier>-prod</modifier>
74 </properties>
75 </profile>
76 </profiles>
77
78 <build>
79 <finalName>redis-transfer-project</finalName>
80 <plugins>
81 <plugin>
82 <groupId>org.springframework.boot</groupId>
83 <artifactId>spring-boot-maven-plugin</artifactId>
84 <configuration>
85 <fork>true</fork>
86 </configuration>
87 </plugin>
88 <!-- 跳过单元测试 -->
89 <plugin>
90 <groupId>org.apache.maven.plugins</groupId>
91 <artifactId>maven-surefire-plugin</artifactId>
92 <configuration>
93 <skipTests>true</skipTests>
94 </configuration>
95 </plugin>
96 <!-- 复制指定配置文件到指定目录 -->
97 <plugin>
98 <artifactId>maven-resources-plugin</artifactId>
99 <executions>
100 <execution>
101 <id>copy-resources</id>
102 <phase>package</phase>
103 <goals>
104 <goal>copy-resources</goal>
105 </goals>
106 <configuration>
107 <resources>
108 <resource>
109 <directory>src/main/resources/config</directory>
110 <includes>
111 <include>application.yml</include>
112 <include>application-${profiles.active}.yml</include>
113 </includes>
114 </resource>
115 </resources>
116 <outputDirectory>${project.build.directory}/config</outputDirectory>
117 </configuration>
118 </execution>
119 </executions>
120 </plugin>
121 <!-- jar包内剔除所有配置文件 -->
122 <plugin>
123 <artifactId>maven-jar-plugin</artifactId>
124 <configuration>
125 <!--不打入jar包的文件类型或者路径-->
126 <excludes>
127 <exclude>config/**</exclude>
128 </excludes>
129 </configuration>
130 </plugin>
131 </plugins>
132 </build>
133
134 </project>
...\ No newline at end of file ...\ No newline at end of file
1 package com.topdraw;
2
3 import com.topdraw.base.BaseRepositoryFactory;
4 import com.topdraw.utils.SpringContextHolder;
5 import org.springframework.beans.factory.annotation.Autowired;
6 import org.springframework.boot.SpringApplication;
7 import org.springframework.boot.autoconfigure.SpringBootApplication;
8 import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
9 import org.springframework.boot.builder.SpringApplicationBuilder;
10 import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
11 import org.springframework.context.annotation.Bean;
12 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
13 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
14 import org.springframework.scheduling.annotation.EnableAsync;
15 import org.springframework.transaction.annotation.EnableTransactionManagement;
16
17 /**
18 * @author ：
19 * @description：
20 * @function :
21 * @date ：Created in 2022/2/10 16:17
22 * @version: ：
23 * @modified By：
24 * @since : modified in 2022/2/10 16:17
25 */
26 @EnableJpaAuditing
27 @EnableAsync
28 @SpringBootApplication(exclude = {SecurityAutoConfiguration.class})
29 @EnableTransactionManagement
30 @EnableJpaRepositories(repositoryFactoryBeanClass = BaseRepositoryFactory.class)
31 public class RedisTransferApplication extends SpringBootServletInitializer {
32
33 @Override
34 protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
35 return builder.sources(RedisTransferApplication.class);
36 }
37
38 public static void main(String[] args) {
39 SpringApplication.run(RedisTransferApplication.class, args);
40 }
41
42 @Bean
43 public SpringContextHolder springContextHolder() {
44 return new SpringContextHolder();
45 }
46
47
48 }
1 package com.topdraw.business.module.activitybtn.all.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2022-02-26
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="act_tpl_param_click")
24 public class ActTplParamClick implements Serializable {
25
26 // ID
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 营销活动ID
33 @Column(name = "marketing_activity_id", nullable = false)
34 private Long marketingActivityId;
35
36 // 活动事件id
37 @Column(name = "activity_id", nullable = false)
38 private Long activityId;
39
40 // 活动按钮id
41 @Column(name = "template_param_value_id", nullable = false)
42 private Long templateParamValueId;
43
44 // 显示用名称，表示哪个按钮或者内容
45 @Column(name = "name", nullable = false)
46 private String name;
47
48 // pv值
49 @Column(name = "pv", nullable = false)
50 private Integer pv;
51
52 // uv值
53 @Column(name = "uv", nullable = false)
54 private Integer uv;
55
56 // 创建时间
57 @CreatedDate
58 @Column(name = "create_time")
59 private Timestamp createTime;
60
61 // 更新时间
62 @LastModifiedDate
63 @Column(name = "update_time")
64 private Timestamp updateTime;
65
66 public void copy(ActTplParamClick source){
67 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
68 }
69 }
1 package com.topdraw.business.module.activitybtn.all.repository;
2
3 import com.topdraw.business.module.activitybtn.all.domain.ActTplParamClick;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.Optional;
8
9 /**
10 * @author XiangHan
11 * @date 2022-02-26
12 */
13 public interface ActivityBtnPvUvRepository extends JpaRepository<ActTplParamClick, Long>, JpaSpecificationExecutor<ActTplParamClick> {
14
15 Optional<ActTplParamClick> findByMarketingActivityIdAndActivityIdAndTemplateParamValueId(Long marketingActivityId, Long activityId, Long templateParamValueId);
16 }
1 package com.topdraw.business.module.activitybtn.all.service;
2
3 import com.topdraw.business.module.activitybtn.all.domain.ActTplParamClick;
4
5 /**
6 * @author XiangHan
7 * @date 2022-02-26
8 */
9 public interface ActivityBtnPvUvService {
10
11 void create(ActTplParamClick resources);
12
13 void update(ActTplParamClick resources);
14
15 ActTplParamClick findByMarketingActivityIdAndActivityIdAndTemplateParamValueId(Long marketingActivityId, Long activityId, Long templateParamValueId);
16 }
1 package com.topdraw.business.module.activitybtn.all.service.dto;
2
3 import lombok.Data;
4
5 import javax.persistence.Column;
6 import java.io.Serializable;
7 import java.sql.Timestamp;
8
9
10 /**
11 * @author XiangHan
12 * @date 2022-02-26
13 */
14 @Data
15 public class ActTplParamClickDTO implements Serializable {
16
17 // ID
18 private Long id;
19
20 // 营销活动ID
21 private Long marketingActivityId;
22
23 // 活动事件id
24 private Long activityId;
25
26 // 活动按钮id
27 private Long templateParamValueId;
28
29 // 显示用名称，表示哪个按钮或者内容
30 private String name;
31
32 // pv值
33 private Long pv;
34
35 // uv值
36 private Long uv;
37
38 // 创建时间
39 private Timestamp createTime;
40
41 // 更新时间
42 private Timestamp updateTime;
43 }
1 package com.topdraw.business.module.activitybtn.all.service.impl;
2
3 import com.topdraw.business.module.activitybtn.all.domain.ActTplParamClick;
4 import com.topdraw.business.module.activitybtn.all.repository.ActivityBtnPvUvRepository;
5 import com.topdraw.business.module.activitybtn.all.service.ActivityBtnPvUvService;
6 import com.topdraw.utils.ValidationUtil;
7 import org.springframework.beans.factory.annotation.Autowired;
8 import org.springframework.stereotype.Service;
9 import org.springframework.transaction.annotation.Propagation;
10 import org.springframework.transaction.annotation.Transactional;
11
12 /**
13 * @author XiangHan
14 * @date 2022-02-26
15 */
16 @Service
17 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
18 public class ActivityBtnPvUvServiceImpl implements ActivityBtnPvUvService {
19
20 @Autowired
21 private ActivityBtnPvUvRepository PvUvRepository;
22
23 @Override
24 @Transactional(rollbackFor = Exception.class)
25 public void create(ActTplParamClick resources) {
26 PvUvRepository.save(resources);
27 }
28
29 @Override
30 @Transactional(rollbackFor = Exception.class)
31 public void update(ActTplParamClick resources) {
32 ActTplParamClick PvUv = PvUvRepository.findById(resources.getId()).orElseGet(ActTplParamClick::new);
33 ValidationUtil.isNull( PvUv.getId(),"PvUv","id",resources.getId());
34 PvUv.copy(resources);
35 PvUvRepository.save(PvUv);
36 }
37
38 @Override
39 public ActTplParamClick findByMarketingActivityIdAndActivityIdAndTemplateParamValueId(Long marketingActivityId, Long activityId, Long templateParamValueId) {
40 return PvUvRepository.findByMarketingActivityIdAndActivityIdAndTemplateParamValueId(marketingActivityId, activityId, templateParamValueId).orElseGet(ActTplParamClick::new);
41 }
42
43 }
1 package com.topdraw.business.module.activitybtn.day.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2022-02-26
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="act_tpl_param_click_day")
24 public class ActTplParamClickDay implements Serializable {
25
26 // ID
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 营销活动ID
33 @Column(name = "marketing_activity_id", nullable = false)
34 private Long marketingActivityId;
35
36 // 活动事件id
37 @Column(name = "activity_id", nullable = false)
38 private Long activityId;
39
40 // 显示用名称，表示哪个按钮或者内容
41 @Column(name = "name", nullable = false)
42 private String name;
43
44 // 活动按钮id
45 @Column(name = "template_param_value_id", nullable = false)
46 private Long templateParamValueId;
47
48 // 日期
49 @Column(name = "day", nullable = false)
50 private String day;
51
52 // pv值
53 @Column(name = "pv", nullable = false)
54 private Integer pv;
55
56 // uv值
57 @Column(name = "uv", nullable = false)
58 private Integer uv;
59
60 // 创建时间
61 @CreatedDate
62 @Column(name = "create_time")
63 private Timestamp createTime;
64
65 // 更新时间
66 @LastModifiedDate
67 @Column(name = "update_time")
68 private Timestamp updateTime;
69
70 public void copy(ActTplParamClickDay source){
71 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
72 }
73 }
1 package com.topdraw.business.module.activitybtn.day.repository;
2
3 import com.topdraw.business.module.activitybtn.day.domain.ActTplParamClickDay;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.Optional;
8
9 /**
10 * @author XiangHan
11 * @date 2022-02-26
12 */
13 public interface ActivityBtnPvUvDayRepository extends JpaRepository<ActTplParamClickDay, Long>, JpaSpecificationExecutor<ActTplParamClickDay> {
14
15 Optional<ActTplParamClickDay> findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDay(Long marketingActivityId, Long activityId, Long paramValueId, String day);
16
17 }
1 package com.topdraw.business.module.activitybtn.day.service;
2
3 import com.topdraw.business.module.activitybtn.day.domain.ActTplParamClickDay;
4
5 /**
6 * @author XiangHan
7 * @date 2022-02-26
8 */
9 public interface ActivityBtnPvUvDayService {
10
11 void create(ActTplParamClickDay resources);
12
13 void update(ActTplParamClickDay resources);
14
15 ActTplParamClickDay findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDay(Long marketingActivityId, Long activityId, Long templateParamValueId, String toString);
16 }
1 package com.topdraw.business.module.activitybtn.day.service.dto;
2
3 import lombok.Data;
4
5 import java.io.Serializable;
6 import java.sql.Timestamp;
7
8
9 /**
10 * @author XiangHan
11 * @date 2022-02-26
12 */
13 @Data
14 public class ActTplParamClickDTO implements Serializable {
15
16 // ID
17 private Long id;
18
19 // 营销活动ID
20 private Long marketingActivityId;
21
22 // 活动事件id
23 private Long activityId;
24
25 // 活动按钮id
26 private Long templateParamValueId;
27
28 // 显示用名称，表示哪个按钮或者内容
29 private String name;
30
31 // 日期
32 private String day;
33
34 // pv值
35 private Integer pv;
36
37 // uv值
38 private Integer uv;
39
40 // 创建时间
41 private Timestamp createTime;
42
43 // 更新时间
44 private Timestamp updateTime;
45 }
1 package com.topdraw.business.module.activitybtn.day.service.impl;
2
3 import com.topdraw.business.module.activitybtn.day.domain.ActTplParamClickDay;
4 import com.topdraw.business.module.activitybtn.day.repository.ActivityBtnPvUvDayRepository;
5 import com.topdraw.business.module.activitybtn.day.service.ActivityBtnPvUvDayService;
6 import com.topdraw.utils.ValidationUtil;
7 import org.springframework.beans.factory.annotation.Autowired;
8 import org.springframework.stereotype.Service;
9 import org.springframework.transaction.annotation.Propagation;
10 import org.springframework.transaction.annotation.Transactional;
11
12 /**
13 * @author XiangHan
14 * @date 2022-02-26
15 */
16 @Service
17 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
18 public class ActivityBtnPvUvDayServiceImpl implements ActivityBtnPvUvDayService {
19
20 @Autowired
21 private ActivityBtnPvUvDayRepository pvUvDayRepository;
22
23 @Override
24 @Transactional(rollbackFor = Exception.class)
25 public void create(ActTplParamClickDay resources) {
26 pvUvDayRepository.save(resources);
27 }
28
29 @Override
30 @Transactional(rollbackFor = Exception.class)
31 public void update(ActTplParamClickDay resources) {
32 ActTplParamClickDay PvUvDay = pvUvDayRepository.findById(resources.getId()).orElseGet(ActTplParamClickDay::new);
33 ValidationUtil.isNull( PvUvDay.getId(),"PvUvDay","id",resources.getId());
34 PvUvDay.copy(resources);
35 pvUvDayRepository.save(PvUvDay);
36 }
37
38 @Override
39 public ActTplParamClickDay findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDay(Long marketingActivityId, Long activityId, Long templateParamValueId, String day) {
40 return this.pvUvDayRepository.findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDay(marketingActivityId,
41 activityId, templateParamValueId, day).orElseGet(ActTplParamClickDay::new);
42 }
43
44
45 }
1 package com.topdraw.business.module.activitybtn.hour.domain;
2
3 import cn.hutool.core.bean.BeanUtil;
4 import cn.hutool.core.bean.copier.CopyOptions;
5 import lombok.Data;
6 import lombok.experimental.Accessors;
7 import org.springframework.data.annotation.CreatedDate;
8 import org.springframework.data.annotation.LastModifiedDate;
9 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
10
11 import javax.persistence.*;
12 import java.io.Serializable;
13 import java.sql.Timestamp;
14
15 /**
16 * @author XiangHan
17 * @date 2022-02-26
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="act_tpl_param_click_hour")
24 public class ActTplParamClickHour implements Serializable {
25
26 // ID
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 营销活动ID
33 @Column(name = "marketing_activity_id", nullable = false)
34 private Long marketingActivityId;
35
36 // 活动事件id
37 @Column(name = "activity_id", nullable = false)
38 private Long activityId;
39
40 // 显示用名称，表示哪个按钮或者内容
41 @Column(name = "name", nullable = false)
42 private String name;
43
44 // 活动按钮id
45 @Column(name = "template_param_value_id", nullable = false)
46 private Long templateParamValueId;
47
48 // 日期
49 @Column(name = "day", nullable = false)
50 private String day;
51
52 // 小时（0-23）
53 @Column(name = "hour", nullable = false)
54 private Integer hour;
55
56 // pv值
57 @Column(name = "pv", nullable = false)
58 private Integer pv;
59
60 // uv值
61 @Column(name = "uv", nullable = false)
62 private Integer uv;
63
64 // 创建时间
65 @CreatedDate
66 @Column(name = "create_time")
67 private Timestamp createTime;
68
69 // 更新时间
70 @LastModifiedDate
71 @Column(name = "update_time")
72 private Timestamp updateTime;
73
74 public void copy(ActTplParamClickHour source){
75 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
76 }
77 }
1 package com.topdraw.business.module.activitybtn.hour.repository;
2
3 import com.topdraw.business.module.activitybtn.hour.domain.ActTplParamClickHour;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.Optional;
8
9 /**
10 * @author XiangHan
11 * @date 2022-02-26
12 */
13 public interface ActivityBtnPvUvHourRepository extends JpaRepository<ActTplParamClickHour, Long>, JpaSpecificationExecutor<ActTplParamClickHour> {
14
15 Optional<ActTplParamClickHour> findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDayAndHour(Long marketingActivityId, Long activityId, Long paramValueId, String day, int hour);
16 }
1 package com.topdraw.business.module.activitybtn.hour.service;
2
3 import com.topdraw.business.module.activitybtn.hour.domain.ActTplParamClickHour;
4
5 /**
6 * @author XiangHan
7 * @date 2022-02-26
8 */
9 public interface ActivityBtnPvUvHourService {
10
11 void create(ActTplParamClickHour resources);
12
13 void update(ActTplParamClickHour resources);
14
15 ActTplParamClickHour findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDayAndHour(Long marketingActivityId, Long activityId, Long paramValueId, String day, int hour);
16 }
1 package com.topdraw.business.module.activitybtn.hour.service.dto;
2
3 import lombok.Data;
4
5 import javax.persistence.Column;
6 import java.io.Serializable;
7 import java.sql.Timestamp;
8
9
10 /**
11 * @author XiangHan
12 * @date 2022-02-26
13 */
14 @Data
15 public class ActTplParamClickHourDTO implements Serializable {
16
17 // ID
18 private Long id;
19
20 // 营销活动ID
21 private Long marketingActivityId;
22
23 // 活动事件id
24 private Long activityId;
25
26 // 活动按钮id
27 private Long templateParamValueId;
28
29 // 显示用名称，表示哪个按钮或者内容
30 private String name;
31
32 // 日期
33 private String day;
34
35 // 小时（0-23）
36 private Integer hour;
37
38 // pv值
39 private Integer pv;
40
41 // uv值
42 private Integer uv;
43
44 // 创建时间
45 private Timestamp createTime;
46
47 // 更新时间
48 private Timestamp updateTime;
49 }
1 package com.topdraw.business.module.activitybtn.hour.service.impl;
2
3 import com.topdraw.business.module.activitybtn.hour.domain.ActTplParamClickHour;
4 import com.topdraw.business.module.activitybtn.hour.repository.ActivityBtnPvUvHourRepository;
5 import com.topdraw.business.module.activitybtn.hour.service.ActivityBtnPvUvHourService;
6 import com.topdraw.utils.ValidationUtil;
7 import org.springframework.beans.factory.annotation.Autowired;
8 import org.springframework.stereotype.Service;
9 import org.springframework.transaction.annotation.Propagation;
10 import org.springframework.transaction.annotation.Transactional;
11
12 /**
13 * @author XiangHan
14 * @date 2022-02-26
15 */
16 @Service
17 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
18 public class ActivityBtnPvUvHourServiceImpl implements ActivityBtnPvUvHourService {
19
20 @Autowired
21 private ActivityBtnPvUvHourRepository PvUvHourRepository;
22
23
24 @Override
25 @Transactional(rollbackFor = Exception.class)
26 public void create(ActTplParamClickHour resources) {
27 PvUvHourRepository.save(resources);
28 }
29
30 @Override
31 @Transactional(rollbackFor = Exception.class)
32 public void update(ActTplParamClickHour resources) {
33 ActTplParamClickHour PvUvHour = PvUvHourRepository.findById(resources.getId()).orElseGet(ActTplParamClickHour::new);
34 ValidationUtil.isNull( PvUvHour.getId(),"PvUvHour","id",resources.getId());
35 PvUvHour.copy(resources);
36 PvUvHourRepository.save(PvUvHour);
37 }
38
39 @Override
40 public ActTplParamClickHour findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDayAndHour(Long marketingActivityId,
41 Long activityId, Long paramValueId,
42 String day, int hour) {
43 return PvUvHourRepository.findByMarketingActivityIdAndActivityIdAndTemplateParamValueIdAndDayAndHour(marketingActivityId, activityId,
44 paramValueId, day, hour).
45 orElseGet(ActTplParamClickHour::new);
46 }
47
48
49 }
1 package com.topdraw.business.module.subscribe.all.domain;
2
3 import lombok.Data;
4 import lombok.experimental.Accessors;
5 import cn.hutool.core.bean.BeanUtil;
6 import cn.hutool.core.bean.copier.CopyOptions;
7 import javax.persistence.*;
8 import org.springframework.data.annotation.CreatedDate;
9 import org.springframework.data.annotation.LastModifiedDate;
10 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
11 import java.sql.Timestamp;
12
13 import java.io.Serializable;
14
15 /**
16 * @author XiangHan
17 * @date 2022-04-20
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="act_subscribe_pv_uv")
24 public class SubscribePvUv implements Serializable {
25
26 // ID
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 营销活动ID
33 @Column(name = "marketing_activity_id", nullable = false)
34 private Long marketingActivityId;
35
36 // 营销活动标识
37 @Column(name = "marketing_activity_code", nullable = false)
38 private String marketingActivityCode;
39
40 // 产品包id
41 @Column(name = "package_id", nullable = false)
42 private String packageId;
43
44 // 产品包标识
45 @Column(name = "package_code")
46 private String packageCode;
47
48 // 产品包名称
49 @Column(name = "package_name")
50 private String packageName;
51
52 // 订购按钮总点击量
53 @Column(name = "btn_click_pv", nullable = false)
54 private Long btnClickPv;
55
56 // 订购按钮总点击人数
57 @Column(name = "btn_click_uv", nullable = false)
58 private Long btnClickUv;
59
60 // 订购成功人数
61 @Column(name = "subscribe_num", nullable = false)
62 private Long subscribeNum;
63
64 // 创建时间
65 @CreatedDate
66 @Column(name = "create_time")
67 private Timestamp createTime;
68
69 // 更新时间
70 @LastModifiedDate
71 @Column(name = "update_time")
72 private Timestamp updateTime;
73
74 public void copy(SubscribePvUv source){
75 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
76 }
77 }
1 package com.topdraw.business.module.subscribe.all.repository;
2
3 import com.topdraw.business.module.subscribe.all.domain.SubscribePvUv;
4 import com.topdraw.business.module.subscribe.day.domain.SubscribePvUvDay;
5 import org.springframework.data.jpa.repository.JpaRepository;
6 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
7
8 import java.util.Optional;
9
10 /**
11 * @author XiangHan
12 * @date 2022-04-20
13 */
14 public interface SubscribePvUvRepository extends JpaRepository<SubscribePvUv, Long>, JpaSpecificationExecutor<SubscribePvUv> {
15
16 Optional<SubscribePvUv> findByMarketingActivityCodeAndPackageId(String code, String packageId);
17 }
1 package com.topdraw.business.module.subscribe.all.service;
2
3 import com.topdraw.business.module.subscribe.all.domain.SubscribePvUv;
4 import com.topdraw.business.module.subscribe.all.service.dto.SubscribePvUvDTO;
5
6 /**
7 * @author XiangHan
8 * @date 2022-04-20
9 */
10 public interface SubscribePvUvService {
11
12 /**
13 * 根据ID查询
14 * @param id ID
15 * @return SubscribePvUvDTO
16 */
17 SubscribePvUvDTO findById(Long id);
18
19 void create(SubscribePvUv resources);
20
21 void update(SubscribePvUv resources);
22
23 void delete(Long id);
24
25 SubscribePvUv findByMarketingActivityCodeAndPackageId(String code, String packageId);
26 }
1 package com.topdraw.business.module.subscribe.all.service.dto;
2
3 import lombok.Data;
4 import java.sql.Timestamp;
5 import java.io.Serializable;
6
7
8 /**
9 * @author XiangHan
10 * @date 2022-04-20
11 */
12 @Data
13 public class SubscribePvUvDTO implements Serializable {
14
15 // ID
16 private Long id;
17
18 // 营销活动ID
19 private Long marketingActivityId;
20
21 // 营销活动标识
22 private String marketingActivityCode;
23
24 // 产品包id
25 private String packageId;
26
27 // 产品包标识
28 private String packageCode;
29
30 // 产品包名称
31 private String packageName;
32
33 // 订购按钮总点击量
34 private Long btnClickPv;
35
36 // 订购按钮总点击人数
37 private Long btnClickUv;
38
39 // 订购成功人数
40 private Long subscribeNum;
41
42 // 创建时间
43 private Timestamp createTime;
44
45 // 更新时间
46 private Timestamp updateTime;
47 }
1 package com.topdraw.business.module.subscribe.all.service.impl;
2
3 import com.topdraw.business.module.subscribe.all.domain.SubscribePvUv;
4 import com.topdraw.utils.ValidationUtil;
5 import com.topdraw.business.module.subscribe.all.repository.SubscribePvUvRepository;
6 import com.topdraw.business.module.subscribe.all.service.SubscribePvUvService;
7 import com.topdraw.business.module.subscribe.all.service.dto.SubscribePvUvDTO;
8 import com.topdraw.business.module.subscribe.all.service.mapper.SubscribePvUvMapper;
9 import org.springframework.beans.factory.annotation.Autowired;
10 import org.springframework.stereotype.Service;
11 import org.springframework.transaction.annotation.Propagation;
12 import org.springframework.transaction.annotation.Transactional;
13 import org.springframework.dao.EmptyResultDataAccessException;
14 import org.springframework.util.Assert;
15
16 /**
17 * @author XiangHan
18 * @date 2022-04-20
19 */
20 @Service
21 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
22 public class SubscribePvUvServiceImpl implements SubscribePvUvService {
23
24 @Autowired
25 private SubscribePvUvRepository SubscribePvUvRepository;
26
27 @Autowired
28 private SubscribePvUvMapper SubscribePvUvMapper;
29
30 @Override
31 public SubscribePvUvDTO findById(Long id) {
32 SubscribePvUv SubscribePvUv = SubscribePvUvRepository.findById(id).orElseGet(SubscribePvUv::new);
33 ValidationUtil.isNull(SubscribePvUv.getId(),"SubscribePvUv","id",id);
34 return SubscribePvUvMapper.toDto(SubscribePvUv);
35 }
36
37 @Override
38 @Transactional(rollbackFor = Exception.class)
39 public void create(SubscribePvUv resources) {
40 SubscribePvUvRepository.save(resources);
41 }
42
43 @Override
44 @Transactional(rollbackFor = Exception.class)
45 public void update(SubscribePvUv resources) {
46 SubscribePvUv SubscribePvUv = SubscribePvUvRepository.findById(resources.getId()).orElseGet(SubscribePvUv::new);
47 ValidationUtil.isNull( SubscribePvUv.getId(),"SubscribePvUv","id",resources.getId());
48 SubscribePvUv.copy(resources);
49 SubscribePvUvRepository.save(SubscribePvUv);
50 }
51
52 @Override
53 @Transactional(rollbackFor = Exception.class)
54 public void delete(Long id) {
55 Assert.notNull(id, "The given id must not be null!");
56 SubscribePvUv SubscribePvUv = SubscribePvUvRepository.findById(id).orElseThrow(
57 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", SubscribePvUv.class, id), 1));
58 SubscribePvUvRepository.delete(SubscribePvUv);
59 }
60
61 @Override
62 public SubscribePvUv findByMarketingActivityCodeAndPackageId(String code, String packageId) {
63 SubscribePvUv SubscribePvUvDay =
64 SubscribePvUvRepository.findByMarketingActivityCodeAndPackageId(code, packageId).orElseGet(SubscribePvUv::new);
65 return SubscribePvUvDay;
66 }
67
68
69 }
1 package com.topdraw.business.module.subscribe.all.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.module.subscribe.all.domain.SubscribePvUv;
5 import com.topdraw.business.module.subscribe.all.service.dto.SubscribePvUvDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2022-04-20
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface SubscribePvUvMapper extends BaseMapper<SubscribePvUvDTO, SubscribePvUv> {
15
16 }
1 package com.topdraw.business.module.subscribe.day.domain;
2
3 import lombok.Data;
4 import lombok.experimental.Accessors;
5 import cn.hutool.core.bean.BeanUtil;
6 import cn.hutool.core.bean.copier.CopyOptions;
7 import javax.persistence.*;
8 import org.springframework.data.annotation.CreatedDate;
9 import org.springframework.data.annotation.LastModifiedDate;
10 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
11 import java.sql.Timestamp;
12
13 import java.io.Serializable;
14
15 /**
16 * @author XiangHan
17 * @date 2022-04-20
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="act_subscribe_pv_uv_day")
24 public class SubscribePvUvDay implements Serializable {
25
26 // ID
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 营销活动ID
33 @Column(name = "marketing_activity_id", nullable = false)
34 private Long marketingActivityId;
35
36 // 营销活动标识
37 @Column(name = "marketing_activity_code", nullable = false)
38 private String marketingActivityCode;
39
40 // 产品包id
41 @Column(name = "package_id", nullable = false)
42 private String packageId;
43
44 // 产品包标识
45 @Column(name = "package_code")
46 private String packageCode;
47
48 // 产品包名称
49 @Column(name = "package_name")
50 private String packageName;
51
52 // 日期
53 @Column(name = "day", nullable = false)
54 private String day;
55
56 // 订购按钮总点击量
57 @Column(name = "btn_click_pv", nullable = false)
58 private Long btnClickPv;
59
60 // 订购按钮总点击人数
61 @Column(name = "btn_click_uv", nullable = false)
62 private Long btnClickUv;
63
64 // 订购成功人数
65 @Column(name = "subscribe_num", nullable = false)
66 private Long subscribeNum;
67
68 // 创建时间
69 @CreatedDate
70 @Column(name = "create_time")
71 private Timestamp createTime;
72
73 // 更新时间
74 @LastModifiedDate
75 @Column(name = "update_time")
76 private Timestamp updateTime;
77
78 public void copy(SubscribePvUvDay source){
79 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
80 }
81 }
1 package com.topdraw.business.module.subscribe.day.repository;
2
3 import com.topdraw.business.module.subscribe.day.domain.SubscribePvUvDay;
4 import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
5 import org.springframework.data.jpa.repository.JpaRepository;
6 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
7
8 import java.util.Optional;
9
10 /**
11 * @author XiangHan
12 * @date 2022-04-20
13 */
14 public interface SubscribePvUvDayRepository extends JpaRepository<SubscribePvUvDay, Long>, JpaSpecificationExecutor<SubscribePvUvDay> {
15
16 Optional<SubscribePvUvDay> findByMarketingActivityCodeAndPackageIdAndDay(String code, String packageId, String day);
17 }
1 package com.topdraw.business.module.subscribe.day.service;
2
3 import com.topdraw.business.module.subscribe.day.domain.SubscribePvUvDay;
4 import com.topdraw.business.module.subscribe.day.service.dto.SubscribePvUvDayDTO;
5 import com.topdraw.business.module.subscribe.day.service.dto.SubscribePvUvDayQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7 import java.util.Map;
8 import java.util.List;
9 import java.io.IOException;
10 import javax.servlet.http.HttpServletResponse;
11
12 /**
13 * @author XiangHan
14 * @date 2022-04-20
15 */
16 public interface SubscribePvUvDayService {
17
18 /**
19 * 查询数据分页
20 * @param criteria 条件参数
21 * @param pageable 分页参数
22 * @return Map<String,Object>
23 */
24 Map<String,Object> queryAll(SubscribePvUvDayQueryCriteria criteria, Pageable pageable);
25
26 /**
27 * 查询所有数据不分页
28 * @param criteria 条件参数
29 * @return List<SubscribePvUvDayDTO>
30 */
31 List<SubscribePvUvDayDTO> queryAll(SubscribePvUvDayQueryCriteria criteria);
32
33 /**
34 * 根据ID查询
35 * @param id ID
36 * @return SubscribePvUvDayDTO
37 */
38 SubscribePvUvDayDTO findById(Long id);
39
40 void create(SubscribePvUvDay resources);
41
42 void update(SubscribePvUvDay resources);
43
44 void delete(Long id);
45
46 SubscribePvUvDay findByMarketingActivityCodeAndPackageIdAndDay(String code, String packageId, String day);
47
48 void updateByMarketingActivityCodeAndDayAndPackageId(SubscribePvUvDay subscribePvUvDay);
49
50 }
1 package com.topdraw.business.module.subscribe.day.service.dto;
2
3 import lombok.Data;
4 import java.sql.Timestamp;
5 import java.io.Serializable;
6
7
8 /**
9 * @author XiangHan
10 * @date 2022-04-20
11 */
12 @Data
13 public class SubscribePvUvDayDTO implements Serializable {
14
15 // ID
16 private Long id;
17
18 // 营销活动ID
19 private Long marketingActivityId;
20
21 // 营销活动标识
22 private String marketingActivityCode;
23
24 // 产品包id
25 private String packageId;
26
27 // 产品包标识
28 private String packageCode;
29
30 // 产品包名称
31 private String packageName;
32
33 // 日期
34 private String day;
35
36 // 订购按钮总点击量
37 private Long btnClickPv;
38
39 // 订购按钮总点击人数
40 private Long btnClickUv;
41
42 // 订购成功人数
43 private Long subscribeNum;
44
45 // 创建时间
46 private Timestamp createTime;
47
48 // 更新时间
49 private Timestamp updateTime;
50 }
1 package com.topdraw.business.module.subscribe.day.service.dto;
2
3 import lombok.Data;
4 import com.topdraw.annotation.Query;
5
6 /**
7 * @author XiangHan
8 * @date 2022-04-20
9 */
10 @Data
11 public class SubscribePvUvDayQueryCriteria{
12 }
1 package com.topdraw.business.module.subscribe.day.service.impl;
2
3 import com.topdraw.business.module.subscribe.day.domain.SubscribePvUvDay;
4 import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
5 import com.topdraw.utils.ValidationUtil;
6 import com.topdraw.utils.FileUtil;
7 import com.topdraw.business.module.subscribe.day.repository.SubscribePvUvDayRepository;
8 import com.topdraw.business.module.subscribe.day.service.SubscribePvUvDayService;
9 import com.topdraw.business.module.subscribe.day.service.dto.SubscribePvUvDayDTO;
10 import com.topdraw.business.module.subscribe.day.service.dto.SubscribePvUvDayQueryCriteria;
11 import com.topdraw.business.module.subscribe.day.service.mapper.SubscribePvUvDayMapper;
12 import org.springframework.beans.factory.annotation.Autowired;
13 import org.springframework.stereotype.Service;
14 import org.springframework.transaction.annotation.Propagation;
15 import org.springframework.transaction.annotation.Transactional;
16 import org.springframework.dao.EmptyResultDataAccessException;
17 import org.springframework.data.domain.Page;
18 import org.springframework.data.domain.Pageable;
19 import org.springframework.util.Assert;
20 import com.topdraw.utils.PageUtil;
21 import com.topdraw.utils.QueryHelp;
22 import com.topdraw.utils.StringUtils;
23
24 import java.util.List;
25 import java.util.Map;
26 import java.io.IOException;
27 import javax.servlet.http.HttpServletResponse;
28 import java.util.ArrayList;
29 import java.util.LinkedHashMap;
30
31 /**
32 * @author XiangHan
33 * @date 2022-04-20
34 */
35 @Service
36 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
37 public class SubscribePvUvDayServiceImpl implements SubscribePvUvDayService {
38
39 @Autowired
40 private SubscribePvUvDayRepository SubscribePvUvDayRepository;
41
42 @Autowired
43 private SubscribePvUvDayMapper SubscribePvUvDayMapper;
44
45 @Override
46 public Map<String, Object> queryAll(SubscribePvUvDayQueryCriteria criteria, Pageable pageable) {
47 Page<SubscribePvUvDay> page = SubscribePvUvDayRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
48 return PageUtil.toPage(page.map(SubscribePvUvDayMapper::toDto));
49 }
50
51 @Override
52 public List<SubscribePvUvDayDTO> queryAll(SubscribePvUvDayQueryCriteria criteria) {
53 return SubscribePvUvDayMapper.toDto(SubscribePvUvDayRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
54 }
55
56 @Override
57 public SubscribePvUvDayDTO findById(Long id) {
58 SubscribePvUvDay SubscribePvUvDay = SubscribePvUvDayRepository.findById(id).orElseGet(SubscribePvUvDay::new);
59 ValidationUtil.isNull(SubscribePvUvDay.getId(),"SubscribePvUvDay","id",id);
60 return SubscribePvUvDayMapper.toDto(SubscribePvUvDay);
61 }
62
63 @Override
64 @Transactional(rollbackFor = Exception.class)
65 public void create(SubscribePvUvDay resources) {
66 SubscribePvUvDayRepository.save(resources);
67 }
68
69 @Override
70 @Transactional(rollbackFor = Exception.class)
71 public void update(SubscribePvUvDay resources) {
72 SubscribePvUvDay SubscribePvUvDay = SubscribePvUvDayRepository.findById(resources.getId()).orElseGet(SubscribePvUvDay::new);
73 ValidationUtil.isNull( SubscribePvUvDay.getId(),"SubscribePvUvDay","id",resources.getId());
74 SubscribePvUvDay.copy(resources);
75 SubscribePvUvDayRepository.save(SubscribePvUvDay);
76 }
77
78 @Override
79 @Transactional(rollbackFor = Exception.class)
80 public void delete(Long id) {
81 Assert.notNull(id, "The given id must not be null!");
82 SubscribePvUvDay SubscribePvUvDay = SubscribePvUvDayRepository.findById(id).orElseThrow(
83 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", SubscribePvUvDay.class, id), 1));
84 SubscribePvUvDayRepository.delete(SubscribePvUvDay);
85 }
86
87 @Override
88 public SubscribePvUvDay findByMarketingActivityCodeAndPackageIdAndDay(String code, String packageId, String day) {
89 SubscribePvUvDay SubscribePvUvDay =
90 SubscribePvUvDayRepository.findByMarketingActivityCodeAndPackageIdAndDay(code, packageId, day).orElseGet(SubscribePvUvDay::new);
91 return SubscribePvUvDay;
92 }
93
94 @Override
95 public void updateByMarketingActivityCodeAndDayAndPackageId(SubscribePvUvDay subscribePvUvDay) {
96
97 }
98
99
100 }
1 package com.topdraw.business.module.subscribe.day.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.module.subscribe.day.domain.SubscribePvUvDay;
5 import com.topdraw.business.module.subscribe.day.service.dto.SubscribePvUvDayDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2022-04-20
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface SubscribePvUvDayMapper extends BaseMapper<SubscribePvUvDayDTO, SubscribePvUvDay> {
15
16 }
1 package com.topdraw.business.module.subscribe.hour.domain;
2
3 import lombok.Data;
4 import lombok.experimental.Accessors;
5 import cn.hutool.core.bean.BeanUtil;
6 import cn.hutool.core.bean.copier.CopyOptions;
7 import javax.persistence.*;
8 import org.springframework.data.annotation.CreatedDate;
9 import org.springframework.data.annotation.LastModifiedDate;
10 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
11 import java.sql.Timestamp;
12
13 import java.io.Serializable;
14
15 /**
16 * @author XiangHan
17 * @date 2022-04-20
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="act_subscribe_pv_uv_hour")
24 public class SubscribePvUvHour implements Serializable {
25
26 // ID
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 营销活动ID
33 @Column(name = "marketing_activity_id", nullable = false)
34 private Long marketingActivityId;
35
36 // 营销活动标识
37 @Column(name = "marketing_activity_code", nullable = false)
38 private String marketingActivityCode;
39
40 // 产品包id
41 @Column(name = "package_id", nullable = false)
42 private String packageId;
43
44 // 产品包标识
45 @Column(name = "package_code")
46 private String packageCode;
47
48 // 产品包名称
49 @Column(name = "package_name")
50 private String packageName;
51
52 // 日期
53 @Column(name = "day", nullable = false)
54 private String day;
55
56 // 小时（0-23）
57 @Column(name = "hour", nullable = false)
58 private Integer hour;
59
60 // 订购按钮总点击量
61 @Column(name = "btn_click_pv", nullable = false)
62 private Long btnClickPv;
63
64 // 订购按钮总点击人数
65 @Column(name = "btn_click_uv", nullable = false)
66 private Long btnClickUv;
67
68 // 订购成功人数
69 @Column(name = "subscribe_num", nullable = false)
70 private Long subscribeNum;
71
72 // 创建时间
73 @CreatedDate
74 @Column(name = "create_time")
75 private Timestamp createTime;
76
77 // 更新时间
78 @LastModifiedDate
79 @Column(name = "update_time")
80 private Timestamp updateTime;
81
82 public void copy(SubscribePvUvHour source){
83 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
84 }
85 }
1 package com.topdraw.business.module.subscribe.hour.repository;
2
3 import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.List;
8 import java.util.Optional;
9
10 /**
11 * @author XiangHan
12 * @date 2022-04-20
13 */
14 public interface SubscribePvUvHourRepository extends JpaRepository<SubscribePvUvHour, Long>, JpaSpecificationExecutor<SubscribePvUvHour> {
15
16 Optional<SubscribePvUvHour> findByMarketingActivityCodeAndPackageIdAndDayAndHour(String code, String packageId, String day, int hour);
17 }
1 package com.topdraw.business.module.subscribe.hour.service;
2
3 import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
4 import com.topdraw.business.module.subscribe.hour.service.dto.SubscribePvUvHourDTO;
5 import com.topdraw.business.module.subscribe.hour.service.dto.SubscribePvUvHourQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7 import java.util.Map;
8 import java.util.List;
9 import java.io.IOException;
10 import javax.servlet.http.HttpServletResponse;
11
12 /**
13 * @author XiangHan
14 * @date 2022-04-20
15 */
16 public interface SubscribePvUvHourService {
17
18 /**
19 * 根据ID查询
20 * @param id ID
21 * @return SubscribePvUvHourDTO
22 */
23 SubscribePvUvHourDTO findById(Long id);
24
25 void create(SubscribePvUvHour resources);
26
27 void update(SubscribePvUvHour resources);
28
29 void delete(Long id);
30
31 SubscribePvUvHour findByMarketingActivityCodeAndPackageIdAndDayAndHour(String code, String packageId, String toString, int hour);
32
33 void updateByMarketingActivityCodeAndDayAndHourAndPackageId(SubscribePvUvHour subscribePvUvHour);
34 }
1 package com.topdraw.business.module.subscribe.hour.service.dto;
2
3 import lombok.Data;
4 import java.sql.Timestamp;
5 import java.io.Serializable;
6
7
8 /**
9 * @author XiangHan
10 * @date 2022-04-20
11 */
12 @Data
13 public class SubscribePvUvHourDTO implements Serializable {
14
15 // ID
16 private Long id;
17
18 // 营销活动ID
19 private Long marketingActivityId;
20
21 // 营销活动标识
22 private String marketingActivityCode;
23
24 // 产品包id
25 private String packageId;
26
27 // 产品包标识
28 private String packageCode;
29
30 // 产品包名称
31 private String packageName;
32
33 // 日期
34 private String day;
35
36 // 小时（0-23）
37 private Integer hour;
38
39 // 订购按钮总点击量
40 private Long btnClickPv;
41
42 // 订购按钮总点击人数
43 private Long btnClickUv;
44
45 // 订购成功人数
46 private Long subscribeNum;
47
48 // 创建时间
49 private Timestamp createTime;
50
51 // 更新时间
52 private Timestamp updateTime;
53 }
1 package com.topdraw.business.module.subscribe.hour.service.dto;
2
3 import lombok.Data;
4 import com.topdraw.annotation.Query;
5
6 /**
7 * @author XiangHan
8 * @date 2022-04-20
9 */
10 @Data
11 public class SubscribePvUvHourQueryCriteria{
12 }
1 package com.topdraw.business.module.subscribe.hour.service.impl;
2
3 import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
4 import com.topdraw.utils.ValidationUtil;
5 import com.topdraw.utils.FileUtil;
6 import com.topdraw.business.module.subscribe.hour.repository.SubscribePvUvHourRepository;
7 import com.topdraw.business.module.subscribe.hour.service.SubscribePvUvHourService;
8 import com.topdraw.business.module.subscribe.hour.service.dto.SubscribePvUvHourDTO;
9 import com.topdraw.business.module.subscribe.hour.service.dto.SubscribePvUvHourQueryCriteria;
10 import com.topdraw.business.module.subscribe.hour.service.mapper.SubscribePvUvHourMapper;
11 import org.springframework.beans.factory.annotation.Autowired;
12 import org.springframework.stereotype.Service;
13 import org.springframework.transaction.annotation.Propagation;
14 import org.springframework.transaction.annotation.Transactional;
15 import org.springframework.dao.EmptyResultDataAccessException;
16 import org.springframework.data.domain.Page;
17 import org.springframework.data.domain.Pageable;
18 import org.springframework.util.Assert;
19 import com.topdraw.utils.PageUtil;
20 import com.topdraw.utils.QueryHelp;
21 import com.topdraw.utils.StringUtils;
22
23 import java.util.List;
24 import java.util.Map;
25 import java.io.IOException;
26 import javax.servlet.http.HttpServletResponse;
27 import java.util.ArrayList;
28 import java.util.LinkedHashMap;
29
30 /**
31 * @author XiangHan
32 * @date 2022-04-20
33 */
34 @Service
35 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
36 public class SubscribePvUvHourServiceImpl implements SubscribePvUvHourService {
37
38 @Autowired
39 private SubscribePvUvHourRepository SubscribePvUvHourRepository;
40
41 @Autowired
42 private SubscribePvUvHourMapper SubscribePvUvHourMapper;
43
44 @Override
45 public SubscribePvUvHourDTO findById(Long id) {
46 SubscribePvUvHour SubscribePvUvHour = SubscribePvUvHourRepository.findById(id).orElseGet(SubscribePvUvHour::new);
47 ValidationUtil.isNull(SubscribePvUvHour.getId(),"SubscribePvUvHour","id",id);
48 return SubscribePvUvHourMapper.toDto(SubscribePvUvHour);
49 }
50
51 @Override
52 @Transactional(rollbackFor = Exception.class)
53 public void create(SubscribePvUvHour resources) {
54 SubscribePvUvHourRepository.save(resources);
55 }
56
57 @Override
58 @Transactional(rollbackFor = Exception.class)
59 public void update(SubscribePvUvHour resources) {
60 SubscribePvUvHour SubscribePvUvHour = SubscribePvUvHourRepository.findById(resources.getId()).orElseGet(SubscribePvUvHour::new);
61 ValidationUtil.isNull( SubscribePvUvHour.getId(),"SubscribePvUvHour","id",resources.getId());
62 SubscribePvUvHour.copy(resources);
63 SubscribePvUvHourRepository.save(SubscribePvUvHour);
64 }
65
66 @Override
67 @Transactional(rollbackFor = Exception.class)
68 public void delete(Long id) {
69 Assert.notNull(id, "The given id must not be null!");
70 SubscribePvUvHour SubscribePvUvHour = SubscribePvUvHourRepository.findById(id).orElseThrow(
71 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", SubscribePvUvHour.class, id), 1));
72 SubscribePvUvHourRepository.delete(SubscribePvUvHour);
73 }
74
75 @Override
76 public SubscribePvUvHour findByMarketingActivityCodeAndPackageIdAndDayAndHour(String code, String packageId, String day, int hour) {
77 SubscribePvUvHour SubscribePvUvHour =
78 SubscribePvUvHourRepository.findByMarketingActivityCodeAndPackageIdAndDayAndHour(code, packageId, day, hour).orElseGet(SubscribePvUvHour::new);
79 return SubscribePvUvHour;
80 }
81
82 @Override
83 public void updateByMarketingActivityCodeAndDayAndHourAndPackageId(SubscribePvUvHour subscribePvUvHour) {
84
85 }
86
87
88 }
1 package com.topdraw.business.module.subscribe.hour.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.module.subscribe.hour.domain.SubscribePvUvHour;
5 import com.topdraw.business.module.subscribe.hour.service.dto.SubscribePvUvHourDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2022-04-20
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface SubscribePvUvHourMapper extends BaseMapper<SubscribePvUvHourDTO, SubscribePvUvHour> {
15
16 }
1 package com.topdraw.business.module.uv.all.domain;
2
3 import lombok.Data;
4 import lombok.experimental.Accessors;
5 import cn.hutool.core.bean.BeanUtil;
6 import cn.hutool.core.bean.copier.CopyOptions;
7 import javax.persistence.*;
8 import org.springframework.data.annotation.CreatedDate;
9 import org.springframework.data.annotation.LastModifiedDate;
10 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
11 import java.sql.Timestamp;
12
13 import java.io.Serializable;
14
15 /**
16 * @author XiangHan
17 * @date 2022-02-26
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="act_pv_uv")
24 public class PvUv implements Serializable {
25
26 // ID
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 营销活动ID
33 @Column(name = "marketing_activity_id", nullable = false)
34 private Long marketingActivityId;
35
36 // 营销活动标识
37 @Column(name = "marketing_activity_code", nullable = false)
38 private String marketingActivityCode;
39
40 // pv值
41 @Column(name = "pv", nullable = false)
42 private Integer pv;
43
44 // uv值
45 @Column(name = "uv", nullable = false)
46 private Integer uv;
47
48 // 创建时间
49 @CreatedDate
50 @Column(name = "create_time")
51 private Timestamp createTime;
52
53 // 更新时间
54 @LastModifiedDate
55 @Column(name = "update_time")
56 private Timestamp updateTime;
57
58 public void copy(PvUv source){
59 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
60 }
61 }
1 package com.topdraw.business.module.uv.all.repository;
2
3 import com.topdraw.business.module.uv.all.domain.PvUv;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6 import org.springframework.data.jpa.repository.Modifying;
7 import org.springframework.data.jpa.repository.Query;
8 import org.springframework.data.repository.query.Param;
9 import org.springframework.transaction.annotation.Transactional;
10
11 import java.util.Optional;
12
13 /**
14 * @author XiangHan
15 * @date 2022-02-26
16 */
17 public interface PvUvRepository extends JpaRepository<PvUv, Long>, JpaSpecificationExecutor<PvUv> {
18
19 @Modifying
20 @Transactional
21 @Query(value = "update act_pv_uv set pv = :#{#resources.pv} , uv = :#{#resources.uv} , " +
22 "update_time = :#{#resources.updateTime} where marketing_activity_code = :#{#resources.marketingActivityCode} " , nativeQuery = true)
23 void updateByMarketingActivityId(@Param("resources") PvUv resources);
24
25 Optional<PvUv> findByMarketingActivityCode(String marketingActivityCode);
26
27 Optional<PvUv> findByMarketingActivityId(Long mActivityId);
28 }
1 package com.topdraw.business.module.uv.all.service;
2
3 import com.topdraw.business.module.uv.all.domain.PvUv;
4 import com.topdraw.business.module.uv.all.service.dto.PvUvDTO;
5 import com.topdraw.business.module.uv.all.service.dto.PvUvQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7 import org.springframework.transaction.annotation.Transactional;
8
9 import java.util.Map;
10 import java.util.List;
11 import java.io.IOException;
12 import javax.servlet.http.HttpServletResponse;
13
14 /**
15 * @author XiangHan
16 * @date 2022-02-26
17 */
18 public interface PvUvService {
19
20 /**
21 * 查询数据分页
22 * @param criteria 条件参数
23 * @param pageable 分页参数
24 * @return Map<String,Object>
25 */
26 Map<String,Object> queryAll(PvUvQueryCriteria criteria, Pageable pageable);
27
28 /**
29 * 查询所有数据不分页
30 * @param criteria 条件参数
31 * @return List<PvUvDTO>
32 */
33 List<PvUvDTO> queryAll(PvUvQueryCriteria criteria);
34
35 /**
36 * 根据ID查询
37 * @param id ID
38 * @return PvUvDTO
39 */
40 PvUvDTO findById(Long id);
41
42 void create(PvUv resources);
43
44 @Transactional(rollbackFor = Exception.class)
45 void updateByMarketingActivityId(PvUv resources);
46
47 void update(PvUv resources);
48
49 void delete(Long id);
50
51 PvUv findByMarketingActivityCode(String code);
52
53 PvUv findByMarketingActivityId(Long parseLong);
54 }
1 package com.topdraw.business.module.uv.all.service.dto;
2
3 import lombok.Data;
4 import java.sql.Timestamp;
5 import java.io.Serializable;
6
7
8 /**
9 * @author XiangHan
10 * @date 2022-02-26
11 */
12 @Data
13 public class PvUvDTO implements Serializable {
14
15 // ID
16 private Long id;
17
18 // 营销活动ID
19 private Long marketingActivityId;
20
21 // 营销活动标识
22 private String marketingActivityCode;
23
24 // pv值
25 private Long pv;
26
27 // uv值
28 private Long uv;
29
30 // 创建时间
31 private Timestamp createTime;
32
33 // 更新时间
34 private Timestamp updateTime;
35 }
1 package com.topdraw.business.module.uv.all.service.dto;
2
3 import lombok.Data;
4 import com.topdraw.annotation.Query;
5
6 /**
7 * @author XiangHan
8 * @date 2022-02-26
9 */
10 @Data
11 public class PvUvQueryCriteria{
12 }
1 package com.topdraw.business.module.uv.all.service.impl;
2
3 import com.topdraw.business.module.uv.all.domain.PvUv;
4 import com.topdraw.utils.ValidationUtil;
5 import com.topdraw.utils.FileUtil;
6 import com.topdraw.business.module.uv.all.repository.PvUvRepository;
7 import com.topdraw.business.module.uv.all.service.PvUvService;
8 import com.topdraw.business.module.uv.all.service.dto.PvUvDTO;
9 import com.topdraw.business.module.uv.all.service.dto.PvUvQueryCriteria;
10 import com.topdraw.business.module.uv.all.service.mapper.PvUvMapper;
11 import org.springframework.beans.factory.annotation.Autowired;
12 import org.springframework.stereotype.Service;
13 import org.springframework.transaction.annotation.Propagation;
14 import org.springframework.transaction.annotation.Transactional;
15 import org.springframework.dao.EmptyResultDataAccessException;
16 import org.springframework.data.domain.Page;
17 import org.springframework.data.domain.Pageable;
18 import org.springframework.util.Assert;
19 import com.topdraw.utils.PageUtil;
20 import com.topdraw.utils.QueryHelp;
21 import com.topdraw.utils.StringUtils;
22
23 import java.util.List;
24 import java.util.Map;
25 import java.io.IOException;
26 import javax.servlet.http.HttpServletResponse;
27 import java.util.ArrayList;
28 import java.util.LinkedHashMap;
29
30 /**
31 * @author XiangHan
32 * @date 2022-02-26
33 */
34 @Service
35 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
36 public class PvUvServiceImpl implements PvUvService {
37
38 @Autowired
39 private PvUvRepository PvUvRepository;
40
41 @Autowired
42 private PvUvMapper PvUvMapper;
43
44 @Override
45 public Map<String, Object> queryAll(PvUvQueryCriteria criteria, Pageable pageable) {
46 Page<PvUv> page = PvUvRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
47 return PageUtil.toPage(page.map(PvUvMapper::toDto));
48 }
49
50 @Override
51 public List<PvUvDTO> queryAll(PvUvQueryCriteria criteria) {
52 return PvUvMapper.toDto(PvUvRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
53 }
54
55 @Override
56 public PvUvDTO findById(Long id) {
57 PvUv PvUv = PvUvRepository.findById(id).orElseGet(PvUv::new);
58 ValidationUtil.isNull(PvUv.getId(),"PvUv","id",id);
59 return PvUvMapper.toDto(PvUv);
60 }
61
62 @Override
63 @Transactional(rollbackFor = Exception.class)
64 public void create(PvUv resources) {
65 PvUvRepository.save(resources);
66 }
67
68 @Override
69 @Transactional(rollbackFor = Exception.class)
70 public void updateByMarketingActivityId(PvUv resources) {
71 PvUvRepository.updateByMarketingActivityId(resources);
72 }
73
74 @Override
75 @Transactional(rollbackFor = Exception.class)
76 public void update(PvUv resources) {
77 PvUv PvUv = PvUvRepository.findById(resources.getId()).orElseGet(PvUv::new);
78 ValidationUtil.isNull( PvUv.getId(),"PvUv","id",resources.getId());
79 PvUv.copy(resources);
80 PvUvRepository.save(PvUv);
81 }
82
83 @Override
84 @Transactional(rollbackFor = Exception.class)
85 public void delete(Long id) {
86 Assert.notNull(id, "The given id must not be null!");
87 PvUv PvUv = PvUvRepository.findById(id).orElseThrow(
88 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", PvUv.class, id), 1));
89 PvUvRepository.delete(PvUv);
90 }
91
92 @Override
93 public PvUv findByMarketingActivityCode(String code) {
94 PvUv PvUv = PvUvRepository.findByMarketingActivityCode(code).orElseGet(PvUv::new);
95 return PvUv;
96 }
97
98 @Override
99 public PvUv findByMarketingActivityId(Long mActivityId) {
100 return PvUvRepository.findByMarketingActivityId(mActivityId).orElseGet(PvUv::new);
101 }
102
103
104 }
1 package com.topdraw.business.module.uv.all.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.module.uv.all.domain.PvUv;
5 import com.topdraw.business.module.uv.all.service.dto.PvUvDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2022-02-26
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface PvUvMapper extends BaseMapper<PvUvDTO, PvUv> {
15
16 }
1 package com.topdraw.business.module.uv.day.domain;
2
3 import lombok.Data;
4 import lombok.experimental.Accessors;
5 import cn.hutool.core.bean.BeanUtil;
6 import cn.hutool.core.bean.copier.CopyOptions;
7 import javax.persistence.*;
8 import org.springframework.data.annotation.CreatedDate;
9 import org.springframework.data.annotation.LastModifiedDate;
10 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
11 import java.sql.Timestamp;
12
13 import java.io.Serializable;
14
15 /**
16 * @author XiangHan
17 * @date 2022-02-26
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="act_pv_uv_day")
24 public class PvUvDay implements Serializable {
25
26 // ID
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 营销活动ID
33 @Column(name = "marketing_activity_id", nullable = false)
34 private Long marketingActivityId;
35
36 // 营销活动标识
37 @Column(name = "marketing_activity_code", nullable = false)
38 private String marketingActivityCode;
39
40 // 日期
41 @Column(name = "day", nullable = false)
42 private String day;
43
44 // pv值
45 @Column(name = "pv", nullable = false)
46 private Integer pv;
47
48 // uv值
49 @Column(name = "uv", nullable = false)
50 private Integer uv;
51
52 // 创建时间
53 @CreatedDate
54 @Column(name = "create_time")
55 private Timestamp createTime;
56
57 // 更新时间
58 @LastModifiedDate
59 @Column(name = "update_time")
60 private Timestamp updateTime;
61
62 public void copy(PvUvDay source){
63 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
64 }
65 }
1 package com.topdraw.business.module.uv.day.repository;
2
3 import com.topdraw.business.module.uv.day.domain.PvUvDay;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6 import org.springframework.data.jpa.repository.Modifying;
7 import org.springframework.data.jpa.repository.Query;
8 import org.springframework.data.repository.query.Param;
9 import org.springframework.transaction.annotation.Transactional;
10
11 import java.util.Optional;
12
13 /**
14 * @author XiangHan
15 * @date 2022-02-26
16 */
17 public interface PvUvDayRepository extends JpaRepository<PvUvDay, Long>, JpaSpecificationExecutor<PvUvDay> {
18
19 Optional<PvUvDay> findByMarketingActivityCodeAndDay(String marketingActivityCode, String day);
20
21 @Modifying
22 @Transactional
23 @Query(value = "update act_pv_uv_day set pv = :#{#resources.pv} , uv = :#{#resources.uv} , " +
24 " update_time = :#{#resources.updateTime} where marketing_activity_code = :#{#resources.marketingActivityCode} and " +
25 " `day` = :#{#resources.day}" , nativeQuery = true)
26 void updateByMarketingActivityCodeAndDay(@Param("resources") PvUvDay pvUvDay);
27
28 Optional<PvUvDay> findByMarketingActivityIdAndDay(Long mActivityId, String day);
29 }
1 package com.topdraw.business.module.uv.day.service;
2
3 import com.topdraw.business.module.uv.day.domain.PvUvDay;
4 import com.topdraw.business.module.uv.day.service.dto.PvUvDayDTO;
5 import com.topdraw.business.module.uv.day.service.dto.PvUvDayQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7 import java.util.Map;
8 import java.util.List;
9 import java.io.IOException;
10 import javax.servlet.http.HttpServletResponse;
11
12 /**
13 * @author XiangHan
14 * @date 2022-02-26
15 */
16 public interface PvUvDayService {
17
18 /**
19 * 查询数据分页
20 * @param criteria 条件参数
21 * @param pageable 分页参数
22 * @return Map<String,Object>
23 */
24 Map<String,Object> queryAll(PvUvDayQueryCriteria criteria, Pageable pageable);
25
26 /**
27 * 查询所有数据不分页
28 * @param criteria 条件参数
29 * @return List<PvUvDayDTO>
30 */
31 List<PvUvDayDTO> queryAll(PvUvDayQueryCriteria criteria);
32
33 /**
34 * 根据ID查询
35 * @param id ID
36 * @return PvUvDayDTO
37 */
38 PvUvDayDTO findById(Long id);
39
40 void create(PvUvDay resources);
41
42 void update(PvUvDay resources);
43
44 void delete(Long id);
45
46 PvUvDay findByMarketingActivityCodeAndDay(String code, String day);
47
48 void updateByMarketingActivityCodeAndDay(PvUvDay pvUvDay);
49
50 PvUvDay findByMarketingActivityIdAndDay(Long mActivityId, String day);
51 }
1 package com.topdraw.business.module.uv.day.service.dto;
2
3 import lombok.Data;
4 import java.sql.Timestamp;
5 import java.io.Serializable;
6
7
8 /**
9 * @author XiangHan
10 * @date 2022-02-26
11 */
12 @Data
13 public class PvUvDayDTO implements Serializable {
14
15 // ID
16 private Long id;
17
18 // 营销活动ID
19 private Long marketingActivityId;
20
21 // 营销活动标识
22 private String marketingActivityCode;
23
24 // 日期
25 private String day;
26
27 // pv值
28 private Integer pv;
29
30 // uv值
31 private Integer uv;
32
33 // 创建时间
34 private Timestamp createTime;
35
36 // 更新时间
37 private Timestamp updateTime;
38 }
1 package com.topdraw.business.module.uv.day.service.dto;
2
3 import lombok.Data;
4 import com.topdraw.annotation.Query;
5
6 /**
7 * @author XiangHan
8 * @date 2022-02-26
9 */
10 @Data
11 public class PvUvDayQueryCriteria{
12 }
1 package com.topdraw.business.module.uv.day.service.impl;
2
3 import com.topdraw.business.module.uv.day.domain.PvUvDay;
4 import com.topdraw.utils.ValidationUtil;
5 import com.topdraw.utils.FileUtil;
6 import com.topdraw.business.module.uv.day.repository.PvUvDayRepository;
7 import com.topdraw.business.module.uv.day.service.PvUvDayService;
8 import com.topdraw.business.module.uv.day.service.dto.PvUvDayDTO;
9 import com.topdraw.business.module.uv.day.service.dto.PvUvDayQueryCriteria;
10 import com.topdraw.business.module.uv.day.service.mapper.PvUvDayMapper;
11 import org.springframework.beans.factory.annotation.Autowired;
12 import org.springframework.stereotype.Service;
13 import org.springframework.transaction.annotation.Propagation;
14 import org.springframework.transaction.annotation.Transactional;
15 import org.springframework.dao.EmptyResultDataAccessException;
16 import org.springframework.data.domain.Page;
17 import org.springframework.data.domain.Pageable;
18 import org.springframework.util.Assert;
19 import com.topdraw.utils.PageUtil;
20 import com.topdraw.utils.QueryHelp;
21 import com.topdraw.utils.StringUtils;
22
23 import java.util.List;
24 import java.util.Map;
25 import java.io.IOException;
26 import javax.servlet.http.HttpServletResponse;
27 import java.util.ArrayList;
28 import java.util.LinkedHashMap;
29
30 /**
31 * @author XiangHan
32 * @date 2022-02-26
33 */
34 @Service
35 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
36 public class PvUvDayServiceImpl implements PvUvDayService {
37
38 @Autowired
39 private PvUvDayRepository PvUvDayRepository;
40
41 @Autowired
42 private PvUvDayMapper PvUvDayMapper;
43
44 @Override
45 public Map<String, Object> queryAll(PvUvDayQueryCriteria criteria, Pageable pageable) {
46 Page<PvUvDay> page = PvUvDayRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
47 return PageUtil.toPage(page.map(PvUvDayMapper::toDto));
48 }
49
50 @Override
51 public List<PvUvDayDTO> queryAll(PvUvDayQueryCriteria criteria) {
52 return PvUvDayMapper.toDto(PvUvDayRepository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
53 }
54
55 @Override
56 public PvUvDayDTO findById(Long id) {
57 PvUvDay PvUvDay = PvUvDayRepository.findById(id).orElseGet(PvUvDay::new);
58 ValidationUtil.isNull(PvUvDay.getId(),"PvUvDay","id",id);
59 return PvUvDayMapper.toDto(PvUvDay);
60 }
61
62 @Override
63 @Transactional(rollbackFor = Exception.class)
64 public void create(PvUvDay resources) {
65 PvUvDayRepository.save(resources);
66 }
67
68 @Override
69 @Transactional(rollbackFor = Exception.class)
70 public void update(PvUvDay resources) {
71 PvUvDay PvUvDay = PvUvDayRepository.findById(resources.getId()).orElseGet(PvUvDay::new);
72 ValidationUtil.isNull( PvUvDay.getId(),"PvUvDay","id",resources.getId());
73 PvUvDay.copy(resources);
74 PvUvDayRepository.save(PvUvDay);
75 }
76
77 @Override
78 @Transactional(rollbackFor = Exception.class)
79 public void delete(Long id) {
80 Assert.notNull(id, "The given id must not be null!");
81 PvUvDay PvUvDay = PvUvDayRepository.findById(id).orElseThrow(
82 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", PvUvDay.class, id), 1));
83 PvUvDayRepository.delete(PvUvDay);
84 }
85
86 @Override
87 public PvUvDay findByMarketingActivityCodeAndDay(String code, String day) {
88 PvUvDay PvUvDay = PvUvDayRepository.findByMarketingActivityCodeAndDay(code,day).orElseGet(PvUvDay::new);
89 return PvUvDay;
90 }
91
92 @Override
93 public void updateByMarketingActivityCodeAndDay(PvUvDay pvUvDay) {
94 PvUvDayRepository.updateByMarketingActivityCodeAndDay(pvUvDay);
95 }
96
97 @Override
98 public PvUvDay findByMarketingActivityIdAndDay(Long mActivityId, String day) {
99 return PvUvDayRepository.findByMarketingActivityIdAndDay(mActivityId, day).orElseGet(PvUvDay::new);
100 }
101
102
103 }
1 package com.topdraw.business.module.uv.day.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.module.uv.day.domain.PvUvDay;
5 import com.topdraw.business.module.uv.day.service.dto.PvUvDayDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2022-02-26
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface PvUvDayMapper extends BaseMapper<PvUvDayDTO, PvUvDay> {
15
16 }
1 package com.topdraw.business.module.uv.hour.domain;
2
3 import lombok.Data;
4 import lombok.experimental.Accessors;
5 import cn.hutool.core.bean.BeanUtil;
6 import cn.hutool.core.bean.copier.CopyOptions;
7 import javax.persistence.*;
8 import org.springframework.data.annotation.CreatedDate;
9 import org.springframework.data.annotation.LastModifiedDate;
10 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
11 import java.sql.Timestamp;
12
13 import java.io.Serializable;
14
15 /**
16 * @author XiangHan
17 * @date 2022-02-26
18 */
19 @Entity
20 @Data
21 @EntityListeners(AuditingEntityListener.class)
22 @Accessors(chain = true)
23 @Table(name="act_pv_uv_hour")
24 public class PvUvHour implements Serializable {
25
26 // ID
27 @Id
28 @GeneratedValue(strategy = GenerationType.IDENTITY)
29 @Column(name = "id")
30 private Long id;
31
32 // 营销活动ID
33 @Column(name = "marketing_activity_id", nullable = false)
34 private Long marketingActivityId;
35
36 // 营销活动标识
37 @Column(name = "marketing_activity_code", nullable = false)
38 private String marketingActivityCode;
39
40 // 日期
41 @Column(name = "day", nullable = false)
42 private String day;
43
44 // 小时（0-23）
45 @Column(name = "hour", nullable = false)
46 private Integer hour;
47
48 // pv值
49 @Column(name = "pv", nullable = false)
50 private Integer pv;
51
52 // uv值
53 @Column(name = "uv", nullable = false)
54 private Integer uv;
55
56 // 创建时间
57 @CreatedDate
58 @Column(name = "create_time")
59 private Timestamp createTime;
60
61 // 更新时间
62 @LastModifiedDate
63 @Column(name = "update_time")
64 private Timestamp updateTime;
65
66 public void copy(PvUvHour source){
67 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
68 }
69 }
1 package com.topdraw.business.module.uv.hour.repository;
2
3 import com.topdraw.business.module.uv.hour.domain.PvUvHour;
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6 import org.springframework.data.jpa.repository.Modifying;
7 import org.springframework.data.jpa.repository.Query;
8 import org.springframework.data.repository.query.Param;
9 import org.springframework.transaction.annotation.Transactional;
10
11 import java.util.Optional;
12
13 /**
14 * @author XiangHan
15 * @date 2022-02-26
16 */
17 public interface PvUvHourRepository extends JpaRepository<PvUvHour, Long>, JpaSpecificationExecutor<PvUvHour> {
18
19 Optional<PvUvHour> findByMarketingActivityCodeAndDayAndHour(String code, String day, int hour);
20
21 Optional<PvUvHour> findByMarketingActivityIdAndDayAndHour(Long id, String day, int hour);
22
23 @Modifying
24 @Transactional
25 @Query(value = "update act_pv_uv_hour set pv = :#{#resources.pv} , uv = :#{#resources.uv} , " +
26 "update_time = :#{#resources.updateTime} where marketing_activity_code = :#{#resources.marketingActivityCode} and " +
27 " `day` = :#{#resources.day} and `hour` = :#{#resources.hour}" , nativeQuery = true)
28 void updateByMarketingActivityCodeAndDayAndHour(@Param("resources") PvUvHour pvUvHour);
29
30 @Query(value = "select SUM(pv) pv ,SUM(uv) pv from (\n" +
31 "select pv,uv from act_pv_uv_hour where `marketing_activity_code` = ?1 and `day` = ?2 and `hour` = ?3) t " , nativeQuery = true)
32 Integer calculatePvDay(@Param("code") String code, @Param("day") String day, @Param("hour") int hour);
33 }
1 package com.topdraw.business.module.uv.hour.service;
2
3 import com.topdraw.business.module.uv.hour.domain.PvUvHour;
4 import com.topdraw.business.module.uv.hour.service.dto.PvUvHourDTO;
5 import com.topdraw.business.module.uv.hour.service.dto.PvUvHourQueryCriteria;
6 import org.springframework.data.domain.Pageable;
7 import java.util.Map;
8 import java.util.List;
9 import java.io.IOException;
10 import javax.servlet.http.HttpServletResponse;
11
12 /**
13 * @author XiangHan
14 * @date 2022-02-26
15 */
16 public interface PvUvHourService {
17
18 /**
19 * 根据ID查询
20 * @param id ID
21 * @return PvUvHourDTO
22 */
23 PvUvHourDTO findById(Long id);
24
25 void create(PvUvHour resources);
26
27 void update(PvUvHour resources);
28
29 void delete(Long id);
30
31 PvUvHour findByMarketingActivityCodeAndDayAndHour(String code, String toString, int hour);
32
33 void updateByMarketingActivityCodeAndDayAndHour(PvUvHour pvUvHour);
34
35 Integer calculatePvDay(String code, String toString, int hour);
36
37 PvUvHour findByMarketingActivityIdAndDayAndHour(Long parseLong, String toString, int hour);
38 }
1 package com.topdraw.business.module.uv.hour.service.dto;
2
3 import lombok.Data;
4 import java.sql.Timestamp;
5 import java.io.Serializable;
6
7
8 /**
9 * @author XiangHan
10 * @date 2022-02-26
11 */
12 @Data
13 public class PvUvHourDTO implements Serializable {
14
15 // ID
16 private Long id;
17
18 // 营销活动ID
19 private Long marketingActivityId;
20
21 // 营销活动标识
22 private String marketingActivityCode;
23
24 // 日期
25 private String day;
26
27 // 小时（0-23）
28 private Integer hour;
29
30 // pv值
31 private Integer pv;
32
33 // uv值
34 private Integer uv;
35
36 // 创建时间
37 private Timestamp createTime;
38
39 // 更新时间
40 private Timestamp updateTime;
41 }
1 package com.topdraw.business.module.uv.hour.service.dto;
2
3 import lombok.Data;
4 import com.topdraw.annotation.Query;
5
6 /**
7 * @author XiangHan
8 * @date 2022-02-26
9 */
10 @Data
11 public class PvUvHourQueryCriteria{
12 }
1 package com.topdraw.business.module.uv.hour.service.impl;
2
3 import com.topdraw.business.module.uv.hour.domain.PvUvHour;
4 import com.topdraw.utils.ValidationUtil;
5 import com.topdraw.utils.FileUtil;
6 import com.topdraw.business.module.uv.hour.repository.PvUvHourRepository;
7 import com.topdraw.business.module.uv.hour.service.PvUvHourService;
8 import com.topdraw.business.module.uv.hour.service.dto.PvUvHourDTO;
9 import com.topdraw.business.module.uv.hour.service.dto.PvUvHourQueryCriteria;
10 import com.topdraw.business.module.uv.hour.service.mapper.PvUvHourMapper;
11 import org.springframework.beans.factory.annotation.Autowired;
12 import org.springframework.stereotype.Service;
13 import org.springframework.transaction.annotation.Propagation;
14 import org.springframework.transaction.annotation.Transactional;
15 import org.springframework.dao.EmptyResultDataAccessException;
16 import org.springframework.data.domain.Page;
17 import org.springframework.data.domain.Pageable;
18 import org.springframework.util.Assert;
19 import com.topdraw.utils.PageUtil;
20 import com.topdraw.utils.QueryHelp;
21 import com.topdraw.utils.StringUtils;
22
23 import java.util.List;
24 import java.util.Map;
25 import java.io.IOException;
26 import javax.servlet.http.HttpServletResponse;
27 import java.util.ArrayList;
28 import java.util.LinkedHashMap;
29
30 /**
31 * @author XiangHan
32 * @date 2022-02-26
33 */
34 @Service
35 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
36 public class PvUvHourServiceImpl implements PvUvHourService {
37
38 @Autowired
39 private PvUvHourRepository PvUvHourRepository;
40
41 @Autowired
42 private PvUvHourMapper PvUvHourMapper;
43
44 @Override
45 public PvUvHourDTO findById(Long id) {
46 PvUvHour PvUvHour = PvUvHourRepository.findById(id).orElseGet(PvUvHour::new);
47 ValidationUtil.isNull(PvUvHour.getId(),"PvUvHour","id",id);
48 return PvUvHourMapper.toDto(PvUvHour);
49 }
50
51 @Override
52 @Transactional(rollbackFor = Exception.class)
53 public void create(PvUvHour resources) {
54 PvUvHourRepository.save(resources);
55 }
56
57 @Override
58 @Transactional(rollbackFor = Exception.class)
59 public void update(PvUvHour resources) {
60 PvUvHour PvUvHour = PvUvHourRepository.findById(resources.getId()).orElseGet(PvUvHour::new);
61 ValidationUtil.isNull( PvUvHour.getId(),"PvUvHour","id",resources.getId());
62 PvUvHour.copy(resources);
63 PvUvHourRepository.save(PvUvHour);
64 }
65
66 @Override
67 @Transactional(rollbackFor = Exception.class)
68 public void delete(Long id) {
69 Assert.notNull(id, "The given id must not be null!");
70 PvUvHour PvUvHour = PvUvHourRepository.findById(id).orElseThrow(
71 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", PvUvHour.class, id), 1));
72 PvUvHourRepository.delete(PvUvHour);
73 }
74
75 @Override
76 public PvUvHour findByMarketingActivityCodeAndDayAndHour(String code, String day, int hour) {
77 PvUvHour PvUvHour = PvUvHourRepository.findByMarketingActivityCodeAndDayAndHour(code,day,hour).orElseGet(PvUvHour::new);
78 return PvUvHour;
79 }
80
81 @Override
82 public void updateByMarketingActivityCodeAndDayAndHour(PvUvHour pvUvHour) {
83 PvUvHourRepository.updateByMarketingActivityCodeAndDayAndHour(pvUvHour);
84 }
85
86 @Override
87 public Integer calculatePvDay(String code, String day, int hour) {
88 Integer count = PvUvHourRepository.calculatePvDay(code,day,hour);
89 return count;
90 }
91
92 @Override
93 public PvUvHour findByMarketingActivityIdAndDayAndHour(Long mActivityId, String day, int hour) {
94 return PvUvHourRepository.findByMarketingActivityIdAndDayAndHour(mActivityId, day, hour).orElseGet(PvUvHour::new);
95 }
96
97
98 }
1 package com.topdraw.business.module.uv.hour.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import com.topdraw.business.module.uv.hour.domain.PvUvHour;
5 import com.topdraw.business.module.uv.hour.service.dto.PvUvHourDTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author XiangHan
11 * @date 2022-02-26
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface PvUvHourMapper extends BaseMapper<PvUvHourDTO, PvUvHour> {
15
16 }
1 package com.topdraw.redis.config;
2
3 import lombok.extern.slf4j.Slf4j;
4 import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
5 import org.springframework.beans.factory.annotation.Autowired;
6 import org.springframework.beans.factory.annotation.Qualifier;
7 import org.springframework.beans.factory.annotation.Value;
8 import org.springframework.boot.context.properties.ConfigurationProperties;
9 import org.springframework.context.annotation.Bean;
10 import org.springframework.context.annotation.Configuration;
11 import org.springframework.core.env.Environment;
12 import org.springframework.data.redis.connection.*;
13 import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
14 import org.springframework.data.redis.core.RedisTemplate;
15 import org.springframework.data.redis.core.StringRedisTemplate;
16 import org.springframework.util.StringUtils;
17 import redis.clients.jedis.Jedis;
18 import redis.clients.jedis.JedisPool;
19 import redis.clients.jedis.JedisPoolConfig;
20 import redis.clients.jedis.JedisSentinelPool;
21
22 import javax.annotation.Resource;
23 import java.util.HashSet;
24 import java.util.Set;
25
26 /**
27 * @author ：
28 * @description：
29 * @function :
30 * @date ：Created in 2022/2/27 10:39
31 * @version: ：
32 * @modified By：
33 * @since : modified in 2022/2/27 10:39
34 */
35 @Configuration
36 @Slf4j
37 public class MyJedisConfig {
38
39 /***生产环境要打开此配置*/
40 @Value("${spring.redis.sentinel.master}")
41 private String master;
42
43 @Value("${spring.redis.sentinel.nodes}")
44 private String sentinelHost;
45
46 @Bean
47 public Jedis jedisPool(JedisPoolConfig jedisPoolConfig) {
48 String[] split = sentinelHost.split(",");
49 Set<String> sentinels = new HashSet<>();
50 for (int i = 0; i < split.length; i++) {
51 String s = split[i];
52 sentinels.add(s);
53 }
54
55 JedisSentinelPool jedisPool = new JedisSentinelPool(master, sentinels, jedisPoolConfig);
56 Jedis jedis = jedisPool.getResource();
57 return jedis;
58 }
59
60 @Bean
61 public JedisPoolConfig jedisPoolConfig() {
62 JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
63 jedisPoolConfig.setMaxTotal(15);
64 jedisPoolConfig.setMaxIdle(10);
65 jedisPoolConfig.setMinIdle(5);
66 jedisPoolConfig.setMaxWaitMillis(10000);
67 jedisPoolConfig.setTestOnBorrow(true);
68
69 return jedisPoolConfig;
70 }
71
72 /*@Bean
73 public Jedis jedisPool(@Value("${spring.redis.host}") String host,
74 @Value("${spring.redis.port}") int port,
75 @Value("${spring.redis.timeout}") int timeout,
76 // @Value("${spring.redis.password}") String password,
77 JedisPoolConfig jedisPoolConfig) {
78
79 // JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout,"redis123");
80 JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout);
81
82 return jedisPool.getResource();
83 }*/
84 }
1 package com.topdraw.schedule;
2
3 import com.topdraw.business.process.calculate.task.ActivityBtnClickPvUcCalculateTask;
4 import lombok.extern.slf4j.Slf4j;
5 import org.springframework.beans.factory.annotation.Autowired;
6 import org.springframework.beans.factory.annotation.Value;
7 import org.springframework.scheduling.annotation.EnableScheduling;
8 import org.springframework.scheduling.annotation.Scheduled;
9 import org.springframework.stereotype.Component;
10
11 import java.time.LocalDateTime;
12
13 /**
14 * @author ：
15 * @description：
16 * @function :
17 * @date ：Created in 2022/2/26 19:44
18 * @version: ：
19 * @modified By：
20 * @since : modified in 2022/2/26 19:44
21 */
22 @Component
23 @Slf4j
24 @EnableScheduling
25 public class TransferActivityBtnClickPvUvScheduleTask {
26
27 @Autowired
28 private ActivityBtnClickPvUcCalculateTask activityBtnClickPvUcCalculateTask;
29
30 @Value("${cronActivityBtn:50 0/5 * * * ?}")
31 private String cron;
32
33 public String cron(){
34 return cron;
35 }
36
37 /**
38 * 统计订购转换数据
39 */
40 @Scheduled(cron = "#{transferActivityBtnClickPvUvScheduleTask.cron()}")
41 public void calculateSubscribe2Mysql(){
42 log.info("活动按钮点击次数统计 ===>>> 开始 !!!" + LocalDateTime.now());
43 this.activityBtnClickPvUcCalculateTask.calculateRedisData2Mysql();
44 }
45
46 }
1 package com.topdraw.schedule;
2
3 import com.topdraw.business.process.calculate.task.PvUvCalculateTask;
4 import lombok.extern.slf4j.Slf4j;
5 import org.springframework.beans.factory.annotation.Autowired;
6 import org.springframework.beans.factory.annotation.Value;
7 import org.springframework.scheduling.annotation.EnableScheduling;
8 import org.springframework.scheduling.annotation.Scheduled;
9 import org.springframework.stereotype.Component;
10
11 import java.time.LocalDateTime;
12
13 /**
14 * @author ：
15 * @description：
16 * @function :
17 * @date ：Created in 2022/2/26 19:44
18 * @version: ：
19 * @modified By：
20 * @since : modified in 2022/2/26 19:44
21 */
22 @Component
23 @Slf4j
24 @EnableScheduling
25 public class TransferScheduleTask {
26
27 @Autowired
28 private PvUvCalculateTask pvUvCalculateTask;
29
30 @Value("${cron:50 0/5 * * * ?}")
31 private String cron;
32
33 public String cron(){
34 return cron;
35 }
36
37 /**
38 * 统计pv、uv
39 */
40 @Scheduled(cron = "#{transferScheduleTask.cron()}")
41 public void calculatePvUv2Mysql(){
42 log.info("pv、uv统计 ===>>> 开始 !!!" + LocalDateTime.now());
43 this.pvUvCalculateTask.calculateRedisData2Mysql();
44 }
45
46 }
1 package com.topdraw.schedule;
2
3 import com.topdraw.business.process.calculate.task.SubscribeCalculateTask;
4 import lombok.extern.slf4j.Slf4j;
5 import org.springframework.beans.factory.annotation.Autowired;
6 import org.springframework.beans.factory.annotation.Value;
7 import org.springframework.scheduling.annotation.EnableScheduling;
8 import org.springframework.scheduling.annotation.Scheduled;
9 import org.springframework.stereotype.Component;
10
11 import java.time.LocalDateTime;
12
13 /**
14 * @author ：
15 * @description：
16 * @function :
17 * @date ：Created in 2022/2/26 19:44
18 * @version: ：
19 * @modified By：
20 * @since : modified in 2022/2/26 19:44
21 */
22 @Component
23 @Slf4j
24 @EnableScheduling
25 public class TransferSubscribeScheduleTask {
26
27 @Autowired
28 private SubscribeCalculateTask subscribeCalculateTask;
29
30 @Value("${cronSubscribe:50 0/5 * * * ?}")
31 // @Value("0/5 * * * * ?")
32 private String cron;
33
34 public String cron(){
35 return cron;
36 }
37
38 /**
39 * 统计订购转换数据
40 */
41 @Scheduled(cron = "#{transferSubscribeScheduleTask.cron()}")
42 // @Scheduled(cron = "0/5 * * * * ?")
43 public void calculateSubscribe2Mysql(){
44 log.info("订购数据统计 ===>>> 开始 !!!" + LocalDateTime.now());
45 this.subscribeCalculateTask.calculateSubscribe2Mysql();
46 }
47
48 }
1 package com.topdraw.util;
2
3 import java.sql.Timestamp;
4 import java.time.Instant;
5 import java.time.LocalDateTime;
6 import java.time.ZoneOffset;
7
8 public class TimestampUtil {
9
10 public static Timestamp now(){
11 return new Timestamp(System.currentTimeMillis());
12 }
13
14 public static Timestamp now(LocalDateTime localDateTime) {
15 long epochSecond = localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
16 return new Timestamp(epochSecond);
17 }
18
19 public static long localDateTime2long(LocalDateTime localDateTime){
20 return localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
21 }
22
23 public static Timestamp localDateTime2Timestamp(LocalDateTime localDateTime){
24 long epochSecond = localDateTime.toInstant(ZoneOffset.of("+8")).toEpochMilli();
25 return long2Timestamp(epochSecond);
26 }
27 public static Timestamp long2Timestamp(long timestamp){
28 return Timestamp.from(Instant.ofEpochMilli(timestamp));
29 }
30
31 public static long timestamp2long(Timestamp timestamp){
32 return timestamp.toInstant().toEpochMilli();
33 }
34
35 public static LocalDateTime long2LocalDateTime(Long expireTime) {
36 return LocalDateTime.ofInstant(Instant.ofEpochMilli(expireTime),ZoneOffset.of("+8"));
37 }
38
39 }
1 ___________ .___
2 \__ ___/___ ______ __| _/___________ __ _ __
3 | | / _ \\____ \ / __ |\_ __ \__ \\ \/ \/ /
4 | |( <_> ) |_> > /_/ | | | \// __ \\ /
5 |____| \____/| __/\____ | |__| (____ /\/\_/
6 |__| \/ \/
7
8 :: UserCenter :: Spring Boot - ${spring-boot.version}
1 spring:
2 # 数据源
3 datasource:
4 # 数据源地址
5 url: jdbc:log4jdbc:mysql://139.196.145.150:3306/moss_test?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false
6 # 用户名
7 username: root
8 # 密码
9 password: Tjlh@2021
10 # 驱动程序
11 driverClassName: net.sf.log4jdbc.sql.jdbcapi.DriverSpy
12 # Druid
13 type: com.alibaba.druid.pool.DruidDataSource
14 druid:
15 # 初始化配置
16 initial-size: 3
17 # 最小连接数
18 min-idle: 3
19 # 最大连接数
20 max-active: 15
21 # 获取连接超时时间
22 max-wait: 5000
23 # 连接有效性检测时间
24 time-between-eviction-runs-millis: 90000
25 # 最大空闲时间
26 min-evictable-idle-time-millis: 1800000
27 test-while-idle: true
28 test-on-borrow: false
29 test-on-return: false
30 validation-query: select 1
31 # 配置监控统计拦截的filters
32 filters: stat
33 stat-view-servlet:
34 url-pattern: /druid/*
35 reset-enable: false
36 # 过滤器
37 web-stat-filter:
38 url-pattern: /*
39 exclusions: "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*"
40 # jpa
41 jpa:
42 properties:
43 hibernate:
44 # 数据库类型
45 dialect: org.hibernate.dialect.MySQL5InnoDBDialect
46 hibernate:
47 # 生产环境设置成 none，避免程序运行时自动更新数据库结构
48 ddl-auto: none
49 open-in-view: true
50 show-sql: false
51
52 # redis
53 redis:
54 #数据库索引
55 database: 0
56 host: 122.112.214.149
57 # host: 139.196.192.242
58 port: 6379
59 #连接超时时间
60 timeout: 5000
61 password: redis123
62 #缓存过期时间
63 expire-minutes: 5
64 # sentinel:
65 # master: mymaster
66 # nodes: 122.112.214.149:6379,122.112.214.149:6379
67
1 # 服务器
2 server:
3 # 服务端口号
4 port: 8558
5
6 spring:
7 # 服务
8 application:
9 # 服务名
10 name: moss-statistic
11 # 配置文件
12 profiles:
13 # 启动具体的配置文件
14 active: dev
15
16
17 cron: "0/10 * * * * ?"
18 cronSubscribe: "* 0/60 * * * ?"
19 cronActivityBtn: "0/60 * * * * ?"
1 #数据库类型转Java类型
2 tinyint=Integer
3 smallint=Integer
4 mediumint=Integer
5 int=Integer
6 integer=Integer
7
8 bigint=Long
9
10 float=Float
11
12 double=Double
13
14 decimal=BigDecimal
15
16 bit=Boolean
17
18 char=String
19 varchar=String
20 tinytext=String
21 text=String
22 mediumtext=String
23 longtext=String
24
25 date=Timestamp
26 datetime=Timestamp
27 timestamp=Timestamp
1 # If you use SLF4J. First, you need to tell log4jdbc-log4j2 that you want to use the SLF4J logger
2 log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator
3 log4jdbc.auto.load.popular.drivers=false
4 log4jdbc.drivers=com.mysql.cj.jdbc.Driver
...\ No newline at end of file ...\ No newline at end of file
1 <?xml version="1.0" encoding="UTF-8"?>
2 <configuration scan="true" scanPeriod="60 seconds" debug="false">
3
4 <contextName>UserCenter</contextName>
5 <!--定义参数,后面可以通过${app.name}使用-->
6 <property name="app.name" value="member-engine"/>
7 <property name="log.path" value="./logs"/>
8 <property name="log.pattern" value="%d [%thread] %-5level %logger{36} [%file : %line] - %msg%n"/>
9
10 <!--输出到控制台-->
11 <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
12 <!-- encoder 默认配置为PatternLayoutEncoder -->
13 <!--定义控制台输出格式-->
14 <encoder>
15 <pattern>%black(%contextName-) %red(%d{yyyy-MM-dd HH:mm:ss}) %green([%thread]) %highlight(%-5level) %boldMagenta(%logger{36}) - %msg %n</pattern>
16 <charset>utf-8</charset>
17 </encoder>
18 </appender>
19
20 <!--获取比info级别高(包括info级别)但除error级别的日志-->
21 <appender name="info" class="ch.qos.logback.core.rolling.RollingFileAppender">
22 <filter class="ch.qos.logback.classic.filter.LevelFilter">
23 <level>ERROR</level>
24 <onMatch>DENY</onMatch>
25 <onMismatch>ACCEPT</onMismatch>
26 </filter>
27 <encoder>
28 <pattern>${log.pattern}</pattern>
29 </encoder>
30 <!--滚动策略-->
31 <file>${log.path}/${app.name}-info.log</file>
32 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
33 <!--路径-->
34 <fileNamePattern>${log.path}/info/${app.name}-%d{yyyy-MM-dd}.log</fileNamePattern>
35 <maxHistory>30</maxHistory>
36 <totalSizeCap>10GB</totalSizeCap>
37 </rollingPolicy>
38 </appender>
39
40 <appender name="error" class="ch.qos.logback.core.rolling.RollingFileAppender">
41 <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
42 <level>ERROR</level>
43 </filter>
44 <encoder>
45 <pattern>${log.pattern}</pattern>
46 </encoder>
47 <!--滚动策略-->
48 <file>${log.path}/${app.name}-error.log</file>
49 <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
50 <!--路径-->
51 <fileNamePattern>${log.path}/error/${app.name}-%d{yyyy-MM-dd}.log</fileNamePattern>
52 <maxHistory>30</maxHistory>
53 <totalSizeCap>10GB</totalSizeCap>
54 </rollingPolicy>
55 </appender>
56
57
58 <!--普通日志输出到控制台-->
59 <root level="info">
60 <appender-ref ref="console" />
61 <appender-ref ref="info" />
62 <appender-ref ref="error" />
63 </root>
64
65
66 <!--监控sql日志输出 -->
67 <logger name="jdbc.sqlonly" level="INFO" additivity="false">
68 <appender-ref ref="console" />
69 <appender-ref ref="info" />
70 </logger>
71
72 <logger name="jdbc.resultset" level="OFF" additivity="false">
73 <appender-ref ref="console" />
74 <appender-ref ref="info" />
75 </logger>
76
77 <!-- 如想看到表格数据，将OFF改为INFO -->
78 <logger name="jdbc.resultsettable" level="OFF" additivity="false">
79 <appender-ref ref="console" />
80 </logger>
81
82 <logger name="jdbc.connection" level="OFF" additivity="false">
83 <appender-ref ref="console" />
84 <appender-ref ref="info" />
85 </logger>
86
87 <logger name="jdbc.sqltiming" level="OFF" additivity="false">
88 <appender-ref ref="console" />
89 <appender-ref ref="info" />
90 </logger>
91
92 <logger name="jdbc.audit" level="OFF" additivity="false">
93 <appender-ref ref="console" />
94 <appender-ref ref="info" />
95 </logger>
96 </configuration>
1 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
2 <html xmlns="http://www.w3.org/1999/xhtml">
3 <head>
4 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
5 <style>
6 @page {
7 margin: 0;
8 }
9 </style>
10 </head>
11 <body style="margin: 0px;
12 padding: 0px;
13 font: 100% SimSun, Microsoft YaHei, Times New Roman, Verdana, Arial, Helvetica, sans-serif;
14 color: #000;">
15 <div style="height: auto;
16 width: 820px;
17 min-width: 820px;
18 margin: 0 auto;
19 margin-top: 20px;
20 border: 1px solid #eee;">
21 <div style="padding: 10px;padding-bottom: 0px;">
22 <p style="margin-bottom: 10px;padding-bottom: 0px;">尊敬的用户，您好：</p>
23 <p style="text-indent: 2em; margin-bottom: 10px;">您正在申请邮箱验证，您的验证码为：</p>
24 <p style="text-align: center;
25 font-family: Times New Roman;
26 font-size: 22px;
27 color: #C60024;
28 padding: 20px 0px;
29 margin-bottom: 10px;
30 font-weight: bold;
31 background: #ebebeb;">${code}</p>
32 <div style="list-style: none;
33 margin-top: 22px;
34 maigin-bottom: 10px;
35 font-size: 14px;
36 color: #555;">
37 <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>
38 </div>
39 <div class="foot-hr hr" style="margin: 0 auto;
40 z-index: 111;
41 width: 800px;
42 margin-top: 30px;
43 border-top: 1px solid #DA251D;">
44 </div>
45 <div style="text-align: center;
46 font-size: 12px;
47 padding: 20px 0px;
48 font-family: Microsoft YaHei;">
49 Copyright &copy;${.now?string("yyyy")} EL-ADMIN 后台管理系统 All Rights Reserved.
50 </div>
51
52 </div>
53 </div>
54 </body>
55 </html>
1 package ${package}.rest;
2
3 import com.topdraw.common.ResultInfo;
4 import com.topdraw.annotation.Log;
5 import ${package}.domain.${className};
6 import ${package}.service.${className}Service;
7 import ${package}.service.dto.${className}QueryCriteria;
8 import org.springframework.beans.factory.annotation.Autowired;
9 import org.springframework.data.domain.Pageable;
10 import org.springframework.http.HttpStatus;
11 import org.springframework.http.ResponseEntity;
12 import org.springframework.validation.annotation.Validated;
13 import org.springframework.web.bind.annotation.*;
14 import io.swagger.annotations.*;
15 import java.io.IOException;
16 import javax.servlet.http.HttpServletResponse;
17
18 /**
19 * @author ${author}
20 * @date ${date}
21 */
22 @Api(tags = "${className}管理")
23 @RestController
24 @RequestMapping("/api/${changeClassName}")
25 public class ${className}Controller {
26
27 @Autowired
28 private ${className}Service ${changeClassName}Service;
29
30 @GetMapping
31 @ApiOperation("查询${className}")
32 public ResultInfo get${className}s(${className}QueryCriteria criteria, Pageable pageable) {
33 return ResultInfo.successPage(${changeClassName}Service.queryAll(criteria,pageable));
34 }
35
36 @GetMapping(value = "/all")
37 @ApiOperation("查询所有${className}")
38 public ResultInfo get${className}s(${className}QueryCriteria criteria) {
39 return ResultInfo.success(${changeClassName}Service.queryAll(criteria));
40 }
41
42 @Log
43 @PostMapping
44 @ApiOperation("新增${className}")
45 public ResultInfo create(@Validated @RequestBody ${className} resources) {
46 ${changeClassName}Service.create(resources);
47 return ResultInfo.success();
48 }
49
50 @Log
51 @PutMapping
52 @ApiOperation("修改${className}")
53 public ResultInfo update(@Validated @RequestBody ${className} resources) {
54 ${changeClassName}Service.update(resources);
55 return ResultInfo.success();
56 }
57
58
59 @Log
60 @DeleteMapping(value = "/{${pkChangeColName}}")
61 @ApiOperation("删除${className}")
62 public ResultInfo delete(@PathVariable ${pkColumnType} ${pkChangeColName}) {
63 ${changeClassName}Service.delete(${pkChangeColName});
64 return ResultInfo.success();
65 }
66
67 <#if columns??>
68 <#list columns as column>
69 <#if column.columnName == 'code'>
70 @GetMapping(value = "/getByCode/{code}")
71 @ApiOperation(value = "根据标识查询")
72 public ResultInfo getByCode(@PathVariable String code) {
73 return ResultInfo.success(${changeClassName}Service.getByCode(code));
74 }
75 </#if>
76 </#list>
77 </#if>
78 }
1 package ${package}.service.dto;
2
3 import lombok.Data;
4 <#if hasTimestamp>
5 import java.sql.Timestamp;
6 </#if>
7 <#if hasBigDecimal>
8 import java.math.BigDecimal;
9 </#if>
10 import java.io.Serializable;
11 <#if !auto && pkColumnType = 'Long'>
12 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
13 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
14 </#if>
15
16
17 /**
18 * @author ${author}
19 * @date ${date}
20 */
21 @Data
22 public class ${className}DTO implements Serializable {
23 <#if columns??>
24 <#list columns as column>
25
26 <#if column.columnComment != ''>
27 // ${column.columnComment}
28 </#if>
29 <#if column.columnKey = 'PRI'>
30 <#if !auto && pkColumnType = 'Long'>
31 // 处理精度丢失问题
32 @JsonSerialize(using= ToStringSerializer.class)
33 </#if>
34 </#if>
35 private ${column.columnType} ${column.changeColumnName};
36 </#list>
37 </#if>
38 }
1 package ${package}.domain;
2
3 import lombok.Data;
4 import lombok.experimental.Accessors;
5 import cn.hutool.core.bean.BeanUtil;
6 import cn.hutool.core.bean.copier.CopyOptions;
7 import javax.persistence.*;
8 import org.springframework.data.annotation.CreatedDate;
9 import org.springframework.data.annotation.LastModifiedDate;
10 import org.springframework.data.jpa.domain.support.AuditingEntityListener;
11 <#if hasTimestamp>
12 import java.sql.Timestamp;
13 </#if>
14 <#if hasBigDecimal>
15 import java.math.BigDecimal;
16 </#if>
17 <#if hasCode>
18 import java.util.UUID;
19 </#if>
20
21 import java.io.Serializable;
22
23 /**
24 * @author ${author}
25 * @date ${date}
26 */
27 @Entity
28 @Data
29 @EntityListeners(AuditingEntityListener.class)
30 @Accessors(chain = true)
31 @Table(name="${tableName}")
32 public class ${className} implements Serializable {
33 <#if columns??>
34 <#list columns as column>
35
36 <#if column.columnComment != ''>
37 // ${column.columnComment}
38 </#if>
39 <#if column.columnKey = 'PRI'>
40 @Id
41 <#if auto>
42 @GeneratedValue(strategy = GenerationType.IDENTITY)
43 </#if>
44 </#if>
45 <#if column.columnName == 'create_time'>
46 @CreatedDate
47 </#if>
48 <#if column.columnName == 'update_time'>
49 @LastModifiedDate
50 </#if>
51 @Column(name = "${column.columnName}"<#if column.columnKey = 'UNI'>,unique = true</#if><#if column.isNullable = 'NO' && column.columnKey != 'PRI'>, nullable = false</#if>)
52 private ${column.columnType} ${column.changeColumnName};
53 </#list>
54 </#if>
55
56 public void copy(${className} source){
57 BeanUtil.copyProperties(source,this, CopyOptions.create().setIgnoreNullValue(true));
58 }
59 }
1 package ${package}.service.mapper;
2
3 import com.topdraw.base.BaseMapper;
4 import ${package}.domain.${className};
5 import ${package}.service.dto.${className}DTO;
6 import org.mapstruct.Mapper;
7 import org.mapstruct.ReportingPolicy;
8
9 /**
10 * @author ${author}
11 * @date ${date}
12 */
13 @Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
14 public interface ${className}Mapper extends BaseMapper<${className}DTO, ${className}> {
15
16 }
1 package ${package}.service.dto;
2
3 import lombok.Data;
4 <#if queryHasTimestamp>
5 import java.sql.Timestamp;
6 </#if>
7 <#if queryHasBigDecimal>
8 import java.math.BigDecimal;
9 </#if>
10 <#if queryColumns??>
11 import com.topdraw.annotation.Query;
12 </#if>
13
14 /**
15 * @author ${author}
16 * @date ${date}
17 */
18 @Data
19 public class ${className}QueryCriteria{
20 <#if queryColumns??>
21 <#list queryColumns as column>
22
23 <#if column.columnQuery = '1'>
24 // 模糊
25 @Query(type = Query.Type.INNER_LIKE)
26 </#if>
27 <#if column.columnQuery = '2'>
28 // 精确
29 @Query
30 </#if>
31 private ${column.columnType} ${column.changeColumnName};
32 </#list>
33 </#if>
34 }
1 package ${package}.repository;
2
3 import ${package}.domain.${className};
4 import org.springframework.data.jpa.repository.JpaRepository;
5 import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
6
7 import java.util.Optional;
8
9 /**
10 * @author ${author}
11 * @date ${date}
12 */
13 public interface ${className}Repository extends JpaRepository<${className}, ${pkColumnType}>, JpaSpecificationExecutor<${className}> {
14 <#if columns??>
15 <#list columns as column>
16 <#if column.columnKey = 'UNI'>
17
18 ${className} findBy${column.capitalColumnName}(${column.columnType} ${column.columnName});
19 </#if>
20 </#list>
21 </#if>
22
23 <#if columns??>
24 <#list columns as column>
25 <#if column.columnName == 'code'>
26 Optional<${className}> findFirstByCode(String code);
27 </#if>
28 </#list>
29 </#if>
30 }
1 package ${package}.service;
2
3 import ${package}.domain.${className};
4 import ${package}.service.dto.${className}DTO;
5 import ${package}.service.dto.${className}QueryCriteria;
6 import org.springframework.data.domain.Pageable;
7 import java.util.Map;
8 import java.util.List;
9 import java.io.IOException;
10 import javax.servlet.http.HttpServletResponse;
11
12 /**
13 * @author ${author}
14 * @date ${date}
15 */
16 public interface ${className}Service {
17
18 /**
19 * 查询数据分页
20 * @param criteria 条件参数
21 * @param pageable 分页参数
22 * @return Map<String,Object>
23 */
24 Map<String,Object> queryAll(${className}QueryCriteria criteria, Pageable pageable);
25
26 /**
27 * 查询所有数据不分页
28 * @param criteria 条件参数
29 * @return List<${className}DTO>
30 */
31 List<${className}DTO> queryAll(${className}QueryCriteria criteria);
32
33 /**
34 * 根据ID查询
35 * @param ${pkChangeColName} ID
36 * @return ${className}DTO
37 */
38 ${className}DTO findById(${pkColumnType} ${pkChangeColName});
39
40 void create(${className} resources);
41
42 void update(${className} resources);
43
44 void delete(${pkColumnType} ${pkChangeColName});
45
46 <#if columns??>
47 <#list columns as column>
48 <#if column.columnName == 'code'>
49 /**
50 * Code校验
51 * @param code
52 * @return ${className}DTO
53 */
54 ${className}DTO getByCode(String code);
55 </#if>
56 </#list>
57 </#if>
58 }
1 package ${package}.service.impl;
2
3 import ${package}.domain.${className};
4 <#if columns??>
5 <#list columns as column>
6 <#if column.columnKey = 'UNI'>
7 <#if column_index = 1>
8 import com.topdraw.exception.EntityExistException;
9 </#if>
10 </#if>
11 </#list>
12 </#if>
13 import com.topdraw.utils.ValidationUtil;
14 import com.topdraw.utils.FileUtil;
15 import ${package}.repository.${className}Repository;
16 import ${package}.service.${className}Service;
17 import ${package}.service.dto.${className}DTO;
18 import ${package}.service.dto.${className}QueryCriteria;
19 import ${package}.service.mapper.${className}Mapper;
20 import org.springframework.beans.factory.annotation.Autowired;
21 import org.springframework.stereotype.Service;
22 import org.springframework.transaction.annotation.Propagation;
23 import org.springframework.transaction.annotation.Transactional;
24 import org.springframework.dao.EmptyResultDataAccessException;
25 <#if !auto && pkColumnType = 'Long'>
26 import cn.hutool.core.lang.Snowflake;
27 import cn.hutool.core.util.IdUtil;
28 </#if>
29 <#if !auto && pkColumnType = 'String'>
30 import cn.hutool.core.util.IdUtil;
31 </#if>
32 import org.springframework.data.domain.Page;
33 import org.springframework.data.domain.Pageable;
34 import org.springframework.util.Assert;
35 import com.topdraw.utils.PageUtil;
36 import com.topdraw.utils.QueryHelp;
37 import com.topdraw.utils.StringUtils;
38
39 import java.util.List;
40 import java.util.Map;
41 import java.io.IOException;
42 import javax.servlet.http.HttpServletResponse;
43 import java.util.ArrayList;
44 import java.util.LinkedHashMap;
45
46 /**
47 * @author ${author}
48 * @date ${date}
49 */
50 @Service
51 @Transactional(propagation = Propagation.SUPPORTS, readOnly = true, rollbackFor = Exception.class)
52 public class ${className}ServiceImpl implements ${className}Service {
53
54 @Autowired
55 private ${className}Repository ${changeClassName}Repository;
56
57 @Autowired
58 private ${className}Mapper ${changeClassName}Mapper;
59
60 @Override
61 public Map<String, Object> queryAll(${className}QueryCriteria criteria, Pageable pageable) {
62 Page<${className}> page = ${changeClassName}Repository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder),pageable);
63 return PageUtil.toPage(page.map(${changeClassName}Mapper::toDto));
64 }
65
66 @Override
67 public List<${className}DTO> queryAll(${className}QueryCriteria criteria) {
68 return ${changeClassName}Mapper.toDto(${changeClassName}Repository.findAll((root, criteriaQuery, criteriaBuilder) -> QueryHelp.getPredicate(root,criteria,criteriaBuilder)));
69 }
70
71 @Override
72 public ${className}DTO findById(${pkColumnType} ${pkChangeColName}) {
73 ${className} ${changeClassName} = ${changeClassName}Repository.findById(${pkChangeColName}).orElseGet(${className}::new);
74 ValidationUtil.isNull(${changeClassName}.get${pkCapitalColName}(),"${className}","${pkChangeColName}",${pkChangeColName});
75 return ${changeClassName}Mapper.toDto(${changeClassName});
76 }
77
78 @Override
79 @Transactional(rollbackFor = Exception.class)
80 public void create(${className} resources) {
81 <#if !auto && pkColumnType = 'Long'>
82 Snowflake snowflake = IdUtil.createSnowflake(1, 1);
83 resources.set${pkCapitalColName}(snowflake.nextId());
84 </#if>
85 <#if !auto && pkColumnType = 'String'>
86 resources.set${pkCapitalColName}(IdUtil.simpleUUID());
87 </#if>
88 <#if columns??>
89 <#list columns as column>
90 <#if column.columnKey = 'UNI'>
91 if(${changeClassName}Repository.findBy${column.capitalColumnName}(resources.get${column.capitalColumnName}()) != null) {
92 throw new EntityExistException(${className}.class,"${column.columnName}",resources.get${column.capitalColumnName}());
93 }
94 </#if>
95 </#list>
96 </#if>
97 ${changeClassName}Repository.save(resources);
98 }
99
100 @Override
101 @Transactional(rollbackFor = Exception.class)
102 public void update(${className} resources) {
103 ${className} ${changeClassName} = ${changeClassName}Repository.findById(resources.get${pkCapitalColName}()).orElseGet(${className}::new);
104 ValidationUtil.isNull( ${changeClassName}.get${pkCapitalColName}(),"${className}","id",resources.get${pkCapitalColName}());
105 <#if columns??>
106 <#list columns as column>
107 <#if column.columnKey = 'UNI'>
108 <#if column_index = 1>
109 ${className} ${changeClassName}1 = null;
110 </#if>
111 ${changeClassName}1 = ${changeClassName}Repository.findBy${column.capitalColumnName}(resources.get${column.capitalColumnName}());
112 if(${changeClassName}1 != null && !${changeClassName}1.get${pkCapitalColName}().equals(${changeClassName}.get${pkCapitalColName}())){
113 throw new EntityExistException(${className}.class,"${column.columnName}",resources.get${column.capitalColumnName}());
114 }
115 </#if>
116 </#list>
117 </#if>
118 ${changeClassName}.copy(resources);
119 ${changeClassName}Repository.save(${changeClassName});
120 }
121
122 @Override
123 @Transactional(rollbackFor = Exception.class)
124 public void delete(${pkColumnType} ${pkChangeColName}) {
125 Assert.notNull(id, "The given id must not be null!");
126 ${className} ${changeClassName} = ${changeClassName}Repository.findById(id).orElseThrow(
127 () -> new EmptyResultDataAccessException(String.format("No %s entity " + "with id %s " + "exists!", ${className}.class, id), 1));
128 ${changeClassName}Repository.delete(${changeClassName});
129 }
130
131
132 <#if columns??>
133 <#list columns as column>
134 <#if column.columnName == 'code'>
135 @Override
136 public ${className}DTO getByCode(String code) {
137 return StringUtils.isNotEmpty(code) ? ${changeClassName}Mapper.toDto(${changeClassName}Repository.findFirstByCode(code).orElseGet(${className}::new))
138 : new ${className}DTO();
139 }
140 </#if>
141 </#list>
142 </#if>
143 }
1 import request from '@/utils/request'
2
3 export function add(data) {
4 return request({
5 url: 'api/${changeClassName}',
6 method: 'post',
7 data
8 })
9 }
10
11 export function del(${pkChangeColName}) {
12 return request({
13 url: 'api/${changeClassName}/' + ${pkChangeColName},
14 method: 'delete'
15 })
16 }
17
18 export function edit(data) {
19 return request({
20 url: 'api/${changeClassName}',
21 method: 'put',
22 data
23 })
24 }
25
26 export function download${className}(params) {
27 return request({
28 url: 'api/${changeClassName}/download',
29 method: 'get',
30 params,
31 responseType: 'blob'
32 })
33 }
34
35 <#if columns??>
36 <#list columns as column>
37 <#if column.columnName == 'code'>
38 export function getByCode(code) {
39 return request({
40 url: 'api/${changeClassName}/getByCode/' + code,
41 method: 'get'
42 })
43 }
44 </#if>
45 </#list>
46 </#if>
1 <template>
2 <el-dialog :append-to-body="true" :close-on-click-modal="false" :visible.sync="dialog" :title="isAdd ? '新增' : '编辑'" width="960px" @closed="doClose">
3 <el-form ref="form" :model="form" :rules="rules" size="small" label-width="80px" style="padding: 30px;margin: -20px 0">
4 <el-row>
5 <#if columns??>
6 <#list columns as column>
7 <#if column.changeColumnName != '${pkChangeColName}'>
8 <#if column.columnName != 'images' && column.columnName != 'create_time' && column.columnName != 'update_time'>
9 <el-col :span="12">
10 <el-form-item label="<#if column.columnComment != ''>${column.columnComment}<#else>${column.changeColumnName}</#if>" <#if column.isNullable =
11 'NO'>prop="${column.changeColumnName}"</#if>>
12 <#if column.columnName = 'code'>
13 <el-input v-model="form.${column.changeColumnName}" prop="code"/>
14 <#elseif column.columnType = 'Timestamp'>
15 <el-date-picker v-model="form.${column.changeColumnName}" type="datetime"/>
16 <#elseif column.columnName = 'image'>
17 <images-upload ref="upload" :limit="5" :image.sync="form.image" :images.sync="form.images" upload-entity="${changeClassName}" />
18 <#else>
19 <el-input v-model="form.${column.changeColumnName}"/>
20 </#if>
21 </el-form-item>
22 </el-col>
23 </#if>
24 </#if>
25 </#list>
26 </#if>
27 </el-row>
28 </el-form>
29 <div slot="footer" class="dialog-footer">
30 <el-button type="text" @click="cancel">取消</el-button>
31 <el-button :loading="loading" type="primary" @click="doSubmit">确认</el-button>
32 </div>
33 </el-dialog>
34 </template>
35
36 <script>
37 import { add, edit } from '@/api/${changeClassName}'
38 <#if columns??>
39 <#list columns as column>
40 <#if column.columnName == 'code'>
41 import { getByCode } from '@/api/${changeClassName}'
42 </#if>
43 </#list>
44 </#if>
45 import ImagesUpload from '@/components/ImagesUpload/index'
46 export default {
47 components: { ImagesUpload },
48 props: {
49 isAdd: {
50 type: Boolean,
51 required: true
52 },
53 dictMap: {
54 type: Object,
55 required: true
56 }
57 },
58 data() {
59 return {
60 loading: false, dialog: false,
61 form: {
62 <#if columns??>
63 <#list columns as column>
64 ${column.changeColumnName}: ''<#if column_has_next>,</#if>
65 </#list>
66 </#if>
67 },
68 rules: {
69 <#if columns??>
70 <#list columns as column>
71 <#if column.columnName == 'code'>
72 code: [
73 { required: true, message: '请输入标识', trigger: 'blur' }, { validator: this.validateCode, trigger: 'blur' }
74 ],
75 </#if>
76 </#list>
77 </#if>
78 <#function filter columns>
79 <#local result = []>
80 <#list columns as column>
81 <#if column.columnKey != 'PRI' && column.isNullable = 'NO'>
82 <#local result = result + [column]>
83 </#if>
84 </#list>
85 <#return result>
86 </#function>
87 <#assign filteredData = filter(columns)>
88 <#list filteredData as column>
89 ${column.changeColumnName}: [
90 { required: true, message: '${column.columnComment}不能为空', trigger: 'blur' }
91 ]<#sep>,</#sep>
92 </#list>
93 }
94 }
95 },
96 methods: {
97 <#if columns??>
98 <#list columns as column>
99 <#if column.columnName == 'code'>
100 validateCode(rule, value, callback) {
101 // 当为编辑状态且code未改变时不进行校验
102 if (!this.isAdd && this.form.originalCode === value) {
103 callback()
104 } else {
105 getByCode(value)
106 .then(res => {
107 typeof (res) === 'undefined' || res.id === null || this.form.id === res.id
108 ? callback()
109 : callback(new Error('该code已存在!'))
110 })
111 .catch((err) => {
112 console.log(err)
113 callback()
114 })
115 }
116 },
117 </#if>
118 </#list>
119 </#if>
120 cancel() {
121 this.dialog = false
122 },
123 doSubmit() {
124 if (this.isAdd) {
125 this.doAdd()
126 } else this.doEdit()
127 },
128 doAdd() {
129 this.$refs['form'].validate((valid) => {
130 if (valid) {
131 this.loading = true
132 add(this.form).then(() => {
133 this.$notify({
134 title: '添加成功',
135 type: 'success',
136 duration: 2500
137 })
138 this.dialog = false
139 this.loading = false
140 this.$parent.init()
141 }).catch(err => {
142 this.loading = false
143 console.log(err)
144 })
145 } else {
146 this.$notify({
147 title: '警告',
148 message: '信息不合法',
149 type: 'warning',
150 duration: 2000
151 })
152 }
153 })
154 },
155 doEdit() {
156 this.$refs['form'].validate((valid) => {
157 if (valid) {
158 this.loading = true
159 edit(this.form).then(() => {
160 this.$notify({
161 title: '修改成功',
162 type: 'success',
163 duration: 2500
164 })
165 this.loading = false
166 this.dialog = false
167 this.$parent.init()
168 }).catch(err => {
169 console.log(err)
170 this.loading = false
171 })
172 } else {
173 this.$notify({
174 title: '警告',
175 message: '信息不合法',
176 type: 'warning',
177 duration: 2000
178 })
179 }
180 })
181 },
182 doClose() {
183 this.resetForm()
184 },
185 resetForm() {
186 this.$refs['form'].resetFields()
187 this.form = {
188 <#if columns??>
189 <#list columns as column>
190 <#if column.columnName == 'code'>
191 originalCode: '',
192 </#if>
193 ${column.changeColumnName}: ''<#if column_has_next>,</#if>
194 </#list>
195 </#if>
196 }
197 }
198 }
199 }
200 </script>
201
202 <style scoped>
203
204 </style>
1 <#--noinspection ALL-->
2 <template>
3 <div class="app-container">
4 <!--工具栏-->
5 <div class="head-container">
6 <#if hasQuery>
7 <!-- 搜索 -->
8 <el-select v-model="query.type" clearable placeholder="聚合筛选条件" class="filter-item" style="width: 130px">
9 <el-option v-for="item in queryTypeOptions" :key="item.key" :label="item.display_name" :value="item.key"/>
10 </el-select>
11 <el-input v-model="query.value" clearable placeholder="输入搜索内容" style="width: 200px;" class="filter-item" @keyup.enter.native="toQuery"/>
12 <el-button class="filter-item" size="mini" type="success" icon="el-icon-search" @click="toQuery">搜索</el-button>
13 </#if>
14 <!-- 新增 -->
15 <div style="display: inline-block;margin: 0 2px;">
16 <el-button
17 v-permission="['admin','${changeClassName}:add']"
18 class="filter-item"
19 size="mini"
20 type="primary"
21 icon="el-icon-plus"
22 @click="add">新增</el-button>
23 </div>
24 </div>
25 <!--表单组件-->
26 <eForm ref="form" :is-add="isAdd" :dict-map="dictMap"/>
27 <!--表格渲染-->
28 <el-table v-loading="loading" :data="data" size="small" style="width: 100%;" @row-dblclick="edit">
29 <#if columns??>
30 <#list columns as column>
31 <#if column.columnShow = 'true'>
32 <#if column.columnType != 'Timestamp'>
33 <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>/>
34 <#else>
35 <el-table-column prop="${column.changeColumnName}" label="<#if column.columnComment != ''>${column.columnComment}<#else>${column.changeColumnName}</#if>">
36 <template slot-scope="scope">
37 <span>{{ parseTime(scope.row.${column.changeColumnName}) }}</span>
38 </template>
39 </el-table-column>
40 </#if>
41 </#if>
42 </#list>
43 </#if>
44 <el-table-column label="操作" width="120px" fixed="right" align="center">
45 <template slot-scope="scope">
46 <el-button v-permission="['admin','${changeClassName}:edit']" size="mini" type="primary" icon="el-icon-edit" @click="edit(scope.row)"/>
47 <el-popover
48 v-permission="['admin','${changeClassName}:del']"
49 :ref="scope.row.${pkChangeColName}"
50 placement="top"
51 width="180">
52 <p>确定删除本条数据吗？</p>
53 <div style="text-align: right; margin: 0">
54 <el-button size="mini" type="text" @click="$refs[scope.row.${pkChangeColName}].doClose()">取消</el-button>
55 <el-button :loading="delLoading" type="primary" size="mini" @click="subDelete(scope.row.${pkChangeColName})">确定</el-button>
56 </div>
57 <el-button slot="reference" type="danger" icon="el-icon-delete" size="mini"/>
58 </el-popover>
59 </template>
60 </el-table-column>
61 </el-table>
62 <!--分页组件-->
63 <el-pagination
64 :total="total"
65 :current-page="page + 1"
66 style="margin-top: 8px;"
67 layout="total, prev, pager, next, sizes"
68 @size-change="sizeChange"
69 @current-change="pageChange"/>
70 </div>
71 </template>
72
73 <script>
74 import initData from '@/mixins/initData'
75 import initDict from '@/mixins/initDict'
76 import { getAttrByValueFromDict } from '@/utils/common-util'
77 import { del, download${className} } from '@/api/${changeClassName}'
78 <#if hasTimestamp>
79 import { parseTime, downloadFile } from '@/utils/index'
80 </#if>
81 import eForm from './form'
82 export default {
83 components: { eForm },
84 mixins: [initData, initDict],
85 data() {
86 return {
87 delLoading: false<#if hasQuery>,</#if>
88 <#if hasQuery>
89 queryTypeOptions: [
90 <#if queryColumns??>
91 <#list queryColumns as column>
92 { key: '${column.changeColumnName}', display_name: '<#if column.columnComment != ''>${column.columnComment}<#else>${column.changeColumnName}</#if>' }<#if column_has_next>,</#if>
93 </#list>
94 </#if>
95 ]
96 </#if>
97 }
98 },
99 created() {
100 this.$nextTick(() => {
101 this.init()
102 this.getDictMap('')
103 })
104 },
105 methods: {
106 <#if hasTimestamp>
107 parseTime,
108 </#if>
109 getAttrByValueFromDict,
110 beforeInit() {
111 this.url = 'api/${changeClassName}'
112 const sort = '${pkChangeColName},desc'
113 this.params = { page: this.page, size: this.size, sort: sort }
114 <#if hasQuery>
115 const query = this.query
116 const type = query.type
117 const value = query.value
118 if (type && value) { this.params[type] = value }
119 </#if>
120 return true
121 },
122 subDelete(${pkChangeColName}) {
123 this.delLoading = true
124 del(${pkChangeColName}).then(res => {
125 this.delLoading = false
126 this.$refs[${pkChangeColName}].doClose()
127 this.dleChangePage()
128 this.init()
129 this.$notify({
130 title: '删除成功',
131 type: 'success',
132 duration: 2500
133 })
134 }).catch(err => {
135 this.delLoading = false
136 this.$refs[${pkChangeColName}].doClose()
137 console.log(err.response.data.message)
138 })
139 },
140 add() {
141 this.isAdd = true
142 this.$refs.form.dialog = true
143 },
144 edit(data) {
145 this.isAdd = false
146 const _this = this.$refs.form
147 _this.form = {
148 <#if columns??>
149 <#list columns as column>
150 <#if column.columnName == 'code'>
151 originalCode: data.code,
152 </#if>
153 ${column.changeColumnName}: data.${column.changeColumnName}<#if column_has_next>,</#if>
154 </#list>
155 </#if>
156 }
157 _this.dialog = true
158 },
159 // 导出
160 download() {
161 this.beforeInit()
162 this.downloadLoading = true
163 download${className}(this.params).then(result => {
164 downloadFile(result, '${className}列表', 'xlsx')
165 this.downloadLoading = false
166 }).catch(() => {
167 this.downloadLoading = false
168 })
169 }
170 }
171 }
172 </script>
173
174 <style scoped>
175
176 </style>