ibsp-fg-page 4.0.2

package/src/models/app/uni/useUniAction.ts

@@ -0,0 +1,174 @@
+import { reactive } from 'vue';
+import IbspEvents from '@models/tools/IbspEvents';
+
+export default (
+  app:IBSP.IbspAPP.APP
+)=>{
+
+  const state = reactive({
+    safeDistance: {
+      top: 0,
+      bottom: 0
+    },
+    currentScanContent: ''
+  })
+
+  const _uniEvent = new IbspEvents()
+  const _uniWebviewContainer = new Map<string, any[]>()
+  let currentScanCodeCallback:any = null
+
+  const print_callback:Record<string, null | Function> = {
+    queryPrinter: null,
+    connectPrinter: null,
+    closePrinter: null,
+    printing: null,
+    getPrinterName: null,
+    pausePrint: null,
+    isPrinterOpened: null
+  }
+
+
+  _uniEvent.on('scanCode', (res:any)=>{
+    state.currentScanContent = res;
+    if (currentScanCodeCallback) {
+      currentScanCodeCallback(res.value)
+      currentScanCodeCallback = null
+    }
+  })
+
+  _uniEvent.on('safeDistance', (top:number, bottom:number)=>{
+    state.safeDistance.top = top;
+    state.safeDistance.bottom = bottom;
+  })
+
+  _uniEvent.on('uniCallback', (name:string, ...args:any)=>{
+    const callback_list = _uniWebviewContainer.get(name)
+    if (callback_list?.length) {
+      callback_list.forEach((callback:any) => {
+        callback(...args)
+      })
+    }
+  })
+
+  _uniEvent.on('queryPrinter', (res:any)=>{
+    print_callback.queryPrinter?.(res?.value)
+  })
+
+  _uniEvent.on('connectPrinter', (res:any)=>{
+    print_callback.connectPrinter?.(res?.value)
+  })
+
+  _uniEvent.on('closePrinter', (res:any)=>{
+    print_callback.closePrinter?.(res?.value)
+  })
+
+  _uniEvent.on('printing', (res:any)=>{
+    print_callback.printing?.(res?.value)
+  })
+
+
+  _uniEvent.on('pausePrint', (res:any)=>{
+    print_callback.pausePrint?.(res?.value)
+  })
+
+  _uniEvent.on('printProgress', (res:any)=>{
+    print_callback.printProgress?.(res?.value)
+  })
+
+  _uniEvent.on('getPrinterInfo', (res:any)=>{
+    print_callback.getPrinterInfo?.(res?.value)
+  })
+  _uniEvent.on('isPrinterOpened', (res:any)=>{
+    print_callback.isPrinterOpened?.(res?.value)
+  })
+
+
+  const queryPrinter = (callback:Function)=>{
+    print_callback.queryPrinter = callback
+    window.uni.postMessage({ data: { type: 'print', params: {
+      type: 'queryPrinter'
+    } } })
+  }
+
+  const getPrinterInfo = (callback:Function)=>{
+    print_callback.getPrinterInfo = callback
+    window.uni.postMessage({ data: { type: 'print', params: {
+      type: 'getPrinterInfo'
+    } } })
+  }
+
+  const connectPrinter = (name:string, callback:Function)=>{
+    print_callback.connectPrinter = callback
+    window.uni.postMessage({ data: { type: 'print', params: {
+      type: 'connectPrinter',
+      name
+    } } })
+
+  }
+
+  const closePrinter = (callback:Function)=>{
+    print_callback.closePrinter = callback
+    window.uni.postMessage({ data: { type: 'print', params: {
+      type: 'closePrinter'
+    } } })
+  }
+
+  const printing = (data:string, callback:Function)=>{
+    print_callback.printing = callback
+    window.uni.postMessage({ data: { type: 'print', params: {
+      type: 'printing',
+      data
+    } } })
+  }
+
+  const pausePrint = (callback:Function)=>{
+    print_callback.pausePrint = callback
+    window.uni.postMessage({ data: { type: 'print', params: {
+      type: 'pausePrint'
+    } } })
+  }
+
+  const isPrinterOpened = (callback:Function)=>{
+    print_callback.isPrinterOpened = callback
+    window.uni.postMessage({ data: { type: 'print', params: {
+      type: 'isPrinterOpened'
+    } } })
+  }
+
+  const emitScanCode = (callback:(...args:any)=>void)=>{
+    window.uni.postMessage({ data: { type: 'scanCode' } })
+    currentScanCodeCallback = callback
+  }
+
+  const emitUniFun = (fun_name:string, fun_callback:(...args:any)=>void, ...args:any)=>{
+    window.uni.postMessage({ data: { type: 'emitUni', params: {
+      name: fun_name,
+      args: args
+    } } })
+    if (_uniWebviewContainer.has(fun_name)) {
+      _uniWebviewContainer.get(fun_name)!.push(fun_callback)
+      return
+    }
+    _uniWebviewContainer.set(fun_name, [fun_callback])
+  }
+
+  const printProgress = (callback:Function)=>{
+    print_callback.printProgress = callback
+  }
+
+
+  return {
+    state,
+    _uniEvent,
+    emitScanCode,
+    emitUniFun,
+    queryPrinter,
+    connectPrinter,
+    closePrinter,
+    printing,
+    pausePrint,
+    getPrinterInfo,
+    printProgress,
+    isPrinterOpened
+  }
+}

