Alluxio 集群环境搭建

最新推荐文章于 2023-06-09 17:53:32 发布

chengsao5165

最新推荐文章于 2023-06-09 17:53:32 发布

阅读量405

点赞数

原文链接：https://my.oschina.net/u/3424826/blog/1975934

版权

单节点启动
验证本机的环境
./bin/alluxio validateEnv local
只需要配置alluxio.master.hostname即可
alluxio.master.hostname=hadoop-slave2
然后我们启动alluxio，访问
http://192.168.12.203:19999
访问成功说明启动成功

然后配置hadoop的namenode节点，映射到HDFS上
hdfs://hadoop-master:9000/alluxio

然后使用alluxio自带的test跑一遍测试用例
./alluxio runTests

在Hadoop NameNode上查看刚才跑的测试用例
http://192.168.12.201:50070
在/alluxio文件夹下可以返现

网站demo
https://blog.csdn.net/duan_zhihua/article/details/79327383

alluxio单机安装部署
https://blog.csdn.net/duan_zhihua/article/details/79315918

设置alluxio home
#ALLUXIO HOME
export ALLUXIO_HOME=/data/alluxio/alluxio
export PATH=$PATH:$ALLUXIO_HOME/bin

验证
alluxio version
1.7.0

配置alluxio-site.properties
# Common properties
alluxio.master.hostname=hadoop-slave2
alluxio.underfs.address=hdfs://hadoop-master:9000/alluxio

执行alluxio文件格式化
./alluxio format

然后启动alluxio
./alluxio-start.sh local

mount | grep ramdisk
ramfs on /mnt/ramdisk type ramfs (rw,relatime,size=44885688320)
当前新增了一个映射ramdisk

jps查看
25970 AlluxioMaster
25972 AlluxioSecondaryMaster
26249 AlluxioWorker
26251 AlluxioProxy

查看http://192.168.12.203:19999
是否启动成功

运行Alluxio系统完整性检查
./alluxio runTests

因为文件系统映射到了HDFS上，所以如果test全部通过之后
可以在Hadoop的nameNode上看到当前测试通过生成的文件夹以及文件
http://192.168.12.201:50070

alluxio映射的amdisk中的内容
[root@hadoop-slave2 alluxioworker]# ls /mnt/ramdisk/alluxioworker/
419430400 452984832 486539264 520093696 553648128 587202560 620756992 654311424 687865856 721420288 788529152
436207616 469762048 503316480 536870912 570425344 603979776 637534208 671088640 704643072 738197504 805306368

停止单机alluxio
./alluxio-stop.sh local

#alluxio
export ALLUXIO_HOME=/data/alluxio/alluxio
export PATH=$PATH:$ALLUXIO_HOME/bin

scp -P 9922 alluxio-1.7.0-bin.tar.gz root@192.168.12.217:/data/install-package/

/alluxio/journal
/logs/alluxio/journal

201 master
203 worker
204 worker

alluxio.zookeeper.enabled=true
alluxio.zookeeper.address=192.168.12.201:2181,192.168.12.203:2181,192.168.12.204:2181
alluxio.master.journal.folder=hdfs://hadoop-master:9000/logs/alluxio/journal

alluxioMaster 201
HA 217
worker 203
worker 204
worker 33

SELECT
COALESCE (count(*), 0)
FROM
(
SELECT
(
CASE
WHEN biz_bs.waiter_id IS NULL THEN
'无'
ELSE
emp. NAME
END
) "waiterName",
(
CASE
WHEN emp."deptId" IS NULL THEN
'无'
ELSE
emp."deptName"
END
) "deptName",
(
CASE
WHEN biz_bs.waiter_id IS NULL THEN
'无'
ELSE
emp. NAME
END
) AS "data1",
waiter_id AS "waiterId",
emp."deptId" AS "deptId",
COUNT(DISTINCT biz_bs.ID) AS "fwts",
SUM(biz_bs.orig_total) AS "csje",
SUM(biz_bs.orig_total) AS "data13",
biz_bs.create_shop_id AS "shopId"
FROM
biz_bs
LEFT JOIN (
SELECT
emp.ID,
emp. CODE,
emp. NAME,
dept.ID AS "deptId",
dept. NAME "deptName",
shop. NAME "shopName"
FROM
(
SELECT
ID,
CODE,
NAME,
dept_id,
belong_shop_id
FROM
dbi_emp
WHERE

create_shop_id = cast('9759' as integer )
) emp
LEFT JOIN (
SELECT
ID,
NAME
FROM
dbi_dept
WHERE

create_shop_id = cast('9759' as integer )

) dept ON emp.dept_id = dept.ID
LEFT JOIN dbi_shop shop ON shop.ID = emp.belong_shop_id
) emp ON emp.ID = biz_bs.waiter_id
WHERE
biz_bs.STATE = 1

AND create_shop_id IN
('11755')

AND settle_biz_date >= to_timestamp ('2018-04-10 00:00:00', 'yyyy-MM-dd')
AND settle_biz_date <= to_timestamp ('2018-04-10 23:59:59', 'yyyy-MM-dd')
AND STATE = 1
AND delflg = 0
GROUP BY
biz_bs.create_shop_id,
emp."deptName",
emp."deptId",
waiter_id,
emp. NAME
) AS t

select * from biz_bs where create_shop_id IN ('15589')
AND settle_time >= to_timestamp ('2018-04-10 00:00:00', 'yyyy-MM-dd')
AND settle_time < to_timestamp ('2018-04-10 23:59:59', 'yyyy-MM-dd')

SELECT
(
CASE
WHEN biz_bs.waiter_id IS NULL THEN
'未知'
ELSE
emp. NAME
END
) "empName",
ROUND(COALESCE(SUM (biz_bs.orig_total),0),2) empAmount
FROM
biz_bs
LEFT JOIN (
SELECT
emp. ID,
emp.code,
emp. NAME,
dept. ID AS "deptId",
dept. NAME "deptName",
shop. NAME "shopName"
FROM
(
SELECT
ID,
code,
NAME,
dept_id,
belong_shop_id
FROM
dbi_emp
WHERE

create_shop_id = cast('3217' as integer )

) emp
LEFT JOIN (
SELECT
ID,
NAME
FROM
dbi_dept
WHERE

create_shop_id = cast('3217' as integer )

) dept ON emp.dept_id = dept. ID
LEFT JOIN dbi_shop shop ON shop. ID = emp.belong_shop_id
) emp ON emp. ID = biz_bs.waiter_id
WHERE
biz_bs. STATE = 1

AND create_shop_id IN

('15589')

AND settle_time >= to_timestamp('2018-04-10 00:00:00', 'yyyy-MM-dd')
AND settle_time < to_timestamp('2018-04-10 23:59:59', 'yyyy-MM-dd')
AND STATE = 1
AND delflg = 0
GROUP BY
biz_bs.create_shop_id,
emp."deptName",
emp."deptId",
waiter_id,
emp. NAME













































package cn.com.tcsl.loongboss.report.biz.corp.service.impl;

import cn.com.tcsl.loongboss.common.constant.Constant;
import cn.com.tcsl.loongboss.common.constant.LoongBossEsConstant;
import cn.com.tcsl.loongboss.common.constant.LoongBossServiceResultConstant;
import cn.com.tcsl.loongboss.common.util.DateUtils;
import cn.com.tcsl.loongboss.common.util.DigitsUtils;
import cn.com.tcsl.loongboss.cy7.api.model.business.*;
import cn.com.tcsl.loongboss.cy7.client.BusinessAnalysisClient;
import cn.com.tcsl.loongboss.report.api.model.account.AccountTrendDTO;
import cn.com.tcsl.loongboss.report.api.model.business.*;
import cn.com.tcsl.loongboss.report.api.service.corp.AccountAnalysisService;
import cn.com.tcsl.loongboss.report.api.service.corp.BusinessAnalysisService;
import cn.com.tcsl.loongboss.report.biz.corp.entity.converter.BusinessAnalysisConverter;
import cn.com.tcsl.loongboss.report.biz.corp.service.dao.BusinessAnalysisDao;
import cn.com.tcsl.loongboss.report.biz.corp.service.repository.es.BusinessAnalysisEsRepository;
import cn.com.tcsl.loongboss.sys.api.model.SysGoalDTO;
import cn.com.tcsl.loongboss.sys.api.model.UserStorePermissionInDTO;
import cn.com.tcsl.loongboss.sys.api.model.account.AccountInDTO;
import cn.com.tcsl.loongboss.sys.api.model.account.AccountTotalDTO;
import cn.com.tcsl.loongboss.sys.client.SysAccountClient;
import cn.com.tcsl.loongboss.sys.client.SysGoalClient;
import cn.com.tcsl.loongboss.sys.client.SysUserClient;
import cn.com.tcsl.scmsframework.common.model.ResponseResult;
import cn.com.tcsl.scmsframework.common.model.ServiceResult;
import cn.com.tcsl.scmsframework.common.util.DateUtil;
import cn.com.tcsl.scmsframework.context.Privilege;
import com.alibaba.fastjson.JSONObject;
import com.google.common.primitives.Ints;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.assertj.core.util.Lists;
import org.assertj.core.util.Strings;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramInterval;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

import static cn.com.tcsl.loongboss.common.constant.Constant.ElasticsearchIndexType.*;
import static cn.com.tcsl.loongboss.common.constant.Constant.ElasticsearchStatisticsType.*;
import static cn.com.tcsl.loongboss.common.constant.Constant.TimeType.DAY;
import static cn.com.tcsl.loongboss.common.constant.Constant.TimeType.TODAY;
import static cn.com.tcsl.loongboss.common.constant.LoongBossEsConstant.*;
import static cn.com.tcsl.loongboss.common.constant.LoongBossEsConstant.CODE;
import static cn.com.tcsl.loongboss.common.constant.LoongBossParamConstant.*;
import static cn.com.tcsl.loongboss.common.constant.LoongBossServiceResultConstant.STORE_AMOUNT_RANKING_SQL_EXCEPTION;
import static cn.com.tcsl.loongboss.common.constant.LoongBossServiceResultConstant.STORE_BUSINESS_AMOUNT_SQL_EXCEPTION;
import static cn.com.tcsl.loongboss.common.util.DateUtils.*;
import static java.util.stream.Collectors.toList;

