Merge remote-tracking branch 'origin/master'

 Source/UBCS-WEB/src/components/BatchImport/index.vue

@@ -148,9 +148,15 @@
          classifyAttr: this.classifyAttr,

        };

      } else if (this.type === "batchImportApply") {

        const secDTOList = this.localSecVOList.map(item => {

            return {

              secOid: item.oid,

              secValue: this.codeApplyForm[item.id]

            }

          })

        return {

          codeClassifyOid: this.codeClassifyOid,

          secDTOList: this.secDTOList,

          secDTOList: JSON.stringify(secDTOList),

          ...this.codeApplyForm,

        };

      } else if (this.type === "batchApplyCode") {


 Source/UBCS-WEB/src/mixins/codeApply.js

@@ -3,6 +3,7 @@
  data() {

    return {

      secVOList: [],

      localSecVOList: [],

      showCodeApply: false,

      selfColumnType: {

        codefixedsec: "combox",

@@ -57,13 +58,13 @@
            "coderefersec",

          ];

          this.secVOList = res.data.data.secVOList || []

          let localSecVOList = (res.data.data.secVOList || []).filter((item) =>

          this.localSecVOList = (res.data.data.secVOList || []).filter((item) =>

            typeList.includes(item.secType)

          );

          if (localSecVOList.length > 0) {

          if (this.localSecVOList.length > 0) {

            this.showCodeApply = true

            this.$nextTick(() => {

              this.$refs.CodeApply.templateRender(localSecVOList);

              this.$refs.CodeApply.templateRender(this.localSecVOList);

            });

          }




 Source/UBCS-WEB/src/views/modeling/originalAdd.vue

@@ -297,17 +297,17 @@
        submitAttribute() {
            const that = this;
            if (that.referInitFlag && that.referEditFlag){
                this.$delete(this.attribute,'dictCode');
                this.$delete(this.attribute,'dictKey');
                this.$delete(this.attribute,'dictValue');
                this.$delete(this.attribute,'usingDict');
                this.$set(this.attribute,'dictCode','');
                this.$set(this.attribute,'dictKey','');
                this.$set(this.attribute,'dictValue','');
                this.$set(this.attribute,'usingDict','');
            }
            if (that.enumInitFlag && that.enumEditFlag){
                this.$delete(this.attribute,'referTypeCode');
                this.$delete(this.attribute,'referTypeKey');
                this.$delete(this.attribute,'referTypeValue');
                this.$delete(this.attribute,'referToId');
                this.$delete(this.attribute,'referToName');
                this.$set(this.attribute,'referTypeCode','');
                this.$set(this.attribute,'referTypeKey','');
                this.$set(this.attribute,'referTypeValue','');
                this.$set(this.attribute,'referToId','');
                this.$set(this.attribute,'referToName','');
            }
            this.$refs.form.validate(function (pass, field) {
                if (pass) {

 Source/UBCS/ubcs-ops/ubcs-flow/src/main/java/com/vci/ubcs/flow/engine/service/impl/VCIFlowserviceImpl.java

@@ -62,6 +62,8 @@
    private final ProcessStageAttrService processStageAttrService;

    private static String MODELKEY = "modelKey";//前端传过来的模型key
    private static String TASKID = "taskId";//前端传过来的模型key
    private static String PROCESSINSTANCEID = "processInstanceId";//前端传过来的模型key
    @Override
    public R<BladeFlow> startProcess(FlowTaskDTO flowTaskUserC){
        Map<String, Object> kvv = flowTaskUserC.getVariables();
@@ -228,16 +230,10 @@
            flowTaskDTO.setVariables(variables);
        }

        String templateId = variables.get("templateId").toString();
        //流程阶段
        Map<String, Object> m = new HashMap<>();
        m.put("template_id", templateId);
        m.put("task_id", crruentActivityId);
        m.put("model_key", modelKey);
        QueryWrapper q = Condition.getQueryWrapper(m, ProcessStageAttr.class)
            .select("attr_id attrId,attr_name attrName,attr_group attrGroup");
        List<ProcessStageAttr> stageAttrs = processStageAttrService.list(q);
        flowTaskDTO.setStageAttrs(stageAttrs);

        //放入流程阶段、流程modelkey
        variables.put(TASKID,crruentActivityId);
        variables.put(PROCESSINSTANCEID,processInstanceId);
        return flowTaskDTO;
    }
}

 Source/UBCS/ubcs-service-api/ubcs-omd-api/src/main/java/com/vci/ubcs/omd/constant/BtmTypeConstant.java

@@ -54,6 +54,16 @@
    public static final String LIFE_CYCLE_EVENT = "lifeCycleEvent";

    /**
     * ç”Ÿå‘½å‘¨æœŸçš„节点
     */
    public static final String LIFE_CYCLE_NODE = "lifeCycleNode";

    /**
     * ç”Ÿå‘½å‘¨æœŸçš„连接线信息
     */
    public static final String LIFE_CYCLE_EDGE = "lifeCycleEdge";

    /**
     * ç”Ÿå‘½å‘¨æœŸè¿žæŽ¥çº¿çš„业务类型名称
     */
    public static final String LIFE_CYCLE_LINE = "lifeCycleLine";

 Source/UBCS/ubcs-service-api/ubcs-util-api/src/main/java/com/vci/ubcs/starter/web/pagemodel/BaseQueryObject.java

@@ -8,6 +8,7 @@

import com.alibaba.fastjson.annotation.JSONField;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.springblade.core.mp.support.Query;

import java.io.Serializable;
import java.util.HashMap;
@@ -103,10 +104,15 @@
        this.limit = limit;
    }

    /**
     * ä»Žä»¥å‰çš„项目拷贝过来的分页
     * @return
     */
    @JSONField(
        serialize = false,
        deserialize = false
    )
    @Deprecated
    public PageHelper getPageHelper() {
        PageHelper pageHelper = new PageHelper(this.limit);
        pageHelper.setPage(this.getPage());
@@ -115,6 +121,7 @@
        return pageHelper;
    }


    public BaseQueryObject addSort(String sort, String order) {
        this.setSort(StringUtils.isBlank(this.getSort()) ? sort : this.getSort() + "," + sort);
        this.setOrder(StringUtils.isBlank(this.getOrder()) ? order : this.getOrder() + "," + order);

 Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/controller/LifeCycleController.java

@@ -9,6 +9,7 @@
import com.vci.ubcs.omd.vo.LifeCycleVO;
import com.vci.ubcs.omd.wrapper.LifeCycleRuleWrapper;
import com.vci.ubcs.starter.web.pagemodel.BaseQueryObject;
import com.vci.ubcs.starter.web.pagemodel.BladeQueryObject;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
@@ -43,12 +44,12 @@
    @GetMapping("page")
    @ApiOperationSupport(order = 2)
    @ApiOperation(value = "分页查询生命周期",notes = "分页查询生命周期")
    public R<IPage<LifeCycleVO>> page(BaseQueryObject baseQueryObject){
        Map<String, String> conditionMap = baseQueryObject.getConditionMap();
    public R<IPage<LifeCycleVO>> page(BladeQueryObject baseQueryObject){
        Map<String, Object> conditionMap = baseQueryObject.getConditionMap();
        if (conditionMap == null){
            conditionMap = new HashMap<>();
        }
        return R.data(lifeCycleService.listLife(conditionMap,baseQueryObject.getPageHelper()));
        return R.data(lifeCycleService.listLife(conditionMap,baseQueryObject.getQuery()));
    }



 Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/feign/BtmTypeClient.java

@@ -171,6 +171,7 @@
     * @return é»˜è®¤å­—段属性
     */
    @Override
    @GetMapping(GET_DEFAULT_ATTR_BY_BTM_ID)
    public R<BtmTypeVO> getDefaultAttrByBtmId(String btmTypeId) {
        return R.data(Optional.ofNullable(btmTypeService.getDefaultAttrByBtmId(btmTypeId)).orElseGet(BtmTypeVO::new));
    }
@@ -182,6 +183,7 @@
     * @return æ‰€æœ‰å­—段
     */
    @Override
    @GetMapping(GET_ALL_ATTR_BY_BTM_ID)
    public R<BtmTypeVO> getAllAttributeByBtmId(String btmTypeId) {
        return R.data(Optional.ofNullable(btmTypeService.getAllAttributeByBtmId(btmTypeId)).orElseGet(BtmTypeVO::new));
    }
@@ -193,6 +195,7 @@
     * @return æ‰€æœ‰å­—段
     */
    @Override
    @GetMapping(GET_ALL_ATTR_BY_BTM_OID)
    public R<BtmTypeVO> getAllAttributeByBtmOid(String btmTypeOid) {
        return R.data(Optional.ofNullable(btmTypeService.getAllAttributeByBtmOid(btmTypeOid)).orElseGet(BtmTypeVO::new));
    }

 Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/mapper/LifeCycleEdgeMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
package com.vci.ubcs.omd.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.vci.ubcs.omd.entity.LifeCycleEdge;

/**
 * ç”Ÿå‘½å‘¨æœŸçš„连接线
 * @author weidy
 * @date 2023/7/4
 */
public interface LifeCycleEdgeMapper extends BaseMapper<LifeCycleEdge> {
}

 Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/mapper/LifeCycleLineEventMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,13 @@
package com.vci.ubcs.omd.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.vci.ubcs.omd.dto.LifeCycleLineEventDTO;
import com.vci.ubcs.omd.entity.LifeCycleLineEvent;

/**
 * ç”Ÿå‘½å‘¨æœŸè¿žæŽ¥çº¿çš„事件
 * @author weidy
 * @date 2023/7/4
 */
public interface LifeCycleLineEventMapper extends BaseMapper<LifeCycleLineEvent> {
}

 Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/mapper/LifeCycleNodeMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
package com.vci.ubcs.omd.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.vci.ubcs.omd.entity.LifeCycleNode;

/**
 * ç”Ÿå‘½å‘¨æœŸçš„节点存储
 * @author weidy
 * @date 2023/7/4
 */
public interface LifeCycleNodeMapper extends BaseMapper<LifeCycleNode> {
}

 Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/service/IBtmTypeService.java

@@ -250,4 +250,18 @@
     * @return ä¸šåŠ¡ç±»åž‹
     */
    BtmTypeVO getAllAttributeByBtmOid(String btmTypeOid);

    /**
     * èŽ·å–引用某个生命周期的业务类型
     * @param lifeOid ç”Ÿå‘½å‘¨æœŸçš„主键
     * @return ä¸šåŠ¡ç±»åž‹æ˜¾ç¤ºå¯¹è±¡
     */
    List<BtmTypeVO> selectByLifeId(String lifeId);

    /**
     * ç»Ÿè®¡å¼•ç”¨æŸä¸ªç”Ÿå‘½å‘¨æœŸçš„业务类型
     * @param lifeOid ç”Ÿå‘½å‘¨æœŸçš„主键
     * @return ä¸ªæ•°
     */
    Integer countByLifeId(String lifeId);
}

 Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/service/ILifeCycleService.java

@@ -7,6 +7,7 @@
import com.vci.ubcs.omd.vo.BtmTypeVO;
import com.vci.ubcs.omd.vo.LifeCycleVO;
import com.vci.ubcs.starter.web.pagemodel.PageHelper;
import org.springblade.core.mp.support.Query;

import java.util.List;
import java.util.Map;
@@ -21,10 +22,10 @@
    /**
     * èŽ·å–生命周期列表
     * @param conditionMap æŸ¥è¯¢æ¡ä»¶
     * @param pageHelper åˆ†é¡µ
     * @param query åˆ†é¡µ
     * @return ç”Ÿå‘½å‘¨æœŸçš„显示对象
     */
    IPage<LifeCycleVO> listLife(Map<String, String> conditionMap, PageHelper pageHelper);
    IPage<LifeCycleVO> listLife(Map<String, Object> conditionMap, Query query);

    /**
     * æ·»åŠ ä¿å­˜

 Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/service/impl/BtmTypeServiceImpl.java

@@ -4,6 +4,7 @@
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.api.exception.NacosException;
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.vci.ubcs.omd.constant.BtmTypeConstant;
@@ -868,4 +869,36 @@
        btmType.setAttributes(btmTypeAttributeService.getAllAttribute(btmType));
        return btmType;
    }

    /**
     * èŽ·å–引用某个生命周期的业务类型
     *
     * @param lifeId ç”Ÿå‘½å‘¨æœŸçš„编号
     * @return ä¸šåŠ¡ç±»åž‹æ˜¾ç¤ºå¯¹è±¡
     */
    @Override
    public List<BtmTypeVO> selectByLifeId(String lifeId) {
        if(StringUtils.isBlank(lifeId)){
            return new ArrayList<>();
        }
        LambdaQueryWrapper<BtmType> query = new LambdaQueryWrapper<BtmType>();
        query.eq(BtmType::getLifeCycleId,lifeId);
        return BtmTypeWrapper.build().listEntityVO(getBaseMapper().selectList(query));
    }

    /**
     * ç»Ÿè®¡å¼•ç”¨æŸä¸ªç”Ÿå‘½å‘¨æœŸçš„业务类型
     *
     * @param lifeId ç”Ÿå‘½å‘¨æœŸçš„编号
     * @return ä¸ªæ•°
     */
    @Override
    public Integer countByLifeId(String lifeId) {
        if(StringUtils.isBlank(lifeId)){
            return 0;
        }
        LambdaQueryWrapper<BtmType> query = new LambdaQueryWrapper<BtmType>();
        query.eq(BtmType::getLifeCycleId,lifeId);
        return baseMapper.selectCount(query).intValue();
    }
}

 Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/service/impl/LifeCycleServiceImpl.java

@@ -1,18 +1,49 @@
package com.vci.ubcs.omd.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vci.ubcs.omd.constant.BtmTypeConstant;
import com.vci.ubcs.omd.dto.LifeCycleDTO;
import com.vci.ubcs.omd.dto.LifeCycleEdgeDTO;
import com.vci.ubcs.omd.dto.LifeCycleLineEventDTO;
import com.vci.ubcs.omd.dto.LifeCycleNodeDTO;
import com.vci.ubcs.omd.entity.LifeCycleEdge;
import com.vci.ubcs.omd.entity.LifeCycleLineEvent;
import com.vci.ubcs.omd.entity.LifeCycleNode;
import com.vci.ubcs.omd.entity.LifeCycleRule;
import com.vci.ubcs.omd.mapper.LifeCycleEdgeMapper;
import com.vci.ubcs.omd.mapper.LifeCycleLineEventMapper;
import com.vci.ubcs.omd.mapper.LifeCycleMapper;
import com.vci.ubcs.omd.mapper.LifeCycleNodeMapper;
import com.vci.ubcs.omd.repeater.DomainRepeater;
import com.vci.ubcs.omd.service.IBtmTypeService;
import com.vci.ubcs.omd.service.ILifeCycleService;
import com.vci.ubcs.omd.service.IStatusService;
import com.vci.ubcs.omd.vo.BtmTypeVO;
import com.vci.ubcs.omd.vo.LifeCycleVO;
import com.vci.ubcs.starter.web.pagemodel.PageHelper;
import com.vci.ubcs.omd.vo.StatusVO;
import com.vci.ubcs.omd.wrapper.LifeCycleRuleWrapper;
import com.vci.ubcs.starter.enumpack.NewAppConstantEnum;
import com.vci.ubcs.starter.exception.VciBaseException;
import com.vci.ubcs.starter.web.constant.RegExpConstant;
import com.vci.ubcs.starter.web.util.BeanUtil;
import com.vci.ubcs.starter.web.util.VciBaseUtil;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.mp.support.Query;
import org.springblade.core.secure.utils.AuthUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;


/**
 * ç”Ÿå‘½å‘¨æœŸçš„服务
@@ -22,17 +53,49 @@
@Service
public class LifeCycleServiceImpl  extends ServiceImpl<LifeCycleMapper, LifeCycleRule> implements ILifeCycleService{

    /**
     * èŠ‚点的数据层
     */
    @Resource
    private LifeCycleNodeMapper nodeMapper;

    /**
     * è¿žæŽ¥çº¿æ•°æ®å±‚
     */
    @Resource
    private LifeCycleEdgeMapper edgeMapper;

    /**
     * çŠ¶æ€
     */
    @Autowired(required = false)
    @Lazy
    private IStatusService statusService;

    /**
     * è¿žæŽ¥çº¿çš„事件
     */
    @Resource
    private LifeCycleLineEventMapper lineEventMapper;

    /**
     * ä¸šåŠ¡ç±»åž‹çš„服务
     */
    @Autowired(required = false)
    @Lazy
    private IBtmTypeService btmTypeService;


    /**
     * èŽ·å–生命周期列表
     *
     * @param conditionMap æŸ¥è¯¢æ¡ä»¶
     * @param pageHelper   åˆ†é¡µ
     * @param query   åˆ†é¡µ
     * @return ç”Ÿå‘½å‘¨æœŸçš„显示对象
     */
    @Override
    public IPage<LifeCycleVO> listLife(Map<String, String> conditionMap, PageHelper pageHelper) {
        return null;
    public IPage<LifeCycleVO> listLife(Map<String, Object> conditionMap, Query query) {
        return LifeCycleRuleWrapper.build().pageVO(baseMapper.selectPage(Condition.getPage(query),Condition.getQueryWrapper(conditionMap,LifeCycleRule.class).lambda().orderByAsc(LifeCycleRule::getId)));
    }

    /**
@@ -42,9 +105,160 @@
     * @return æ·»åŠ åŽçš„显示对象
     */
    @Override
    @Transactional
    public LifeCycleVO addSave(LifeCycleDTO lifeCycleDTO) {
        return null;
        VciBaseUtil.alertNotNull(lifeCycleDTO,"生命周期信息",lifeCycleDTO.getId(),"生命周期的编号",lifeCycleDTO.getName(),"生命周期名称",lifeCycleDTO.getNodes(),"生命周期的节点",lifeCycleDTO.getStartStatus(),"起始状态");
        //先查询是否存在
        QueryWrapper wrapper = new QueryWrapper(LifeCycleRule.class);
        wrapper.eq("lower(id)",lifeCycleDTO.getId().toLowerCase(Locale.ROOT));
        if(baseMapper.selectCount(wrapper)>0){
            throw new VciBaseException("生命周期的编号不能重复");
        }
        String lifeOid = addLifeCycle(lifeCycleDTO);
        return LifeCycleRuleWrapper.build().entityVO(baseMapper.selectById(lifeOid));
    }

    /**
     * æ·»åŠ ç”Ÿå‘½å‘¨æœŸ
     * @param lifeCycleDTO
     * @return ä¸»é”®
     */
    private String addLifeCycle(LifeCycleDTO lifeCycleDTO){
        //编号不能有特殊的内容
        if(!lifeCycleDTO.getId().matches(RegExpConstant.LETTER)){
            throw new VciBaseException("生命周期的编号只能是字母");
        }
        LifeCycleRule life = LifeCycleRuleWrapper.build().copyDTO2DO(lifeCycleDTO);
        life.setOid(VciBaseUtil.getPk());
        String creator = AuthUtil.getUserAccount();
        Date now = new Date();
        life.setBtmname(BtmTypeConstant.LIFE_CYCLE);
        life.setOwner(creator);
        life.setCreator(creator);
        life.setCreateTime(now);
        life.setLastModifier(creator);
        life.setLastModifyTime(now);
        life.setTs(now);

        List<String> statusList = new ArrayList<>();
        //处理节点
        if(!CollectionUtils.isEmpty(lifeCycleDTO.getNodes())){
            lifeCycleDTO.getNodes().stream().forEach(nodeDTO->{
                addLifeCycleNode(nodeDTO,life.getOid(),creator,now);
                statusList.add(nodeDTO.getId());
            });
        }
        if(!statusList.contains(life.getStartStatus())){
            throw new VciBaseException("起始状态不在生命周期的画布中");
        }
        //判断所有的节点在系统里都存在
        List<String> existStatusIdList = statusService.listStatusByIdCollection(statusList).stream().map(StatusVO::getId).collect(Collectors.toList());
        String unExistStatus = statusList.stream().filter(s -> !existStatusIdList.contains(s)).collect(Collectors.joining(","));
        if(StringUtils.hasLength(unExistStatus)){
            throw new VciBaseException(unExistStatus + "这些状态在状态池里不存在，不能添加到生命周期中");
        }
        //处理边界和连接线
        if(!CollectionUtils.isEmpty(lifeCycleDTO.getEdges())){
            lifeCycleDTO.getEdges().stream().forEach(edgeDTO->{
                String edgeOid = addLifeCycleEdge(edgeDTO,statusList,life.getOid(),creator,now);
                if(!CollectionUtils.isEmpty(edgeDTO.getEvents())){
                    //有事件
                    edgeDTO.getEvents().stream().forEach(eventDTO->{
                        addLifeCycleLineEvent(eventDTO,edgeOid,creator,now);
                    });
                }
            });
        }
        baseMapper.insert(life);
        return life.getOid();
    }

    /**
     * æ·»åŠ ç”Ÿå‘½å‘¨æœŸçš„连接线上的事件
     * @param eventDTO
     * @param edgeOid
     * @param creator
     * @param now
     */
    private void addLifeCycleLineEvent(LifeCycleLineEventDTO eventDTO,String edgeOid,String creator,Date now){
        VciBaseUtil.alertNotNull(eventDTO.getBizDomain(),"所属领域",eventDTO.getEventFullName(),"事件的全路径");
        NewAppConstantEnum[] values = NewAppConstantEnum.values();
        Boolean fined = false;
        for (int i = 0; i < values.length; i++) {
            NewAppConstantEnum value = values[i];
            if(value.getName().equalsIgnoreCase(eventDTO.getBizDomain())){
                fined = true;
                break;
            }
        }
        if(!fined){
            throw new VciBaseException(eventDTO.getBizDomain() + "这个领域还没有开放,请让开发人员在NewAppConstantEnum类中添加");
        }
        LifeCycleLineEvent event = org.springblade.core.tool.utils.BeanUtil.copy(eventDTO, LifeCycleLineEvent.class);
        event.setOid(VciBaseUtil.getPk());
        event.setPkLifeCycleEdge(edgeOid);
        event.setBtmname(BtmTypeConstant.LIFE_CYCLE_LINE_EVENT);
        event.setOwner(creator);
        event.setCreator(creator);
        event.setCreateTime(now);
        event.setLastModifier(creator);
        event.setLastModifyTime(now);
        event.setTs(now);
        lineEventMapper.insert(event);
    }

    /**
     * æ·»åŠ ç”Ÿå‘½å‘¨æœŸçš„节点
     * @param nodeDTO
     * @param lifeOid
     * @param creator
     * @param now
     */
    private void addLifeCycleNode(LifeCycleNodeDTO nodeDTO,String lifeOid,String creator,Date now){
        VciBaseUtil.alertNotNull(nodeDTO.getId(),"状态标识",nodeDTO.getName(),"状态名称");
        LifeCycleNode node = org.springblade.core.tool.utils.BeanUtil.copy(nodeDTO, LifeCycleNode.class);
        node.setOid(VciBaseUtil.getPk());
        node.setLifeCycleOid(lifeOid);
        node.setBtmname(BtmTypeConstant.LIFE_CYCLE_NODE);
        node.setOwner(creator);
        node.setCreator(creator);
        node.setCreateTime(now);
        node.setLastModifier(creator);
        node.setLastModifyTime(now);
        node.setTs(now);
        nodeMapper.insert(node);
    }

    /**
     * æ·»åŠ ç”Ÿå‘½å‘¨æœŸçš„连接线
     * @param edgeDTO
     * @param statusList
     * @param lifeOid
     * @param creator
     * @param now
     * @return è¿žæŽ¥çº¿çš„主键
     */
    private String addLifeCycleEdge(LifeCycleEdgeDTO edgeDTO,List<String> statusList,String lifeOid,String creator,Date now){
        VciBaseUtil.alertNotNull(edgeDTO.getSource(),"来源状态",edgeDTO.getTarget(),"目标状态",edgeDTO.getName(),"连接线名称");
        if(!statusList.contains(edgeDTO.getSource())
            ||!statusList.contains(edgeDTO.getTarget())){
            throw new VciBaseException("数据错误，[" + edgeDTO.getName() + "]连接线上中使用的状态没有找到");
        }
        LifeCycleEdge edge = org.springblade.core.tool.utils.BeanUtil.copy(edgeDTO, LifeCycleEdge.class);
        edge.setOid(VciBaseUtil.getPk());
        edge.setLifeCycleOid(lifeOid);
        edge.setBtmname(BtmTypeConstant.LIFE_CYCLE_EDGE);
        edge.setOwner(creator);
        edge.setCreator(creator);
        edge.setCreateTime(now);
        edge.setLastModifier(creator);
        edge.setLastModifyTime(now);
        edge.setTs(now);
        edgeMapper.insert(edge);
        return edge.getOid();
    }



    /**
     * æ‰¹é‡æ·»åŠ å†…容
@@ -53,8 +267,40 @@
     * @return æ·»åŠ åŽçš„显示对象
     */
    @Override
    @Transactional
    public List<LifeCycleVO> batchAddSave(List<LifeCycleDTO> lifeCycleDTOs) {
        return null;
        VciBaseUtil.alertNotNull(lifeCycleDTOs,"生命周期的信息");
        //先集体校验一下
        if(lifeCycleDTOs.stream().anyMatch(s->!StringUtils.hasLength(s.getId()) || !StringUtils.hasLength(s.getName())
        || CollectionUtils.isEmpty(s.getNodes()) || !StringUtils.hasLength(s.getStartStatus()))){
            throw new VciBaseException("生命周期的编号，名称，起始状态，包含的节点不能为空");
        }
        //统一校验重复
        Map<String, List<LifeCycleDTO>> dtoMap = lifeCycleDTOs.stream().collect(Collectors.groupingBy(LifeCycleDTO::getId));
        dtoMap.forEach((id,dtos)->{
            if(dtos.size()>1){
                throw new VciBaseException("编号为【" + id + "】的生命周期重复");
            }
        });
        VciBaseUtil.switchCollectionForOracleIn(dtoMap.keySet()).stream().forEach(
            ids->{
                QueryWrapper wrapper = new QueryWrapper(LifeCycleRule.class);
                ids.stream().forEach(id->{
                    wrapper.eq("lower(id)",id.toLowerCase(Locale.ROOT));
                    wrapper.or();
                });
                wrapper.eq("1","2");
                if(baseMapper.selectCount(wrapper)>0){
                    throw new VciBaseException("生命周期的编号不能重复");
                }
            }
        );
        //先循环处理下，因为现在当前用户没有处理为线程共享的，后面修改后，可以用并发流去处理
        List<String> oidList = new ArrayList<>();
        lifeCycleDTOs.stream().forEach(dto->{
            oidList.add(addLifeCycle(dto));
        });
        return LifeCycleRuleWrapper.build().listEntityVO(listByIds(oidList));
    }

    /**
@@ -63,10 +309,34 @@
     * @param lifeCycleDTO æ•°æ®ä¼ è¾“对象
     */
    @Override
    @Transactional
    public void delete(LifeCycleDTO lifeCycleDTO) {
        VciBaseUtil.alertNotNull(lifeCycleDTO,"数据传输对象",lifeCycleDTO.getOid(),"主键");
        LifeCycleRule rule = null;
        try {
            rule = getById(lifeCycleDTO.getOid());
        }catch (Throwable e){
            throw new VciBaseException("使用主键获取对象出错，这个数据可能不存在，或者数据重复了");
        }
        //检查被引用不能删除
        Integer count = btmTypeService.countByLifeId(lifeCycleDTO.getOid());
        if(count !=null && count>0){
            throw new VciBaseException("生命周期被使用，不能被删除");
        }
        //我们查询全部node和edge，然后一起删除

    }


    private List<LifeCycleNode> selectNodeByLifeOid(String lifeOid){
        if(!StringUtils.hasLength(lifeOid)){
            return new ArrayList<>();
        }
        LambdaQueryWrapper<LifeCycleNode> query = new LambdaQueryWrapper<LifeCycleNode>();
        query.eq(LifeCycleNode::getLifeCycleOid,lifeOid);
        return nodeMapper.selectList(query);
    }

    /**
     * æ‰¹é‡åˆ é™¤ç”Ÿå‘½å‘¨æœŸ
     *

 Source/UBCS/ubcs-service/ubcs-omd/src/main/java/com/vci/ubcs/omd/wrapper/LifeCycleRuleWrapper.java

@@ -1,5 +1,6 @@
package com.vci.ubcs.omd.wrapper;

import com.vci.ubcs.omd.dto.LifeCycleDTO;
import com.vci.ubcs.omd.entity.LifeCycleRule;
import com.vci.ubcs.omd.vo.LifeCycleVO;
import org.springblade.core.mp.support.BaseEntityWrapper;
@@ -43,4 +44,8 @@
    }


    public LifeCycleRule copyDTO2DO(LifeCycleDTO lifeCycleDTO) {
        LifeCycleRule LifeCycleRule = BeanUtil.copy(lifeCycleDTO, LifeCycleRule.class);
        return LifeCycleRule;
    }
}