BY-Team
/
ad-callback
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

增加vpoint查询

Browse Source
master
bynt 9 months ago
parent b04cc69ec6
commit c2b2fee034
14 changed files with 188 additions and 99 deletions
Show Stats Download Patch File Download Diff File

1
src/main/java/com/baiyee/adcallback/api/dto/DmpMonitorNumDto.java
Unescape Escape View File

@ -21,6 +21,7 @@ public class DmpMonitorNumDto {
private String mail; private String mail;
private Integer vpoint;
private Integer version; private Integer version;

3
src/main/java/com/baiyee/adcallback/service/DslBaseService.java
Unescape Escape View File

@ -21,9 +21,10 @@ public interface DslBaseService {
* @param tagList tag * @param tagList tag
* @param flag num or link * @param flag num or link
* @param type * @param type
* @param vPoint
* @return * @return
*/ */
List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type); List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type, Integer vPoint);
/** /**
* 删除数据 * 删除数据

3
src/main/java/com/baiyee/adcallback/service/GdtBackDateService.java
Unescape Escape View File

@ -19,7 +19,8 @@ public interface GdtBackDateService {
* @param tagList tag * @param tagList tag
* @param flag num or link * @param flag num or link
* @param type * @param type
* @param vPoint
* @return * @return
*/ */
List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type); List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type, Integer vPoint);
} }

2
src/main/java/com/baiyee/adcallback/service/VivoBackDateService.java
Unescape Escape View File

@ -21,5 +21,5 @@ public interface VivoBackDateService {
* @param type * @param type
* @return * @return
*/ */
List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type); List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type,Integer vPoint);
} }

52
src/main/java/com/baiyee/adcallback/service/impl/BdBackDataServiceImpl.java
Unescape Escape View File

