KeyValueConfigServiceImpl.java

package pwc.taxtech.atms.service.impl;

import com.alibaba.druid.util.StringUtils;
import org.apache.poi.openxml4j.exceptions.InvalidOperationException;
import org.nutz.lang.Strings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import pwc.taxtech.atms.common.ApplyScope;
import pwc.taxtech.atms.common.CommonUtils;
import pwc.taxtech.atms.common.OperateLogType;
import pwc.taxtech.atms.common.OperationModule;
import pwc.taxtech.atms.constant.enums.KeyValueConfigType;
import pwc.taxtech.atms.dpo.AnalyticsModelDetail;
import pwc.taxtech.atms.dpo.FinancialStatementDetail;
import pwc.taxtech.atms.dpo.TaxReturnDetail;
import pwc.taxtech.atms.dto.AddKeyValueConfigDto;
import pwc.taxtech.atms.dto.KeyValueConfigDisplayDto;
import pwc.taxtech.atms.dto.OperationResultDto;
import pwc.taxtech.atms.dto.UpdateKeyValueConfigDto;
import pwc.taxtech.atms.dto.formula.FormulaConfigDto;
import pwc.taxtech.atms.entity.*;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

@Service
public class KeyValueConfigServiceImpl extends AbstractService {

    private static final Logger logger = LoggerFactory.getLogger(KeyValueConfigServiceImpl.class);

    private OperateLogType logType = OperateLogType.OperationLogKeyvalue;

    public List<KeyValueConfigDisplayDto> get() {
        List<KeyValueConfig> list = keyValueConfigMapper.selectKeyValueConfigsByOrderByCreateTime();
        List<KeyValueConfigDisplayDto> result = new ArrayList<>();
        if (list.size() > 0) {
            Map<String, String> industryList = new HashMap<>();
            industryMapper.selectByExample(new IndustryExample()).forEach(item -> industryList.put(item.getId(), item.getName()));
            Map<String, String> serviceType = new HashMap<>();
            serviceTypeMapper.selectByExample(new ServiceTypeExample()).forEach(item -> serviceType.put(item.getId(), item.getName()));
            List<KeyValueReference> scopes = keyValueReferenceMapper.selectByExample(new KeyValueReferenceExample());
            for (KeyValueConfig keyValueConfig : list) {
                KeyValueConfigDisplayDto dtoObj = new KeyValueConfigDisplayDto();
                CommonUtils.copyProperties(keyValueConfig, dtoObj);
                dtoObj.setServiceTypes(getNamesByIds(keyValueConfig.getServiceTypeIds(), serviceType));
                dtoObj.setIndustrys(getNamesByIds(keyValueConfig.getIndustryIds(), industryList));
                dtoObj.setIndustryIDs(Arrays.asList(keyValueConfig.getIndustryIds().split(",")));
                dtoObj.setServiceTypeIDs(Arrays.asList(keyValueConfig.getServiceTypeIds().split(",")));
                List<KeyValueReference> selectScopeList = scopes.stream().filter(item -> item.getKeyValueConfigId().equals(keyValueConfig.getId())).collect(Collectors.toList());
                List<Integer> selectScopes = selectScopeList.stream().map(KeyValueReference::getScope).distinct().collect(Collectors.toList());
                Map<Integer, Integer> scopeCount = new HashMap<>();
                if (selectScopeList.size() > 0) {
                    for (Integer selectScope : selectScopes) {
                        Integer count = (int) (selectScopeList.stream().filter(a -> a.getScope().equals(selectScope)).count());
                        scopeCount.put(selectScope, count);
                    }
                }
                dtoObj.setScopeCount(scopeCount);
                dtoObj.setScopeSummary(jointToString(selectScopes));
                result.add(dtoObj);
            }
        }
        return result;
    }

    public OperationResultDto<List<FormulaConfigDto>> getAllFormulaList() {
        OperationResultDto<List<FormulaConfigDto>> result = new OperationResultDto<>();
        List<FormulaConfig> dbItems = formulaConfigMapper.selectByExample(new FormulaConfigExample());
        List<FormulaConfigDto> items = new ArrayList<>();
        CommonUtils.copyProperties(dbItems, items);
        result.setData(items);
        result.setResult(true);
        return result;
    }

