szwlServer/src/main/java/com/szwl/service/impl/TEquipmentServiceImpl.java

package com.szwl.service.impl;

import cn.hutool.core.util.RandomUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.szwl.constant.OperationType;
import com.szwl.feign.bean.SyncOldFeign;
import com.szwl.mapper.TEquipmentMapper;
import com.szwl.model.bo.R;
import com.szwl.model.entity.*;
import com.szwl.model.query.StatisticsParam;
import com.szwl.model.utils.MailUtil;
import com.szwl.model.utils.PushUtils;
import com.szwl.model.utils.YunPianSms;
import com.szwl.service.*;
import com.szwl.util.WechatSendUtil;
import org.apache.commons.lang.StringUtils;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author wuhs
 * @since 2023-10-25
 */
@Service
public class TEquipmentServiceImpl extends ServiceImpl<TEquipmentMapper, TEquipment> implements TEquipmentService {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @Resource
    TEquipmentMapper tEquipmentMapper;

    @Autowired
    TAdminService adminService;

    @Resource
    SyncOldFeign syncOldFeign;

    @Resource
    TEquipmentService equipmentService;

    @Autowired
    TEquipmentDescService equipmentDescService;

    @Resource
    TWechatService wechatService;

//    @Resource
//    private MqttService mqttService;
    private final MqttService mqttService;

    @Resource
    MessageLogService messageLogService;

    private static final String appid = "07784f5fedb508046c841b391005b7de";

    @Autowired
    public TEquipmentServiceImpl(@Lazy MqttService mqttService) {
        this.mqttService = mqttService;
    }

