foundation/designer.approve.2.git

import * as api from '@/api';
import * as tools from '@/utils/tools.js';
import * as format from '@/utils/format.js'
 
import store from '@/store';
 
const dictCache = {};
 
import {useSettingStore, useEntityStore} from '@/store/modules';
 
const langeMap = {
  label: {
    'zh': 'labelchinese',
    'en': 'labelenglish'
  },
  dict: {
    'zh': 'value',
    'en': 'code'
  }
}
 
const typeMap = {
  'Input': 'el-input',
  'popup': 'el-input-dialog',
  'select': 'el-select',
  'span': 'el-input',
  'switch': 'el-switch',
  'textarea': 'el-input',
  'year': 'year',
  'month': 'month',
  'date': 'el-date-picker',
  'daterange': 'daterange',
  'number': 'el-input-number'
}
 
const formatMap = {
  'formatter_date': format.date,
  'formatter_percent': format.percent,
  'formatter_percent100': format.percent100,
  'formatter_money': format.money,
}
 
/**
 * meta转换成 [{prop: 'id', type: "id", label: "id", fixed: true, sortable: 'id', width: 300}]
 * @param meta
 */
const metaConvertColumns = async (list) => {
 
  const settingsStore = useSettingStore(store);
 
  const column = [];
 
  const selectMap = {};
 
  let selectData = list.map(e => e.select_data_name).filter(Boolean);
 
  selectData = [...new Set(selectData)];
 
  // const {data} = await entityStore.getEntitySet({
  //   dataName: e.select_data_name,
  // });
  //
  // options.select = {
  //   placeholder: '请选择',
  //   options: data.entityset,
  //   clearable: true,
  //   valueKey: e.select_code_field,
  //   labelKey: e.select_name_field,
  // }
 
  if (selectData.length) {
    const res = await Promise.all(
      selectData.map(e =>
        api.entity.getEntitySet({
          dataName: e
        })
      )
    );
 
    selectData.forEach((e, i) => {
      selectMap[e] = res[i].data.entityset;
    });
  }
 
 
  list.forEach(item => {
    if (item['is_list']) {
      const prop = item.field;
      const align = item.align || 'center';
      const label = tools.decode(item[langeMap.label[settingsStore.language]]);
      const width = item.width;
      const type = item.optionsgroup ? 'dict' : item.select_data_name ? 'select' : '';
      const dict = item.optionsgroup ? Object.fromEntries(dictCache[item.optionsgroup].map(e => [e.code, e[langeMap.dict[settingsStore.language]]])) : {};
      const select = item.select_data_name ? Object.fromEntries(selectMap[item.select_data_name].map(e => [e[item.select_code_field], e[item.select_name_field]])) : {};
 
      column.push({
        type,
        format: formatMap[item.formatter] || ((e) => e),
        options: {
          dict,
          select
        },
        prop,
        label,
        group: tools.decode(item.table_group_name),
        table: {
          fixed: item.isfixed,
          sortable: prop,
          width,
          align
        },
        card: {
          span: 8
        }
      });
    }
  });
  return column;
}
 
 
/**
 * meta转换成 [  {
 *     type: 'el-input',
 *     prop: 'name',
 *     col: {
 *       span: 8
 *     },
 *     item: {
 *       label: '名称',
 *       prop: 'name'
 *     },
 *     input: {
 *       placeholder: '请输入'
 *     }
 *   },]
 * @param meta
 */
const metaConvertFields = async (list) => {
 
  const settingsStore = useSettingStore(store);
  const entityStore = useEntityStore();
 
  const fields = [];
  for (const e of list) {
    if (e['is_form']) {
      let type = typeMap[e.inputtype] || 'el-input';
 
      const col = {span: 12};
      const prop = e.field;
      const {required} = e;
      const item = {
        prop,
        label: tools.decode(e[langeMap.label[settingsStore.language]])
      }
      const label = tools.decode(e[langeMap.label[settingsStore.language]]);
 
      if (required) {
        item.rules = [{required: true, message: `${label}为必填!`}];
      }
 
      /**
       * 字典先刷类型
       */
      if (e.optionsgroup) {
        type = 'el-select';
      }
 
      let options = {};
 
      if (type === 'el-input') {
        options = {input: {placeholder: '请输入'}}
      }
 
 
      if (type === 'el-select') {
        options = {select: {filterable: true, options: []}};
 
        /**
         * 字典
         */
        if (e.optionsgroup) {
          let _options = [];
          _options = (dictCache[e.optionsgroup] || []).map(e => ({
            name: e.code,
            label: e[langeMap.dict[settingsStore.language]]
          }));
 
          options.select = {
            filterable: true,
            placeholder: '请选择',
            options: _options,
            clearable: true,
            valueKey: 'name',
            labelKey: 'label',
          }
        }
 
        /**
         * 自定义类型
         */
        if (e.select_data_name) {
 
          const {data} = await entityStore.getEntitySet({
            dataName: e.select_data_name,
          });
 
          options.select = {
            filterable: true,
            placeholder: '请选择',
            options: data.entityset,
            clearable: true,
            valueKey: e.select_code_field,
            labelKey: e.select_name_field,
          }
        }
      }
 
      const field = {
        group:  tools.decode(e.group_name),
        format: formatMap[e.formatter] || ((e) => e),
        type,
        prop,
        col,
        item,
        label,
        ...options
      }
      fields.push(field);
    }
  }
  return fields;
}
 
