纪念自己第一次在实践项目中编写后端代码，虽然很烂 ┭┮﹏┭┮

第一次在实践项目中编写后端代码，虽然很烂，但是功能实现了，还是很信心满满滴。。。。。。。。。。。。

package com.zenithchain.ebillv3.service.impl;

import com.aliyuncs.utils.StringUtils;
import com.zenithchain.ebillv3.common.CommonResult;
import com.zenithchain.ebillv3.component.HostHolder;
import com.zenithchain.ebillv3.dao.ParametersRuleChangeRecordMapper;
import com.zenithchain.ebillv3.po.ParametersRule;
import com.zenithchain.ebillv3.dao.ParametersRuleMapper;
import com.zenithchain.ebillv3.po.ParametersRuleChangeRecord;
import com.zenithchain.ebillv3.po.User;
import com.zenithchain.ebillv3.service.ParametersRuleService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.*;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author george
 * @since 2022-07-14
 */
@Service
public class ParametersRuleServiceImpl extends ServiceImpl<ParametersRuleMapper, ParametersRule> implements ParametersRuleService {
    //单日配置文件
    @Value("${ONE_DAY_PARAM_NAME}")
    private String oneDayParamName;
    @Value("${ONE_DAY_PARAM_VALUE}")
    private String oneDayParamValue;
    //单笔配置文件
    @Value("${SINGLE_PARAM_NAME}")
    private String singleParamName;
    @Value("${SINGLE_PARAM_VALUE}")
    private String singleParamValue;
    //预提现配置信息
    @Value("${WITHHOLDING_QUOTA_NAME}")
    private String withholdingQuotaName;
    @Value("${WITHHOLDING_QUOTA_VALUE}")
    private String withholdingQuotaValue;
    //账期转换日期
    @Value("${PAYMENT_DAYS_CONVERT_DATE}")
    private String paymentDaysConvertDateName;
    @Value("${PAYMENT_DAYS_CONVERT_DATE_VALUE}")
    private String paymentDaysConvertDateValue;
    //是否考虑欠款
    @Value("${DEBT}")
    private String debtName;
    @Value("${DEBT_VALUE}")
    private String debtValue;
    //最终付款日提前天数
    @Value("${END_ADVANCE_PAY_DATE}")
    private String endAdvancePayDateName;
    @Value("${END_ADVANCE_PAY_DATE_VALUE}")
    private String endAdvancePayDateValue;
    @Autowired
    private ParametersRuleMapper parametersRuleMapper;
    @Autowired
    private ParametersRuleChangeRecordMapper parametersRuleChangeRecordMapper;
    @Autowired
    private HostHolder hostHolder;

    protected User getUser() {
        return hostHolder.getUser();
    }


    /**
     * 数据拆分方法
     *
     * @param data
     * @return
     */
    public static Map<String, String> splitData(List<String> data) {
        Map<String, String> hashMap = new HashMap<>();
        String s = StringUtils.join(",", data);
        String s1 = s.replaceAll("[{}\"\"？|-]", "");
        String[] array = s1.split(",");
        List<String> stringList = new ArrayList<>();
        for (int i = 0; i < array.length; i++) {
            stringList.add(array[i]);
        }
        for (int i = 0; i < stringList.size(); i++) {
            array = stringList.get(i).split(":");
            for (int j = 0; j < array.length; j++) {
                int even = 0;
                int uneven = 0;
                if (j % 2 == 0) {
                    even = j;
                } else {
                    uneven = j;
                }
                hashMap.put(array[even], array[uneven]);
            }
        }
        return hashMap;
    }


    /**
     * 提现配置信息
     */
    //单日限额
    private ParametersRule parametersRuleOneDay(Integer supplierId, String paramName) {
        return parametersRuleMapper.getParameterBySupplierIdAndParamName(supplierId, paramName);
    }

    //单笔限额
    private ParametersRule parametersRuleSingle(Integer supplierId, String paramName) {
        return parametersRuleMapper.getParameterBySupplierIdAndParamName(supplierId, paramName);
    }

