bxs-tools-ui 3.2.1 → 3.3.0

package/packages/planbook-input/helper.js

@@ -1,169 +1,226 @@
-import { Toast } from 'vant';
-import QS from 'qs';
-import { get as _get, cloneDeep } from 'lodash';
-import { PLANBOOK_API_HOSTNAME } from '@src/js/variables.js';
+import qs from 'qs'
+import { get as _get, cloneDeep } from 'lodash'
+import { Toast, Dialog } from 'vant'
 import {
   initPersonData,
   personDataHandler,
   convertPersonData,
+  calcTotalBaof,
   initProductData,
   productDataHandler,
+  multipleInsuredHandler,
+  clearAddAndTakeAndAdjustBaoeData,
   convertProductData,
   verifyProductRules,
   convertEleOrderListToObj,
   getExpressionParamMap
-} from 'packages/bxs-utils/index';
-import { createMd5Token } from '@src/js/md5Token.js';
+} from '../bxs-utils/index'
+import { calcPlanbookProduct, uploadPlanBookResult, getUnderwriteEffectiveRules } from '../../src/api/index.js'
+import { parseTime, getSecurityToken, goBack } from '../../src/js/utils.js'
+import { isIos, appVersion, URL_PARAM } from '../../src/js/variables'
 
-export async function initPageData(data) {
-  const inputData = data && data.initData && data.initData.inputData;
-  if (inputData) {
-    initPersonData(inputData, data.verifyData);
-    personDataHandler(inputData.personData);
-    const productGroupList = inputData.productGroupList || [];
-    const promises = [];
-    productGroupList
-      .filter(g => g.prodOrderList)
-      .forEach(g => {
-        return g.prodOrderList.forEach(p => {
-          initProductData(p);
-          promises.push(
-            productDataHandler(p, data.verifyData[p.key], inputData.personData, {
-              planbookId: data.pbId
-            })
-          );
-        });
-      });
-    await Promise.all(promises);
+let productCalcVuexStore = null
+export function setProductCalcVuexStore(storeInstance) {
+  productCalcVuexStore = storeInstance
+}
+
+function getProductCalcVuexStore() {
+  return productCalcVuexStore
+}
+
+function commitProductCalcError(productUniqueKey, message) {
+  const calcStore = getProductCalcVuexStore()
+  if (productUniqueKey && calcStore && calcStore._mutations && calcStore._mutations.SET_PRODUCT_CALC_ERROR) {
+    calcStore.commit('SET_PRODUCT_CALC_ERROR', { id: productUniqueKey, message })
   }
-  return data;
 }
 
-export function setPageDataBaseOnResult(data) {
-  if (!data) {
-    return data;
+export async function initPageData(data, options = {}) {
+  const planbookId = data.pbId
+  const pbType = _get(options, 'pbType')
+  const { user } = options || {}
+
+  // 承保规则赋值
+  if (!['annual_survey'].includes(pbType)) {
+    const _inputData = await setupUnderwriteRuleToInputData(_get(data, 'initData.inputData')).catch(() => null)
+    if (_inputData) {
+      data.initData.inputData = _inputData
+    }
   }
-  let inputData = data.initData && data.initData.inputData;
-  let exportData = data.exportData ? JSON.parse(data.exportData) : null;
+
+  data.interestProductList = data.interestProductList || []
+  const inputData = _get(data, 'initData.inputData')
+  if (inputData) {
+    const verifyData = data.verifyData
+    const exportData = data.exportData ? JSON.parse(data.exportData) : null
+    const policyInfo = data.policyInfo
+    const personData = inputData.personData
+    initPersonData(inputData, verifyData)
+    const productFlatList = (inputData.productGroupList || []).map(g => g.prodOrderList || []).flat()
+    productFlatList.forEach(p => {
+      initProductData(p)
+      multipleInsuredHandler(p, personData)
+    })
+
+    // 导入已有数据，重新赋值到初始化中的产品对象中
+    setPageDataBaseOnResult(inputData, exportData, policyInfo, options)
+
+    personDataHandler(personData)
+    const promises = productFlatList.map(p => {
+      return productDataHandler(p, _get(verifyData, p.key), personData, {
+        user,
+        planbookId,
+        executeSource: exportData ? 'import' : 'init'
+      })
+    })
+    await Promise.all(promises)
+  }
+  return data
+}
+
+export function setPageDataBaseOnResult(inputData, exportData, policyInfo, options = {}) {
   if (inputData && exportData) {
     // 人员信息赋值
-    let iPersonData = inputData.personData;
-    let ePersonData = exportData.personData;
+    const iPersonData = inputData.personData
+    const ePersonData = exportData.personData
     if (iPersonData && ePersonData) {
       for (let k in iPersonData) {
         if (k == 'personOrderList' && ePersonData[k]) {
-          iPersonData[k].forEach((person, pi) => {
-            person.eleOrderList &&
-              person.eleOrderList.forEach(ele => {
-                if (ePersonData[k][pi] && ePersonData[k][pi][ele.key] !== undefined && ePersonData[k][pi][ele.key] !== null) {
-                  ele.value = ePersonData[k][pi][ele.key];
-                }
-              });
-          });
+          iPersonData[k].forEach(person => {
+            if (!person.eleOrderList) {
+              return
+            }
+            const ePerson = ePersonData[k].find(e => e.key === person.key)
+            person.eleOrderList.forEach(ele => {
+              let value = ePerson && ePerson[ele.key]
+              if (ele.key === 'insuranceDay' && policyInfo) {
+                value = parseTime(policyInfo.insuranceDay, '{y}/{m}/{d}')
+              }
+              if (value !== undefined && value !== null) {
+                ele.value = value
+              }
+            })
+
+            const cid = policyInfo ? policyInfo[person.key.replace(/Info/, 'Uuid')] : ePerson.cid
+            if (ePerson && cid) {
+              person.cid = cid
+            }
+          })
         }
         if (k == 'recipientInfo' && ePersonData[k]) {
           iPersonData[k].eleOrderList &&
             iPersonData[k].eleOrderList.forEach(ele => {
               if (iPersonData[k][ele.key]) {
-                ele.value = ePersonData[k][ele.key];
+                ele.value = ePersonData[k][ele.key]
               }
-            });
+            })
         }
       }
     }
 
     // 产品赋值
-    let iGroupList = inputData.productGroupList;
-    let eGroupList = exportData.productGroupList;
+    const iGroupList = inputData.productGroupList
+    const eGroupList = exportData.productGroupList
     if (iGroupList && eGroupList) {
       iGroupList.forEach((group, gi) => {
-        let eGroupData = eGroupList[gi];
-        if (eGroupData && group.prodOrderList) {
-          group.prodOrderList.forEach(prod => {
-            let eProductData = eGroupData.prodOrderList.find(p => p.key === prod.key);
-            if (eProductData) {
-              // 取调整保额数据
-              if (eProductData.adjustBaoeData) {
-                prod.adjustBaoeData = eProductData.adjustBaoeData;
-              }
-              prod.inputResultSwitch = !!eProductData.inputResultSwitch;
-              prod.resultImport = true;
-              // 已生成的计划书取回的产品数据，赋值到初始化中的产品对象中
-              for (let k in prod) {
-                if (k == 'mulInsOrderList') {
-                  // 清除组合险
-                  prod.mulInsOrderList = prod.mulInsOrderList.filter(ins => !ins.isGroup);
-                  // 已生成的计划书取回的险种数据，赋值到初始化中的险种对象中
-                  prod.mulInsOrderList.forEach(ins => {
-                    let eInsuranceData = eProductData.mulInsOrderList.find(m => m.key === ins.key);
-                    if (eInsuranceData) {
-                      if (ins.eleOrderList) {
-                        // 下为处理从结果页中导入数值时，保额保费互算问题 2018.12.11
-                        let calMethod = ins.eleOrderList.find(e => e.key === 'calMethod');
-                        let baoe = ins.eleOrderList.find(e => e.key === 'baoe');
-                        let baof = ins.eleOrderList.find(e => e.key === 'baof') || ins.eleOrderList.find(e => e.key === 'payModePremium');
-                        if (calMethod && baoe && baof && eInsuranceData.calMethod) {
-                          baoe.isHide = eInsuranceData.calMethod !== 'baoe2baof';
-                          baof.isHide = eInsuranceData.calMethod === 'baoe2baof';
-                        }
-                        ins.eleOrderList.forEach(ele => {
-                          if (eInsuranceData[ele.key]) {
-                            ele.value = eInsuranceData[ele.key];
-                          }
-                        });
+        let eGroupData = eGroupList[gi]
+        if (!eGroupData || !group.prodOrderList) {
+          return
+        }
+        group.prodOrderList.forEach(prod => {
+          let eProductData = eGroupData.prodOrderList.find(p => p.key === prod.key)
+          if (!eProductData) {
+            return
+          }
+          // 取调整保额数据
+          if (eProductData.adjustBaoeData) {
+            prod.adjustBaoeData = eProductData.adjustBaoeData
+          }
+          prod.inputResultSwitch = !!eProductData.inputResultSwitch
+          prod.resultImport = true
+          // 已生成的计划书取回的产品数据，赋值到初始化中的产品对象中
+          for (let k in prod) {
+            if (k == 'mulInsOrderList') {
+              // 清除组合险
+              prod.mulInsOrderList = prod.mulInsOrderList.filter(ins => !ins.isGroup)
+              // 已生成的计划书取回的险种数据，赋值到初始化中的险种对象中
+              prod.mulInsOrderList.forEach(ins => {
+                const eInsuranceData = eProductData.mulInsOrderList.find(m => m.key === ins.key)
+                if (eInsuranceData) {
+                  if (ins.eleOrderList) {
+                    // 下为处理从结果页中导入数值时，保额保费互算问题 2018.12.11
+                    let calMethod = ins.eleOrderList.find(e => e.key === 'calMethod')
+                    let baoe = ins.eleOrderList.find(e => e.key === 'baoe')
+                    let baof = ins.eleOrderList.find(e => e.key === 'baof') || ins.eleOrderList.find(e => e.key === 'payModePremium')
+                    if (calMethod && baoe && baof && eInsuranceData.calMethod) {
+                      baoe.isHide = eInsuranceData.calMethod !== 'baoe2baof'
+                      baof.isHide = eInsuranceData.calMethod === 'baoe2baof'
+                    }
+                    ins.eleOrderList.forEach(ele => {
+                      if (!options.uuid && options.ocrUuid) {
+                        ele.value = eInsuranceData[ele.key]
+                        return
                       }
-                      if (eInsuranceData.inputResult !== undefined) {
-                        ins.inputResult = eInsuranceData.inputResult;
+                      if (eInsuranceData[ele.key]) {
+                        ele.value = eInsuranceData[ele.key]
                       }
+                    })
+                  }
+                  if (eInsuranceData.inputResult !== undefined) {
+                    ins.inputResult = eInsuranceData.inputResult
+                  }
 
-                      // 万能账户存在，可以不加追加领取数据
-                      for (let ik in ins) {
-                        if (['reduceBaof'].indexOf(ik) !== -1) {
-                          if (eInsuranceData[ik + 'Data']) {
-                            ins[ik + 'Data'] = eInsuranceData[ik + 'Data'];
-                          }
-                        }
+                  // 万能账户存在，可以不加追加领取数据
+                  for (let ik in ins) {
+                    if (['reduceBaof'].includes(ik)) {
+                      if (eInsuranceData[ik + 'Data']) {
+                        ins[ik + 'Data'] = eInsuranceData[ik + 'Data']
                       }
-                    } else {
-                      // 结果页数据中没有对应险种，对应的初始化数据置为未选中
-                      if (ins.eleOrderList) {
-                        ins.eleOrderList.forEach(ele => {
-                          if (ele.key == 'title') {
-                            ele.value = false;
-                          }
-                        });
+                      if (eInsuranceData.duplicateReduceBaofData) {
+                        ins.duplicateReduceBaofData = eInsuranceData.duplicateReduceBaofData
                       }
                     }
-                  });
+                  }
+                  if ('policyInsuranceCategory' in eInsuranceData) {
+                    ins.policyInsuranceCategory = eInsuranceData.policyInsuranceCategory
+                  }
+                } else {
+                  // 结果页数据中没有对应险种，对应的初始化数据置为未选中
+                  if (ins.eleOrderList) {
+                    ins.eleOrderList.forEach(ele => {
+                      if (ele.key == 'title') {
+                        ele.value = false
+                      }
+                    })
+                  }
                 }
-              }
+              })
             }
-          });
-        }
-      });
+          }
+        })
+      })
     }
   }
-  return initPageData(data);
+  return inputData
 }
 
-export function createdProductDataToCalc(inputData, options = {}) {
+export async function createdProductDataToCalc(inputData, options = {}) {
   if (inputData && inputData.personData && inputData.productGroupList && inputData.productGroupList.length) {
     const productData = getProductFromInputData(inputData, {
       groupKey: options.groupKey,
       productKey: options.productKey
-    });
-
-    const tempProductForm = convertProductData(productData);
+    })
+    const tempProductForm = convertProductData(productData)
     // 过滤一些不必要的数据
-    const productForm = {};
+    const productForm = {}
     for (let k in tempProductForm) {
-      if (!['hadChoice', 'hide', 'totalBaof', 'insShowArr', 'autoImport'].includes(k)) {
-        productForm[k] = tempProductForm[k];
+      if (!['hadChoice', 'hide', 'totalBaof', 'insShowArr', 'autoImport', 'restrictList', 'resultImport', 'adjustBaoeData'].includes(k)) {
+        productForm[k] = tempProductForm[k]
       }
     }
     if (productForm.mulInsOrderList) {
       productForm.mulInsOrderList = productForm.mulInsOrderList.map(ins => {
-        let tempIns = {};
+        const tempIns = {}
         for (let k in ins) {
           if (
             ![
@@ -172,38 +229,37 @@ export function createdProductDataToCalc(inputData, options = {}) {
               'baoeDesc',
               'baofDesc',
               'iDurationDesc',
+              'payModeDesc',
+              'payModePremiumDesc',
               'accountData',
               'reduceBaofData',
               'duplicateReduceBaofData',
               'isCheckbox',
               'groupKey',
               'groupName',
+              'shmInsData',
+              'totalBaof',
               'customVariableExp',
-              'calcResultExp',
+              // 'calcResultExp', // 不能删除，后面有依赖
               'revalidateFlag'
             ].includes(k)
           ) {
-            tempIns[k] = ins[k];
+            tempIns[k] = ins[k]
           }
         }
-        return tempIns;
-      });
+        return tempIns
+      })
     }
 
     // 产品是否有选中的险种
+    if (productForm && productForm.policyType === 'online_trade') {
+      return Promise.resolve({})
+    }
     if (productForm && productForm.mulInsOrderList && productForm.mulInsOrderList.length) {
       const errorMsg = verifyProductRules({
         personData: inputData.personData,
         productData
-      });
-
-      // 清除产品中的一些不必要的险种数据
-      productForm.mulInsOrderList.forEach(ins => {
-        if (ins.shmInsData) {
-          delete ins.shmInsData;
-        }
-      });
-
+      })
       const reqData = {
         publicPbUuid: options.publicPbUuid || null,
         insuranceTypeId: options.planbookId ? options.planbookId * 1 : null,
@@ -219,414 +275,745 @@ export function createdProductDataToCalc(inputData, options = {}) {
             prodOrderList: [productForm] //转换后的产品数据
           }
         ]
-      };
+      }
+      const reqDataStr = JSON.stringify(reqData)
+      const signature = await getSecurityToken(reqDataStr, {
+        groupDataKey: options.groupKey
+      })
       return Promise.resolve({
         errorMsg,
-        jd: JSON.stringify(reqData),
-        signature: createMd5Token(reqData, {
-          groupDataKey: options.groupKey
-        })
-      });
+        jd: reqDataStr,
+        signature,
+        clientVersion: appVersion,
+        isIos
+      })
     } else {
-      return Promise.reject('请选择险种');
+      return Promise.reject('请选择险种')
     }
   } else {
-    return Promise.reject('请填写投保数据');
+    return Promise.reject('请填写投保数据')
   }
 }
 
 export function receiveProductData(inputData, rProductData, options = {}) {
-  let productData = getProductFromInputData(inputData, options);
-  rProductData.mulInsOrderList.forEach(ins => {
-    let insuranceData = productData.mulInsOrderList.find(i => i.key === ins.key);
-    if (insuranceData) {
-      if (ins.huomian === 'shm_spouse') {
-        insuranceData.shmInsData = ins;
-      } else {
-        //将返回来的险种数据，赋值到现在数据中
-        for (let k in ins) {
-          if (insuranceData.eleOrderList.some(e => e.key === k)) {
-            insuranceData.eleOrderList.forEach(e => {
-              if (ins[e.key] !== undefined) {
-                e.value = ins[e.key];
-              }
-            });
-          } else {
-            insuranceData[k] = ins[k];
+  const productData = getProductFromInputData(inputData, options)
+  if (productData) {
+    rProductData.mulInsOrderList.forEach(ins => {
+      let insuranceData = productData.mulInsOrderList.find(i => i.key === ins.key)
+      if (insuranceData) {
+        if (ins.huomian === 'shm_spouse') {
+          insuranceData.shmInsData = ins
+        } else {
+          //将返回来的险种数据，赋值到现在数据中
+          for (let k in ins) {
+            if (insuranceData.eleOrderList.some(e => e.key === k)) {
+              insuranceData.eleOrderList.forEach(e => {
+                if (ins[e.key] !== undefined) {
+                  e.value = ins[e.key]
+                }
+              })
+            }
+            insuranceData[k] = ins[k]
           }
         }
       }
-    }
-  });
-  productData.mulInsOrderList.forEach(ins => {
-    if (ins.isGroup) {
-      let groupInsData = convertEleOrderListToObj(ins);
-      let insuranceId = groupInsData.isCheckbox ? groupInsData.insuranceId[0] : groupInsData.insuranceId;
-      let checkedIns = productData.mulInsOrderList.find(i => i.key === insuranceId);
-      for (let key in checkedIns) {
-        if (!['allowSamePerson', 'code', 'eleOrderList', 'groupKey', 'groupName', 'huomian', 'key', 'name'].includes(key)) {
-          ins[key] = checkedIns[key];
-        }
+    })
+
+    productData.mulInsOrderList.forEach(ins => {
+      if (ins.isGroup) {
+        return
       }
-    }
-  });
-
-  const hasSomeCheckedIns = rProductData.mulInsOrderList.some(ins => ins.title);
-  productData.hadChoice = hasSomeCheckedIns;
-  productData.totalBaof = hasSomeCheckedIns ? rProductData.totalBaof : null;
-  productData.companyName = rProductData.companyName;
-
-  let insShowArr = null;
-  if (rProductData.insShowArr) {
-    insShowArr = rProductData.insShowArr;
-  } else if (hasSomeCheckedIns) {
-    const hasPayModePremium = rProductData.mulInsOrderList.some(ins => 'payModePremium' in ins && (ins.payModePremium || ins.payModePremium === 0));
-    insShowArr = [['险种', '保额', '保费', '交费期', hasPayModePremium ? '期交保费' : ''].filter(Boolean)];
-    rProductData.mulInsOrderList.forEach(function(ins) {
-      if (ins.title && !ins.resultFormulaRef) {
-        const insResultItem = [
-          ins.name,
-          ins.showPlanDesc ? ins.planDesc : ins.baoeDesc || '-',
-          ins.baofDesc === 0 || ins.baofDesc === '0' || ins.baofDesc ? ins.baof : '-',
-          ins.pPeriodDesc
-        ];
-        if (hasPayModePremium) {
-          insResultItem.push(ins.payModePremiumDesc || '-');
+      const groupInsData = convertEleOrderListToObj(ins)
+      const insuranceId = groupInsData.isCheckbox ? groupInsData.insuranceId[0] : groupInsData.insuranceId
+      const checkedIns = productData.mulInsOrderList.find(i => i.key === insuranceId)
+      for (const key in checkedIns) {
+        if (['allowSamePerson', 'code', 'eleOrderList', 'groupKey', 'groupName', 'huomian', 'key', 'name'].indexOf(key) === -1) {
+          ins[key] = checkedIns[key]
         }
-        insShowArr.push(insResultItem);
       }
-    });
-  }
-  if (insShowArr && insShowArr.length > 1) {
-    productData.insShowArr = insShowArr;
-  } else {
-    productData.insShowArr = null;
+    })
+
+    const hasSomeCheckedIns = rProductData.mulInsOrderList.some(ins => ins.title)
+    productData.hadChoice = hasSomeCheckedIns
+    productData.totalBaof = hasSomeCheckedIns ? rProductData.totalBaof : null
+    productData.companyName = rProductData.companyName
+
+    let insShowArr = null
+    if (rProductData.insShowArr) {
+      insShowArr = rProductData.insShowArr
+    } else if (hasSomeCheckedIns) {
+      const hasPayModePremium = rProductData.mulInsOrderList.some(ins => ins.payModeDesc && ins.payModePremiumDesc)
+      insShowArr = [['投保险种', '保额', '保险期', '交费期', '首年保费', hasPayModePremium ? '期交保费' : ''].filter(Boolean)]
+      rProductData.mulInsOrderList.forEach(function(ins) {
+        if (ins.title && !ins.resultFormulaRef) {
+          const insResultItem = [
+            ins.name,
+            ins.showPlanDesc ? ins.planDesc : ins.baoeDesc || '-',
+            ins.iDurationDesc,
+            ins.pPeriodDesc,
+            ins.baofDesc === 0 || ins.baofDesc === '0' || ins.baofDesc ? ins.baofDesc : '-'
+          ]
+          if (hasPayModePremium) {
+            insResultItem.push(ins.payModePremiumDesc ? `${ins.payModeDesc}${ins.payModePremiumDesc}` : '-')
+          }
+          insShowArr.push(insResultItem)
+        }
+      })
+    }
+    if (insShowArr && insShowArr.length > 1) {
+      productData.insShowArr = insShowArr
+    } else {
+      productData.insShowArr = null
+    }
   }
-  return productData;
+  return productData
 }
 
-export function defaultProductData(eleOrderList) {
-  let timeStamp = new Date().getTime();
-  return {
-    key: timeStamp,
-    titleName: '待完善险种',
-    policyType: 'manual_insurance',
-    mulInsOrderList: [
-      {
-        eleOrderList: eleOrderList,
-        key: timeStamp,
-        title: true
+export function createPlanbookDataToMake(inputData = {}, options = {}) {
+  const { title, theme, categorySort, displayFormatSort, commonData, personData, productGroupList } = cloneDeep(inputData)
+  const _prodOrderList0 = _get(productGroupList, '[0].prodOrderList') || []
+  if (!_prodOrderList0.some(ele => !!ele.hadChoice && !ele.hide)) {
+    return
+  }
+  let hasMultipleInsured = false
+  const _productGroupList = productGroupList.filter(g => g.prodOrderList.some(p => p.hadChoice && !p.hide))
+  _productGroupList.forEach(g => {
+    const _prodOrderList = g.prodOrderList.filter(p => !!p.hadChoice && !p.hide)
+    _prodOrderList.forEach(p => {
+      if (p.multipleInsured) {
+        hasMultipleInsured = true
       }
-    ],
-    liabilityOrderList: [],
-    companyId: null,
-    hide: false,
-    trade: false,
-    companyName: '',
-    autoImport: false,
-    liabilityShowType: 0,
-    required: false
-  };
-}
-
-export function createPlanbookDataToMake(planbookData = {}, options = {}) {
-  let inputData = planbookData && planbookData.initData && planbookData.initData.inputData;
-  let productGroup = inputData.productGroupList && inputData.productGroupList[0];
-  let hadChoiceProducts = productGroup && productGroup.prodOrderList && productGroup.prodOrderList.some(ele => !!ele.hadChoice && !ele.hide);
-  if (hadChoiceProducts) {
-    let resultData = {
-      ...options,
-      companyId: inputData.companyId,
-      recordSetting: inputData.recordSetting,
-      personData: convertPersonData(inputData.personData),
-      productGroupList: [],
-      theme: inputData.theme,
-      commonData: inputData.commonData,
-      displayFormatSort: inputData.displayFormatSort,
-      categorySort: inputData.categorySort,
-      title: inputData.title || document.title,
-      videoTypeKey: planbookData.videoTypeKey
-    };
-
-    inputData.productGroupList.forEach(group => {
-      let reqProductGroup = {
-        key: group.key,
-        prodOrderList: []
-      };
-      group.prodOrderList.forEach(prod => {
-        if (!!prod.hadChoice && !prod.hide) {
-          prod.mulInsOrderList.forEach((ins, iIdx, arr) => {
-            // 结果页需要显示的数据
-            ins.eleOrderInResult = [];
-            let refInsuranceData;
-            //refInsuranceId: -1，关联主险；-2，关联险种自身
-            if (ins.refInsuranceId && ins.refInsuranceId != -2) {
-              if (ins.refInsuranceId == -1) {
-                refInsuranceData = arr[arr[0].key == 'common' ? 1 : 0];
-              } else {
-                refInsuranceData = arr.find(e => e.key === ins.refInsuranceId);
+    })
+  })
+  // 高客-险种类型逻辑：当用户选择的险种类型与后台定义的默认值一致时，服务端不要保存该值
+  // 解决方案：如果元素有 unnecessaryValue，且与元素的 value 值相同时，该元素的 value 设置为 null。该逻辑适用于所有字段
+  _productGroupList.forEach(g => {
+    const _prodOrderList = g.prodOrderList.filter(p => !!p.hadChoice && !p.hide)
+    _prodOrderList
+      .filter(p => Array.isArray(p.mulInsOrderList))
+      .forEach(p => {
+        p.mulInsOrderList
+          .filter(ins => Array.isArray(ins.eleOrderList))
+          .forEach(ins => {
+            ins.eleOrderList.forEach(e => {
+              if (e.unnecessaryValue && e.unnecessaryValue === e.value) {
+                e.value = null
               }
-            }
-            if (refInsuranceData && refInsuranceData.eleOrderList && ins.eleOrderList) {
-              ins.eleOrderList.forEach(ele => {
-                let refElementData = refInsuranceData.eleOrderList.find(e => e.key === ele.key);
-                if (
-                  ['title', 'calMethod', 'customRate', 'company'].indexOf(ele.key) === -1 &&
-                  (!ele.isHide || (ele.isHide && !ele.isDisabled && refElementData && !refElementData.isHide))
-                ) {
-                  ins.eleOrderInResult.push({
-                    value: ele.key,
-                    label: ele.labelName
-                  });
-                }
-              });
-            }
-          });
+            })
+          })
+      })
+  })
+  personData.personOrderList = personData.personOrderList.filter(p => hasMultipleInsured || p.key !== 'insured2Info')
+  const resultData = {
+    ...options,
+    title: title || document.title,
+    theme,
+    displayFormatSort,
+    categorySort,
+    commonData,
+    totalBaof: options.totalBaof || calcTotalBaof(_productGroupList),
+    personData: convertPersonData(personData),
+    productGroupList: []
+  }
+  const productKeyList = []
+  _productGroupList.forEach(group => {
+    const reqProductGroup = {
+      key: group.key,
+      prodOrderList: []
+    }
+    const _prodOrderList = group.prodOrderList.filter(p => !!p.hadChoice && !p.hide)
+    _prodOrderList.forEach(prod => {
+      prod.mulInsOrderList.forEach((ins, i, arr) => {
+        let refInsuranceData = null
+        const _refId = ins.refInsuranceId
+        //refInsuranceId: -1，关联主险；-2，关联险种自身
+        if (_refId && _refId != -2) {
+          if (_refId == -1) {
+            refInsuranceData = arr[arr[0].key == 'common' ? 1 : 0]
+          } else {
+            refInsuranceData = arr.find(e => e.key === _refId)
+          }
+        }
 
-          let productData = convertProductData(prod);
-          productData.mulInsOrderList.forEach(ins => {
-            if (ins.huomian == 'shuangHuomian' && ins.shmInsData && ins.shmInsData.title) {
-              productData.mulInsOrderList.push(ins.shmInsData);
+        const eleOrderInResult = []
+        const _eleOrderList = ins.eleOrderList || []
+        const _refEleOrderList = _get(refInsuranceData, 'eleOrderList') || []
+        _eleOrderList
+          .filter(e => !['title', 'calMethod', 'customRate', 'company'].includes(e.key))
+          .forEach(e => {
+            const _refElementData = _refEleOrderList.find(e => e.key === e.key)
+            if (!e.isHide || (e.isHide && !e.isDisabled && _refElementData && !_refElementData.isHide)) {
+              eleOrderInResult.push({
+                value: e.key,
+                label: e.labelName
+              })
             }
-          });
-          reqProductGroup.prodOrderList.push(productData);
+          })
+        if ('payMode' in ins && ins.payMode) {
+          if (!eleOrderInResult.some(e => e.value === 'payModePremium')) {
+            eleOrderInResult.push({
+              value: 'payModePremium',
+              label: '期交保费'
+            })
+          }
         }
-      });
-      resultData.productGroupList.push(reqProductGroup);
-    });
-    return resultData;
-  } else {
-    return;
-  }
+        ins.eleOrderInResult = eleOrderInResult
+      })
+
+      const productData = convertProductData(prod)
+      productData.mulInsOrderList.forEach(ins => {
+        if (ins.huomian == 'shuangHuomian' && ins.shmInsData && ins.shmInsData.title) {
+          productData.mulInsOrderList.push(ins.shmInsData)
+        }
+      })
+      reqProductGroup.prodOrderList.push(productData)
+      productKeyList.push(productData.key)
+    })
+    resultData.productGroupList.push(reqProductGroup)
+  })
+
+  const insuredInfo = resultData.personData.personOrderList.find(e => e.key === 'insuredInfo')
+  window.WeiyiStatSDK &&
+    window.WeiyiStatSDK.submit('scjhs', {
+      productList: productKeyList.join(),
+      insuredName: insuredInfo.name
+    })
+
+  return cleanNeedlessResultData(resultData)
 }
 
 export function getProductFromInputData(inputData, options = {}) {
-  let product = null;
+  let product = null
   if (inputData.productGroupList && inputData.productGroupList.length) {
-    let groupData = inputData.productGroupList.find(g => g.key === options.groupKey);
-    product = groupData && groupData.prodOrderList && groupData.prodOrderList.find(p => p.key === options.productKey);
+    let groupData = inputData.productGroupList.find(g => g.key === options.groupKey)
+    product = groupData && groupData.prodOrderList && groupData.prodOrderList.find(p => p.key === options.productKey)
   }
-  return product;
+  return product
 }
 
-export function initRecipientData(personData) {
-  let eleOrderList = cloneDeep(personData.eleOrderList);
-  eleOrderList = eleOrderList.filter(ele => !['name', 'sex'].includes(ele.key));
-  eleOrderList.forEach(ele => {
-    if (ele.key === 'title') {
-      ele.componentName = 'cmCommonTitle';
-      ele.isDisabled = false;
-      (ele.label = '封面信息'), (ele.rules = []);
-    }
-  });
-  if (!eleOrderList.find(ele => ele.key === 'shareTitle')) {
-    eleOrderList.push({
-      componentName: 'cmCommonInput',
-      key: 'shareTitle',
-      label: '计划书标题',
-      labelIcon: 'icon-common_problem',
-      maxlength: 16,
-      placeholder: '请输入计划书标题',
-      rules: [
-        {
-          type: 'string',
-          validator(rule, value, callback, source, options) {
-            if (value && value.match(/本金|利息|额度有限|回本|返本|复利|存钱|理财|返佣|赠送|免费|暴利/)) {
-              return new Error('标题不能包含禁用词');
-            }
-            return true;
-          }
-        }
-      ],
-      value: ''
-    });
+export function genProductUniqueKeyWithNS(namespace, groupKey, productKey) {
+  if (groupKey == null || productKey == null) {
+    return ''
   }
-  if (!eleOrderList.find(ele => ele.key === 'coverId')) {
-    eleOrderList.push({
-      componentName: 'cmCommonSelect',
-      key: 'coverId',
-      label: '封面样式',
-      placeholder: '请选择封面样式',
-      isDisabled: true,
-      options: [],
-      value: 1,
-      rules: []
-    });
-  }
-  personData.eleOrderList = eleOrderList;
+  const ns = namespace ? String(namespace) : ''
+  return ns ? `ns:${ns}:${groupKey}:${productKey}` : `${groupKey}:${productKey}`
 }
 
-export async function calculateProductData(inputData, options = {}) {
-  const { planbookId, publicPbUuid, groupKey, productKey, isIgnoreError } = options;
-  if (inputData) {
-    const calcData = await createdProductDataToCalc(inputData, {
+export async function calcProductData(inputData, options, cb) {
+  const { planbookId, publicPbUuid, groupKey, productKey, isIgnoreError, isIgnoreLoading, productCalcNamespace } = options || {}
+  const productUniqueKey = genProductUniqueKeyWithNS(productCalcNamespace, groupKey, productKey)
+  try {
+    const params = await createdProductDataToCalc(inputData, {
       planbookId,
       publicPbUuid,
       groupKey,
       productKey
-    });
-    if (calcData.errorMsg) {
-      if (!isIgnoreError) {
-        Toast(calcData.errorMsg);
-        return Promise.reject(calcData.errorMsg);
+    })
+
+    if (params.errorMsg && !isIgnoreError) {
+      commitProductCalcError(productUniqueKey, params.errorMsg)
+      Toast(params.errorMsg)
+      return Promise.reject(params.errorMsg)
+    }
+    if (['annual_survey', 'compare2'].includes(URL_PARAM.pbType)) {
+      if (inputData.productGroupList) {
+        inputData.productGroupList.forEach(g => {
+          g.defNum = 0
+          g.prodOrderList.forEach(p => {
+            p.required = false
+          })
+        })
       }
     }
-    return fetch(`${PLANBOOK_API_HOSTNAME}/planBook/${publicPbUuid ? 'public' : 'V2'}/calculate`, {
-      method: 'POST',
-      credentials: 'include',
-      headers: {
-        Accept: 'application/json, text/plain, */*',
-        'Content-Type': 'application/x-www-form-urlencoded'
-      },
-      body: QS.stringify(calcData)
-    })
-      .then(response => response.json())
-      .then(res => {
-        const { success, code, info, data } = res;
-        if (success && data) {
-          const productList = [];
-          data.productGroupList.forEach(g => {
-            g.prodOrderList.forEach(p => {
-              productList.push(
-                receiveProductData(inputData, p, {
-                  publicPbUuid,
-                  groupKey,
-                  productKey
-                })
-              );
-            });
-          });
-
-          // 计算结果校验
-          if (Array.isArray(inputData.productGroupList)) {
-            let errorMessage = '';
-            const allProductList = inputData.productGroupList.map(g => g.prodOrderList).flat();
-            const productData = allProductList.find(p => p && p.key === productKey);
-            const mulInsOrderList = _get(productData, 'mulInsOrderList') || [];
-            const hasCalcResultExp = mulInsOrderList.some(ins => ins.calcResultExp);
-            if (hasCalcResultExp) {
-              mulInsOrderList
-                .filter(ins => ins.calcResultExp)
-                .forEach(ins => {
-                  if (!errorMessage) {
-                    const paramMap = getExpressionParamMap(inputData.personData, productData, ins, options);
-                    if (paramMap) {
-                      const exp = ins.calcResultExp.replace(/(%)(\d+)(\.*\w*)(%)/g, 'paramMap.i$2$3').replace(/(%)(\w*\.*\w*)(%)/g, 'paramMap.$2');
-                      errorMessage = eval(exp);
-                      console.log('计算结果校验公式: ', ins.calcResultExp);
-                      console.log('计算结果校验结果: ', errorMessage);
-                    }
-                  }
-                });
-            }
-            if (errorMessage) {
-              return Promise.reject(new Error(errorMessage));
-            }
-          }
+    let resData = null
+    if (publicPbUuid) {
+      resData = await calcPlanbookProduct({
+        jd: params.jd
+      })
+    } else {
+      resData = await calcPlanbookProduct(
+        qs.stringify({
+          jd: params.jd,
+          signature: params.signature,
+          clientVersion: params.clientVersion,
+          isIos: params.isIos
+        }),
+        {
+          isIgnoreLoading
+        }
+      ).catch(err => {
+        return Promise.reject(err)
+      })
+    }
+
+    if (!resData.success || !resData.data) {
+      if (resData.code === '002017') {
+        window.WeiyiStatSDK && window.WeiyiStatSDK.submit('crawler_warning')
+      }
+      const calcFailMsg = resData.info || '计算请求出错'
+      commitProductCalcError(productUniqueKey, calcFailMsg)
+      Toast(calcFailMsg)
+      return
+    }
+
+    if (resData.data.productGroupList) {
+      const productGroupList = resData.data.productGroupList || []
+      productGroupList
+        .filter(g => g.key === groupKey)
+        .map(g =>
+          g.prodOrderList
+            .filter(p => p.key === productKey)
+            .map(p => {
+              return receiveProductData(inputData, p, {
+                planbookId,
+                groupKey: g.key,
+                productKey: p.key
+              })
+            })
+        )
+    }
 
-          return Promise.resolve(productList);
+    if (Array.isArray(inputData.productGroupList)) {
+      const productList = inputData.productGroupList
+        .map(g => g.prodOrderList)
+        .flat()
+        .filter(Boolean)
+      const currentProduct = productList.find(p => p.key === productKey)
+
+      if (currentProduct) {
+        clearAddAndTakeAndAdjustBaoeData(currentProduct)
+      }
+
+      // 计算结果校验
+      const mulInsOrderList = _get(currentProduct, 'mulInsOrderList') || []
+      const hasCalcResultExp = mulInsOrderList.some(ins => ins.calcResultExp)
+      if (hasCalcResultExp) {
+        let errorMessage = ''
+        mulInsOrderList
+          .filter(ins => ins.calcResultExp)
+          .forEach(ins => {
+            if (!errorMessage) {
+              const paramMap = getExpressionParamMap(inputData.personData, currentProduct, ins, options)
+              if (paramMap) {
+                try {
+                  const exp = ins.calcResultExp.replace(/(%)(\d+)(\.*\w*)(%)/g, 'paramMap.i$2$3').replace(/(%)(\w*\.*\w*)(%)/g, 'paramMap.$2')
+                  errorMessage = eval(exp)
+                  console.log('计算结果约束结果: ', errorMessage)
+                } catch (error) {
+                  errorMessage = '校验公式语法错误！'
+                }
+                if (ins.calcResultExp) {
+                  console.log('计算结果约束公式: ', ins.calcResultExp)
+                }
+              }
+            }
+          })
+        if (errorMessage) {
+          commitProductCalcError(productUniqueKey, errorMessage)
+          return Promise.reject({
+            type: 'calcResultError',
+            message: errorMessage
+          })
         }
-        return Promise.reject(new Error(info || `计算失败：${code || ''}`));
-      });
+      }
+    }
+
+    cb && cb()
+    commitProductCalcError(productUniqueKey, null)
+    return Promise.resolve(resData)
+  } catch (err) {
+    const errMsg = typeof err === 'string' ? err : _get(err, 'message') || _get(err, 'info') || '计算请求出错'
+    if (!(_get(err, 'type') === 'calcResultError')) {
+      commitProductCalcError(productUniqueKey, errMsg)
+    }
+    if (typeof err === 'string') {
+      Toast(err)
+    }
+    return Promise.reject(err)
   }
-  return Promise.reject();
 }
 
 export async function doubleCalcProductData(inputData, verifyData, options = {}) {
-  const { planbookId, publicPbUuid, groupKey, productKey, isIgnoreError, eventTarget } = options;
-  const personData = inputData && inputData.personData;
-  const productGroupList = inputData && inputData.productGroupList ? inputData.productGroupList : [];
-  const productGroup = productGroupList.find(g => g.key === groupKey);
-  const prodOrderList = productGroup && productGroup.prodOrderList ? productGroup.prodOrderList : [];
-  const productData = prodOrderList.find(p => p.key === productKey);
-  const mulInsOrderList = productData && productData.mulInsOrderList ? productData.mulInsOrderList : [];
-  const productVerifyData = verifyData && verifyData[productKey];
-  const hasRevalidateFlag = mulInsOrderList.some(ins => ins.revalidateFlag);
+  const { user, planbookId, publicPbUuid, groupKey, productKey, isIgnoreError, productCalcNamespace, executeSource } = options
+  const personData = inputData && inputData.personData
+  const productGroupList = inputData && inputData.productGroupList ? inputData.productGroupList : []
+  const productGroup = productGroupList.find(g => g.key === groupKey)
+  const prodOrderList = productGroup && productGroup.prodOrderList ? productGroup.prodOrderList : []
+  const productData = prodOrderList.find(p => p.key === productKey)
+  const mulInsOrderList = productData && productData.mulInsOrderList ? productData.mulInsOrderList : []
+  const productVerifyData = verifyData && verifyData[productKey]
+  const hasRevalidateFlag = mulInsOrderList.some(ins => ins.revalidateFlag)
   if (productData) {
+    if (productData.multipleInsured) {
+      multipleInsuredHandler(productData, personData)
+    }
     await productDataHandler(productData, productVerifyData, personData, {
+      user,
       planbookId,
-      eventTarget
-    });
-    await calculateProductData(inputData, {
+      executeSource
+    })
+    await calcProductData(inputData, {
+      user,
       planbookId,
       publicPbUuid,
       groupKey,
       productKey,
-      isIgnoreError
-    });
+      executeSource,
+      isIgnoreError,
+      productCalcNamespace
+    })
     if (hasRevalidateFlag) {
       await productDataHandler(productData, productVerifyData, personData, {
+        user,
         planbookId,
-        eventTarget
-      });
-      await calculateProductData(inputData, {
+        executeSource
+      })
+      await calcProductData(inputData, {
+        user,
         planbookId,
         publicPbUuid,
         groupKey,
         productKey,
-        isIgnoreError
-      });
+        executeSource,
+        isIgnoreError,
+        productCalcNamespace
+      })
     }
   }
 }
 
-export function setupUnderwriteRuleToInputData(data) {
-  const inputData = cloneDeep(data);
-  if (inputData) {
-    const productGroupList = _get(inputData, 'productGroupList') || [];
-    const productList = productGroupList
-      .map(g => g.prodOrderList)
-      .filter(Boolean)
-      .flat();
-    const insuranceList = productList
-      .map(p => p.mulInsOrderList)
-      .filter(Boolean)
-      .flat();
-    const insuranceIds = insuranceList
-      .map(ins => ins.key)
-      .filter(k => !['common'].includes(k))
-      .filter(Boolean);
-
-    return fetch(`${PLANBOOK_API_HOSTNAME}/planBook/interest/underwrite/effective-rules`, {
-      method: 'POST',
-      credentials: 'include',
-      headers: {
-        Accept: 'application/json, text/plain, */*',
-        'Content-Type': 'application/json;'
-      },
-      body: JSON.stringify(insuranceIds)
+export function calcAllProductData(inputData, verifyData, options) {
+  const { planbookId, publicPbUuid, userUuid, appid, productCalcNamespace, executeSource } = options
+  const productGroupList = (_get(inputData, 'productGroupList') || []).filter(g => g.prodOrderList)
+  const prodOrderList = productGroupList
+    .map(g => g.prodOrderList)
+    .flat()
+    .filter(p => p.hadChoice)
+  if (prodOrderList.length) {
+    let allProductCalcCount = options.allProductCalcCount != null ? options.allProductCalcCount : 0
+    const calcStore = getProductCalcVuexStore()
+    if (calcStore && calcStore._mutations && calcStore._mutations.CLEAR_PRODUCT_CALC_ERROR_MAP) {
+      calcStore.commit('CLEAR_PRODUCT_CALC_ERROR_MAP', productCalcNamespace)
+    }
+    const promises = productGroupList
+      .map(g => {
+        return g.prodOrderList
+          .filter(p => p.hadChoice)
+          .filter(p => !['single_insurance', 'noconfig_insurance', 'manual_insurance'].includes(p.policyType))
+          .map(p => {
+            if (p.policyType === 'online_trade') {
+              return
+            }
+            return doubleCalcProductData(inputData, verifyData, {
+              planbookId,
+              executeSource,
+              publicPbUuid,
+              groupKey: g.key,
+              productKey: p.key,
+              isIgnoreError: true,
+              isIgnoreLoading: true,
+              productCalcNamespace
+            })
+          })
+      })
+      .flat()
+
+    window.appBridge.showLoading()
+    return Promise.all(promises)
+      .then(res => {
+        Dialog.close()
+        return res
+      })
+      .catch(err => {
+        const errorType = err && err.type
+        const errorMessage = typeof err === 'string' ? err : _get(err, 'message') || '未知错误'
+        const isVerifyError = errorMessage === '请选择险种'
+        const isRestrictError = ['002012', '002013', '002015'].includes(_get(err, 'code'))
+        const isNeedConfirm = !(isVerifyError || isRestrictError || ['calcResultError'].includes(errorType))
+        if (isNeedConfirm) {
+          allProductCalcCount += 1
+          Dialog.confirm({
+            title: '保费计算超时',
+            message: allProductCalcCount > 1 ? '建议检查网络或点击反馈问题。' : '当前网络不稳定，导致保费计算失败。为避免保费不准确，请检查网络后重试。',
+            cancelButtonText: '退出',
+            confirmButtonText: allProductCalcCount > 1 ? '反馈问题' : '重试'
+          })
+            .then(() => {
+              window.WeiyiStatSDK && window.WeiyiStatSDK.submit(allProductCalcCount > 1 ? 'JHS_JSCW_FK' : 'JHS_JSCW_CS')
+              if (allProductCalcCount > 1) {
+                location.href = `https://pbf.winbaoxian.cn/planBook/projectGroup/feedback/index.html?type=0&planbookId=${planbookId}&tagId=3`
+              } else {
+                calcAllProductData(inputData, verifyData, {
+                  ...options,
+                  allProductCalcCount
+                })
+              }
+            })
+            .catch(() => {
+              goBack()
+            })
+        } else if (['calcResultError'].includes(errorType) && errorMessage) {
+          Toast(errorMessage)
+        }
+
+        window.WeiyiStatSDK &&
+          window.WeiyiStatSDK.submit('JHS_JSCW', {
+            localUuid: localStorage.getItem('intellectScheme') ? JSON.parse(localStorage.getItem('intellectScheme'))[`s${planbookId}`] : null,
+            productIds: prodOrderList.map(p => p.key).join(','),
+            errorMessage
+          })
+        return Promise.reject(err)
+      })
+      .finally(() => {
+        window.appBridge.hideLoading()
+      })
+  }
+  return Promise.reject('请选择投保产品')
+}
+
+export async function makePlanbook(inputData, options = {}) {
+  if (!inputData) {
+    return Promise.reject()
+  }
+  const { pbType, userUuid, insuranceTypeId, videoTypeKey } = options
+  const reqData = createPlanbookDataToMake(inputData, {
+    pbType: pbType || '',
+    userUuid,
+    insuranceTypeId,
+    videoTypeKey
+  })
+  if (!reqData) {
+    Toast('请选择险种')
+    return Promise.reject()
+  }
+
+  const reqDataStr = JSON.stringify(reqData)
+  const groupDataKey = _get(inputData, 'productGroupList[0].key')
+  const signature = await getSecurityToken(reqDataStr, {
+    groupDataKey
+  })
+  return uploadPlanBookResult(
+    qs.stringify({
+      jd: JSON.stringify(reqData),
+      userUuid,
+      signature,
+      clientVersion: appVersion,
+      isIos
     })
-      .then(response => response.json())
-      .then(({ success, data }) => {
-        if (success && Array.isArray(data)) {
-          insuranceList.forEach(ins => {
-            const ruleData = data.find(rule => rule.insruanceId === ins.key);
-            if (ruleData) {
-              const insExpKeys = ['customVariableExp', 'calcResultExp', 'revalidateFlag'];
-              insExpKeys
-                .filter(k => k in ruleData)
-                .forEach(key => {
-                  ins[key] = ruleData[key];
-                });
-              if (Array.isArray(ins.eleOrderList) && Array.isArray(ruleData.eleRules)) {
-                ins.eleOrderList.forEach(ele => {
-                  const eleRule = ruleData.eleRules.find(rule => rule.elementKey === ele.key);
-                  const eleExpkeys = ['defaultValueExp', 'maxExp', 'minExp', 'multiExp', 'underwriteExp'];
-                  if (eleRule) {
-                    eleExpkeys
-                      .filter(k => k in eleRule)
-                      .forEach(key => {
-                        ele[key] = eleRule[key];
-                      });
+  ).then(({ success, data, info }) => {
+    if (!success || !data) {
+      Toast(info || '生成计划书失败')
+      return Promise.reject()
+    }
+    return Promise.resolve(data)
+  })
+}
+
+export function convertInputDataToResultData(inputData, options = {}) {
+  let resultData = null
+  if (inputData) {
+    const { title, theme, categorySort, displayFormatSort, commonData, personData, productGroupList, addedServiceList = [] } = cloneDeep(inputData)
+    const { insuranceTypeId, pbType, planName, userUuid } = options
+    resultData = {
+      insuranceTypeId,
+      pbType,
+      planName,
+      userUuid,
+      title: title || document.title,
+      theme,
+      displayFormatSort,
+      categorySort,
+      addedServiceList,
+      commonData,
+      personData: convertPersonData(personData),
+      productGroupList: [],
+      totalBaof: null
+    }
+
+    const _productGroupList = productGroupList.filter(g => (g.prodOrderList || []).some(p => p.hadChoice && !p.hide))
+    if (_productGroupList.length) {
+      _productGroupList.forEach(g => {
+        g.prodOrderList = g.prodOrderList.filter(p => p.hadChoice && !p.hide)
+      })
+
+      _productGroupList.forEach(group => {
+        const _productGroup = {
+          key: group.key,
+          prodOrderList: []
+        }
+        group.prodOrderList.forEach(prod => {
+          const mainInsurance = prod.mulInsOrderList.find(ins => ins.key !== 'common')
+          prod.mulInsOrderList.forEach((ins, i, arr) => {
+            if (Array.isArray(ins.eleOrderList)) {
+              // 用于结果页控制字段显示顺序
+              const eleOrderInResult = []
+              // refInsuranceId: -1-主险 -2-险种自身
+              const _refId = Number(ins.refInsuranceId)
+              let refInsuranceData = null
+              if (_refId && _refId !== -2) {
+                refInsuranceData = _refId === -1 ? mainInsurance : arr.find(e => e.key === _refId)
+              }
+
+              const _refEleOrderList = _get(refInsuranceData, 'eleOrderList') || []
+              ins.eleOrderList
+                .filter(e => !['title', 'calMethod', 'customRate', 'company'].includes(e.key))
+                .forEach(e => {
+                  const _refElementData = _refEleOrderList.find(e => e.key === e.key)
+                  if (!e.isHide || (e.isHide && !e.isDisabled && _refElementData && !_refElementData.isHide)) {
+                    eleOrderInResult.push({
+                      value: e.key,
+                      label: e.labelName
+                    })
                   }
-                });
+                })
+              if ('payMode' in ins && ins.payMode) {
+                if (!eleOrderInResult.some(e => e.value === 'payModePremium')) {
+                  eleOrderInResult.push({
+                    value: 'payModePremium',
+                    label: '期交保费'
+                  })
+                }
               }
+              ins.eleOrderInResult = eleOrderInResult
             }
-          });
-          return inputData;
-        }
-      });
+          })
+
+          const productData = convertProductData(prod)
+          // 双豁免险种处理
+          productData.mulInsOrderList.forEach(ins => {
+            const { huomian, shmInsData } = ins
+            if (huomian === 'shuangHuomian' && shmInsData && shmInsData.title) {
+              productData.mulInsOrderList.push(shmInsData)
+            }
+          })
+          _productGroup.prodOrderList.push(productData)
+        })
+        resultData.productGroupList.push(_productGroup)
+      })
+      resultData.totalBaof = calcTotalBaof(_productGroupList)
+    }
   }
+  return resultData
+}
 
-  return inputData;
+export function cleanNeedlessResultData(resultData) {
+  const pureResultData = cloneDeep(resultData)
+  if (pureResultData) {
+    const productGroupList = _get(pureResultData, 'productGroupList') || []
+    productGroupList
+      .filter(g => g.prodOrderList)
+      .forEach(g => {
+        g.prodOrderList.forEach(p => {
+          const noNeedProductKeys = ['constraintRules', 'inputResultSwitch', 'insShowArr', 'isShowDeleteButton', 'restrictList']
+          noNeedProductKeys.forEach(k => {
+            if (k in p) {
+              delete p[k]
+            }
+          })
+          if (Array.isArray(p.mulInsOrderList)) {
+            p.mulInsOrderList.forEach(ins => {
+              const noNeedInsuranceKeys = ['isFollowing', 'isCheckbox', 'condotionList', 'customVariableExp', 'calcResultExp', 'revalidateFlag']
+              noNeedInsuranceKeys.forEach(k => {
+                if (k in ins) {
+                  delete ins[k]
+                }
+              })
+            })
+          }
+        })
+      })
+  }
+  return pureResultData
+}
+
+// 获取产品险种标签；入参过滤与 findInsuranceTag().catch 与 compare3 fetchInsuranceSaleStatusMap 一致
+export async function getProductInsuranceTags(inputData, options = {}, key = 'salesStatus') {
+  const product = getProductFromInputData(inputData, options)
+  const mulInsOrderList = (_get(product, 'mulInsOrderList') || []).filter(ins => !ins.isGroup)
+
+  if (!mulInsOrderList.length) {
+    return {}
+  }
+  const insuranceKeys = mulInsOrderList.map(ins => ins.key)
+  const keys = insuranceKeys.filter(k => {
+    if (k == null) return false
+    if (typeof k === 'number') return Number.isFinite(k)
+    if (typeof k === 'string') {
+      const t = k.trim()
+      if (t === '') return false
+      return Number.isFinite(Number(t))
+    }
+    return false
+  })
+  if (!keys.length) {
+    return {}
+  }
+  const res = await findInsuranceTag(keys).catch(() => {})
+  const list = _get(res, 'data') || []
+  const byInsuranceId = new Map()
+  list.forEach(item => {
+    if (item && item.insuranceId != null) {
+      byInsuranceId.set(String(item.insuranceId), item)
+    }
+  })
+  const tagMap = {}
+  mulInsOrderList.forEach(ins => {
+    const row = byInsuranceId.get(String(ins.key))
+    if (row && Object.prototype.hasOwnProperty.call(row, key)) {
+      tagMap[ins.key] = row[key]
+    }
+  })
+  return tagMap
+}
+
+export async function setupUnderwriteRuleToInputData(data) {
+  const inputData = cloneDeep(data)
+  if (inputData) {
+    const insuranceList = (_get(inputData, 'productGroupList') || [])
+      .map(g => g.prodOrderList)
+      .flat()
+      .map(p => p && p.mulInsOrderList)
+      .flat()
+      .filter(ins => ins && !['common'].includes(ins.key))
+    await setupUnderwriteRuleToInsuranceList(insuranceList).catch(() => {})
+  }
+  return inputData
+}
+
+export function setupUnderwriteRuleToInsuranceList(list) {
+  if (Array.isArray(list)) {
+    const insuranceIds = list.map(ins => ins.key)
+    return getUnderwriteEffectiveRules(insuranceIds).then(data => {
+      if (Array.isArray(data)) {
+        data.forEach(rule => {
+          const { insruanceId, eleRules } = rule
+          const insurance = list.find(ins => ins.key === insruanceId)
+          if (insurance) {
+            const insExpKeys = ['customVariableExp', 'calcResultExp', 'revalidateFlag']
+            insExpKeys
+              .filter(k => k in rule)
+              .forEach(key => {
+                insurance[key] = rule[key]
+              })
+            const eleOrderList = insurance.eleOrderList || []
+            if (eleOrderList && Array.isArray(eleRules)) {
+              eleOrderList.forEach(ele => {
+                const eleRule = eleRules.find(e => e.elementKey === ele.key)
+                if (eleRule) {
+                  const eleExpkeys = ['defaultValueExp', 'maxExp', 'minExp', 'multiExp', 'underwriteExp']
+                  eleExpkeys
+                    .filter(k => k in eleRule)
+                    .forEach(key => {
+                      ele[key] = eleRule[key]
+                    })
+                }
+              })
+            }
+          }
+        })
+        return list
+      }
+    })
+  }
+  return list
 }