    @Override
    public String sentMessage(String clientId, String json) {
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getClientId,clientId);
        List<TEquipment> equipmentList = tEquipmentMapper.selectList(query);
        if(equipmentList.size()==0){
            return "该设备不存在";
        }
        TEquipment equipment = equipmentList.get(0);
        if (equipment == null) {
            return "该设备不存在";
        }
        String channel = equipment.getChannel();
        String equimentType = equipment.getEquimentType();
        if(StringUtils.isEmpty(channel)||channel.equals("1")||StringUtils.isEmpty(equimentType)){
            //用个推
            PushUtils.push(equipment.getGtClientId(), "", "", json);
        }
        if(StringUtils.isNotEmpty(channel)&&channel.equals("2")&&StringUtils.isNotEmpty(equimentType)){
            //用Mq
            //1 创建消息
            MessageProperties messageProperties = new MessageProperties();
            messageProperties.setContentType("text/plain");
            org.springframework.amqp.core.Message message = new org.springframework.amqp.core.Message(json.getBytes(), messageProperties);
            amqpTemplate.send(equimentType, clientId, message);
        }
        return "success";
    }

    @Override
    public void sendRemoteMessage(String clientId, OperationType operationType, String message) {
        MessageLog messageLog = new MessageLog();
        messageLog.setMsgId(System.currentTimeMillis() + RandomUtil.randomNumbers(10));
        messageLog.setClientId(clientId);
        messageLog.setDirection(1);
        messageLog.setOperation(operationType.getCode());
        messageLog.setTimestamp(System.currentTimeMillis());
        messageLog.setDataContent(message);
        messageLog.setCreatedAt(new Date());
        messageLogService.save(messageLog);
        // 参数
        JSONObject data = new JSONObject();
        // 请求流水号
        data.put("msgId", messageLog.getMsgId());
        data.put("clientId", messageLog.getClientId());
        data.put("timestamp", messageLog.getTimestamp());
        data.put("dataContent", messageLog.getDataContent());
        mqttService.sendMessage(clientId, data.toJSONString(), 0);
    }


    @Override
    public String findMachineTotalNum(StatisticsParam param) {
        return tEquipmentMapper.findMachineTotalNum(param);
    }

    @Override
    public String findMachineUseNum(StatisticsParam param) {
        return tEquipmentMapper.findMachineUseNum(param);
    }

    @Override
    public String findMachineUseNumAdmin(StatisticsParam param) {
        return tEquipmentMapper.findMachineUseNumAdmin(param);
    }

    @Override
    public Optional<String> syncOneEquipmentByClientId(String clientId) {
        if (StringUtils.isNotEmpty(clientId)) {
            TEquipment oldEquipment = R.getDataIfSuccess(syncOldFeign.getEquipmentByClientId(clientId));

            Long id = oldEquipment.getId();
            Date createDate = oldEquipment.getCreateDate();
            Date modifyDate = oldEquipment.getModifyDate();
            Long adminId = oldEquipment.getAdminId();
            String adminLevel = oldEquipment.getAdminLevel();
            String adminPwd = oldEquipment.getAdminPwd();
            Long areaId = oldEquipment.getAreaId();
            String cabinetHd = oldEquipment.getCabinetHd();
            String cabinetTm = oldEquipment.getCabinetTm();
//            String clientId = oldEquipment.getClientId();
            String contactName = oldEquipment.getContactName();
            String contactPhone = oldEquipment.getContactPhone();
            String operationalPhone = oldEquipment.getOperationalPhone();
            String operationalName = oldEquipment.getOperationalName();
            String furnaceSp = oldEquipment.getFurnaceSp();
            String furnaceTm = oldEquipment.getFurnaceTm();
            String guestPwd = oldEquipment.getGuestPwd();
            Boolean isNetWork = oldEquipment.getIsNetWork();
            Boolean isUsing = oldEquipment.getIsUsing();
            Date lastUpdateTime = oldEquipment.getLastUpdateTime();
            Double latitude = oldEquipment.getLatitude();
            Double longitude = oldEquipment.getLongitude();
            String managerId = oldEquipment.getManagerId();
            String selfName = oldEquipment.getSelfName();
            String channel = oldEquipment.getChannel();
            String name = oldEquipment.getName();
            String netWorkingMode = oldEquipment.getNetWorkingMode();
            String operator = oldEquipment.getOperator();
            Integer payType = oldEquipment.getPayType();
            Integer productTotal = oldEquipment.getProductTotal();
            String simNo = oldEquipment.getSimNo();
            String sn = oldEquipment.getSn();
            String adminUserName = oldEquipment.getAdminUserName();
            Long agencyId = oldEquipment.getAgencyId();
            Long merchantId = oldEquipment.getMerchantId();
            String companyPhone = oldEquipment.getCompanyPhone();
            Long personageId = oldEquipment.getPersonageId();
            Integer type = oldEquipment.getType();
            String fullName = oldEquipment.getFullName();
            Date pushUpdateTime = oldEquipment.getPushUpdateTime();
            Long timeRuleId = oldEquipment.getTimeRuleId();
            String gtClientId = oldEquipment.getGtClientId();
            Integer eqeStatus = oldEquipment.getEqeStatus();
            Boolean isBlocked = oldEquipment.getIsBlocked();
            String messageReceiver = oldEquipment.getMessageReceiver();
            Boolean isSleep = oldEquipment.getIsSleep();
            String advancedParameters = oldEquipment.getAdvancedParameters();
            String volume = oldEquipment.getVolume();
            String commonParameters = oldEquipment.getCommonParameters();
            String network = oldEquipment.getNetwork();
            String offTime = oldEquipment.getOffTime();
            String bootTime = oldEquipment.getBootTime();
            String plcVersion = oldEquipment.getPlcVersion();
            String equipmentType = oldEquipment.getEquimentType();
            Date endDate = oldEquipment.getEndDate();
            String flowers = oldEquipment.getFlowers();
            String machineType = oldEquipment.getMachineType();
//                String apkVersion = oldEquipment.getApkVersion(); // 旧系统没有
//                String couponStatus = oldEquipment.getCouponStatus(); // 旧系统没有
            String paymentType = oldEquipment.getPaymentType();
            String companyType = oldEquipment.getCompanyType();

            TEquipment equipment = new TEquipment();
            equipment.setId(id);
            equipment.setCreateDate(createDate);
            equipment.setModifyDate(modifyDate);
            equipment.setAdminId(adminId);
            equipment.setAdminLevel(adminLevel);
            equipment.setAdminPwd(adminPwd);
            equipment.setAreaId(areaId);
            equipment.setCabinetHd(cabinetHd);
            equipment.setCabinetTm(cabinetTm);
            equipment.setClientId(clientId);
            equipment.setContactName(contactName);
            equipment.setContactPhone(contactPhone);
            equipment.setOperationalPhone(operationalPhone);
            equipment.setOperationalName(operationalName);
            equipment.setFurnaceSp(furnaceSp);
            equipment.setFurnaceTm(furnaceTm);
            equipment.setGuestPwd(guestPwd);
            equipment.setIsNetWork(isNetWork);
            equipment.setIsUsing(isUsing);
            equipment.setLastUpdateTime(lastUpdateTime);
            equipment.setLatitude(latitude);
            equipment.setLongitude(longitude);
            equipment.setManagerId(managerId);
            equipment.setSelfName(selfName);
            equipment.setChannel(channel);
            equipment.setName(name);
            equipment.setNetWorkingMode(netWorkingMode);
            equipment.setOperator(operator);
            equipment.setPayType(payType);
            equipment.setProductTotal(productTotal);
            equipment.setSimNo(simNo);
            equipment.setSn(sn);
            equipment.setAdminUserName(adminUserName);
            equipment.setAgencyId(agencyId);
            equipment.setMerchantId(merchantId);
            equipment.setCompanyPhone(companyPhone);
            equipment.setPersonageId(personageId);
            equipment.setType(type);
            equipment.setFullName(fullName);
            equipment.setPushUpdateTime(pushUpdateTime);
            equipment.setTimeRuleId(timeRuleId);
            equipment.setGtClientId(gtClientId);
            equipment.setEqeStatus(eqeStatus);
            equipment.setIsBlocked(isBlocked);
            equipment.setMessageReceiver(messageReceiver);
            equipment.setIsSleep(isSleep);
            equipment.setAdvancedParameters(advancedParameters);
            equipment.setVolume(volume);
            equipment.setCommonParameters(commonParameters);
            equipment.setNetwork(network);
            equipment.setOffTime(offTime);
            equipment.setBootTime(bootTime);
            equipment.setPlcVersion(plcVersion);
            equipment.setEquimentType(equipmentType);
            equipment.setEndDate(endDate);
            equipment.setFlowers(flowers);
            equipment.setMachineType(machineType);
            equipment.setCompanyType(companyType);
            equipment.setPaymentType(paymentType);

            equipmentService.save(equipment);

            return Optional.of("success");
        } else {
            return Optional.empty();
        }
    }

    @Override
    public int getForeignEquipmentCount(String area) {
        switch (area) {
            case "0":
                // 统计国内
                List<Long> domesticAdminIdList = adminService.lambdaQuery().eq(TAdmin::getIfForeign, "0").list().stream().map(TAdmin::getId).collect(Collectors.toList());
                return equipmentService.lambdaQuery().in(TEquipment::getAdminId, domesticAdminIdList).count();
            case "1":
                // 统计海外
                List<Long> overseasAdminIdList = adminService.lambdaQuery().eq(TAdmin::getIfForeign, "1").list().stream().map(TAdmin::getId).collect(Collectors.toList());
                return equipmentService.lambdaQuery().in(TEquipment::getAdminId, overseasAdminIdList).count();
            case "2":
                // 统计全球
                return equipmentService.list().size();
            default:
                return 0;
        }
    }

    @Override
    public void checkEquipmentStatus() {
        // 检查处于开机状态的机器
        LambdaQueryWrapper<TEquipment> query = Wrappers.lambdaQuery();
        query.eq(TEquipment::getEqeStatus, 1);
        List<TEquipment> equipmentList = equipmentService.list(query);
        if (!equipmentList.isEmpty()) {
            // 获取当前时间，并检查设备状态是否过期
            long nowTime = System.currentTimeMillis();
            for (TEquipment equipment : equipmentList) {
                if (equipment.getModifyDate() != null) {
                    // 如果设备的最后刷新时间超过480秒前，则清除设备状态信息，更改为关机状态
                    long updateTime = equipment.getModifyDate().getTime();
                    if (nowTime > updateTime && (nowTime - updateTime) > 600000) {
                        // 发送上传心跳信号
                        equipmentService.sentMessage(equipment.getClientId(), PushUtils.buildJson("onoffstatus", "0").toString());
                        // 添加标志
                        TEquipmentDesc equipmentDesc = equipmentDescService.getById(equipment.getId());
                        if (equipmentDesc != null) {
                            equipmentDesc.setNote("1");
                            equipmentDescService.updateById(equipmentDesc);
                        } else {
                            TEquipmentDesc newEquipmentDesc = new TEquipmentDesc();
                            newEquipmentDesc.setEquipmentId(equipment.getId());
                            newEquipmentDesc.setNote("1");
                            equipmentDescService.save(newEquipmentDesc);
                        }
                    }
                }
            }
        }
    }

    @Override
    public void checkAgEquipmentStatus() {
        LambdaQueryWrapper<TEquipmentDesc> query = Wrappers.lambdaQuery();
        query.eq(TEquipmentDesc::getNote, "1");
        List<TEquipmentDesc> list = equipmentDescService.list(query);
        if (!list.isEmpty()) {
            // 获取当前时间，并检查设备状态是否过期
            long nowTime = System.currentTimeMillis();
            for (TEquipmentDesc equipmentDesc : list) {
                TEquipment equipment = equipmentService.getById(equipmentDesc.getEquipmentId());
                long updateTime = equipment.getModifyDate().getTime();
                if (nowTime > updateTime && (nowTime - updateTime) > 600000) {
                    // 判断为异常关机或者断网，通知客户
//                    equipment.setCabinetTm("0");
//                    equipment.setCabinetHd("0");
//                    equipment.setFurnaceTm("0");
//                    equipment.setFurnaceSp("0");
                    equipment.setEqeStatus(0);
                    equipmentService.updateById(equipment);
                    // 说明机器没有上传信号，判断为网络不好或者关机，发送信号通知客户 查机器归属国内还是国外
                    TAdmin admin = adminService.getById(equipment.getAdminId());
                    String ifForeign = admin.getIfForeign();
                    String timeZone = admin.getTimeZone();
                    timeZone = StringUtils.isEmpty(timeZone) ? "Asia/Shanghai" : timeZone;
                    // 查询是申泽还是七云的
                    String companyType = admin.getCompanyType();
                    LambdaQueryWrapper<TWechat> wechatQuery = Wrappers.lambdaQuery();
                    wechatQuery.eq(TWechat::getAdminId, equipment.getAdminId());
                    TWechat wechat = wechatService.getOne(wechatQuery);
                    // 设备名称
                    String name = equipment.getName();
                    // 如果为空就拿设备编号后六位
                    if(StringUtils.isEmpty(name)) {
                        name = equipment.getClientId().substring(equipment.getClientId().length() - 6);
                    }
                    String machineType = equipment.getMachineType();
                    if (StringUtils.isNotEmpty(machineType)) {
                        machineType = "0";
                    }
                    if(wechat != null) {
                        // 有绑定微信的话发公众号
                        String openId = wechat.getOpenId();
                        wechatService.sendNetworkMessage(openId,equipment.getClientId(),name, ifForeign, companyType);
                        if ("1".equals(ifForeign)) {
                            // 国外再发邮件
                            String messageReceiver = equipment.getMessageReceiver();
                            if(StringUtils.isNotEmpty(messageReceiver)) {
                                String[] split = messageReceiver.split(",");
                                for (String s : split) {
                                    WechatSendUtil.sentEmail(s, name, timeZone, machineType);
                                }
                            } else {
                                if(StringUtils.isNotEmpty(admin.getEmail())){
                                    WechatSendUtil.sentEmail(admin.getEmail(), name, timeZone, machineType);
                                }
                            }
                        }
                    } else {
                        // 0或空：国内，1：国外
                        if ("0".equals(ifForeign) || ifForeign.isEmpty()) {
                            //TODO 国内发短信
                        } else {
                            // 国外发送邮件
                            String messageReceiver = equipment.getMessageReceiver();
                            if(StringUtils.isNotEmpty(messageReceiver)) {
                                String[] split = messageReceiver.split(",");
                                for (String s : split) {
                                    WechatSendUtil.sentEmail(s, name, timeZone, machineType);
                                }
                            } else {
                                if(StringUtils.isNotEmpty(admin.getEmail())){
                                    WechatSendUtil.sentEmail(admin.getEmail(), name, timeZone, machineType);
                                }
                            }

                        }
                    }
                }
                equipmentDesc.setNote("0");
                equipmentDescService.updateById(equipmentDesc);
            }
        }
    }

    @Override
    public void informClient(Long adminId, String deviceId) {
        LambdaQueryWrapper<TAdmin> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(TAdmin::getId, adminId);
        TAdmin admin = adminService.getOne(queryWrapper);
        String ifForeign = admin.getIfForeign();
        String phone = admin.getPhone();
        String email = admin.getEmail();
        switch (ifForeign) {
            case "0": { // 国内发短信
                if (StringUtils.isEmpty(phone)) {
                    return;
                }
                try {
                    String sms = YunPianSms.sendSms(appid, getInformText(deviceId), phone);
                    System.out.println("短信已发送：" + sms);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
                break;
            }
            case "1": { // 海外发邮箱
                if (StringUtils.isEmpty(email)) {
                    return;
                }
                String subject = "Reset the price of the flowers"; // 邮件标题
                String content = getInformContent(deviceId); // 邮件正文
                new MailUtil().send(email, subject, content);
                break;
            }
            default:
                System.out.println("无效的ifForeign");
                break;
        }
    }

    private String getInformContent(String deviceId) {
        String content;
        String str = "Dear customer:<br>" +
                "<br>" +
                "Your machine number is <" + deviceId + "> cotton candy machine, the number of flowers has been pushed, please reset the price of the flowers!" +
                "<br>" +
                "<br>" +
                "Best Regards.<br>" +
                "Sunzee Intelligent";
        content = String.format(str);
        return content;
    }

    private String getInformText(String deviceId) {
        String sms = "";
        if(StringUtils.isNotEmpty(deviceId)){
            sms = "【申泽智能】您好，您名下设备编号为" + deviceId + "的机器，花型数量已推送，请重新设置价格！";
        }
        return sms;
    }

    /**
     * 根据经度获取时区
     * @param currentLon 当前经度
     * @return
     */
    public static int lateTimeZone(double currentLon) {
        int timeZone ;
        int shangValue = (int)(currentLon / 15);
        double yushuValue =  Math.abs(currentLon % 15);
        if (yushuValue <= 7.5) {
            timeZone = shangValue;
        } else {
            timeZone = shangValue +(currentLon > 0 ?  1 :-1);
        }
        return timeZone;
    }
}