公式相关

blade-service-api/blade-manager-api/src/main/java/org/springblade/manager/dto/ElementData.java

@@ -1,6 +1,10 @@
 package org.springblade.manager.dto;
 
 
+import org.springblade.core.tool.utils.Func;
+
+import java.util.Objects;
+
 
 /**
  * @author yangyj
@@ -51,4 +55,18 @@ public class ElementData {
         this.groupId = groupId;
         this.value = value;
     }
+    public double doubleValue(){
+        return Double.parseDouble(this.value.toString());
+    }
+
+    public String stringValue(){
+        return this.value.toString();
+    }
+
+
+    public ElementData clone(Object value){
+        return new ElementData(index,groupId,value);
+    }
+
+
 }

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/ITurnPointCalculator.java

@@ -0,0 +1,20 @@
+package org.springblade.manager.formula;
+
+import com.mixsmart.utils.CustomFunction;
+import com.mixsmart.utils.StringUtils;
+
+import java.util.List;
+
+/**
+ * @author yangyj
+ */
+public interface ITurnPointCalculator {
+    /**
+     * 转点生成方法
+     * */
+     List<NextPoint> turnPoint(LevelInfo levelInfo,NextPoint nextPoint);
+     /**闭合转点生成方法
+      * */
+     List<NextPoint> closePoint(List<NextPoint> forward,LevelInfo levelInfo);
+
+}

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/LevelInfo.java

@@ -0,0 +1,40 @@
+package org.springblade.manager.formula;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @author yangyj
+ * @Date 2022/9/6 10:04
+ * @description TODO
+ */
+@Data
+public class LevelInfo {
+    /**
+     * 前后视最小值*/
+    public final Double min=0.5D;
+    /**
+     * 保留小数位*/
+    public final Integer scale=3;
+    /**
+     * 水准点名称*/
+    private String bm;
+    /**水准点高程
+     * */
+    private Double bmh;
+    /**
+     * 当前仪器视线高程*/
+    private Double sightHeight;
+    /**
+     * 转点信息*/
+    private List<NextPoint> nextPointList;
+    /**
+     *偏差范围
+     */
+    private String dx="-5,+5";
+    /**
+     * 前后视最大值
+     */
+    private Double step=4.8D;
+}

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/NextPoint.java

@@ -0,0 +1,100 @@
+package org.springblade.manager.formula;
+
+/**
+ * @author yangyj
+ * @Date 2022/1/24 13:44
+ * @description 水准尺测量对象
+ */
+public class NextPoint {
+    /**
+     * 前视*/
+    private String q;
+    /*后视*/
+    private String h;
+    /**
+     * 仪高或者视高*/
+    private String bmd;
+    /**
+     * 实测值*/
+    private String sc;
+    /**
+     * 设计值*/
+    private String sj;
+    /**
+     * 偏差值*/
+    private String dx;
+    /**
+     * 是否转点*/
+    private Boolean  isZd;
+
+    public NextPoint() {
+    }
+    public NextPoint(String q, String h, String bmd) {
+        this.q = q;
+        this.h = h;
+        this.bmd = bmd;
+        this.isZd=true;
+    }
+
+    public NextPoint(String q, String sc) {
+        this.q = q;
+        this.sc = sc;
+        this.isZd=false;
+    }
+
+    public String getQ() {
+        return q;
+    }
+
+    public void setQ(String q) {
+        this.q = q;
+    }
+
+    public String getH() {
+        return h;
+    }
+
+    public void setH(String h) {
+        this.h = h;
+    }
+
+    public String getBmd() {
+        return bmd;
+    }
+
+    public void setBmd(String bmd) {
+        this.bmd = bmd;
+    }
+
+    public String getSc() {
+        return sc;
+    }
+
+    public void setSc(String sc) {
+        this.sc = sc;
+    }
+
+    public String getSj() {
+        return sj;
+    }
+
+    public void setSj(String sj) {
+        this.sj = sj;
+    }
+
+    public String getDx() {
+        return dx;
+    }
+
+    public void setDx(String dx) {
+        this.dx = dx;
+    }
+
+    public Boolean getZd() {
+        return isZd;
+    }
+
+    public void setZd(Boolean zd) {
+        isZd = zd;
+    }
+}

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/impl/CompositeDataAccess.java