    /**
     * 预提现配置信息
     */
    //预提现限额
    private ParametersRule withholdingQuotaNameObject(Integer supplierId, String paramName) {
        return parametersRuleMapper.getParameterBySupplierIdAndParamName(supplierId, paramName);
    }

    /**
     * 预核销配置信息
     */
    //账期转换日期
    private ParametersRule paymentDaysConvertDateObject(Integer supplierId, String paramName) {
        return parametersRuleMapper.getParameterBySupplierIdAndParamName(supplierId, paramName);
    }

    //是否考虑欠款
    private ParametersRule debtObject(Integer supplierId, String paramName) {
        return parametersRuleMapper.getParameterBySupplierIdAndParamName(supplierId, paramName);
    }

    // 最终付款日提前天数
    private ParametersRule endAdvancePayDateObject(Integer supplierId, String paramName) {
        return parametersRuleMapper.getParameterBySupplierIdAndParamName(supplierId, paramName);
    }

    /**
     * 查询参数配置信息
     *
     * @param supplierId
     * @return
     */
    @Override
    public CommonResult getParameter(Integer supplierId) {
        Map<String, Object> map = new HashMap<>();
        //获取当前年月
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        Date date = new Date();

        ParametersRule oneDayParamObject = parametersRuleOneDay(supplierId, oneDayParamName);
        ParametersRule singleParamObject = parametersRuleSingle(supplierId, singleParamName);
        ParametersRule withholdingQuotaObject = withholdingQuotaNameObject(supplierId, withholdingQuotaName);
        ParametersRule paymentDaysConvertDateObject = paymentDaysConvertDateObject(supplierId, paymentDaysConvertDateName);
        ParametersRule debtObject = debtObject(supplierId, debtName);
        ParametersRule endAdvancePayDateObject = endAdvancePayDateObject(supplierId, endAdvancePayDateName);
        if (oneDayParamObject != null && singleParamObject != null) {
            oneDayParamValue = oneDayParamObject.getParamValue();
            singleParamValue = singleParamObject.getParamValue();
        } else {
            oneDayParamValue = "10000000";
            singleParamValue = "1000000";
        }
        if (withholdingQuotaObject != null) {
            withholdingQuotaValue = withholdingQuotaObject.getParamValue();
        } else {
            withholdingQuotaValue = "1000000";
        }
        if (paymentDaysConvertDateObject != null && debtObject != null && endAdvancePayDateObject != null) {
            paymentDaysConvertDateValue = paymentDaysConvertDateObject.getParamValue();
            debtValue = debtObject.getParamValue();
            endAdvancePayDateValue = endAdvancePayDateObject.getParamValue();
        } else {
            paymentDaysConvertDateValue = "15";
            debtValue = "true";
            endAdvancePayDateValue = "10";
        }
        map.put(oneDayParamName, oneDayParamValue);
        map.put(singleParamName, singleParamValue);
        map.put(withholdingQuotaName, withholdingQuotaValue);
        map.put(paymentDaysConvertDateName, paymentDaysConvertDateValue);
        map.put(debtName, debtValue);
        map.put(endAdvancePayDateName, endAdvancePayDateValue);
        map.put("years", sdf.format(date));
        return CommonResult.success(map);
    }