/**
* @package: cn.com.tcsl.loongboss.report.biz.corp.service.impl
* @project-name: tcsl-loongboss-parent
* @description: 营业分析业务逻辑实现
* @author: Created by 刘凯峰
* @create-datetime: 2017-10-30 10-31
*/
@Service("businessAnalysisService")
public class BusinessAnalysisServiceImpl implements BusinessAnalysisService {

//region 构造函数注入
//初始化一年当中的12个月时间坐标轴
private static final List<CommonDetailBean> MONTHS_A_YEAR = getDefault12MonthsAYear();
private Logger logger = LogManager.getLogger(this.getClass());

private final BusinessAnalysisDao businessAnalysisDao;
//查询当天数据
private final BusinessAnalysisClient businessAnalysisClient;
//查询保本线
private final SysAccountClient sysAccountClient;
//查询营业目标
private final SysGoalClient sysGoalClient;
//查询用户可查看门店权限
private final SysUserClient sysUserClient;
//报表查询入参校验
private final ReportInParamCheckService reportInParamCheckService;
//查询全年范围每月的总支出
private final AccountAnalysisService accountAnalysisService;
private final BusinessAnalysisEsRepository businessAnalysisEsRespository;
//线程内全局变量，营业目标
private final ThreadLocal<Object> businessGoalLocal = new ThreadLocal<>();
//线程内全局变量，保本线
private final ThreadLocal<Object> breakEvenLinesLocal = new ThreadLocal<>();

@Autowired
public BusinessAnalysisServiceImpl(
BusinessAnalysisDao businessAnalysisDao,
BusinessAnalysisClient businessAnalysisClient,
SysAccountClient sysAccountClient,
SysGoalClient sysGoalClient,
SysUserClient sysUserClient,
AccountAnalysisService accountAnalysisService,
BusinessAnalysisEsRepository businessAnalysisEsRespository,
ReportInParamCheckService reportInParamCheckService) {

this.businessAnalysisDao = businessAnalysisDao;
this.businessAnalysisClient = businessAnalysisClient;
this.sysAccountClient = sysAccountClient;
this.sysGoalClient = sysGoalClient;
this.sysUserClient = sysUserClient;
this.accountAnalysisService = accountAnalysisService;
this.businessAnalysisEsRespository = businessAnalysisEsRespository;
this.reportInParamCheckService = reportInParamCheckService;
}

//endregion

// region 营业统计

/**
* @param commonInDTO 入参信息
* @method-name: businessStatisticsService
* @description: 营业统计(营业额, 实际收入, 优惠金额, 客单数, 平均客单价, 非收入金额)
* @author: 刘凯峰
* @date: 2017/10/31 14:51
* @param:
* @return:
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name: 刘凯峰
* date: 2018年1月22日
* description:代码优化
* 1.将ES统计方法抽离
* 2.将原有变量封装成对象
* *****************************************************
*/
@Override
public ServiceResult<BusinessStatisticsOutDTO> queryBusinessStatisticsService(CommonInDTO commonInDTO) {
//入参校验，空值校验，日期格式校验
ServiceResult<String> checkResult = reportInParamCheckService.checkParam(commonInDTO);
if ((ZERO).equals(checkResult.getCode())) {
if (commonInDTO.getTimeFlag() == MINUS_ONE) {
return businessStatisticsSqlService(commonInDTO);
}
if (DateUtils.isToday(commonInDTO.getBeginTime())) {
return businessStatisticsSqlService(commonInDTO);
}
//统计营业额(type_id=10)、优惠金额(type_id=12)、实际收入(type_id=11)、客单数(type_id=15)、平均客单价(type_id=16)、非收入金额（type_id=60）
BusinessStatisticsEsDTO businessStatisticsEsDTO = buildBusinessStatisticsEsCondition(commonInDTO);
BusinessStatisticsOutDTO businessStatisticsOutDTO = businessAnalysisEsRespository.queryBusinessStatisticsEs(businessStatisticsEsDTO);
//营业额
Double businessAmount = Objects.isNull(businessStatisticsOutDTO.getBusiTotal()) ? 0d : Double.valueOf(businessStatisticsOutDTO.getBusiTotal());
//客单数
Double orderNum = Objects.isNull(businessStatisticsOutDTO.getBsCount()) ? 0d : Double.valueOf(businessStatisticsOutDTO.getBsCount());

//平均客单价(营业额或实际收入除以单数),需要从数据库查询
Double avgUnitPrice = orderNum > 0 ? DigitsUtils.division(businessAmount, orderNum) : 0d;
businessStatisticsOutDTO.setAvgBsPrice(DigitsUtils.doubleRoundOff2String(avgUnitPrice));
if (commonInDTO.getTimeFlag().equals(TODAY.getKey())) {
//营业目标
double businessGoal = queryBusinessGoal(commonInDTO);
businessStatisticsOutDTO.setBusiGoal(String.valueOf(businessGoal));
if (!ZERO.equals(businessStatisticsOutDTO.getBusiGoal())) {
double finishRate = DigitsUtils.division(businessAmount, businessGoal);
businessStatisticsOutDTO.setFinishRate(DigitsUtils.getNoPercentFormat(finishRate));
}
}
return ServiceResult.success(businessStatisticsOutDTO);
} else {
return ServiceResult.failure(checkResult.getCode(), checkResult.getMsg());
}
}

/**
* @method-name: businessStatisticsSqlService
* @description: 营业统计当天数据（SQL）
* @author: 刘凯峰
* @date: 2017/11/7 14:20
* @param: [commonInDTO]
* @return: cn.com.tcsl.scmsframework.common.model.ServiceResult<cn.com.tcsl.loongboss.report.api.model.business.BusinessStatisticsOutDTO>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private ServiceResult<BusinessStatisticsOutDTO> businessStatisticsSqlService(CommonInDTO commonInDTO) {
BusinessStatisticsOutDTO statisticsOutDTO = new BusinessStatisticsOutDTO();
BusinessReportInDTO inDTO = buildSqlCondition(commonInDTO);
ResponseResult<BusinessReportOutDTO> outResult = businessAnalysisClient.queryBusinessDaily(inDTO);
if (ZERO.equals(outResult.getCode()) && (outResult.getData() != null)) {
BusinessReportOutDTO outDTO = outResult.getData();
statisticsOutDTO.setBusiTotal(DigitsUtils.doubleRoundOff2String(outDTO.getBusinessAmount()));
statisticsOutDTO.setAvgBsPrice(DigitsUtils.doubleRoundOff2String(outDTO.getAvgAmount()));
statisticsOutDTO.setIncomeTotal(DigitsUtils.doubleRoundOff2String(outDTO.getActualIncomeAmount()));
statisticsOutDTO.setDiscTotal(DigitsUtils.doubleRoundOff2String(outDTO.getCouponAmount()));
statisticsOutDTO.setBsCount(String.valueOf(outDTO.getOrderCount()));
double businessGoal = queryBusinessGoal(commonInDTO);
if (!ZERO.equals(statisticsOutDTO.getBusiGoal())) {
double finishRate = DigitsUtils.division(outDTO.getBusinessAmount(), businessGoal);
statisticsOutDTO.setFinishRate(DigitsUtils.getNoPercentFormat(finishRate));
}
}
return ServiceResult.success(statisticsOutDTO);
}

/**
* @method-name: queryBusinessGoal
* @description: 查询营业目标
* @author: 刘凯峰
* @date: 2017/12/8 9:14
* @param: [commonInDTO]
* @return: java.lang.Double
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private Double queryBusinessGoal(CommonInDTO commonInDTO) {
double businessGoal = 0d;
/*查询营业目标*/
SysGoalDTO sysGoalDTO = new SysGoalDTO();
sysGoalDTO.setGroupCode(commonInDTO.getGroupCode());
sysGoalDTO.setStoreCode(commonInDTO.getStoreCode());
ResponseResult<SysGoalDTO> businessGoalResult = sysGoalClient.getGoalInfo(sysGoalDTO);
if (ZERO.equals(businessGoalResult.getCode())) {
if (Objects.nonNull(businessGoalResult.getData()) && !Strings.isNullOrEmpty(businessGoalResult.getData().getTurnover())) {
if (businessGoalResult.getData().getTurnoverFlag() == 1) {
businessGoal = Double.valueOf(businessGoalResult.getData().getTurnover());
}
}
}
return businessGoal;
}

/**
* 查询营业目标开启还是关闭状态
*
* @param commonInDTO
* @return
*/
private Boolean queryBusinessGoalStatus(CommonInDTO commonInDTO) {

Boolean businessGoalStatus = false;
/*查询营业目标*/
SysGoalDTO sysGoalDTO = new SysGoalDTO();
sysGoalDTO.setGroupCode(commonInDTO.getGroupCode());
sysGoalDTO.setStoreCode(commonInDTO.getStoreCode());
ResponseResult<SysGoalDTO> businessGoalResult = sysGoalClient.getGoalInfo(sysGoalDTO);
if (ZERO.equals(businessGoalResult.getCode())) {
if (Objects.nonNull(businessGoalResult.getData()) && Objects.nonNull(businessGoalResult.getData().getTurnoverStatus())) {
if (businessGoalResult.getData().getTurnoverStatus() == 1) {
businessGoalStatus = true;
}

}
}
return businessGoalStatus;

}