@@ -5,9 +5,7 @@ import com.mixsmart.utils.ListUtils;
 import com.mixsmart.utils.StringUtils;
 import org.springblade.manager.dto.ElementData;
 import org.springblade.manager.dto.FormData;
-import org.springblade.manager.entity.Formula;
 import java.util.*;
-import java.util.stream.Collectors;
 
 
 /**
@@ -53,7 +51,7 @@ public class CompositeDataAccess  {
         }
     }
 
-    public   LinkedHashMap<String, ElementData> get(Integer index){
+    private   LinkedHashMap<String, ElementData> get(Integer index){
         LinkedHashMap<String, ElementData> data =new LinkedHashMap<>();
         for(FormData fd:fds.values()){
             int step = fd.getStep()==null?1:fd.getStep();
@@ -71,27 +69,29 @@ public class CompositeDataAccess  {
 
 
     public void insert(LinkedHashMap<String, ElementData> data){
-        for(Map.Entry<String,FormData> fd:fds.entrySet()){
-            List<ElementData> list = fd.getValue().getValues();
-            /*当前游标已经指向下一个位置*/
-            if(list.size()<=cursor){
-                list.addAll(Collections.nCopies(cursor-list.size()+1,null));
+        if(++cursor>maxSize-1){
+            append(data);
+        }else{
+            for(Map.Entry<String,FormData> fd:fds.entrySet()){
+                List<ElementData> list = fd.getValue().getValues();
+                if(list.size()<=cursor){
+                    list.addAll(Collections.nCopies(cursor-list.size()+1,null));
+                }
+                /*动态增减的时候难以判定是否换页，暂时全部用1代替*/
+                list.add(cursor,data.getOrDefault(fd.getKey(),new ElementData(1,1,"")));
             }
-            /*动态增减的时候难以判定是否换页，暂时全部用1代替*/
-            list.add(cursor,data.getOrDefault(fd.getKey(),new ElementData(1,1,"")));
         }
-        ++cursor;
     }
 
 
     public void append(LinkedHashMap<String, ElementData> data){
         if(data!=null){
+            /*最大长度+1，游标不变*/
+            ++maxSize;
             for(Map.Entry<String,ElementData> d:data.entrySet()){
                 List<ElementData> list = fds.get(d.getKey()).getValues();
-                /*当前游标已经指向下一个位置*/
-                if(list.size()<maxSize){
-                    list.addAll(Collections.nCopies(maxSize-list.size(),null));
-                }
+                /*向所有数据末尾追加*/
+                list.addAll(Collections.nCopies(maxSize-list.size(), null));
                 list.add(maxSize,d.getValue());
             }
         }
@@ -99,51 +99,25 @@ public class CompositeDataAccess  {
 
 
     public Boolean hasNext(){
-          return cursor<maxSize;
+        return (cursor<maxSize-1?++cursor:-1)>0;
+    }
+    public Boolean isFirst(){
+        return cursor==0;
+    }
+
+    public Boolean isLast(){
+        return cursor==maxSize-1;
+    }
+
+    public void close(){
+        this.cursor=this.maxSize-1;
     }
 
     public LinkedHashMap<String, ElementData> next(){
-        return get(cursor++);
+        return get(cursor);
     }
 
 
-//    public static FormData makeFd(String fs, String code, String rely,Integer step, Object... obs){
-//        Formula f= new Formula();
-//        f.setRely(rely);
-//        f.setFormula(fs);
-//        List<ElementData> list = new ArrayList<>();
-//        if(obs!=null){
-//            list= Arrays.stream(obs).map(e->new ElementData(0,0,e)).collect(Collectors.toList());
-//        }
-//        return new FormData(code,step, list,f);
-//    }
-//    public static void main(String[] args) {
-//        List<FormData> list = new ArrayList<>();
-//        list.add(makeFd("","a","",1,0,2,2,2,2,2));
-//        list.add(makeFd("","b","",1,0,3,3,6,3,8,9));
-//        list.add(makeFd("","c","",1,0,5.5,3,7,3,9));
-//        list.add(makeFd("","d","",1,0,10,7,2,5,5,0));
-//        list.add(makeFd("","e","",2,13,23,39));
-//        CompositeDataAccess cda = new CompositeDataAccess();
-//        for(FormData fd:list){
-//            cda.addFormData(fd.getCode(),fd);
-//        }
-//        while (cda.hasNext()){
-//            LinkedHashMap<String, ElementData> data =cda.next();
-//            if(cda.cursor==1){
-//                LinkedHashMap<String, ElementData> t1= new LinkedHashMap<>();
-//                t1.put("a",new ElementData(1,1,666));
-//                cda.insert(t1);
-//            }
-//            data.get("d").setValue(100);
-//        }
-//        LinkedHashMap<String, ElementData> t= new LinkedHashMap<>();
-//        t.put("c",new ElementData(1,1,777));
-//        cda.append(t);
-//        System.out.println();
-//
-//
-//    }
 
 
 }

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/impl/FormulaTurnPoint.java

@@ -2,12 +2,16 @@ package org.springblade.manager.formula.impl;
 
 import com.mixsmart.utils.StringUtils;
 import lombok.Data;
+import org.springblade.core.tool.utils.Func;
+import org.springblade.manager.dto.ElementData;
 import org.springblade.manager.dto.FormData;
 import org.springblade.manager.formula.FormulaStrategy;
+import org.springblade.manager.formula.LevelInfo;
+import org.springblade.manager.formula.NextPoint;
 import org.springframework.stereotype.Component;
 
-import java.util.List;
-import java.util.Map;
+import java.math.BigDecimal;
+import java.util.*;
 
 /**
  * @author yangyj
@@ -18,9 +22,57 @@ import java.util.Map;
 @Data
 public class FormulaTurnPoint implements FormulaStrategy {
     private FormData cur;
+    static   final List<String>  KEYS;
+    private List<String> args;
+    static {
+        KEYS=new ArrayList<>(Arrays.asList("测点","后视","前视","仪器高","实际标高","设计标高","高程偏差","备注"));
+    }
     @Override
     public void execute(List<FormData> fds, Map<String, Object> constantMap) {
+        LinkedHashMap<String,FormData> dataSourceMap = new LinkedHashMap<>();
+        List<String> args=cur.getFormula().getRelyList();
+        this.args=args;
+        if(Func.isNotEmpty(args)) {
+            args.forEach(k -> {
+                dataSourceMap.put(k, fds.stream().filter(e -> k.equals(e.getCode())).findFirst().orElseGet(null));
+            });
+            CompositeDataAccess cda = new CompositeDataAccess(dataSourceMap);
+            cda.cursorReset();
+            while (cda.hasNext()) {
+                LinkedHashMap<String, ElementData> map = cda.next();
+                LevelInfo levelInfo = new LevelInfo();
+                ElementData sjgc = map.get(c("设计标高"));
+                ElementData cd = map.get(c("测点"));
+                if (cda.isFirst()) {
+                     ElementData hs = map.get(c("后视"));
+                     if(hs!=null&&sjgc!=null){
+                          double bmd =hs.doubleValue()+ sjgc.doubleValue();
+                          map.put(c("仪器高"),hs.clone(bmd));
+                          levelInfo.setSightHeight(bmd);
+                          levelInfo.setBm(cd.stringValue());
+                     }else{
+                          cda.close();
+                     }
+                }else{
+                    ElementData gc = map.get(c("实际标高"));
+                    ElementData qs = map.get(c("前视"));
+                    TurnPointCalculator tpc = new TurnPointCalculator();
+                    NextPoint nextPoint = new NextPoint(qs.stringValue(),gc.stringValue());
+                    List<NextPoint> nextPointList= tpc.turnPoint(levelInfo,nextPoint);
+
+                }
+            }
+        }
+    }
 
+    private String c(String name){
+        if(Func.isNotEmpty(name)&&Func.isNotEmpty(this.args)){
+            int  index= KEYS.indexOf(name);
+            if(index<args.size()){
+              return  args.get(index);
+            }
+        }
+         return null;
     }
 
     @Override
@@ -29,4 +81,6 @@ public class FormulaTurnPoint implements FormulaStrategy {
         String f= fd.getFormula().getFormula();
         return StringUtils.isNotEmpty(f)&&f.startsWith("TURN_POINT(");
     }
+
+
 }

blade-service/blade-manager/src/main/java/org/springblade/manager/formula/impl/TurnPointCalculator.java

@@ -0,0 +1,264 @@
+package org.springblade.manager.formula.impl;
+
+import com.mixsmart.utils.CustomFunction;
+import com.mixsmart.utils.ListUtils;
+import com.mixsmart.utils.StringUtils;
+import org.springblade.manager.formula.ITurnPointCalculator;
+import org.springblade.manager.formula.LevelInfo;
+import org.springblade.manager.formula.NextPoint;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
+
+import static java.math.BigDecimal.ROUND_HALF_UP;
+
+/**
+ * @author yangyj
+ * @Date 2022/9/6 11:51
+ * @description TODO
+ */
+public class TurnPointCalculator implements ITurnPointCalculator {
+    public static Double FACTOR =0.46D;
+
+    @Override
+    public List<NextPoint> turnPoint(LevelInfo levelInfo, NextPoint nextPoint) {
+        double min=levelInfo.getMin();
+        List<NextPoint> list = new ArrayList<>();
+        double cD =levelInfo.getStep();
+        double bD= levelInfo.getBmh();
+        double npD=Double.parseDouble(nextPoint.getSc());
+        boolean existQ=StringUtils.isNumber(nextPoint.getQ());
+        double qD=existQ?Double.parseDouble(StringUtils.number2String(nextPoint.getQ(),3)):0;
+        /*默认保留三位小数*/
+        int scaleI = levelInfo.getScale();
+        /*前视后视的高差计算参数，趋高的时候前视小后视大，趋低的时候前视大后视小*/
+        double cut = BigDecimal.valueOf(cD*FACTOR).setScale(scaleI,ROUND_HALF_UP).doubleValue();
+        Random rd = new Random();
+        /*累计循环次数，循环上限是300*/
+        int count=0;
+        if(existQ){
+            if(npD+qD==bD){
+                /*已经得到正确的测量结果*/
+                list.add(new NextPoint(StringUtils.number2String(bD-npD,scaleI),StringUtils.number2String(npD,scaleI)));
+            }else{
+                /**
+                 * target是当前测点的前一个转点仪器高*/
+                double target=npD+qD;
+                boolean higher=target>bD;
+                boolean loop=true;
+                do{
+                    double big,small;
+                    /*视高和目标视高的差值落在前后视最大差值内*/
+                    /*bD可能从上下两个方向不断逼近target*/
+                    if(Math.abs(bD-target)<cD-min){
+                        loop=false;
+                        double hd=Math.abs(bD-target);
+                        big=BigDecimal.valueOf(rd.nextDouble()*(cD-cut)+cut).setScale(scaleI,ROUND_HALF_UP).doubleValue();
+                        small=big-hd;
+                        NextPoint lastZd =new NextPoint();
+                        lastZd.setBmd(StringUtils.number2String(target,3));
+                        if(higher){
+                            /*前小后大*/
+                            lastZd.setQ(StringUtils.number2String(small,3));
+                            lastZd.setH(StringUtils.number2String(big,3));
+                        }else{
+                            /*前大后小*/
+                            lastZd.setQ(StringUtils.number2String(big,3));
+                            lastZd.setH(StringUtils.number2String(small,3));
+                        }
+                        lastZd.setZd(true);
+                        list.add(lastZd);
+                        list.add(new NextPoint(StringUtils.number2String(qD,3),StringUtils.number2String(npD,3)));
+                    }else{
+                        big=BigDecimal.valueOf(rd.nextDouble()*(cD-cut)+cut).setScale(scaleI,ROUND_HALF_UP).doubleValue();
+                        small=BigDecimal.valueOf(rd.nextDouble()*(cut-0.6)+0.5).setScale(scaleI,ROUND_HALF_UP).doubleValue();
+                        NextPoint p =createNextPoint(higher,big,small,bD,null,scaleI);
+                        bD=Double.parseDouble(p.getBmd());
+                        list.add(p);
+                    }
+                    count++;
+                }while (loop&&count<300);
+            }
+        }else {
+            boolean loop=true;
+            do{
+                double big,small;
+                boolean higher=npD+min>bD;
+                NextPoint p;
+                if(bD-npD>min&&bD-npD<cD){
+                    /*测点已经在仪器测量范围0.5<x<step*/
+                    loop=false;
+                    p=new NextPoint();
+                    zd(bD-npD,0d,bD,npD,scaleI,p);
+                }else{
+                    big=BigDecimal.valueOf(rd.nextDouble()*(cD-cut)+cut).setScale(scaleI,ROUND_HALF_UP).doubleValue();
+                    small=BigDecimal.valueOf(rd.nextDouble()*(cut-0.6)+0.5).setScale(scaleI,ROUND_HALF_UP).doubleValue();
+                    p =createNextPoint(higher,big,small,bD,npD,scaleI);
+                }
+                /*更新视高*/
+                if(StringUtils.isNotEmpty(p.getBmd())){
+                    bD=Double.parseDouble(p.getBmd());
+                }
+                list.add(p);
+                count++;
+            }while (loop&&count<300);
+        }
+        if(list.size()>1){
+            levelInfo.setSightHeight(Double.parseDouble(list.get(list.size()-1).getBmd()));
+            levelInfo.getNextPointList().addAll(list.stream().limit(list.size()-1).collect(Collectors.toList()));
+        }
+        return list;
+    }
+    public  NextPoint createNextPoint(Boolean higher,Double big,Double small ,Double bD,Double sc,Integer scaleI){
+        NextPoint p = new NextPoint();
+        if(higher){
+            /*测点大于仪器高0.5米*/
+            /*前视小后视大*/
+            zd(small, big, bD, sc, scaleI, p);
+        }else{
+            /*前视大后视小*/
+            zd(big, small, bD, sc, scaleI, p);
+        }
+        return  p;
+    }
+    private  void zd(Double q, Double h, Double bD, Double sc, Integer scaleI, NextPoint p) {
+        p.setQ(StringUtils.number2String(q,scaleI));
+        if(h!=0) {
+            p.setBmd(StringUtils.number2String(bD+h-q,scaleI));
+            p.setH(StringUtils.number2String(h, scaleI));
+            p.setZd(true);
+        }else{
+            p.setSc(StringUtils.number2String(sc,scaleI));
+        }
+    }
+    public  static  Random RD= new Random();
+    public static void jitter(NextPoint np){
+        if(np!=null&&StringUtils.isNotEmpty(np.getBmd())){
+            double dx = Math.random()*0.07*(RD.nextBoolean()?-1:1);
+            np.setBmd(StringUtils.number2String(Double.parseDouble(np.getBmd())+dx,3));
+        }
+    }
+
+    @Override
+    public List<NextPoint> closePoint(List<NextPoint> forward, LevelInfo levelInfo) {
+        List<NextPoint> result = new ArrayList<>();
+        Random rd = new Random();
+        /*默认保留三位小数*/
+        int scaleI=levelInfo.getScale();
+        /*当前实测点*/
+        Double[] DL=new Double[]{0.001,0.002,0.003,-0.001,-0.002,-0.003};
+        double ldx=DL[(int)Math.round(Math.random()*5)];
+        double scD= levelInfo.getBmh()+ldx;
+        /*当前仪器视线高*/
+        double bD=levelInfo.getSightHeight();
+        if(ListUtils.isNotEmpty(forward)){
+            /*每一个转点仪器视高之间最大高差*/
+            double cD =levelInfo.getStep();
+            /*必须保证转点视高最小高程大于0.5*/
+            String target=StringUtils.number2String(scD+0.5+rd.nextDouble()*(cD-0.5),scaleI);
+            List<NextPoint> backward = new ArrayList<>(forward);
+            /*反转转点得到闭合转点走势*/
+            Collections.reverse(backward);
+            backward=backward.stream().peek(TurnPointCalculator::jitter).collect(Collectors.toList());
+            backward.add(new NextPoint("0","0",target));
+            if(backward.size()>1){
+                /*去头*/
+                backward.remove(0);
+            }
+            for(NextPoint np:backward){
+                double dx = bD-Double.parseDouble(np.getBmd());
+                double dxx=Math.abs(dx);
+                double big=BigDecimal.valueOf(rd.nextDouble()*(cD-dxx-0.5)+dxx+0.5).setScale(scaleI,ROUND_HALF_UP).doubleValue();
+                double small=big-dxx;
+                if(dx<0){
+                    /*后大前小,取高*/
+                    np.setQ(StringUtils.number2String(small,3));
+                    np.setH(StringUtils.number2String(big,3));
+
+                }else{
+                    /*前大后小，趋低*/
+                    np.setQ(StringUtils.number2String(big,3));
+                    np.setH(StringUtils.number2String(small,3));
+                }
+                bD=Double.parseDouble(np.getBmd());
+                result.add(np);
+            }
+            result.add(new NextPoint(StringUtils.number2String(Double.parseDouble(target)-scD,scaleI),StringUtils.number2String(scD,scaleI)));
+        }else{
+            /*闭合点*/
+            result.add(new NextPoint(StringUtils.number2String(bD-scD,scaleI),StringUtils.number2String(scD,scaleI)));
+        }
+        return result;
+    }
+
+    public NextPoint vacancy(Object qs, Object gc, Object sj, Double bmd, String range, Object step){
+        NextPoint np = new NextPoint();
+        String dev="-6,6";
+        if(StringUtils.isNotEmpty(range)){
+            dev=range.replaceAll("[\\[\\]]","");
+        }
+        String dx;
+        double cD=Double.parseDouble(step.toString());
+        double min=0.5d;
+        do{
+            dx= CustomFunction.rangeList(1,0,dev,1,0,1).get(0).toString();
+        }while (StringUtils.isEquals(0,dx));
+        double hd;
+        boolean hasNp=true;
+        if(StringUtils.isNotEmpty(bmd,gc)){
+            hd=Double.parseDouble(bmd.toString())-Double.parseDouble(gc.toString());
+            if(hd>min&&hd<cD){
+                hasNp=false;
+            }
+            np.setSc(StringUtils.handleNull(gc));
+        }
+        if(StringUtils.isNotEmpty(gc)&&StringUtils.isEmpty(sj,qs)){
+            /*010*/
+            if(!hasNp){
+                np.setQ(CustomFunction.calculate(bmd,gc,3,2).toString());
+            }
+        }else if(StringUtils.isNotEmpty(gc,sj)&&StringUtils.isEmpty(qs)){
+            /*011*/
+            if(!hasNp){
+                np.setQ(CustomFunction.calculate(bmd,gc,3,2).toString());
+            }
+            np.setSj(sj.toString());
+        }else if(StringUtils.isNotEmpty(gc,qs)&&StringUtils.isEmpty(sj)){
+            /*110*/
+            np.setQ(qs.toString());
+        }else if(StringUtils.isNotEmpty(sj)&&StringUtils.isEmpty(gc,qs)){
+            /*001*/
+            np.setSj(sj.toString());
+            np.setSc(StringUtils.number2String(Double.parseDouble(np.getSj())+Double.parseDouble(dx)/1000,3));
+            hd=Double.parseDouble(bmd.toString())-Double.parseDouble(np.getSc());
+            if(hd>min&&hd<cD){
+                hasNp=false;
+            }
+            if(!hasNp){
+                np.setQ(CustomFunction.calculate(bmd,np.getSc(),3,2).toString());
+            }
+        }else if(StringUtils.isNotEmpty(qs,bmd)&&StringUtils.isEmpty(gc,sj)){
+            /*100*/
+            np.setQ(qs.toString());
+            np.setSc(StringUtils.number2String(bmd-Double.parseDouble(np.getQ()),3));
+        }else if(StringUtils.isNotEmpty(qs,sj)&&StringUtils.isEmpty(gc)){
+            /*101*/
+            np.setQ(qs.toString());
+            np.setSc(StringUtils.number2String(Double.parseDouble(sj.toString())+Double.parseDouble(dx)/1000,3));
+        }else if(StringUtils.isNotEmpty(qs,sj,gc)){
+            /*111*/
+            np.setQ(qs.toString());
+            np.setSc(gc.toString());
+        }
+        if(np.getSc()==null){
+            /*实测高程一定不能为空*/
+            return null;
+        }
+        return  np;
+    }
+
+}

blade-service/blade-manager/src/main/java/org/springblade/manager/service/impl/FormulaServiceImpl.java

@@ -213,7 +213,7 @@ public class FormulaServiceImpl extends BaseServiceImpl<FormulaMapper, Formula>
     @Override
     public void execute(TableElementConverter tec) {
         WbsTreeContract one = this.treeContractService.getById(tec.getTableInfoList().get(0).getPkeyId());
-        this.execute(tec.getFds(),tec.getContractId(),one.getParentId());
+        this.execute(tec.getFds(),tec.getContractId(),Func.isNotEmpty(one.getOldId())?Long.parseLong(one.getOldId()):one.getParentId());
     }
 
     public  Map<String,Object> getMap(Map<String,Object> main,String key){