    /**
     * 修改参数配置信息
     *
     * @param data
     * @return
     */
    @Override
    public CommonResult updateParameter(List<String> data) {
        /**
         *获取当前时间
         */
        Date date = new Date(System.currentTimeMillis());
        /**
         * 前端数据通过拆分存放到Map中
         */
        Map<String, String> hashMap = splitData(data);
        /**
         *获取供应商ID
         */
        String supplierId = hashMap.get("companyId");
        Integer supplierIdAndInt = Integer.valueOf(supplierId);
        /**
         * 获取类型
         */
        String paramType = hashMap.get("paramType");
        List<ParametersRule> parametersRuleList = new ArrayList<ParametersRule>();


        switch (paramType) {
            case "提现":
                /**
                 * 提现配置信息
                 */
                ParametersRule oneDayParamObject = parametersRuleOneDay(supplierIdAndInt, oneDayParamName);
                ParametersRule singleParamObject = parametersRuleSingle(supplierIdAndInt, singleParamName);

                if (oneDayParamObject == null && singleParamObject == null) {
                    //插入数据
                    parametersRuleMapper.insertParameter(hashMap.get("oneDayQuotaParamNameCn"), oneDayParamName, hashMap.get("oneDayQuota"), hashMap.get("paramType"),
                            date, getUser().getId(), supplierIdAndInt);
                    parametersRuleMapper.insertParameter(hashMap.get("singleQuotaParamNameCn"), singleParamName, hashMap.get("singleQuota"), hashMap.get("paramType"),
                            date, getUser().getId(), supplierIdAndInt);
                } else {
                    parametersRuleList.add(oneDayParamObject);
                    parametersRuleList.add(singleParamObject);
                    compareValue(hashMap, parametersRuleList);
                    //修改数据
                    Map updateHashMap = new HashMap<String, Object>();
                    //当前端传来的数据 与  数据库数据不同 才修改
                    if (!oneDayParamObject.getParamValue().equals(hashMap.get("oneDayQuota"))) {
                        updateHashMap.put("paramName", oneDayParamName);
                        updateHashMap.put("paramValue", hashMap.get("oneDayQuota"));
                        updateHashMap.put("supplierId", hashMap.get("companyId"));
                        parametersRuleMapper.updateParameter(updateHashMap);
                    }
                    if (!singleParamObject.getParamValue().equals(hashMap.get("singleQuota"))) {
                        updateHashMap.put("paramName", singleParamName);
                        updateHashMap.put("paramValue", hashMap.get("singleQuota"));
                        updateHashMap.put("supplierId", hashMap.get("companyId"));
                        parametersRuleMapper.updateParameter(updateHashMap);
                    }
                }
                break;
            case "预核销":
                /**
                 * 预核销配置信息
                 */
                if (hashMap.get("debt").equals("3")) {
                    hashMap.replace("debt", "3", "true");
                } else {
                    hashMap.replace("debt", "6", "false");
                }
                ParametersRule paymentDaysConvertDateObject = paymentDaysConvertDateObject(supplierIdAndInt, paymentDaysConvertDateName);
                ParametersRule debtObject = debtObject(supplierIdAndInt, debtName);
                ParametersRule endAdvancePayDateObject = endAdvancePayDateObject(supplierIdAndInt, endAdvancePayDateName);

                if (paymentDaysConvertDateObject == null && debtObject == null && endAdvancePayDateObject == null) {
                    //插入数据
                    parametersRuleMapper.insertParameter(hashMap.get("paymentDaysConvertDateCn"), paymentDaysConvertDateName, hashMap.get("paymentDaysConvertDate"), hashMap.get("paramType"),
                            date, getUser().getId(), supplierIdAndInt);
                    parametersRuleMapper.insertParameter(hashMap.get("debtCn"), debtName, hashMap.get("debt"), hashMap.get("paramType"),
                            date, getUser().getId(), supplierIdAndInt);
                    parametersRuleMapper.insertParameter(hashMap.get("endAdvancePayDateCn"), endAdvancePayDateName, hashMap.get("endAdvancePayDate"), hashMap.get("paramType"),
                            date, getUser().getId(), supplierIdAndInt);
                } else {
                    parametersRuleList.add(paymentDaysConvertDateObject);
                    parametersRuleList.add(debtObject);
                    parametersRuleList.add(endAdvancePayDateObject);
                    compareValue(hashMap, parametersRuleList);
                    //修改数据
                    Map updateHashMap = new HashMap<String, Object>();
                    if (!paymentDaysConvertDateObject.getParamValue().equals(hashMap.get("paymentDaysConvertDate"))) {
                        updateHashMap.put("paramName", paymentDaysConvertDateName);
                        updateHashMap.put("paramValue", hashMap.get("paymentDaysConvertDate"));
                        updateHashMap.put("supplierId", hashMap.get("companyId"));
                        parametersRuleMapper.updateParameter(updateHashMap);
                    }
                    if (!paymentDaysConvertDateObject.getParamValue().equals(hashMap.get("debt"))) {
                        updateHashMap.put("paramName", debtName);
                        updateHashMap.put("paramValue", hashMap.get("debt"));
                        updateHashMap.put("supplierId", hashMap.get("companyId"));
                        parametersRuleMapper.updateParameter(updateHashMap);
                    }
                    if (!paymentDaysConvertDateObject.getParamValue().equals(hashMap.get("endAdvancePayDate"))) {
                        updateHashMap.put("paramName", endAdvancePayDateName);
                        updateHashMap.put("paramValue", hashMap.get("endAdvancePayDate"));
                        updateHashMap.put("supplierId", hashMap.get("companyId"));
                        parametersRuleMapper.updateParameter(updateHashMap);
                    }

                }
                break;
            case "预提现":
                /**
                 * 预提现配置信息
                 */
                ParametersRule withholdingQuotaObject = withholdingQuotaNameObject(supplierIdAndInt, withholdingQuotaName);
                parametersRuleList.add(withholdingQuotaObject);

                if (withholdingQuotaObject == null) {
                    //插入数据
                    parametersRuleMapper.insertParameter(hashMap.get("withholdingQuotaCn"), withholdingQuotaName, hashMap.get("withholdingQuota"), hashMap.get("paramType"),
                            date, getUser().getId(), supplierIdAndInt);
                } else {
                    compareValue(hashMap, parametersRuleList);
                    //修改数据
                    Map updateHashMap = new HashMap<String, Object>();
                    if (!withholdingQuotaObject.getParamValue().equals(hashMap.get("withholdingQuota"))) {
                        updateHashMap.put("paramName", withholdingQuotaName);
                        updateHashMap.put("paramValue", hashMap.get("withholdingQuota"));
                        updateHashMap.put("supplierId", hashMap.get("companyId"));
                        parametersRuleMapper.updateParameter(updateHashMap);
                    }
                }
        }

        return CommonResult.success(data);
    }