/**
* @method-name: buildBusinessStatisticsEsCondition
* @description: 构建营业统计ES查询条件
* @author: 刘凯峰
* @date: 2018/1/22 14:57
* @param: [commonInDTO]
* @return: cn.com.tcsl.loongboss.report.api.model.business.BusinessStatisticsEsDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessStatisticsEsDTO buildBusinessStatisticsEsCondition(CommonInDTO commonInDTO) {
BusinessStatisticsEsDTO businessStatisticsEsDTO = new BusinessStatisticsEsDTO();

String beginTime = DateUtils.timestampToDateTimeString(commonInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.getSomeDay(commonInDTO.getEndTime(), -1);

businessStatisticsEsDTO.setStoreCodeList(commonInDTO.getStoreCode());
businessStatisticsEsDTO.setStoreFieldName(STORE_CODE_FIELD_NAME);
businessStatisticsEsDTO.setIndexFieldName(RPT_INDICATES.getIndex());
businessStatisticsEsDTO.setTypeFieldName(RPT_INDICATES.getType());
businessStatisticsEsDTO.setGroupByFieldName(TYPE_ID_FIELD_NAME);
businessStatisticsEsDTO.setSumFieldName(AMOUNT_FIELD_NAME);
businessStatisticsEsDTO.setBeginTimeValue(beginTime);
businessStatisticsEsDTO.setEndTimeValue(endTime);
businessStatisticsEsDTO.setTimeFieldName(BIZ_DATE_FIELD_NAME);
businessStatisticsEsDTO.setTimeParamFormat(DateUtil.formate_date);
businessStatisticsEsDTO.setTypeIdFieldName(TYPE_ID_FIELD_NAME);
businessStatisticsEsDTO.setGroupFieldName(GROUP_CODE_FIELD_NAME);
businessStatisticsEsDTO.setGroupCode(commonInDTO.getGroupCode());
businessStatisticsEsDTO.setGroupQueryFlag(commonInDTO.getGroupQueryFlag());
List<Integer> typeIds = Lists.newArrayList();
typeIds.add(BUSINESS_AMOUNT.getKey());
typeIds.add(ACTUAL_INCORM_AMOUNT.getKey());
typeIds.add(COUPON_AMOUNT.getKey());
typeIds.add(ORDER_NUM.getKey());
typeIds.add(NOT_INCOME_AMOUNT.getKey());
businessStatisticsEsDTO.setTypeIdList(typeIds);
return businessStatisticsEsDTO;

}
//endregion

//region 营业趋势

/**
* @param businessTrendInDTO 营业趋势入参实体
* @method-name: businessTrendService
* @description: 营业趋势分析服务
* 营业额统计：各个时段的营业额、营业目标
* 实际收入统计：各个时段的营业额、计算保本线
* @author: 刘凯峰
* @date: 2017/10/30 11:58
* @param:
* @return:
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name: 刘凯峰
* date: 2018年1月20日
* description: 代码修改及优化
* 1.ES查询抽离
* 2.代码逻辑优化
* 3.添加字段空值营业目标和保本线是否在页面展示
* *****************************************************
*/
@Override
public ServiceResult<BusinessTrendOutDTO> queryBusinessTrendService(BusinessTrendInDTO businessTrendInDTO) {
//入参校验，空值校验，日期格式校验
ServiceResult<String> checkResult = reportInParamCheckService.checkParam(businessTrendInDTO);
if (!ZERO.equals(checkResult.getCode())) {
return ServiceResult.failure(checkResult.getCode(), checkResult.getMsg());
}
//时间区间相差天数
int days = DateUtils.getDays(businessTrendInDTO.getBeginTime(), businessTrendInDTO.getEndTime());
//时间区间在同一天，统计当天24小时营业额或实际收入
if (Objects.equals(days, 1)) {
businessTrendInDTO.setTimeFlag(Constant.TimeType.DAY.getKey());
}
//时间区间大于一天，统计每天的营业额或实际收入
<<<<<<< HEAD

if(Ints.compare(days,28) > 0){
businessTrendInDTO.setTimeFlag(Constant.TimeType.YEAR.getKey());
=======
if (businessTrendInDTO.getTimeFlag() == Constant.TimeType.DAY.getKey() && Ints.compare(days, 1) > 0) {
businessTrendInDTO.setTimeFlag(Constant.TimeType.WEEK.getKey());
>>>>>>> origin/develop
}

if(Ints.compare(days,7) > 0){
businessTrendInDTO.setTimeFlag(Constant.TimeType.MONTH.getKey());
}

if (Ints.compare(days, 1) > 0) {
businessTrendInDTO.setTimeFlag(Constant.TimeType.WEEK.getKey());
}

/*1-营业额*/
if (businessTrendInDTO.getTrendType().equals(1)) {
return queryBusinessTrendByAmount(businessTrendInDTO);
}
/*2-实际收入*/
if (businessTrendInDTO.getTrendType().equals(2)) {
return queryBusinessTrendByActualIncome(businessTrendInDTO);
}
return ServiceResult.success();
}

/**
* @method-name: queryBusinessTrendByAmount
* @description: 按营业额统计营业趋势
* 营业额统计：各个时段的营业额、营业目标
* 日营业目标：月营业目标/本月自然天数
* @author: 刘凯峰
* @date: 2017/11/1 18:06
* @param: [businessTrendInDTO, beginTime, endTime]
* @return: void
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name: 刘凯峰
* date: 2018-01-20
* description:改造营业趋势-营业额统计
* 1、将ES查询条件封装到对象，取缔原有的变量
* 2、业务判断逻辑梳理，精简代码
* *****************************************************
*/
private ServiceResult<BusinessTrendOutDTO> queryBusinessTrendByAmount(BusinessTrendInDTO businessTrendInDTO) {
BusinessTrendOutDTO businessTrendOutDTO = new BusinessTrendOutDTO();
//时间标识为按日统计
boolean isDay = Objects.equals(DAY.getKey(), businessTrendInDTO.getTimeFlag());
//时间标识为按今日统计
boolean isToday = Objects.equals(TODAY.getKey(), businessTrendInDTO.getTimeFlag());
//起始时间为今天
boolean isTodayTime = DateUtils.isToday(businessTrendInDTO.getBeginTime());
boolean businessGoalShow = false;
String beginTime = DateUtils.timestampToDateTimeString(businessTrendInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.getSomeDay(businessTrendInDTO.getEndTime(), -1, DateUtils.PATTERN_OF_DATE);
//月营业目标
String businessGoal = ZERO;
if (!businessTrendInDTO.getManyStores()) {
String goalBeginTime = beginTime + " " + DateUtils.DAY_OF_BEGIN;
String goalEndTime = endTime + " " + DateUtils.DAY_OF_END;
List<CommonDetailBean> goals = businessAnalysisDao.selectStoreBusinessGoals(businessTrendInDTO.getStoreCode().get(0), goalBeginTime, goalEndTime);
if (goals == null || goals.isEmpty()) {
businessGoal = ZERO;
} else {
businessGoal = goals.get(0).getTotalMoney();
businessGoalShow = true;
}
}
businessTrendInDTO.setBusinessGoal(businessGoal);
BusinessTrendEsDTO businessTrendEsDTO = buildBusinessAmountEsCondition(businessTrendInDTO);
//实时数据统计
if ((isToday)) {
businessTrendOutDTO = queryBusinessTrendSqlService(businessTrendInDTO);
} else if (isDay && isTodayTime) {
businessTrendOutDTO = queryBusinessTrendSqlService(businessTrendInDTO);
} else {
//ES统计营业额趋势
List<CommonDetailBean> commonDetailBeans = businessAnalysisEsRespository.queryBusinessTrendEs(businessTrendEsDTO);
if (commonDetailBeans != null && !commonDetailBeans.isEmpty()) {
businessTrendOutDTO.setBusinessDetail(commonDetailBeans);
}
}
//营业目标
businessTrendOutDTO.setBusinessGoal(businessGoalLocal.get());
//保本线
businessTrendOutDTO.setBreakEvenLine(Lists.newArrayList());
//页面显示营业目标
businessTrendOutDTO.setBusinessGoalShow(businessGoalShow);
businessGoalLocal.remove();
return ServiceResult.success(businessTrendOutDTO);
}

/**
* @method-name: buildBusinessAmountEsCondition
* @description: 营业分析-营业趋势-营业额-ES统计条件构建
* @author: 刘凯峰
* @date: 2018/1/20 10:58
* @param: [businessTrendInDTO]
* @return: cn.com.tcsl.loongboss.report.api.model.business.BusinessTrendEsDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessTrendEsDTO buildBusinessAmountEsCondition(BusinessTrendInDTO businessTrendInDTO) {
String beginTime = DateUtils.timestampToDateTimeString(businessTrendInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.getSomeDay(businessTrendInDTO.getEndTime(), -1, DateUtils.PATTERN_OF_DATE);
List<CommonDetailBean> goals = Lists.newArrayList();
CommonDetailBean goal = new CommonDetailBean();
//月营业目标
String businessGoal = businessTrendInDTO.getBusinessGoal();

BusinessTrendEsDTO esCondition = new BusinessTrendEsDTO();
esCondition.setStoreFieldName(STORE_CODE_FIELD_NAME);
esCondition.setStoreCodeList(businessTrendInDTO.getStoreCode());
esCondition.setTypeIdFieldName(TYPE_ID_FIELD_NAME);
esCondition.setTypeIdFieldValue(BUSINESS_AMOUNT.getKey());
esCondition.setTimeFieldName(BIZ_DATE_FIELD_NAME);
esCondition.setBeginTimeValue(beginTime);
esCondition.setEndTimeValue(endTime);
esCondition.setGroupQueryFlag(businessTrendInDTO.getGroupQueryFlag());
esCondition.setGroupCode(businessTrendInDTO.getGroupCode());
esCondition.setGroupFieldName(GROUP_CODE_FIELD_NAME);
//时间标识为按日统计
boolean isDay = Objects.equals(DAY.getKey(), businessTrendInDTO.getTimeFlag());
//起始时间为今天
boolean isTodayTime = DateUtils.isToday(businessTrendInDTO.getBeginTime());
//日营业目标
if (isDay || isTodayTime) {

int days = DateUtils.getMonthDays(beginTime);
goal.setTotalMoney(DigitsUtils.division2String(Double.valueOf(businessGoal), days));
goal.setTimeName("all");
goals.add(goal);
}
//按日统计
if (isDay && !isTodayTime) {
String begintime = beginTime.replaceAll("[-]", "");
String endtime = endTime.replaceAll("[-]", "");
esCondition.setGroupByFieldName(BIZ_HOUR_FIELD_NAME);
esCondition.setSumFieldName(BUSI_INCOME_FIELD_NAME);
esCondition.setBeginTimeValue(begintime);
esCondition.setEndTimeValue(endtime);
esCondition.setTimeParamFormat(DateUtils.PATTERN_OF_DATE_WITHOUT_LINE);
esCondition.setResultDateFormat(DateUtils.PATTERN_OF_DATE_WITHOUT_LINE);
esCondition.setIndexFieldName(RPT_INDICATES.getIndex());
esCondition.setTypeFieldName(RPT_INDICATES.getType());
esCondition.setDateHistogramInterval(null);
} else {
esCondition.setGroupByFieldName(BIZ_DATE_FIELD_NAME);
esCondition.setSumFieldName(AMOUNT_FIELD_NAME);
esCondition.setTimeParamFormat(DateUtils.PATTERN_OF_DATE);
esCondition.setResultDateFormat(DateUtils.PATTERN_OF_DATE);
esCondition.setIndexFieldName(RPT_INDICATES.getIndex());
esCondition.setTypeFieldName(RPT_INDICATES.getType());

//统计一周中每天
if (Objects.equals(Constant.TimeType.WEEK.getKey(), businessTrendInDTO.getTimeFlag())) {
esCondition.setDateHistogramInterval(DateHistogramInterval.DAY);
//周营业目标
Double weekGoal = DigitsUtils.division(Double.valueOf(businessGoal), 4d);
goal.setTotalMoney(DigitsUtils.doubleRoundOff2String(weekGoal));
goal.setTimeName("all");
goals.add(goal);
}
//统计一月的每一天
if (Constant.TimeType.MONTH.getKey() == businessTrendInDTO.getTimeFlag()) {
esCondition.setDateHistogramInterval(DateHistogramInterval.DAY);
goal.setTotalMoney(businessGoal);
goal.setTimeName("all");
goals.add(goal);
}
//统计一年中的每月
if (Constant.TimeType.YEAR.getKey() == businessTrendInDTO.getTimeFlag()) {
esCondition.setResultDateFormat(DateUtils.PATTERN_OF_MONTH);
esCondition.setDateHistogramInterval(DateHistogramInterval.MONTH);
if (!businessTrendInDTO.getManyStores()) {

//这里需要补齐坐标轴

goals = businessAnalysisDao.selectStoreBusinessGoals(businessTrendInDTO.getStoreCode().get(0),
beginTime, endTime);
goals = get12MonthsAYear(goals);
}
}
}
businessGoalLocal.set(goals);
return esCondition;
}

/**
* @method-name: queryBusinessTrendByActualIncome
* @description: 按实际收入统计营业趋势
* @author: 刘凯峰
* @date: 2017/11/1 18:07
* @param: [businessTrendInDTO, beginTime, endTime]
* @return: void
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private ServiceResult<BusinessTrendOutDTO> queryBusinessTrendByActualIncome(BusinessTrendInDTO businessTrendInDTO) {
//时间标识为按日统计
boolean isDay = Objects.equals(DAY.getKey(), businessTrendInDTO.getTimeFlag());
//时间标识为按今日统计
boolean isToday = Objects.equals(TODAY.getKey(), businessTrendInDTO.getTimeFlag());
//起始时间为今天
boolean isTodayTime = DateUtils.isToday(businessTrendInDTO.getBeginTime());
//实际收入趋势结果集
BusinessTrendOutDTO businessTrendOutDTO = new BusinessTrendOutDTO();
double breakevenLineValue = 0d;
boolean breakEvenLineShow = false;
/*获取保本线*/
if (!businessTrendInDTO.getManyStores()) {
ServiceResult<Double> breakevenLineResult = queryBreakevenLine(businessTrendInDTO);
if (ZERO.equals(breakevenLineResult.getCode())) {
breakevenLineValue = breakevenLineResult.getResult();
}
breakEvenLineShow = breakevenLineValue > 0;
}
businessTrendInDTO.setBreakevenLine(breakevenLineValue);
//构建实际收入ES统计条件
BusinessTrendEsDTO businessTrendEsDTO = buildBusinessActualIncomeEsCondition(businessTrendInDTO);
if ((isToday)) {
businessTrendOutDTO = queryBusinessTrendSqlService(businessTrendInDTO);
} else if (isDay && isTodayTime) {
businessTrendOutDTO = queryBusinessTrendSqlService(businessTrendInDTO);
} else {
//ES统计实际收入趋势
List<CommonDetailBean> commonDetailBeans = businessAnalysisEsRespository.queryBusinessTrendEs(businessTrendEsDTO);
businessTrendOutDTO.setBusinessDetail(commonDetailBeans);
}
businessTrendOutDTO.setBreakEvenLine(breakEvenLinesLocal.get());
businessTrendOutDTO.setBreakEvenLineShow(breakEvenLineShow);
breakEvenLinesLocal.remove();
return ServiceResult.success(businessTrendOutDTO);
}

/**
* @method-name: buildBusinessActualIncomeEsCondition
* @description: 营业分析-营业趋势-实际收入-ES统计条件构建
* @author: 刘凯峰
* @date: 2018/1/20 11:06
* @param: [businessTrendInDTO]
* @return: cn.com.tcsl.loongboss.report.api.model.business.BusinessTrendEsDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessTrendEsDTO buildBusinessActualIncomeEsCondition(BusinessTrendInDTO businessTrendInDTO) {
String beginTime = DateUtils.timestampToDateTimeString(businessTrendInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.getSomeDay(businessTrendInDTO.getEndTime(), -1, DateUtils.PATTERN_OF_DATE);

double breakevenLineValue = businessTrendInDTO.getBreakevenLine();
List<CommonDetailBean> breakEvenLines = Lists.newArrayList();
CommonDetailBean breakEvenLine = new CommonDetailBean();
BusinessTrendEsDTO esCondition = new BusinessTrendEsDTO();
esCondition.setStoreFieldName(STORE_CODE_FIELD_NAME);
esCondition.setStoreCodeList(businessTrendInDTO.getStoreCode());
esCondition.setTypeIdFieldName(TYPE_ID_FIELD_NAME);
esCondition.setTypeIdFieldValue(ACTUAL_INCORM_AMOUNT.getKey());
esCondition.setTimeFieldName(BIZ_DATE_FIELD_NAME);
esCondition.setBeginTimeValue(beginTime);
esCondition.setEndTimeValue(endTime);
esCondition.setGroupCode(businessTrendInDTO.getGroupCode());
esCondition.setGroupQueryFlag(businessTrendInDTO.getGroupQueryFlag());
esCondition.setGroupFieldName(GROUP_CODE_FIELD_NAME);
//时间标识为按日统计
boolean isDay = Objects.equals(DAY.getKey(), businessTrendInDTO.getTimeFlag());
//起始时间为今天
boolean isTodayTime = DateUtils.isToday(businessTrendInDTO.getBeginTime());
if (isDay || isTodayTime) {
//日保本线
int days = DateUtils.getMonthDays(beginTime);
breakEvenLine.setTotalMoney(DigitsUtils.doubleRoundOff2String(DigitsUtils.division(breakevenLineValue, days)));
breakEvenLine.setTimeName("all");
breakEvenLines.add(breakEvenLine);
}
//按日统计
if (isDay && !isTodayTime) {
String begintime = beginTime.replaceAll("[-]", "");
String endtime = endTime.replaceAll("[-]", "");
esCondition.setGroupByFieldName(BIZ_HOUR_FIELD_NAME);
esCondition.setSumFieldName(ORIG_TOTAL_FIELD_NAME);
esCondition.setBeginTimeValue(begintime);
esCondition.setEndTimeValue(endtime);
esCondition.setTimeParamFormat(DateUtils.PATTERN_OF_DATE_WITHOUT_LINE);
esCondition.setResultDateFormat(DateUtils.PATTERN_OF_DATE_WITHOUT_LINE);
esCondition.setIndexFieldName(RPT_INDICATES_DAY.getIndex());
esCondition.setTypeFieldName(RPT_INDICATES_DAY.getType());
esCondition.setDateHistogramInterval(null);
} else {
esCondition.setGroupByFieldName(BIZ_DATE_FIELD_NAME);
esCondition.setSumFieldName(AMOUNT_FIELD_NAME);
esCondition.setTimeParamFormat(DateUtils.PATTERN_OF_DATE);
esCondition.setResultDateFormat(DateUtils.PATTERN_OF_DATE);
esCondition.setIndexFieldName(RPT_INDICATES.getIndex());
esCondition.setTypeFieldName(RPT_INDICATES.getType());

//统计一周中每天实际收入
if (Constant.TimeType.WEEK.getKey() == businessTrendInDTO.getTimeFlag()) {
esCondition.setDateHistogramInterval(DateHistogramInterval.DAY);
//周保本线
breakEvenLine.setTotalMoney(DigitsUtils.division2String(breakevenLineValue, 4));
breakEvenLine.setTimeName("all");
breakEvenLines.add(breakEvenLine);
}
//统计一月中每天实际收入
if (Constant.TimeType.MONTH.getKey() == businessTrendInDTO.getTimeFlag()) {
esCondition.setDateHistogramInterval(DateHistogramInterval.DAY);
//月保本线
breakEvenLine.setTotalMoney(DigitsUtils.doubleRoundOff2String(breakevenLineValue));
breakEvenLine.setTimeName("all");
breakEvenLines.add(breakEvenLine);
}
//统计一年中的每月实际收入
if (Constant.TimeType.YEAR.getKey() == businessTrendInDTO.getTimeFlag()) {
esCondition.setResultDateFormat(DateUtils.PATTERN_OF_MONTH);
esCondition.setDateHistogramInterval(DateHistogramInterval.MONTH);
if (!businessTrendInDTO.getManyStores()) {
breakEvenLines = queryMonthlyBreakevenLine(businessTrendInDTO);
}
}
}
breakEvenLinesLocal.set(breakEvenLines);
return esCondition;
}

/**
* @method-name: queryBusinessTrendSqlService
* @description: 当天营业趋势查询
* @author: 刘凯峰
* @date: 2017/11/7 14:54
* @param: [businessTrendInDTO]
* @return: cn.com.tcsl.scmsframework.common.model.ServiceResult<cn.com.tcsl.loongboss.report.api.model.business.BusinessTrendOutDTO>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessTrendOutDTO queryBusinessTrendSqlService(BusinessTrendInDTO businessTrendInDTO) {
/*获取营业趋势统计数据*/
BusinessReportInDTO reportInDTO = buildSqlCondition(businessTrendInDTO);
ResponseResult<List<BusinessTrendSqlOutDTO>> trendSqlResult = businessAnalysisClient.queryBusinessTrend(reportInDTO);
if (!ZERO.equals(trendSqlResult.getCode())) {
logger.info("【营业分析-营业趋势-SQL查询异常】-" + JSONObject.toJSONString(trendSqlResult));
}
BusinessTrendOutDTO trendOutDTO = new BusinessTrendOutDTO();
List<BusinessTrendSqlOutDTO> trendSqlOutDTOS = trendSqlResult.getData();
if (trendSqlOutDTOS == null || trendSqlOutDTOS.isEmpty()) {
return trendOutDTO;
}
List<CommonDetailBean> commonDetailBeans = Lists.newArrayList();
List<String> hours24 = getHours24();
trendSqlOutDTOS.forEach(trendSql -> {
CommonDetailBean commonDetailBean = new CommonDetailBean();
String timeName = getHour(trendSql.getHourName());
commonDetailBean.setTimeName(Strings.isNullOrEmpty(timeName) ? trendSql.getHourName() : timeName);
hours24.remove(commonDetailBean.getTimeName());
if (businessTrendInDTO.getTrendType().equals(1)) /*营业额*/ {
commonDetailBean.setTotalMoney(DigitsUtils.doubleRoundOff2String(trendSql.getBusinessAmount()));
}
if (businessTrendInDTO.getTrendType().equals(2)) /*实际收入*/ {
commonDetailBean.setTotalMoney(DigitsUtils.doubleRoundOff2String(trendSql.getActualincomeAmount()));
}
commonDetailBeans.add(commonDetailBean);
});
List<CommonDetailBean> fillHours24Bean = timeMapList2CommonBeanList(DateUtils.fillHours24(hours24));
if (!fillHours24Bean.isEmpty()) {
commonDetailBeans.addAll(fillHours24Bean);
}
List<CommonDetailBean> collect = commonDetailBeans.stream().sorted(Comparator.comparing(CommonDetailBean::getTimeName)).collect(toList());

if (!collect.isEmpty()) {
trendOutDTO.setBusinessDetail(collect);
}
return trendOutDTO;
}