@ -3,6 +3,7 @@ package com.baiyee.adcallback.service.impl;
import cn.hutool.core.convert.Convert; import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateTime; import cn.hutool.core.date.DateTime;
import cn.hutool.core.text.CharSequenceUtil; import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baiyee.adcallback.api.constants.SqlConstant; import com.baiyee.adcallback.api.constants.SqlConstant;
import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto; import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto;
import com.baiyee.adcallback.api.vo.QueryImeiVO; import com.baiyee.adcallback.api.vo.QueryImeiVO;
@ -15,10 +16,7 @@ import com.baiyee.adcallback.service.BdBackDateService;
import com.querydsl.core.Tuple; import com.querydsl.core.Tuple;
import com.querydsl.core.types.Projections; import com.querydsl.core.types.Projections;
import com.querydsl.core.types.SubQueryExpression; import com.querydsl.core.types.SubQueryExpression;
import com.querydsl.core.types.dsl.Expressions; import com.querydsl.core.types.dsl.*;
import com.querydsl.core.types.dsl.SimpleTemplate;
import com.querydsl.core.types.dsl.StringPath;
import com.querydsl.core.types.dsl.StringTemplate;
import com.querydsl.sql.SQLExpressions; import com.querydsl.sql.SQLExpressions;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@ -38,7 +36,7 @@ public class BdBackDataServiceImpl extends AbstractService<TbBdNewBackdataEntity
QTbBdNewBackdataEntity bdNewBackdata = QTbBdNewBackdataEntity.tbBdNewBackdataEntity; QTbBdNewBackdataEntity bdNewBackdata = QTbBdNewBackdataEntity.tbBdNewBackdataEntity;
@Override @Override
public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag
(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type) { (Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type, Integer vPoint) {
Timestamp endTimeStamp = new Timestamp(endTime.getTime()); Timestamp endTimeStamp = new Timestamp(endTime.getTime());
Timestamp startTimeStamp = new Timestamp(startTime.getTime()); Timestamp startTimeStamp = new Timestamp(startTime.getTime());
return this.applyJPA(query -> { return this.applyJPA(query -> {
@ -50,26 +48,24 @@ public class BdBackDataServiceImpl extends AbstractService<TbBdNewBackdataEntity
SimpleTemplate<String> t3Imei = Expressions.template(String.class, "t3.imei"); SimpleTemplate<String> t3Imei = Expressions.template(String.class, "t3.imei");
SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid"); SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid");
SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate"); SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate");
if (type == 2) {
if (type == 2){ BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
// 封装子查询 // 封装子查询
SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
(bdNewBackdata.oaid, bdNewBackdata.tag, bdNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from (bdNewBackdata.oaid, bdNewBackdata.tag, bdNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from
(bdNewBackdata).where(bdNewBackdata.tag.in(tagList).and(bdNewBackdata.gmtCreate.gt(startTimeStamp)).and(bdNewBackdata.gmtCreate.lt(endTimeStamp)).and (bdNewBackdata).where(expression).groupBy(bdNewBackdata.oaid, bdNewBackdata.tag);
(bdNewBackdata.oaid.ne(CharSequenceUtil.EMPTY)).and(bdNewBackdata.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(bdNewBackdata.oaid.ne(DataConstant.IDFA_NUM))).groupBy(bdNewBackdata.oaid, bdNewBackdata.tag);
// 结果返回 // 结果返回
List<QueryQuantityVO> voList = query.select(Projections.bean List<QueryQuantityVO> voList = query.select(Projections.bean
(QueryQuantityVO.class, bdNewBackdata.oaid.count().as("num"), bdNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).from (QueryQuantityVO.class, bdNewBackdata.oaid.count().as("num"), bdNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).from
(bdNewBackdata).innerJoin(gmtCreate, t3).on(bdNewBackdata.oaid.eq(t3Oaid).and(bdNewBackdata.gmtCreate.eq(t3Date).and(bdNewBackdata.tag.eq(t3Tag)))).groupBy(dateExpr, bdNewBackdata.tag).fetch(); (bdNewBackdata).innerJoin(gmtCreate, t3).on(bdNewBackdata.oaid.eq(t3Oaid).and(bdNewBackdata.gmtCreate.eq(t3Date).and(bdNewBackdata.tag.eq(t3Tag)))).groupBy(dateExpr, bdNewBackdata.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, voList); return Convert.toList(DmpMonitorJpaDto.class, voList);
} }
BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
// 封装子查询 // 封装子查询
SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
(bdNewBackdata.imei, bdNewBackdata.tag, bdNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from (bdNewBackdata.imei, bdNewBackdata.tag, bdNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from
(bdNewBackdata).where(bdNewBackdata.tag.in(tagList).and(bdNewBackdata.gmtCreate.gt(startTimeStamp)).and(bdNewBackdata.gmtCreate.lt(endTimeStamp)).and (bdNewBackdata).where(expression).groupBy(bdNewBackdata.imei, bdNewBackdata.tag);
(bdNewBackdata.imei.ne(CharSequenceUtil.EMPTY)).and(bdNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(bdNewBackdata.imei.ne(DataConstant.IMEI_TAG))).groupBy(bdNewBackdata.imei, bdNewBackdata.tag);
// 结果返回 // 结果返回
List<QueryQuantityVO> voList = query.select(Projections.bean List<QueryQuantityVO> voList = query.select(Projections.bean
(QueryQuantityVO.class, bdNewBackdata.imei.count().as("num"), bdNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).from (QueryQuantityVO.class, bdNewBackdata.imei.count().as("num"), bdNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).from
@ -80,25 +76,43 @@ public class BdBackDataServiceImpl extends AbstractService<TbBdNewBackdataEntity
// 修改时间格式 // 修改时间格式
dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, bdNewBackdata.gmtCreate); dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, bdNewBackdata.gmtCreate);
if (type == 2){ if (type == 2) {
BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
List<QueryImeiVO> oaidVOList = query.select(Projections.bean List<QueryImeiVO> oaidVOList = query.select(Projections.bean
(QueryImeiVO.class, bdNewBackdata.oaid.as("imei"), bdNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(bdNewBackdata).where (QueryImeiVO.class, bdNewBackdata.oaid.as("imei"), bdNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(bdNewBackdata).where
(bdNewBackdata.tag.in(tagList).and(bdNewBackdata.gmtCreate.gt(startTimeStamp)).and(bdNewBackdata.gmtCreate.lt(endTimeStamp)).and(bdNewBackdata.oaid.ne(CharSequenceUtil.EMPTY)).and (expression).groupBy(bdNewBackdata.oaid, bdNewBackdata.tag).fetch();
(bdNewBackdata.oaid.ne(DataConstant.IDFA_NUM)).and(bdNewBackdata.oaid.ne(DataConstant.IMEI_TAG))).groupBy(bdNewBackdata.oaid, bdNewBackdata.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, oaidVOList); return Convert.toList(DmpMonitorJpaDto.class, oaidVOList);
} }
BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
List<QueryImeiVO> imeiVOList = query.select(Projections.bean List<QueryImeiVO> imeiVOList = query.select(Projections.bean
(QueryImeiVO.class, bdNewBackdata.imei, bdNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(bdNewBackdata).where (QueryImeiVO.class, bdNewBackdata.imei, bdNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(bdNewBackdata).where
(bdNewBackdata.tag.in(tagList).and(bdNewBackdata.gmtCreate.gt(startTimeStamp)).and(bdNewBackdata.gmtCreate.lt(endTimeStamp)).and(bdNewBackdata.imei.ne(CharSequenceUtil.EMPTY)).and (expression).groupBy(bdNewBackdata.imei, bdNewBackdata.tag).fetch();
(bdNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(bdNewBackdata.imei.ne(DataConstant.IMEI_TAG))).groupBy(bdNewBackdata.imei, bdNewBackdata.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, imeiVOList); return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
}); });
} }
private BooleanExpression getImeiBooleanExpression(List<String> tagList, Integer vPoint, Timestamp startTimeStamp, Timestamp endTimeStamp) {
BooleanExpression expression = bdNewBackdata.tag.in(tagList).and(bdNewBackdata.gmtCreate.gt(startTimeStamp)).and(bdNewBackdata.gmtCreate.lt(endTimeStamp)).and
(bdNewBackdata.imei.ne(CharSequenceUtil.EMPTY)).and(bdNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(bdNewBackdata.imei.ne(DataConstant.IMEI_TAG));
if (ObjectUtil.isNotNull(vPoint)){
expression = expression.and(bdNewBackdata.vpoint.eq(vPoint));
}
return expression;
}
private BooleanExpression getOaidBooleanExpression(List<String> tagList, Integer vPoint, Timestamp startTimeStamp, Timestamp endTimeStamp) {
BooleanExpression expression = bdNewBackdata.tag.in(tagList).and(bdNewBackdata.gmtCreate.gt(startTimeStamp)).and(bdNewBackdata.gmtCreate.lt(endTimeStamp)).and(bdNewBackdata.oaid.ne(CharSequenceUtil.EMPTY)).and
(bdNewBackdata.oaid.ne(DataConstant.IDFA_NUM)).and(bdNewBackdata.oaid.ne(DataConstant.IMEI_TAG));
if (ObjectUtil.isNotNull(vPoint)){
expression = expression.and(bdNewBackdata.vpoint.eq(vPoint));
}
return expression;
}
@Override @Override
public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) { public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) {
Timestamp timestamp = new Timestamp(date.getTime()); Timestamp timestamp = new Timestamp(date.getTime());
return this.newQuery().delete(bdNewBackdata).where(bdNewBackdata.gmtCreate.lt(timestamp)).execute(); return this.newQuery().delete(bdNewBackdata).where(bdNewBackdata.gmtCreate.gt(timestamp)).execute();
} }
@Override @Override

15
src/main/java/com/baiyee/adcallback/service/impl/DmpMonitorV2ServiceImpl.java
Unescape Escape View File

@ -77,6 +77,7 @@ public class DmpMonitorV2ServiceImpl implements DmpMonitorV2Service {
Map<Integer, List<String>> talbeMap = Maps.newHashMap(); Map<Integer, List<String>> talbeMap = Maps.newHashMap();
List<DmpMonitorJpaDto> voList = Lists.newArrayList(); List<DmpMonitorJpaDto> voList = Lists.newArrayList();
Integer type = dmpMonitorNumDto.getQueryType(); Integer type = dmpMonitorNumDto.getQueryType();
Integer vPoint = dmpMonitorNumDto.getVpoint();
Date endTime = dmpMonitorNumDto.getEndTime(); Date endTime = dmpMonitorNumDto.getEndTime();
Date startTime = dmpMonitorNumDto.getStartTime(); Date startTime = dmpMonitorNumDto.getStartTime();
for (String tag : dmpMonitorNumDto.getTags()) { for (String tag : dmpMonitorNumDto.getTags()) {
@ -100,31 +101,31 @@ public class DmpMonitorV2ServiceImpl implements DmpMonitorV2Service {
List<String> tagList = entry.getValue(); List<String> tagList = entry.getValue();
switch (index) { switch (index) {
case 1: case 1:
voList.addAll(jlV1BackDataService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type)); voList.addAll(jlV1BackDataService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type,vPoint));
break; break;
case 7: case 7:
// v2 // v2
voList.addAll(jlV2BackDataService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type)); voList.addAll(jlV2BackDataService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type,vPoint));
break; break;
case 2: case 2:
// 快手 // 快手
voList.addAll(ksBackDateService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type)); voList.addAll(ksBackDateService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type,vPoint));
break; break;
case 3: case 3:
// UC // UC
voList.addAll(ucBackDateService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type)); voList.addAll(ucBackDateService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type,vPoint));
break; break;
case 4: case 4:
// VIVO // VIVO
voList.addAll(vivoBackDateService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type)); voList.addAll(vivoBackDateService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type,vPoint));
break; break;
case 5: case 5:
//百度 //百度
voList.addAll(bdBackDateService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type)); voList.addAll(bdBackDateService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type,vPoint));
break; break;
case 6: case 6:
//广点通 //广点通
voList.addAll(gdtBackDateService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type)); voList.addAll(gdtBackDateService.queryByTagAndTimeAndFlag(startTime, endTime, tagList, flag, type, vPoint));
break; break;
default: default:
break; break;

57
src/main/java/com/baiyee/adcallback/service/impl/GdtBackDataServiceImpl.java
Unescape Escape View File

@ -2,6 +2,7 @@ package com.baiyee.adcallback.service.impl;
import cn.hutool.core.convert.Convert; import cn.hutool.core.convert.Convert;
import cn.hutool.core.text.CharSequenceUtil; import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baiyee.adcallback.api.constants.SqlConstant; import com.baiyee.adcallback.api.constants.SqlConstant;
import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto; import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto;
import com.baiyee.adcallback.api.vo.QueryImeiVO; import com.baiyee.adcallback.api.vo.QueryImeiVO;
@ -14,14 +15,12 @@ import com.baiyee.adcallback.service.GdtBackDateService;
import com.querydsl.core.Tuple; import com.querydsl.core.Tuple;
import com.querydsl.core.types.Projections; import com.querydsl.core.types.Projections;
import com.querydsl.core.types.SubQueryExpression; import com.querydsl.core.types.SubQueryExpression;
import com.querydsl.core.types.dsl.Expressions; import com.querydsl.core.types.dsl.*;
import com.querydsl.core.types.dsl.SimpleTemplate;
import com.querydsl.core.types.dsl.StringPath;
import com.querydsl.core.types.dsl.StringTemplate;
import com.querydsl.sql.SQLExpressions; import com.querydsl.sql.SQLExpressions;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.sql.Timestamp;
import java.util.Date; import java.util.Date;
import java.util.List; import java.util.List;
@ -32,16 +31,18 @@ import java.util.List;
@Service @Service
@RequiredArgsConstructor @RequiredArgsConstructor
public class GdtBackDataServiceImpl extends AbstractService<TbGdtNewBackdataEntity,Long> implements GdtBackDateService { public class GdtBackDataServiceImpl extends AbstractService<TbGdtNewBackdataEntity, Long> implements GdtBackDateService {
QTbGdtNewBackdataEntity gdtNewBackdata = QTbGdtNewBackdataEntity.tbGdtNewBackdataEntity;
@Override @Override
public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag
(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type) { (Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type, Integer vPoint) {
Timestamp endTimeStamp = new Timestamp(endTime.getTime());
Timestamp startTimeStamp = new Timestamp(startTime.getTime());
return this.applyJPA(query -> { return this.applyJPA(query -> {
StringPath t3 = Expressions.stringPath("t3"); StringPath t3 = Expressions.stringPath("t3");
StringTemplate dateExpr; StringTemplate dateExpr;
QTbGdtNewBackdataEntity gdtNewBackdata = QTbGdtNewBackdataEntity.tbGdtNewBackdataEntity;
if (flag == 1) { if (flag == 1) {
dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR, gdtNewBackdata.gmtCreate); dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR, gdtNewBackdata.gmtCreate);
SimpleTemplate<String> t3Tag = Expressions.template(String.class, "t3.tag"); SimpleTemplate<String> t3Tag = Expressions.template(String.class, "t3.tag");
@ -49,13 +50,12 @@ public class GdtBackDataServiceImpl extends AbstractService<TbGdtNewBackdataEnti
SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid"); SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid");
SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate"); SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate");
if (type == 2) {
if (type == 2){ BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
// 封装子查询 // 封装子查询
SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
(gdtNewBackdata.oaid, gdtNewBackdata.tag,gdtNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from (gdtNewBackdata.oaid, gdtNewBackdata.tag, gdtNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from
(gdtNewBackdata).where(gdtNewBackdata.tag.in(tagList).and(gdtNewBackdata.oaid.ne(CharSequenceUtil.EMPTY).and (gdtNewBackdata).where(expression).groupBy(gdtNewBackdata.oaid, gdtNewBackdata.tag);
(gdtNewBackdata.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(gdtNewBackdata.oaid.ne(DataConstant.IMEI_TAG)))).groupBy(gdtNewBackdata.oaid,gdtNewBackdata.tag);
// 结果返回 // 结果返回
List<QueryQuantityVO> voList = query.select(Projections.bean List<QueryQuantityVO> voList = query.select(Projections.bean
@ -63,11 +63,11 @@ public class GdtBackDataServiceImpl extends AbstractService<TbGdtNewBackdataEnti
(gdtNewBackdata).innerJoin(gmtCreate, t3).on(gdtNewBackdata.oaid.eq(t3Oaid).and(gdtNewBackdata.gmtCreate.eq(t3Date).and(gdtNewBackdata.tag.eq(t3Tag)))).groupBy(dateExpr, gdtNewBackdata.tag).fetch(); (gdtNewBackdata).innerJoin(gmtCreate, t3).on(gdtNewBackdata.oaid.eq(t3Oaid).and(gdtNewBackdata.gmtCreate.eq(t3Date).and(gdtNewBackdata.tag.eq(t3Tag)))).groupBy(dateExpr, gdtNewBackdata.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, voList); return Convert.toList(DmpMonitorJpaDto.class, voList);
} }
BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
// 封装子查询 // 封装子查询
SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
(gdtNewBackdata.imei, gdtNewBackdata.tag,gdtNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from (gdtNewBackdata.imei, gdtNewBackdata.tag, gdtNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from
(gdtNewBackdata).where(gdtNewBackdata.tag.in(tagList).and(gdtNewBackdata.imei.ne(CharSequenceUtil.EMPTY).and (gdtNewBackdata).where(expression).groupBy(gdtNewBackdata.imei, gdtNewBackdata.tag);
(gdtNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(gdtNewBackdata.imei.ne(DataConstant.IMEI_TAG)))).groupBy(gdtNewBackdata.imei,gdtNewBackdata.tag);
// 结果返回 // 结果返回
List<QueryQuantityVO> voList = query.select(Projections.bean List<QueryQuantityVO> voList = query.select(Projections.bean
@ -80,17 +80,36 @@ public class GdtBackDataServiceImpl extends AbstractService<TbGdtNewBackdataEnti
dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, gdtNewBackdata.gmtCreate); dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, gdtNewBackdata.gmtCreate);
if (type == 2) { if (type == 2) {
BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
List<QueryImeiVO> imeiVOList = query.select(Projections.bean List<QueryImeiVO> imeiVOList = query.select(Projections.bean
(QueryImeiVO.class, gdtNewBackdata.oaid.as("imei"), gdtNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(gdtNewBackdata).where (QueryImeiVO.class, gdtNewBackdata.oaid.as("imei"), gdtNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(gdtNewBackdata).where
(gdtNewBackdata.tag.in(tagList).and(gdtNewBackdata.oaid.ne(CharSequenceUtil.EMPTY).and(gdtNewBackdata.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(gdtNewBackdata.oaid.ne (expression).groupBy(gdtNewBackdata.oaid, gdtNewBackdata.tag).fetch();
(DataConstant.IDFA_NUM)))).groupBy(gdtNewBackdata.oaid,gdtNewBackdata.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, imeiVOList); return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
} }
BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
List<QueryImeiVO> imeiVOList = query.select(Projections.bean List<QueryImeiVO> imeiVOList = query.select(Projections.bean
(QueryImeiVO.class, gdtNewBackdata.imei, gdtNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(gdtNewBackdata).where (QueryImeiVO.class, gdtNewBackdata.imei, gdtNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(gdtNewBackdata).where
(gdtNewBackdata.tag.in(tagList).and(gdtNewBackdata.imei.ne(CharSequenceUtil.EMPTY).and(gdtNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(gdtNewBackdata.imei.ne (expression).groupBy(gdtNewBackdata.imei, gdtNewBackdata.tag).fetch();
(DataConstant.IMEI_TAG)))).groupBy(gdtNewBackdata.imei,gdtNewBackdata.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, imeiVOList); return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
}); });
} }
private BooleanExpression getImeiBooleanExpression(List<String> tagList, Integer vPoint, Timestamp startTimeStamp, Timestamp endTimeStamp) {
BooleanExpression expression = gdtNewBackdata.tag.in(tagList).and(gdtNewBackdata.gmtCreate.gt(startTimeStamp)).and(gdtNewBackdata.gmtCreate.lt(endTimeStamp)).and
(gdtNewBackdata.imei.ne(CharSequenceUtil.EMPTY)).and(gdtNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(gdtNewBackdata.imei.ne(DataConstant.IMEI_TAG));
if (ObjectUtil.isNotNull(vPoint)) {
expression = expression.and(gdtNewBackdata.vpoint.eq(vPoint));
}
return expression;
}
private BooleanExpression getOaidBooleanExpression(List<String> tagList, Integer vPoint, Timestamp startTimeStamp, Timestamp endTimeStamp) {
BooleanExpression expression = gdtNewBackdata.tag.in(tagList).and(gdtNewBackdata.gmtCreate.gt(startTimeStamp)).and(gdtNewBackdata.gmtCreate.lt(endTimeStamp)).and(gdtNewBackdata.oaid.ne(CharSequenceUtil.EMPTY)).and
(gdtNewBackdata.oaid.ne(DataConstant.IDFA_NUM)).and(gdtNewBackdata.oaid.ne(DataConstant.IMEI_TAG));
if (ObjectUtil.isNotNull(vPoint)) {
expression = expression.and(gdtNewBackdata.vpoint.eq(vPoint));
}
return expression;
}
} }

47
src/main/java/com/baiyee/adcallback/service/impl/JlV1BackDataServiceImpl.java
Unescape Escape View File

@ -3,6 +3,7 @@ package com.baiyee.adcallback.service.impl;
import cn.hutool.core.convert.Convert; import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateTime; import cn.hutool.core.date.DateTime;
import cn.hutool.core.text.CharSequenceUtil; import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baiyee.adcallback.api.constants.SqlConstant; import com.baiyee.adcallback.api.constants.SqlConstant;
import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto; import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto;
import com.baiyee.adcallback.api.vo.QueryImeiVO; import com.baiyee.adcallback.api.vo.QueryImeiVO;
@ -15,10 +16,7 @@ import com.baiyee.adcallback.service.JlV1BackDataService;
import com.querydsl.core.Tuple; import com.querydsl.core.Tuple;
import com.querydsl.core.types.Projections; import com.querydsl.core.types.Projections;
import com.querydsl.core.types.SubQueryExpression; import com.querydsl.core.types.SubQueryExpression;
import com.querydsl.core.types.dsl.Expressions; import com.querydsl.core.types.dsl.*;
import com.querydsl.core.types.dsl.SimpleTemplate;
import com.querydsl.core.types.dsl.StringPath;
import com.querydsl.core.types.dsl.StringTemplate;
import com.querydsl.sql.SQLExpressions; import com.querydsl.sql.SQLExpressions;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@ -38,7 +36,7 @@ public class JlV1BackDataServiceImpl extends AbstractService<TbJLBackDataV1Entit
@Override @Override
public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag
(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type) { (Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type, Integer vPoint) {
return this.applyJPA(query -> { return this.applyJPA(query -> {
StringTemplate dateExpr; StringTemplate dateExpr;
StringPath t3 = Expressions.stringPath("t3"); StringPath t3 = Expressions.stringPath("t3");
@ -49,12 +47,12 @@ public class JlV1BackDataServiceImpl extends AbstractService<TbJLBackDataV1Entit
SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid"); SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid");
SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate"); SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate");
if (type == 2){ if (type == 2) {
BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTime, endTime);
// 封装子查询 // 封装子查询
SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
(v1Entity.oaid, v1Entity.tag, v1Entity.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from (v1Entity.oaid, v1Entity.tag, v1Entity.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from
(v1Entity).where(v1Entity.tag.in(tagList).and(v1Entity.gmtCreate.gt(startTime)).and(v1Entity.gmtCreate.lt(endTime)).and (v1Entity).where(expression).groupBy(v1Entity.oaid, v1Entity.tag);
(v1Entity.oaid.ne(CharSequenceUtil.EMPTY)).and(v1Entity.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(v1Entity.oaid.ne(DataConstant.IDFA_NUM))).groupBy(v1Entity.oaid, v1Entity.tag);
// 结果返回 // 结果返回
List<QueryQuantityVO> voList = query.select(Projections.bean List<QueryQuantityVO> voList = query.select(Projections.bean
@ -63,11 +61,11 @@ public class JlV1BackDataServiceImpl extends AbstractService<TbJLBackDataV1Entit
return Convert.toList(DmpMonitorJpaDto.class, voList); return Convert.toList(DmpMonitorJpaDto.class, voList);
} }
BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTime, endTime);
// 封装子查询 // 封装子查询
SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
(v1Entity.imei, v1Entity.tag, v1Entity.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from (v1Entity.imei, v1Entity.tag, v1Entity.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from
(v1Entity).where(v1Entity.tag.in(tagList).and(v1Entity.gmtCreate.gt(startTime)).and(v1Entity.gmtCreate.lt(endTime)).and (v1Entity).where(expression).groupBy(v1Entity.imei, v1Entity.tag);
(v1Entity.imei.ne(CharSequenceUtil.EMPTY)).and(v1Entity.imei.ne(DataConstant.IMEI_NULL_TAG)).and(v1Entity.imei.ne(DataConstant.IMEI_TAG))).groupBy(v1Entity.imei, v1Entity.tag);
// 结果返回 // 结果返回
List<QueryQuantityVO> voList = query.select(Projections.bean List<QueryQuantityVO> voList = query.select(Projections.bean
@ -78,22 +76,41 @@ public class JlV1BackDataServiceImpl extends AbstractService<TbJLBackDataV1Entit
// 修改时间格式 // 修改时间格式
dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, v1Entity.gmtCreate); dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, v1Entity.gmtCreate);
if (type == 2){ if (type == 2) {
BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTime, endTime);
List<QueryImeiVO> imeiVOList = query.select(Projections.bean List<QueryImeiVO> imeiVOList = query.select(Projections.bean
(QueryImeiVO.class, v1Entity.oaid.as("imei"), v1Entity.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(v1Entity).where (QueryImeiVO.class, v1Entity.oaid.as("imei"), v1Entity.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(v1Entity).where
(v1Entity.tag.in(tagList).and(v1Entity.gmtCreate.gt(startTime)).and(v1Entity.gmtCreate.lt(endTime)).and(v1Entity.oaid.ne(CharSequenceUtil.EMPTY)).and (expression).groupBy(v1Entity.oaid, v1Entity.tag).fetch();
(v1Entity.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(v1Entity.oaid.ne(DataConstant.IDFA_NUM))).groupBy(v1Entity.oaid, v1Entity.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, imeiVOList); return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
} }
BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTime, endTime);
List<QueryImeiVO> imeiVOList = query.select(Projections.bean List<QueryImeiVO> imeiVOList = query.select(Projections.bean
(QueryImeiVO.class, v1Entity.imei, v1Entity.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(v1Entity).where (QueryImeiVO.class, v1Entity.imei, v1Entity.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(v1Entity).where
(v1Entity.tag.in(tagList).and(v1Entity.gmtCreate.gt(startTime)).and(v1Entity.gmtCreate.lt(endTime)).and(v1Entity.imei.ne(CharSequenceUtil.EMPTY)).and (expression).groupBy(v1Entity.imei, v1Entity.tag).fetch();
(v1Entity.imei.ne(DataConstant.IMEI_NULL_TAG)).and(v1Entity.imei.ne(DataConstant.IMEI_TAG))).groupBy(v1Entity.imei, v1Entity.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, imeiVOList); return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
}); });
} }
private BooleanExpression getImeiBooleanExpression(List<String> tagList, Integer vPoint, Date startTimeStamp, Date endTimeStamp) {
BooleanExpression expression = v1Entity.tag.in(tagList).and(v1Entity.gmtCreate.gt(startTimeStamp)).and(v1Entity.gmtCreate.lt(endTimeStamp)).and
(v1Entity.imei.ne(CharSequenceUtil.EMPTY)).and(v1Entity.imei.ne(DataConstant.IMEI_NULL_TAG)).and(v1Entity.imei.ne(DataConstant.IMEI_TAG));
if (ObjectUtil.isNotNull(vPoint)) {
expression = expression.and(v1Entity.vpoint.eq(vPoint));
}
return expression;
}
private BooleanExpression getOaidBooleanExpression(List<String> tagList, Integer vPoint, Date startTimeStamp, Date endTimeStamp) {
BooleanExpression expression = v1Entity.tag.in(tagList).and(v1Entity.gmtCreate.gt(startTimeStamp)).and(v1Entity.gmtCreate.lt(endTimeStamp)).and(v1Entity.oaid.ne(CharSequenceUtil.EMPTY)).and
(v1Entity.oaid.ne(DataConstant.IDFA_NUM)).and(v1Entity.oaid.ne(DataConstant.IMEI_TAG));
if (ObjectUtil.isNotNull(vPoint)) {
expression = expression.and(v1Entity.vpoint.eq(vPoint));
}
return expression;
}
@Override @Override
public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) { public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) {
return this.newQuery().delete(v1Entity).where(v1Entity.gmtCreate.lt(date)).execute(); return this.newQuery().delete(v1Entity).where(v1Entity.gmtCreate.lt(date)).execute();

47
src/main/java/com/baiyee/adcallback/service/impl/JlV2BackDataServiceImpl.java
Unescape Escape View File

@ -1,8 +1,10 @@
package com.baiyee.adcallback.service.impl; package com.baiyee.adcallback.service.impl;
import cn.hutool.core.codec.Base64;
import cn.hutool.core.convert.Convert; import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateTime; import cn.hutool.core.date.DateTime;
import cn.hutool.core.text.CharSequenceUtil; import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baiyee.adcallback.api.constants.SqlConstant; import com.baiyee.adcallback.api.constants.SqlConstant;
import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto; import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto;
import com.baiyee.adcallback.api.vo.QueryImeiVO; import com.baiyee.adcallback.api.vo.QueryImeiVO;
@ -15,10 +17,7 @@ import com.baiyee.adcallback.service.JlV2BackDataService;
import com.querydsl.core.Tuple; import com.querydsl.core.Tuple;
import com.querydsl.core.types.Projections; import com.querydsl.core.types.Projections;
import com.querydsl.core.types.SubQueryExpression; import com.querydsl.core.types.SubQueryExpression;
import com.querydsl.core.types.dsl.Expressions; import com.querydsl.core.types.dsl.*;
import com.querydsl.core.types.dsl.SimpleTemplate;
import com.querydsl.core.types.dsl.StringPath;
import com.querydsl.core.types.dsl.StringTemplate;
import com.querydsl.sql.SQLExpressions; import com.querydsl.sql.SQLExpressions;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@ -36,7 +35,7 @@ public class JlV2BackDataServiceImpl extends AbstractService<TbJLBackDataV2Entit
QTbJLBackDataV2Entity v2Entity = QTbJLBackDataV2Entity.tbJLBackDataV2Entity; QTbJLBackDataV2Entity v2Entity = QTbJLBackDataV2Entity.tbJLBackDataV2Entity;
@Override @Override
public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag
(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type) { (Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type, Integer vPoint) {
return this.applyJPA(query -> { return this.applyJPA(query -> {
StringTemplate dateExpr; StringTemplate dateExpr;
StringPath t3 = Expressions.stringPath("t3"); StringPath t3 = Expressions.stringPath("t3");
@ -47,24 +46,23 @@ public class JlV2BackDataServiceImpl extends AbstractService<TbJLBackDataV2Entit
SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid"); SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid");
SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate"); SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate");
if (type == 2) {
if (type == 2){ BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTime, endTime);
// 封装子查询 // 封装子查询
SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
(v2Entity.oaid, v2Entity.tag, v2Entity.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from (v2Entity.oaid, v2Entity.tag, v2Entity.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from
(v2Entity).where(v2Entity.tag.in(tagList).and(v2Entity.gmtCreate.gt(startTime)).and(v2Entity.gmtCreate.lt(endTime)).and (v2Entity).where(expression).groupBy(v2Entity.oaid, v2Entity.tag);
(v2Entity.oaid.ne(CharSequenceUtil.EMPTY)).and(v2Entity.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(v2Entity.oaid.ne(DataConstant.IDFA_NUM))).groupBy(v2Entity.oaid, v2Entity.tag);
// 结果返回 // 结果返回
List<QueryQuantityVO> voList = query.select(Projections.bean List<QueryQuantityVO> voList = query.select(Projections.bean
(QueryQuantityVO.class, v2Entity.oaid.count().as("num"), v2Entity.tag, dateExpr.as(SqlConstant.CREATE_TIME))).from (QueryQuantityVO.class, v2Entity.oaid.count().as("num"), v2Entity.tag, dateExpr.as(SqlConstant.CREATE_TIME))).from
(v2Entity).innerJoin(gmtCreate, t3).on(v2Entity.oaid.eq(t3Oaid).and(v2Entity.gmtCreate.eq(t3Date).and(v2Entity.tag.eq(t3Tag)))).groupBy(dateExpr, v2Entity.tag).fetch(); (v2Entity).innerJoin(gmtCreate, t3).on(v2Entity.oaid.eq(t3Oaid).and(v2Entity.gmtCreate.eq(t3Date).and(v2Entity.tag.eq(t3Tag)))).groupBy(dateExpr, v2Entity.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, voList); return Convert.toList(DmpMonitorJpaDto.class, voList);
} }
BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTime, endTime);
// 封装子查询 // 封装子查询
SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
(v2Entity.imei, v2Entity.tag, v2Entity.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from (v2Entity.imei, v2Entity.tag, v2Entity.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from
(v2Entity).where(v2Entity.tag.in(tagList).and(v2Entity.gmtCreate.gt(startTime)).and(v2Entity.gmtCreate.lt(endTime)).and (v2Entity).where(expression).groupBy(v2Entity.imei, v2Entity.tag);
(v2Entity.imei.ne(CharSequenceUtil.EMPTY)).and(v2Entity.imei.ne(DataConstant.IMEI_NULL_TAG)).and(v2Entity.imei.ne(DataConstant.IMEI_TAG))).groupBy(v2Entity.imei, v2Entity.tag);
// 结果返回 // 结果返回
List<QueryQuantityVO> voList = query.select(Projections.bean List<QueryQuantityVO> voList = query.select(Projections.bean
@ -77,20 +75,39 @@ public class JlV2BackDataServiceImpl extends AbstractService<TbJLBackDataV2Entit
dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, v2Entity.gmtCreate); dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, v2Entity.gmtCreate);
if (type == 2){ if (type == 2){
BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTime, endTime);
List<QueryImeiVO> imeiVOList = query.select(Projections.bean List<QueryImeiVO> imeiVOList = query.select(Projections.bean
(QueryImeiVO.class, v2Entity.oaid.as("imei"), v2Entity.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(v2Entity).where (QueryImeiVO.class, v2Entity.oaid.as("imei"), v2Entity.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(v2Entity).where
(v2Entity.tag.in(tagList).and(v2Entity.gmtCreate.gt(startTime)).and(v2Entity.gmtCreate.lt(endTime)).and(v2Entity.oaid.ne(CharSequenceUtil.EMPTY)).and (expression).groupBy(v2Entity.oaid, v2Entity.tag).fetch();
(v2Entity.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(v2Entity.oaid.ne(DataConstant.IDFA_NUM))).groupBy(v2Entity.oaid, v2Entity.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, imeiVOList); return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
} }
BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTime, endTime);
List<QueryImeiVO> imeiVOList = query.select(Projections.bean List<QueryImeiVO> imeiVOList = query.select(Projections.bean
(QueryImeiVO.class, v2Entity.imei, v2Entity.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(v2Entity).where (QueryImeiVO.class, v2Entity.imei, v2Entity.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(v2Entity).where
(v2Entity.tag.in(tagList).and(v2Entity.gmtCreate.gt(startTime)).and(v2Entity.gmtCreate.lt(endTime)).and(v2Entity.imei.ne(CharSequenceUtil.EMPTY)).and (expression).groupBy(v2Entity.imei, v2Entity.tag).fetch();
(v2Entity.imei.ne(DataConstant.IMEI_NULL_TAG)).and(v2Entity.imei.ne(DataConstant.IMEI_TAG))).groupBy(v2Entity.imei, v2Entity.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, imeiVOList); return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
}); });
} }
private BooleanExpression getImeiBooleanExpression(List<String> tagList, Integer vPoint, Date startTimeStamp, Date endTimeStamp) {
BooleanExpression expression = v2Entity.tag.in(tagList).and(v2Entity.gmtCreate.gt(startTimeStamp)).and(v2Entity.gmtCreate.lt(endTimeStamp)).and
(v2Entity.imei.ne(CharSequenceUtil.EMPTY)).and(v2Entity.imei.ne(DataConstant.IMEI_NULL_TAG)).and(v2Entity.imei.ne(DataConstant.IMEI_TAG));
if (ObjectUtil.isNotNull(vPoint)) {
expression = expression.and(v2Entity.vpoint.eq(vPoint));
}
return expression;
}
private BooleanExpression getOaidBooleanExpression(List<String> tagList, Integer vPoint, Date startTimeStamp, Date endTimeStamp) {
BooleanExpression expression = v2Entity.tag.in(tagList).and(v2Entity.gmtCreate.gt(startTimeStamp)).and(v2Entity.gmtCreate.lt(endTimeStamp)).and(v2Entity.oaid.ne(CharSequenceUtil.EMPTY)).and
(v2Entity.oaid.ne(DataConstant.IDFA_NUM)).and(v2Entity.oaid.ne(DataConstant.IMEI_TAG));
if (ObjectUtil.isNotNull(vPoint)) {
expression = expression.and(v2Entity.vpoint.eq(vPoint));
}
return expression;
}
@Override @Override
public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) { public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) {
return this.newQuery().delete(v2Entity).where(v2Entity.gmtCreate.lt(date)).execute(); return this.newQuery().delete(v2Entity).where(v2Entity.gmtCreate.lt(date)).execute();

45
src/main/java/com/baiyee/adcallback/service/impl/KsBackDataServiceImpl.java
Unescape Escape View File

@ -3,6 +3,7 @@ package com.baiyee.adcallback.service.impl;
import cn.hutool.core.convert.Convert; import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateTime; import cn.hutool.core.date.DateTime;
import cn.hutool.core.text.CharSequenceUtil; import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baiyee.adcallback.api.constants.SqlConstant; import com.baiyee.adcallback.api.constants.SqlConstant;
import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto; import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto;
import com.baiyee.adcallback.api.vo.QueryImeiVO; import com.baiyee.adcallback.api.vo.QueryImeiVO;
@ -15,10 +16,7 @@ import com.baiyee.adcallback.service.KsBackDateService;
import com.querydsl.core.Tuple; import com.querydsl.core.Tuple;
import com.querydsl.core.types.Projections; import com.querydsl.core.types.Projections;
import com.querydsl.core.types.SubQueryExpression; import com.querydsl.core.types.SubQueryExpression;
import com.querydsl.core.types.dsl.Expressions; import com.querydsl.core.types.dsl.*;
import com.querydsl.core.types.dsl.SimpleTemplate;
import com.querydsl.core.types.dsl.StringPath;
import com.querydsl.core.types.dsl.StringTemplate;
import com.querydsl.sql.SQLExpressions; import com.querydsl.sql.SQLExpressions;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@ -38,7 +36,7 @@ public class KsBackDataServiceImpl extends AbstractService<TbKSNewBackdataEntity
QTbKSNewBackdataEntity ksNewBackdata = QTbKSNewBackdataEntity.tbKSNewBackdataEntity; QTbKSNewBackdataEntity ksNewBackdata = QTbKSNewBackdataEntity.tbKSNewBackdataEntity;
@Override @Override
public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag
(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type) { (Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type, Integer vPoint) {
Timestamp endTimeStamp = new Timestamp(endTime.getTime()); Timestamp endTimeStamp = new Timestamp(endTime.getTime());
Timestamp startTimeStamp = new Timestamp(startTime.getTime()); Timestamp startTimeStamp = new Timestamp(startTime.getTime());
return this.applyJPA(query -> { return this.applyJPA(query -> {
@ -52,12 +50,12 @@ public class KsBackDataServiceImpl extends AbstractService<TbKSNewBackdataEntity
SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid"); SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid");
SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate"); SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate");
if (type == 2){ if (type == 2) {
BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
// 封装子查询 // 封装子查询
SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
(ksNewBackdata.oaid, ksNewBackdata.tag, ksNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from (ksNewBackdata.oaid, ksNewBackdata.tag, ksNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from
(ksNewBackdata).where(ksNewBackdata.tag.in(tagList).and(ksNewBackdata.gmtCreate.gt(startTimeStamp)).and(ksNewBackdata.gmtCreate.lt(endTimeStamp)).and (ksNewBackdata).where(expression).groupBy(ksNewBackdata.oaid, ksNewBackdata.tag);
(ksNewBackdata.oaid.ne(CharSequenceUtil.EMPTY)).and(ksNewBackdata.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(ksNewBackdata.oaid.ne(DataConstant.IDFA_NUM))).groupBy(ksNewBackdata.oaid, ksNewBackdata.tag);
// 结果返回 // 结果返回
List<QueryQuantityVO> voList = query.select(Projections.bean List<QueryQuantityVO> voList = query.select(Projections.bean
@ -65,11 +63,11 @@ public class KsBackDataServiceImpl extends AbstractService<TbKSNewBackdataEntity
(ksNewBackdata).innerJoin(gmtCreate, t3).on(ksNewBackdata.oaid.eq(t3Oaid).and(ksNewBackdata.gmtCreate.eq(t3Date).and(ksNewBackdata.tag.eq(t3Tag)))).groupBy(dateExpr, ksNewBackdata.tag).fetch(); (ksNewBackdata).innerJoin(gmtCreate, t3).on(ksNewBackdata.oaid.eq(t3Oaid).and(ksNewBackdata.gmtCreate.eq(t3Date).and(ksNewBackdata.tag.eq(t3Tag)))).groupBy(dateExpr, ksNewBackdata.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, voList); return Convert.toList(DmpMonitorJpaDto.class, voList);
} }
BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
// 封装子查询 // 封装子查询
SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
(ksNewBackdata.imei, ksNewBackdata.tag, ksNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from (ksNewBackdata.imei, ksNewBackdata.tag, ksNewBackdata.gmtCreate.max().as(SqlConstant.CREATE_TIME)).from
(ksNewBackdata).where(ksNewBackdata.tag.in(tagList).and(ksNewBackdata.gmtCreate.gt(startTimeStamp)).and(ksNewBackdata.gmtCreate.lt(endTimeStamp)).and (ksNewBackdata).where(expression).groupBy(ksNewBackdata.imei, ksNewBackdata.tag);
(ksNewBackdata.imei.ne(CharSequenceUtil.EMPTY)).and(ksNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(ksNewBackdata.imei.ne(DataConstant.IMEI_TAG))).groupBy(ksNewBackdata.imei, ksNewBackdata.tag);
// 结果返回 // 结果返回
List<QueryQuantityVO> voList = query.select(Projections.bean List<QueryQuantityVO> voList = query.select(Projections.bean
@ -81,21 +79,40 @@ public class KsBackDataServiceImpl extends AbstractService<TbKSNewBackdataEntity
// 修改时间格式 // 修改时间格式
dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, ksNewBackdata.gmtCreate); dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, ksNewBackdata.gmtCreate);
if (type == 2){ if (type == 2){
BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
List<QueryImeiVO> imeiVOList = query.select(Projections.bean List<QueryImeiVO> imeiVOList = query.select(Projections.bean
(QueryImeiVO.class, ksNewBackdata.oaid.as("imei"), ksNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(ksNewBackdata).where (QueryImeiVO.class, ksNewBackdata.oaid.as("imei"), ksNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(ksNewBackdata).where
(ksNewBackdata.tag.in(tagList).and(ksNewBackdata.gmtCreate.gt(startTimeStamp)).and(ksNewBackdata.gmtCreate.lt(endTimeStamp)).and(ksNewBackdata.oaid.ne(CharSequenceUtil.EMPTY)).and (expression).groupBy(ksNewBackdata.oaid, ksNewBackdata.tag).fetch();
(ksNewBackdata.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(ksNewBackdata.oaid.ne(DataConstant.IDFA_NUM))).groupBy(ksNewBackdata.oaid, ksNewBackdata.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, imeiVOList); return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
} }
BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
List<QueryImeiVO> imeiVOList = query.select(Projections.bean List<QueryImeiVO> imeiVOList = query.select(Projections.bean
(QueryImeiVO.class, ksNewBackdata.imei, ksNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(ksNewBackdata).where (QueryImeiVO.class, ksNewBackdata.imei, ksNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(ksNewBackdata).where
(ksNewBackdata.tag.in(tagList).and(ksNewBackdata.gmtCreate.gt(startTimeStamp)).and(ksNewBackdata.gmtCreate.lt(endTimeStamp)).and(ksNewBackdata.imei.ne(CharSequenceUtil.EMPTY)).and (expression).groupBy(ksNewBackdata.imei, ksNewBackdata.tag).fetch();
(ksNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(ksNewBackdata.imei.ne(DataConstant.IMEI_TAG))).groupBy(ksNewBackdata.imei, ksNewBackdata.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, imeiVOList); return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
}); });
} }
private BooleanExpression getImeiBooleanExpression(List<String> tagList, Integer vPoint, Timestamp startTimeStamp, Timestamp endTimeStamp) {
BooleanExpression expression = ksNewBackdata.tag.in(tagList).and(ksNewBackdata.gmtCreate.gt(startTimeStamp)).and(ksNewBackdata.gmtCreate.lt(endTimeStamp)).and
(ksNewBackdata.imei.ne(CharSequenceUtil.EMPTY)).and(ksNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(ksNewBackdata.imei.ne(DataConstant.IMEI_TAG));
if (ObjectUtil.isNotNull(vPoint)) {
expression = expression.and(ksNewBackdata.vpoint.eq(vPoint));
}
return expression;
}
private BooleanExpression getOaidBooleanExpression(List<String> tagList, Integer vPoint, Timestamp startTimeStamp, Timestamp endTimeStamp) {
BooleanExpression expression = ksNewBackdata.tag.in(tagList).and(ksNewBackdata.gmtCreate.gt(startTimeStamp)).and(ksNewBackdata.gmtCreate.lt(endTimeStamp)).and(ksNewBackdata.oaid.ne(CharSequenceUtil.EMPTY)).and
(ksNewBackdata.oaid.ne(DataConstant.IDFA_NUM)).and(ksNewBackdata.oaid.ne(DataConstant.IMEI_TAG));
if (ObjectUtil.isNotNull(vPoint)) {
expression = expression.and(ksNewBackdata.vpoint.eq(vPoint));
}
return expression;
}
@Override @Override
public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) { public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) {
Timestamp timestamp = new Timestamp(date.getTime()); Timestamp timestamp = new Timestamp(date.getTime());

5
src/main/java/com/baiyee/adcallback/service/impl/UcBackDataServiceImpl.java
Unescape Escape View File

@ -38,7 +38,7 @@ public class UcBackDataServiceImpl extends AbstractService<TbUcBackdataEntity,Lo
QTbUcBackdataEntity ucBackdata = QTbUcBackdataEntity.tbUcBackdataEntity; QTbUcBackdataEntity ucBackdata = QTbUcBackdataEntity.tbUcBackdataEntity;
@Override @Override
public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag
(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type) { (Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type, Integer vPoint) {
return this.applyJPA(query -> { return this.applyJPA(query -> {
StringTemplate dateExpr; StringTemplate dateExpr;
@ -101,6 +101,9 @@ public class UcBackDataServiceImpl extends AbstractService<TbUcBackdataEntity,Lo
return this.newQuery().delete(ucBackdata).where(ucBackdata.gmtCreate.lt(timestamp)).execute(); return this.newQuery().delete(ucBackdata).where(ucBackdata.gmtCreate.lt(timestamp)).execute();
} }
@Override @Override
public Long countByDate(DateTime date) { public Long countByDate(DateTime date) {
return 0L; return 0L;

6
src/main/java/com/baiyee/adcallback/service/impl/VivoBackDataServiceImpl.java
Unescape Escape View File

@ -36,12 +36,12 @@ public class VivoBackDataServiceImpl extends AbstractService<TbVivoBackdataEntit
@Override @Override
public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag public List<DmpMonitorJpaDto> queryByTagAndTimeAndFlag
(Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type) { (Date startTime, Date endTime, List<String> tagList, Integer flag, Integer type,Integer vPoint) {
QTbVivoBackdataEntity vivoBackdata = QTbVivoBackdataEntity.tbVivoBackdataEntity;
return this.applyJPA(query -> { return this.applyJPA(query -> {
StringPath t3 = Expressions.stringPath("t3"); StringPath t3 = Expressions.stringPath("t3");
StringTemplate dateExpr; StringTemplate dateExpr;
QTbVivoBackdataEntity vivoBackdata = QTbVivoBackdataEntity.tbVivoBackdataEntity;
if (flag == 1) { if (flag == 1) {
dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR, vivoBackdata.gmtCreate); dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR, vivoBackdata.gmtCreate);
SimpleTemplate<String> t3Tag = Expressions.template(String.class, "t3.tag"); SimpleTemplate<String> t3Tag = Expressions.template(String.class, "t3.tag");
@ -73,10 +73,8 @@ public class VivoBackDataServiceImpl extends AbstractService<TbVivoBackdataEntit
(vivoBackdata).innerJoin(gmtCreate, t3).on(vivoBackdata.imei.eq(t3Imei).and(vivoBackdata.gmtCreate.eq(t3Date).and(vivoBackdata.tag.eq(t3Tag)))).groupBy(dateExpr, vivoBackdata.tag).fetch(); (vivoBackdata).innerJoin(gmtCreate, t3).on(vivoBackdata.imei.eq(t3Imei).and(vivoBackdata.gmtCreate.eq(t3Date).and(vivoBackdata.tag.eq(t3Tag)))).groupBy(dateExpr, vivoBackdata.tag).fetch();
return Convert.toList(DmpMonitorJpaDto.class, voList); return Convert.toList(DmpMonitorJpaDto.class, voList);
} }
// 修改时间格式 // 修改时间格式
dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, vivoBackdata.gmtCreate); dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, vivoBackdata.gmtCreate);
if (type == 2){ if (type == 2){
List<QueryImeiVO> imeiVOList = query.select(Projections.bean List<QueryImeiVO> imeiVOList = query.select(Projections.bean
(QueryImeiVO.class, vivoBackdata.oaid.as("imei"), vivoBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(vivoBackdata).where (QueryImeiVO.class, vivoBackdata.oaid.as("imei"), vivoBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(vivoBackdata).where

2
src/main/java/com/baiyee/adcallback/task/NewPlatFormRecordTask.java
Unescape Escape View File

@ -89,7 +89,7 @@ public class NewPlatFormRecordTask {
} }
// 偏移十分钟 // 偏移十分钟
DateTime offsetMinute = ObjectUtil.isNull(beginTime) ? DateTime offsetMinute = ObjectUtil.isNull(beginTime) ?
DateUtil.offsetMinute(date, -9) : beginTime; DateUtil.offsetMinute(date, -9) : DateUtil.offsetMinute(beginTime, -9);
beginTime = offsetMinute; beginTime = offsetMinute;
log.info("================ the begin time as {} end time as {} ================", offsetMinute, date); log.info("================ the begin time as {} end time as {} ================", offsetMinute, date);
List<PlateFormDTO> dtoList = backDataEntityService.queryNewPlateFormDTO List<PlateFormDTO> dtoList = backDataEntityService.queryNewPlateFormDTO

2
src/main/java/com/baiyee/adcallback/task/PlatFormRecordTask.java
Unescape Escape View File

@ -94,7 +94,7 @@ public class PlatFormRecordTask {
} }
// 偏移十分钟 // 偏移十分钟
DateTime offsetMinute = ObjectUtil.isNull(beginTime) ? DateTime offsetMinute = ObjectUtil.isNull(beginTime) ?
DateUtil.offsetMinute(date, -10) : beginTime; DateUtil.offsetMinute(date, -10) : DateUtil.offsetMinute(beginTime, -9);
beginTime = offsetMinute; beginTime = offsetMinute;
log.info("================ the begin time as {} end time as {} ================", offsetMinute, date); log.info("================ the begin time as {} end time as {} ================", offsetMinute, date);
List<PlateFormDTO> dtoList = backDataEntityService.queryPlateFormDTO List<PlateFormDTO> dtoList = backDataEntityService.queryPlateFormDTO

Write Preview
Loading…
Cancel
Save