cloud-web-corejs 1.0.258 → 1.0.260

package/src/components/xform/form-designer/form-widget/field-widget/mixins/date-limit-mixin.js

@@ -0,0 +1,157 @@
+export default {
+  methods: {
+    getDateLimitOptions() {
+      return this.field.options || {};
+    },
+    initDateLimitPickerOptions() {
+      const pickerOptions = { ...(this.pickerOptions || {}) };
+      if (["year", "month", "date", "datetime"].includes(this.field.options.type)) {
+        if (!pickerOptions.shortcuts) {
+          pickerOptions.shortcuts = [
+            {
+              text: this.$t1("此刻"),
+              onClick(picker) {
+                picker.$emit("pick", new Date());
+              },
+            },
+          ];
+        }
+      }
+      pickerOptions.disabledDate = (time) => this.isDateLimitDisabled(time);
+      this.pickerOptions = pickerOptions;
+    },
+    initDateLimitWatch() {
+      if (this.designState) {
+        return;
+      }
+      const { limitStartField, limitEndField } = this.getDateLimitOptions();
+      if (limitStartField) {
+        this.$watch(
+          () => this.getDateLimitLinkedValue(limitStartField),
+          () => {
+            this.initDateLimitPickerOptions();
+          }
+        );
+      }
+      if (limitEndField) {
+        this.$watch(
+          () => this.getDateLimitLinkedValue(limitEndField),
+          () => {
+            this.initDateLimitPickerOptions();
+          }
+        );
+      }
+    },
+    getDateLimitDataSource() {
+      return this.tableParam && this.tableParam.row
+        ? this.tableParam.row
+        : this.formModel;
+    },
+    getDateLimitLinkedValue(fieldName) {
+      if (!fieldName) {
+        return null;
+      }
+      const dataSource = this.getDateLimitDataSource();
+      return dataSource ? dataSource[fieldName] : null;
+    },
+    parseDateLimitValue(val) {
+      if (val === null || val === undefined || val === "") {
+        return null;
+      }
+      const date = new Date(String(val).replace(/-/g, "/"));
+      return isNaN(date.getTime()) ? null : date.getTime();
+    },
+    normalizeDateLimitDayTime(time, isEnd) {
+      const date = new Date(time);
+      if (this.field.options.type === "datetime") {
+        return date.getTime();
+      }
+      date.setHours(isEnd ? 23 : 0, isEnd ? 59 : 0, isEnd ? 59 : 0, isEnd ? 999 : 0);
+      return date.getTime();
+    },
+    isDateLimitDisabled(time) {
+      const options = this.getDateLimitOptions();
+      const currentTime = time.getTime();
+
+      const minDate = this.parseDateLimitValue(options.minDate);
+      if (minDate !== null && currentTime < this.normalizeDateLimitDayTime(minDate, false)) {
+        return true;
+      }
+
+      const maxDate = this.parseDateLimitValue(options.maxDate);
+      if (maxDate !== null && currentTime > this.normalizeDateLimitDayTime(maxDate, true)) {
+        return true;
+      }
+
+      if (options.limitStartField) {
+        const startTime = this.parseDateLimitValue(
+          this.getDateLimitLinkedValue(options.limitStartField)
+        );
+        if (startTime !== null && currentTime < this.normalizeDateLimitDayTime(startTime, false)) {
+          return true;
+        }
+      }
+
+      if (options.limitEndField) {
+        const endTime = this.parseDateLimitValue(
+          this.getDateLimitLinkedValue(options.limitEndField)
+        );
+        if (endTime !== null && currentTime > this.normalizeDateLimitDayTime(endTime, true)) {
+          return true;
+        }
+      }
+
+      return false;
+    },
+    isDateLimitViolated(value) {
+      if (value === null || value === undefined || value === "") {
+        return false;
+      }
+      const currentTime = this.parseDateLimitValue(value);
+      if (currentTime === null) {
+        return false;
+      }
+
+      const options = this.getDateLimitOptions();
+      const minDate = this.parseDateLimitValue(options.minDate);
+      if (minDate !== null && currentTime < this.normalizeDateLimitDayTime(minDate, false)) {
+        return true;
+      }
+
+      const maxDate = this.parseDateLimitValue(options.maxDate);
+      if (maxDate !== null && currentTime > this.normalizeDateLimitDayTime(maxDate, true)) {
+        return true;
+      }
+
+      if (options.limitStartField) {
+        const startTime = this.parseDateLimitValue(
+          this.getDateLimitLinkedValue(options.limitStartField)
+        );
+        if (startTime !== null && currentTime < this.normalizeDateLimitDayTime(startTime, false)) {
+          return true;
+        }
+      }
+
+      if (options.limitEndField) {
+        const endTime = this.parseDateLimitValue(
+          this.getDateLimitLinkedValue(options.limitEndField)
+        );
+        if (endTime !== null && currentTime > this.normalizeDateLimitDayTime(endTime, true)) {
+          return true;
+        }
+      }
+
+      return false;
+    },
+    getDateLimitViolationMessage() {
+      const options = this.getDateLimitOptions();
+      if (options.limitEndField && !options.limitStartField) {
+        return "开始时间不能大于结束时间";
+      }
+      if (options.limitStartField && !options.limitEndField) {
+        return "结束时间不能小于开始时间";
+      }
+      return "日期超出允许范围";
+    },
+  },
+};