/**
* @method-name: queryMonthlyBreakevenLine
* @description: 查询全年每月的保本线
* @author: 刘凯峰
* @date: 2017/12/7 15:30
* @param: [businessTrendInDTO]
* @return: java.util.List<cn.com.tcsl.loongboss.report.api.model.business.CommonDetailBean>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private List<CommonDetailBean> queryMonthlyBreakevenLine(BusinessTrendInDTO businessTrendInDTO) {
List<CommonDetailBean> breakEvenLines = Lists.newArrayList();
Integer breakEventLine = businessAnalysisDao.selectBreakEvenLineStatus(businessTrendInDTO.getStoreCode().get(0), businessTrendInDTO.getGroupCode());
if (breakEventLine != 1) {
return timeMapList2CommonBeanList(DateUtils.getMonth12(getCurrentYear()));
}
cn.com.tcsl.loongboss.report.api.model.account.AccountInDTO accountInDTO = new cn.com.tcsl.loongboss.report.api.model.account.AccountInDTO();
String firstDay = DateUtils.getMonthFirstDay(businessTrendInDTO.getBeginTime()) + DateUtils.DAY_OF_BEGIN;
String lastDay = DateUtils.getMonthLastDay(businessTrendInDTO.getBeginTime()) + DateUtils.DAY_OF_END;

accountInDTO.setBeginTime(date2TimeStamp(firstDay, DateUtils.PATTERN_OF_DATE_TIME));
accountInDTO.setEndTime(date2TimeStamp(lastDay, DateUtils.PATTERN_OF_DATE_TIME));
accountInDTO.setStoreCode(businessTrendInDTO.getStoreCode());
accountInDTO.setGroupCode(businessTrendInDTO.getGroupCode());
accountInDTO.setTimeFlag(businessTrendInDTO.getTimeFlag());
accountInDTO.setAccountFlag(4);

ServiceResult<List<AccountTrendDTO>> serviceResult = accountAnalysisService.getAccountTrend(accountInDTO);
if (Objects.nonNull(serviceResult.getResult()) && !serviceResult.getResult().isEmpty()) {
List<AccountTrendDTO> accountTrendDTOS = serviceResult.getResult();
accountTrendDTOS.forEach(accountTrendDTO -> {
CommonDetailBean commonDetailBean = new CommonDetailBean();
commonDetailBean.setTimeName(accountTrendDTO.getDate());
commonDetailBean.setTotalMoney(DigitsUtils.doubleRoundOff2String(accountTrendDTO.getTotalExpend()));
breakEvenLines.add(commonDetailBean);
});
}
return breakEvenLines;
}

//endregion

//region 支付方式分布

/**
* @param commonInDTO 入参信息
* @method-name: paymentService
* @description: 支付方式分布情况
* @author: 刘凯峰
* @date: 2017/10/30 14:36
* @param:
* @return:
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name: 刘凯峰
* date: 2018-01-12
* description: 支付方式饼图显示数据条数限制为11条，从结果集中取前10条，其余作为第11条归为其它
* *****************************************************
*/
@Override
public ServiceResult<List<PaymentOutDTO>> queryBusinessPaymentService(CommonInDTO commonInDTO) {
ServiceResult<String> checkResult = reportInParamCheckService.checkParam(commonInDTO);
if (!ZERO.equals(checkResult.getCode())) {
return ServiceResult.failure(checkResult.getCode(), checkResult.getMsg());
}
BusinessPaymentEsDTO conditionDTO = buildPaymentEsCondition(commonInDTO);
List<PaymentOutDTO> paymentOutDTOS = Lists.newArrayList();
String endTime = DateUtils.getSomeDate(conditionDTO.getEndTimeValue(), -1);
conditionDTO.setEndTimeValue(endTime);
//时间标识为按日查询
boolean isDay = Objects.equals(DAY.getKey(), commonInDTO.getTimeFlag());
//时间标识为今天
boolean isToday = Objects.equals(TODAY.getKey(), commonInDTO.getTimeFlag());
//时间条件为今天
boolean isTodayDate = DateUtils.isToday(commonInDTO.getBeginTime());
//时间标识,不是今天,不是按日查询,查询日期不是今天
if (!isDay && !isToday) {
paymentOutDTOS = searchPaymentFromEs(conditionDTO, true, commonInDTO.getClientType());
} else {
//时间标识为今天或按日查询
if (isTodayDate || isToday) {
paymentOutDTOS = searchPaymentFromSql(commonInDTO).getResult();
} else {
/*从es中查询历史数据，每种支付方式的营业额*/
conditionDTO.setDateHistogramInterval(DateHistogramInterval.DAY);
conditionDTO.setResultDateFormat(DateUtils.PATTERN_OF_DATE);
paymentOutDTOS = searchPaymentFromEs(conditionDTO, false, commonInDTO.getClientType());
}
}

if(!CollectionUtils.isEmpty(paymentOutDTOS)){
paymentOutDTOS = paymentOutDTOS.stream().filter(p -> p.getBusinessTurnover() != 0).collect(toList());
}

paymentOutDTOS = paymentLimit(paymentOutDTOS);
return ServiceResult.success(paymentOutDTOS);
}

/**
* @method-name: paymentLimit
* @description: 支付方式饼图分布展示数据条数限制
* 共展示11条数据，从查询的结果集中查询前10条，将其余归为其它
* @author: 刘凯峰
* @date: 2018/1/12 11:20
* @param: [paymentOutDTOS]
* @return: java.util.List<cn.com.tcsl.loongboss.report.api.model.business.PaymentOutDTO>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private List<PaymentOutDTO> paymentLimit(List<PaymentOutDTO> paymentOutDTOS) {
//展示前10个支付方式，其余支付方式归为其它
if (Objects.nonNull(paymentOutDTOS) && !paymentOutDTOS.isEmpty() && paymentOutDTOS.size() > LIMIT_SIZE) {
//其它部分支付方式实际收入之和及所占比例之和
double otherTotalAmount = 0, otherTotalPercentage = 0d;
//支付方式统计结果实际大小
int size = paymentOutDTOS.size();
//排除前10个支付方式，统计剩余支付方式的总实际收入和总占比
for (int init = LIMIT_SIZE; init < size; init++) {
otherTotalAmount += Double.valueOf(paymentOutDTOS.get(init).getBusinessTurnover());
otherTotalPercentage += Double.valueOf(paymentOutDTOS.get(init).getPercentage());
}
PaymentOutDTO paymentOutDTO = new PaymentOutDTO();
paymentOutDTO.setPaymentName(OTHER_NAME);
paymentOutDTO.setBusinessTurnover(DigitsUtils.formatDouble(otherTotalAmount));
paymentOutDTO.setPercentage(DigitsUtils.doubleRoundOff2String(otherTotalPercentage));

//从实际统计结果中取前10条
paymentOutDTOS = paymentOutDTOS.stream().limit(LIMIT_SIZE).skip(0).collect(toList());
//将其它支付方式添加到结果集的最后
paymentOutDTOS.add(paymentOutDTO);
}
return paymentOutDTOS;
}

/**
* @method-name: searchPaymentFromEs
* @description: 统计并组装数据
* @author: 刘凯峰
* @date: 2017/11/3 11:19
* @param: conditionDTO ES查询条件
* @param: detailFlag 支付方式明细标识
* @param: clientType 客户端类型（1-手机；2-大屏）
* @return: java.util.List<cn.com.tcsl.loongboss.report.api.model.business.PaymentOutDTO>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private List<PaymentOutDTO> searchPaymentFromEs(BusinessPaymentEsDTO conditionDTO, Boolean detailFlag, int clientType) {
//支付方式实际收入统计
List<PaymentOutDTO> paymentOutDTOS = businessAnalysisEsRespository.queryBusinessPayMentRankingEs(conditionDTO);
//每个支付方式折线
if (detailFlag && 2 != clientType && !paymentOutDTOS.isEmpty()) {
List<String> paywayList = Lists.newArrayList();
paymentOutDTOS.forEach(paymentOutDTO -> paywayList.add(paymentOutDTO.getPaymentName()));
conditionDTO.setPaymentList(paywayList);
conditionDTO.setPaymentOutDTOList(paymentOutDTOS);
paymentOutDTOS = businessAnalysisEsRespository.queryBusinessPayMentDetailEs(conditionDTO);
}
return paymentOutDTOS;
}

/**
* @method-name: searchPaymentFromSql
* @description: 从数据库查询当天支付方式
* @author: 刘凯峰
* @date: 2017/11/8 11:57
* @param: [commonInDTO]
* @return: cn.com.tcsl.scmsframework.common.model.ServiceResult<java.util.List<cn.com.tcsl.loongboss.report.api.model.business.PaymentOutDTO>>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private ServiceResult<List<PaymentOutDTO>> searchPaymentFromSql(CommonInDTO commonInDTO) {
List<PaymentOutDTO> paymentOutDTOS = Lists.newArrayList();
BusinessReportInDTO inDTO = buildSqlCondition(commonInDTO);
ResponseResult<Map<String, Object>> outResult = businessAnalysisClient.queryBusinessPayment(inDTO);
if (!ZERO.equals(outResult.getCode()) || outResult.getData() == null) {
return ServiceResult.failure(outResult.getCode(), outResult.getMsg());
}
Double totalAmount = Double.valueOf(String.valueOf(outResult.getData().get(LoongBossEsConstant.TOTAL_AMOUNT)));
List<HashMap<String, Object>> businessReportBeans = (List<HashMap<String, Object>>) outResult.getData().get(LoongBossEsConstant.DATA_OBJECT);
if (Objects.nonNull(businessReportBeans) && !businessReportBeans.isEmpty()) {
businessReportBeans.forEach(map -> {
PaymentOutDTO paymentOutDTO = new PaymentOutDTO();
paymentOutDTO.setPaymentName(String.valueOf(map.get("name")));
paymentOutDTO.setOrderNumber(Integer.valueOf(String.valueOf(map.get("count"))));
paymentOutDTO.setBusinessTurnover(Double.valueOf(String.valueOf(map.get("amount"))));
if (!Objects.equals(totalAmount, 0d)) {
paymentOutDTO.setPercentage(DigitsUtils.division2NoPercent((double) map.get("amount"), totalAmount, 4));
}
paymentOutDTOS.add(paymentOutDTO);
});
} else {
paymentOutDTOS.add(new PaymentOutDTO());
}
return ServiceResult.success(paymentOutDTOS);
}

/**
* @method-name: getPaymentEsCondition
* @description: 构建支付方式ES查询条件
* @author: 刘凯峰
* @date: 2017/11/3 10:48
* @param: [commonInDTO]
* @return: cn.com.tcsl.loongboss.report.api.model.business.BusinessStatisticsConditionDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessPaymentEsDTO buildPaymentEsCondition(CommonInDTO commonInDTO) {

String beginTime = DateUtils.timestampToDateTimeString(commonInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.timestampToDateTimeString(commonInDTO.getEndTime(), DateUtils.PATTERN_OF_DATE);

BusinessPaymentEsDTO paymentEsCondition = new BusinessPaymentEsDTO();
paymentEsCondition.setStoreCodeList(commonInDTO.getStoreCode());
paymentEsCondition.setStoreFieldName(CREATE_SHOP_ID_FIELD_NAME);
paymentEsCondition.setGroupByFieldName(PAYWAY_FIELD_NAME);
paymentEsCondition.setPaymentFieldName(PAYWAY_FIELD_NAME);
paymentEsCondition.setSumFieldName(INCOME_MONEY_FIELD_NAME);
paymentEsCondition.setCountByFieldName(PAY_COUNT_FIELD_NAME);
paymentEsCondition.setIndexFieldName(RPT_PAYWAYINFO.getIndex());
paymentEsCondition.setTypeFieldName(RPT_PAYWAYINFO.getType());
paymentEsCondition.setDateRangFieldName(BIZ_DATE_FIELD_NAME);
paymentEsCondition.setBeginTimeValue(beginTime);
paymentEsCondition.setEndTimeValue(endTime);
paymentEsCondition.setTimeParamFormat(DateUtil.formate_date);
paymentEsCondition.setGroupFieldName(GROUP_CODE_FIELD_NAME_1);
paymentEsCondition.setGroupCode(commonInDTO.getGroupCode());
paymentEsCondition.setGroupQueryFlag(commonInDTO.getGroupQueryFlag());
/*按周统计*/
if (Constant.TimeType.WEEK.getKey() == commonInDTO.getTimeFlag()) {
paymentEsCondition.setDateHistogramInterval(DateHistogramInterval.DAY);
paymentEsCondition.setResultDateFormat(DateUtils.PATTERN_OF_DATE);
}
/*按月统计*/
if (Constant.TimeType.MONTH.getKey() == commonInDTO.getTimeFlag()) {
paymentEsCondition.setDateHistogramInterval(DateHistogramInterval.DAY);
paymentEsCondition.setResultDateFormat(DateUtils.PATTERN_OF_DATE);
}
/*按年统计*/
if (Constant.TimeType.YEAR.getKey() == commonInDTO.getTimeFlag()) {
paymentEsCondition.setDateHistogramInterval(DateHistogramInterval.MONTH);
paymentEsCondition.setResultDateFormat(DateUtils.PATTERN_OF_MONTH);
}
return paymentEsCondition;
}