package/src/models/command/CommandTypes.d.ts

@@ -0,0 +1,24 @@
+
+type CommandTypes = {
+  /** 复制组件 */
+  'copyComponent': '复制组件',
+  'pasteComponent': '粘贴组件',
+  'cutComponent': '剪切组件',
+  'hideComponent': '隐藏组件',
+  'deleteComponent': '删除组件',
+  'group.create': '创建组合',
+  'group.remove': '删除组合',
+  'group.remove.drag': '删除拖拽组合的逻辑函数',
+  'sort.moveTop': '置于顶层',
+  'sort.moveUp': '上移一层',
+  'sort.moveDown': '下移一层',
+  'sort.moveBottom': '置于底层',
+  'layout.clear': '清空布局内容',
+  'layout.remove': '移除布局',
+  'component.hide': '隐藏组件',
+  'layout.add': '新增布局',
+  'group.mark.close': '关闭组合标记',
+  'page.clear': '清空页面',
+  'component.create':'创建组件',
+  'dataSource.open': '打开数据源',
+}

package/src/models/command/index.ts

@@ -0,0 +1,40 @@
+
+class Commands <T extends keyof CommandTypes > {
+
+  private _commands: Map<T, Function> = new Map();
+
+  constructor() {
+
+  }
+
+  register(commandKey: T, callback: Function) {
+    this._commands.set(commandKey, callback);
+  }
+
+  execute(commandKey: T, ...args: any) {
+    const cb = this._commands.get(commandKey)
+
+    if (cb) {
+      cb(...args);
+    }
+  }
+
+}
+
+
+const commands = new Commands();
+
+const useCommand = () => {
+  return commands;
+}
+
+export const registerCommand = <T extends keyof CommandTypes > (commandKey: T, callback: Function) => {
+  commands.register(commandKey, callback);
+  return registerCommand;
+}
+export const executeCommand = <T extends keyof CommandTypes > (commandKey: T, ...args: any) => {
+  commands.execute(commandKey, ...args);
+  return executeCommand;
+}
+
+export default useCommand;

package/src/models/component/index.ts

@@ -0,0 +1,56 @@
+import type { ComponentInternalInstance } from 'vue';
+
+// TODO
+class BaseComponent {
+
+  ref = {
+    dom: null
+  }
+  componentRef: any;
+  baseStyle = {
+    color: '',
+    fontSize: 14,
+    '--backgroundType': 'none',
+    backgroundImage: '',
+    backgroundColor: '',
+    '--visibilityWidth': 'left,right,top,bottom',
+    '--originalWidth': '0px',
+    borderStyle: 'none',
+    borderColor: 'rgba(229, 229, 229, 1)',
+    borderRadius: '0px',
+    paddingLeft: '0px',
+    paddingRight: '0px',
+    paddingTop: '0px',
+    paddingBottom: '0px',
+    marginLeft: '0px',
+    marginRight: '0px',
+    marginTop: '0px',
+    marginBottom: '0px',
+    visibility: true,
+    borderWidth: '0px',
+    backgroundRepeat: 'no-repeat',
+    '--backgroundSize-w': '',
+    '--backgroundSize-h': '',
+    '--backgroundPosition-x': '',
+    '--backgroundPosition-y': '',
+    '--backgroundSize-type': '',
+    '--show-visibility': '1',
+    '--bg-resource': ''
+  }
+  methods = {}
+  interactionDataList = []
+  customResources = {
+    css: {
+      state: false,
+      content: ''
+    },
+    js: {
+      state: false,
+      content: ''
+    }
+  }
+  setRef(el: any) {
+    this.componentRef = el;
+  }
+
+}

