通过设置规则生成各种单据编号(二)

**获取业务编号代码**
/**
*seqCode : 业务单据类型Code
*(code==0 成功, 其他均失败, msg= 新业务编号 || 错误提示)
*/
public Map<String, String> generateSequence(String seqCode){
        //返回参数
        Map<String, String> retMap = new HashMap<String, String>();  
        //生成编号   
        String sequence = "";
        // 参数校验
        if (StringUtils.isEmpty(seqCode)){
            retMap.put("code", "1001");
            retMap.put("msg", "参数错误：业务编码编号");
            return retMap;
        }
        //根据业务单类型code获取对应的编码信息
        SysSeq seq = getDao(SequenceMapper.class).findBySeqCode(seqCode);
        //根据对应的编码信息，查询对应的编号生成规则
        if (seq!= null){
            List<SysSeqRule> seqRuleList =getDao(SequenceRuleMapper.class).findBySeqCode(seq.getSeqCode());
            //规则的条数小于1，说明未配置规则  
            if (seqRuleList.size()<1){
                retMap.put("code", "1005");
                retMap.put("msg", "未查询到业务编码对应的编码规则配置, 请检查编码规则配置!");
                return retMap;
            }
            int delimiterNum = 0;
            for (SysSeqRule rule : seqRuleList){
                delimiterNum++;
                switch (rule.getRuleCode()) {
                    //常量方式
                    case "const":               
                        sequence += rule.getRuleValue();
                        break;
                    //计数
                    case "numbering":     
                        //重置规则      
                        Integer num = currentReset(seq, rule);      
                        //计数拼接
                        sequence += numberingSeqRule(rule, num);   
                        //更新当前序号, 当前序号+步长 
                        seq.setCurrentNo(num + seq.getStep());      
                        break;
                    //时间戳    
                    case "timestamp":           
                        sequence += DateUtils.getDate(rule.getRuleValue());
                        break;
                    //参数
                    case "param":               
                        if(StringUtils.isNotEmpty(seqParam)){
                            sequence += seqParam;
                        }else {
                            retMap.put("code", "1008");
                            retMap.put("msg", "编码规则类型为参数类型，请传递参数！");
                            return retMap;
                        }
                        break;
                }
                if (StringUtils.isNotEmpty(seq.getDelimiter()) && delimiterNum!= seqRuleList.size())
        {           //分隔符
                    sequence += seq.getDelimiter();     
                }
            }
            //当前编号
            seq.setCurrentCode(sequence);
            //当前重置依赖               
            seq.setCurrentReset(DateUtils.getDate("yyyyMMdd"));     

            SysSeqValue seqValue = new SysSeqValue(
                   null,null,null,
                    seq.getId(),seqCode,
                    null, null,
                    seq.getCurrentNo(),seq.getCurrentCode(),seq.getCurrentReset()
            );
            //单据关联值 存储
            getDao(SequenceValueMapper.class).insert(seqValue);;     
            if (seqValue.getId() >0){
                //更新规则 当前编码
                getDao(SequenceMapper.class).updateCurrentCode(seq);    
                retMap.put("code", "0");
                retMap.put("msg", sequence);
                logger.info("生成业务编号 : "+sequence);
            }else{
                retMap.put("code", "1006");
                retMap.put("msg", "业务编号生成失败, 请重试!");
            }
        }else{
            retMap.put("code", "1004");
            retMap.put("msg", "未查询到业务编码,请检查业务编码编号是否正确!");
        }
        return retMap;
    }

    /**
     * 计数 方式 重置规则
     * @return
     */
private Integer currentReset(SysSeq seq, SysSeqRule seqRule){
        Integer no = null;
        Integer ruleNo;
        try {
            ruleNo = Integer.parseInt(seqRule.getRuleValue());
        }catch (Exception e){
            return 1;
        }

        switch (seq.getResetRule()) {
            case "day":      //每天重置
                String resetDate1 = seq.getCurrentReset();
                SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");
                if(!StringUtils.isBlank(resetDate1)&&!resetDate1.equals(formatter.format(new Date()))){
                    return 1;
                }
                break;
            case "month":    //每月重置
                String resetDate = seq.getCurrentReset().substring(seq.getCurrentReset().length() - 2);
                //每个月 的 28/29/30/31 号进行判断  因.每月最后一天 只有这4种情况
                if (resetDate.equals("28") || resetDate.equals("29") ||
                        resetDate.equals("30") || resetDate.equals("31")) {
                    // 判断当前时间是否是每月第一天, 如果是: 重置规则, 使用初始的值
                    if (DateUtils.getDay().equals("01")) {
                        no = ruleNo;
                    }
                }
                break;
            case "year":    //每年重置
                // 当前时间 = 1月1号 且 当前重置 != 1月1号
                if (DateUtils.getDate("yyyyMMdd").contains("0101") && !seq.getCurrentReset().contains("0101")) {
                    no = ruleNo;
                }
                break;
        }
        if (no == null){
            if (seq.getCurrentNo() == null || seq.getCurrentNo()==0){
                return ruleNo;
            }else {
                return seq.getCurrentNo();
            }
        }
        return no;
    }

 /**
     * 计数规则
     * @param seqRule
     * @return
     */
    private String numberingSeqRule(SysSeqRule seqRule, Integer code){
        String str = "" ;
        int codeConst = seqRule.getPaddingWide() - sizeOfInt(code);    //需要对其位数
        if (codeConst > 0) {
            String st = org.apache.commons.lang3.StringUtils.repeat("0", codeConst);   //补位
            if (seqRule.getPaddingSide().equals("left")){            //左对齐
                str+= code + st;
            } else if (seqRule.getPaddingSide().equals("right")){    //右对齐
                str+= st + code;
            }
        }else {
            str+= code;
        }

        return str;
    }