//endregion

//region 销售来源分布

/**
* @param commonInDTO 入参信息
* @method-name: salesSourceService
* @description: 销售来源统计服务
* @author: 刘凯峰
* @date: 2017/10/30 15:03
* @param:
* @return:
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
@Override
public ServiceResult<List<SaleSourceOutDTO>> queryBusinessSalesSourceService(CommonInDTO commonInDTO) {
ServiceResult<String> checkResult = reportInParamCheckService.checkParam(commonInDTO);
if (!ZERO.equals(checkResult.getCode())) {
return ServiceResult.failure(checkResult.getCode(), checkResult.getMsg());
}
//构建ES查询条件
BusinessSalesSourceEsDTO conditionDTO = buildSalesSourceEsCondition(commonInDTO);
List<SaleSourceOutDTO> saleSourceOutDTOS = Lists.newArrayList();
String endTime = DateUtils.getSomeDate(conditionDTO.getEndTimeValue(), -1);
conditionDTO.setEndTimeValue(endTime);
//时间标识为按日统计
boolean isDay = Objects.equals(DAY.getKey(), commonInDTO.getTimeFlag());
//时间标识为按今日统计
boolean isToday = Objects.equals(TODAY.getKey(), commonInDTO.getTimeFlag());
//起始时间为今天
boolean isTodayTime = DateUtils.isToday(commonInDTO.getBeginTime());
//实时数据统计
if (isToday || (isDay && isTodayTime)) {
saleSourceOutDTOS = searchSalesSourceFromSql(commonInDTO).getResult();
} else {
saleSourceOutDTOS = searchSalesSourceFromEs(conditionDTO);
}
//结果集截取
if (Objects.nonNull(saleSourceOutDTOS) && !saleSourceOutDTOS.isEmpty()) {
saleSourceOutDTOS = salesSourceLimit(saleSourceOutDTOS);
}
return ServiceResult.success(saleSourceOutDTOS);
}

/**
* @method-name: salesSourceLimit
* @description: 销售来源饼图分布展示数据条数限制
* 共展示11条数据，从查询的结果集中查询前10条，将其余归为其它
* @author: 刘凯峰
* @date: 2018/1/12 11:29
* @param: [saleSourceOutDTOS]
* @return: java.util.List<cn.com.tcsl.loongboss.report.api.model.business.SaleSourceOutDTO>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private List<SaleSourceOutDTO> salesSourceLimit(List<SaleSourceOutDTO> saleSourceOutDTOS) {
//展示前10个销售来源，其余销售来源归为其它
if (Objects.nonNull(saleSourceOutDTOS) && !saleSourceOutDTOS.isEmpty() && saleSourceOutDTOS.size() > LIMIT_SIZE) {
//其它部分销售来源实际收入之和及所占比例之和
double otherTotalAmount = 0, otherTotalPercentage = 0d;
int orderNum = 0;
//销售来源统计结果实际大小
int size = saleSourceOutDTOS.size();
//排除前10个销售来源，统计剩余销售来源的总实际收入和总占比
for (int init = LIMIT_SIZE; init < size; init++) {
otherTotalAmount += Double.valueOf(saleSourceOutDTOS.get(init).getBusinessTurnover());
otherTotalPercentage += Double.valueOf(saleSourceOutDTOS.get(init).getPercentage());
orderNum += saleSourceOutDTOS.get(init).getOrderNumber();
}
SaleSourceOutDTO saleSourceOutDTO = new SaleSourceOutDTO();
saleSourceOutDTO.setSaleSource(OTHER_NAME);
saleSourceOutDTO.setOrderNumber(orderNum);
saleSourceOutDTO.setBusinessTurnover(DigitsUtils.formatDouble(otherTotalAmount));
saleSourceOutDTO.setPercentage(DigitsUtils.doubleRoundOff2String(otherTotalPercentage));

//从实际统计结果中取前10条
saleSourceOutDTOS = saleSourceOutDTOS.stream().limit(LIMIT_SIZE).skip(0).collect(toList());
//将其它销售来源添加到结果集的最后
saleSourceOutDTOS.add(saleSourceOutDTO);
}
return saleSourceOutDTOS;
}

/**
* @method-name: searchSalesSourceFromEs
* @description: 从ES中查询并统计销售来源
* @author: 刘凯峰
* @date: 2017/11/3 14:27
* @param: [conditionDTO, detailFlag]
* @return: java.util.List<cn.com.tcsl.loongboss.report.api.model.business.SaleSourceOutDTO>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private List<SaleSourceOutDTO> searchSalesSourceFromEs(BusinessSalesSourceEsDTO conditionDTO) {
List<SaleSourceOutDTO> saleSourceOutDTOS = Lists.newArrayList();
saleSourceOutDTOS = businessAnalysisEsRespository.queryBusinessSalesSourceRankingEs(conditionDTO);
if (saleSourceOutDTOS.isEmpty()) {
return saleSourceOutDTOS;
}
if (conditionDTO.getDetailFlag() && 2 != conditionDTO.getClientType() && !saleSourceOutDTOS.isEmpty()) {
List<String> saleSourceNameList = Lists.newArrayList();
saleSourceOutDTOS.forEach(saleSourceOutDTO -> saleSourceNameList.add(saleSourceOutDTO.getSaleSource()));
conditionDTO.setSumFieldName(ORIG_TOTAL_FIELD_NAME);
conditionDTO.setSaleSourceList(saleSourceNameList);
conditionDTO.setSaleSourceOutDTOList(saleSourceOutDTOS);
saleSourceOutDTOS = businessAnalysisEsRespository.queryBusinessSalesSourceDetailEs(conditionDTO);
}
return saleSourceOutDTOS;
}

/**
* @method-name: searchSalesSourceFromSql
* @description: 查询当日销售来源
* @author: 刘凯峰
* @date: 2017/11/8 13:58
* @param: [commonInDTO]
* @return: cn.com.tcsl.scmsframework.common.model.ServiceResult<java.util.List<cn.com.tcsl.loongboss.report.api.model.business.SaleSourceOutDTO>>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private ServiceResult<List<SaleSourceOutDTO>> searchSalesSourceFromSql(CommonInDTO commonInDTO) {
List<SaleSourceOutDTO> saleSourceOutDTOS = Lists.newArrayList();
BusinessReportInDTO inDTO = buildSqlCondition(commonInDTO);
ResponseResult<Map<String, Object>> outResult = businessAnalysisClient.queryBusinessSaleSource(inDTO);
if (!ZERO.equals(outResult.getCode()) || outResult.getData() == null) {
return ServiceResult.failure(outResult.getCode(), outResult.getMsg());
}
Double totalAmount = (Double) outResult.getData().get(TOTAL_AMOUNT);
List<HashMap> businessReportBeans = (List<HashMap>) outResult.getData().get(DATA_OBJECT);
if (Objects.nonNull(businessReportBeans) && !businessReportBeans.isEmpty()) {
businessReportBeans.forEach(map -> {
SaleSourceOutDTO saleSourceOutDTO = new SaleSourceOutDTO();
saleSourceOutDTO.setSaleSource((String) map.get("name"));
saleSourceOutDTO.setOrderNumber((Integer) map.get("count"));
saleSourceOutDTO.setBusinessTurnover(Double.valueOf(map.get("amount").toString()));
saleSourceOutDTO.setPercentage(DigitsUtils.division2NoPercent((double) map.get("amount"), totalAmount, 4));
saleSourceOutDTOS.add(saleSourceOutDTO);
});
} else {
saleSourceOutDTOS.add(new SaleSourceOutDTO());
}
return ServiceResult.success(saleSourceOutDTOS);
}

/**
* @method-name: getSalesSourceEsCondition
* @description: 构造销售类型的ES查询条件
* @author: 刘凯峰
* @date: 2017/11/3 14:22
* @param: [commonInDTO]
* @return: cn.com.tcsl.loongboss.report.api.model.business.BusinessStatisticsConditionDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessSalesSourceEsDTO buildSalesSourceEsCondition(CommonInDTO commonInDTO) {
String beginTime = DateUtils.timestampToDateTimeString(commonInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.timestampToDateTimeString(commonInDTO.getEndTime(), DateUtils.PATTERN_OF_DATE);

BusinessSalesSourceEsDTO conditionDTO = new BusinessSalesSourceEsDTO();
conditionDTO.setStoreCodeList(commonInDTO.getStoreCode());
conditionDTO.setStoreFieldName(CREATE_SHOP_ID_FIELD_NAME);
conditionDTO.setGroupByFieldName(SALE_TYPE_FIELD_NAME);
conditionDTO.setSalesSourceFiledName(SALE_TYPE_FIELD_NAME);
conditionDTO.setSumFieldNames(Lists.newArrayList(ORIG_TOTAL_FIELD_NAME, PEOPLE_COUNT_FIELD_NAME));

conditionDTO.setIndexFieldName(RPT_SALETYPEINFO.getIndex());
conditionDTO.setTypeFieldName(RPT_SALETYPEINFO.getType());
conditionDTO.setDateRangFieldName(BIZ_DATE_FIELD_NAME);
conditionDTO.setTimeParamFormat(DateUtil.formate_date);
conditionDTO.setBeginTimeValue(beginTime);
conditionDTO.setEndTimeValue(endTime);
conditionDTO.setDateHistogramInterval(DateHistogramInterval.DAY);
conditionDTO.setResultDateFormat(DateUtils.PATTERN_OF_DATE);
conditionDTO.setSalesSourceFiledName(SALE_TYPE_FIELD_NAME);
conditionDTO.setGroupQueryFlag(commonInDTO.getGroupQueryFlag());
conditionDTO.setGroupFieldName(GROUP_CODE_FIELD_NAME_1);
conditionDTO.setGroupCode(commonInDTO.getGroupCode());
conditionDTO.setClientType(commonInDTO.getClientType());
//时间标识为按日统计
boolean isDay = Objects.equals(DAY.getKey(), commonInDTO.getTimeFlag());
//按日统计（饼图）
if (isDay) {
conditionDTO.setDetailFlag(false);
} else {
//按周月统计
conditionDTO.setDetailFlag(true);
}
//按年统计
if (Constant.TimeType.YEAR.getKey() == commonInDTO.getTimeFlag()) {
conditionDTO.setDateHistogramInterval(DateHistogramInterval.MONTH);
conditionDTO.setResultDateFormat(DateUtils.PATTERN_OF_MONTH);
}
return conditionDTO;
}

//endregion

//region 不同市别统计

/**
* @param commonInDTO
* @method-name: marketService
* @description: 按市别统计营业额情况
* @author: 刘凯峰
* @date: 2017/10/30 15:17
* @param:
* @return:
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
@Override
public ServiceResult<List<MarketOutDTO>> queryBusinessMarketService(CommonInDTO commonInDTO) {
ServiceResult<String> checkResult = reportInParamCheckService.checkParam(commonInDTO);
if (!ZERO.equals(checkResult.getCode())) {
return ServiceResult.failure(checkResult.getCode(), checkResult.getMsg());
}

BusinessMarketRankingEsDTO marketRankingEsCondition = buildMarketEsCondition(commonInDTO);
String endTime = DateUtils.getSomeDate(marketRankingEsCondition.getEndTimeValue(), -1);
marketRankingEsCondition.setEndTimeValue(endTime);
List<MarketOutDTO> marketOutDTOS = Lists.newArrayList();

//时间标识为按日统计
boolean isDay = Objects.equals(DAY.getKey(), commonInDTO.getTimeFlag());
//时间标识为按今日统计
boolean isToday = Objects.equals(TODAY.getKey(), commonInDTO.getTimeFlag());
//起始时间为今天
boolean isTodayTime = DateUtils.isToday(commonInDTO.getBeginTime());

//实时数据统计
if (isToday || (isDay && isTodayTime)) {
marketOutDTOS = searchMarketFromSql(commonInDTO).getResult();
} else {
marketOutDTOS = searchMarketSourceFromEs(marketRankingEsCondition);
}
return ServiceResult.success(marketOutDTOS);
}

/**
* @method-name: searchMarketSourceFromEs
* @description: 基于ES统计不同市别营业额
* @author: 刘凯峰
* @date: 2017/11/4 9:41
* @param: conditionDTO 查询条件
* @param: detailFlag 是否查询各个时段的营业额标识
* @return: java.util.List<cn.com.tcsl.loongboss.report.api.model.business.MarketOutDTO>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private List<MarketOutDTO> searchMarketSourceFromEs(BusinessMarketRankingEsDTO marketRankingEsCondition) {
List<MarketOutDTO> marketOutDTOS = Lists.newArrayList();
marketOutDTOS = businessAnalysisEsRespository.queryBusinessMarketRankingEs(marketRankingEsCondition);
if (marketOutDTOS.isEmpty()) {
return marketOutDTOS;
}
if (marketRankingEsCondition.isDetailFlag() && marketRankingEsCondition.getClientType() != 2) {
List<String> marketNameList = Lists.newArrayList();
marketOutDTOS.forEach(marketOutDTO -> {
marketNameList.add(marketOutDTO.getMarketName());
});
marketRankingEsCondition.setSettleShiftList(marketNameList);
marketRankingEsCondition.setMarketOutDTOList(marketOutDTOS);
marketOutDTOS = businessAnalysisEsRespository.queryBusinessMarketDetailEs(marketRankingEsCondition);
}
return marketOutDTOS;
}

/**
* @method-name: searchMarketFromSql
* @description: 当天不同市别统计
* @author: 刘凯峰
* @date: 2017/11/8 10:10
* @param: [commonInDTO]
* @return: cn.com.tcsl.scmsframework.common.model.ServiceResult<java.util.List<cn.com.tcsl.loongboss.report.api.model.business.MarketOutDTO>>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private ServiceResult<List<MarketOutDTO>> searchMarketFromSql(CommonInDTO commonInDTO) {
List<MarketOutDTO> marketOutDTOS = Lists.newArrayList();
BusinessReportInDTO inDTO = buildSqlCondition(commonInDTO);
ResponseResult<List<BusinessReportBean>> outResult = businessAnalysisClient.queryBusinessSettleShift(inDTO);
if (!ZERO.equals(outResult.getCode())) {
return ServiceResult.failure(outResult.getCode(), outResult.getMsg());
}
outResult.getData().forEach(businessReportBean -> {
MarketOutDTO marketOutDTO = new MarketOutDTO();
marketOutDTO.setMarketName(businessReportBean.getName());
marketOutDTO.setBusinessTurnover(DigitsUtils.doubleRoundOff2String(businessReportBean.getAmount()));
marketOutDTOS.add(marketOutDTO);
});
return ServiceResult.success(marketOutDTOS);
}

/**
* @method-name: getMarketEsCondition
* @description: 构建市别统计ES查询参数
* @author: 刘凯峰
* @date: 2017/11/4 9:14
* @param: [commonInDTO]
* @return: cn.com.tcsl.loongboss.report.api.model.business.BusinessStatisticsConditionDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessMarketRankingEsDTO buildMarketEsCondition(CommonInDTO commonInDTO) {
String beginTime = DateUtils.timestampToDateTimeString(commonInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.timestampToDateTimeString(commonInDTO.getEndTime(), DateUtils.PATTERN_OF_DATE);

BusinessMarketRankingEsDTO marketRankingEsCondition = new BusinessMarketRankingEsDTO();
marketRankingEsCondition.setStoreCodeList(commonInDTO.getStoreCode());
marketRankingEsCondition.setGroupFieldName(GROUP_CODE_FIELD_NAME);
marketRankingEsCondition.setGroupCode(commonInDTO.getGroupCode());
marketRankingEsCondition.setGroupQueryFlag(commonInDTO.getGroupQueryFlag());
marketRankingEsCondition.setStoreFieldName(STORE_CODE_FIELD_NAME);
marketRankingEsCondition.setGroupByFieldName(SETTLE_SHIFT_FIELD_NAME);
marketRankingEsCondition.setSumFieldName(AMOUNT_FIELD_NAME);
marketRankingEsCondition.setIndexFieldName(RPT_INDICATES.getIndex());
marketRankingEsCondition.setTypeFieldName(RPT_INDICATES.getType());
marketRankingEsCondition.setDateRangFieldName(BIZ_DATE_FIELD_NAME);
marketRankingEsCondition.setTimeParamFormat(DateUtils.PATTERN_OF_DATE);
marketRankingEsCondition.setBeginTimeValue(beginTime);
marketRankingEsCondition.setEndTimeValue(endTime);
marketRankingEsCondition.setTypeIdFieldName(TYPE_ID_FIELD_NAME);
marketRankingEsCondition.setTypeIdFieldValue(BUSINESS_AMOUNT.getKey());
marketRankingEsCondition.setSettleShiftFieldName(SETTLE_SHIFT_FIELD_NAME);
/*按周月统计*/
marketRankingEsCondition.setDateHistogramInterval(DateHistogramInterval.DAY);
marketRankingEsCondition.setResultDateFormat(DateUtils.PATTERN_OF_DATE);
marketRankingEsCondition.setDetailFlag(true);
marketRankingEsCondition.setClientType(commonInDTO.getClientType());
/*按年统计*/
if (Constant.TimeType.YEAR.getKey() == commonInDTO.getTimeFlag()) {
marketRankingEsCondition.setDateHistogramInterval(DateHistogramInterval.MONTH);
marketRankingEsCondition.setResultDateFormat(DateUtils.PATTERN_OF_MONTH);
}
return marketRankingEsCondition;
}

