@oinone/kunlun-vue-admin-base 6.3.9 → 6.4.0

package/src/basic/field/complex/select/FormSelectComplexFieldWidget.ts

@@ -3,7 +3,7 @@ import {
   ActiveRecords,
   getRelationFieldKey,
   isRelatedField,
-  parseConfigs,
+  ModelCache,
   QueryService,
   RequestHelper,
   RuntimeModel,
@@ -11,9 +11,9 @@ import {
   RuntimeRelationField,
   translateValueByKey
 } from '@oinone/kunlun-engine';
-import { Entity, isEmptyValue, ModelType } from '@oinone/kunlun-meta';
+import { deepClone, Entity, IModel, isEmptyValue, ModelType } from '@oinone/kunlun-meta';
 import { Condition, ObjectValue } from '@oinone/kunlun-request';
-import { DEFAULT_TRUE_CONDITION, IQueryPageOption, IQueryPageResult } from '@oinone/kunlun-service';
+import { DEFAULT_TRUE_CONDITION, IQueryPageOption, IQueryPageResult, queryOne } from '@oinone/kunlun-service';
 import { CastHelper, NumberHelper } from '@oinone/kunlun-shared';
 import {
   autoFillSelectedValueToOptions,
@@ -22,7 +22,7 @@ import {
 } from '@oinone/kunlun-vue-admin-layout';
 import { PageSizeEnum, WidgetTrigger } from '@oinone/kunlun-vue-ui-common';
 import { Widget } from '@oinone/kunlun-vue-widget';
-import { isNil, isPlainObject } from 'lodash-es';
+import { isEmpty, isNil, isNumber, isPlainObject, isString, toInteger } from 'lodash-es';
 import { isValidatorSuccess, ValidatorInfo } from '../../../../typing';
 import { FormComplexFieldProps } from '../FormComplexFieldWidget';
 import { BaseSelectFieldWidget } from './BaseSelectFieldWidget';
@@ -43,14 +43,19 @@ export abstract class FormSelectComplexFieldWidget<
 
   protected timeout;
 
+  @Widget.Reactive()
   protected searchValue = '';
 
   protected queryFieldName = 'name';
 
-  protected abstract fillOptions(dataList: Record<string, unknown>[], insetDefaultValue?: boolean);
+  protected computeQueryOneDefaultKey() {
+    return 'id';
+  }
 
   @Widget.Reactive()
-  protected loadMoreLoading = false;
+  public get computeQueryOneKey() {
+    return this.getDsl().computeQueryOneKey;
+  }
 
   @Widget.Reactive()
   protected showMoreButton = false;
@@ -60,8 +65,13 @@ export abstract class FormSelectComplexFieldWidget<
 
   protected totalPages = 10000;
 
+  @Widget.Reactive()
+  protected total = 0;
+
+  @Widget.Reactive()
   protected currentPage = 1;
 
+  @Widget.Reactive()
   protected pageSize = PageSizeEnum.OPTION_2;
 
   @Widget.Reactive()
@@ -69,11 +79,6 @@ export abstract class FormSelectComplexFieldWidget<
 
   protected dataList: Record<string, unknown>[] = [];
 
-  @Widget.Reactive()
-  protected get loadFunctionFun(): string | undefined {
-    return this.getDsl().load;
-  }
-
   protected defaultConstructDataTrigger() {
     return [WidgetTrigger.CHANGE];
   }
@@ -102,6 +107,44 @@ export abstract class FormSelectComplexFieldWidget<
     }
   }
 
+  protected async fillOptions(dataList: Record<string, unknown>[], insetDefaultValue = true) {
+    this.field.multi ? this.fillOptionsForMulti(dataList) : this.fillOptionsForSingle(dataList, insetDefaultValue);
+  }
+
+  public x2oChange(value) {
+    if (value == null) {
+      super.change(null as any);
+      this.handleEmpty();
+      return;
+    }
+
+    const selectedValue = this.dataList.find((d) => d[this.relationFieldKey] === value.value)! || value;
+    super.change(selectedValue as any);
+  }
+
+  protected x2mChange(value) {
+    if (value == null) {
+      super.change(value);
+      this.handleEmpty();
+    } else {
+      if (!value.length) {
+        this.handleEmpty();
+      }
+      const submitData = this.filterX2mChangeValue(value);
+      super.change(submitData);
+    }
+  }
+
+  protected filterX2mChangeValue(value) {
+    // focus的时候才会查询数据，这时候dataList为空，如果开始有value，会导致剩下的已选数据匹配不到值
+    const list = isEmpty(this.dataList) ? this.value || [] : this.dataList;
+    return value
+      .map((item) => {
+        return (list as any[])?.find((d) => d[this.relationFieldKey] === item.value);
+      })
+      .filter((a) => !!a);
+  }
+
   public async loadMetadata() {}
 
   @Widget.Method()