    public List<FinancialStatementDetail> getFinacialStatement(String configurationId) {
        Map<String, String> jointObjectMap = new HashMap<>();
        industryMapper.selectByExample(new IndustryExample()).forEach(a -> jointObjectMap.put(a.getId(), a.getName()));
        List<FinancialStatementDetail> referenceFinance = keyValueReferenceMapper.getFinancialStatementDetails(configurationId);
        for (FinancialStatementDetail item : referenceFinance) {
            item.setIndustry(getNamesByIds(item.getIndustry(), jointObjectMap));
        }
        return referenceFinance;
    }

    public List<TaxReturnDetail> getTaxReturn(String configurationId) {
        Map<String, String> jointObjectMap = new HashMap<>();
        industryMapper.selectByExample(new IndustryExample()).forEach(a -> jointObjectMap.put(a.getId(), a.getName()));
        List<TaxReturnDetail> referenceTax = keyValueReferenceMapper.getTaxReturnDetails(configurationId);
        for (TaxReturnDetail item : referenceTax) {
            item.setIndustry(getNamesByIds(item.getIndustry(), jointObjectMap));
        }
        return referenceTax;
    }

    public List<AnalyticsModelDetail> getAnalyticsModel(String configurationId) {
        Map<String, String> industryList = new HashMap<>();
        industryMapper.selectByExample(new IndustryExample()).forEach(a -> industryList.put(a.getId(), a.getName()));
        Map<String, String> organization = new HashMap<>();
        organizationMapper.selectByExample(new OrganizationExample()).forEach(a -> organization.put(a.getId(), a.getName()));
        List<AnalyticsModelDetail> referenceModel = keyValueReferenceMapper.getAnalyticsModelDetails(configurationId);
        for (AnalyticsModelDetail analyticsModelDetail : referenceModel) {
            analyticsModelDetail.setIndustry(getNamesByIds(analyticsModelDetail.getIndustry(), industryList));
            analyticsModelDetail.setEntityName(getNamesByIds(analyticsModelDetail.getEntityId(), organization));
        }
        return referenceModel;
    }

    public int deleteKeyValueConfiguration(String keyId) {
        KeyValueReferenceExample example = new KeyValueReferenceExample();
        example.createCriteria().andKeyValueConfigIdEqualTo(keyId);
        int referenceCount = (int) keyValueReferenceMapper.countByExample(example);
        if (referenceCount == 0) {
            KeyValueConfigExample kvcExample = new KeyValueConfigExample();
            kvcExample.createCriteria().andIdEqualTo(keyId).andKeyValueTypeEqualTo(KeyValueConfigType.Customize.getCode());
            Optional<KeyValueConfig> deleteKey = keyValueConfigMapper.selectByExample(kvcExample).stream().findFirst();
            if (deleteKey.isPresent()) {
                keyValueConfigMapper.deleteByPrimaryKey(deleteKey.get().getId());
                operationLogService.deleteDataAddLog(deleteKey, OperationModule.KeyValueConfig, ""
                        , "DeleteKeyValueConfiguration", "", deleteKey.get().getName(), logType);
                referenceCount = 1;
            }
        } else {
            referenceCount = -1;
        }
        return referenceCount;
    }

    public void addKeyValueConfiguration(AddKeyValueConfigDto addKeyValueConfigDto) {
        Date now = new Date();
        KeyValueConfig keyValueConfig = new KeyValueConfig();
        CommonUtils.copyProperties(addKeyValueConfigDto, keyValueConfig);
        keyValueConfig.setIndustryIds(Strings.join(",", addKeyValueConfigDto.getIndustryIds()));
        keyValueConfig.setServiceTypeIds(Strings.join(",", addKeyValueConfigDto.getServiceTypeIds()));
        String guid = CommonUtils.getUUID();
        keyValueConfig.setId(guid);
        keyValueConfig.setKeyCode(guid.replaceAll("-", ""));
        keyValueConfig.setIsConstant(0);
        keyValueConfig.setCalculateStatus(99);
        keyValueConfig.setCreateTime(now);
        keyValueConfig.setUpdateTime(now);
        keyValueConfig.setUpdator(addKeyValueConfigDto.getUserName());
        keyValueConfig.setKeyValueType(2);

        keyValueConfigMapper.insertSelective(keyValueConfig);
        operationLogService.addDataAddLog(keyValueConfig, OperationModule.KeyValueConfig, addKeyValueConfigDto.getUserName()
                , Message.Log.AddKeyValueConfiguration, "", keyValueConfig.getName(), logType);
    }