//endregion

//region 优惠构成统计

/**
* @param commonInDTO 入参信息
* @method-name: discountService
* @description: 优惠构成统计
* @author: 刘凯峰
* @date: 2017/10/30 15:28
* @param:
* @return:
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
@Override
public ServiceResult<List<DiscountOutDTO>> queryBusinessDiscountService(CommonInDTO commonInDTO) {
//入参校验
ServiceResult<String> checkResult = reportInParamCheckService.checkParam(commonInDTO);
if (!ZERO.equals(checkResult.getCode())) {
return ServiceResult.failure(checkResult.getCode(), checkResult.getMsg());
}
BusinessDiscountRankingEsDTO conditionDTO = buidDiscountEsCondition(commonInDTO);
String endTime = DateUtils.getSomeDate(conditionDTO.getEndTimeValue(), -1);
conditionDTO.setEndTimeValue(endTime);
List<DiscountOutDTO> discountOutDTOS = Lists.newArrayList();
//时间标识为按日统计
boolean isDay = Objects.equals(DAY.getKey(), commonInDTO.getTimeFlag());
//时间标识为按今日统计
boolean isToday = Objects.equals(TODAY.getKey(), commonInDTO.getTimeFlag());
//起始时间为今天
boolean isTodayTime = DateUtils.isToday(commonInDTO.getBeginTime());
//实时数据统计
if (isToday || (isDay && isTodayTime)) {
discountOutDTOS = searchDiscountFromSql(commonInDTO).getResult();
} else {
discountOutDTOS = searchDiscountFromEs(conditionDTO);
}

if(!CollectionUtils.isEmpty(discountOutDTOS)){
discountOutDTOS = discountOutDTOS.stream().filter(d -> !String.valueOf(d.getBusinessTurnover()).equals(ZERO)).collect(toList());
}

return ServiceResult.success(discountOutDTOS);
}

/**
* @method-name: searchDiscountFromEs
* @description: 基于ES统计不同优惠构成
* @author: 刘凯峰
* @date: 2017/11/4 11:01
* @param: [conditionDTO, detailFlag]
* @return: java.util.List<cn.com.tcsl.loongboss.report.api.model.business.DiscountOutDTO>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private List<DiscountOutDTO> searchDiscountFromEs(BusinessDiscountRankingEsDTO discountRankingEsDTO) {
List<DiscountOutDTO> discountOutDTOS = Lists.newArrayList();
discountOutDTOS = businessAnalysisEsRespository.queryBusinessDiscountRankingEs(discountRankingEsDTO);
if (discountOutDTOS.isEmpty()) {
return discountOutDTOS;
}
if (discountRankingEsDTO.isDetailFlag() && discountRankingEsDTO.getClientType() != 2) {
discountRankingEsDTO.setDiscountOutDTOList(discountOutDTOS);
discountOutDTOS = businessAnalysisEsRespository.queryBusinessDiscountDetailEs(discountRankingEsDTO);
}
return discountOutDTOS;
}

/**
* @method-name: searchDiscountFromSql
* @description: 查询当天优惠构成
* @author: 刘凯峰
* @date: 2017/11/8 10:16
* @param: [commonInDTO]
* @return: cn.com.tcsl.scmsframework.common.model.ServiceResult<java.util.List<cn.com.tcsl.loongboss.report.api.model.business.DiscountOutDTO>>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private ServiceResult<List<DiscountOutDTO>> searchDiscountFromSql(CommonInDTO commonInDTO) {
List<DiscountOutDTO> discountOutDTOS = Lists.newArrayList();
BusinessReportInDTO inDTO = buildSqlCondition(commonInDTO);
ResponseResult<Map<String, Double>> outResult = businessAnalysisClient.queryBusinessDiscount(inDTO);
if (!ZERO.equals(outResult.getCode()) || outResult.getData() == null) {
return ServiceResult.failure(outResult.getCode(), outResult.getMsg());
}
for (Map.Entry<String, Double> entry : outResult.getData().entrySet()) {
DiscountOutDTO discountOutDTO = new DiscountOutDTO();
discountOutDTO.setDiscountWay(entry.getKey());
discountOutDTO.setBusinessTurnover(DigitsUtils.doubleRoundOff2String(entry.getValue()));
discountOutDTOS.add(discountOutDTO);
}
return ServiceResult.success(discountOutDTOS);
}

/**
* @method-name: getDiscountEsCondition
* @description: 构建优惠构成统计ES查询参数
* @author: 刘凯峰
* @date: 2017/11/4 10:29
* @param: [commonInDTO]
* @return: cn.com.tcsl.loongboss.report.api.model.business.BusinessStatisticsConditionDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessDiscountRankingEsDTO buidDiscountEsCondition(CommonInDTO commonInDTO) {
String beginTime = DateUtils.timestampToDateTimeString(commonInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.timestampToDateTimeString(commonInDTO.getEndTime(), DateUtils.PATTERN_OF_DATE);

BusinessDiscountRankingEsDTO discountRankingEsDTO = new BusinessDiscountRankingEsDTO();
discountRankingEsDTO.setStoreCodeList(commonInDTO.getStoreCode());
discountRankingEsDTO.setGroupQueryFlag(commonInDTO.getGroupQueryFlag());
discountRankingEsDTO.setGroupCode(commonInDTO.getGroupCode());
discountRankingEsDTO.setStoreFieldName(STORE_CODE_FIELD_NAME);
discountRankingEsDTO.setGroupByFieldName(TYPE_ID_FIELD_NAME);
discountRankingEsDTO.setSumFieldName(AMOUNT_FIELD_NAME);
discountRankingEsDTO.setIndexFieldName(RPT_INDICATES.getIndex());
discountRankingEsDTO.setTypeFieldName(RPT_INDICATES.getType());

discountRankingEsDTO.setDateRangFieldName(BIZ_DATE_FIELD_NAME);
discountRankingEsDTO.setTimeParamFormat(DateUtils.PATTERN_OF_DATE);
discountRankingEsDTO.setBeginTimeValue(beginTime);
discountRankingEsDTO.setEndTimeValue(endTime);
discountRankingEsDTO.setTypeIdFieldName(TYPE_ID_FIELD_NAME);
discountRankingEsDTO.setTypeIdList(Lists.newArrayList(FIXED_DISCOUNT_AMOUNT.getKey()
, MALING_AMOUNT.getKey(), DISCOUNT_AMOUNT.getKey(), NOT_INCOME_AMOUNT.getKey()));
//时间标识为按日统计
boolean isDay = Objects.equals(DAY.getKey(), commonInDTO.getTimeFlag());
//按日统计（饼图）
if (isDay) {
discountRankingEsDTO.setDetailFlag(false);
} else {
discountRankingEsDTO.setDateHistogramInterval(DateHistogramInterval.DAY);
discountRankingEsDTO.setResultDateFormat(DateUtils.PATTERN_OF_DATE);
discountRankingEsDTO.setDetailFlag(true);
}
/*按年统计*/
if (Constant.TimeType.YEAR.getKey() == commonInDTO.getTimeFlag()) {
discountRankingEsDTO.setDateHistogramInterval(DateHistogramInterval.MONTH);
discountRankingEsDTO.setResultDateFormat(DateUtils.PATTERN_OF_MONTH);
}
return discountRankingEsDTO;
}

//endregion

//region 营业日报

/**
* @param commonInDTO
* @method-name: businessAnalysisDaily
* @description: 营业日报
* @author: 刘凯峰
* @date: 2017/11/6 16:49
* @param:
* @return:
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
@Override
public ServiceResult<BusinessDailyOutDTO> queryBusinessDailyService(CommonInDTO commonInDTO) {
commonInDTO.setTimeFlag(-1);
ServiceResult<Privilege> privileResult = reportInParamCheckService.getLoginUserInfo();
if (!ZERO.equals(privileResult.getCode())) {
return ServiceResult.failure(privileResult.getCode(), privileResult.getMsg());
}
String userName = privileResult.getResult().getUsername();
// String userName = "13811894134";
boolean storeCodeIsEmpty = (Objects.isNull(commonInDTO.getStoreCode()) || commonInDTO.getStoreCode().isEmpty());
boolean groupCodeIsEmpty = (Strings.isNullOrEmpty(commonInDTO.getGroupCode()));
if (storeCodeIsEmpty && groupCodeIsEmpty) {
return ServiceResult.failure(LoongBossServiceResultConstant.SHOP_CODE_IS_EMPTY);
}
if (!groupCodeIsEmpty && storeCodeIsEmpty) {
/* 门店编号为空，集团编号不为空
当前登录人如果是管理员，根据集团号查询下属所有门店编号
当前登录人不是管理员，根据用户名查询其权限范围内的门店编号*/
UserStorePermissionInDTO userStorePermission = BusinessAnalysisConverter.commonInDTO2UserStorePermission(commonInDTO, userName);
ResponseResult<List<String>> result = sysUserClient.queryUserStorePermission2(userStorePermission);
if (ZERO.equals(result.getCode()) && Objects.nonNull(result.getData()) && !result.getData().isEmpty()) {
commonInDTO.setStoreCode(result.getData());
} else {
return ServiceResult.failure(LoongBossServiceResultConstant.SHOP_CODE_IS_EMPTY);
}
}
Double breakevenLineValue = 0d; /*保本线*/
BusinessDailyOutDTO businessDailyOutDTO = new BusinessDailyOutDTO();
BusinessReportInDTO businessReportInDTO = new BusinessReportInDTO();
String currentDate = DateUtil.getCurrentDate(DateUtil.formate_date);
String tomorrowDate = DateUtil.getSomeDay(1);
businessReportInDTO.setBeginTime(currentDate + " 00:00:00");
businessReportInDTO.setEndTime(tomorrowDate + " 00:00:00");
businessReportInDTO.setStoreCodes(commonInDTO.getStoreCode());
businessReportInDTO.setGroupCode(commonInDTO.getGroupCode());
commonInDTO.setBeginTime(DateUtils.DateTimeStringToTimeStamp(businessReportInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE_TIME));
commonInDTO.setEndTime(DateUtils.DateTimeStringToTimeStamp(businessReportInDTO.getEndTime(), DateUtils.PATTERN_OF_DATE_TIME));
logger.info("【营业分析】-【营业日报】-查询参数：" + JSONObject.toJSONString(businessReportInDTO));
/*获取营业额、优惠金额、实际收入金额*/
ResponseResult<BusinessReportOutDTO> dailyResult = businessAnalysisClient.queryBusinessDaily(businessReportInDTO);

