修改配置参数

# Conflicts:
#	src/main/java/com/baiyee/adcallback/task/PlatFormRecordTask.java

src/main/java/com/baiyee/adcallback/api/dto/DmpMonitorNumDto.java

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

src/main/java/com/baiyee/adcallback/service/DslBaseService.java

@@ -21,9 +21,10 @@ public interface DslBaseService {
      * @param tagList   tag
      * @param flag      num or link
      * @param type
+     * @param vPoint
      * @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);
 
     /**
      * 删除数据

src/main/java/com/baiyee/adcallback/service/GdtBackDateService.java

@@ -19,7 +19,8 @@ public interface GdtBackDateService {
      * @param tagList   tag
      * @param flag      num or link
      * @param type
+     * @param vPoint
      * @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);
 }

src/main/java/com/baiyee/adcallback/service/VivoBackDateService.java

@@ -21,5 +21,5 @@ public interface VivoBackDateService {
      * @param type
      * @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);
 }

src/main/java/com/baiyee/adcallback/service/impl/BdBackDataServiceImpl.java

@@ -3,6 +3,7 @@ package com.baiyee.adcallback.service.impl;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.text.CharSequenceUtil;
+import cn.hutool.core.util.ObjectUtil;
 import com.baiyee.adcallback.api.constants.SqlConstant;
 import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto;
 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.types.Projections;
 import com.querydsl.core.types.SubQueryExpression;
-import com.querydsl.core.types.dsl.Expressions;
-import com.querydsl.core.types.dsl.SimpleTemplate;
-import com.querydsl.core.types.dsl.StringPath;
-import com.querydsl.core.types.dsl.StringTemplate;
+import com.querydsl.core.types.dsl.*;
 import com.querydsl.sql.SQLExpressions;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -38,7 +36,7 @@ public class BdBackDataServiceImpl extends AbstractService<TbBdNewBackdataEntity
     QTbBdNewBackdataEntity bdNewBackdata = QTbBdNewBackdataEntity.tbBdNewBackdataEntity;
     @Override
     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 -> {
@@ -50,26 +48,24 @@ public class BdBackDataServiceImpl extends AbstractService<TbBdNewBackdataEntity
                 SimpleTemplate<String> t3Imei = Expressions.template(String.class, "t3.imei");
                 SimpleTemplate<String> t3Oaid = Expressions.template(String.class, "t3.oaid");
                 SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate");
-
                 if (type == 2) {
+                    BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
                     // 封装子查询
                     SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
                             (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.oaid.ne(CharSequenceUtil.EMPTY)).and(bdNewBackdata.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(bdNewBackdata.oaid.ne(DataConstant.IDFA_NUM))).groupBy(bdNewBackdata.oaid, bdNewBackdata.tag);
-
+                                    (bdNewBackdata).where(expression).groupBy(bdNewBackdata.oaid, bdNewBackdata.tag);
                     // 结果返回
                     List<QueryQuantityVO> voList = query.select(Projections.bean
                             (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();
                     return Convert.toList(DmpMonitorJpaDto.class, voList);
                 }
+
+                 BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
                 // 封装子查询
                 SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
                         (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.imei.ne(CharSequenceUtil.EMPTY)).and(bdNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(bdNewBackdata.imei.ne(DataConstant.IMEI_TAG))).groupBy(bdNewBackdata.imei, bdNewBackdata.tag);
-
+                                (bdNewBackdata).where(expression).groupBy(bdNewBackdata.imei, bdNewBackdata.tag);
                 // 结果返回
                 List<QueryQuantityVO> voList = query.select(Projections.bean
                         (QueryQuantityVO.class, bdNewBackdata.imei.count().as("num"), bdNewBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).from
@@ -81,24 +77,42 @@ public class BdBackDataServiceImpl extends AbstractService<TbBdNewBackdataEntity
             dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, bdNewBackdata.gmtCreate);
 
             if (type == 2) {
+                BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
                 List<QueryImeiVO> oaidVOList = query.select(Projections.bean
                         (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
-                                        (bdNewBackdata.oaid.ne(DataConstant.IDFA_NUM)).and(bdNewBackdata.oaid.ne(DataConstant.IMEI_TAG))).groupBy(bdNewBackdata.oaid, bdNewBackdata.tag).fetch();
+                                (expression).groupBy(bdNewBackdata.oaid, bdNewBackdata.tag).fetch();
                 return Convert.toList(DmpMonitorJpaDto.class, oaidVOList);
             }
+            BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
             List<QueryImeiVO> imeiVOList = query.select(Projections.bean
                     (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
-                                    (bdNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(bdNewBackdata.imei.ne(DataConstant.IMEI_TAG))).groupBy(bdNewBackdata.imei, bdNewBackdata.tag).fetch();
+                            (expression).groupBy(bdNewBackdata.imei, bdNewBackdata.tag).fetch();
             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
     public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) {
         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

src/main/java/com/baiyee/adcallback/service/impl/DmpMonitorV2ServiceImpl.java

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

src/main/java/com/baiyee/adcallback/service/impl/GdtBackDataServiceImpl.java

@@ -2,6 +2,7 @@ package com.baiyee.adcallback.service.impl;
 
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.text.CharSequenceUtil;
+import cn.hutool.core.util.ObjectUtil;
 import com.baiyee.adcallback.api.constants.SqlConstant;
 import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto;
 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.types.Projections;
 import com.querydsl.core.types.SubQueryExpression;
-import com.querydsl.core.types.dsl.Expressions;
-import com.querydsl.core.types.dsl.SimpleTemplate;
-import com.querydsl.core.types.dsl.StringPath;
-import com.querydsl.core.types.dsl.StringTemplate;
+import com.querydsl.core.types.dsl.*;
 import com.querydsl.sql.SQLExpressions;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.sql.Timestamp;
 import java.util.Date;
 import java.util.List;
 
@@ -33,15 +32,17 @@ import java.util.List;
 @Service
 @RequiredArgsConstructor
 public class GdtBackDataServiceImpl extends AbstractService<TbGdtNewBackdataEntity, Long> implements GdtBackDateService {
+    QTbGdtNewBackdataEntity gdtNewBackdata = QTbGdtNewBackdataEntity.tbGdtNewBackdataEntity;
 
     @Override
     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 -> {
             StringPath t3 = Expressions.stringPath("t3");
             StringTemplate dateExpr;
-            QTbGdtNewBackdataEntity gdtNewBackdata = QTbGdtNewBackdataEntity.tbGdtNewBackdataEntity;
             if (flag == 1) {
                 dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR, gdtNewBackdata.gmtCreate);
                 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<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate");
 
-
                 if (type == 2) {
+                    BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
                     // 封装子查询
                     SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
                             (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.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(gdtNewBackdata.oaid.ne(DataConstant.IMEI_TAG)))).groupBy(gdtNewBackdata.oaid,gdtNewBackdata.tag);
+                                    (gdtNewBackdata).where(expression).groupBy(gdtNewBackdata.oaid, gdtNewBackdata.tag);
 
                     // 结果返回
                     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();
                     return Convert.toList(DmpMonitorJpaDto.class, voList);
                 }
+                BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
                 // 封装子查询
                 SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
                         (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.imei.ne(DataConstant.IMEI_NULL_TAG)).and(gdtNewBackdata.imei.ne(DataConstant.IMEI_TAG)))).groupBy(gdtNewBackdata.imei,gdtNewBackdata.tag);
+                                (gdtNewBackdata).where(expression).groupBy(gdtNewBackdata.imei, gdtNewBackdata.tag);
 
                 // 结果返回
                 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);
 
             if (type == 2) {
+                BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
                 List<QueryImeiVO> imeiVOList = query.select(Projections.bean
                         (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
-                                        (DataConstant.IDFA_NUM)))).groupBy(gdtNewBackdata.oaid,gdtNewBackdata.tag).fetch();
+                                (expression).groupBy(gdtNewBackdata.oaid, gdtNewBackdata.tag).fetch();
                 return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
             }
+            BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
             List<QueryImeiVO> imeiVOList = query.select(Projections.bean
                     (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
-                                        (DataConstant.IMEI_TAG)))).groupBy(gdtNewBackdata.imei,gdtNewBackdata.tag).fetch();
+                            (expression).groupBy(gdtNewBackdata.imei, gdtNewBackdata.tag).fetch();
             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;
+    }
 }

src/main/java/com/baiyee/adcallback/service/impl/JlV1BackDataServiceImpl.java

@@ -3,6 +3,7 @@ package com.baiyee.adcallback.service.impl;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.text.CharSequenceUtil;
+import cn.hutool.core.util.ObjectUtil;
 import com.baiyee.adcallback.api.constants.SqlConstant;
 import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto;
 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.types.Projections;
 import com.querydsl.core.types.SubQueryExpression;
-import com.querydsl.core.types.dsl.Expressions;
-import com.querydsl.core.types.dsl.SimpleTemplate;
-import com.querydsl.core.types.dsl.StringPath;
-import com.querydsl.core.types.dsl.StringTemplate;
+import com.querydsl.core.types.dsl.*;
 import com.querydsl.sql.SQLExpressions;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -38,7 +36,7 @@ public class JlV1BackDataServiceImpl extends AbstractService<TbJLBackDataV1Entit
 
     @Override
     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 -> {
             StringTemplate dateExpr;
             StringPath t3 = Expressions.stringPath("t3");
@@ -50,11 +48,11 @@ public class JlV1BackDataServiceImpl extends AbstractService<TbJLBackDataV1Entit
                 SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate");
 
                 if (type == 2) {
+                    BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTime, endTime);
                     // 封装子查询
                     SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
                             (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.oaid.ne(CharSequenceUtil.EMPTY)).and(v1Entity.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(v1Entity.oaid.ne(DataConstant.IDFA_NUM))).groupBy(v1Entity.oaid, v1Entity.tag);
+                                    (v1Entity).where(expression).groupBy(v1Entity.oaid, v1Entity.tag);
 
                     // 结果返回
                     List<QueryQuantityVO> voList = query.select(Projections.bean
@@ -63,11 +61,11 @@ public class JlV1BackDataServiceImpl extends AbstractService<TbJLBackDataV1Entit
                     return Convert.toList(DmpMonitorJpaDto.class, voList);
                 }
 
+                BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTime, endTime);
                 // 封装子查询
                 SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
                         (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.imei.ne(CharSequenceUtil.EMPTY)).and(v1Entity.imei.ne(DataConstant.IMEI_NULL_TAG)).and(v1Entity.imei.ne(DataConstant.IMEI_TAG))).groupBy(v1Entity.imei, v1Entity.tag);
+                                (v1Entity).where(expression).groupBy(v1Entity.imei, v1Entity.tag);
 
                 // 结果返回
                 List<QueryQuantityVO> voList = query.select(Projections.bean
@@ -79,21 +77,40 @@ public class JlV1BackDataServiceImpl extends AbstractService<TbJLBackDataV1Entit
             // 修改时间格式
             dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, v1Entity.gmtCreate);
             if (type == 2) {
+                BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTime, endTime);
                 List<QueryImeiVO> imeiVOList = query.select(Projections.bean
                         (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
-                        (v1Entity.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(v1Entity.oaid.ne(DataConstant.IDFA_NUM))).groupBy(v1Entity.oaid, v1Entity.tag).fetch();
+                                (expression).groupBy(v1Entity.oaid, v1Entity.tag).fetch();
                 return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
             }
 
+            BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTime, endTime);
             List<QueryImeiVO> imeiVOList = query.select(Projections.bean
                     (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
-                                    (v1Entity.imei.ne(DataConstant.IMEI_NULL_TAG)).and(v1Entity.imei.ne(DataConstant.IMEI_TAG))).groupBy(v1Entity.imei, v1Entity.tag).fetch();
+                                (expression).groupBy(v1Entity.imei, v1Entity.tag).fetch();
             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
     public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) {
         return this.newQuery().delete(v1Entity).where(v1Entity.gmtCreate.lt(date)).execute();

src/main/java/com/baiyee/adcallback/service/impl/JlV2BackDataServiceImpl.java

@@ -1,8 +1,10 @@
 package com.baiyee.adcallback.service.impl;
 
+import cn.hutool.core.codec.Base64;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.text.CharSequenceUtil;
+import cn.hutool.core.util.ObjectUtil;
 import com.baiyee.adcallback.api.constants.SqlConstant;
 import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto;
 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.types.Projections;
 import com.querydsl.core.types.SubQueryExpression;
-import com.querydsl.core.types.dsl.Expressions;
-import com.querydsl.core.types.dsl.SimpleTemplate;
-import com.querydsl.core.types.dsl.StringPath;
-import com.querydsl.core.types.dsl.StringTemplate;
+import com.querydsl.core.types.dsl.*;
 import com.querydsl.sql.SQLExpressions;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -36,7 +35,7 @@ public class JlV2BackDataServiceImpl extends AbstractService<TbJLBackDataV2Entit
     QTbJLBackDataV2Entity v2Entity = QTbJLBackDataV2Entity.tbJLBackDataV2Entity;
     @Override
     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 -> {
             StringTemplate dateExpr;
             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<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate");
 
-
                 if (type == 2) {
+                    BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTime, endTime);
                     // 封装子查询
                     SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
                             (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.oaid.ne(CharSequenceUtil.EMPTY)).and(v2Entity.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(v2Entity.oaid.ne(DataConstant.IDFA_NUM))).groupBy(v2Entity.oaid, v2Entity.tag);
+                                    (v2Entity).where(expression).groupBy(v2Entity.oaid, v2Entity.tag);
                     // 结果返回
                     List<QueryQuantityVO> voList = query.select(Projections.bean
                             (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();
                     return Convert.toList(DmpMonitorJpaDto.class, voList);
                 }
+                BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTime, endTime);
                 // 封装子查询
                 SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
                         (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.imei.ne(CharSequenceUtil.EMPTY)).and(v2Entity.imei.ne(DataConstant.IMEI_NULL_TAG)).and(v2Entity.imei.ne(DataConstant.IMEI_TAG))).groupBy(v2Entity.imei, v2Entity.tag);
+                                (v2Entity).where(expression).groupBy(v2Entity.imei, v2Entity.tag);
 
                 // 结果返回
                 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);
 
             if (type == 2){
+                BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTime, endTime);
                 List<QueryImeiVO> imeiVOList = query.select(Projections.bean
                         (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
-                                (v2Entity.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(v2Entity.oaid.ne(DataConstant.IDFA_NUM))).groupBy(v2Entity.oaid, v2Entity.tag).fetch();
+                            (expression).groupBy(v2Entity.oaid, v2Entity.tag).fetch();
                 return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
             }
+            BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTime, endTime);
             List<QueryImeiVO> imeiVOList = query.select(Projections.bean
                     (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
-                                    (v2Entity.imei.ne(DataConstant.IMEI_NULL_TAG)).and(v2Entity.imei.ne(DataConstant.IMEI_TAG))).groupBy(v2Entity.imei, v2Entity.tag).fetch();
+                            (expression).groupBy(v2Entity.imei, v2Entity.tag).fetch();
             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
     public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) {
         return this.newQuery().delete(v2Entity).where(v2Entity.gmtCreate.lt(date)).execute();

src/main/java/com/baiyee/adcallback/service/impl/KsBackDataServiceImpl.java

@@ -3,6 +3,7 @@ package com.baiyee.adcallback.service.impl;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.text.CharSequenceUtil;
+import cn.hutool.core.util.ObjectUtil;
 import com.baiyee.adcallback.api.constants.SqlConstant;
 import com.baiyee.adcallback.api.dto.DmpMonitorJpaDto;
 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.types.Projections;
 import com.querydsl.core.types.SubQueryExpression;
-import com.querydsl.core.types.dsl.Expressions;
-import com.querydsl.core.types.dsl.SimpleTemplate;
-import com.querydsl.core.types.dsl.StringPath;
-import com.querydsl.core.types.dsl.StringTemplate;
+import com.querydsl.core.types.dsl.*;
 import com.querydsl.sql.SQLExpressions;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -38,7 +36,7 @@ public class KsBackDataServiceImpl extends AbstractService<TbKSNewBackdataEntity
     QTbKSNewBackdataEntity ksNewBackdata = QTbKSNewBackdataEntity.tbKSNewBackdataEntity;
     @Override
     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 -> {
@@ -53,11 +51,11 @@ public class KsBackDataServiceImpl extends AbstractService<TbKSNewBackdataEntity
                 SimpleTemplate<Date> t3Date = Expressions.template(Date.class, "t3.gmtCreate");
 
                 if (type == 2) {
+                    BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
                     // 封装子查询
                     SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
                             (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.oaid.ne(CharSequenceUtil.EMPTY)).and(ksNewBackdata.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(ksNewBackdata.oaid.ne(DataConstant.IDFA_NUM))).groupBy(ksNewBackdata.oaid, ksNewBackdata.tag);
+                                    (ksNewBackdata).where(expression).groupBy(ksNewBackdata.oaid, ksNewBackdata.tag);
 
                     // 结果返回
                     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();
                     return Convert.toList(DmpMonitorJpaDto.class, voList);
                 }
+                BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
                 // 封装子查询
                 SubQueryExpression<Tuple> gmtCreate = SQLExpressions.select
                         (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.imei.ne(CharSequenceUtil.EMPTY)).and(ksNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(ksNewBackdata.imei.ne(DataConstant.IMEI_TAG))).groupBy(ksNewBackdata.imei, ksNewBackdata.tag);
+                                (ksNewBackdata).where(expression).groupBy(ksNewBackdata.imei, ksNewBackdata.tag);
 
                 // 结果返回
                 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);
             if (type == 2){
+                BooleanExpression expression = getOaidBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
                 List<QueryImeiVO> imeiVOList = query.select(Projections.bean
                         (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
-                                (ksNewBackdata.oaid.ne(DataConstant.IMEI_NULL_TAG)).and(ksNewBackdata.oaid.ne(DataConstant.IDFA_NUM))).groupBy(ksNewBackdata.oaid, ksNewBackdata.tag).fetch();
+                                (expression).groupBy(ksNewBackdata.oaid, ksNewBackdata.tag).fetch();
                 return Convert.toList(DmpMonitorJpaDto.class, imeiVOList);
             }
 
+            BooleanExpression expression = getImeiBooleanExpression(tagList, vPoint, startTimeStamp, endTimeStamp);
             List<QueryImeiVO> imeiVOList = query.select(Projections.bean
                     (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
-                                    (ksNewBackdata.imei.ne(DataConstant.IMEI_NULL_TAG)).and(ksNewBackdata.imei.ne(DataConstant.IMEI_TAG))).groupBy(ksNewBackdata.imei, ksNewBackdata.tag).fetch();
+                            (expression).groupBy(ksNewBackdata.imei, ksNewBackdata.tag).fetch();
             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
     public Long deleteDateByDateAndLimitNum(DateTime date, Integer num) {
         Timestamp timestamp = new Timestamp(date.getTime());

src/main/java/com/baiyee/adcallback/service/impl/UcBackDataServiceImpl.java

@@ -38,7 +38,7 @@ public class UcBackDataServiceImpl extends AbstractService<TbUcBackdataEntity,Lo
     QTbUcBackdataEntity ucBackdata = QTbUcBackdataEntity.tbUcBackdataEntity;
     @Override
     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 -> {
             StringTemplate dateExpr;
@@ -101,6 +101,9 @@ public class UcBackDataServiceImpl extends AbstractService<TbUcBackdataEntity,Lo
         return this.newQuery().delete(ucBackdata).where(ucBackdata.gmtCreate.lt(timestamp)).execute();
     }
 
+
+
+
     @Override
     public Long countByDate(DateTime date) {
         return 0L;

src/main/java/com/baiyee/adcallback/service/impl/VivoBackDataServiceImpl.java

@@ -36,12 +36,12 @@ public class VivoBackDataServiceImpl extends AbstractService<TbVivoBackdataEntit
 
     @Override
     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 -> {
             StringPath t3 = Expressions.stringPath("t3");
             StringTemplate dateExpr;
-            QTbVivoBackdataEntity vivoBackdata = QTbVivoBackdataEntity.tbVivoBackdataEntity;
             if (flag == 1) {
                 dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR, vivoBackdata.gmtCreate);
                 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();
                 return Convert.toList(DmpMonitorJpaDto.class, voList);
             }
-
             // 修改时间格式
             dateExpr = Expressions.stringTemplate(SqlConstant.DATE_EXPR_V2, vivoBackdata.gmtCreate);
-
             if (type == 2){
                 List<QueryImeiVO> imeiVOList = query.select(Projections.bean
                         (QueryImeiVO.class, vivoBackdata.oaid.as("imei"), vivoBackdata.tag, dateExpr.as(SqlConstant.CREATE_TIME))).distinct().from(vivoBackdata).where

src/main/java/com/baiyee/adcallback/task/PlatFormRecordTask.java

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

src/main/resources/application-dev.yml

@@ -233,8 +233,8 @@ spring:
 platform:
   workId: 32
   authToken: JI8AeA7POKsdGcBC
-  url: http://8.130.96.163:8866/api/taskImei/callback/add
-  tripartite-url: http://127.0.0.1:8866/api/taskImei/tripartite/add
+  url: http://8.130.96.163:8866/api/data/callback/add
+  tripartite-url: http://127.0.0.1:8866/api/data/tripartite/add
 
 
 tf:

src/main/resources/application-prod.yml

@@ -50,17 +50,17 @@ spring:
         type: com.alibaba.druid.pool.DruidDataSource
         # 数据库驱动类名
         driver-class-name: com.mysql.cj.jdbc.Driver
-        url: jdbc:mysql://localhost:3306/db_ad?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false&rewriteBatchedStatements=true
+        url: jdbc:mysql://127.0.0.1:3306/db_ad?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false&rewriteBatchedStatements=true
         username: root
-        password: Yuyou@2020
+        password: ukYTrVrRp3TQ.
       db1:
         # 数据库连接池类名称
         type: com.alibaba.druid.pool.DruidDataSource
         # 数据库驱动类名
         driver-class-name: com.mysql.cj.jdbc.Driver
-        url: jdbc:mysql://localhost:3306/db_ad1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false&rewriteBatchedStatements=true
+        url: jdbc:mysql://127.0.0.1:3306/db_ad1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf8&useSSL=false&rewriteBatchedStatements=true
         username: root
-        password: Yuyou@2020
+        password: ukYTrVrRp3TQ.
     # 规则配置
     rules:
       sharding:
@@ -226,8 +226,8 @@ spring:
       sql-show: false
 platform:
   authToken: nqJpVSf3UcrEcVIH
-  tripartite-url: https://baiyee.vip/api/taskImei/tripartite/add
-  url: https://baiyee.vip/api/taskImei/callback/add
+  tripartite-url: https://baiyee.vip/api/data/tripartite/add
+  url: https://baiyee.vip/api/data/callback/add
   workId: 32
 
 tf:

src/main/resources/application.yml

@@ -4,7 +4,7 @@ spring:
   application:
     name: ad-callback
   profiles:
-    active: dev
+    active: prod
   jackson:
     time-zone: GMT+8
     date-format: yyyy-MM-dd HH:mm:ss
@@ -19,6 +19,7 @@ spring:
       #允许对象忽略json中不存在的属性
       fail_on_unknown_properties: false
     parser:
+
       #允许出现特殊字符和转义符
       allow_unquoted_control_chars: true
       #允许出现单引号