package com.yeshi.fanli.service.impl.count;
|
|
import java.math.BigDecimal;
|
import java.text.DecimalFormat;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
|
import javax.annotation.Resource;
|
|
import org.springframework.stereotype.Service;
|
import org.yeshi.utils.DateUtil;
|
|
import com.yeshi.fanli.dao.mybatis.UserInfoCountMapper;
|
import com.yeshi.fanli.dao.mybatis.UserInfoMapper;
|
import com.yeshi.fanli.dao.user.count.CountOrderInfoDao;
|
import com.yeshi.fanli.dao.user.count.CountUserInfoDao;
|
import com.yeshi.fanli.dto.ChartTDO;
|
import com.yeshi.fanli.dto.order.CountOrderDTO;
|
import com.yeshi.fanli.entity.admin.count.CountOrderInfo;
|
import com.yeshi.fanli.entity.admin.count.CountOrderInfo.CountOrderEnum;
|
import com.yeshi.fanli.entity.admin.count.CountUserInfo;
|
import com.yeshi.fanli.entity.admin.count.CountUserInfo.CountUserEnum;
|
import com.yeshi.fanli.entity.bus.user.UserInfoRegister;
|
import com.yeshi.fanli.entity.system.ChannelEnum;
|
import com.yeshi.fanli.service.inter.count.HongBaoV2CountService;
|
import com.yeshi.fanli.service.inter.count.UserInfoCountService;
|
import com.yeshi.fanli.service.inter.order.CommonOrderCountService;
|
import com.yeshi.fanli.service.inter.order.LostOrderService;
|
import com.yeshi.fanli.service.inter.order.UserOrderWeiQuanRecordService;
|
import com.yeshi.fanli.service.inter.user.UserInfoRegisterService;
|
import org.yeshi.utils.MoneyBigDecimalUtil;
|
import com.yeshi.fanli.util.StringUtil;
|
import org.yeshi.utils.TimeUtil;
|
import com.yeshi.fanli.vo.user.UserGoldCoinVO;
|
|
@Service
|
public class UserInfoCountServiceImpl implements UserInfoCountService {
|
|
@Resource
|
private UserInfoMapper userInfoMapper;
|
|
@Resource
|
private UserInfoCountMapper userInfoCountMapper;
|
|
@Resource
|
private CountUserInfoDao countUserInfoDao;
|
|
@Resource
|
private CountOrderInfoDao countOrderInfoDao;
|
|
@Resource
|
private CommonOrderCountService commonOrderCountService;
|
|
@Resource
|
private HongBaoV2CountService hongBaoV2CountService;
|
|
@Resource
|
private UserOrderWeiQuanRecordService userOrderWeiQuanRecordService;
|
|
@Resource
|
private LostOrderService lostOrderService;
|
|
@Resource
|
private UserInfoRegisterService userInfoRegisterService;
|
|
|
@Override
|
public long countNewUser(Integer isToday, Integer isMonth) {
|
return userInfoMapper.countNewUser(isToday, isMonth);
|
}
|
|
@Override
|
public long countRank(Integer rank) {
|
return userInfoMapper.countRank(rank);
|
}
|
|
@Override
|
public BigDecimal countAllMoney(Double rank) {
|
return userInfoMapper.countAllMoney(rank);
|
}
|
|
@Override
|
public long countLoseUser(int daysNum) {
|
return userInfoMapper.countLoseUser(daysNum);
|
}
|
|
@Override
|
public long countHasOrderUser() {
|
return userInfoMapper.countHasOrderUser();
|
}
|
|
@Override
|
public List<ChartTDO> countNewUserByDate(String channel, Integer type, String years, String startTime,
|
String endTime) throws Exception {
|
return userInfoMapper.countNewUserByDate(channel, type, years, startTime, endTime);
|
|
}
|
|
@Override
|
public List<ChartTDO> getTodayBuyRate(String channel, Integer dateType, String years, String startTime,
|
String endTime) throws Exception {
|
|
List<ChartTDO> result_list = null;
|
|
List<ChartTDO> listToday = userInfoMapper.getTodayHasOrder(channel, dateType, years, startTime, endTime);
|
|
if (listToday == null || listToday.size() == 0) {
|
return result_list;
|
}
|
|
List<ChartTDO> listTotal = userInfoMapper.countNewUserByDate(channel, dateType, years, startTime, endTime);
|
|
if (listTotal == null || listTotal.size() == 0) {
|
return result_list;
|
}
|
|
switch (dateType) {
|
case 1: // 按天处理
|
result_list = dayFactory(startTime, endTime, listTotal);
|
break;
|
case 2: // 按月处理
|
result_list = monthFactory(listTotal);
|
break;
|
case 3:
|
result_list = yearFactory(listTotal);
|
break;
|
default:
|
break;
|
}
|
|
DecimalFormat df = new DecimalFormat("#.00");
|
|
for (int i = 0; i < result_list.size(); i++) {
|
double proportion = 0;
|
ChartTDO chartTDO = result_list.get(i);
|
String showDate = chartTDO.getShowDate();
|
for (int j = 0; j < listToday.size(); j++) {
|
ChartTDO innerTDO = listToday.get(j);
|
String innerDate = innerTDO.getShowDate();
|
if (innerDate != null && innerDate.equals(showDate)) {
|
String innerValue = innerTDO.getShowValue();
|
long innerData = Long.parseLong(innerValue);
|
|
String showValue = chartTDO.getShowValue();
|
long showData = Long.parseLong(showValue);
|
|
if (showData > 0) {
|
proportion = innerData / (double) showData;
|
}
|
break; // 结束内部循环
|
}
|
}
|
chartTDO.setShowValue(Double.parseDouble(df.format(proportion * 100)) + "");
|
}
|
return result_list;
|
}
|
|
@Override
|
public List<Object> getWeekBuyRate(String channel, String startTime, String endTime, Integer orderNum,
|
List<String> dateList) throws Exception {
|
List<Object> resultList = new ArrayList<Object>();
|
if (dateList == null || dateList.size() == 0) {
|
return resultList;
|
}
|
|
List<ChartTDO> totalList = userInfoMapper.countNewUserByDate(channel, 1, null, startTime, endTime);
|
if (totalList == null || totalList.size() == 0) {
|
return resultList;
|
}
|
|
DecimalFormat df = new DecimalFormat("#.00");
|
for (int i = 0; i < dateList.size(); i++) {
|
double proportion = 0;
|
String showDate = dateList.get(i);
|
String plusDay = DateUtil.plusDay(7, showDate);
|
ChartTDO chartTDO = userInfoMapper.getWeekHasOrder(channel, showDate, plusDay, orderNum);
|
|
String showValue = null;
|
if (chartTDO != null) {
|
showValue = chartTDO.getShowValue();
|
if (showValue != null) {
|
for (int j = 0; j < totalList.size(); j++) {
|
ChartTDO chart = totalList.get(j);
|
String reslutTime = chart.getShowDate();
|
if (showDate.equalsIgnoreCase(reslutTime)) {
|
String totalObject = chart.getShowValue();
|
long hasCount = Long.parseLong(showValue);
|
long total = Long.parseLong(totalObject);
|
|
if (total > 0) {
|
proportion = hasCount / (double) total;
|
}
|
|
break;
|
}
|
}
|
}
|
}
|
resultList.add(Double.parseDouble(df.format(proportion * 100)));
|
}
|
|
return resultList;
|
}
|
|
public List<ChartTDO> dayFactory(String startTime, String endTime, List<ChartTDO> list) throws Exception {
|
List<ChartTDO> listObject = new ArrayList<ChartTDO>();
|
if (startTime.equals(endTime)) {
|
ChartTDO chartTDO = list.get(0);
|
String showValue = chartTDO.getShowValue();
|
if (showValue == null) {
|
chartTDO.setShowValue("0");
|
}
|
listObject.add(chartTDO);
|
return listObject;
|
}
|
|
String plusDay = "";
|
for (int i = 0; i < 1000; i++) {
|
if (i == 0) {
|
plusDay = startTime;
|
} else {
|
plusDay = DateUtil.plusDay(i, startTime);
|
}
|
|
String total = null;
|
for (int j = 0; j < list.size(); j++) {
|
ChartTDO chartTDO = list.get(j);
|
String month = chartTDO.getShowDate();
|
if (plusDay.equalsIgnoreCase(month)) {
|
total = chartTDO.getShowValue();
|
break;
|
}
|
}
|
|
if (total == null) {
|
total = "0";
|
}
|
ChartTDO chartTDO = new ChartTDO();
|
chartTDO.setShowValue(total);
|
chartTDO.setShowDate(plusDay);
|
listObject.add(chartTDO);
|
|
if (plusDay.equals(endTime)) {
|
break; // 时间结束
|
}
|
}
|
|
return listObject;
|
}
|
|
public List<ChartTDO> monthFactory(List<ChartTDO> list) {
|
List<ChartTDO> listObject = new ArrayList<ChartTDO>();
|
// 12 个月处理
|
for (int i = 1; i <= 12; i++) {
|
String total = null;
|
for (int j = 0; j < list.size(); j++) {
|
ChartTDO chartTDO = list.get(j);
|
String month = chartTDO.getShowDate();
|
if ((i + "").equalsIgnoreCase(month) || i == Integer.parseInt(month)) {
|
total = chartTDO.getShowValue();
|
break;
|
}
|
}
|
|
if (total == null) {
|
total = "0";
|
}
|
|
ChartTDO chartTDO = new ChartTDO();
|
chartTDO.setShowValue(total);
|
|
if (i < 10) {
|
chartTDO.setShowDate("0" + i);
|
} else {
|
chartTDO.setShowDate("" + i);
|
}
|
listObject.add(chartTDO);
|
}
|
return listObject;
|
}
|
|
public List<ChartTDO> yearFactory(List<ChartTDO> list) {
|
List<ChartTDO> listObject = new ArrayList<ChartTDO>();
|
for (int i = 0; i < list.size(); i++) {
|
ChartTDO chartTDO = list.get(i);
|
String total = chartTDO.getShowValue();
|
if (total == null) {
|
total = "0";
|
}
|
chartTDO.setShowValue(total);
|
listObject.add(chartTDO);
|
}
|
return listObject;
|
}
|
|
@Override
|
public List<UserGoldCoinVO> listByUserGoldCoin(long start, int count, int type, String key) {
|
return userInfoCountMapper.listByUserGoldCoin(start, count, type, key);
|
}
|
|
@Override
|
public long countByUserGoldCoin(int type, String key) {
|
return userInfoCountMapper.countByUserGoldCoin(type, key);
|
}
|
|
@Override
|
public List<UserGoldCoinVO> listByHasGoldCoin(long start, int count, String key) {
|
return userInfoCountMapper.listByHasGoldCoin(start, count, key);
|
}
|
|
@Override
|
public long countByHasGoldCoin(String key) {
|
return userInfoCountMapper.countByHasGoldCoin(key);
|
}
|
|
@Override
|
public List<CountUserInfo> getNewUserData(Date startTime, Date endTime, String channel) {
|
// 重新查询统计今日以及空缺
|
|
return countUserInfoDao.query(CountUserEnum.newUser, startTime, endTime, channel);
|
}
|
|
|
|
|
@Override
|
public List<CountOrderInfo> countOderByChannel(String channel, Date startTime, Date endTime) {
|
// 重新查询统计今日以及空缺
|
initOrderCount();
|
|
return countOrderInfoDao.query(CountOrderEnum.channelTotal, startTime, endTime, channel);
|
}
|
|
// 初始化统计
|
private void initOrderCount() {
|
try {
|
CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.channelTotal);
|
Date lastDay = null;
|
if (lastRecord != null && lastRecord.getDay() != null) {
|
lastDay = lastRecord.getDay();
|
}
|
|
if (lastDay == null) {
|
lastDay = TimeUtil.parse("2018-01-01");
|
}
|
|
Date today = new Date();
|
int betweenDays = DateUtil.daysBetween2(lastDay, today);
|
if (betweenDays > 0) {
|
for (int i = 0; i <= betweenDays; i++) {
|
addRecordOrderCount(DateUtil.plusDay(i, lastDay));
|
}
|
} else {
|
// 重新统计昨日
|
addRecordOrderCount(DateUtil.reduceDay2(1, lastDay));
|
// 重新统计今日
|
addRecordOrderCount(TimeUtil.getGernalTime(today.getTime()));
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
|
private void addRecordOrderCount(String preDay) throws Exception {
|
ChannelEnum[] channels = ChannelEnum.values();
|
for (int i = 0; i < channels.length; i++) {
|
int count = 0;
|
String channelVlaue = channels[i].getVlaue();
|
|
List<CountOrderDTO> listOrder = commonOrderCountService.countValidOrderByDay(preDay);
|
if (listOrder != null && listOrder.size() > 0) {
|
List<Long> listUid = new ArrayList<>();
|
for (CountOrderDTO countOrderDTO: listOrder) {
|
listUid.add(countOrderDTO.getUid());
|
}
|
|
List<UserInfoRegister> listRegister = userInfoRegisterService.listByMultipleUids(listUid);
|
if (listRegister != null && listRegister.size() > 0) {
|
for (int m = 0; m <listRegister.size(); m ++) {
|
boolean reduce = false;
|
Long uid = listRegister.get(m).getId();
|
String vlaue = listRegister.get(m).getChannel();
|
|
for (int n = 0; n <listOrder.size(); n ++) {
|
if (channelVlaue.equalsIgnoreCase(vlaue) && uid.longValue() == listOrder.get(n).getUid()) {
|
Integer totalOrder = listOrder.get(n).getTotalOrder();
|
if (totalOrder != null)
|
count += totalOrder;
|
|
listOrder.remove(n);
|
n--;
|
reduce = true;
|
}
|
}
|
|
if (reduce) {
|
listRegister.remove(m);
|
m--;
|
}
|
}
|
}
|
}
|
|
CountOrderInfo record = new CountOrderInfo();
|
record.setNum(count);
|
record.setChannel(channels[i].name());
|
record.setDay(TimeUtil.parse(preDay));
|
record.setType(CountOrderEnum.channelTotal.name());
|
record.setId(StringUtil.Md5(preDay + channels[i].name() + CountOrderEnum.channelTotal.name()));
|
countOrderInfoDao.save(record);
|
}
|
}
|
|
|
@Override
|
public List<CountOrderInfo> count24HOderByChannel(String channel, Date startTime, Date endTime) {
|
// 重新查询统计今日以及空缺
|
init24HOrderCount();
|
|
return countOrderInfoDao.query(CountOrderEnum.oder24H, startTime, endTime, channel);
|
}
|
|
// 初始化统计
|
private void init24HOrderCount() {
|
try {
|
CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.oder24H);
|
Date lastDay = null;
|
if (lastRecord != null && lastRecord.getDay() != null) {
|
lastDay = lastRecord.getDay();
|
}
|
|
if (lastDay == null) {
|
lastDay = TimeUtil.parse("2018-01-01");
|
}
|
|
Date today = new Date();
|
int betweenDays = DateUtil.daysBetween2(lastDay, today);
|
if (betweenDays > 0) {
|
for (int i = 0; i <= betweenDays; i++) {
|
addRecord24HOrderCount(DateUtil.plusDay(i, lastDay));
|
}
|
} else {
|
// 重新统计昨日
|
addRecord24HOrderCount(DateUtil.reduceDay2(1, lastDay));
|
// 重新统计今日
|
addRecord24HOrderCount(TimeUtil.getGernalTime(today.getTime()));
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
private void addRecord24HOrderCount(String preDay) throws Exception {
|
ChannelEnum[] channels = ChannelEnum.values();
|
for (int i = 0; i < channels.length; i++) {
|
int count = 0;
|
List<UserInfoRegister> list = userInfoRegisterService.listByChannelAndDay(channels[i].getVlaue(), preDay);
|
if (list != null && list.size() > 0) {
|
// 统计24小时产生订单数量
|
for (UserInfoRegister user : list) {
|
Date limitDay = DateUtil.plusDayDate(1, user.getCreateTime());
|
Integer total = commonOrderCountService.countOderByUidAndDate(limitDay, user.getId());
|
if (total != null)
|
count += total;
|
}
|
}
|
CountOrderInfo record = new CountOrderInfo();
|
record.setNum(count);
|
record.setChannel(channels[i].name());
|
record.setDay(TimeUtil.parse(preDay));
|
record.setType(CountOrderEnum.oder24H.name());
|
record.setId(StringUtil.Md5(preDay + channels[i].name() + CountOrderEnum.oder24H.name()));
|
countOrderInfoDao.save(record);
|
}
|
}
|
|
|
@Override
|
public List<CountOrderInfo> countHongBaoByChannel(String channel, Date startTime, Date endTime) {
|
// 重新查询统计今日以及空缺
|
initHongBaoCount();
|
|
return countOrderInfoDao.query(CountOrderEnum.channelCommission, startTime, endTime, channel);
|
}
|
|
// 初始化统计
|
private void initHongBaoCount() {
|
try {
|
CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.channelCommission);
|
Date lastDay = null;
|
if (lastRecord != null && lastRecord.getDay() != null) {
|
lastDay = lastRecord.getDay();
|
}
|
|
if (lastDay == null) {
|
lastDay = TimeUtil.parse("2018-01-01");
|
}
|
|
Date today = new Date();
|
int betweenDays = DateUtil.daysBetween2(lastDay, today);
|
if (betweenDays > 0) {
|
for (int i = 0; i <= betweenDays; i++) {
|
addRecordHongBaoCount(DateUtil.plusDay(i, lastDay));
|
}
|
} else {
|
// 重新统计昨日
|
addRecordHongBaoCount(DateUtil.reduceDay2(1, lastDay));
|
// 重新统计今日
|
addRecordHongBaoCount(TimeUtil.getGernalTime(today.getTime()));
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
private void addRecordHongBaoCount(String preDay) throws Exception {
|
ChannelEnum[] channels = ChannelEnum.values();
|
for (int i = 0; i < channels.length; i++) {
|
BigDecimal money = new BigDecimal(0);
|
String channelVlaue = channels[i].getVlaue();
|
|
List<CountOrderDTO> listOrder = commonOrderCountService.countCommissionByDay(preDay);
|
if (listOrder != null && listOrder.size() > 0) {
|
List<Long> listUid = new ArrayList<>();
|
for (CountOrderDTO countOrderDTO: listOrder) {
|
listUid.add(countOrderDTO.getUid());
|
}
|
|
List<UserInfoRegister> listRegister = userInfoRegisterService.listByMultipleUids(listUid);
|
if (listRegister != null && listRegister.size() > 0) {
|
for (int m = 0; m <listRegister.size(); m ++) {
|
boolean reduce = false;
|
Long uid = listRegister.get(m).getId();
|
String vlaue = listRegister.get(m).getChannel();
|
|
for (int n = 0; n <listOrder.size(); n ++) {
|
if (channelVlaue.equalsIgnoreCase(vlaue) && uid.longValue() == listOrder.get(n).getUid()) {
|
BigDecimal commission = listOrder.get(n).getCommission();
|
if (commission != null)
|
MoneyBigDecimalUtil.add(money, commission);
|
|
listOrder.remove(n);
|
n--;
|
reduce = true;
|
}
|
}
|
|
if (reduce) {
|
listRegister.remove(m);
|
m--;
|
}
|
}
|
}
|
}
|
|
|
CountOrderInfo record = new CountOrderInfo();
|
record.setMoney(money);
|
record.setChannel(channels[i].name());
|
record.setDay(TimeUtil.parse(preDay));
|
record.setType(CountOrderEnum.channelCommission.name());
|
record.setId(StringUtil.Md5(preDay + channels[i].name() + CountOrderEnum.channelCommission.name()));
|
countOrderInfoDao.save(record);
|
}
|
}
|
|
|
@Override
|
public List<CountOrderInfo> countWeiQuanOrder(Date startTime, Date endTime) {
|
// 重新查询统计今日以及空缺
|
initWeiQuanCount();
|
|
return countOrderInfoDao.query(CountOrderEnum.weiQuanNum, startTime, endTime);
|
}
|
|
// 初始化统计
|
private void initWeiQuanCount() {
|
try {
|
CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.weiQuanNum);
|
Date lastDay = null;
|
if (lastRecord != null && lastRecord.getDay() != null) {
|
lastDay = lastRecord.getDay();
|
}
|
|
if (lastDay == null) {
|
lastDay = TimeUtil.parse("2019-01-01");
|
}
|
|
Date today = new Date();
|
int betweenDays = DateUtil.daysBetween2(lastDay, today);
|
if (betweenDays > 0) {
|
for (int i = 0; i <= betweenDays; i++) {
|
addRecordWeiQuanCount(DateUtil.plusDay(i, lastDay));
|
}
|
} else {
|
// 重新统计昨日
|
addRecordWeiQuanCount(DateUtil.reduceDay2(1, lastDay));
|
// 重新统计今日
|
addRecordWeiQuanCount(TimeUtil.getGernalTime(today.getTime()));
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
private void addRecordWeiQuanCount(String preDay) throws Exception {
|
Integer count = userOrderWeiQuanRecordService.countWeiQaunOrderNumberByDate(preDay);
|
if (count == null)
|
count = 0;
|
CountOrderInfo record = new CountOrderInfo();
|
record.setNum(count);
|
record.setDay(TimeUtil.parse(preDay));
|
record.setType(CountOrderEnum.weiQuanNum.name());
|
record.setId(StringUtil.Md5(preDay + CountOrderEnum.weiQuanNum.name()));
|
countOrderInfoDao.save(record);
|
}
|
|
|
@Override
|
public List<CountOrderInfo> countWeiQuanOrderMoney(Date startTime, Date endTime) {
|
// 重新查询统计今日以及空缺
|
initWeiQuanMoneyCount();
|
|
return countOrderInfoDao.query(CountOrderEnum.weiQuanMoney, startTime, endTime);
|
}
|
|
// 初始化统计
|
private void initWeiQuanMoneyCount() {
|
try {
|
CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.weiQuanMoney);
|
Date lastDay = null;
|
if (lastRecord != null && lastRecord.getDay() != null) {
|
lastDay = lastRecord.getDay();
|
}
|
|
if (lastDay == null) {
|
lastDay = TimeUtil.parse("2019-01-01");
|
}
|
|
Date today = new Date();
|
int betweenDays = DateUtil.daysBetween2(lastDay, today);
|
if (betweenDays > 0) {
|
for (int i = 0; i <= betweenDays; i++) {
|
addRecordWeiQuanMoneyCount(DateUtil.plusDay(i, lastDay));
|
}
|
} else {
|
// 重新统计昨日
|
addRecordWeiQuanMoneyCount(DateUtil.reduceDay2(1, lastDay));
|
// 重新统计今日
|
addRecordWeiQuanMoneyCount(TimeUtil.getGernalTime(today.getTime()));
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
private void addRecordWeiQuanMoneyCount(String preDay) throws Exception {
|
BigDecimal money = userOrderWeiQuanRecordService.countWeiQaunOrderMoneyByDate(preDay);
|
if (money == null)
|
money = new BigDecimal(0);
|
CountOrderInfo record = new CountOrderInfo();
|
record.setMoney(money);
|
record.setDay(TimeUtil.parse(preDay));
|
record.setType(CountOrderEnum.weiQuanMoney.name());
|
record.setId(StringUtil.Md5(preDay + CountOrderEnum.weiQuanMoney.name()));
|
countOrderInfoDao.save(record);
|
}
|
|
|
@Override
|
public List<CountOrderInfo> counOrderTotalNum(Date startTime, Date endTime) {
|
// 重新查询统计今日以及空缺
|
initOrderTotalNum();
|
|
return countOrderInfoDao.query(CountOrderEnum.totalNum, startTime, endTime);
|
}
|
|
// 初始化统计
|
private void initOrderTotalNum() {
|
try {
|
CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.totalNum);
|
Date lastDay = null;
|
if (lastRecord != null && lastRecord.getDay() != null) {
|
lastDay = lastRecord.getDay();
|
}
|
|
if (lastDay == null) {
|
lastDay = TimeUtil.parse("2019-01-01");
|
}
|
|
Date today = new Date();
|
int betweenDays = DateUtil.daysBetween2(lastDay, today);
|
if (betweenDays > 0) {
|
for (int i = 0; i <= betweenDays; i++) {
|
addRecordOrderTotalNum(DateUtil.plusDay(i, lastDay));
|
}
|
} else {
|
// 重新统计昨日
|
addRecordOrderTotalNum(DateUtil.reduceDay2(1, lastDay));
|
// 重新统计今日
|
addRecordOrderTotalNum(TimeUtil.getGernalTime(today.getTime()));
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
private void addRecordOrderTotalNum(String preDay) throws Exception {
|
Integer num = commonOrderCountService.countOderByDate(preDay);
|
if (num == null)
|
num = 0;
|
CountOrderInfo record = new CountOrderInfo();
|
record.setNum(num);
|
record.setDay(TimeUtil.parse(preDay));
|
record.setType(CountOrderEnum.totalNum.name());
|
record.setId(StringUtil.Md5(preDay + CountOrderEnum.totalNum.name()));
|
countOrderInfoDao.save(record);
|
}
|
|
|
|
|
@Override
|
public List<CountOrderInfo> counOrderTotalCommission(Date startTime, Date endTime) {
|
// 重新查询统计今日以及空缺
|
initTotalCommission();
|
|
return countOrderInfoDao.query(CountOrderEnum.totalCommission, startTime, endTime);
|
}
|
|
// 初始化统计
|
private void initTotalCommission() {
|
try {
|
CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.totalCommission);
|
Date lastDay = null;
|
if (lastRecord != null && lastRecord.getDay() != null) {
|
lastDay = lastRecord.getDay();
|
}
|
|
if (lastDay == null) {
|
lastDay = TimeUtil.parse("2019-01-01");
|
}
|
|
Date today = new Date();
|
int betweenDays = DateUtil.daysBetween2(lastDay, today);
|
if (betweenDays > 0) {
|
for (int i = 0; i <= betweenDays; i++) {
|
addRecordTotalCommission(DateUtil.plusDay(i, lastDay));
|
}
|
} else {
|
// 重新统计昨日
|
addRecordTotalCommission(DateUtil.reduceDay2(1, lastDay));
|
// 重新统计今日
|
addRecordTotalCommission(TimeUtil.getGernalTime(today.getTime()));
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
private void addRecordTotalCommission(String preDay) throws Exception {
|
BigDecimal money = commonOrderCountService.countCommissionByDate(preDay);
|
if (money == null)
|
money = new BigDecimal("0");
|
CountOrderInfo record = new CountOrderInfo();
|
record.setMoney(money);
|
record.setDay(TimeUtil.parse(preDay));
|
record.setType(CountOrderEnum.totalCommission.name());
|
record.setId(StringUtil.Md5(preDay + CountOrderEnum.totalCommission.name()));
|
countOrderInfoDao.save(record);
|
}
|
|
@Override
|
public List<CountOrderInfo> counOrderLastNum(Date startTime, Date endTime) {
|
|
return countOrderInfoDao.query(CountOrderEnum.lastNum, startTime, endTime);
|
}
|
|
|
|
@Override
|
public List<CountOrderInfo> counOrderLastMoney(Date startTime, Date endTime) {
|
// 重新查询统计今日以及空缺
|
initOrderLastMoney();
|
|
return countOrderInfoDao.query(CountOrderEnum.lastMoney, startTime, endTime);
|
}
|
|
// 初始化统计
|
private void initOrderLastMoney() {
|
try {
|
CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.lastMoney);
|
Date lastDay = null;
|
if (lastRecord != null && lastRecord.getDay() != null) {
|
lastDay = lastRecord.getDay();
|
}
|
|
if (lastDay == null) {
|
lastDay = TimeUtil.parse("2019-01-01");
|
}
|
|
Date today = new Date();
|
int betweenDays = DateUtil.daysBetween2(lastDay, today);
|
if (betweenDays > 0) {
|
for (int i = 0; i <= betweenDays; i++) {
|
addRecordOrderLastMoney(DateUtil.plusDay(i, lastDay));
|
}
|
} else {
|
// 重新统计昨日
|
addRecordOrderLastMoney(DateUtil.reduceDay2(1, lastDay));
|
// 重新统计今日
|
addRecordOrderLastMoney(TimeUtil.getGernalTime(today.getTime()));
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
private void addRecordOrderLastMoney(String preDay) throws Exception {
|
BigDecimal money = lostOrderService.countAppealMoney(preDay);
|
if (money == null)
|
money = new BigDecimal("0");
|
CountOrderInfo record = new CountOrderInfo();
|
record.setMoney(money);
|
record.setDay(TimeUtil.parse(preDay));
|
record.setType(CountOrderEnum.lastMoney.name());
|
record.setId(StringUtil.Md5(preDay + CountOrderEnum.lastMoney.name()));
|
countOrderInfoDao.save(record);
|
}
|
|
|
|
|
@Override
|
public List<CountUserInfo> countUserDownOrderByChannelAndToday(String channel, Date startTime, Date endTime) {
|
// 重新查询统计今日以及空缺
|
initTodayDownOrderCount();
|
|
return countUserInfoDao.query(CountUserEnum.todayOrder, startTime, endTime, channel);
|
}
|
|
// 初始化统计
|
private void initTodayDownOrderCount() {
|
try {
|
CountUserInfo lastRecord = countUserInfoDao.getMaxDate(CountUserEnum.todayOrder);
|
Date lastDay = null;
|
if (lastRecord != null && lastRecord.getDay() != null) {
|
lastDay = lastRecord.getDay();
|
}
|
if (lastDay == null) {
|
lastDay = TimeUtil.parse("2018-01-01");
|
}
|
|
Date today = new Date();
|
int betweenDays = DateUtil.daysBetween2(lastDay, today);
|
if (betweenDays > 0) {
|
for (int i = 0; i <= betweenDays; i++) {
|
addRecordTodayDownOrderCount(DateUtil.plusDay(i, lastDay));
|
}
|
} else {
|
// 重新统计昨日
|
addRecordTodayDownOrderCount(DateUtil.reduceDay2(1, lastDay));
|
// 重新统计今日
|
addRecordTodayDownOrderCount(TimeUtil.getGernalTime(today.getTime()));
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
private void addRecordTodayDownOrderCount(String preDay) throws Exception {
|
ChannelEnum[] channels = ChannelEnum.values();
|
for (int i = 0; i < channels.length; i++) {
|
int count = 0;
|
String channelVlaue = channels[i].getVlaue();
|
|
List<CountOrderDTO> listOrder = commonOrderCountService.countValidOrderByDay(preDay);
|
if (listOrder != null && listOrder.size() > 0) {
|
List<Long> listUid = new ArrayList<>();
|
for (CountOrderDTO countOrderDTO: listOrder) {
|
listUid.add(countOrderDTO.getUid());
|
}
|
|
List<UserInfoRegister> listRegister = userInfoRegisterService.listByMultipleUidAndDay(listUid, preDay);
|
if (listRegister != null && listRegister.size() > 0) {
|
for (int m = 0; m <listRegister.size(); m ++) {
|
boolean reduce = false;
|
Long uid = listRegister.get(m).getId();
|
String vlaue = listRegister.get(m).getChannel();
|
|
for (int n = 0; n <listOrder.size(); n ++) {
|
if (channelVlaue.equalsIgnoreCase(vlaue) && uid.longValue() == listOrder.get(n).getUid()) {
|
Integer totalOrder = listOrder.get(n).getTotalOrder();
|
if (totalOrder != null)
|
count += totalOrder;
|
|
listOrder.remove(n);
|
n--;
|
reduce = true;
|
}
|
}
|
|
if (reduce) {
|
listRegister.remove(m);
|
m--;
|
}
|
}
|
}
|
}
|
|
CountUserInfo record = new CountUserInfo();
|
record.setNum(count);
|
record.setChannel(channels[i].name());
|
record.setDay(TimeUtil.parse(preDay));
|
record.setType(CountUserEnum.todayOrder);
|
record.setId(StringUtil.Md5(preDay + channels[i].name() + CountUserEnum.todayOrder.name()));
|
countUserInfoDao.save(record);
|
}
|
}
|
|
@Override
|
public List<CountUserInfo> countUseByChannelAndWeekOrder(String channel, Date startTime, Date endTime) {
|
return countUserInfoDao.query(CountUserEnum.weekOrder, startTime, endTime, channel);
|
}
|
|
@Override
|
public List<CountUserInfo> countUseByChannelAndWeekThreeOrder(String channel, Date startTime, Date endTime) {
|
return countUserInfoDao.query(CountUserEnum.weekThreeOrder, startTime, endTime, channel);
|
}
|
|
// 初始化统计
|
@Override
|
public void initCountUserWeekOrder() {
|
try {
|
CountUserInfo lastRecord = countUserInfoDao.getMaxDate(CountUserEnum.weekOrder);
|
Date lastDay = null;
|
if (lastRecord != null && lastRecord.getDay() != null) {
|
lastDay = lastRecord.getDay();
|
}
|
if (lastDay == null) {
|
lastDay = TimeUtil.parse("2018-01-01");
|
}
|
Date today = new Date();
|
int betweenDays = DateUtil.daysBetween2(lastDay, today);
|
if (betweenDays > 0) {
|
for (int i = 0; i <= betweenDays; i++) {
|
addRecordWeekOrderCount(DateUtil.plusDay(i, lastDay));
|
}
|
} else {
|
// 重新统计昨日
|
addRecordWeekOrderCount(DateUtil.reduceDay2(1, lastDay));
|
// 重新统计今日
|
addRecordWeekOrderCount(TimeUtil.getGernalTime(today.getTime()));
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
private void addRecordWeekOrderCount(String preDay) throws Exception {
|
ChannelEnum[] channels = ChannelEnum.values();
|
for (int i = 0; i < channels.length; i++) {
|
int count = 0;
|
int count3 = 0;
|
List<UserInfoRegister> list = userInfoRegisterService.listByChannelAndDay(channels[i].getVlaue(), preDay);
|
if (list != null && list.size() > 0) {
|
Date startDay = new Date(TimeUtil.convertDateToTemp2(preDay + " 23:59:59"));
|
Date limitDay = DateUtil.plusDayDate(6, startDay);
|
for (UserInfoRegister user : list) {
|
Integer total = commonOrderCountService.countOderByUidAndDate(limitDay, user.getId());
|
if (total != null && total > 0) {
|
count++;
|
if (total >= 3) {
|
count3++;
|
}
|
}
|
}
|
}
|
|
// 7天内产生有效订单
|
CountUserInfo record = new CountUserInfo();
|
record.setNum(count);
|
record.setChannel(channels[i].name());
|
record.setDay(TimeUtil.parse(preDay));
|
record.setType(CountUserEnum.weekOrder);
|
record.setId(StringUtil.Md5(preDay + channels[i].name() + CountUserEnum.weekOrder.name()));
|
countUserInfoDao.save(record);
|
|
// 7天内产生3单以上有效订单
|
CountUserInfo record3 = new CountUserInfo();
|
record3.setNum(count3);
|
record3.setChannel(channels[i].name());
|
record3.setDay(TimeUtil.parse(preDay));
|
record3.setType(CountUserEnum.weekThreeOrder);
|
record3.setId(StringUtil.Md5(preDay + channels[i].name() + CountUserEnum.weekThreeOrder.name()));
|
countUserInfoDao.save(record);
|
}
|
}
|
|
}
|