if (!ZERO.equals(dailyResult.getCode())) {
return ServiceResult.failure(dailyResult.getCode(), dailyResult.getMsg());
}
BusinessReportOutDTO dailytDTO = dailyResult.getData();
/*获取营业目标*/
double businessGoal = queryBusinessGoal(commonInDTO);

/*获取保本线*/
ServiceResult<Double> breakevenLineResult = queryBreakevenLine(commonInDTO);
if (ZERO.equals(breakevenLineResult.getCode())) {
breakevenLineValue = breakevenLineResult.getResult();
}
if (Objects.nonNull(dailytDTO.getActualIncomeAmount())) {
businessDailyOutDTO.setIncomeTotal(DigitsUtils.formatDouble(dailytDTO.getActualIncomeAmount()).toString());
}
if (Objects.nonNull(dailytDTO.getCouponAmount())) {
businessDailyOutDTO.setDiscTotal(DigitsUtils.formatDouble(dailytDTO.getCouponAmount()).toString());
}
businessDailyOutDTO.setBusiTotal(ZERO);
if (Objects.nonNull(dailytDTO.getBusinessAmount())) {
businessDailyOutDTO.setBusiTotal(String.valueOf(dailytDTO.getBusinessAmount()));
businessDailyOutDTO.setBreakevenLineGap(DigitsUtils.doubleRoundOff2String(dailytDTO.getBusinessAmount() - breakevenLineValue));
businessDailyOutDTO.setBusinessGoalGap(DigitsUtils.doubleRoundOff2String(dailytDTO.getBusinessAmount() - businessGoal));

Boolean isOpen = queryBusinessGoalStatus(commonInDTO);

if (isOpen) {
if (!Objects.equals(businessGoal, 0d)) {
/*营业目标除以月份天数为日营业目标*/
int days = DateUtils.getMonthDays(businessReportInDTO.getBeginTime());
double dayBusinessGoal = DigitsUtils.division(businessGoal, days);
businessDailyOutDTO.setBusiGoal(DigitsUtils.doubleRoundOff2String(dayBusinessGoal));

double finishRate = DigitsUtils.division(dailytDTO.getBusinessAmount(), dayBusinessGoal, 4);
businessDailyOutDTO.setFinishRate(DigitsUtils.getNoPercentFormat(finishRate));
}
} else {
businessDailyOutDTO.setBusiGoal(DigitsUtils.DEFAULT_DOUBLE_ZERO.toString());
businessDailyOutDTO.setFinishRate(DigitsUtils.DEFAULT_DOUBLE_ZERO.toString());
}
}
return ServiceResult.success(businessDailyOutDTO);
}