    public void updateKeyValueConfiguration(UpdateKeyValueConfigDto updateKeyValueConfigDto) {
        KeyValueConfig keyValueConfig = keyValueConfigMapper.selectByPrimaryKey(updateKeyValueConfigDto.getId());

        if (keyValueConfig == null) {
            throw new InvalidOperationException("Not found");
        }

        KeyValueConfig original = new KeyValueConfig();
        CommonUtils.copyProperties(keyValueConfig, original);
        keyValueConfig.setFormula(updateKeyValueConfigDto.getFormula());
        keyValueConfig.setDescription(updateKeyValueConfigDto.getDescription());
        keyValueConfig.setName(updateKeyValueConfigDto.getName());
        keyValueConfig.setDataSource(updateKeyValueConfigDto.getDataSource());
        keyValueConfig.setServiceTypeIds(Strings.join(",", updateKeyValueConfigDto.getServiceTypeIds()));
        keyValueConfig.setIndustryIds(Strings.join(",", updateKeyValueConfigDto.getIndustryIds()));

        keyValueConfigMapper.updateByPrimaryKey(keyValueConfig);

        operationLogService.updateDataAddLog(original, keyValueConfig, OperationModule.KeyValueConfig
                , updateKeyValueConfigDto.getUserName(), Message.Log.UpdateKeyValueConfiguration
                , keyValueConfig.getName(), "Operation content", logType);
    }

    public boolean isKeyValueDuplicated(String name) {
        KeyValueConfigExample example = new KeyValueConfigExample();
        example.createCriteria().andNameEqualTo(name);
        Optional<KeyValueConfig> keyValueConfig = keyValueConfigMapper.selectByExample(example).stream().findFirst();
        return keyValueConfig.isPresent();
    }

    public List<KeyValueConfigDisplayDto> getByOrgId(String orgId) {
        Organization organization = organizationMapper.selectByPrimaryKey(orgId);
        if (organization == null) {
            return new ArrayList<>();
        }
        KeyValueConfigExample example = new KeyValueConfigExample();
        example.createCriteria().andIndustryIdsLike(organization.getIndustryId());
        List<KeyValueConfig> list = keyValueConfigMapper.selectByExample(example);
        List<KeyValueConfigDisplayDto> result = new ArrayList<>();
        if (list.size() > 0) {
            Map<String, String> industryList = new HashMap<>();
            industryMapper.selectByExample(new IndustryExample()).forEach(a -> industryList.put(a.getId(), a.getName()));
            Map<String, String> serviceType = new HashMap<>();
            serviceTypeMapper.selectByExample(new ServiceTypeExample()).forEach(a -> serviceType.put(a.getId(), a.getName()));
            List<KeyValueReference> scopes = keyValueReferenceMapper.selectByExample(new KeyValueReferenceExample());
            for (KeyValueConfig item : list) {
                KeyValueConfigDisplayDto dtoObj = new KeyValueConfigDisplayDto();
                CommonUtils.copyProperties(item, dtoObj);
                dtoObj.setServiceTypes(getNamesByIds(item.getServiceTypeIds(), serviceType));
                dtoObj.setIndustrys(getNamesByIds(item.getIndustryIds(), industryList));
                dtoObj.setIndustryIDs(new ArrayList<>(Arrays.asList(item.getIndustryIds().split(","))));
                List<Integer> selectScopes = scopes.stream().filter(a -> a.getKeyValueConfigId().equals(item.getId()))
                        .map(KeyValueReference::getScope).collect(Collectors.toList());
                dtoObj.setScopeSummary(jointToString(selectScopes));
                result.add(dtoObj);
            }
        }
        return result;
    }

    private String jointToString(List<Integer> selectScopes) {
        StringBuilder scopeBuilder = new StringBuilder();
        for (Integer selectScope : selectScopes) {
            scopeBuilder.append(ApplyScope.getName(selectScope)).append(",");
        }
        return scopeBuilder.length() > 0 ? scopeBuilder.toString().substring(0, scopeBuilder.length() - 2) : "";
    }

    private String getNamesByIds(String source, Map<String, String> queryList) {
        if (StringUtils.isEmpty(source)) {
            return source;
        }
        String[] sArray = source.split(",");
        List<String> sName = new ArrayList<>();
        for (String s : sArray) {
            if (queryList.containsKey(s)) {
                sName.add(queryList.get(s));
            }
        }
        StringBuilder retStr = new StringBuilder();
        sName.forEach(s -> retStr.append(s).append(","));
        return retStr.toString().substring(0, retStr.length() - 2);
    }

}