package/src/components/xform/form-designer/form-widget/field-widget/mixins/utc-transform-mixin.js

@@ -0,0 +1,75 @@
+import { deepClone, isNilOrEmptyStr } from "../../../../utils/util";
+import fieldMixin from "../fieldMixin";
+
+export default {
+  methods: {
+    isUtcTransformEnabled() {
+      return !!this.field?.options?.utcTransformEnabled;
+    },
+    transformUtcToLocalValue(value) {
+      if (isNilOrEmptyStr(value) || !this.isUtcTransformEnabled()) {
+        return value;
+      }
+      if (Array.isArray(value)) {
+        return value.map((item) => this.transformUtcToLocalSingle(item));
+      }
+      return this.transformUtcToLocalSingle(value);
+    },
+    transformUtcToLocalSingle(value) {
+      if (isNilOrEmptyStr(value)) {
+        return value;
+      }
+      const localValue = this.$utcToLocal(value);
+      if (!localValue) {
+        return localValue;
+      }
+      const widgetType = this.field?.type;
+      const options = this.field?.options || {};
+      if (widgetType === "time") {
+        const parts = String(localValue).split(" ");
+        return parts.length > 1 ? parts[1] : localValue;
+      }
+      if (widgetType === "time-range") {
+        return localValue;
+      }
+      const dateType = options.type;
+      const valueFormat = options.valueFormat || "";
+      if (widgetType === "date" || widgetType === "date-range") {
+        if (
+          dateType === "datetime"
+          || (valueFormat && /[HhmSs]/.test(valueFormat))
+        ) {
+          return localValue;
+        }
+        return String(localValue).split(" ")[0];
+      }
+      return localValue;
+    },
+    getUtcTransformedFieldValue() {
+      if (!this.isUtcTransformEnabled()) {
+        return this.fieldModel;
+      }
+      return this.transformUtcToLocalValue(this.fieldModel);
+    },
+    initFieldModel(flag) {
+      fieldMixin.methods.initFieldModel.call(this, flag);
+      // flag=true 来自 initValueWatchEvent；行数据已是本地时间，再转换会重复偏移并触发 watch 死循环
+      if (this.designState || !this.isUtcTransformEnabled() || flag) {
+        return;
+      }
+      const transformed = this.getUtcTransformedFieldValue();
+      if (transformed === this.fieldModel) {
+        return;
+      }
+      const currentData =
+        this.tableParam && this.tableParam.row
+          ? this.tableParam.row
+          : this.formModel;
+      this.fieldModel = transformed;
+      this.oldFieldValue = deepClone(transformed);
+      if (transformed !== currentData[this.fieldKeyName]) {
+        this.syncUpdateFormModel(transformed);
+      }
+    },
+  },
+};