package/src/models/dataModel/index.ts

@@ -0,0 +1,243 @@
+import { reactive, ref, watch, shallowRef, type Ref, markRaw } from 'vue';
+import { isPlainObject } from 'lodash-es';
+
+import DataView from './models/DataView';
+import ServiceInterface from './models/ServiceInterface';
+import CategoryDict from './models/CategoryDict';
+import Script from './models/Script';
+import Static from './models/Static';
+
+type DataModelSource = {
+  dataView: DataView;
+  serviceInterface: ServiceInterface;
+  categoryDict: CategoryDict;
+  script: Script;
+  static: Static;
+};
+
+type dataSconceValues = {
+  data: Ref<any[]>;
+  refreshData: Function;
+  config: any;
+  builtInMethods: any;
+  builtInData: Ref<any>;
+  fields: Ref<any[]>;
+  queryList: Ref<any>;
+  commonFields:any
+};
+
+
+export default class IbspDataModel {
+  page: IBSP.IPage.Page;
+
+  // @ts-ignore
+  sources: DataModelSource = {};
+
+  pageDataSource: IBSP.IPage.Page['pageDataSource'];
+
+  constructor(page: IBSP.IPage.Page) {
+    this.page = page;
+    this.pageDataSource = this.page.pageDataSource;
+    this.loadBaseModel();
+  }
+
+  loadBaseModel() {
+    this.sources.dataView = new DataView(this.page);
+    this.sources.serviceInterface = new ServiceInterface(this.page);
+    this.sources.categoryDict = new CategoryDict(this.page);
+    this.sources.script = new Script(this.page);
+    this.sources.static = new Static(this.page);
+  }
+
+  _dataInitQueue = new Map<string, ((res:any)=>void)[]>();
+
+  /**
+   *
+   * @param id 数据源id
+   */
+  private useDataSconce = (
+    id: string | {
+      id:string
+    },
+    options: any
+  ): any => {
+
+    const _id = typeof id === 'string' ? id : id?.id;
+
+
+    const {
+      initData = true,
+      page = this.page,
+      initBuiltInData = false,
+      watch: _watch = null,
+      loaded = null,
+      beforeLoad = null
+    } = options || {};
+
+
+    const data = shallowRef([]);
+    const builtInData = ref<any>({});
+    const queryList = ref<any>({});
+    const fields = ref([])
+    const enterParams = ref<any>([]);
+    const selectFields = ref<any>([]);
+    const loading = ref(false);
+    const error = ref(null);
+    const response = ref({})
+
+
+    const res = {
+      data,
+      loading,
+      queryList,
+      builtInData,
+      fields,
+      selectFields,
+      enterParams,
+      error,
+      commonFields: {},
+      builtInMethods: {},
+      config: {},
+      response,
+      refreshData: async() => ([]),
+      refreshConfig: async() => ({})
+    }
+
+
+    const getConfig = (id:string)=>{
+      return page.pageDataSource.find((i: any) => i.id === id);
+    }
+
+
+    let config = getConfig(_id)
+
+    const _initSelectFields = (config:any, fields:any) => {
+      const selectConfig = config.leaveParams.dataRecast?.selectFields;
+      if (selectConfig?.length) {
+        return selectConfig.map((f:any) =>{
+          const exitField:any = fields.find((field:any) => field.value === field);
+          return {
+            label: exitField?.label || f.label,
+            value: f.key
+          }
+        })
+      }
+    }
+
+    const init = ()=>{
+
+      res.config = config;
+      enterParams.value = config.enterParams?.params || []
+
+      const pull = config.pull;
+      const type = pull.type as keyof DataModelSource;
+
+      const targetSource = this.sources[type];
+
+      res.builtInMethods = targetSource.builtInMethods;
+      res.commonFields = config.leaveParams?.dataRecast?.commonFields || {}
+
+
+      res.refreshData = async (requestParams:any = {}) => {
+        loading.value = true;
+        error.value = null;
+        try {
+          data.value = await targetSource.getData(pull, config, {
+            requestParams: requestParams,
+            successCallback: (data:any)=>{
+              response.value = data
+            }
+          })
+        } catch (e:any) {
+          error.value = e.message;
+        } finally {
+          loading.value = false;
+        }
+        return data.value;
+      };
+
+      res.refreshConfig = async () => {
+        await res.refreshData()
+        fields.value = await targetSource.getFields(pull, data.value);
+        selectFields.value = _initSelectFields(config, fields.value);
+        if (targetSource.getQueryParams && typeof targetSource.getQueryParams === 'function') {
+          queryList.value = await targetSource.getQueryParams(pull);
+        }
+        return res
+      }
+
+      if (initData) {
+        if (beforeLoad && typeof beforeLoad === 'function') {
+          beforeLoad(config)
+        }
+        res.refreshConfig().then(()=>{
+          if (loaded && typeof loaded === 'function') {
+            loaded(res);
+          }
+        })
+      }
+
+
+      if (initBuiltInData) {
+        // 判断 targetSource.builtInMethods 值是否为一个可迭代对象
+        if (
+          targetSource.builtInMethods &&
+          typeof targetSource.builtInMethods[Symbol.iterator] === 'function'
+        ) {
+          for (const key in targetSource.builtInMethods) {
+            const fun = targetSource.builtInMethods[key];
+            // 判断 fun 是否为一个函数并且是同步还是异步
+            if (
+              typeof fun === 'function' &&
+              fun.constructor.name === 'AsyncFunction'
+            ) {
+              fun(config).then((res: any) => {
+                builtInData.value[key] = res;
+              });
+            } else {
+              builtInData.value[key] = fun(config);
+            }
+          }
+        }
+      }
+    }
+
+    if (!config) {
+      console.warn('未找到数据源', id);
+    } else {
+      init()
+    }
+
+    if (_watch && typeof _watch === 'function') {
+      watch(_watch, (newId:any)=>{
+        const _id = typeof newId === 'string' ? newId : newId?.id;
+        if (_id) {
+          config = getConfig(_id)
+          if (!config) {
+            console.error('未找到数据源', _id);
+            return
+          }
+          init()
+        } else {
+          data.value = []
+          selectFields.value = []
+          queryList.value = []
+          builtInData.value = {}
+          loading.value = false
+          fields.value = []
+          enterParams.value = []
+          res.config = {}
+          res.refreshData = async() => ([])
+        }
+      }, {
+        deep: true
+      })
+    }
+
+    return res
+  };
+
+  useDataModel = (id: string | {id:string} & Record<string, any>, options: any): dataSconceValues | undefined => {
+    return this.useDataSconce(id, options);
+  };
+}

package/src/models/dataModel/models/CategoryDict.ts

@@ -0,0 +1,35 @@
+import DataSource from './DataSource';
+
+import { getDetailList } from '@/api/ibsp-bg-app';
+
+export default class CategoryDict extends DataSource {
+
+
+  readonly name: string = 'categoryDict';
+
+  constructor(page: IBSP.IPage.Page) {
+    super(page)
+  }
+
+  private PAGE_SIZE = 1000000
+  private PAGE_NO = 1
+
+  async getData(config: DataSourceConfig<'categoryDict'>, model:any, options:any = {}): Promise<any> {
+    const res = await getDetailList({
+      pageSize: this.PAGE_SIZE,
+      pageNo: this.PAGE_NO,
+      appId: this.page.appId,
+      dictId: config.configValues.id
+    })
+    const data = res.data?.list || []
+    if (options.shipRecast) {
+      return data
+    }
+    return this.dataRecast(data, model.leaveParams)
+  }
+
+  async getFields(config: DataSourceConfig<'categoryDict'>, data:any[]): Promise<any[]> {
+    return DataSource.dataFields(data)
+  }
+
+}