/**
* @method-name: queryBreakevenLine
* @description: 查询保本线
* @author: 刘凯峰
* @date: 2017/11/6 17:15
* @param: [commonInDTO]
* @return: cn.com.tcsl.scmsframework.common.model.ServiceResult<java.lang.Double>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private ServiceResult<Double> queryBreakevenLine(CommonInDTO commonInDTO) {
AccountInDTO accountInDTO = new AccountInDTO();
String firstDay = DateUtils.getMonthFirstDay(commonInDTO.getBeginTime()) + DateUtils.DAY_OF_BEGIN;
String lastDay = DateUtils.getMonthLastDay(commonInDTO.getBeginTime()) + DateUtils.DAY_OF_END;
accountInDTO.setStoreCode(commonInDTO.getStoreCode());
accountInDTO.setBeginTime(date2TimeStamp(firstDay, DateUtils.PATTERN_OF_DATE_TIME));
accountInDTO.setEndTime(date2TimeStamp(lastDay, DateUtils.PATTERN_OF_DATE_TIME));
accountInDTO.setAccountFlag(2);
accountInDTO.setTimeFlag(commonInDTO.getTimeFlag());
accountInDTO.setGroupCode(commonInDTO.getGroupCode());
if (commonInDTO.getTimeFlag() <= Constant.TimeType.MONTH.getKey()) {
accountInDTO.setTimeFlag(Constant.TimeType.MONTH.getKey());
}
Integer breakEventLine = businessAnalysisDao.selectBreakEvenLineStatus(commonInDTO.getStoreCode().get(0), commonInDTO.getGroupCode());
if (breakEventLine == 1) {
ResponseResult<AccountTotalDTO> accountResult = sysAccountClient.getAccountTotal(accountInDTO);
logger.info(String.format("营业趋势查询保本线：入参【%s】,返回值【%s】", JSONObject.toJSONString(accountInDTO),
JSONObject.toJSONString(accountResult)));
if (!ZERO.equals(accountResult.getCode())) {
return ServiceResult.failure(accountResult.getCode(), accountResult.getMsg());
} else {
AccountTotalDTO accountTotalDTO = accountResult.getData();
return ServiceResult.success(accountTotalDTO == null ? 0d : accountTotalDTO.getTotalExpend());
}
}
return ServiceResult.success(0d);
}

//endregion

//region 统计各省份营业额

/**
* @param commonInDTO 入参
* @method-name: businessAnalysisProvinceService
* @description: 统计各省份营业额
* @author: 刘凯峰
* @date: 2018/1/16 19:34
* @param:
* @return:
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
@Override
public ServiceResult<List<BusinessProvinceOutDTO>> queryBusinessProvinceService(CommonInDTO commonInDTO) {
ServiceResult<String> checkResult = reportInParamCheckService.checkParam(commonInDTO);
if (!ZERO.equals(checkResult.getCode())) {
return ServiceResult.failure(checkResult.getCode(), checkResult.getMsg());
}
//时间标识为按日查询
boolean isDay = Objects.equals(DAY.getKey(), commonInDTO.getTimeFlag());
//时间标识为今天
boolean isToday = Objects.equals(TODAY.getKey(), commonInDTO.getTimeFlag());
//时间条件为今天
boolean isTodayDate = DateUtils.isToday(commonInDTO.getBeginTime());
//ES统计条件
BusinessProvinceEsDTO businessProvinceEsDTO = buildProvinceBusinessEsDTO(commonInDTO);
//返回结果集
List<BusinessProvinceOutDTO> businessProvinceOutDTOS = Lists.newArrayList();
//实时数据统计
if (isToday || (isDay && isTodayDate)) {
businessProvinceOutDTOS = searchProvinceAmountFromSql(commonInDTO);
} else {
businessProvinceOutDTOS = businessAnalysisEsRespository.queryBusinessProvinceEs(businessProvinceEsDTO);
}
return ServiceResult.success(businessProvinceOutDTOS);
}

/**
* @method-name: searchProvinceAmountFromSql
* @description: 统计各省市营业额，SQL实时查询
* @author: 刘凯峰
* @date: 2018/1/16 20:00
* @param: [commonInDTO]
* @return: java.util.List<cn.com.tcsl.loongboss.report.api.model.business.BusinessProvinceOutDTO>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private List<BusinessProvinceOutDTO> searchProvinceAmountFromSql(CommonInDTO commonInDTO) {
ResponseResult<List<BusinessReportBean>> responseResult = businessAnalysisClient.queryBusinessAmountByProvince(BusinessAnalysisConverter.commonInDTO2Cy7InDTO(commonInDTO));
List<BusinessReportBean> businessReportBeans = responseResult.getData();
List<BusinessProvinceOutDTO> businessProvinceOutDTOS = Lists.newArrayList();
if (Objects.nonNull(businessReportBeans) && !businessReportBeans.isEmpty()) {
businessReportBeans.forEach(businessReportBean -> {
businessProvinceOutDTOS.add(BusinessAnalysisConverter.cy7ProvinceDTO2ProvinceOutDTO(businessReportBean));
});
}
return businessProvinceOutDTOS;
}

/**
* @method-name: buildProvinceBusinessEsDTO
* @description: 构建各城市门店营业额ES统计条件
* @author: 刘凯峰
* @date: 2018/1/30 15:08
* @param: [commonInDTO]
* @return: cn.com.tcsl.loongboss.report.api.model.business.BusinessProvinceEsDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessProvinceEsDTO buildProvinceBusinessEsDTO(CommonInDTO commonInDTO) {
String beginTime = DateUtils.timestampToDateTimeString(commonInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.getSomeDay(commonInDTO.getEndTime(), -1);

BusinessProvinceEsDTO businessProvinceEsDTO = new BusinessProvinceEsDTO();
businessProvinceEsDTO.setStoreCodeList(commonInDTO.getStoreCode());
businessProvinceEsDTO.setGroupQueryFlag(commonInDTO.getGroupQueryFlag());
businessProvinceEsDTO.setGroupFieldName(GROUP_CODE_FIELD_NAME);
businessProvinceEsDTO.setGroupCode(commonInDTO.getGroupCode());
//门店编号字段名
businessProvinceEsDTO.setStoreFieldName(STORE_CODE_FIELD_NAME);
//分组字段
businessProvinceEsDTO.setGroupByFieldName(PROVINCE_NAME);
//营业额字段名字段名
businessProvinceEsDTO.setSumFieldName(BUSI_INCOME_FIELD_NAME);
businessProvinceEsDTO.setTimeParamFormat(DateUtil.formate_date);
businessProvinceEsDTO.setDateRangFieldName(BIZ_DATE_FIELD_NAME);
businessProvinceEsDTO.setBeginTimeValue(beginTime);
businessProvinceEsDTO.setEndTimeValue(endTime);
businessProvinceEsDTO.setIndexFieldName(RPT_BUSI_DATA_AREA.getIndex());
businessProvinceEsDTO.setTypeFieldName(RPT_BUSI_DATA_AREA.getType());
return businessProvinceEsDTO;
}
//endregion

//region 统计各门店营业额排行

/**
* @param commonInDTO 入参信息
* @method-name: businessAnalysisStoreRankingService
* @description: 门店营业额排行
* @author: 刘凯峰
* @date: 2018/1/17 13:04
* @param:
* @return:
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
@Override
public ServiceResult<List<BusinessStoreRankingOutDTO>> queryBusinessStoreRankingService(CommonInDTO commonInDTO) {
//入参校验及处理
ServiceResult<String> checkResult = reportInParamCheckService.checkParam(commonInDTO);
if (!ZERO.equals(checkResult.getCode())) {
return ServiceResult.failure(checkResult.getCode(), checkResult.getMsg());
}
//构建ES查询条件
BusinessStoreEsDTO businessStoreEsDTO = buildStoreBusinessAmountRankingDTO(commonInDTO);
//时间标识为-1，统计当天
if (TODAY.getKey() == commonInDTO.getTimeFlag()) {
return searchBusinessStoreRankingSql(commonInDTO);
}
List<BusinessStoreRankingOutDTO> storeRankingOutDTOS = Lists.newArrayList();
//时间标识为-1，按日统计
if (Objects.equals(DAY.getKey(), commonInDTO.getTimeFlag())) {
//当天从数据库统计
if (DateUtils.isToday(commonInDTO.getBeginTime())) {
return searchBusinessStoreRankingSql(commonInDTO);
}
}
storeRankingOutDTOS = businessAnalysisEsRespository.queryBusinessStoreAmountRankingEs(businessStoreEsDTO);
return ServiceResult.success(storeRankingOutDTOS);
}

/**
* @method-name: searchBusinessStoreRankingSql
* @description: 门店销售额排行sql
* @author: 刘凯峰
* @date: 2018/1/17 13:39
* @param: [commonInDTO]
* @return: java.util.List<cn.com.tcsl.loongboss.report.api.model.business.BusinessStoreRankingOutDTO>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private ServiceResult<List<BusinessStoreRankingOutDTO>> searchBusinessStoreRankingSql(CommonInDTO commonInDTO) {
ResponseResult<List<BusinessReport4StoreOutDTO>> storeRankingSqlResult = businessAnalysisClient.queryBusiness4Store(BusinessAnalysisConverter.commonInDTO2StoreRankingInDTO(commonInDTO));
if (!Objects.equals(ZERO, storeRankingSqlResult.getCode())) {
return ServiceResult.failure(STORE_AMOUNT_RANKING_SQL_EXCEPTION);
}
List<BusinessStoreRankingOutDTO> storeRankingOutDTOS = Lists.newArrayList();
if (Objects.nonNull(storeRankingSqlResult.getData()) && !storeRankingSqlResult.getData().isEmpty()) {
storeRankingSqlResult.getData().forEach(storeRanking -> {
BusinessStoreRankingOutDTO storeRankingOutDTO = new BusinessStoreRankingOutDTO();
storeRankingOutDTO.setStoreName(storeRanking.getStoreName());
storeRankingOutDTO.setBusiTotal(DigitsUtils.doubleRoundOff2String(Double.valueOf(storeRanking.getBusinessAmount())));
storeRankingOutDTOS.add(storeRankingOutDTO);
});
}
return ServiceResult.success(storeRankingOutDTOS);
}

/**
* @method-name: buildStoreBusinessAmountRankingDTO
* @description: 门店销售额排行ES统计条件
* @author: 刘凯峰
* @date: 2018/1/17 14:33
* @param: [commonInDTO]
* @return: cn.com.tcsl.loongboss.report.api.model.business.BusinessStoreEsDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessStoreEsDTO buildStoreBusinessAmountRankingDTO(CommonInDTO commonInDTO) {
String beginTime = DateUtils.timestampToDateTimeString(commonInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.getSomeDay(commonInDTO.getEndTime(), -1);

BusinessStoreEsDTO conditionDTO = new BusinessStoreEsDTO();
conditionDTO.setStoreCodeList(commonInDTO.getStoreCode());
conditionDTO.setGroupQueryFlag(commonInDTO.getGroupQueryFlag());
conditionDTO.setGroupFieldName(GROUP_CODE_FIELD_NAME);
conditionDTO.setGroupCode(commonInDTO.getGroupCode());
//门店编号字段名
conditionDTO.setStoreFieldName(STORE_CODE_FIELD_NAME);
//门店名称字段名
conditionDTO.setGroupByFieldName(STORE_NAME_FIELD_NAME);
//营业额字段名字段名
conditionDTO.setSumFieldName(AMOUNT_FIELD_NAME);
conditionDTO.setDateRangFieldName(BIZ_DATE_FIELD_NAME);
conditionDTO.setBeginTimeValue(beginTime);
conditionDTO.setEndTimeValue(endTime);
conditionDTO.setIndexFieldName(RPT_INDICATES.getIndex());
conditionDTO.setTypeFieldName(RPT_INDICATES.getType());

conditionDTO.setSize(commonInDTO.getSize());
conditionDTO.setTypeIdFieldName(TYPE_ID_FIELD_NAME);
conditionDTO.setTypeIdFieldValue(BUSINESS_AMOUNT.getKey());
return conditionDTO;
}
//endregion

//region 统计各门店营业额、实际收入、客单数等营业情况

/**
* @param storeInDTO 入参信息
* @method-name: businessAnalysisStoreService
* @description: 门店营业情况统计
* 统计的内容有：营业额、实际收入、客单数
* @author: 刘凯峰
* @date: 2018/1/17 13:08
* @param:
* @return:
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
@Override
public ServiceResult<List<BusinessStoreOutDTO>> queryBusinessStoreService(BusinessStoreInDTO storeInDTO) {
//入参校验及处理
ServiceResult<String> checkResult = reportInParamCheckService.checkParam(storeInDTO);
if (!ZERO.equals(checkResult.getCode())) {
return ServiceResult.failure(checkResult.getCode(), checkResult.getMsg());
}
//返回结果
List<BusinessStoreOutDTO> businessStoreOutDTOS = Lists.newArrayList();
//时间标识为按日统计
boolean isDay = Objects.equals(DAY.getKey(), storeInDTO.getTimeFlag());
//时间标识为按今日统计
boolean isToday = Objects.equals(TODAY.getKey(), storeInDTO.getTimeFlag());
//起始时间为今天
boolean isTodayTime = DateUtils.isToday(storeInDTO.getBeginTime());
//构建ES查询条件
BusinessStoreEsDTO businessStoreEsDTO = buildStoreBusinessEsDTO(storeInDTO);
//实时数据统计
if (isToday || (isDay && isTodayTime)) {
businessStoreOutDTOS = searchBusinessStoreSql(storeInDTO).getResult();
} else {
//周月年统计
businessStoreOutDTOS = businessAnalysisEsRespository.queryBusinessStoreEs(businessStoreEsDTO);
}
//分页
if (Objects.nonNull(businessStoreOutDTOS) && !businessStoreOutDTOS.isEmpty()) {
List<BusinessStoreOutDTO> collectResult = businessStoreOutDTOS.stream()
.limit(storeInDTO.getLimit() * storeInDTO.getPage())
.skip((storeInDTO.getPage() - 1) * storeInDTO.getLimit()).collect(toList());
return ServiceResult.success(collectResult);
}
return ServiceResult.success(businessStoreOutDTOS);
}

/**
* @method-name: buildStoreBusinessEsDTO
* @description: 门店营业情况，ES条件构建
* @author: 刘凯峰
* @date: 2018/1/17 17:04
* @param: [storeInDTO]
* @return: cn.com.tcsl.loongboss.report.api.model.business.BusinessStoreEsDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessStoreEsDTO buildStoreBusinessEsDTO(BusinessStoreInDTO storeInDTO) {
String beginTime = DateUtils.timestampToDateTimeString(storeInDTO.getBeginTime(), DateUtils.PATTERN_OF_DATE);
String endTime = DateUtils.timestampToDateTimeString(storeInDTO.getEndTime(), DateUtils.PATTERN_OF_DATE);
LocalDate localDate = LocalDate.parse(endTime).minusDays(1L);
endTime = localDate.toString();

BusinessStoreEsDTO conditionDTO = new BusinessStoreEsDTO();
conditionDTO.setStoreCodeList(storeInDTO.getStoreCode());
conditionDTO.setGroupQueryFlag(storeInDTO.getGroupQueryFlag());
conditionDTO.setGroupCode(storeInDTO.getGroupCode());
conditionDTO.setGroupFieldName(GROUP_CODE_FIELD_NAME);
//门店编号字段名
conditionDTO.setStoreFieldName(STORE_CODE_FIELD_NAME);
//门店名称字段名
conditionDTO.setGroupByFieldName(STORE_NAME_FIELD_NAME);
//日期字段名字
conditionDTO.setDateRangFieldName(BIZ_DATE_FIELD_NAME_2);
conditionDTO.setBeginTimeValue(beginTime);
conditionDTO.setEndTimeValue(endTime);
conditionDTO.setIndexFieldName(RPT_INDICATES_DAY.getIndex());
conditionDTO.setTypeFieldName(RPT_INDICATES_DAY.getType());
conditionDTO.setSize(storeInDTO.getSize());
return conditionDTO;
}

/**
* @method-name: searchBusinessStoreSql
* @description: 门店营业排实时查询，包括：营业额、实际收入、客单数
* @author: 刘凯峰
* @date: 2018/1/17 16:46
* @param: [storeInDTO]
* @return: cn.com.tcsl.scmsframework.common.model.ServiceResult<java.util.List<cn.com.tcsl.loongboss.report.api.model.business.BusinessStoreOutDTO>>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private ServiceResult<List<BusinessStoreOutDTO>> searchBusinessStoreSql(BusinessStoreInDTO storeInDTO) {
ResponseResult<List<BusinessReport4StoreOutDTO>> storeRankingSqlResult = businessAnalysisClient.queryBusiness4Store(BusinessAnalysisConverter.commonInDTO2StoreInDTO(storeInDTO));
if (!Objects.equals(ZERO, storeRankingSqlResult.getCode())) {
return ServiceResult.failure(STORE_BUSINESS_AMOUNT_SQL_EXCEPTION);
}
List<BusinessStoreOutDTO> businessStoreOutDTOS = Lists.newArrayList();
if (Objects.nonNull(storeRankingSqlResult.getData()) && !storeRankingSqlResult.getData().isEmpty()) {
storeRankingSqlResult.getData().forEach(storeRanking -> {
BusinessStoreOutDTO businessStoreOutDTO = new BusinessStoreOutDTO();
businessStoreOutDTO.setStoreName(storeRanking.getStoreName());
businessStoreOutDTO.setBusiTotal(DigitsUtils.doubleRoundOff2String(Double.valueOf(storeRanking.getBusinessAmount())));
businessStoreOutDTO.setIncomeTotal(DigitsUtils.doubleRoundOff2String(Double.valueOf(storeRanking.getActualIncomeAmount())));
businessStoreOutDTO.setBsCount(storeRanking.getOrderCount());
businessStoreOutDTOS.add(businessStoreOutDTO);
});
}
return ServiceResult.success(businessStoreOutDTOS);
}
//endregion

//region 公共方法

/**
* @method-name: buildSqlCondition
* @description: 构建当天数据查询SQL条件
* @author: 刘凯峰
* @date: 2017/11/7 14:22
* @param: [commonInDTO]
* @return: cn.com.tcsl.loongboss.cy7.api.model.BusinessReportInDTO
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private BusinessReportInDTO buildSqlCondition(CommonInDTO commonInDTO) {
BusinessReportInDTO businessReportInDTO = new BusinessReportInDTO();
String currentDate = DateUtil.getCurrentDate(DateUtil.formate_date);
businessReportInDTO.setBeginTime(currentDate + " 00:00:00");
businessReportInDTO.setEndTime(currentDate + " 00:00:00");
businessReportInDTO.setStoreCodes(commonInDTO.getStoreCode());
businessReportInDTO.setGroupCode(commonInDTO.getGroupCode());
return businessReportInDTO;
}

/**
* @method-name: timeMapList2CommonBeanList
* @description: 时间MAP转换成bean
* @author: 刘凯峰
* @date: 2017/12/27 9:44
* @param: [map]
* @return: java.util.List<cn.com.tcsl.loongboss.report.api.model.business.CommonDetailBean>
* @version V1.0
* update-logs:方法变更说明
* ****************************************************
* name:
* date:
* description:
* *****************************************************
*/
private List<CommonDetailBean> timeMapList2CommonBeanList(List<Map<String, String>> map) {
List<CommonDetailBean> commonDetailBeans = Lists.newArrayList();
map.forEach(mapItem -> {
CommonDetailBean commonDetailBean = new CommonDetailBean();
commonDetailBean.setTimeName(mapItem.get(CODE));
commonDetailBean.setTotalMoney(mapItem.get(VALUE));
commonDetailBeans.add(commonDetailBean);
});
return commonDetailBeans;
}

//endregion

private static List<CommonDetailBean> getDefault12MonthsAYear(){

List<CommonDetailBean> beans = new ArrayList<>();

int year = LocalDate.now().getYear();

for(int i= 1; i<=12;i++){
CommonDetailBean bean = new CommonDetailBean();
if(i<10) {
bean.setTimeName(year + "-0" + i);
}else{
bean.setTimeName(year + "-" + i);
}

beans.add(bean);

}

return beans;
}

private static List<CommonDetailBean> get12MonthsAYear( List<CommonDetailBean> goals ){

List<CommonDetailBean> beans = MONTHS_A_YEAR;

Map<String, String> defaultDate = beans.stream().collect(Collectors.toMap(CommonDetailBean::getTimeName, CommonDetailBean::getTotalMoney));

if(!CollectionUtils.isEmpty(goals)){
Map<String, String> currentDate = goals.stream().collect(Collectors.toMap(CommonDetailBean::getTimeName, CommonDetailBean::getTotalMoney));
currentDate.entrySet().stream().forEach(c->{
defaultDate.put(c.getKey(),c.getValue());
});
}

List<CommonDetailBean> resultBeans = new ArrayList<>();

defaultDate.entrySet().stream().forEach(d->{

CommonDetailBean bean = new CommonDetailBean();
bean.setTimeName(d.getKey());
bean.setTotalMoney(d.getValue());

resultBeans.add(bean);

});

return resultBeans;
}

}

{
"size" : 0,
"query" : {
"bool" : {
"must" : [
{
"range" : {
"biz_date" : {
"from" : "20180330",
"to" : "20180330",
"include_lower" : true,
"include_upper" : true,
"format" : "yyyyMMdd",
"boost" : 1.0
}
}
}
],
"filter" : [
{
"terms" : {
"mcid" : [
"12787"
],
"boost" : 1.0
}
}
],
"disable_coord" : false,
"adjust_pure_negative" : true,
"boost" : 1.0
}
},
"aggregations" : {
"biz_hour" : {
"terms" : {
"field" : "biz_hour",
"size" : 30,
"min_doc_count" : 1,
"shard_min_doc_count" : 0,
"show_term_doc_count_error" : false,
"order" : [
{
"_count" : "desc"
},
{
"_term" : "asc"
}
]
},
"aggregations" : {
"busi_income" : {
"sum" : {
"field" : "busi_income"
}
}
}
}
}
}

{
"size" : 0,
"query" : {
"bool" : {
"must" : [
{
"range" : {
"biz_date" : {
"from" : "20180330",
"to" : "20180330",
"include_lower" : true,
"include_upper" : true,
"format" : "yyyyMMdd",
"boost" : 1.0
}
}
}
],
"filter" : [
{
"terms" : {
"mcid" : [
"12787"
],
"boost" : 1.0
}
}
],
"disable_coord" : false,
"adjust_pure_negative" : true,
"boost" : 1.0
}
},
"aggregations" : {
"biz_hour" : {
"terms" : {
"field" : "biz_hour",
"size" : 30,
"min_doc_count" : 1,
"shard_min_doc_count" : 0,
"show_term_doc_count_error" : false,
"order" : [
{
"_count" : "desc"
},
{
"_term" : "asc"
}
]
},
"aggregations" : {
"orig_total" : {
"sum" : {
"field" : "orig_total"
}
}
}
}
}
}

转载于:https://my.oschina.net/u/3424826/blog/1975934

chengsao5165

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Alluxio 集群环境搭建

单节点启动验证本机的环境 ./bin/alluxio validateEnv local 只需要配置alluxio.master.hostname即可 alluxio.master.hostname=hadoop-slave2 然后我们启动alluxio，访问 http://192.168....
复制链接

扫一扫