    /**
     * 比较值是否修改过
     */
    private void compareValue(Map<String, String> hashMap, List<ParametersRule> parametersRuleList) {
        /**
         *获取当前时间
         */
        LocalDateTime dateTime = LocalDateTime.now();
        JSONArray retArray = new JSONArray();
        JSONObject jsonObject = new JSONObject();
        ParametersRuleChangeRecord parametersRuleChangeRecord = null;
        // 若不是空就执行...
        if (!parametersRuleList.isEmpty()) {
            for (int i = 0; i < parametersRuleList.size(); i++) {
                ParametersRule parametersRule = parametersRuleList.get(i);
                if (!hashMap.get(parametersRule.getParamName()).equals(parametersRule.getParamValue())) {
                    jsonObject.put("title", parametersRule.getParamNameCn());
                    jsonObject.put("beforeVal", parametersRule.getParamValue());
                    jsonObject.put("afterVal", hashMap.get(parametersRule.getParamName()));
                    retArray.add(jsonObject);
                }
                parametersRuleChangeRecord = setParametersRuleChangeRecord(getUser().getNickName(),
                        hashMap.get("paramType"), dateTime, retArray.toString(), parametersRule.getId(), parametersRule.getSupplierId());
            }
            parametersRuleChangeRecordMapper.insert(parametersRuleChangeRecord);
        }
    }

    /**
     * 参数规则历史变更记录
     *
     * @return
     */
    private ParametersRuleChangeRecord setParametersRuleChangeRecord(String operationName, String operationType,
                                                                     LocalDateTime operationTime, String diffData, Integer parameterId, Integer supplierId) {
        ParametersRuleChangeRecord parametersRuleChangeRecord = new ParametersRuleChangeRecord();
        parametersRuleChangeRecord.setOperationName(operationName);
        parametersRuleChangeRecord.setOperationType(operationType);
        parametersRuleChangeRecord.setOperationTime(operationTime);
        parametersRuleChangeRecord.setDiffData(diffData);
        parametersRuleChangeRecord.setParamId(parameterId);
        parametersRuleChangeRecord.setSupplierId(supplierId);
        return parametersRuleChangeRecord;
    }


}