@@ -142,6 +185,7 @@ export abstract class FormSelectComplexFieldWidget<
   }
 
   protected async fillOptionsForMulti(dataList: Record<string, unknown>[]) {
+    const list = deepClone(dataList || []);
     const pk = this.referencesModel!.pks!;
     if (this.selectedValues) {
       for (let j = 0; j < this.selectedValues.length; j++) {
@@ -221,24 +265,6 @@ export abstract class FormSelectComplexFieldWidget<
     return getRelationFieldKey(this.field, this.referencesModel);
   }
 
-  @Widget.Reactive()
-  protected get allowClear() {
-    const { allowClear } = this.getDsl();
-    if (isNil(allowClear)) {
-      return true;
-    }
-    return allowClear;
-  }
-
-  @Widget.Reactive()
-  protected get showSearch() {
-    const show = this.getDsl().showSearch;
-    if (!isNil(show)) {
-      return show;
-    }
-    return true;
-  }
-
   @Widget.Method()
   protected async loadMore() {
     this.currentPage += 1;
@@ -408,6 +434,7 @@ export abstract class FormSelectComplexFieldWidget<
         const iQueryPageResult = await this.innerQueryPage(references, option, referencesModelFields!, undefined, {
           maxDepth: this.maxDepth
         });
+        this.total = toInteger(iQueryPageResult.totalElements);
         this.totalPages = FormSelectComplexFieldWidget.getRealPages(iQueryPageResult.totalPages);
         this.showMoreButton = this.currentPage < this.totalPages;
 
@@ -616,17 +643,56 @@ export abstract class FormSelectComplexFieldWidget<
   }
 
   protected genQueryData() {
-    const queryData = {};
-    const dslConfig = this.getDsl();
-    const { queryDataConfig } = parseConfigs(dslConfig, { key: 'queryDataConfig', prefix: 'queryData' });
-    if (queryDataConfig) {
-      for (const queryDataConfigKey in queryDataConfig) {
-        const value = queryDataConfig[queryDataConfigKey] as any;
-        queryData[queryDataConfigKey] = this.executeExpression(value, value);
+    return this.generatorQueryData();
+  }
+
+  public async updateM2oValue() {
+    const val = this.getValue();
+    const _compute = this.getCompute(this.formData);
+    if (_compute != null && _compute !== '') {
+      const computeResult = this.executeExpression<number | null | string | undefined>(_compute, null);
+      let queryOneKey = this.computeQueryOneKey;
+      const _computeList = _compute.split('.');
+      if (_computeList[0] === 'activeRecord' && _computeList[1] && _computeList[2] && !queryOneKey) {
+        const currentModel = (await ModelCache.get(this.field!.model)) as unknown as IModel;
+
+        const relatedField = currentModel?.modelFields?.find((_f) => _f.name === _computeList[1]);
+        if (relatedField && relatedField.references) {
+          const relatedFieldModel = (await ModelCache.get(relatedField.references)) as unknown as IModel;
+          if (relatedFieldModel && relatedFieldModel.modelFields) {
+            const finalField = relatedFieldModel.modelFields.find(
+              (_f) => _f.relationFields && _f.relationFields.includes(_computeList[2])
+            );
+            if (finalField) {
+              const keyIndex = finalField.relationFields?.findIndex((_r) => _r === _computeList[2]);
+              queryOneKey = finalField.referenceFields?.[keyIndex!] || 'id';
+            }
+          }
+        }
+      }
+      if (!queryOneKey) {
+        queryOneKey = this.computeQueryOneDefaultKey();
+      }
+      const param = {};
+      param[queryOneKey] = computeResult;
+      if (isString(computeResult) || isNumber(computeResult)) {
+        if (typeof val === 'object' && !isEmptyValue(val)) {
+          if (val[queryOneKey] !== computeResult) {
+            const data = await queryOne(this.field!.references!, param);
+            this.setValue(data);
+          }
+        } else {
+          const data = await queryOne(this.field!.references!, param);
+          this.setValue(data);
+        }
+      } else if (typeof computeResult === 'object') {
+        if (JSON.stringify(computeResult) !== JSON.stringify(this.value)) {
+          this.setValue(computeResult);
+        }
+      } else if (isNil(computeResult)) {
+        this.setValue(null);
       }
-      return queryData;
     }
-    return {};
   }
 
   protected async innerQueryPage<T = Record<string, unknown>>(

package/src/basic/field/complex/select/SelectFieldWidget.ts

@@ -0,0 +1,189 @@
+import {
+  ActiveRecord,
+  ActiveRecords,
+  ActiveRecordsOperator,
+  Pagination,
+  QueryContext,
+  QueryPageResult,
+  QueryService,
+  QueryVariables,
+  QueryWrapper,
+  RequestModelField,
+  RuntimeRelationField
+} from '@oinone/kunlun-engine';
+import { GraphqlHelper, RSQLCondition } from '@oinone/kunlun-shared';
+import { SelectItem, SelectMode } from '@oinone/kunlun-vue-ui-common';
+import { Widget } from '@oinone/kunlun-vue-widget';
+import { DefaultSelect } from '../../../../components';
+import { FormComplexFieldProps } from '../FormComplexFieldWidget';
+import { BaseSelectFieldWidget } from './BaseSelectFieldWidget';
+
+export class SelectFieldWidget<
+  Option extends ActiveRecord = ActiveRecord,
+  Value extends ActiveRecords = ActiveRecords,
+  Field extends RuntimeRelationField = RuntimeRelationField,
+  Props extends FormComplexFieldProps<Field> = FormComplexFieldProps<Field>
+> extends BaseSelectFieldWidget<Value, Field, Props> {
+  @Widget.Reactive()
+  protected mode: SelectMode = SelectMode.single;
+
+  public initialize(props) {
+    super.initialize(props);
+    this.setComponent(DefaultSelect);
+    return this;
+  }
+
+  @Widget.Reactive()
+  protected get bizStyle(): string | undefined {
+    return this.getDsl().bizStyle;
+  }
+
+  protected isNeedReloadOptions = false;
+
+  @Widget.Method()
+  protected async initLoad() {
+    if (!this.options || (this.lastDomain || '') !== (this.domain || '') || this.isNeedReloadOptions) {
+      this.isNeedReloadOptions = false;
+      await this.$$initLoad();
+    }
+  }
+
+  protected async $$initLoad(condition?: RSQLCondition): Promise<void> {
+    this.pagination = undefined;
+    const data = await this.fetchData(condition);
+    const options: SelectItem<Option>[] =
+      (this.lastOptionValues || this.optionValues)?.map((v) => this.mapping(v as Option)) || [];
+    for (const item of data) {
+      options.push(this.mapping(item));
+    }
+    this.options = options;
+  }
+
+  @Widget.Method()
+  protected async loadMore() {
+    const pagination = this.generatorPagination();
+    if ((pagination.totalPageSize || 0) > pagination.current) {
+      pagination.current++;
+      const data = await this.fetchData();
+      const options = [...(this.options || [])];
+      for (const item of data) {
+        options.push(this.mapping(item));
+      }
+      this.options = options;
+    } else {
+      this.loadCompleted = true;
+    }
+  }
+
+  @Widget.Reactive()
+  protected searchValue: string | undefined;
+
+  @Widget.Method()
+  protected onUpdateSearchValue(val: string | undefined) {
+    if (val) {
+      this.searchValue = val;
+    } else {
+      if (this.searchValue) {
+        this.isNeedReloadOptions = true;
+      }
+      this.searchValue = undefined;
+      this.lastOptionValues = undefined;
+    }
+  }
+
+  @Widget.Method()
+  protected search(keyword: string): Promise<void> {
+    if (!keyword) {
+      this.lastOptionValues = undefined;
+      this.searchValue = undefined;
+      this.isNeedReloadOptions = false;
+      return this.$$initLoad();
+    }
+    this.searchValue = keyword;
+    this.lastOptionValues = this.optionValues;
+    keyword = GraphqlHelper.serializableSearchString(keyword);
+    let { searchFields } = this;
+    if (!searchFields.length) {
+      searchFields = ['name'];
+    }
+    const condition = RSQLCondition.wrapper();
+    for (const searchField of searchFields) {
+      condition.or().like(searchField, keyword, "'");
+    }
+    this.isNeedReloadOptions = false;
+    return this.$$initLoad(condition);
+  }
+
+  @Widget.Reactive()
+  protected get selected(): SelectItem<Option> | SelectItem<Option>[] | null | undefined {
+    const value = this.value as unknown as Option | Option[] | null | undefined;
+    if (value == null) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((v) => this.mapping(v));
+    }
+    return this.mapping(value);
+  }
+
+  @Widget.Method()
+  protected get initSelectedOptions(): SelectItem[] {
+    return this.dataSource?.map((v) => this.mapping(v)) || [];
+  }
+
+  @Widget.Reactive()
+  protected options: SelectItem<Option>[] | undefined;
+
+  protected async fetchData(condition?: RSQLCondition): Promise<Option[]> {
+    this.loadMoreLoading = true;
+    try {
+      return await this.$$fetchData(condition);
+    } finally {
+      this.loadMoreLoading = false;
+    }
+  }
+
+  protected async $$fetchData(condition?: RSQLCondition): Promise<Option[]> {
+    const finalCondition = this.generatorCondition(condition);
+    const queryData = this.generatorQueryData();
+    const pagination = this.generatorPagination();
+    const variables = this.generatorQueryVariables();
+    const context = this.generatorQueryContext();
+    const result = await this.queryPage<Option>(
+      this.generatorRequestFields(),
+      {
+        rsql: finalCondition.toString(),
+        queryData
+      },
+      pagination,
+      variables,
+      context
+    );
+    pagination.total = result.totalElements;
+    pagination.totalPageSize = result.totalPages;
+    return ActiveRecordsOperator.repairRecords(result.content) as Option[];
+  }
+
+  protected async queryPage<T extends Record<string, unknown>>(
+    requestFields: RequestModelField[],
+    queryWrapper: QueryWrapper,
+    pagination: Pagination,
+    variables: QueryVariables,
+    context: QueryContext
+  ): Promise<QueryPageResult<T>> {
+    const { referencesModel } = this;
+    if (!referencesModel) {
+      console.error('references model not found.');
+      return { content: [], totalPages: 0, totalElements: 0 };
+    }
+    return QueryService.queryPage(referencesModel, {
+      fun: this.loadFunctionFun,
+      requestFields,
+      currentPage: pagination.current,
+      pageSize: this.isFetchAll ? -1 : pagination.pageSize,
+      queryWrapper,
+      variables,
+      context
+    });
+  }
+}

package/src/basic/field/complex/select/SelectModalFieldWidget.ts

@@ -0,0 +1,76 @@
+import { ActiveRecords, Pagination, RuntimeRelationField } from '@oinone/kunlun-engine';
+import { buildSelectSearchCondition } from '@oinone/kunlun-vue-admin-layout';
+import { Widget } from '@oinone/kunlun-vue-widget';
+import { toInteger } from 'lodash-es';
+import { SelectModal } from '../../../../components';
+import { SelectTableFieldWidget } from './SelectTableFieldWidget';
+
+export abstract class SelectModalFieldWidget<
+  Value extends ActiveRecords = ActiveRecords,
+  Field extends RuntimeRelationField = RuntimeRelationField
+> extends SelectTableFieldWidget<Value, Field> {
+  public initialize(props: any) {
+    super.initialize(props);
+    this.setComponent(SelectModal);
+    return this;
+  }
+
+  protected isFirstFillOptions = true;
+
+  /**
+   * 弹窗表格分页信息
+   */
+  @Widget.Reactive()
+  protected get tablePagination(): Pagination {
+    return {
+      pageSize: this.pageSize,
+      total: this.total,
+      current: this.currentPage
+    };
+  }
+
+  /**
+   * 切换分页
+   */
+  @Widget.Method()
+  protected async onPaginationChange(page: number, pageSize: number) {
+    this.currentPage = page;
+    this.pageSize = pageSize;
+
+    const iQueryPageResult = await this.loadOptions({
+      condition: buildSelectSearchCondition(this.referencesModel, this.queryFieldName, this.searchValue, this.domain),
+      currentPage: this.currentPage
+    });
+    if (iQueryPageResult) {
+      this.totalPages = toInteger(iQueryPageResult.totalPages);
+      await this.fillOptions(iQueryPageResult.content, false);
+    }
+  }
+
+  /**
+   * x2m字段数据填充
+   */
+  protected async fillOptionsForMulti(dataList: Record<string, unknown>[]) {
+    if (this.isFirstFillOptions) {
+      this.isFirstFillOptions = false;
+      super.fillOptionsForMulti(dataList);
+      return;
+    }
+    this.dataList = dataList;
+    this.options = this.handleSelectOption(this.dataList, this.referencesModel);
+  }
+
+  /**
+   * x2o字段数据填充
+   */
+  protected async fillOptionsForSingle(dataList: Record<string, unknown>[], insetDefaultValue = true) {
+    if (this.isFirstFillOptions) {
+      this.isFirstFillOptions = false;
+      super.fillOptionsForSingle(dataList, insetDefaultValue);
+      return;
+    }
+
+    this.dataList = dataList;
+    this.options = this.handleSelectOption(this.dataList, this.referencesModel);
+  }
+}

package/src/basic/field/complex/select/SelectTableFieldWidget.ts

@@ -0,0 +1,143 @@
+import {
+  ActiveRecords,
+  isEnumerationField,
+  isRelationField,
+  RuntimeModelField,
+  RuntimeRelationField
+} from '@oinone/kunlun-engine';
+import { StringHelper } from '@oinone/kunlun-shared';
+import { RowContext } from '@oinone/kunlun-vue-ui';
+import { Widget } from '@oinone/kunlun-vue-widget';
+import { get as getValue } from 'lodash-es';
+import { VNode } from 'vue';
+import { SelectTable } from '../../../../components';
+import { FormSelectComplexFieldWidget } from './FormSelectComplexFieldWidget';
+
+/**
+ * 同 oio-column 组件的 props
+ */
+export interface SelectTableColumn extends Record<string, any> {
+  key: string;
+  label: string;
+  field: string;
+  renderDefaultSlot?: (context: RowContext) => string | VNode | undefined;
+}
+
+export abstract class SelectTableFieldWidget<
+  Value extends ActiveRecords = ActiveRecords,
+  Field extends RuntimeRelationField = RuntimeRelationField
+> extends FormSelectComplexFieldWidget<Value, Field> {
+  public initialize(props: any) {
+    super.initialize(props);
+    this.setComponent(SelectTable);
+    return this;
+  }
+
+  @Widget.Method()
+  public getDataList() {
+    return this.dataList;
+  }
+
+  @Widget.Method()
+  public change(value) {
+    if (this.field.multi) {
+      this.x2mChange(value);
+    } else {
+      this.x2oChange(value);
+    }
+  }
+
+  @Widget.Reactive()
+  protected get optionColumns(): SelectTableColumn[] {
+    if (!this.referencesModel) {
+      return [];
+    }
+    let columnFields: string[] | undefined = StringHelper.convertArray(this.getDsl().columnFields as string);
+    if (!columnFields?.length) {
+      columnFields = this.labelFields;
+    }
+    if (!columnFields.length) {
+      console.error('Invalid column fields.');
+      return [];
+    }
+    const modelFields = this.referencesModel.modelFields || [];
+    const fieldMap = new Map<string, RuntimeModelField>(modelFields.map((f) => [f.data, f]));
+    const columns: SelectTableColumn[] = [];
+    let index = 0;
+    for (const columnField of columnFields) {
+      const ss = columnField.split('.');
+      const field = fieldMap.get(ss[0]);
+      if (!field) {
+        continue;
+      }
+      if (ss.length === 1) {
+        const { data, name, label } = field;
+        const column: SelectTableColumn = {
+          key: `${data}-${index}`,
+          label: label || data,
+          field: name
+        };
+        this.generatorColumnRender(column, field);
+        columns.push(column);
+      } else if (isRelationField(field)) {
+        const fields = this.getColumnFields(field, ss);
+        if (fields) {
+          const lastField = fields[fields.length - 1];
+          const label = fields.map((v) => v.label || v.data).join(' - ');
+          const field = fields.map((v) => v.name).join('.');
+          const column: SelectTableColumn = {
+            key: `${field}-${index}`,
+            label,
+            field
+          };
+          this.generatorColumnRender(column, lastField);
+          columns.push(column);
+        }
+      }
+      index++;
+    }
+    return columns;
+  }
+
+  protected generatorColumnRender(column: SelectTableColumn, runtimeField: RuntimeModelField) {
+    const { field } = column;
+    if (isEnumerationField(runtimeField)) {
+      const mapping: Record<string, string> = {};
+      for (const option of runtimeField.options) {
+        mapping[option.name] = option.label || option.displayName || option.name;
+      }
+      column.renderDefaultSlot = (context) => {
+        const value = getValue(context.data, field);
+        if (value == null) {
+          return undefined;
+        }
+        const stringValue = `${value}`;
+        const displayValue = mapping[stringValue];
+        return displayValue || stringValue;
+      };
+    }
+  }
+
+  protected getColumnFields(field: RuntimeRelationField, keys: string[]): RuntimeModelField[] | undefined {
+    const fields: RuntimeModelField[] = [field];
+    let lastField: RuntimeModelField | undefined;
+    for (let i = 1; i < keys.length; i++) {
+      const key = keys[i];
+      if (i === 1) {
+        lastField = field.referencesModel.modelFields.find((v) => v.data === key);
+        if (!lastField) {
+          return undefined;
+        }
+      } else if (lastField && isRelationField(lastField)) {
+        lastField = lastField.referencesModel.modelFields.find((v) => v.data === key);
+        if (!lastField) {
+          return undefined;
+        }
+      } else {
+        return undefined;
+      }
+      fields.push(lastField);
+    }
+    return fields;
+  }
+}

package/src/basic/field/complex/select/index.ts

@@ -1,2 +1,5 @@
 export * from './BaseSelectFieldWidget';
 export * from './FormSelectComplexFieldWidget';
+export * from './SelectFieldWidget';
+export * from './SelectTableFieldWidget';
+export * from './SelectModalFieldWidget';

package/src/basic/field/complex/subview/FormSubviewListFieldWidget.ts

@@ -103,7 +103,7 @@ export class FormSubviewListFieldWidget<
     this.refreshCallChaining?.syncCall();
   }
 
-  public flushDataSource(reloadDataSource = true) {
+  public flushDataSource() {
     const { dataSource, submitCache, subviewSubmitCache } = this;
     let showRecords = dataSource;
     if (submitCache) {
@@ -112,7 +112,7 @@ export class FormSubviewListFieldWidget<
     if (subviewSubmitCache) {
       subviewSubmitCache.submit(dataSource || []);
     }
-    reloadDataSource && this.reloadDataSource(showRecords);
+    this.reloadDataSource(showRecords);
     this.change(showRecords);
 
     this.repairTablePagination();

package/src/basic/field/complex/table/TableComplexFieldWidget.ts

@@ -40,6 +40,11 @@ export class TableComplexFieldWidget<
     return this.referencesModel?.pks?.[0] || 'id';
   }
 
+  @Widget.Reactive()
+  protected get defaultSortable() {
+    return false;
+  }
+
   protected handleTableLabel(dataEntity) {
     const realLabel = this.optionLabel || this.referencesModel?.label;
     let showValue;

package/src/basic/form/BaseFormWidget.ts

@@ -1,6 +1,6 @@
 import { DEFAULT_SLOT_NAME } from '@oinone/kunlun-dsl';
 import { FormLayout, OioColModel, OioFormInstance } from '@oinone/kunlun-vue-ui-common';
-import { Widget } from '@oinone/kunlun-vue-widget';
+import { isFormViewState, OioAnyViewState, Widget } from '@oinone/kunlun-vue-widget';
 import { BaseElementObjectViewWidget, BaseElementObjectViewWidgetProps } from '../element';
 import DefaultForm from './DefaultForm.vue';
 
@@ -49,4 +49,10 @@ export abstract class BaseFormWidget<
     this.setComponent(DefaultForm);
     return this;
   }
+
+  protected $$initViewState(state: OioAnyViewState): void {
+    if (isFormViewState(state) && !state.form) {
+      state.form = this.currentHandle;
+    }
+  }
 }