package/src/components/xform/form-designer/form-widget/field-widget/save_submit_wf_button-widget.vue

@@ -0,0 +1,112 @@
+<template>
+  <static-content-wrapper
+    :designer="designer"
+    :field="field"
+    :design-state="designState"
+    :display-style="field.options.displayStyle"
+    :parent-widget="parentWidget"
+    :parent-list="parentList"
+    :index-of-parent-list="indexOfParentList"
+    :sub-form-row-index="subFormRowIndex"
+    :sub-form-col-index="subFormColIndex"
+    :sub-form-row-id="subFormRowId"
+  >
+    <el-button
+      v-show="isShow"
+      class="button-sty"
+      :type="field.options.type"
+      :size="field.options.size"
+      :plain="field.options.plain"
+      :round="field.options.round"
+      :circle="field.options.circle"
+      :icon="field.options.icon"
+      :disabled="!designState && field.options.disabled"
+      @click="clickHandle"
+    >
+      {{ getI18nLabel(field.options.label) }}
+    </el-button>
+  </static-content-wrapper>
+</template>
+
+<script>
+import StaticContentWrapper from "./static-content-wrapper";
+import emitter from "../../../../../components/xform/utils/emitter";
+import i18n from "../../../../../components/xform/utils/i18n";
+import fieldMixin from "../../../../../components/xform/form-designer/form-widget/field-widget/fieldMixin";
+
+export default {
+  name: "save_submit_wf_button-widget",
+  componentName: "FieldWidget",
+  mixins: [emitter, fieldMixin, i18n],
+  props: {
+    field: Object,
+    parentWidget: Object,
+    parentList: Array,
+    indexOfParentList: Number,
+    designer: Object,
+    designState: {
+      type: Boolean,
+      default: false,
+    },
+    subFormRowIndex: {
+      type: Number,
+      default: -1,
+    },
+    subFormColIndex: {
+      type: Number,
+      default: -1,
+    },
+    subFormRowId: {
+      type: String,
+      default: "",
+    },
+  },
+  components: {
+    StaticContentWrapper,
+  },
+  inject: {
+    getHasWf: {
+      default: () => () => false,
+    },
+  },
+  computed: {
+    isShow() {
+      if (this.designState) return true;
+      const formRef = this.getFormRef();
+      if (!formRef?.formConfig?.wfEnabled) return false;
+      if (this.isWfStarted(formRef)) return false;
+      return !this.field.options.hidden;
+    },
+  },
+  created() {
+    this.registerToRefList();
+    this.initEventHandler();
+    this.handleOnCreated();
+  },
+  mounted() {
+    this.handleOnMounted();
+  },
+  beforeDestroy() {
+    this.unregisterFromRefList();
+  },
+  methods: {
+    isWfStarted(formRef) {
+      const wfParam = formRef?.wfParam || {};
+      return !!(
+        wfParam.hasWf ||
+        formRef.hasWf ||
+        this.getHasWf() ||
+        wfParam.wfInfo?.procInstId
+      );
+    },
+    clickHandle() {
+      if (this.designState || this.field.options.disabled || !this.isShow) return;
+      this.saveAndSubmitWfHandle();
+    },
+  },
+};
+</script>
+
+<style lang="scss" scoped>
+@import "~@/styles/global.scss";
+</style>

package/src/components/xform/form-designer/form-widget/field-widget/script-input-widget.vue

@@ -0,0 +1,149 @@
+<template>
+  <form-item-wrapper
+    :designer="designer"
+    :field="field"
+    :rules="rules"
+    :design-state="designState"
+    :parent-widget="parentWidget"
+    :parent-list="parentList"
+    :index-of-parent-list="indexOfParentList"
+    :sub-form-row-index="subFormRowIndex"
+    :sub-form-col-index="subFormColIndex"
+    :sub-form-row-id="subFormRowId"
+  >
+    <div v-if="designState" class="script-input-design-placeholder">
+      {{ getI18nLabel(field.options.placeholder) || "脚本输入框" }}
+      <span class="script-input-mode">({{ editorMode }})</span>
+    </div>
+    <template v-else-if="isReadMode">
+      <pre class="readonly-mode-field script-input-readonly">{{ fieldModel }}</pre>
+    </template>
+    <code-editor
+      v-else
+      v-model="fieldModel"
+      :mode="editorMode"
+      :readonly="field.options.readonly || field.options.disabled"
+      :height="editorHeight"
+      :min-lines="editorMinLines"
+      :max-lines="editorMaxLines"
+      :user-worker="userWorker"
+      :resize="!field.options.disabled && !field.options.readonly"
+      @input="onEditorInput"
+    />
+  </form-item-wrapper>
+</template>
+
+<script>
+import FormItemWrapper from "./form-item-wrapper";
+import emitter from "../../../utils/emitter";
+import i18n from "../../../utils/i18n";
+import fieldMixin from "./fieldMixin";
+import createCodeEditorAsyncComponent from "../../../../code-editor/async";
+
+export default {
+  name: "script-input-widget",
+  componentName: "FieldWidget",
+  mixins: [emitter, fieldMixin, i18n],
+  props: {
+    field: Object,
+    parentWidget: Object,
+    parentList: Array,
+    indexOfParentList: Number,
+    designer: Object,
+    designState: {
+      type: Boolean,
+      default: false,
+    },
+    subFormRowIndex: {
+      type: Number,
+      default: -1,
+    },
+    subFormColIndex: {
+      type: Number,
+      default: -1,
+    },
+    subFormRowId: {
+      type: String,
+      default: "",
+    },
+  },
+  components: {
+    FormItemWrapper,
+    // 不依赖 src/index.js 的全局注册，避免宿主应用未注册时整块消失
+    CodeEditor: createCodeEditorAsyncComponent,
+  },
+  inject: ["refList", "globalOptionData", "globalModel"],
+  data() {
+    return {
+      oldFieldValue: null,
+      fieldModel: null,
+      rules: [],
+    };
+  },
+  computed: {
+    editorMode() {
+      return this.field.options.editorMode || "javascript";
+    },
+    editorHeight() {
+      return this.field.options.editorHeight || "200px";
+    },
+    editorMinLines() {
+      return this.field.options.editorMinLines || 8;
+    },
+    editorMaxLines() {
+      return this.field.options.editorMaxLines || 30;
+    },
+    userWorker() {
+      if (this.field.options.editorMode === "text") {
+        return false;
+      }
+      return this.field.options.userWorker === true;
+    },
+  },
+  created() {
+    this.initFieldModel();
+    this.registerToRefList();
+    this.initEventHandler();
+    this.buildFieldRules();
+    this.handleOnCreated();
+  },
+  mounted() {
+    this.handleOnMounted();
+  },
+  beforeDestroy() {
+    this.unregisterFromRefList();
+  },
+  methods: {
+    onEditorInput(val) {
+      this.handleInputCustomEvent(val);
+    },
+  },
+};
+</script>
+
+<style lang="scss" scoped>
+@import "~@/styles/global.scss";
+
+.script-input-design-placeholder {
+  min-height: 120px;
+  padding: 12px;
+  border: 1px dashed #c0c4cc;
+  border-radius: 4px;
+  color: #909399;
+  font-size: 13px;
+  background: #fafafa;
+}
+
+.script-input-mode {
+  margin-left: 6px;
+  color: #336699;
+}
+
+.script-input-readonly {
+  margin: 0;
+  white-space: pre-wrap;
+  word-break: break-all;
+  font-family: Consolas, Monaco, monospace;
+  font-size: 12px;
+}
+</style>