const useMetaData = (
  dataName,
  mounted = () => {
  }
) => {
  const entityStore = useEntityStore();
 
  const filters = [];
  const fields = [];
  const columns = [];
 
  nextTick(async () => {
    const [columnsMeta, fieldsMeta] = await Promise.all([
      api.entity.getEntitySet({
        dataName,
        attachMeta: true,
        filter: '1 != 1'
      }),
      api.entity.getEntity({
        dataName,
        attachMeta: true,
        filter: '1 != 1'
      })]
    )
 
    let groups = [...columnsMeta.meta[dataName].fields, ...fieldsMeta.meta[dataName].fields].map(e => e.optionsgroup).filter(Boolean).filter(e => !dictCache[e]);
    groups = [...new Set(groups)];
    if (groups.length) {
      const res = await Promise.all(
        groups.map(key =>
          api.entity.getOldEntitySet({
            dataName: 'dictitem',
            filter: " parent_id = '" + key + "'"
          })
        ));
 
      groups.forEach((e, i) => {
        dictCache[e] = res[i].data.entityset;
      });
 
    }
 
    const result = await Promise.all([metaConvertFields(fieldsMeta.meta[dataName].fields), metaConvertColumns(columnsMeta.meta[dataName].fields)]);
    result[0].forEach(e => {
      fields.push(e);
      columnsMeta.meta[dataName].fields.forEach(f => {
        if (f.field === e.prop && f.isfilter) {
          filters.push(e);
        }
      });
    });
 
    result[1].forEach(e => {
      columns.push(e);
    });
 
    const fieldsTools = {
      remove: (prop) => {
        fields.forEach((e, i) => {
          if (e.prop === prop) {
            fields.splice(i, 1);
          }
        })
      },
      assign: (prop, field) => {
        fields.forEach((e) => {
          if (e.prop === prop) {
            Object.keys(field).forEach(key => {
              if (e[key] && typeof e[key] === 'object') {
                e[key] = Object.assign(e[key], field[key]);
              } else {
                e[key] = field[key];
              }
            })
          }
        })
      },
      splice: (index, delNum, field) => {
        fields.splice(index, delNum, field);
      },
      selectEntitySet: async (prop, dataName, labelKey, valueKey) => {
        const {data} = await entityStore.getEntitySet({dataName});
        fields.forEach((e) => {
          if (e.prop === prop) {
            e.type = 'el-select';
            e.select = {
              placeholder: '请选择',
              options: data.entityset,
              clearable: true,
              valueKey,
              labelKey,
            }
          }
        });
      }
    }
 
    const columnsTools = {
      remove: (prop) => {
        columns.forEach((e, i) => {
          if (e.prop === prop) {
            columns.splice(i, 1);
          }
        })
      },
      assign: (prop, column) => {
        columns.forEach((e) => {
          if (e.prop === prop) {
            Object.keys(column).forEach(key => {
              if (e[key] && typeof e[key] === 'object') {
                e[key] = Object.assign(e[key], column[key]);
              } else {
                e[key] = column[key];
              }
            })
          }
        })
      },
      splice: (index, delNum, column) => {
        columns.splice(index, delNum, column);
      },
      selectEntitySet: async (prop, dataName, labelKey, valueKey) => {
        const {data} = await entityStore.getEntitySet({dataName});
        columns.forEach((e) => {
          if (e.prop === prop) {
            e.type = 'el-select';
            e.select = {
              placeholder: '请选择',
              options: data.entityset,
              clearable: true,
              valueKey,
              labelKey,
            }
          }
        });
      }
    }
 
    const filtersTools = {
      assign: (prop, filter) => {
        filters.forEach((e) => {
          if (e.prop === prop) {
            Object.keys(filter).forEach(key => {
              if (e[key] && typeof e[key] === 'object') {
                e[key] = Object.assign(e[key], filter[key]);
              } else {
                e[key] = filter[key];
              }
            })
          }
        })
      },
      splice: (index, delNum, filter) => {
        filters.splice(index, delNum, filter);
      },
      selectEntitySet: async (prop, dataName, labelKey, valueKey) => {
        const {data} = await entityStore.getEntitySet({dataName});
        filters.forEach((e) => {
          if (e.prop === prop) {
            e.type = 'el-select';
            e.select = {
              placeholder: '请选择',
              options: data.entityset,
              clearable: true,
              valueKey,
              labelKey,
            }
          }
        });
      }
    }
 
    mounted({columns, filters, fields, fieldsTools, filtersTools, columnsTools});
  });
 
  return [columns, filters, fields];
}
 
export default {
  useMetaData
};