Skip to content

R
refined-platform
Commit 9804dbad authored by 赵啸非's avatar 赵啸非
Browse files
Options

添加人流统计模块

parent 0b6f034d
Hide whitespace changes
Inline Side-by-side
Showing with 3393 additions and 191 deletions
doc/api.md
View file @ 9804dbad
......@@ -4080,6 +4080,69 @@ data| object |数据对象
}
```
## 人员流量统计
### 查询人员流量统计列表
**请求URL:** realtime/dataflow/stat/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询人员流量统计
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
page|Integer|否|当前页
size|Integer|否|每页条数，值为-1，查询所有记录
**请求样例:**
```
{
"page":1,
"size":10
}
```
**响应参数:**
参数名称|参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
 per_page|Integer|每页条数
 total|Integer|总条数
 last_page|Integer|总页数
 current_page|Integer|当前页
 data|array|结果集列表|数组
  id|Long|主键ID，主键，自增长
  siteId|Long|站点Id
  siteName|String|站点名称
  personSum|Integer|人流总数
  strangerSum|Integer|陌生人数量
  recoginzeSum|Integer|识别注册群众数量
  year|Integer|年
  month|Integer|月
  day|Integer|日
  hour|Integer|小时
  createTime|Date|创建时间
  createUserId|Long|创建人id
  updateTime|Date|更新时间
  updateUserId|Long|更新人id
dict|object|字典对象
**响应消息样例:**
```
{
"code":1,
"data":{
}
}
```
```
......
refined-manager/src/main/java/com/mortals/xhx/daemon/task/SyncAppointWaitAndFinTaskImpl.java
View file @ 9804dbad
......@@ -26,10 +26,7 @@ import com.mortals.xhx.common.key.RedisKey;
import com.mortals.xhx.module.appointment.model.AppointmentPersonEntity;
import com.mortals.xhx.module.appointment.model.AppointmentPersonQuery;
import com.mortals.xhx.module.appointment.service.AppointmentPersonService;
import com.mortals.xhx.module.care.model.CareConfigEntity;
import com.mortals.xhx.module.care.model.CareConfigQuery;
import com.mortals.xhx.module.care.model.CareRecordsEntity;
import com.mortals.xhx.module.care.model.CareRecordsQuery;
import com.mortals.xhx.module.care.model.*;
import com.mortals.xhx.module.care.service.CareConfigService;
import com.mortals.xhx.module.care.service.CareRecordsService;
import com.mortals.xhx.module.hik.person.model.rsp.person.PersonInfo;
......@@ -41,6 +38,7 @@ import lombok.extern.slf4j.Slf4j;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.kafka.common.protocol.types.Field;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
......@@ -52,10 +50,7 @@ import org.springframework.web.multipart.commons.CommonsMultipartFile;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
/**
......@@ -169,7 +164,10 @@ public class SyncAppointWaitAndFinTaskImpl implements ITaskExcuteService {
if (checkCareServiceUsed(careConfigEntity)) return;
//校验当天日期是否启用
if (checkCareServiceDay(careConfigEntity)) return;
//校验当天服务最大人数
if (checkCareServiceMaxNum(careConfigEntity)) return;
//校验当天服务时间段
if (checkServiceTimeDurion(careConfigEntity)) return;
Long serviceThreshold = careConfigEntity.getServiceThreshold();
String msgRecipients = careConfigEntity.getMsgRecipients();
......@@ -222,6 +220,36 @@ public class SyncAppointWaitAndFinTaskImpl implements ITaskExcuteService {
}
}
private boolean checkCareServiceMaxNum(CareConfigEntity careConfigEntity) {
Integer maxServicePersonNum = careConfigEntity.getMaxServicePersonNum();
CareRecordsQuery careRecordsQuery = new CareRecordsQuery();
careRecordsQuery.setCreateTimeStart(DateUtils.getCurrStrDate());
careRecordsQuery.setCreateTimeEnd(DateUtils.getCurrStrDate());
int dayServiceNum = careRecordsService.count(careRecordsQuery, null);
if (dayServiceNum > maxServicePersonNum) {
log.info("服务人数超过最大数量！");
return true;
}
return false;
}
private boolean checkServiceTimeDurion(CareConfigEntity careConfigEntity) {
List<CareConfigTimesEntity> careConfigTimesList = careConfigEntity.getCareConfigTimesList();
if (ObjectUtils.isEmpty(careConfigTimesList)) {
Date date = new Date();
boolean isIn = careConfigTimesList.stream()
.anyMatch((tp) -> (tp.getServiceTimeStart().equals(date) || tp.getServiceTimeStart().before(date))
&& (tp.getServiceTimeEnd().equals(date) || tp.getServiceTimeEnd().after(date)));
if (!isIn) {
log.info("当前时间不在服务时间内！");
return true;
}
}
return false;
}
@Override
public void stopTask(ITask task) throws AppException {
......@@ -231,7 +259,27 @@ public class SyncAppointWaitAndFinTaskImpl implements ITaskExcuteService {
public static void main(String[] args) {
System.out.println(DateUtil.parse("19951071", "yyyyMMdd"));
Date date = new Date(); // 待判断的时间对象
List<CareConfigTimesEntity> timePeriodList = new ArrayList<>(); // 时间段列表
CareConfigTimesEntity careConfigTimesEntity = new CareConfigTimesEntity();
careConfigTimesEntity.setServiceTimeStart(DateUtil.parse("2023-04-19 09:00:00"));
careConfigTimesEntity.setServiceTimeEnd(DateUtil.parse("2023-04-19 10:00:00"));
timePeriodList.add(careConfigTimesEntity);
careConfigTimesEntity = new CareConfigTimesEntity();
careConfigTimesEntity.setServiceTimeStart(DateUtil.parse("2023-04-19 10:10:00"));
careConfigTimesEntity.setServiceTimeEnd(DateUtil.parse("2023-04-19 11:00:00"));
timePeriodList.add(careConfigTimesEntity);
boolean isIn = timePeriodList.stream()
.anyMatch((tp) -> (tp.getServiceTimeStart().equals(date) || tp.getServiceTimeStart().before(date))
&& (tp.getServiceTimeEnd().equals(date) || tp.getServiceTimeEnd().after(date)));
System.out.println(isIn);
}
......
refined-manager/src/main/java/com/mortals/xhx/module/care/model/CareConfigEntity.java
View file @ 9804dbad
package com.mortals.xhx.module.care.model;
import java.util.List;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.care.model.vo.CareConfigVo;
import com.mortals.xhx.module.care.model.CareConfigTimesEntity;
/**
* 主动关怀配置实体对象
*
* @author zxfei
* @date 2023-04-09
*/
* 主动关怀配置实体对象
*
* @author zxfei
* @date 2023-04-09
*/
public class CareConfigEntity extends CareConfigVo {
private static final long serialVersionUID = 1L;
/**
* 站点Id
*/
* 站点Id
*/
private Long siteId;
/**
* 站点名称
*/
* 站点名称
*/
private String siteName;
/**
* 是否启用该服务(0.否,1.是)
*/
* 是否启用该服务(0.否,1.是)
*/
private Integer used;
/**
* 周一是否监测(0.否,1.是)
*/
* 周一是否监测(0.否,1.是)
*/
private Integer monday;
/**
* 周二是否监测(0.否,1.是)
*/
* 周二是否监测(0.否,1.是)
*/
private Integer tuesday;
/**
* 周三是否监测(0.否,1.是)
*/
* 周三是否监测(0.否,1.是)
*/
private Integer wednesday;
/**
* 周四是否监测(0.否,1.是)
*/
* 周四是否监测(0.否,1.是)
*/
private Integer thursday;
/**
* 周五是否监测(0.否,1.是)
*/
* 周五是否监测(0.否,1.是)
*/
private Integer friday;
/**
* 周六是否监测(0.否,1.是)
*/
* 周六是否监测(0.否,1.是)
*/
private Integer saturday;
/**
* 周日是否监测(0.否,1.是)
*/
* 周日是否监测(0.否,1.是)
*/
private Integer sunday;
/**
* 单日服务最大人数设置
*/
* 单日服务最大人数设置
*/
private Integer maxServicePersonNum;
/**
* 服务阈值设置，单位分钟
*/
* 服务阈值设置，单位分钟
*/
@Excel(name = "服务阈值设置，单位分钟")
private Long serviceThreshold;
/**
* 累计服务频次预警
*/
* 累计服务频次预警
*/
private Integer alertServiceNum;
/**
* 消息发送对象(办事群众.办事群众,管理员.管理员)
*/
* 消息发送对象(办事群众.办事群众,管理员.管理员)
*/
private String msgRecipients;
/**
* 备注
*/
* 备注
*/
private String remark;
/**
* 主动关怀时间段信息
*/
private List<CareConfigTimesEntity> careConfigTimesList=new ArrayList<>();;
* 主动关怀时间段信息
*/
private List<CareConfigTimesEntity> careConfigTimesList = new ArrayList<>();
;
public CareConfigEntity(){}
public CareConfigEntity() {
}
/**
* 获取 站点Id
* @return Long
*/
public Long getSiteId(){
* 获取 站点Id
*
* @return Long
*/
public Long getSiteId() {
return siteId;
}
/**
* 设置 站点Id
* @param siteId
*/
public void setSiteId(Long siteId){
* 设置 站点Id
*
* @param siteId
*/
public void setSiteId(Long siteId) {
this.siteId = siteId;
}
/**
* 获取 站点名称
* @return String
*/
public String getSiteName(){
* 获取 站点名称
*
* @return String
*/
public String getSiteName() {
return siteName;
}
/**
* 设置 站点名称
* @param siteName
*/
public void setSiteName(String siteName){
* 设置 站点名称
*
* @param siteName
*/
public void setSiteName(String siteName) {
this.siteName = siteName;
}
/**
* 获取 是否启用该服务(0.否,1.是)
* @return Integer
*/
public Integer getUsed(){
* 获取 是否启用该服务(0.否,1.是)
*
* @return Integer
*/
public Integer getUsed() {
return used;
}
/**
* 设置 是否启用该服务(0.否,1.是)
* @param used
*/
public void setUsed(Integer used){
* 设置 是否启用该服务(0.否,1.是)
*
* @param used
*/
public void setUsed(Integer used) {
this.used = used;
}
/**
* 获取 周一是否监测(0.否,1.是)
* @return Integer
*/
public Integer getMonday(){
* 获取 周一是否监测(0.否,1.是)
*
* @return Integer
*/
public Integer getMonday() {
return monday;
}
/**
* 设置 周一是否监测(0.否,1.是)
* @param monday
*/
public void setMonday(Integer monday){
* 设置 周一是否监测(0.否,1.是)
*
* @param monday
*/
public void setMonday(Integer monday) {
this.monday = monday;
}
/**
* 获取 周二是否监测(0.否,1.是)
* @return Integer
*/
public Integer getTuesday(){
* 获取 周二是否监测(0.否,1.是)
*
* @return Integer
*/
public Integer getTuesday() {
return tuesday;
}
/**
* 设置 周二是否监测(0.否,1.是)
* @param tuesday
*/
public void setTuesday(Integer tuesday){
* 设置 周二是否监测(0.否,1.是)
*
* @param tuesday
*/
public void setTuesday(Integer tuesday) {
this.tuesday = tuesday;
}
/**
* 获取 周三是否监测(0.否,1.是)
* @return Integer
*/
public Integer getWednesday(){
* 获取 周三是否监测(0.否,1.是)
*
* @return Integer
*/
public Integer getWednesday() {
return wednesday;
}
/**
* 设置 周三是否监测(0.否,1.是)
* @param wednesday
*/
public void setWednesday(Integer wednesday){
* 设置 周三是否监测(0.否,1.是)
*
* @param wednesday
*/
public void setWednesday(Integer wednesday) {
this.wednesday = wednesday;
}
/**
* 获取 周四是否监测(0.否,1.是)
* @return Integer
*/
public Integer getThursday(){
* 获取 周四是否监测(0.否,1.是)
*
* @return Integer
*/
public Integer getThursday() {
return thursday;
}
/**
* 设置 周四是否监测(0.否,1.是)
* @param thursday
*/
public void setThursday(Integer thursday){
* 设置 周四是否监测(0.否,1.是)
*
* @param thursday
*/
public void setThursday(Integer thursday) {
this.thursday = thursday;
}
/**
* 获取 周五是否监测(0.否,1.是)
* @return Integer
*/
public Integer getFriday(){
* 获取 周五是否监测(0.否,1.是)
*
* @return Integer
*/
public Integer getFriday() {
return friday;
}
/**
* 设置 周五是否监测(0.否,1.是)
* @param friday
*/
public void setFriday(Integer friday){
* 设置 周五是否监测(0.否,1.是)
*
* @param friday
*/
public void setFriday(Integer friday) {
this.friday = friday;
}
/**
* 获取 周六是否监测(0.否,1.是)
* @return Integer
*/
public Integer getSaturday(){
* 获取 周六是否监测(0.否,1.是)
*
* @return Integer
*/
public Integer getSaturday() {
return saturday;
}
/**
* 设置 周六是否监测(0.否,1.是)
* @param saturday
*/
public void setSaturday(Integer saturday){
* 设置 周六是否监测(0.否,1.是)
*
* @param saturday
*/
public void setSaturday(Integer saturday) {
this.saturday = saturday;
}
/**
* 获取 周日是否监测(0.否,1.是)
* @return Integer
*/
public Integer getSunday(){
* 获取 周日是否监测(0.否,1.是)
*
* @return Integer
*/
public Integer getSunday() {
return sunday;
}
/**
* 设置 周日是否监测(0.否,1.是)
* @param sunday
*/
public void setSunday(Integer sunday){
* 设置 周日是否监测(0.否,1.是)
*
* @param sunday
*/
public void setSunday(Integer sunday) {
this.sunday = sunday;
}
/**
* 获取 单日服务最大人数设置
* @return Integer
*/
public Integer getMaxServicePersonNum(){
* 获取 单日服务最大人数设置
*
* @return Integer
*/
public Integer getMaxServicePersonNum() {
return maxServicePersonNum;
}
/**
* 设置 单日服务最大人数设置
* @param maxServicePersonNum
*/
public void setMaxServicePersonNum(Integer maxServicePersonNum){
* 设置 单日服务最大人数设置
*
* @param maxServicePersonNum
*/
public void setMaxServicePersonNum(Integer maxServicePersonNum) {
this.maxServicePersonNum = maxServicePersonNum;
}
/**
* 获取 服务阈值设置，单位分钟
* @return Long
*/
public Long getServiceThreshold(){
* 获取 服务阈值设置，单位分钟
*
* @return Long
*/
public Long getServiceThreshold() {
return serviceThreshold;
}
/**
* 设置 服务阈值设置，单位分钟
* @param serviceThreshold
*/
public void setServiceThreshold(Long serviceThreshold){
* 设置 服务阈值设置，单位分钟
*
* @param serviceThreshold
*/
public void setServiceThreshold(Long serviceThreshold) {
this.serviceThreshold = serviceThreshold;
}
/**
* 获取 累计服务频次预警
* @return Integer
*/
public Integer getAlertServiceNum(){
* 获取 累计服务频次预警
*
* @return Integer
*/
public Integer getAlertServiceNum() {
return alertServiceNum;
}
/**
* 设置 累计服务频次预警
* @param alertServiceNum
*/
public void setAlertServiceNum(Integer alertServiceNum){
* 设置 累计服务频次预警
*
* @param alertServiceNum
*/
public void setAlertServiceNum(Integer alertServiceNum) {
this.alertServiceNum = alertServiceNum;
}
/**
* 获取 消息发送对象(办事群众.办事群众,管理员.管理员)
* @return String
*/
public String getMsgRecipients(){
* 获取 消息发送对象(办事群众.办事群众,管理员.管理员)
*
* @return String
*/
public String getMsgRecipients() {
return msgRecipients;
}
/**
* 设置 消息发送对象(办事群众.办事群众,管理员.管理员)
* @param msgRecipients
*/
public void setMsgRecipients(String msgRecipients){
* 设置 消息发送对象(办事群众.办事群众,管理员.管理员)
*
* @param msgRecipients
*/
public void setMsgRecipients(String msgRecipients) {
this.msgRecipients = msgRecipients;
}
/**
* 获取 备注
* @return String
*/
public String getRemark(){
* 获取 备注
*
* @return String
*/
public String getRemark() {
return remark;
}
/**
* 设置 备注
* @param remark
*/
public void setRemark(String remark){
* 设置 备注
*
* @param remark
*/
public void setRemark(String remark) {
this.remark = remark;
}
public List<CareConfigTimesEntity> getCareConfigTimesList(){
return careConfigTimesList;
public List<CareConfigTimesEntity> getCareConfigTimesList() {
return careConfigTimesList;
}
public void setCareConfigTimesList(List<CareConfigTimesEntity> careConfigTimesList){
public void setCareConfigTimesList(List<CareConfigTimesEntity> careConfigTimesList) {
this.careConfigTimesList = careConfigTimesList;
}
@Override
public int hashCode() {
return this.getId().hashCode();
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof CareConfigEntity) {
CareConfigEntity tmp = (CareConfigEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
return true;
}
}
return false;
}
public String toString(){
public String toString() {
StringBuilder sb = new StringBuilder("");
sb.append(",siteId:").append(getSiteId());
sb.append(",siteName:").append(getSiteName());
......@@ -343,36 +409,36 @@ public class CareConfigEntity extends CareConfigVo {
return sb.toString();
}
public void initAttrValue(){
public void initAttrValue() {
this.siteId = null;
this.siteId = null;
this.siteName = "";
this.siteName = "";
this.used = 0;
this.used = 0;
this.monday = 0;
this.monday = 0;
this.tuesday = 0;
this.tuesday = 0;
this.wednesday = 0;
this.wednesday = 0;
this.thursday = 0;
this.thursday = 0;
this.friday = 0;
this.friday = 0;
this.saturday = 0;
this.saturday = 0;
this.sunday = 0;
this.sunday = 0;
this.maxServicePersonNum = 0;
this.maxServicePersonNum = 0;
this.serviceThreshold = 0L;
this.serviceThreshold = 0L;
this.alertServiceNum = 0;
this.alertServiceNum = 200;
this.msgRecipients = "";
this.msgRecipients = "管理员";
this.remark = "";
this.remark = "";
}
}
\ No newline at end of file
refined-manager/src/main/java/com/mortals/xhx/module/realtime/dao/RealtimeDataflowStatDao.java 0 → 100644
View file @ 9804dbad
package com.mortals.xhx.module.realtime.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.realtime.model.RealtimeDataflowStatEntity;
import java.util.List;
/**
* 人员流量统计Dao
* 人员流量统计 DAO接口
*
* @author zxfei
* @date 2023-04-19
*/
public interface RealtimeDataflowStatDao extends ICRUDDao<RealtimeDataflowStatEntity,Long>{
}
refined-manager/src/main/java/com/mortals/xhx/module/realtime/dao/ibatis/RealtimeDataflowStatDaoImpl.java 0 → 100644
View file @ 9804dbad
package com.mortals.xhx.module.realtime.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.realtime.dao.RealtimeDataflowStatDao;
import com.mortals.xhx.module.realtime.model.RealtimeDataflowStatEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 人员流量统计DaoImpl DAO接口
*
* @author zxfei
* @date 2023-04-19
*/
@Repository("realtimeDataflowStatDao")
public class RealtimeDataflowStatDaoImpl extends BaseCRUDDaoMybatis<RealtimeDataflowStatEntity,Long> implements RealtimeDataflowStatDao {
}
refined-manager/src/main/java/com/mortals/xhx/module/realtime/model/RealtimeDataflowStatEntity.java 0 → 100644
View file @ 9804dbad
package com.mortals.xhx.module.realtime.model;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.realtime.model.vo.RealtimeDataflowStatVo;
import lombok.Data;
/**
* 人员流量统计实体对象
*
* @author zxfei
* @date 2023-04-19
*/
@Data
public class RealtimeDataflowStatEntity extends RealtimeDataflowStatVo {
private static final long serialVersionUID = 1L;
/**
* 站点Id
*/
private Long siteId;
/**
* 站点名称
*/
private String siteName;
/**
* 人流总数
*/
private Integer personSum;
/**
* 陌生人数量
*/
private Integer strangerSum;
/**
* 识别注册群众数量
*/
private Integer recoginzeSum;
/**
* 年
*/
private Integer year;
/**
* 月
*/
private Integer month;
/**
* 日
*/
private Integer day;
/**
* 小时
*/
private Integer hour;
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof RealtimeDataflowStatEntity) {
RealtimeDataflowStatEntity tmp = (RealtimeDataflowStatEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public void initAttrValue(){
this.siteId = null;
this.siteName = "";
this.personSum = null;
this.strangerSum = null;
this.recoginzeSum = null;
this.year = null;
this.month = null;
this.day = null;
this.hour = null;
}
}
\ No newline at end of file
refined-manager/src/main/java/com/mortals/xhx/module/realtime/model/RealtimeDataflowStatQuery.java 0 → 100644
View file @ 9804dbad
package com.mortals.xhx.module.realtime.model;
import java.util.List;
import com.mortals.xhx.module.realtime.model.RealtimeDataflowStatEntity;
/**
* 人员流量统计查询对象
*
* @author zxfei
* @date 2023-04-19
*/
public class RealtimeDataflowStatQuery extends RealtimeDataflowStatEntity {
/** 开始 主键ID，主键，自增长 */
private Long idStart;
/** 结束 主键ID，主键，自增长 */
private Long idEnd;
/** 增加 主键ID，主键，自增长 */
private Long idIncrement;
/** 主键ID，主键，自增长列表 */
private List <Long> idList;
/** 主键ID，主键，自增长排除列表 */
private List <Long> idNotList;
/** 开始 站点Id */
private Long siteIdStart;
/** 结束 站点Id */
private Long siteIdEnd;
/** 增加 站点Id */
private Long siteIdIncrement;
/** 站点Id列表 */
private List <Long> siteIdList;
/** 站点Id排除列表 */
private List <Long> siteIdNotList;
/** 站点名称 */
private List<String> siteNameList;
/** 站点名称排除列表 */
private List <String> siteNameNotList;
/** 开始 人流总数 */
private Integer personSumStart;
/** 结束 人流总数 */
private Integer personSumEnd;
/** 增加 人流总数 */
private Integer personSumIncrement;
/** 人流总数列表 */
private List <Integer> personSumList;
/** 人流总数排除列表 */
private List <Integer> personSumNotList;
/** 开始 陌生人数量 */
private Integer strangerSumStart;
/** 结束 陌生人数量 */
private Integer strangerSumEnd;
/** 增加 陌生人数量 */
private Integer strangerSumIncrement;
/** 陌生人数量列表 */
private List <Integer> strangerSumList;
/** 陌生人数量排除列表 */
private List <Integer> strangerSumNotList;
/** 开始 识别注册群众数量 */
private Integer recoginzeSumStart;
/** 结束 识别注册群众数量 */
private Integer recoginzeSumEnd;
/** 增加 识别注册群众数量 */
private Integer recoginzeSumIncrement;
/** 识别注册群众数量列表 */
private List <Integer> recoginzeSumList;
/** 识别注册群众数量排除列表 */
private List <Integer> recoginzeSumNotList;
/** 开始 年 */
private Integer yearStart;
/** 结束 年 */
private Integer yearEnd;
/** 增加 年 */
private Integer yearIncrement;
/** 年列表 */
private List <Integer> yearList;
/** 年排除列表 */
private List <Integer> yearNotList;
/** 开始 月 */
private Integer monthStart;
/** 结束 月 */
private Integer monthEnd;
/** 增加 月 */
private Integer monthIncrement;
/** 月列表 */
private List <Integer> monthList;
/** 月排除列表 */
private List <Integer> monthNotList;
/** 开始 日 */
private Integer dayStart;
/** 结束 日 */
private Integer dayEnd;
/** 增加 日 */
private Integer dayIncrement;
/** 日列表 */
private List <Integer> dayList;
/** 日排除列表 */
private List <Integer> dayNotList;
/** 开始 小时 */
private Integer hourStart;
/** 结束 小时 */
private Integer hourEnd;
/** 增加 小时 */
private Integer hourIncrement;
/** 小时列表 */
private List <Integer> hourList;
/** 小时排除列表 */
private List <Integer> hourNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 创建人id */
private Long createUserIdStart;
/** 结束 创建人id */
private Long createUserIdEnd;
/** 增加 创建人id */
private Long createUserIdIncrement;
/** 创建人id列表 */
private List <Long> createUserIdList;
/** 创建人id排除列表 */
private List <Long> createUserIdNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** 开始 更新人id */
private Long updateUserIdStart;
/** 结束 更新人id */
private Long updateUserIdEnd;
/** 增加 更新人id */
private Long updateUserIdIncrement;
/** 更新人id列表 */
private List <Long> updateUserIdList;
/** 更新人id排除列表 */
private List <Long> updateUserIdNotList;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<RealtimeDataflowStatQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<RealtimeDataflowStatQuery> andConditionList;
public RealtimeDataflowStatQuery(){}
/**
* 获取 开始 主键ID，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 主键ID，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 主键ID，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 主键ID，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 主键ID，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 主键ID，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 主键ID，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 主键ID，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 主键ID，主键，自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 主键ID，主键，自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 开始 站点Id
* @return siteIdStart
*/
public Long getSiteIdStart(){
return this.siteIdStart;
}
/**
* 设置 开始 站点Id
* @param siteIdStart
*/
public void setSiteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
}
/**
* 获取 结束 站点Id
* @return $siteIdEnd
*/
public Long getSiteIdEnd(){
return this.siteIdEnd;
}
/**
* 设置 结束 站点Id
* @param siteIdEnd
*/
public void setSiteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
}
/**
* 获取 增加 站点Id
* @return siteIdIncrement
*/
public Long getSiteIdIncrement(){
return this.siteIdIncrement;
}
/**
* 设置 增加 站点Id
* @param siteIdIncrement
*/
public void setSiteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
}
/**
* 获取 站点Id
* @return siteIdList
*/
public List<Long> getSiteIdList(){
return this.siteIdList;
}
/**
* 设置 站点Id
* @param siteIdList
*/
public void setSiteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
}
/**
* 获取 站点Id
* @return siteIdNotList
*/
public List<Long> getSiteIdNotList(){
return this.siteIdNotList;
}
/**
* 设置 站点Id
* @param siteIdNotList
*/
public void setSiteIdNotList(List<Long> siteIdNotList){
this.siteIdNotList = siteIdNotList;
}
/**
* 获取 站点名称
* @return siteNameList
*/
public List<String> getSiteNameList(){
return this.siteNameList;
}
/**
* 设置 站点名称
* @param siteNameList
*/
public void setSiteNameList(List<String> siteNameList){
this.siteNameList = siteNameList;
}
/**
* 获取 站点名称
* @return siteNameNotList
*/
public List<String> getSiteNameNotList(){
return this.siteNameNotList;
}
/**
* 设置 站点名称
* @param siteNameNotList
*/
public void setSiteNameNotList(List<String> siteNameNotList){
this.siteNameNotList = siteNameNotList;
}
/**
* 获取 开始 人流总数
* @return personSumStart
*/
public Integer getPersonSumStart(){
return this.personSumStart;
}
/**
* 设置 开始 人流总数
* @param personSumStart
*/
public void setPersonSumStart(Integer personSumStart){
this.personSumStart = personSumStart;
}
/**
* 获取 结束 人流总数
* @return $personSumEnd
*/
public Integer getPersonSumEnd(){
return this.personSumEnd;
}
/**
* 设置 结束 人流总数
* @param personSumEnd
*/
public void setPersonSumEnd(Integer personSumEnd){
this.personSumEnd = personSumEnd;
}
/**
* 获取 增加 人流总数
* @return personSumIncrement
*/
public Integer getPersonSumIncrement(){
return this.personSumIncrement;
}
/**
* 设置 增加 人流总数
* @param personSumIncrement
*/
public void setPersonSumIncrement(Integer personSumIncrement){
this.personSumIncrement = personSumIncrement;
}
/**
* 获取 人流总数
* @return personSumList
*/
public List<Integer> getPersonSumList(){
return this.personSumList;
}
/**
* 设置 人流总数
* @param personSumList
*/
public void setPersonSumList(List<Integer> personSumList){
this.personSumList = personSumList;
}
/**
* 获取 人流总数
* @return personSumNotList
*/
public List<Integer> getPersonSumNotList(){
return this.personSumNotList;
}
/**
* 设置 人流总数
* @param personSumNotList
*/
public void setPersonSumNotList(List<Integer> personSumNotList){
this.personSumNotList = personSumNotList;
}
/**
* 获取 开始 陌生人数量
* @return strangerSumStart
*/
public Integer getStrangerSumStart(){
return this.strangerSumStart;
}
/**
* 设置 开始 陌生人数量
* @param strangerSumStart
*/
public void setStrangerSumStart(Integer strangerSumStart){
this.strangerSumStart = strangerSumStart;
}
/**
* 获取 结束 陌生人数量
* @return $strangerSumEnd
*/
public Integer getStrangerSumEnd(){
return this.strangerSumEnd;
}
/**
* 设置 结束 陌生人数量
* @param strangerSumEnd
*/
public void setStrangerSumEnd(Integer strangerSumEnd){
this.strangerSumEnd = strangerSumEnd;
}
/**
* 获取 增加 陌生人数量
* @return strangerSumIncrement
*/
public Integer getStrangerSumIncrement(){
return this.strangerSumIncrement;
}
/**
* 设置 增加 陌生人数量
* @param strangerSumIncrement
*/
public void setStrangerSumIncrement(Integer strangerSumIncrement){
this.strangerSumIncrement = strangerSumIncrement;
}
/**
* 获取 陌生人数量
* @return strangerSumList
*/
public List<Integer> getStrangerSumList(){
return this.strangerSumList;
}
/**
* 设置 陌生人数量
* @param strangerSumList
*/
public void setStrangerSumList(List<Integer> strangerSumList){
this.strangerSumList = strangerSumList;
}
/**
* 获取 陌生人数量
* @return strangerSumNotList
*/
public List<Integer> getStrangerSumNotList(){
return this.strangerSumNotList;
}
/**
* 设置 陌生人数量
* @param strangerSumNotList
*/
public void setStrangerSumNotList(List<Integer> strangerSumNotList){
this.strangerSumNotList = strangerSumNotList;
}
/**
* 获取 开始 识别注册群众数量
* @return recoginzeSumStart
*/
public Integer getRecoginzeSumStart(){
return this.recoginzeSumStart;
}
/**
* 设置 开始 识别注册群众数量
* @param recoginzeSumStart
*/
public void setRecoginzeSumStart(Integer recoginzeSumStart){
this.recoginzeSumStart = recoginzeSumStart;
}
/**
* 获取 结束 识别注册群众数量
* @return $recoginzeSumEnd
*/
public Integer getRecoginzeSumEnd(){
return this.recoginzeSumEnd;
}
/**
* 设置 结束 识别注册群众数量
* @param recoginzeSumEnd
*/
public void setRecoginzeSumEnd(Integer recoginzeSumEnd){
this.recoginzeSumEnd = recoginzeSumEnd;
}
/**
* 获取 增加 识别注册群众数量
* @return recoginzeSumIncrement
*/
public Integer getRecoginzeSumIncrement(){
return this.recoginzeSumIncrement;
}
/**
* 设置 增加 识别注册群众数量
* @param recoginzeSumIncrement
*/
public void setRecoginzeSumIncrement(Integer recoginzeSumIncrement){
this.recoginzeSumIncrement = recoginzeSumIncrement;
}
/**
* 获取 识别注册群众数量
* @return recoginzeSumList
*/
public List<Integer> getRecoginzeSumList(){
return this.recoginzeSumList;
}
/**
* 设置 识别注册群众数量
* @param recoginzeSumList
*/
public void setRecoginzeSumList(List<Integer> recoginzeSumList){
this.recoginzeSumList = recoginzeSumList;
}
/**
* 获取 识别注册群众数量
* @return recoginzeSumNotList
*/
public List<Integer> getRecoginzeSumNotList(){
return this.recoginzeSumNotList;
}
/**
* 设置 识别注册群众数量
* @param recoginzeSumNotList
*/
public void setRecoginzeSumNotList(List<Integer> recoginzeSumNotList){
this.recoginzeSumNotList = recoginzeSumNotList;
}
/**
* 获取 开始 年
* @return yearStart
*/
public Integer getYearStart(){
return this.yearStart;
}
/**
* 设置 开始 年
* @param yearStart
*/
public void setYearStart(Integer yearStart){
this.yearStart = yearStart;
}
/**
* 获取 结束 年
* @return $yearEnd
*/
public Integer getYearEnd(){
return this.yearEnd;
}
/**
* 设置 结束 年
* @param yearEnd
*/
public void setYearEnd(Integer yearEnd){
this.yearEnd = yearEnd;
}
/**
* 获取 增加 年
* @return yearIncrement
*/
public Integer getYearIncrement(){
return this.yearIncrement;
}
/**
* 设置 增加 年
* @param yearIncrement
*/
public void setYearIncrement(Integer yearIncrement){
this.yearIncrement = yearIncrement;
}
/**
* 获取 年
* @return yearList
*/
public List<Integer> getYearList(){
return this.yearList;
}
/**
* 设置 年
* @param yearList
*/
public void setYearList(List<Integer> yearList){
this.yearList = yearList;
}
/**
* 获取 年
* @return yearNotList
*/
public List<Integer> getYearNotList(){
return this.yearNotList;
}
/**
* 设置 年
* @param yearNotList
*/
public void setYearNotList(List<Integer> yearNotList){
this.yearNotList = yearNotList;
}
/**
* 获取 开始 月
* @return monthStart
*/
public Integer getMonthStart(){
return this.monthStart;
}
/**
* 设置 开始 月
* @param monthStart
*/
public void setMonthStart(Integer monthStart){
this.monthStart = monthStart;
}
/**
* 获取 结束 月
* @return $monthEnd
*/
public Integer getMonthEnd(){
return this.monthEnd;
}
/**
* 设置 结束 月
* @param monthEnd
*/
public void setMonthEnd(Integer monthEnd){
this.monthEnd = monthEnd;
}
/**
* 获取 增加 月
* @return monthIncrement
*/
public Integer getMonthIncrement(){
return this.monthIncrement;
}
/**
* 设置 增加 月
* @param monthIncrement
*/
public void setMonthIncrement(Integer monthIncrement){
this.monthIncrement = monthIncrement;
}
/**
* 获取 月
* @return monthList
*/
public List<Integer> getMonthList(){
return this.monthList;
}
/**
* 设置 月
* @param monthList
*/
public void setMonthList(List<Integer> monthList){
this.monthList = monthList;
}
/**
* 获取 月
* @return monthNotList
*/
public List<Integer> getMonthNotList(){
return this.monthNotList;
}
/**
* 设置 月
* @param monthNotList
*/
public void setMonthNotList(List<Integer> monthNotList){
this.monthNotList = monthNotList;
}
/**
* 获取 开始 日
* @return dayStart
*/
public Integer getDayStart(){
return this.dayStart;
}
/**
* 设置 开始 日
* @param dayStart
*/
public void setDayStart(Integer dayStart){
this.dayStart = dayStart;
}
/**
* 获取 结束 日
* @return $dayEnd
*/
public Integer getDayEnd(){
return this.dayEnd;
}
/**
* 设置 结束 日
* @param dayEnd
*/
public void setDayEnd(Integer dayEnd){
this.dayEnd = dayEnd;
}
/**
* 获取 增加 日
* @return dayIncrement
*/
public Integer getDayIncrement(){
return this.dayIncrement;
}
/**
* 设置 增加 日
* @param dayIncrement
*/
public void setDayIncrement(Integer dayIncrement){
this.dayIncrement = dayIncrement;
}
/**
* 获取 日
* @return dayList
*/
public List<Integer> getDayList(){
return this.dayList;
}
/**
* 设置 日
* @param dayList
*/
public void setDayList(List<Integer> dayList){
this.dayList = dayList;
}
/**
* 获取 日
* @return dayNotList
*/
public List<Integer> getDayNotList(){
return this.dayNotList;
}
/**
* 设置 日
* @param dayNotList
*/
public void setDayNotList(List<Integer> dayNotList){
this.dayNotList = dayNotList;
}
/**
* 获取 开始 小时
* @return hourStart
*/
public Integer getHourStart(){
return this.hourStart;
}
/**
* 设置 开始 小时
* @param hourStart
*/
public void setHourStart(Integer hourStart){
this.hourStart = hourStart;
}
/**
* 获取 结束 小时
* @return $hourEnd
*/
public Integer getHourEnd(){
return this.hourEnd;
}
/**
* 设置 结束 小时
* @param hourEnd
*/
public void setHourEnd(Integer hourEnd){
this.hourEnd = hourEnd;
}
/**
* 获取 增加 小时
* @return hourIncrement
*/
public Integer getHourIncrement(){
return this.hourIncrement;
}
/**
* 设置 增加 小时
* @param hourIncrement
*/
public void setHourIncrement(Integer hourIncrement){
this.hourIncrement = hourIncrement;
}
/**
* 获取 小时
* @return hourList
*/
public List<Integer> getHourList(){
return this.hourList;
}
/**
* 设置 小时
* @param hourList
*/
public void setHourList(List<Integer> hourList){
this.hourList = hourList;
}
/**
* 获取 小时
* @return hourNotList
*/
public List<Integer> getHourNotList(){
return this.hourNotList;
}
/**
* 设置 小时
* @param hourNotList
*/
public void setHourNotList(List<Integer> hourNotList){
this.hourNotList = hourNotList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 创建人id
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建人id
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建人id
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建人id
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建人id
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建人id
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建人id
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建人id
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建人id
* @return createUserIdNotList
*/
public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList;
}
/**
* 设置 创建人id
* @param createUserIdNotList
*/
public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 获取 开始 更新人id
* @return updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新人id
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新人id
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新人id
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新人id
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新人id
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新人id
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新人id
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新人id
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新人id
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 设置 主键ID，主键，自增长
* @param id
*/
public RealtimeDataflowStatQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 主键ID，主键，自增长
* @param idStart
*/
public RealtimeDataflowStatQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 主键ID，主键，自增长
* @param idEnd
*/
public RealtimeDataflowStatQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 主键ID，主键，自增长
* @param idIncrement
*/
public RealtimeDataflowStatQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 主键ID，主键，自增长
* @param idList
*/
public RealtimeDataflowStatQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 主键ID，主键，自增长
* @param idNotList
*/
public RealtimeDataflowStatQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 站点Id
* @param siteId
*/
public RealtimeDataflowStatQuery siteId(Long siteId){
setSiteId(siteId);
return this;
}
/**
* 设置 开始 站点Id
* @param siteIdStart
*/
public RealtimeDataflowStatQuery siteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
return this;
}
/**
* 设置 结束 站点Id
* @param siteIdEnd
*/
public RealtimeDataflowStatQuery siteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
return this;
}
/**
* 设置 增加 站点Id
* @param siteIdIncrement
*/
public RealtimeDataflowStatQuery siteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
return this;
}
/**
* 设置 站点Id
* @param siteIdList
*/
public RealtimeDataflowStatQuery siteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
return this;
}
/**
* 设置 站点Id
* @param siteIdNotList
*/
public RealtimeDataflowStatQuery siteIdNotList(List<Long> siteIdNotList){
this.siteIdNotList = siteIdNotList;
return this;
}
/**
* 设置 站点名称
* @param siteName
*/
public RealtimeDataflowStatQuery siteName(String siteName){
setSiteName(siteName);
return this;
}
/**
* 设置 站点名称
* @param siteNameList
*/
public RealtimeDataflowStatQuery siteNameList(List<String> siteNameList){
this.siteNameList = siteNameList;
return this;
}
/**
* 设置 人流总数
* @param personSum
*/
public RealtimeDataflowStatQuery personSum(Integer personSum){
setPersonSum(personSum);
return this;
}
/**
* 设置 开始 人流总数
* @param personSumStart
*/
public RealtimeDataflowStatQuery personSumStart(Integer personSumStart){
this.personSumStart = personSumStart;
return this;
}
/**
* 设置 结束 人流总数
* @param personSumEnd
*/
public RealtimeDataflowStatQuery personSumEnd(Integer personSumEnd){
this.personSumEnd = personSumEnd;
return this;
}
/**
* 设置 增加 人流总数
* @param personSumIncrement
*/
public RealtimeDataflowStatQuery personSumIncrement(Integer personSumIncrement){
this.personSumIncrement = personSumIncrement;
return this;
}
/**
* 设置 人流总数
* @param personSumList
*/
public RealtimeDataflowStatQuery personSumList(List<Integer> personSumList){
this.personSumList = personSumList;
return this;
}
/**
* 设置 人流总数
* @param personSumNotList
*/
public RealtimeDataflowStatQuery personSumNotList(List<Integer> personSumNotList){
this.personSumNotList = personSumNotList;
return this;
}
/**
* 设置 陌生人数量
* @param strangerSum
*/
public RealtimeDataflowStatQuery strangerSum(Integer strangerSum){
setStrangerSum(strangerSum);
return this;
}
/**
* 设置 开始 陌生人数量
* @param strangerSumStart
*/
public RealtimeDataflowStatQuery strangerSumStart(Integer strangerSumStart){
this.strangerSumStart = strangerSumStart;
return this;
}
/**
* 设置 结束 陌生人数量
* @param strangerSumEnd
*/
public RealtimeDataflowStatQuery strangerSumEnd(Integer strangerSumEnd){
this.strangerSumEnd = strangerSumEnd;
return this;
}
/**
* 设置 增加 陌生人数量
* @param strangerSumIncrement
*/
public RealtimeDataflowStatQuery strangerSumIncrement(Integer strangerSumIncrement){
this.strangerSumIncrement = strangerSumIncrement;
return this;
}
/**
* 设置 陌生人数量
* @param strangerSumList
*/
public RealtimeDataflowStatQuery strangerSumList(List<Integer> strangerSumList){
this.strangerSumList = strangerSumList;
return this;
}
/**
* 设置 陌生人数量
* @param strangerSumNotList
*/
public RealtimeDataflowStatQuery strangerSumNotList(List<Integer> strangerSumNotList){
this.strangerSumNotList = strangerSumNotList;
return this;
}
/**
* 设置 识别注册群众数量
* @param recoginzeSum
*/
public RealtimeDataflowStatQuery recoginzeSum(Integer recoginzeSum){
setRecoginzeSum(recoginzeSum);
return this;
}
/**
* 设置 开始 识别注册群众数量
* @param recoginzeSumStart
*/
public RealtimeDataflowStatQuery recoginzeSumStart(Integer recoginzeSumStart){
this.recoginzeSumStart = recoginzeSumStart;
return this;
}
/**
* 设置 结束 识别注册群众数量
* @param recoginzeSumEnd
*/
public RealtimeDataflowStatQuery recoginzeSumEnd(Integer recoginzeSumEnd){
this.recoginzeSumEnd = recoginzeSumEnd;
return this;
}
/**
* 设置 增加 识别注册群众数量
* @param recoginzeSumIncrement
*/
public RealtimeDataflowStatQuery recoginzeSumIncrement(Integer recoginzeSumIncrement){
this.recoginzeSumIncrement = recoginzeSumIncrement;
return this;
}
/**
* 设置 识别注册群众数量
* @param recoginzeSumList
*/
public RealtimeDataflowStatQuery recoginzeSumList(List<Integer> recoginzeSumList){
this.recoginzeSumList = recoginzeSumList;
return this;
}
/**
* 设置 识别注册群众数量
* @param recoginzeSumNotList
*/
public RealtimeDataflowStatQuery recoginzeSumNotList(List<Integer> recoginzeSumNotList){
this.recoginzeSumNotList = recoginzeSumNotList;
return this;
}
/**
* 设置 年
* @param year
*/
public RealtimeDataflowStatQuery year(Integer year){
setYear(year);
return this;
}
/**
* 设置 开始 年
* @param yearStart
*/
public RealtimeDataflowStatQuery yearStart(Integer yearStart){
this.yearStart = yearStart;
return this;
}
/**
* 设置 结束 年
* @param yearEnd
*/
public RealtimeDataflowStatQuery yearEnd(Integer yearEnd){
this.yearEnd = yearEnd;
return this;
}
/**
* 设置 增加 年
* @param yearIncrement
*/
public RealtimeDataflowStatQuery yearIncrement(Integer yearIncrement){
this.yearIncrement = yearIncrement;
return this;
}
/**
* 设置 年
* @param yearList
*/
public RealtimeDataflowStatQuery yearList(List<Integer> yearList){
this.yearList = yearList;
return this;
}
/**
* 设置 年
* @param yearNotList
*/
public RealtimeDataflowStatQuery yearNotList(List<Integer> yearNotList){
this.yearNotList = yearNotList;
return this;
}
/**
* 设置 月
* @param month
*/
public RealtimeDataflowStatQuery month(Integer month){
setMonth(month);
return this;
}
/**
* 设置 开始 月
* @param monthStart
*/
public RealtimeDataflowStatQuery monthStart(Integer monthStart){
this.monthStart = monthStart;
return this;
}
/**
* 设置 结束 月
* @param monthEnd
*/
public RealtimeDataflowStatQuery monthEnd(Integer monthEnd){
this.monthEnd = monthEnd;
return this;
}
/**
* 设置 增加 月
* @param monthIncrement
*/
public RealtimeDataflowStatQuery monthIncrement(Integer monthIncrement){
this.monthIncrement = monthIncrement;
return this;
}
/**
* 设置 月
* @param monthList
*/
public RealtimeDataflowStatQuery monthList(List<Integer> monthList){
this.monthList = monthList;
return this;
}
/**
* 设置 月
* @param monthNotList
*/
public RealtimeDataflowStatQuery monthNotList(List<Integer> monthNotList){
this.monthNotList = monthNotList;
return this;
}
/**
* 设置 日
* @param day
*/
public RealtimeDataflowStatQuery day(Integer day){
setDay(day);
return this;
}
/**
* 设置 开始 日
* @param dayStart
*/
public RealtimeDataflowStatQuery dayStart(Integer dayStart){
this.dayStart = dayStart;
return this;
}
/**
* 设置 结束 日
* @param dayEnd
*/
public RealtimeDataflowStatQuery dayEnd(Integer dayEnd){
this.dayEnd = dayEnd;
return this;
}
/**
* 设置 增加 日
* @param dayIncrement
*/
public RealtimeDataflowStatQuery dayIncrement(Integer dayIncrement){
this.dayIncrement = dayIncrement;
return this;
}
/**
* 设置 日
* @param dayList
*/
public RealtimeDataflowStatQuery dayList(List<Integer> dayList){
this.dayList = dayList;
return this;
}
/**
* 设置 日
* @param dayNotList
*/
public RealtimeDataflowStatQuery dayNotList(List<Integer> dayNotList){
this.dayNotList = dayNotList;
return this;
}
/**
* 设置 小时
* @param hour
*/
public RealtimeDataflowStatQuery hour(Integer hour){
setHour(hour);
return this;
}
/**
* 设置 开始 小时
* @param hourStart
*/
public RealtimeDataflowStatQuery hourStart(Integer hourStart){
this.hourStart = hourStart;
return this;
}
/**
* 设置 结束 小时
* @param hourEnd
*/
public RealtimeDataflowStatQuery hourEnd(Integer hourEnd){
this.hourEnd = hourEnd;
return this;
}
/**
* 设置 增加 小时
* @param hourIncrement
*/
public RealtimeDataflowStatQuery hourIncrement(Integer hourIncrement){
this.hourIncrement = hourIncrement;
return this;
}
/**
* 设置 小时
* @param hourList
*/
public RealtimeDataflowStatQuery hourList(List<Integer> hourList){
this.hourList = hourList;
return this;
}
/**
* 设置 小时
* @param hourNotList
*/
public RealtimeDataflowStatQuery hourNotList(List<Integer> hourNotList){
this.hourNotList = hourNotList;
return this;
}
/**
* 设置 创建人id
* @param createUserId
*/
public RealtimeDataflowStatQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建人id
* @param createUserIdStart
*/
public RealtimeDataflowStatQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建人id
* @param createUserIdEnd
*/
public RealtimeDataflowStatQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建人id
* @param createUserIdIncrement
*/
public RealtimeDataflowStatQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建人id
* @param createUserIdList
*/
public RealtimeDataflowStatQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建人id
* @param createUserIdNotList
*/
public RealtimeDataflowStatQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 更新人id
* @param updateUserId
*/
public RealtimeDataflowStatQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新人id
* @param updateUserIdStart
*/
public RealtimeDataflowStatQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新人id
* @param updateUserIdEnd
*/
public RealtimeDataflowStatQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新人id
* @param updateUserIdIncrement
*/
public RealtimeDataflowStatQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新人id
* @param updateUserIdList
*/
public RealtimeDataflowStatQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新人id
* @param updateUserIdNotList
*/
public RealtimeDataflowStatQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<RealtimeDataflowStatQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<RealtimeDataflowStatQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<RealtimeDataflowStatQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<RealtimeDataflowStatQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
refined-manager/src/main/java/com/mortals/xhx/module/realtime/model/vo/RealtimeDataflowStatVo.java 0 → 100644
View file @ 9804dbad
package com.mortals.xhx.module.realtime.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.realtime.model.RealtimeDataflowStatEntity;
import java.util.ArrayList;
import java.util.List;
import lombok.Data;
/**
* 人员流量统计视图对象
*
* @author zxfei
* @date 2023-04-19
*/
@Data
public class RealtimeDataflowStatVo extends BaseEntityLong {
/**
* 人流总数
*/
@Excel(name = "人流总数")
private Integer personSum;
/**
* 陌生人数量
*/
@Excel(name = "陌生人数量")
private Integer strangerSum;
/**
* 识别注册群众数量
*/
@Excel(name = "识别注册群众数量")
private Integer recoginzeSum;
}
\ No newline at end of file
refined-manager/src/main/java/com/mortals/xhx/module/realtime/service/RealtimeDataflowStatService.java 0 → 100644
View file @ 9804dbad
package com.mortals.xhx.module.realtime.service;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.realtime.model.RealtimeDataflowStatEntity;
/**
* RealtimeDataflowStatService
*
* 人员流量统计 service接口
*
* @author zxfei
* @date 2023-04-19
*/
public interface RealtimeDataflowStatService extends ICRUDService<RealtimeDataflowStatEntity,Long>{
}
\ No newline at end of file
refined-manager/src/main/java/com/mortals/xhx/module/realtime/service/impl/RealtimeDataflowStatServiceImpl.java 0 → 100644
View file @ 9804dbad
package com.mortals.xhx.module.realtime.service.impl;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.realtime.dao.RealtimeDataflowStatDao;
import com.mortals.xhx.module.realtime.model.RealtimeDataflowStatEntity;
import com.mortals.xhx.module.realtime.service.RealtimeDataflowStatService;
/**
* RealtimeDataflowStatService
* 人员流量统计 service实现
*
* @author zxfei
* @date 2023-04-19
*/
@Service("realtimeDataflowStatService")
public class RealtimeDataflowStatServiceImpl extends AbstractCRUDServiceImpl<RealtimeDataflowStatDao, RealtimeDataflowStatEntity, Long> implements RealtimeDataflowStatService {
}
\ No newline at end of file
refined-manager/src/main/java/com/mortals/xhx/module/realtime/web/RealtimeDataflowStatController.java 0 → 100644
View file @ 9804dbad
package com.mortals.xhx.module.realtime.web;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.realtime.model.RealtimeDataflowStatEntity;
import com.mortals.xhx.module.realtime.service.RealtimeDataflowStatService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 人员流量统计
*
* @author zxfei
* @date 2023-04-19
*/
@RestController
@RequestMapping("realtime/dataflow/stat")
public class RealtimeDataflowStatController extends BaseCRUDJsonBodyMappingController<RealtimeDataflowStatService,RealtimeDataflowStatEntity,Long> {
@Autowired
private ParamService paramService;
public RealtimeDataflowStatController(){
super.setModuleDesc( "人员流量统计");
}
@Override
protected void init(Map<String, Object> model, Context context) {
super.init(model, context);
}
}
\ No newline at end of file
refined-manager/src/main/resources/sqlmap/module/realtime/RealtimeDataflowStatMapper.xml 0 → 100644
View file @ 9804dbad
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.realtime.dao.ibatis.RealtimeDataflowStatDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="RealtimeDataflowStatEntity" id="RealtimeDataflowStatEntity-Map">
<id property="id" column="id" />
<result property="siteId" column="siteId" />
<result property="siteName" column="siteName" />
<result property="personSum" column="personSum" />
<result property="strangerSum" column="strangerSum" />
<result property="recoginzeSum" column="recoginzeSum" />
<result property="year" column="year" />
<result property="month" column="month" />
<result property="day" column="day" />
<result property="hour" column="hour" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="updateTime" column="updateTime" />
<result property="updateUserId" column="updateUserId" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteId') or colPickMode == 1 and data.containsKey('siteId')))">
a.siteId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteName') or colPickMode == 1 and data.containsKey('siteName')))">
a.siteName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('personSum') or colPickMode == 1 and data.containsKey('personSum')))">
a.personSum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('strangerSum') or colPickMode == 1 and data.containsKey('strangerSum')))">
a.strangerSum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('recoginzeSum') or colPickMode == 1 and data.containsKey('recoginzeSum')))">
a.recoginzeSum,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('year') or colPickMode == 1 and data.containsKey('year')))">
a.year,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('month') or colPickMode == 1 and data.containsKey('month')))">
a.month,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('day') or colPickMode == 1 and data.containsKey('day')))">
a.day,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hour') or colPickMode == 1 and data.containsKey('hour')))">
a.hour,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="RealtimeDataflowStatEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_realtime_dataflow_stat
(siteId,siteName,personSum,strangerSum,recoginzeSum,year,month,day,hour,createTime,createUserId,updateTime,updateUserId)
VALUES
(#{siteId},#{siteName},#{personSum},#{strangerSum},#{recoginzeSum},#{year},#{month},#{day},#{hour},#{createTime},#{createUserId},#{updateTime},#{updateUserId})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_realtime_dataflow_stat
(siteId,siteName,personSum,strangerSum,recoginzeSum,year,month,day,hour,createTime,createUserId,updateTime,updateUserId)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.siteId},#{item.siteName},#{item.personSum},#{item.strangerSum},#{item.recoginzeSum},#{item.year},#{item.month},#{item.day},#{item.hour},#{item.createTime},#{item.createUserId},#{item.updateTime},#{item.updateUserId})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_realtime_dataflow_stat as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('siteId')) or (colPickMode==1 and !data.containsKey('siteId'))">
a.siteId=#{data.siteId},
</if>
<if test="(colPickMode==0 and data.containsKey('siteIdIncrement')) or (colPickMode==1 and !data.containsKey('siteIdIncrement'))">
a.siteId=ifnull(a.siteId,0) + #{data.siteIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('siteName')) or (colPickMode==1 and !data.containsKey('siteName'))">
a.siteName=#{data.siteName},
</if>
<if test="(colPickMode==0 and data.containsKey('personSum')) or (colPickMode==1 and !data.containsKey('personSum'))">
a.personSum=#{data.personSum},
</if>
<if test="(colPickMode==0 and data.containsKey('personSumIncrement')) or (colPickMode==1 and !data.containsKey('personSumIncrement'))">
a.personSum=ifnull(a.personSum,0) + #{data.personSumIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('strangerSum')) or (colPickMode==1 and !data.containsKey('strangerSum'))">
a.strangerSum=#{data.strangerSum},
</if>
<if test="(colPickMode==0 and data.containsKey('strangerSumIncrement')) or (colPickMode==1 and !data.containsKey('strangerSumIncrement'))">
a.strangerSum=ifnull(a.strangerSum,0) + #{data.strangerSumIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('recoginzeSum')) or (colPickMode==1 and !data.containsKey('recoginzeSum'))">
a.recoginzeSum=#{data.recoginzeSum},
</if>
<if test="(colPickMode==0 and data.containsKey('recoginzeSumIncrement')) or (colPickMode==1 and !data.containsKey('recoginzeSumIncrement'))">
a.recoginzeSum=ifnull(a.recoginzeSum,0) + #{data.recoginzeSumIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('year')) or (colPickMode==1 and !data.containsKey('year'))">
a.year=#{data.year},
</if>
<if test="(colPickMode==0 and data.containsKey('yearIncrement')) or (colPickMode==1 and !data.containsKey('yearIncrement'))">
a.year=ifnull(a.year,0) + #{data.yearIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('month')) or (colPickMode==1 and !data.containsKey('month'))">
a.month=#{data.month},
</if>
<if test="(colPickMode==0 and data.containsKey('monthIncrement')) or (colPickMode==1 and !data.containsKey('monthIncrement'))">
a.month=ifnull(a.month,0) + #{data.monthIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('day')) or (colPickMode==1 and !data.containsKey('day'))">
a.day=#{data.day},
</if>
<if test="(colPickMode==0 and data.containsKey('dayIncrement')) or (colPickMode==1 and !data.containsKey('dayIncrement'))">
a.day=ifnull(a.day,0) + #{data.dayIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('hour')) or (colPickMode==1 and !data.containsKey('hour'))">
a.hour=#{data.hour},
</if>
<if test="(colPickMode==0 and data.containsKey('hourIncrement')) or (colPickMode==1 and !data.containsKey('hourIncrement'))">
a.hour=ifnull(a.hour,0) + #{data.hourIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_realtime_dataflow_stat as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="siteId=(case" suffix="ELSE siteId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('siteId')) or (colPickMode==1 and !item.containsKey('siteId'))">
when a.id=#{item.id} then #{item.siteId}
</when>
<when test="(colPickMode==0 and item.containsKey('siteIdIncrement')) or (colPickMode==1 and !item.containsKey('siteIdIncrement'))">
when a.id=#{item.id} then ifnull(a.siteId,0) + #{item.siteIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="siteName=(case" suffix="ELSE siteName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('siteName')) or (colPickMode==1 and !item.containsKey('siteName'))">
when a.id=#{item.id} then #{item.siteName}
</if>
</foreach>
</trim>
<trim prefix="personSum=(case" suffix="ELSE personSum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('personSum')) or (colPickMode==1 and !item.containsKey('personSum'))">
when a.id=#{item.id} then #{item.personSum}
</when>
<when test="(colPickMode==0 and item.containsKey('personSumIncrement')) or (colPickMode==1 and !item.containsKey('personSumIncrement'))">
when a.id=#{item.id} then ifnull(a.personSum,0) + #{item.personSumIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="strangerSum=(case" suffix="ELSE strangerSum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('strangerSum')) or (colPickMode==1 and !item.containsKey('strangerSum'))">
when a.id=#{item.id} then #{item.strangerSum}
</when>
<when test="(colPickMode==0 and item.containsKey('strangerSumIncrement')) or (colPickMode==1 and !item.containsKey('strangerSumIncrement'))">
when a.id=#{item.id} then ifnull(a.strangerSum,0) + #{item.strangerSumIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="recoginzeSum=(case" suffix="ELSE recoginzeSum end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('recoginzeSum')) or (colPickMode==1 and !item.containsKey('recoginzeSum'))">
when a.id=#{item.id} then #{item.recoginzeSum}
</when>
<when test="(colPickMode==0 and item.containsKey('recoginzeSumIncrement')) or (colPickMode==1 and !item.containsKey('recoginzeSumIncrement'))">
when a.id=#{item.id} then ifnull(a.recoginzeSum,0) + #{item.recoginzeSumIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="year=(case" suffix="ELSE year end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('year')) or (colPickMode==1 and !item.containsKey('year'))">
when a.id=#{item.id} then #{item.year}
</when>
<when test="(colPickMode==0 and item.containsKey('yearIncrement')) or (colPickMode==1 and !item.containsKey('yearIncrement'))">
when a.id=#{item.id} then ifnull(a.year,0) + #{item.yearIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="month=(case" suffix="ELSE month end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('month')) or (colPickMode==1 and !item.containsKey('month'))">
when a.id=#{item.id} then #{item.month}
</when>
<when test="(colPickMode==0 and item.containsKey('monthIncrement')) or (colPickMode==1 and !item.containsKey('monthIncrement'))">
when a.id=#{item.id} then ifnull(a.month,0) + #{item.monthIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="day=(case" suffix="ELSE day end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('day')) or (colPickMode==1 and !item.containsKey('day'))">
when a.id=#{item.id} then #{item.day}
</when>
<when test="(colPickMode==0 and item.containsKey('dayIncrement')) or (colPickMode==1 and !item.containsKey('dayIncrement'))">
when a.id=#{item.id} then ifnull(a.day,0) + #{item.dayIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="hour=(case" suffix="ELSE hour end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('hour')) or (colPickMode==1 and !item.containsKey('hour'))">
when a.id=#{item.id} then #{item.hour}
</when>
<when test="(colPickMode==0 and item.containsKey('hourIncrement')) or (colPickMode==1 and !item.containsKey('hourIncrement'))">
when a.id=#{item.id} then ifnull(a.hour,0) + #{item.hourIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="RealtimeDataflowStatEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_realtime_dataflow_stat as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_realtime_dataflow_stat as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_realtime_dataflow_stat where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_xhx_realtime_dataflow_stat where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_realtime_dataflow_stat where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_realtime_dataflow_stat as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="RealtimeDataflowStatEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_realtime_dataflow_stat as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_xhx_realtime_dataflow_stat as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('siteId')">
<if test="conditionParamRef.siteId != null ">
${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
</if>
<if test="conditionParamRef.siteId == null">
${_conditionType_} a.siteId is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteIdList') and conditionParamRef.siteIdList.size() > 0">
${_conditionType_} a.siteId in
<foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteIdNotList') and conditionParamRef.siteIdNotList.size() > 0">
${_conditionType_} a.siteId not in
<foreach collection="conditionParamRef.siteIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteIdStart') and conditionParamRef.siteIdStart != null">
${_conditionType_} a.siteId <![CDATA[ >= ]]> #{${_conditionParam_}.siteIdStart}
</if>
<if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
</if>
<if test="conditionParamRef.containsKey('siteName')">
<if test="conditionParamRef.siteName != null and conditionParamRef.siteName != ''">
${_conditionType_} a.siteName like #{${_conditionParam_}.siteName}
</if>
<if test="conditionParamRef.siteName == null">
${_conditionType_} a.siteName is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteNameList') and conditionParamRef.siteNameList.size() > 0">
${_conditionType_} a.siteName in
<foreach collection="conditionParamRef.siteNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteNameNotList') and conditionParamRef.siteNameNotList.size() > 0">
${_conditionType_} a.siteName not in
<foreach collection="conditionParamRef.siteNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('personSum')">
<if test="conditionParamRef.personSum != null ">
${_conditionType_} a.personSum = #{${_conditionParam_}.personSum}
</if>
<if test="conditionParamRef.personSum == null">
${_conditionType_} a.personSum is null
</if>
</if>
<if test="conditionParamRef.containsKey('personSumList') and conditionParamRef.personSumList.size() > 0">
${_conditionType_} a.personSum in
<foreach collection="conditionParamRef.personSumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('personSumNotList') and conditionParamRef.personSumNotList.size() > 0">
${_conditionType_} a.personSum not in
<foreach collection="conditionParamRef.personSumNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('personSumStart') and conditionParamRef.personSumStart != null">
${_conditionType_} a.personSum <![CDATA[ >= ]]> #{${_conditionParam_}.personSumStart}
</if>
<if test="conditionParamRef.containsKey('personSumEnd') and conditionParamRef.personSumEnd != null">
${_conditionType_} a.personSum <![CDATA[ <= ]]> #{${_conditionParam_}.personSumEnd}
</if>
<if test="conditionParamRef.containsKey('strangerSum')">
<if test="conditionParamRef.strangerSum != null ">
${_conditionType_} a.strangerSum = #{${_conditionParam_}.strangerSum}
</if>
<if test="conditionParamRef.strangerSum == null">
${_conditionType_} a.strangerSum is null
</if>
</if>
<if test="conditionParamRef.containsKey('strangerSumList') and conditionParamRef.strangerSumList.size() > 0">
${_conditionType_} a.strangerSum in
<foreach collection="conditionParamRef.strangerSumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('strangerSumNotList') and conditionParamRef.strangerSumNotList.size() > 0">
${_conditionType_} a.strangerSum not in
<foreach collection="conditionParamRef.strangerSumNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('strangerSumStart') and conditionParamRef.strangerSumStart != null">
${_conditionType_} a.strangerSum <![CDATA[ >= ]]> #{${_conditionParam_}.strangerSumStart}
</if>
<if test="conditionParamRef.containsKey('strangerSumEnd') and conditionParamRef.strangerSumEnd != null">
${_conditionType_} a.strangerSum <![CDATA[ <= ]]> #{${_conditionParam_}.strangerSumEnd}
</if>
<if test="conditionParamRef.containsKey('recoginzeSum')">
<if test="conditionParamRef.recoginzeSum != null ">
${_conditionType_} a.recoginzeSum = #{${_conditionParam_}.recoginzeSum}
</if>
<if test="conditionParamRef.recoginzeSum == null">
${_conditionType_} a.recoginzeSum is null
</if>
</if>
<if test="conditionParamRef.containsKey('recoginzeSumList') and conditionParamRef.recoginzeSumList.size() > 0">
${_conditionType_} a.recoginzeSum in
<foreach collection="conditionParamRef.recoginzeSumList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('recoginzeSumNotList') and conditionParamRef.recoginzeSumNotList.size() > 0">
${_conditionType_} a.recoginzeSum not in
<foreach collection="conditionParamRef.recoginzeSumNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('recoginzeSumStart') and conditionParamRef.recoginzeSumStart != null">
${_conditionType_} a.recoginzeSum <![CDATA[ >= ]]> #{${_conditionParam_}.recoginzeSumStart}
</if>
<if test="conditionParamRef.containsKey('recoginzeSumEnd') and conditionParamRef.recoginzeSumEnd != null">
${_conditionType_} a.recoginzeSum <![CDATA[ <= ]]> #{${_conditionParam_}.recoginzeSumEnd}
</if>
<if test="conditionParamRef.containsKey('year')">
<if test="conditionParamRef.year != null ">
${_conditionType_} a.year = #{${_conditionParam_}.year}
</if>
<if test="conditionParamRef.year == null">
${_conditionType_} a.year is null
</if>
</if>
<if test="conditionParamRef.containsKey('yearList') and conditionParamRef.yearList.size() > 0">
${_conditionType_} a.year in
<foreach collection="conditionParamRef.yearList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('yearNotList') and conditionParamRef.yearNotList.size() > 0">
${_conditionType_} a.year not in
<foreach collection="conditionParamRef.yearNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('yearStart') and conditionParamRef.yearStart != null">
${_conditionType_} a.year <![CDATA[ >= ]]> #{${_conditionParam_}.yearStart}
</if>
<if test="conditionParamRef.containsKey('yearEnd') and conditionParamRef.yearEnd != null">
${_conditionType_} a.year <![CDATA[ <= ]]> #{${_conditionParam_}.yearEnd}
</if>
<if test="conditionParamRef.containsKey('month')">
<if test="conditionParamRef.month != null ">
${_conditionType_} a.month = #{${_conditionParam_}.month}
</if>
<if test="conditionParamRef.month == null">
${_conditionType_} a.month is null
</if>
</if>
<if test="conditionParamRef.containsKey('monthList') and conditionParamRef.monthList.size() > 0">
${_conditionType_} a.month in
<foreach collection="conditionParamRef.monthList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('monthNotList') and conditionParamRef.monthNotList.size() > 0">
${_conditionType_} a.month not in
<foreach collection="conditionParamRef.monthNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('monthStart') and conditionParamRef.monthStart != null">
${_conditionType_} a.month <![CDATA[ >= ]]> #{${_conditionParam_}.monthStart}
</if>
<if test="conditionParamRef.containsKey('monthEnd') and conditionParamRef.monthEnd != null">
${_conditionType_} a.month <![CDATA[ <= ]]> #{${_conditionParam_}.monthEnd}
</if>
<if test="conditionParamRef.containsKey('day')">
<if test="conditionParamRef.day != null ">
${_conditionType_} a.day = #{${_conditionParam_}.day}
</if>
<if test="conditionParamRef.day == null">
${_conditionType_} a.day is null
</if>
</if>
<if test="conditionParamRef.containsKey('dayList') and conditionParamRef.dayList.size() > 0">
${_conditionType_} a.day in
<foreach collection="conditionParamRef.dayList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('dayNotList') and conditionParamRef.dayNotList.size() > 0">
${_conditionType_} a.day not in
<foreach collection="conditionParamRef.dayNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('dayStart') and conditionParamRef.dayStart != null">
${_conditionType_} a.day <![CDATA[ >= ]]> #{${_conditionParam_}.dayStart}
</if>
<if test="conditionParamRef.containsKey('dayEnd') and conditionParamRef.dayEnd != null">
${_conditionType_} a.day <![CDATA[ <= ]]> #{${_conditionParam_}.dayEnd}
</if>
<if test="conditionParamRef.containsKey('hour')">
<if test="conditionParamRef.hour != null ">
${_conditionType_} a.hour = #{${_conditionParam_}.hour}
</if>
<if test="conditionParamRef.hour == null">
${_conditionType_} a.hour is null
</if>
</if>
<if test="conditionParamRef.containsKey('hourList') and conditionParamRef.hourList.size() > 0">
${_conditionType_} a.hour in
<foreach collection="conditionParamRef.hourList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('hourNotList') and conditionParamRef.hourNotList.size() > 0">
${_conditionType_} a.hour not in
<foreach collection="conditionParamRef.hourNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('hourStart') and conditionParamRef.hourStart != null">
${_conditionType_} a.hour <![CDATA[ >= ]]> #{${_conditionParam_}.hourStart}
</if>
<if test="conditionParamRef.containsKey('hourEnd') and conditionParamRef.hourEnd != null">
${_conditionType_} a.hour <![CDATA[ <= ]]> #{${_conditionParam_}.hourEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteId')">
a.siteId
<if test='orderCol.siteId != null and "DESC".equalsIgnoreCase(orderCol.siteId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteName')">
a.siteName
<if test='orderCol.siteName != null and "DESC".equalsIgnoreCase(orderCol.siteName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('personSum')">
a.personSum
<if test='orderCol.personSum != null and "DESC".equalsIgnoreCase(orderCol.personSum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('strangerSum')">
a.strangerSum
<if test='orderCol.strangerSum != null and "DESC".equalsIgnoreCase(orderCol.strangerSum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('recoginzeSum')">
a.recoginzeSum
<if test='orderCol.recoginzeSum != null and "DESC".equalsIgnoreCase(orderCol.recoginzeSum)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('year')">
a.year
<if test='orderCol.year != null and "DESC".equalsIgnoreCase(orderCol.year)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('month')">
a.month
<if test='orderCol.month != null and "DESC".equalsIgnoreCase(orderCol.month)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('day')">
a.day
<if test='orderCol.day != null and "DESC".equalsIgnoreCase(orderCol.day)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('hour')">
a.hour
<if test='orderCol.hour != null and "DESC".equalsIgnoreCase(orderCol.hour)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
refined-manager/src/test/java/com/mortals/httpclient/realtime/RealtimeDataflowStatController.http 0 → 100644
View file @ 9804dbad
###登录
POST {{baseUrl}}/login/login
Content-Type: application/json
{
"loginName":"admin",
"password":"admin",
"securityCode":"8888"
}
> {%
client.global.set("SmsSet_id", JSON.parse(response.body).data.id);
client.global.set("authToken", JSON.parse(response.body).data.token);
%}
###人员流量统计列表
POST {{baseUrl}}/realtime/dataflow/stat/list
Authorization: {{authToken}}
Content-Type: application/json
{
"page":1,
"size":10
}
###人员流量统计更新与保存
POST {{baseUrl}}/realtime/dataflow/stat/save
Authorization: {{authToken}}
Content-Type: application/json
{
"siteId":818,
"siteName":"51hmqj",
"personSum":924,
"strangerSum":704,
"recoginzeSum":196,
"year":390,
"month":201,
"day":998,
"hour":416,
}
> {%
client.global.set("RealtimeDataflowStat_id", JSON.parse(response.body).data.id);
%}
###人员流量统计查看
GET {{baseUrl}}/realtime/dataflow/stat/info?id={{RealtimeDataflowStat_id}}
Authorization: {{authToken}}
Accept: application/json
###人员流量统计编辑
GET {{baseUrl}}/realtime/dataflow/stat/edit?id={{RealtimeDataflowStat_id}}
Authorization: {{authToken}}
Accept: application/json
###人员流量统计删除
GET {{baseUrl}}/realtime/dataflow/stat/delete?id={{RealtimeDataflowStat_id}}
Authorization: {{authToken}}
Accept: application/json
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment