package com.doumee.service.business.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.doumee.core.exception.BusinessException;
|
import com.doumee.core.model.LoginUserInfo;
|
import com.doumee.core.utils.Constants;
|
import com.doumee.core.utils.Utils;
|
import com.doumee.dao.business.*;
|
import com.doumee.dao.business.dto.YwCustomerGsConfigDTO;
|
import com.doumee.dao.business.model.*;
|
import com.doumee.service.business.YwCustomerDeviceAutoBindService;
|
import com.doumee.service.business.YwCustomerRechargeBizService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import java.math.BigDecimal;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Service
|
@Slf4j
|
public class YwCustomerDeviceAutoBindServiceImpl implements YwCustomerDeviceAutoBindService {
|
|
private static final int BIND_SOURCE_CONTRACT = 1;
|
|
@Autowired
|
private YwContractMapper ywContractMapper;
|
@Autowired
|
private YwContractRoomMapper ywContractRoomMapper;
|
@Autowired
|
private YwElectricalRoomMapper ywElectricalRoomMapper;
|
@Autowired
|
private YwCustomerElectricalMapper ywCustomerElectricalMapper;
|
@Autowired
|
private YwCustomerConditionerMapper ywCustomerConditionerMapper;
|
@Autowired
|
private YwConditionerMapper ywConditionerMapper;
|
@Autowired
|
@Lazy
|
private YwCustomerRechargeBizService ywCustomerRechargeBizService;
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void syncByContractId(Integer contractId, LoginUserInfo user) {
|
if (contractId == null) {
|
return;
|
}
|
YwContract contract = ywContractMapper.selectById(contractId);
|
if (contract == null || Objects.equals(contract.getIsdeleted(), Constants.ONE) || contract.getRenterId() == null) {
|
return;
|
}
|
refreshCustomerDevices(contract.getRenterId(), user);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void syncByCustomerId(Integer customerId, LoginUserInfo user) {
|
refreshCustomerDevices(customerId, user);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void refreshCustomerDevices(Integer customerId, LoginUserInfo user) {
|
if (customerId == null) {
|
return;
|
}
|
LoginUserInfo opUser = user != null ? user : systemUser();
|
List<YwContract> contracts = ywContractMapper.selectList(new QueryWrapper<YwContract>().lambda()
|
.eq(YwContract::getRenterId, customerId)
|
.eq(YwContract::getIsdeleted, Constants.ZERO));
|
List<YwContract> activeContracts = contracts.stream().filter(this::isActiveContract).collect(Collectors.toList());
|
Set<Integer> activeContractIds = activeContracts.stream().map(YwContract::getId).collect(Collectors.toSet());
|
|
for (YwContract contract : contracts) {
|
if (!activeContractIds.contains(contract.getId())) {
|
unbindByContractId(contract.getId(), opUser);
|
}
|
}
|
|
Set<Integer> roomIds = new LinkedHashSet<>();
|
for (YwContract contract : activeContracts) {
|
roomIds.addAll(listContractRoomIds(contract.getId()));
|
}
|
if (roomIds.isEmpty()) {
|
clearContractElectricalBindings(customerId, opUser);
|
softDeleteAllConditionerRels(customerId, opUser);
|
return;
|
}
|
|
List<Integer> roomIdList = new ArrayList<>(roomIds);
|
for (YwContract contract : activeContracts) {
|
bindElectricals(contract, listContractRoomIds(contract.getId()), opUser);
|
}
|
bindConditionersMerged(customerId, roomIdList, opUser);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void unbindByContractId(Integer contractId, LoginUserInfo user) {
|
if (contractId == null) {
|
return;
|
}
|
Date now = new Date();
|
Integer editor = user != null ? user.getId() : null;
|
ywCustomerElectricalMapper.update(null, new UpdateWrapper<YwCustomerElectrical>().lambda()
|
.set(YwCustomerElectrical::getIsdeleted, Constants.ONE)
|
.set(YwCustomerElectrical::getEditDate, now)
|
.set(YwCustomerElectrical::getEditor, editor)
|
.eq(YwCustomerElectrical::getContractId, contractId)
|
.eq(YwCustomerElectrical::getBindSource, BIND_SOURCE_CONTRACT)
|
.eq(YwCustomerElectrical::getIsdeleted, Constants.ZERO));
|
}
|
|
@Override
|
public List<Integer> listActiveContractRoomIds(Integer customerId) {
|
if (customerId == null) {
|
return Collections.emptyList();
|
}
|
List<YwContract> active = listActiveContracts(customerId);
|
Set<Integer> roomIds = new LinkedHashSet<>();
|
for (YwContract contract : active) {
|
roomIds.addAll(listContractRoomIds(contract.getId()));
|
}
|
return new ArrayList<>(roomIds);
|
}
|
|
@Override
|
public List<Integer> listElectricalIdsByActiveContracts(Integer customerId) {
|
List<Integer> roomIds = listActiveContractRoomIds(customerId);
|
if (roomIds.isEmpty()) {
|
return Collections.emptyList();
|
}
|
return new ArrayList<>(resolveElectricalIdsFromRooms(roomIds));
|
}
|
|
@Override
|
public List<Integer> listConditionerIdsByActiveContracts(Integer customerId) {
|
List<Integer> roomIds = listActiveContractRoomIds(customerId);
|
if (roomIds.isEmpty()) {
|
return Collections.emptyList();
|
}
|
return new ArrayList<>(resolveConditionerIdsFromRooms(roomIds));
|
}
|
|
@Override
|
public Map<Integer, List<Integer>> batchListElectricalIdsByActiveContracts(List<Integer> customerIds) {
|
return batchResolveDeviceIds(customerIds, Constants.ZERO);
|
}
|
|
@Override
|
public Map<Integer, List<Integer>> batchListConditionerIdsByActiveContracts(List<Integer> customerIds) {
|
return batchResolveDeviceIds(customerIds, Constants.ONE);
|
}
|
|
private Map<Integer, List<Integer>> batchResolveDeviceIds(List<Integer> customerIds, int deviceType) {
|
if (CollectionUtils.isEmpty(customerIds)) {
|
return Collections.emptyMap();
|
}
|
Map<Integer, Set<Integer>> roomsByCustomer = batchActiveContractRoomIds(customerIds);
|
Set<Integer> allRoomIds = roomsByCustomer.values().stream()
|
.flatMap(Set::stream).collect(Collectors.toCollection(LinkedHashSet::new));
|
Map<Integer, Set<Integer>> devicesByRoom = mapDevicesByRoom(allRoomIds, deviceType);
|
|
Map<Integer, List<Integer>> result = new LinkedHashMap<>();
|
for (Integer customerId : customerIds) {
|
Set<Integer> roomIds = roomsByCustomer.getOrDefault(customerId, Collections.emptySet());
|
Set<Integer> deviceIds = new LinkedHashSet<>();
|
for (Integer roomId : roomIds) {
|
deviceIds.addAll(devicesByRoom.getOrDefault(roomId, Collections.emptySet()));
|
}
|
result.put(customerId, new ArrayList<>(deviceIds));
|
}
|
return result;
|
}
|
|
private Map<Integer, Set<Integer>> batchActiveContractRoomIds(List<Integer> customerIds) {
|
List<YwContract> contracts = ywContractMapper.selectList(new QueryWrapper<YwContract>().lambda()
|
.in(YwContract::getRenterId, customerIds)
|
.eq(YwContract::getIsdeleted, Constants.ZERO));
|
Map<Integer, List<YwContract>> activeByCustomer = contracts.stream()
|
.filter(this::isActiveContract)
|
.collect(Collectors.groupingBy(YwContract::getRenterId));
|
|
List<Integer> contractIds = activeByCustomer.values().stream()
|
.flatMap(List::stream).map(YwContract::getId).distinct().collect(Collectors.toList());
|
Map<Integer, List<Integer>> roomsByContract = loadContractRoomMap(contractIds);
|
|
Map<Integer, Set<Integer>> roomsByCustomer = new LinkedHashMap<>();
|
for (Integer customerId : customerIds) {
|
Set<Integer> roomIds = new LinkedHashSet<>();
|
for (YwContract contract : activeByCustomer.getOrDefault(customerId, Collections.emptyList())) {
|
roomIds.addAll(roomsByContract.getOrDefault(contract.getId(), Collections.emptyList()));
|
}
|
roomsByCustomer.put(customerId, roomIds);
|
}
|
return roomsByCustomer;
|
}
|
|
private Map<Integer, List<Integer>> loadContractRoomMap(List<Integer> contractIds) {
|
if (CollectionUtils.isEmpty(contractIds)) {
|
return Collections.emptyMap();
|
}
|
return ywContractRoomMapper.selectList(new QueryWrapper<YwContractRoom>().lambda()
|
.in(YwContractRoom::getContractId, contractIds)
|
.eq(YwContractRoom::getType, Constants.ZERO)
|
.eq(YwContractRoom::getIsdeleted, Constants.ZERO))
|
.stream()
|
.collect(Collectors.groupingBy(YwContractRoom::getContractId,
|
Collectors.mapping(YwContractRoom::getRoomId,
|
Collectors.collectingAndThen(Collectors.toList(),
|
list -> list.stream().filter(Objects::nonNull).distinct().collect(Collectors.toList())))));
|
}
|
|
private Map<Integer, Set<Integer>> mapDevicesByRoom(Set<Integer> roomIds, int deviceType) {
|
if (CollectionUtils.isEmpty(roomIds)) {
|
return Collections.emptyMap();
|
}
|
List<Integer> roomIdList = new ArrayList<>(roomIds);
|
Map<Integer, Set<Integer>> result = new HashMap<>();
|
List<YwElectricalRoom> relRooms = ywElectricalRoomMapper.selectList(new QueryWrapper<YwElectricalRoom>().lambda()
|
.in(YwElectricalRoom::getRoomId, roomIdList)
|
.eq(YwElectricalRoom::getType, deviceType)
|
.eq(YwElectricalRoom::getIsdeleted, Constants.ZERO));
|
for (YwElectricalRoom rel : relRooms) {
|
if (rel.getRoomId() == null || rel.getObjId() == null) {
|
continue;
|
}
|
result.computeIfAbsent(rel.getRoomId(), k -> new LinkedHashSet<>()).add(rel.getObjId());
|
}
|
if (deviceType == Constants.ONE) {
|
List<YwConditioner> byRoom = ywConditionerMapper.selectList(new QueryWrapper<YwConditioner>().lambda()
|
.in(YwConditioner::getRoomId, roomIdList)
|
.eq(YwConditioner::getIsdeleted, Constants.ZERO));
|
for (YwConditioner conditioner : byRoom) {
|
if (conditioner.getRoomId() == null || conditioner.getId() == null) {
|
continue;
|
}
|
result.computeIfAbsent(conditioner.getRoomId(), k -> new LinkedHashSet<>()).add(conditioner.getId());
|
}
|
}
|
return result;
|
}
|
|
private List<YwContract> listActiveContracts(Integer customerId) {
|
return ywContractMapper.selectList(new QueryWrapper<YwContract>().lambda()
|
.eq(YwContract::getRenterId, customerId)
|
.eq(YwContract::getIsdeleted, Constants.ZERO))
|
.stream().filter(this::isActiveContract).collect(Collectors.toList());
|
}
|
|
private boolean isActiveContract(YwContract contract) {
|
if (contract == null || contract.getStartDate() == null || contract.getEndDate() == null) {
|
return false;
|
}
|
if (Objects.equals(contract.getStatus(), Constants.FOUR)) {
|
return false;
|
}
|
long now = System.currentTimeMillis();
|
return contract.getStartDate().getTime() <= now
|
&& Utils.Date.getEnd(contract.getEndDate()).getTime() >= now;
|
}
|
|
private List<Integer> listContractRoomIds(Integer contractId) {
|
return ywContractRoomMapper.selectList(new QueryWrapper<YwContractRoom>().lambda()
|
.eq(YwContractRoom::getContractId, contractId)
|
.eq(YwContractRoom::getType, Constants.ZERO)
|
.eq(YwContractRoom::getIsdeleted, Constants.ZERO))
|
.stream().map(YwContractRoom::getRoomId).filter(Objects::nonNull).distinct()
|
.collect(Collectors.toList());
|
}
|
|
private Set<Integer> resolveElectricalIdsFromRooms(List<Integer> roomIds) {
|
if (CollectionUtils.isEmpty(roomIds)) {
|
return Collections.emptySet();
|
}
|
return ywElectricalRoomMapper.selectList(new QueryWrapper<YwElectricalRoom>().lambda()
|
.in(YwElectricalRoom::getRoomId, roomIds)
|
.eq(YwElectricalRoom::getType, Constants.ZERO)
|
.eq(YwElectricalRoom::getIsdeleted, Constants.ZERO))
|
.stream().map(YwElectricalRoom::getObjId).filter(Objects::nonNull)
|
.collect(Collectors.toCollection(LinkedHashSet::new));
|
}
|
|
private Set<Integer> resolveConditionerIdsFromRooms(List<Integer> roomIds) {
|
if (CollectionUtils.isEmpty(roomIds)) {
|
return Collections.emptySet();
|
}
|
Set<Integer> conditionerIds = new LinkedHashSet<>();
|
List<YwElectricalRoom> acRooms = ywElectricalRoomMapper.selectList(new QueryWrapper<YwElectricalRoom>().lambda()
|
.in(YwElectricalRoom::getRoomId, roomIds)
|
.eq(YwElectricalRoom::getType, Constants.ONE)
|
.eq(YwElectricalRoom::getIsdeleted, Constants.ZERO));
|
acRooms.stream().map(YwElectricalRoom::getObjId).filter(Objects::nonNull).forEach(conditionerIds::add);
|
if (conditionerIds.isEmpty()) {
|
ywConditionerMapper.selectList(new QueryWrapper<YwConditioner>().lambda()
|
.in(YwConditioner::getRoomId, roomIds)
|
.eq(YwConditioner::getIsdeleted, Constants.ZERO))
|
.stream().map(YwConditioner::getId).filter(Objects::nonNull).forEach(conditionerIds::add);
|
}
|
return conditionerIds;
|
}
|
|
private void bindElectricals(YwContract contract, List<Integer> roomIds, LoginUserInfo user) {
|
Set<Integer> electricalIds = resolveElectricalIdsFromRooms(roomIds);
|
if (electricalIds.isEmpty()) {
|
return;
|
}
|
Set<Integer> boundOthers = listBoundElectricalIdsExcept(contract.getRenterId());
|
Date now = new Date();
|
for (Integer eid : electricalIds) {
|
if (boundOthers.contains(eid)) {
|
log.warn("skip electrical {} already bound to other customer", eid);
|
continue;
|
}
|
YwCustomerElectrical exist = ywCustomerElectricalMapper.selectOne(new QueryWrapper<YwCustomerElectrical>().lambda()
|
.eq(YwCustomerElectrical::getCustomerId, contract.getRenterId())
|
.eq(YwCustomerElectrical::getElectricalId, eid)
|
.eq(YwCustomerElectrical::getIsdeleted, Constants.ZERO)
|
.last("limit 1"));
|
if (exist != null) {
|
if (!Objects.equals(exist.getContractId(), contract.getId())
|
|| !Objects.equals(exist.getBindSource(), BIND_SOURCE_CONTRACT)) {
|
exist.setContractId(contract.getId());
|
exist.setBindSource(BIND_SOURCE_CONTRACT);
|
exist.setEditDate(now);
|
exist.setEditor(user != null ? user.getId() : null);
|
ywCustomerElectricalMapper.updateById(exist);
|
}
|
continue;
|
}
|
YwCustomerElectrical rel = new YwCustomerElectrical();
|
rel.setCreator(user != null ? user.getId() : null);
|
rel.setCreateDate(now);
|
rel.setEditor(user != null ? user.getId() : null);
|
rel.setEditDate(now);
|
rel.setIsdeleted(Constants.ZERO);
|
rel.setCustomerId(contract.getRenterId());
|
rel.setElectricalId(eid);
|
rel.setBindSource(BIND_SOURCE_CONTRACT);
|
rel.setContractId(contract.getId());
|
ywCustomerElectricalMapper.insert(rel);
|
}
|
}
|
|
private void bindConditionersMerged(Integer customerId, List<Integer> roomIds, LoginUserInfo user) {
|
Set<Integer> conditionerIds = resolveConditionerIdsFromRooms(roomIds);
|
if (conditionerIds.isEmpty()) {
|
softDeleteAllConditionerRels(customerId, user);
|
return;
|
}
|
YwCustomerGsConfigDTO dto = new YwCustomerGsConfigDTO();
|
dto.setCustomerId(customerId);
|
dto.setIsPwr(Constants.ONE);
|
dto.setIsRestStop(Constants.ZERO);
|
dto.setGsBz("合同自动关联");
|
dto.setStopMoney(BigDecimal.ZERO);
|
List<YwCustomerGsConfigDTO.ConditionerItem> items = new ArrayList<>();
|
for (Integer cid : conditionerIds) {
|
YwCustomerGsConfigDTO.ConditionerItem item = new YwCustomerGsConfigDTO.ConditionerItem();
|
item.setConditionerId(cid);
|
item.setDevRatio(100);
|
items.add(item);
|
}
|
dto.setConditioners(items);
|
try {
|
ywCustomerRechargeBizService.saveCustomerGsConfig(dto, user);
|
} catch (BusinessException e) {
|
log.warn("auto bind conditioner GS failed customerId={}: {}", customerId, e.getMessage());
|
}
|
}
|
|
private void clearContractElectricalBindings(Integer customerId, LoginUserInfo user) {
|
Date now = new Date();
|
ywCustomerElectricalMapper.update(null, new UpdateWrapper<YwCustomerElectrical>().lambda()
|
.set(YwCustomerElectrical::getIsdeleted, Constants.ONE)
|
.set(YwCustomerElectrical::getEditDate, now)
|
.set(YwCustomerElectrical::getEditor, user != null ? user.getId() : null)
|
.eq(YwCustomerElectrical::getCustomerId, customerId)
|
.eq(YwCustomerElectrical::getBindSource, BIND_SOURCE_CONTRACT)
|
.eq(YwCustomerElectrical::getIsdeleted, Constants.ZERO));
|
}
|
|
private void softDeleteAllConditionerRels(Integer customerId, LoginUserInfo user) {
|
Date now = new Date();
|
ywCustomerConditionerMapper.update(null, new UpdateWrapper<YwCustomerConditioner>().lambda()
|
.set(YwCustomerConditioner::getIsdeleted, Constants.ONE)
|
.set(YwCustomerConditioner::getEditDate, now)
|
.set(YwCustomerConditioner::getEditor, user != null ? user.getId() : null)
|
.eq(YwCustomerConditioner::getCustomerId, customerId)
|
.eq(YwCustomerConditioner::getIsdeleted, Constants.ZERO));
|
}
|
|
private Set<Integer> listBoundElectricalIdsExcept(Integer customerId) {
|
List<YwCustomerElectrical> list = ywCustomerElectricalMapper.selectList(new QueryWrapper<YwCustomerElectrical>().lambda()
|
.eq(YwCustomerElectrical::getIsdeleted, Constants.ZERO)
|
.ne(customerId != null, YwCustomerElectrical::getCustomerId, customerId));
|
return list.stream().map(YwCustomerElectrical::getElectricalId).collect(Collectors.toSet());
|
}
|
|
private LoginUserInfo systemUser() {
|
LoginUserInfo u = new LoginUserInfo();
|
u.setId(1);
|
u.setRealname("system");
|
return u;
|
}
|
}
|
