MallServiceImpl.java

package vion.service.impl.monitor;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import io.github.linpeilie.Converter;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.hutool.core.collection.CollUtil;
import org.dromara.hutool.core.date.TimeUtil;
import org.dromara.hutool.core.lang.Assert;
import org.dromara.hutool.core.text.StrUtil;
import org.dromara.mica.mqtt.codec.MqttQoS;
import org.dromara.mica.mqtt.spring.client.MqttClientTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import vion.dto.monitor.MallDTO;
import vion.mapper.monitor.AgentMapper;
import vion.mapper.monitor.MallMapper;
import vion.model.monitor.*;
import vion.service.monitor.*;
import vion.utils.JsonUtil;
import vion.utils.TopicUtil;
import vion.vo.monitor.MallVO;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author vion
 * @date 2024/10/31
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class MallServiceImpl extends MPJBaseServiceImpl<MallMapper, Mall> implements IMallService {

    private final IMAccountService accountService;
    private final IEventRecordService eventRecordService;
    private final IRAgentEventService agentEventService;
    private final IRMallRemarkService mallRemarkService;
    private final IRMallSilentService mallSilentService;
    private final AgentMapper agentMapper;
    private final MqttClientTemplate client;
    private final Converter converter;

    @Override
    public Page<MAccount> listAccount(MAccount dto) {
        return accountService.lambdaQuery(dto).page(Page.of(dto.getPageNum(), dto.getPageSize()));
    }

    @Override
    public Page<MAccount> listAttentionAccount(MAccount dto) {
        var attentionMallList = this.query()
                .select("distinct account_uid")
                .eq("agent_type", dto.getAgentType())
                .eq("attention", 1)
                .list();
        return accountService.lambdaQuery()
                .in(MAccount::getUid, attentionMallList.stream().map(Mall::getAccountUid).toList())
                .orderByAsc(MAccount::getName)
                .page(Page.of(dto.getPageNum(), dto.getPageSize()));
    }

    @Override
    public Page<MallVO> list(MallDTO dto) {
        Assert.notNull(dto.getAgentType(), "agentType 不能为空");
        var wrapper = new MPJLambdaWrapper<>(converter.convert(dto, Mall.class))
                .selectAll(Mall.class)
                .selectAs(MAccount::getName, MallVO::getAccountName)
                .leftJoin(MAccount.class, MAccount::getUid, Mall::getAccountUid)
                .orderByDesc(Mall::getUpdateTime);
        return this.selectJoinListPage(Page.of(dto.getPageNum(), dto.getPageSize()), MallVO.class, wrapper);
    }

    @Override
    public MallVO get(Long id) {
        var wrapper = new MPJLambdaWrapper<Mall>()
                .selectAll(Mall.class)
                .selectAs(MAccount::getName, MallVO::getAccountName)
                .leftJoin(MAccount.class, MAccount::getUid, Mall::getAccountUid)
                .eq(Mall::getId, id);
        return this.selectJoinOne(MallVO.class, wrapper);
    }

    @Override
    public Page<MallVO> listAttention(MallDTO dto) {
        Assert.notNull(dto.getAgentType(), "agentType 不能为空");
        if (CollUtil.isEmpty(dto.getEventUidList())) {
            var wrapper = new MPJLambdaWrapper<>(converter.convert(dto, Mall.class))
                    .selectAll(Mall.class)
                    .selectAs(MAccount::getName, MallVO::getAccountName)
                    .selectAs(Agent::getHostname, MallVO::getHostname)
                    .leftJoin(MAccount.class, MAccount::getUid, Mall::getAccountUid)
                    .leftJoin(Agent.class, Agent::getUid, Mall::getAgentUid)
                    .eq(Mall::getAttention, 1)
                    .in(CollUtil.isNotEmpty(dto.getAccountUidList()), Mall::getAccountUid, dto.getAccountUidList())
                    .orderByDesc(Mall::getAccountUid, Mall::getName);
            var mallVOPage = this.selectJoinListPage(Page.of(dto.getPageNum(), dto.getPageSize()), MallVO.class, wrapper);
            if (CollUtil.isNotEmpty(mallVOPage.getRecords())) {
                var r = mallVOPage.getRecords();
                var mallUidList = r.stream().map(MallVO::getUid).toList();
                // fixme {@link EventServiceImpl #51}
                var eventRecWrapper = Wrappers.<EventRecord>query()
                        .select("DISTINCT on (mall_uid,event_type) *")
                        .in("mall_uid", mallUidList)
                        .ge("create_time", LocalDateTime.of(LocalDate.now(), LocalTime.MIN));
                var eventRecordList = eventRecordService.list(eventRecWrapper);
                var mallUid2RecMap = eventRecordList.stream().collect(Collectors.groupingBy(EventRecord::getMallUid));

                var remarkList = mallRemarkService.lambdaQuery().in(RMallRemark::getMallUid, mallUidList).list();
                var mallUid2RemarkMap = remarkList.stream().sorted(Comparator.comparing(RMallRemark::getRemarkDate).reversed().thenComparing(Comparator.comparing(RMallRemark::getCreateTime).reversed())).collect(Collectors.toMap(RMallRemark::getMallUid, Function.identity(), (r1, r2) -> r1));

                var tmpWrapper = new MPJLambdaWrapper<RAgentEvent>()
                        .selectAll(RAgentEvent.class)
                        .selectAs(Event::getDescription, RAgentEvent::getDescription)
                        .selectAs(Event::getRemark, RAgentEvent::getRemark)
                        .leftJoin(Event.class, Event::getUid, RAgentEvent::getEventUid)
                        .in(RAgentEvent::getMallUid, mallUidList);
                var tmpAgentEventList = agentEventService.selectJoinList(RAgentEvent.class, tmpWrapper);
                var mallUid2AgentEventMap = tmpAgentEventList.stream().collect(Collectors.groupingBy(RAgentEvent::getMallUid));

                r.forEach(tmp -> {
                    tmp.setEventRecordList(mallUid2RecMap.getOrDefault(tmp.getUid(), List.of()));
                    tmp.setAgentEventList(mallUid2AgentEventMap.getOrDefault(tmp.getUid(), List.of()));
                    tmp.setMallRemark(mallUid2RemarkMap.get(tmp.getUid()));
                });
            }
            return mallVOPage;
        } else {
            var agentEventWrapper = new MPJLambdaWrapper<RAgentEvent>()
                    .selectAll(RAgentEvent.class)
                    .leftJoin(Agent.class, Agent::getUid, RAgentEvent::getAgentUid)
                    .in(RAgentEvent::getEventUid, dto.getEventUidList())
                    .eq(Agent::getType, dto.getAgentType())
                    .in(CollUtil.isNotEmpty(dto.getAccountUidList()), RAgentEvent::getAccountUid, dto.getAccountUidList())
                    .orderByDesc(RAgentEvent::getAccountUid, RAgentEvent::getMallUid);
            var agentEventList = agentEventService.selectJoinList(RAgentEvent.class, agentEventWrapper);
            if (CollUtil.isEmpty(agentEventList)) {
                return new Page<>();
            }
            var mallUidList = agentEventList.stream().map(RAgentEvent::getMallUid).distinct().toList();
            var wrapper = new MPJLambdaWrapper<>(converter.convert(dto, Mall.class))
                    .selectAll(Mall.class)
                    .selectAs(MAccount::getName, MallVO::getAccountName)
                    .selectAs(Agent::getHostname, MallVO::getHostname)
                    .leftJoin(MAccount.class, MAccount::getUid, Mall::getAccountUid)
                    .leftJoin(Agent.class, Agent::getUid, Mall::getAgentUid)
                    .eq(Mall::getAttention, 1)
                    .in(Mall::getUid, mallUidList)
                    .orderByDesc(Mall::getUid, Mall::getUpdateTime);
            var mallVOPage = this.selectJoinListPage(Page.of(dto.getPageNum(), dto.getPageSize()), MallVO.class, wrapper);
            if (CollUtil.isNotEmpty(mallVOPage.getRecords())) {
                var r = mallVOPage.getRecords();
                var tmpMallUidList = r.stream().map(MallVO::getUid).toList();
                // fixme {@link EventServiceImpl #51}
                var eventRecWrapper = Wrappers.<EventRecord>query()
                        .select("DISTINCT on (mall_uid,event_type) *")
                        .in("mall_uid", tmpMallUidList)
                        .ge("create_time", LocalDateTime.of(LocalDate.now(), LocalTime.MIN));
                var eventRecordList = eventRecordService.list(eventRecWrapper);
                var mallUid2RecMap = eventRecordList.stream().collect(Collectors.groupingBy(EventRecord::getMallUid));

                var remarkList = mallRemarkService.lambdaQuery().in(RMallRemark::getMallUid, tmpMallUidList).list();
                var mallUid2RemarkMap = remarkList.stream().sorted(Comparator.comparing(RMallRemark::getRemarkDate).reversed().thenComparing(Comparator.comparing(RMallRemark::getCreateTime).reversed())).collect(Collectors.toMap(RMallRemark::getMallUid, Function.identity(), (r1, r2) -> r1));

                var tmpWrapper = new MPJLambdaWrapper<RAgentEvent>()
                        .selectAll(RAgentEvent.class)
                        .selectAs(Event::getDescription, RAgentEvent::getDescription)
                        .selectAs(Event::getRemark, RAgentEvent::getRemark)
                        .leftJoin(Event.class, Event::getUid, RAgentEvent::getEventUid)
                        .in(RAgentEvent::getMallUid, tmpMallUidList);
                var tmpAgentEventList = agentEventService.selectJoinList(RAgentEvent.class, tmpWrapper);
                var mallUid2AgentEventMap = tmpAgentEventList.stream().collect(Collectors.groupingBy(RAgentEvent::getMallUid));

                r.forEach(tmp -> {
                    tmp.setEventRecordList(mallUid2RecMap.getOrDefault(tmp.getUid(), List.of()));
                    tmp.setAgentEventList(mallUid2AgentEventMap.getOrDefault(tmp.getUid(), List.of()));
                    tmp.setMallRemark(mallUid2RemarkMap.get(tmp.getUid()));
                });
            }
            return mallVOPage;
        }
    }

    @Override
    public Page<MallVO> listErrorAttention(MallDTO dto) {
        var eventRecWrapper = new MPJLambdaWrapper<>(EventRecord.class)
                .selectAll()
                .from(from -> from.select("DISTINCT on (mall_uid,event_type) *")
                        .ge(EventRecord::getCreateTime, LocalDateTime.of(LocalDate.now(), LocalTime.MIN))
                        .eq(EventRecord::getAgentType, dto.getAgentType())
                        .in(CollUtil.isNotEmpty(dto.getEventUidList()), EventRecord::getEventUid, dto.getEventUidList())
                        .in(CollUtil.isNotEmpty(dto.getAccountUidList()), EventRecord::getAccountUid, dto.getAccountUidList())
                        .orderByAsc(EventRecord::getMallUid, EventRecord::getEventType)
                        .orderByDesc(EventRecord::getCreateTime))
                .eq(EventRecord::getStatus, 0);
        var eventRecordList = eventRecordService.selectJoinList(EventRecord.class, eventRecWrapper);
        var mallUidList = eventRecordList.stream().map(EventRecord::getMallUid).toList();
        if (CollUtil.isEmpty(mallUidList)) {
            return new Page<>();
        }

        var wrapper = new MPJLambdaWrapper<>(converter.convert(dto, Mall.class))
                .selectAll(Mall.class)
                .selectAs(MAccount::getName, MallVO::getAccountName)
                .leftJoin(MAccount.class, MAccount::getUid, Mall::getAccountUid)
                .in(Mall::getUid, mallUidList)
                .orderByDesc(Mall::getUid, Mall::getUpdateTime);
        var mallVOPage = this.selectJoinListPage(Page.of(dto.getPageNum(), dto.getPageSize()), MallVO.class, wrapper);
        if (CollUtil.isNotEmpty(mallVOPage.getRecords())) {
            var r = mallVOPage.getRecords();
            var tmpMallUidList = r.stream().map(MallVO::getUid).toList();
            var agentUidSet = r.stream().map(MallVO::getAgentUid).collect(Collectors.toSet());
            var agentList = agentMapper.selectList(Wrappers.<Agent>lambdaQuery().in(Agent::getUid, agentUidSet));
            var uid2AgentMap = agentList.stream().collect(Collectors.toMap(Agent::getUid, Function.identity()));

            var tmpWrapper = Wrappers.<EventRecord>query()
                    .select("DISTINCT on (mall_uid,event_type) *")
                    .in("mall_uid", tmpMallUidList)
                    .ge("create_time", TimeUtil.beginOfDay(LocalDate.now().minusDays(3)))
                    .orderByDesc("mall_uid", "event_type", "create_time");
            var tmpEventRecordList = eventRecordService.list(tmpWrapper);
            var tmpMallUid2RecMap = tmpEventRecordList.stream().collect(Collectors.groupingBy(EventRecord::getMallUid));

            var remarkList = mallRemarkService.lambdaQuery().in(RMallRemark::getMallUid, tmpMallUidList).list();
            var mallUid2RemarkMap = remarkList.stream().sorted(Comparator.comparing(RMallRemark::getRemarkDate).reversed().thenComparing(Comparator.comparing(RMallRemark::getCreateTime).reversed())).collect(Collectors.toMap(RMallRemark::getMallUid, Function.identity(), (r1, r2) -> r1));

            var tmpAgentEventWrapper = new MPJLambdaWrapper<RAgentEvent>()
                    .selectAll(RAgentEvent.class)
                    .selectAs(Event::getDescription, RAgentEvent::getDescription)
                    .selectAs(Event::getRemark, RAgentEvent::getRemark)
                    .leftJoin(Event.class, Event::getUid, RAgentEvent::getEventUid)
                    .in(RAgentEvent::getMallUid, tmpMallUidList);
            var tmpAgentEventList = agentEventService.selectJoinList(RAgentEvent.class, tmpAgentEventWrapper);
            var mallUid2AgentEventMap = tmpAgentEventList.stream().collect(Collectors.groupingBy(RAgentEvent::getMallUid));

            r.forEach(tmp -> {
                tmp.setEventRecordList(tmpMallUid2RecMap.getOrDefault(tmp.getUid(), List.of()));
                tmp.setAgentEventList(mallUid2AgentEventMap.getOrDefault(tmp.getUid(), List.of()));
                tmp.setMallRemark(mallUid2RemarkMap.get(tmp.getUid()));
                tmp.setHostname(uid2AgentMap.getOrDefault(tmp.getAgentUid(), new Agent()).getHostname());
            });
        }
        return mallVOPage;
    }

    @Override
    public String attention(List<MallDTO> dtoList) {
        this.updateBatchById(converter.convert(dtoList, Mall.class));
        return "关注成功";
    }

    @Override
    public String attentionByAccount(String accountUid) {
        var mallList = this.lambdaQuery().eq(Mall::getAccountUid, accountUid).list();
        mallList.forEach(mall -> mall.setAttention((short) 1));
        this.updateBatchById(mallList);
        return "批量关注成功";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String cancelAttention(Long id) {
        var attentionMall = this.getById(id);
        this.lambdaUpdate().set(Mall::getAttention, 0).eq(Mall::getId, id).update(new Mall());
        var agentEventList = agentEventService.lambdaQuery().eq(RAgentEvent::getMallUid, attentionMall.getUid()).list();
        var topic = TopicUtil.getEventTopic(attentionMall.getAgentUid());
        if (StrUtil.isBlank(topic)) {
            var msg = StrUtil.format("agent:{} 获取topic失败", attentionMall.getAgentUid());
            log.error(msg);
            return msg;
        }
        agentEventList.forEach(agentEvent -> client.publish(topic, JsonUtil.toJsonByte(agentEvent), MqttQoS.QOS2));
        agentEventService.lambdaUpdate().eq(RAgentEvent::getMallUid, attentionMall.getUid()).remove();
        return "取消成功";
    }

    @Override
    public List<RMallSilent> listSilent(String mallUid) {
        return mallSilentService.lambdaQuery().eq(RMallSilent::getMallUid, mallUid).list();
    }

    @Override
    public String saveSilent(String agentUid, String mallUid, RMallSilent dto) {
        dto.setAgentUid(agentUid);
        dto.setMallUid(mallUid);
        return mallSilentService.save(dto) ? "新增成功" : "新增失败";
    }

    @Override
    public String updateSilent(RMallSilent dto) {
        return mallSilentService.updateById(dto) ? "修改成功" : "修改失败";
    }

    @Override
    public String removeSilent(Long id) {
        return mallSilentService.removeById(id) ? "删除成功" : "删除失败";
    }
}