Skip to content

yangxiujun / paidan_demo

Go to a project
Commit 3b5a44a1 by 王力
Options

Merge branch 'dev_mp2jpa0803' into 'develop' 

Dev mp2jpa0803

See merge request !319
2 parents a988a1c8 68811cd2
Inline Side-by-side
Showing with 203 additions and 131 deletions
project-order/src/main/java/com/dituhui/pea/order/dao/OrderInfoDao.java
......@@ -10,13 +10,11 @@ import java.util.List;
public interface OrderInfoDao extends JpaRepository<OrderInfoEntity, Long> {
OrderInfoEntity getByOrderId(String orderId);
OrderInfoEntity getByOrderIdAndDt(String orderId, LocalDate dt);
List<OrderInfoEntity> findByOrderId(String orderId);
List<OrderInfoEntity> findByDtAndEngineerCodeIn(LocalDate date, List<String> engineerCodes);
@Query("SELECT o.orderId, s.skillCategory as skillCaption FROM OrderInfoEntity o JOIN SkillInfoEntity s on o.brand=s.brand and o.type=s.type and o.skill=s.skill WHERE o.orderId = :orderId")
OrderSkillProjection getOrderSkillCaptionByOrderId(String orderId);
List<OrderInfoEntity> findAllByOrderIdIn(List<String> orderIds);
List<OrderInfoEntity> findAllByDtAndOrderIdIn(LocalDate dt, List<String> orderIds);
List<OrderInfoEntity> findByEngineerCodeAndDtAndAppointmentStatus(String engineerCode, LocalDate dt, String appointmentStatus);
}
project-order/src/main/java/com/dituhui/pea/order/dao/OrgTeamDao.java
......@@ -22,6 +22,9 @@ public interface OrgTeamDao extends JpaRepository<OrgTeamEntity, Integer> {
@Query("select t from OrgTeamEntity t where t.groupId = :groupId and t.status=1")
List<OrgTeamEntity> findAllByGroupId(String groupId);
@Query("select t from OrgTeamEntity t where t.teamId = :teamId and t.status=1")
List<OrgTeamEntity> findAllByTeamId(String teamId);
@Query("select t from OrgTeamEntity t where t.groupId = :groupId and t.status=1")
Page<OrgTeamEntity> findAllByGroupId(String groupId, Pageable pageable);
......
project-order/src/main/java/com/dituhui/pea/order/service/impl/OrderAssignImpl.java
package com.dituhui.pea.order.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.dituhui.pea.common.BusinessException;
import com.dituhui.pea.common.Result;
import com.dituhui.pea.order.common.OrderAssignCheck;
......@@ -19,6 +18,12 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalDateTime;
......@@ -30,50 +35,49 @@ import java.util.stream.Collectors;
public class OrderAssignImpl implements OrderAssign {
@Autowired
private OrderInfoMPDao orderInfoMPDao;
private OrderInfoDao orderInfoDao;
@Autowired
private EngineerInfoMPDao engineerInfoMPDao;
private EngineerInfoDao engineerInfoDao;
@Autowired
private CommonService commonService;
@Autowired
private OrderEventMPDao orderEventMPDao;
private OrderAssignCheck orderAssignCheck;
@Autowired
private OrderAssignCheck orderAssignCheck;
private OrgTeamDao orgTeamDao;
@Autowired
private OrgTeamMPDao orgTeamMPDao;
private OrgTeamEngineerDao orgTeamEngineerDao;
@Autowired
private OrgTeamEngineerMPDao orgTeamEngineerMPDao;
private SkillInfoDao skillInfoDao;
@Autowired
private SkillInfoMPDao skillInfoMPDao;
private EngineerSkillGroupDao engineerSkillGroupDao;
@Autowired
private EngineerSkillGroupMPDao engineerSkillGroupMPDao;
private EntityManager entityManager;
@Transactional
@Override
public Result<?> getOrderAssignRecommendEngineers(String orderId, String key, String distance, String recommend) {
// 服务单指派-推荐技术员列表
OrderInfo order = orderInfoMPDao.getByOrderId(orderId);
OrderInfoEntity order = orderInfoDao.getByOrderId(orderId);
if (order == null) {
throw new BusinessException("订单不存在");
}
String date = TimeUtils.timestamp2DateTime(order.getExpectTimeBegin(), TimeUtils.DATE_GAP_FORMAT);
String date = TimeUtils.IsoLocalDate2String(order.getDt());
// 获取符合筛选条件的技术员
List<String> engineerCodes = this.searchEngineerCodes(order, distance, key, recommend);
List<EngineerInfo> engineers = engineerInfoMPDao.selectByEngineerCodes(engineerCodes);
List<EngineerInfoEntity> engineers = engineerInfoDao.findByEngineerCodeIn(engineerCodes);
List<OrderAssignRecommendResp.Engineer> items = new ArrayList<>();
for (EngineerInfo engineer : engineers) {
for (EngineerInfoEntity engineer : engineers) {
OrderAssignCheck.Result result = orderAssignCheck.orderAssignCheck(orderId, order.getDt(), engineer.getEngineerCode());
log.info("指派检查结果:{}", result);
if (result.getIndex() < 0) {
......@@ -81,13 +85,13 @@ public class OrderAssignImpl implements OrderAssign {
}
// 获取已技术员已指派订单列表
List<OrderInfo> orderAppointments = orderInfoMPDao.selectByEngineerCodeAndDtAndAppointmentStatus(engineer.getEngineerCode(), order.getDt(), "CONFIRM");
List<OrderInfoEntity> orderAppointments = orderInfoDao.findByEngineerCodeAndDtAndAppointmentStatus(engineer.getEngineerCode(), order.getDt(), "CONFIRM");
// 获取订单tips
HashMap<String, List<LabelValueDTO>> orderTips = new HashMap<>();
List<String> orderIds = orderAppointments.stream().map(OrderInfo::getOrderId).collect(Collectors.toList());
List<String> orderIds = orderAppointments.stream().map(OrderInfoEntity::getOrderId).collect(Collectors.toList());
if (!orderIds.isEmpty()) {
List<OrderInfo> orders = orderInfoMPDao.selectByDtAndOrderIds(order.getDt(), orderIds);
List<OrderInfoEntity> orders = orderInfoDao.findAllByDtAndOrderIdIn(order.getDt(), orderIds);
orderTips = this.packOrderTips(orders);
}
......@@ -124,15 +128,15 @@ public class OrderAssignImpl implements OrderAssign {
public Result<?> orderAssign(String orderId, String engineerCode) throws BusinessException {
// 服务单指派-指派提交
OrderInfo order = orderInfoMPDao.getByOrderId(orderId);
OrderInfoEntity order = orderInfoDao.getByOrderId(orderId);
if (order == null) {
throw new BusinessException("订单不存在");
}
EngineerInfo engineer = engineerInfoMPDao.getByEngineerCode(engineerCode);
EngineerInfoEntity engineer = engineerInfoDao.getByEngineerCode(engineerCode);
boolean record = false;
OrderInfo op = orderInfoMPDao.getByOrderIdAndDt(orderId, order.getDt());
OrderInfoEntity op = orderInfoDao.getByOrderIdAndDt(orderId, order.getDt());
if (op != null) {
record = true;
}
......@@ -151,13 +155,12 @@ public class OrderAssignImpl implements OrderAssign {
Timestamp planEndTime = Timestamp.valueOf(insertNode.getPlanEndTime());
// 更新order_info表状态
LambdaUpdateWrapper<OrderInfo> wrapper = new LambdaUpdateWrapper<>();
wrapper.set(OrderInfo::getAppointmentStatus, "CONFIRM");
wrapper.set(OrderInfo::getAppointmentMethod, "MANUAL");
wrapper.set(OrderInfo::getPlanStartTime, planStartTime);
wrapper.set(OrderInfo::getPlanEndTime, planEndTime);
wrapper.eq(OrderInfo::getOrderId, orderId);
orderInfoMPDao.update(null, wrapper);
String sql = "UPDATE OrderInfo e SET e.appointmentStatus = 'CONFIRM', e.appointmentMethod='MANUAL', e.planStartTime = :planStartTime, e.planEndTime = :panEndTime WHERE e.orderId = :orderId";
Query query = entityManager.createQuery(sql);
query.setParameter("planStartTime", planStartTime);
query.setParameter("planEndTime", planEndTime);
query.setParameter("orderId", orderId);
query.executeUpdate();
// 工单变更登记
commonService.addOrderEvent(orderId, "", "PEA-WEB", "API", "工单指派", "工单指派", "");
......@@ -169,28 +172,18 @@ public class OrderAssignImpl implements OrderAssign {
public Result<?> orderRevokeAssign(String orderId) throws BusinessException {
// 放回工单池
OrderInfo order = orderInfoMPDao.getByOrderId(orderId);
OrderInfoEntity order = orderInfoDao.getByOrderId(orderId);
if (order == null) {
throw new BusinessException("订单不存在");
}
// 更新order_request表为未指派
order.setAppointmentStatus("INIT");
orderInfoMPDao.updateById(order);
entityManager.merge(order);
// 操作员ID TODO-用户系统
// 登记事件
OrderEvent oe = new OrderEvent();
oe.setOrderId(orderId);
oe.setSuborderId("");
oe.setHappen(new Timestamp(System.currentTimeMillis()));
oe.setEvent("放回工单池");
oe.setOperator("123"); // 操作员ID TODO-用户系统
oe.setOperatorName("测试用户"); // 操作员姓名 TODO-用户系统
oe.setSource("PEA");
oe.setDescription("返回工单池");
oe.setMemo("");
oe.setCreateTime(new Timestamp(System.currentTimeMillis()));
orderEventMPDao.insert(oe);
commonService.addOrderEvent(orderId, "", "PEA-WEB", "123", "放回工单池", "放回工单池", "");
return Result.success(null);
}
......@@ -199,7 +192,7 @@ public class OrderAssignImpl implements OrderAssign {
public Result<?> orderReschedule(String orderId, LocalDateTime expectBegin, LocalDateTime expectEnd, String expectDesc) throws BusinessException {
// 工单改约接口(当前同放回工单池处理)
OrderInfo order = orderInfoMPDao.getByOrderId(orderId);
OrderInfoEntity order = orderInfoDao.getByOrderId(orderId);
if (order == null) {
throw new BusinessException("订单不存在");
}
......@@ -212,32 +205,24 @@ public class OrderAssignImpl implements OrderAssign {
LocalDate originDate = order.getDt(); // 改约前的日期
// 更新order_request表为未指派
order.setAppointmentStatus("INIT");
order.setDt(expectBegin.toLocalDate());
order.setExpectTimeBegin(Timestamp.valueOf(expectBegin));
order.setExpectTimeEnd(Timestamp.valueOf(expectEnd));
order.setExpectTimeDesc(expectDesc);
orderInfoMPDao.updateById(order);
// 更新order_info表
String sql = "UPDATE OrderInfo e SET e.appointmentStatus = 'INIT', e.dt=:dt, e.expectTimeBegin = :expectTimeBegin, e.expectTimeEnd = :expectTimeEnd, e.expectTimeDesc = :expectTimeDesc WHERE e.orderId = :orderId";
Query query = entityManager.createQuery(sql);
query.setParameter("dt", expectBegin.toLocalDate());
query.setParameter("expectTimeBegin", expectBegin);
query.setParameter("expectTimeEnd", expectEnd);
query.setParameter("expectTimeDesc", expectDesc);
query.setParameter("orderId", orderId);
query.executeUpdate();
// 操作员ID TODO-用户系统
// 登记事件
OrderEvent oe = new OrderEvent();
oe.setOrderId(orderId);
oe.setSuborderId("");
oe.setHappen(new Timestamp(System.currentTimeMillis()));
oe.setEvent("已改约");
oe.setOperator("123"); // 操作员ID TODO-用户系统
oe.setOperatorName("测试用户"); // 操作员姓名 TODO-用户系统
oe.setSource("PEA");
oe.setDescription("已改约");
oe.setMemo("");
oe.setCreateTime(new Timestamp(System.currentTimeMillis()));
orderEventMPDao.insert(oe);
commonService.addOrderEvent(orderId, "", "PEA-WEB", "123", "已改约", "已改约", "");
return Result.success(null);
}
private List<String> searchEngineerCodes(OrderInfo order, String distance, String key, String recommend) {
private List<String> searchEngineerCodes(OrderInfoEntity order, String distance, String key, String recommend) {
Set<String> engineerCodes1 = this.searchEngineerByRecommend(order, recommend);
if (engineerCodes1.isEmpty()) {
log.info("recommend:{}筛选条件未找到技术员", recommend);
......@@ -257,13 +242,13 @@ public class OrderAssignImpl implements OrderAssign {
}
}
// 匹配技能
SkillInfo skill = skillInfoMPDao.getByBrandAndTypeAndSkill(order.getBrand(), order.getType(), order.getSkill());
SkillInfoEntity skill = skillInfoDao.getByBrandAndTypeAndSkill(order.getBrand(), order.getType(), order.getSkill());
if (skill == null) {
log.info("skill_info表没有匹配到技能配置:{}-{}-{}", order.getBrand(), order.getY(), order.getSkill());
return new ArrayList<>();
}
Set<String> engineerCodes3 = engineerSkillGroupMPDao.selectBySkillGroupCode(skill.getSkillGroupCode()).stream().map(
EngineerSkillGroup::getEngineerCode).collect(Collectors.toSet());
Set<String> engineerCodes3 = engineerSkillGroupDao.findBySkillGroupCode(skill.getSkillGroupCode()).stream().map(
EngineerSkillGroupEntity::getEngineerCode).collect(Collectors.toSet());
if (engineerCodes3.isEmpty()) {
log.info("没有匹配到技能相匹配的技术员:{}-{}-{}", order.getBrand(), order.getType(), order.getSkill());
return new ArrayList<>();
......@@ -284,9 +269,10 @@ public class OrderAssignImpl implements OrderAssign {
return new ArrayList<>(engineerCodes1);
}
private Set<String> searchEngineerByRecommend(OrderInfo order, String recommend) {
private Set<String> searchEngineerByRecommend(OrderInfoEntity order, String recommend) {
if (StringUtils.isNotEmpty(recommend) && recommend.equals("team")) {
return orgTeamEngineerMPDao.selectByTeamId(order.getOrgTeamId()).stream().map(OrgTeamEngineer::getEngineerCode).collect(Collectors.toSet());
return orgTeamEngineerDao.findAllByTeamId(order.getOrgTeamId()).stream().map(
OrgTeamEngineerEntity::getEngineerCode).collect(Collectors.toSet());
}
String levelType;
String levelValue;
......@@ -299,41 +285,53 @@ public class OrderAssignImpl implements OrderAssign {
} else {
return new HashSet<>();
}
LambdaQueryWrapper<OrgTeam> lqw = new LambdaQueryWrapper<>();
lqw.eq(levelType.equals("cluster"), OrgTeam::getClusterId, levelValue);
lqw.eq(levelType.equals("branch"), OrgTeam::getBranchId, levelValue);
lqw.eq(levelType.equals("group"), OrgTeam::getGroupId, levelValue);
lqw.eq(levelType.equals("team"), OrgTeam::getTeamId, levelValue);
List<String> groupIds = orgTeamMPDao.selectList(lqw).stream().map(OrgTeam::getGroupId).collect(Collectors.toList());
return engineerInfoMPDao.selectByGroupIds(groupIds).stream().map(EngineerInfo::getEngineerCode).collect(Collectors.toSet());
List<OrgTeamEntity> teams = new ArrayList<>();
if(levelType.equals("cluster")){
teams = orgTeamDao.findAllByClusterId(levelValue);
} else if (levelType.equals("branch")){
teams = orgTeamDao.findAllByBranchId(levelValue);
} else if (levelType.equals("group")){
teams = orgTeamDao.findAllByGroupId(levelValue);
} else if (levelType.equals("team")){
teams = orgTeamDao.findAllByTeamId(levelValue);
}
List<String> groupIds = teams.stream().map(OrgTeamEntity::getGroupId).collect(Collectors.toList());
return engineerInfoDao.findByGroupIdIn(groupIds).stream().map(EngineerInfoEntity::getEngineerCode).collect(Collectors.toSet());
}
private Set<String> searchEngineerByKey(String key) {
LambdaQueryWrapper<EngineerInfo> lqw = new LambdaQueryWrapper<>();
lqw.eq(EngineerInfo::getBeanStatus, 1);
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<EngineerInfoEntity> criteriaQuery = criteriaBuilder.createQuery(EngineerInfoEntity.class);
Root<EngineerInfoEntity> root = criteriaQuery.from(EngineerInfoEntity.class);
Predicate predicate = criteriaBuilder.equal(root.get("beanStatus"), 1);
if (StringUtils.isNotEmpty(key)) {
lqw.and(w ->
w.like(EngineerInfo::getPhone, key)
.or()
.like(EngineerInfo::getName, key)
.or()
.like(EngineerInfo::getEngineerCode, key)
Predicate keyPredicate = criteriaBuilder.or(
criteriaBuilder.like(root.get("phone"), "%" + key + "%"),
criteriaBuilder.like(root.get("name"), "%" + key + "%"),
criteriaBuilder.like(root.get("engineerCode"), "%" + key + "%")
);
predicate = criteriaBuilder.and(predicate, keyPredicate);
}
return engineerInfoMPDao.selectList(lqw).stream().map(EngineerInfo::getEngineerCode).collect(Collectors.toSet());
criteriaQuery.where(predicate);
CriteriaQuery<EngineerInfoEntity> selectQuery = criteriaQuery.select(root);
return entityManager.createQuery(selectQuery).getResultList().stream().map(
EngineerInfoEntity::getEngineerCode).collect(Collectors.toSet());
}
private List<TimeLineDTO> packTimelines(List<OrderInfo> orders, HashMap<String, List<LabelValueDTO>> orderTips) {
private List<TimeLineDTO> packTimelines(List<OrderInfoEntity> orders, HashMap<String, List<LabelValueDTO>> orderTips) {
List<LabelValueDTO> empty = new ArrayList<>();
List<TimeLineDTO> items = new ArrayList<>();
for (OrderInfo order : orders) {
for (OrderInfoEntity order : orders) {
TimeLineDTO item = new TimeLineDTO();
item.setOrderId(order.getOrderId());
item.setAppointmentStatus(order.getAppointmentStatus());
item.setStartTime(TimeUtils.IsoTimestamp2DateTime(order.getPlanStartTime()));
item.setEndTime(TimeUtils.IsoTimestamp2DateTime(order.getPlanEndTime()));
item.setStartTime(TimeUtils.IsoLocalDateTime2String(order.getPlanStartTime()));
item.setEndTime(TimeUtils.IsoLocalDateTime2String(order.getPlanEndTime()));
item.setTips(orderTips.getOrDefault(order.getOrderId(), empty));
items.add(item);
......@@ -341,12 +339,12 @@ public class OrderAssignImpl implements OrderAssign {
return items;
}
private HashMap<String, List<LabelValueDTO>> packOrderTips(List<OrderInfo> orders) {
private HashMap<String, List<LabelValueDTO>> packOrderTips(List<OrderInfoEntity> orders) {
return orders.stream().collect(Collectors.toMap(
OrderInfo::getOrderId, this::packOrderTip, (l1, l2) -> l1, HashMap::new));
OrderInfoEntity::getOrderId, this::packOrderTip, (l1, l2) -> l1, HashMap::new));
}
private List<LabelValueDTO> packOrderTip(OrderInfo order) {
private List<LabelValueDTO> packOrderTip(OrderInfoEntity order) {
// pack订单tips
List<LabelValueDTO> items = new ArrayList<>();
items.add(new LabelValueDTO("类型/品牌", String.format("%s %s %s", order.getSkill(), order.getType(), order.getBrand())));
......
project-order/src/main/java/com/dituhui/pea/order/service/impl/SkillGroupCategoryServiceImpl.java
package com.dituhui.pea.order.service.impl;
import com.dituhui.pea.common.Result;
import com.dituhui.pea.order.dao.SkillGroupMPDao;
import com.dituhui.pea.order.entity.SkillGroup;
import com.dituhui.pea.order.dao.SkillGroupDao;
import com.dituhui.pea.order.entity.SkillGroupEntity;
import com.dituhui.pea.order.service.SkillGroupCategoryService;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
......@@ -17,15 +17,15 @@ import java.util.stream.Collectors;
public class SkillGroupCategoryServiceImpl implements SkillGroupCategoryService {
@Autowired
SkillGroupMPDao skillGroupMPDao;
SkillGroupDao skillGroupDao;
@Override
public Result<?> querySkillGroupCategoryService() {
List<SkillGroup> records = skillGroupMPDao.selectList(null).stream().sorted(
Comparator.comparing(SkillGroup::getCategory)).collect(Collectors.toList());
List<SkillGroupEntity> records = skillGroupDao.findAll().stream().sorted(
Comparator.comparing(SkillGroupEntity::getCategory)).collect(Collectors.toList());
List<Category> items = new ArrayList<>();
for (SkillGroup r : records) {
for (SkillGroupEntity r : records) {
items.add(new Category(r.getSkillGroupCode(), r.getSkillGroup(), r.getCategory()));
}
Response res = new Response();
......
project-order/src/main/java/com/dituhui/pea/order/service/impl/WorkbenchServiceImpl.java
package com.dituhui.pea.order.service.impl;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dituhui.pea.common.Result;
import com.dituhui.pea.order.dao.*;
import com.dituhui.pea.order.dao.OrderEventDao;
import com.dituhui.pea.order.dao.OrderInfoDao;
import com.dituhui.pea.order.dto.OrderChangeListDTO;
import com.dituhui.pea.order.dto.WorkbenchSummaryResp;
import com.dituhui.pea.order.entity.OrderEventEntity;
import com.dituhui.pea.order.entity.OrderInfoEntity;
import com.dituhui.pea.order.entity.OrderInfo;
import com.dituhui.pea.order.entity.OrderInfoEntity;
import com.dituhui.pea.order.service.WorkbenchService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
......@@ -17,8 +17,15 @@ import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
@Slf4j
@Service
......@@ -28,10 +35,10 @@ public class WorkbenchServiceImpl implements WorkbenchService {
private OrderEventDao orderEventDao;
@Autowired
private OrderInfoMPDao orderInfoMPDao;
private OrderInfoDao orderInfoDao;
@Autowired
private OrderInfoDao orderInfoDao;
private EntityManager entityManager;
@Override
public Result<?> getOrderChangeList(OrderChangeListDTO.Request reqDTO) {
......@@ -89,27 +96,95 @@ public class WorkbenchServiceImpl implements WorkbenchService {
}
private List<Map<String, Object>> queryCountByAppointmentMethod(String levelType, String levelValue, LocalDate dt) {
QueryWrapper<OrderInfo> wrapper = new QueryWrapper<>();
wrapper.select("appointment_method, appointment_status, COUNT(*) as count")
.lambda()
.eq(OrderInfo::getDt, dt)
.eq(levelType.equals("cluster"), OrderInfo::getOrgClusterId, levelValue)
.eq(levelType.equals("branch"), OrderInfo::getOrgBranchId, levelValue)
.eq(levelType.equals("group"), OrderInfo::getOrgGroupId, levelValue)
.groupBy(OrderInfo::getAppointmentMethod, OrderInfo::getAppointmentStatus);
return orderInfoMPDao.selectMaps(wrapper);
}
private List<Map<String, Object>> queryCountByOrderStatus(String levelType, String levelValue, LocalDate dt) {
QueryWrapper<OrderInfo> wrapper = new QueryWrapper<>();
wrapper.select("service_status, COUNT(*) as count")
.lambda()
.eq(OrderInfo::getDt, dt)
.eq(levelType.equals("cluster"), OrderInfo::getOrgClusterId, levelValue)
.eq(levelType.equals("branch"), OrderInfo::getOrgBranchId, levelValue)
.eq(levelType.equals("group"), OrderInfo::getOrgGroupId, levelValue)
.groupBy(OrderInfo::getServiceStatus);
return orderInfoMPDao.selectMaps(wrapper);
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<Object[]> criteriaQuery = criteriaBuilder.createQuery(Object[].class);
Root<OrderInfo> root = criteriaQuery.from(OrderInfo.class);
criteriaQuery.multiselect(
root.get("appointmentMethod"),
root.get("appointmentStatus"),
criteriaBuilder.count(root).alias("count")
);
Predicate datePredicate = criteriaBuilder.equal(root.get("dt"), dt);
Predicate levelPredicate = null;
if ("cluster".equals(levelType)) {
levelPredicate = criteriaBuilder.equal(root.get("orgClusterId"), levelValue);
} else if ("branch".equals(levelType)) {
levelPredicate = criteriaBuilder.equal(root.get("orgBranchId"), levelValue);
} else if ("group".equals(levelType)) {
levelPredicate = criteriaBuilder.equal(root.get("orgGroupId"), levelValue);
}
if (levelPredicate != null) {
criteriaQuery.where(datePredicate, levelPredicate);
} else {
criteriaQuery.where(datePredicate);
}
criteriaQuery.groupBy(root.get("appointmentMethod"), root.get("appointmentStatus"));
TypedQuery<Object[]> typedQuery = entityManager.createQuery(criteriaQuery);
List<Object[]> results = typedQuery.getResultList();
List<Map<String, Object>> mappedResults = results.stream()
.map(result -> {
Map<String, Object> map = Map.of(
"appointmentMethod", result[0],
"appointmentStatus", result[1],
"count", result[2]
);
return map;
})
.collect(Collectors.toList());
return mappedResults;
}
public List<Map<String, Object>> queryCountByOrderStatus(String levelType, String levelValue, LocalDate dt) {
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<Object[]> criteriaQuery = criteriaBuilder.createQuery(Object[].class);
Root<OrderInfo> root = criteriaQuery.from(OrderInfo.class);
criteriaQuery.multiselect(
root.get("serviceStatus"),
criteriaBuilder.count(root).alias("count")
);
Predicate datePredicate = criteriaBuilder.equal(root.get("dt"), dt);
Predicate levelPredicate = null;
if ("cluster".equals(levelType)) {
levelPredicate = criteriaBuilder.equal(root.get("orgClusterId"), levelValue);
} else if ("branch".equals(levelType)) {
levelPredicate = criteriaBuilder.equal(root.get("orgBranchId"), levelValue);
} else if ("group".equals(levelType)) {
levelPredicate = criteriaBuilder.equal(root.get("orgGroupId"), levelValue);
}
if (levelPredicate != null) {
criteriaQuery.where(datePredicate, levelPredicate);
} else {
criteriaQuery.where(datePredicate);
}
criteriaQuery.groupBy(root.get("serviceStatus"));
TypedQuery<Object[]> typedQuery = entityManager.createQuery(criteriaQuery);
List<Object[]> results = typedQuery.getResultList();
List<Map<String, Object>> mappedResults = results.stream()
.map(result -> {
Map<String, Object> map = Map.of(
"serviceStatus", result[0],
"count", result[1]
);
return map;
})
.collect(Collectors.toList());
return mappedResults;
}
private HashMap<String, Long> transAppointmentMethod(List<Map<String, Object>> results) {
......@@ -211,12 +286,10 @@ public class WorkbenchServiceImpl implements WorkbenchService {
return items;
}
private <T> HashMap<String, List<T>> packParams(String key, T ...values) {
private <T> HashMap<String, List<T>> packParams(String key, T... values) {
HashMap<String, List<T>> map = new HashMap<>();
List<T> value = new ArrayList<>();
for(T v: values){
value.add(v);
}
Collections.addAll(value, values);
map.put(key, value);
return map;
}
......
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!