package com.qianwen.smartman.modules.notify.service.impl;
|
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Optional;
|
import java.util.stream.Collectors;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.qianwen.core.cache.utils.CacheUtil;
|
import com.qianwen.core.log.exception.ServiceException;
|
import com.qianwen.core.mp.base.BaseServiceImpl;
|
import com.qianwen.core.notify.DefaultNotifyType;
|
import com.qianwen.core.notify.NotifyType;
|
import com.qianwen.core.notify.notifier.NotifierProvider;
|
import com.qianwen.core.tool.metadata.ConfigMetadata;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.smartman.common.constant.CommonConstant;
|
import com.qianwen.smartman.common.constant.NotifyConstant;
|
import com.qianwen.smartman.common.utils.MessageUtils;
|
import com.qianwen.smartman.modules.notify.api.DingTalkApi;
|
import com.qianwen.smartman.modules.notify.dto.NotifyTypeInfo;
|
import com.qianwen.smartman.modules.notify.dto.ProviderInfo;
|
import com.qianwen.smartman.modules.notify.entity.BusinessNotify;
|
import com.qianwen.smartman.modules.notify.entity.NotifyConfigEntity;
|
import com.qianwen.smartman.modules.notify.mapper.BusinessNotifyMapper;
|
import com.qianwen.smartman.modules.notify.mapper.NotifyConfigMapper;
|
import com.qianwen.smartman.modules.notify.service.INotifyConfigService;
|
import com.qianwen.smartman.modules.sync.constant.OuterAppConfigConstant;
|
import com.qianwen.smartman.modules.sync.entity.OuterAppConfig;
|
import com.qianwen.smartman.modules.sync.service.IOuterAppConfigService;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.core.util.ObjectUtil;
|
|
@Service
|
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/notify/service/impl/NotifyConfigServiceImpl.class */
|
public class NotifyConfigServiceImpl extends BaseServiceImpl<NotifyConfigMapper, NotifyConfigEntity> implements INotifyConfigService {
|
private static final Logger log = LoggerFactory.getLogger(NotifyConfigServiceImpl.class);
|
private final BusinessNotifyMapper notifyBusinessMapper;
|
private final List<NotifierProvider> providers;
|
private final DingTalkApi dingTalkApi;
|
private final IOuterAppConfigService outerAppConfigService;
|
|
public NotifyConfigServiceImpl(BusinessNotifyMapper notifyBusinessMapper, List<NotifierProvider> providers, @Lazy DingTalkApi dingTalkApi, @Lazy IOuterAppConfigService outerAppConfigService) {
|
this.notifyBusinessMapper = notifyBusinessMapper;
|
this.providers = providers;
|
this.dingTalkApi = dingTalkApi;
|
this.outerAppConfigService = outerAppConfigService;
|
}
|
|
@Override // org.springblade.modules.notify.service.INotifyConfigService
|
public void updateServerConfig(OuterAppConfig outerAppConfig) {
|
Integer appType = outerAppConfig.getAppType();
|
if (appType.intValue() == 1) {
|
Object agentid = outerAppConfig.getWxAgentId();
|
Object corpid = outerAppConfig.getWxCorpId();
|
Object corpsecret = outerAppConfig.getWxAppSecret();
|
Map<String, Object> data = new HashMap<>();
|
data.put("agentid", agentid);
|
data.put("corpid", corpid);
|
data.put("corpsecret", corpsecret);
|
NotifyConfigEntity config = getOne(Wrappers.<NotifyConfigEntity>lambdaQuery()
|
.eq(NotifyConfigEntity::getStatus, 1).eq(NotifyConfigEntity::getType, DefaultNotifyType.weiXinQY.name()));
|
/*
|
NotifyConfigEntity config = (NotifyConfigEntity) getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getStatus();
|
}, 1)).eq((v0) -> {
|
return v0.getType();
|
}, DefaultNotifyType.weiXinQY.name()));*/
|
if (config == null) {
|
config = new NotifyConfigEntity();
|
config.setName(DefaultNotifyType.weiXinQY.getName());
|
config.setType(DefaultNotifyType.weiXinQY.name());
|
config.setProvider("qyTextMessage");
|
config.setStatus(1);
|
config.setConfiguration(data);
|
} else {
|
config.setConfiguration(data);
|
}
|
saveOrUpdateConfig(config);
|
} else if (appType.intValue() == 2) {
|
Object appKey = outerAppConfig.getDingAppKey();
|
Object appSecret = outerAppConfig.getDingAppSecret();
|
Map<String, Object> data2 = new HashMap<>();
|
data2.put("appKey", appKey);
|
data2.put("appSecret", appSecret);
|
NotifyConfigEntity config2 = getOne(Wrappers.<NotifyConfigEntity>lambdaQuery().eq(NotifyConfigEntity::getStatus, 1)
|
.eq(NotifyConfigEntity::getType, DefaultNotifyType.dingTalk.name()));
|
/*
|
NotifyConfigEntity config2 = (NotifyConfigEntity) getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getStatus();
|
}, 1)).eq((v0) -> {
|
return v0.getType();
|
}, DefaultNotifyType.dingTalk.name()));*/
|
if (config2 == null) {
|
config2 = new NotifyConfigEntity();
|
config2.setName(DefaultNotifyType.dingTalk.getName());
|
config2.setType(DefaultNotifyType.dingTalk.name());
|
config2.setProvider("dingTalkMessage");
|
config2.setStatus(1);
|
config2.setConfiguration(data2);
|
} else {
|
config2.setConfiguration(data2);
|
}
|
saveOrUpdateConfig(config2);
|
}
|
}
|
|
public boolean checkMatchingByOuterAppConfig(String notifyType) {
|
if (Func.equals(notifyType, DefaultNotifyType.dingTalk.name())) {
|
OuterAppConfig outerAppConfigDing = this.outerAppConfigService.getAppConfig(OuterAppConfigConstant.DING);
|
if (Func.isNotEmpty(outerAppConfigDing) && outerAppConfigDing.getStatus().equals(CommonConstant.ENABLE)) {
|
NotifyConfigEntity config = getOne(Wrappers.<NotifyConfigEntity>lambdaQuery()
|
.eq(NotifyConfigEntity::getType, DefaultNotifyType.dingTalk.name()).eq(NotifyConfigEntity::getStatus, 1));
|
/*
|
NotifyConfigEntity config = (NotifyConfigEntity) getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getType();
|
}, DefaultNotifyType.dingTalk.name())).eq((v0) -> {
|
return v0.getStatus();
|
}, 1));*/
|
Map<String, Object> configuration = config.getConfiguration();
|
if (!configuration.containsKey("appKey") || !configuration.containsKey("appSecret")) {
|
updateServerConfig(outerAppConfigDing);
|
return true;
|
}
|
Object appKey = configuration.get("appKey");
|
Object appSecret = configuration.get("appSecret");
|
String dingAppKey = outerAppConfigDing.getDingAppKey();
|
String dingAppSecret = outerAppConfigDing.getDingAppSecret();
|
if (!Func.equals(appKey, dingAppKey) || !Func.equals(appSecret, dingAppSecret)) {
|
updateServerConfig(outerAppConfigDing);
|
return true;
|
}
|
return true;
|
}
|
return false;
|
}
|
return false;
|
}
|
|
@Override // org.springblade.modules.notify.service.INotifyConfigService
|
public NotifyConfigEntity saveOrUpdateConfig(NotifyConfigEntity notificationConfig) {
|
if (Func.isNotEmpty(notificationConfig.getId())) {
|
CacheUtil.evict("blade:notify", "notifier:id:", notificationConfig.getId(), false);
|
}
|
long count = count(Wrappers.<NotifyConfigEntity>lambdaQuery()
|
.ne(Func.isNotEmpty(notificationConfig.getId()), NotifyConfigEntity::getId, notificationConfig.getId())
|
.eq(NotifyConfigEntity::getType, notificationConfig.getType()));
|
/*
|
long count = count((Wrapper) Wrappers.lambdaQuery().ne(Func.isNotEmpty(notificationConfig.getId()), (v0) -> {
|
return v0.getId();
|
}, notificationConfig.getId()).eq((v0) -> {
|
return v0.getType();
|
}, notificationConfig.getType()));*/
|
if (count > 0) {
|
throw new ServiceException(MessageUtils.message("notify.service.config.not.be.repeated", new Object[0]));
|
}
|
checkProvider(notificationConfig);
|
saveOrUpdate(notificationConfig);
|
return notificationConfig;
|
}
|
|
@Override // org.springblade.modules.notify.service.INotifyConfigService
|
public boolean checkUsedByBusinessNotify(String id) {
|
Long count = this.notifyBusinessMapper.selectCount(Wrappers.<BusinessNotify>lambdaQuery()
|
.eq(BusinessNotify::getNotifyId, id));
|
/*
|
Long count = this.notifyBusinessMapper.selectCount((Wrapper) Wrappers.lambdaQuery().eq((v0) -> {
|
return v0.getNotifyId();
|
}, id));*/
|
if (count.longValue() > 0) {
|
throw new ServiceException(MessageUtils.message("notify.service.config.not.delete", new Object[0]));
|
}
|
return true;
|
}
|
|
public Map<String, NotifyTypeInfo> getNotifyInfo() {
|
return getAllNotifyType().stream().filter(n -> {
|
return ("weiXinMini".equals(n.getId()) || "weiXinMp".equals(n.getId())) ? false : true;
|
}).collect(Collectors.toMap((v0) -> {
|
return v0.getId();
|
}, notifyTypeInfo -> {
|
return notifyTypeInfo;
|
}));
|
}
|
|
@Override // org.springblade.modules.notify.service.INotifyConfigService
|
public List<NotifyTypeInfo> getServiceList() {
|
Map<String, NotifyTypeInfo> typeInfoMap = getNotifyInfo();
|
List<String> typeList = CollectionUtil.list(Boolean.FALSE.booleanValue(), typeInfoMap.keySet());
|
Map<String, NotifyConfigEntity> configMap = getConfigs(typeList);
|
List<BusinessNotify> businessNotifies = this.notifyBusinessMapper.selectList(Wrappers.<BusinessNotify>lambdaQuery().in(BusinessNotify::getNotifyType, typeList));
|
/*
|
List<BusinessNotify> businessNotifies = this.notifyBusinessMapper.selectList((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getNotifyType();
|
}, typeList));*/
|
Map<String, List<BusinessNotify>> notifyMap = businessNotifies.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getNotifyType();
|
}));
|
typeInfoMap.forEach((typeId, typeInfo) -> {
|
if (configMap.containsKey(typeId)) {
|
NotifyConfigEntity config = (NotifyConfigEntity) configMap.get(typeId);
|
typeInfo.setConfigEntity(config);
|
if (Func.equals(config.getType(), DefaultNotifyType.dingTalk.name()) && checkMatchingByOuterAppConfig(DefaultNotifyType.dingTalk.name())) {
|
String companyName = this.dingTalkApi.getCompanyName();
|
typeInfo.setCompanyName(companyName);
|
}
|
}
|
typeInfo.setIsBindBusiness(Boolean.valueOf(notifyMap.containsKey(typeId)));
|
});
|
return new ArrayList<>(typeInfoMap.values());
|
}
|
|
@Override // org.springblade.modules.notify.service.INotifyConfigService
|
public ConfigMetadata getMetadataByTypeAndProvider(String type, String provider) {
|
ConfigMetadata result = null;
|
List<NotifierProvider> providerList = this.providers.stream().filter(prov -> {
|
return prov.getType().getId().equalsIgnoreCase(type) && prov.getProvider().getId().equalsIgnoreCase(provider);
|
}).collect(Collectors.toList());
|
if (Func.isNotEmpty(providerList)) {
|
result = providerList.get(0).getNotifierConfigMetadata();
|
}
|
return result;
|
}
|
|
public void checkProvider(NotifyConfigEntity notificationConfig) {
|
if (Func.isEmpty(notificationConfig.getId())) {
|
return;
|
}
|
String type = notificationConfig.getType();
|
if (!type.equals(NotifyConstant.SMS_TYPE_VALUE)) {
|
return;
|
}
|
NotifyConfigEntity configEntity = (NotifyConfigEntity) getOne(Wrappers.lambdaQuery(NotifyConfigEntity.class).eq((v0) -> {
|
return v0.getId();
|
}, notificationConfig.getId()));
|
if (ObjectUtil.isNull(configEntity)) {
|
throw new ServiceException(MessageUtils.message("notify.service.config.is.null", new Object[0]));
|
}
|
if (notificationConfig.getProvider().equals(configEntity.getProvider())) {
|
return;
|
}
|
Optional<ProviderInfo> first = getNotifyInfo().get(type).getProviderInfos().stream().filter(p -> {
|
return p.getId().equals(configEntity.getProvider());
|
}).findFirst();
|
if (!first.isPresent()) {
|
throw new ServiceException(MessageUtils.message("notify.service.config.is.null", new Object[0]));
|
}
|
if (this.notifyBusinessMapper.exists((Wrapper) Wrappers.lambdaQuery(BusinessNotify.class).eq((v0) -> {
|
return v0.getNotifyId();
|
}, configEntity.getId()))) {
|
throw new ServiceException(first.get().getName() + MessageUtils.message("notify.config.not.be.edit", new Object[0]));
|
}
|
}
|
|
public Map<String, NotifyConfigEntity> getConfigs(List<String> types) {
|
List<NotifyConfigEntity> configList = list(Wrappers.<NotifyConfigEntity>lambdaQuery().in(NotifyConfigEntity::getType, types));
|
/*
|
List<NotifyConfigEntity> configList = list((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
|
return v0.getType();
|
}, types));*/
|
return configList.stream().collect(Collectors.toMap((v0) -> {
|
return v0.getType();
|
}, notifyConfigEntity -> {
|
return notifyConfigEntity;
|
}, (a, b) -> {
|
return a;
|
}));
|
}
|
|
@Override // org.springblade.modules.notify.service.INotifyConfigService
|
public List<NotifyTypeInfo> getAllNotifyType() {
|
List<NotifyTypeInfo> result = new ArrayList<>();
|
Map<NotifyType, List<NotifierProvider>> groups = this.providers.stream().collect(Collectors.groupingBy((v0) -> {
|
return v0.getType();
|
}));
|
groups.forEach((type, providerList) -> {
|
NotifyTypeInfo typeInfo = new NotifyTypeInfo();
|
typeInfo.setId(type.getId());
|
typeInfo.setName(type.getName());
|
typeInfo.setProviderInfos(providerList.stream().map(ProviderInfo::of).collect(Collectors.toList()));
|
result.add(typeInfo);
|
});
|
return result;
|
}
|
}
|
