vap1 0.1.3 → 0.1.5

package/uform/utils/Convert.js

@@ -0,0 +1,274 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaToForm = void 0;
+const react_1 = __importDefault(require("react"));
+const lodash_1 = __importDefault(require("lodash"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const index_1 = require("../../index");
+const utils_1 = require("../../utils");
+const Const_1 = require("./Const");
+const converUrl = (url, data) => {
+    const fn = lodash_1.default.template(url, { imports: { _: lodash_1.default, dayjs: dayjs_1.default } });
+    return fn(data);
+};
+const convertParam = (param, data) => {
+    const fn = lodash_1.default.template(param, { imports: { _: lodash_1.default, dayjs: dayjs_1.default } });
+    return JSON.parse(fn(data));
+};
+const syncValidator = (rule) => {
+    var fn = lodash_1.default.template(`<%  
+    ${rule.code}
+    %>`, { imports: { _: lodash_1.default, dayjs: dayjs_1.default } });
+    return {
+        message: rule.message,
+        validator: (r, value, callback) => {
+            try {
+                let result = fn({ value });
+                if (!Const_1.BOOLEAN_VALUE.has(result)) {
+                    console.error('代码执行有误，请检查，:必须print(true/false)');
+                    return;
+                }
+                if (utils_1.StringUtil.getBoolean(result)) {
+                    callback();
+                }
+                else {
+                    callback('error');
+                }
+            }
+            catch (e) {
+                console.error('代码配置有误，请检查');
+                callback();
+            }
+        }
+    };
+};
+const asyncValidator = (rule) => {
+    var fn = lodash_1.default.template(`<%  
+    ${rule.code}
+    %>`, { imports: { _: lodash_1.default, dayjs: dayjs_1.default } });
+    return {
+        message: null,
+        validator: (r, value) => __awaiter(void 0, void 0, void 0, function* () {
+            let response;
+            const url = converUrl(rule.url, { value });
+            if (rule.method == 'POST') {
+                try {
+                    const param = convertParam(rule.param, { value });
+                    response = yield utils_1.Ajax.POST(url, param);
+                }
+                catch (e) {
+                    console.error(e);
+                    throw '验证失败';
+                }
+            }
+            else {
+                response = yield utils_1.Ajax.GET(url);
+            }
+            try {
+                fn({ response, value });
+            }
+            catch (e) {
+                throw e;
+            }
+        })
+    };
+};
+const syncLink = (link) => {
+    var fn = lodash_1.default.template(`<%  
+    ${link.code}
+    %>`, { imports: { _: lodash_1.default, dayjs: dayjs_1.default } });
+    return {
+        field: link.field,
+        call: (value, form, extra) => {
+            const result = fn({ value, form, extra });
+            if (result == '')
+                return result;
+            try {
+                let json = JSON.parse(result);
+                if (lodash_1.default.isPlainObject(json))
+                    return json;
+                throw (new Error());
+            }
+            catch (_a) {
+                return result;
+            }
+        }
+    };
+};
+const asyncLink = (link) => {
+    var fn = lodash_1.default.template(`<%  
+    ${link.code}
+    %>`, { imports: { _: lodash_1.default, dayjs: dayjs_1.default } });
+    return {
+        field: link.field,
+        call: (value, form, extra) => __awaiter(void 0, void 0, void 0, function* () {
+            let response;
+            const url = converUrl(link.url, { value, form, extra });
+            if (link.method == 'POST') {
+                try {
+                    const param = convertParam(link.param, { value, form, extra });
+                    response = yield utils_1.Ajax.POST(url, param);
+                }
+                catch (e) {
+                    console.error(e);
+                    // throw '验证失败';
+                }
+            }
+            else {
+                response = yield utils_1.Ajax.GET(url);
+            }
+            const result = fn({ value, form, extra, response });
+            if (result == '')
+                return result;
+            try {
+                let json = JSON.parse(result);
+                if (lodash_1.default.isPlainObject(json))
+                    return json;
+                throw (new Error());
+            }
+            catch (_a) {
+                return result;
+            }
+        })
+    };
+};
+const convertFields = (fields, def) => fields.map(item => {
+    let field = { field: item.field, title: item.title, type: item.type };
+    if (lodash_1.default.has(item, '_default')) {
+        if (Const_1.NUMBER.has(item.type) || item._isNumber) {
+            if (!isNaN(item._default)) {
+                def[item.field] = parseInt(item._default);
+            }
+        }
+        else {
+            def[item.field] = item._default;
+        }
+    }
+    field.config = item.config || {};
+    field.rules = [];
+    if (item.ik)
+        field.ik = item.ik;
+    if (item.options)
+        field.options = item.options;
+    if (item.span)
+        field.span = item.span;
+    if (item.extra)
+        field.extra = item.extra;
+    if (item.placeholder)
+        field.placeholder = item.placeholder;
+    if (item.roleCode)
+        field.roleCode = item.roleCode;
+    if (item.required)
+        field.required = true;
+    if (item.tip)
+        field.tip = item.tip;
+    if (lodash_1.default.has(item, 'show'))
+        field.show = item.show;
+    if (lodash_1.default.has(item, 'disabled'))
+        field.disabled = item.disabled;
+    if (item.help)
+        field.help = item.help;
+    if (item.ignore)
+        field.ignore = true;
+    field.rules = [];
+    if (item._pattern && Const_1.TEXT.has(item.type)) {
+        field.rules.push({ pattern: new RegExp(item._pattern), message: item.title + ' 格式有误' });
+    }
+    if (lodash_1.default.has(item, '_min') && lodash_1.default.isNumber(item._min)) {
+        if (Const_1.LEN.has(item.type)) {
+            field.rules.push({
+                message: `${item.title} 不得小于 ${item._min} 个字符`,
+                validator: (rule, value, callback) => {
+                    if ((value + '').length < item._min) {
+                        callback('error');
+                    }
+                    else {
+                        callback();
+                    }
+                }
+            });
+        }
+        else if (Const_1.NUMBER.has(item.type)) {
+            field.config.min = item._min;
+        }
+    }
+    if (item._max) {
+        if (Const_1.LEN.has(item.type)) {
+            field.config.maxLength = item._max;
+            field.rules.push({
+                message: `${item.title} 不得大于 ${item._max} 个字符`,
+                validator: (rule, value, callback) => {
+                    if ((value + '').length > item._max) {
+                        callback('error');
+                    }
+                    else {
+                        callback();
+                    }
+                }
+            });
+        }
+        else if (Const_1.NUMBER.has(item.type)) {
+            field.config.max = item._max;
+        }
+    }
+    (item._rules || []).map(rule => {
+        if (rule.async) {
+            field.rules.push(asyncValidator(rule));
+        }
+        else {
+            field.rules.push(syncValidator(rule));
+        }
+    });
+    field.link = [];
+    (item._links || []).map(link => {
+        if (link.async) {
+            field.link.push(asyncLink(link));
+        }
+        else {
+            field.link.push(syncLink(link));
+        }
+    });
+    // TODO PLUGINS
+    return field;
+});
+const convertGroups = (groups, def) => groups.map(group => ({ title: group.title, fields: convertFields(group.fields, def) }));
+const schemaToForm = (schema) => {
+    const uformProps = {
+        fields: [],
+    };
+    if (schema.tip && schema.tip.text) {
+        uformProps.tip = react_1.default.createElement(index_1.Alert, { message: schema.tip.text, type: schema.tip.type || 'info' });
+    }
+    if (lodash_1.default.has(schema, 'className') && lodash_1.default.isString(schema.className)) {
+        uformProps.className = lodash_1.default.trim(schema.className);
+    }
+    if (schema.layout)
+        uformProps.layout = schema.layout;
+    let def = {};
+    if (schema.isGroup) {
+        if (schema.groupType)
+            uformProps.groupType = schema.groupType;
+        uformProps.fields = convertGroups(schema.fields, def);
+    }
+    else {
+        uformProps.fields = convertFields(schema.fields, def);
+    }
+    if (schema.size)
+        uformProps.size = schema.size;
+    if (lodash_1.default.keys(def).length > 0)
+        uformProps.default = def;
+    return uformProps;
+};
+exports.schemaToForm = schemaToForm;

package/uform/utils/SchemaConvert.d.ts

@@ -0,0 +1,6 @@
+import { FormSchema } from '../schema';
+export declare const save: (schema: FormSchema) => void;
+export declare const saveSchema: (schema: FormSchema) => void;
+export declare const saveUForm: (schema: FormSchema) => void;
+export declare const saveCEMS: (schema: FormSchema) => void;
+export declare const loadFormJSON: (text: string) => any;

package/uform/utils/SchemaConvert.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFormJSON = exports.saveCEMS = exports.saveUForm = exports.saveSchema = exports.save = void 0;
+// 将 schame 转换为 UForm 接收的参数
+const react_1 = __importDefault(require("react"));
+const lodash_1 = __importDefault(require("lodash"));
+const utils_1 = require("../../utils");
+const antd_1 = require("antd");
+const cleanId = (schema) => {
+    let obj = lodash_1.default.cloneDeep(schema);
+    if (obj.isGroup) {
+        obj.fields.map(group => {
+            lodash_1.default.unset(group, 'id');
+            group.fields.map(field => lodash_1.default.unset(field, 'id'));
+        });
+    }
+    else {
+        obj.fields.map(group => {
+            lodash_1.default.unset(group, 'id');
+        });
+    }
+    lodash_1.default.unset(obj, 'selected');
+    lodash_1.default.unset(obj, 'baseSpan');
+    lodash_1.default.unset(obj, '__idx');
+    if (obj.tip && obj.tip.text == '') {
+        lodash_1.default.unset(obj, 'tip');
+    }
+    lodash_1.default.keys(obj).map(key => {
+        if (obj[key] === '') {
+            lodash_1.default.unset(obj, key);
+        }
+    });
+    return obj;
+};
+const setId = (schema) => {
+    let obj = lodash_1.default.cloneDeep(schema);
+    obj.fields.map(group => {
+        lodash_1.default.set(group, 'id', utils_1.StringUtil.genKey());
+        if (lodash_1.default.isArray(group.fields) && group.fields.length) {
+            group.fields.map(field => lodash_1.default.set(field, 'id', utils_1.StringUtil.genKey()));
+        }
+    });
+    if (lodash_1.default.isArray(obj.options) && obj.options.length) {
+        obj.options.map(item => lodash_1.default.set(item, 'id', utils_1.StringUtil.genKey()));
+    }
+    return obj;
+};
+const save = (schema) => {
+    let obj = cleanId(schema);
+    antd_1.notification.success({ message: react_1.default.createElement("pre", { dangerouslySetInnerHTML: { __html: JSON.stringify(obj, null, 2) } }) });
+};
+exports.save = save;
+const saveSchema = (schema) => {
+    if (schema.fields.length <= 0) {
+        antd_1.message.error('表单最少要有一个字段');
+        return;
+    }
+    let obj = cleanId(schema);
+    let fileName = (schema.title ? schema.title : '表单') + ".json";
+    var file = new File([JSON.stringify(obj, null, 4)], fileName, { type: "application/json;charset=utf-8" });
+    var a = document.createElement('a');
+    a.href = URL.createObjectURL(file);
+    a.download = fileName;
+    a.click();
+};
+exports.saveSchema = saveSchema;
+// var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
+const FORMATS = {
+    _title: (title) => {
+        if (title) {
+            return `\n  title="${title}"`;
+        }
+        return '';
+    },
+    _layout: (layout) => {
+        if (layout == 'common' || layout == 'simple' || layout == 'compress') {
+            return `\n  layout="${layout}"`;
+        }
+        return '';
+    },
+    _tip: (tip) => {
+        if (tip && tip.text) {
+            return `\n  tip={<Alert type="${tip.type}" message="${tip.text}"/>}`;
+        }
+        return '';
+    },
+    _group: (group) => {
+        return `{ title: "${group.title}", fields: [
+${group.fields.map(item => FORMATS._field(item)).join('\n')}
+        ]},`;
+    },
+    _field: (field) => {
+        var rule = '';
+        var config = '';
+        var options = '';
+        if (field.options) {
+            options = ` , options: [
+${field.options.map(item => `       { label:"${item.label}", value: "${item.value}"}`).join(',\n')}
+        ]`;
+        }
+        if (field.required) {
+            rule = ` ,rule: [
+                { required: true, },
+        ]`;
+        }
+        if (field.config) {
+        }
+        return `\n      {field:"${field.field}", type: "${field.type}", label:"${field.title}"${rule}${config}${options}}`;
+    }
+};
+const UFormCode = lodash_1.default.template(`<UModal<%= _title(data.title) %><%= _layout(data.layout) %><%= _tip(data.tip) %>
+    fields={[<% _.forEach(data.fields, function(field) { %><%= data.isGroup?_group(field):_field(field) %><% }); %>
+    ]}
+/>`, { imports: FORMATS, variable: 'data' });
+const saveUForm = (schema) => {
+    if (schema.fields.length <= 0) {
+        antd_1.message.error('表单最少要有一个字段');
+        return;
+    }
+    let codeText = UFormCode(schema);
+    let fileName = (schema.title ? schema.title : '代码') + ".tsx";
+    var file = new File([codeText], fileName, { type: "text/plain;charset=utf-8" });
+    var a = document.createElement('a');
+    a.href = URL.createObjectURL(file);
+    a.download = fileName;
+    a.click();
+};
+exports.saveUForm = saveUForm;
+const CEMS = `<?xml version="1.0" encoding="UTF-8"?>
+<policy id="" 
+	originalId="00010094" 
+	name="防网络入侵策略" 
+	type="2" 
+	priority="2" 
+	pid="d82b9e291e3445fdbabab18278caca35" 
+	crc="" 
+	level="1" 
+	orgLevel="" 
+	updateTime="" 
+	executelogic="8" 
+	description="防网络入侵策略模板" 
+	version="8.1.1709.2218" 
+	supportAgentType="1" 
+	UseAgenttype="1"
+></policy>`;
+const saveCEMS = (schema) => {
+    let fileName = (schema.policy || schema.title || 'policy') + ".xml";
+    var file = new File([CEMS], ".xml", { type: "text/plain;charset=utf-8" });
+    var a = document.createElement('a');
+    a.href = URL.createObjectURL(file);
+    a.download = fileName;
+    a.click();
+};
+exports.saveCEMS = saveCEMS;
+const loadFormJSON = (text) => {
+    try {
+        let info = JSON.parse(text);
+        let p = setId(info);
+        // notification.success({ message: <pre dangerouslySetInnerHTML={{ __html: JSON.stringify(p, null, 2) }}></pre> })
+        return p;
+    }
+    catch (err) {
+        throw err;
+    }
+};
+exports.loadFormJSON = loadFormJSON;

package/uform/utils/arr.d.ts

@@ -0,0 +1,12 @@
+import type { FormItem, FormGroup, Cursor } from "../schema";
+import type { PlainObject } from '../../basetype';
+export declare const insertInList: (fieldType: string, list: FormItem[], pos?: Cursor) => FormItem[];
+export declare const insertInGroup: (fieldType: string, list: FormGroup[], groupId: string, pos?: Cursor) => FormGroup[];
+export declare const sortList: (id: string, fields: FormItem[], pos: Cursor) => FormItem[];
+export declare const sortListInGroup: (id: string, fields: FormGroup[], groupId: string, pos?: Cursor) => FormGroup[];
+export declare const setProperties: (fields: FormItem[], fieldId: string, property: string | PlainObject, value: any) => any[];
+export declare const setPropertiesInGroup: (fields: FormGroup[], groupId: string, fieldId: string, property: string, value: any) => {
+    fields: any[];
+    id: string;
+    title: string;
+}[];

package/uform/utils/arr.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPropertiesInGroup = exports.setProperties = exports.sortListInGroup = exports.sortList = exports.insertInGroup = exports.insertInList = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const inputs_1 = require("../inputs");
+const antd_1 = require("antd");
+const utils_1 = require("../../utils");
+const insertFieldInList = (field, list, pos = null) => {
+    if (pos == null) {
+        return [...list, field];
+    }
+    let { id, prev } = pos;
+    let idx = lodash_1.default.findIndex(list, { id });
+    if (idx < 0) {
+        return [...list, field];
+    }
+    let inSertPos = prev ? idx : idx + 1;
+    return [...lodash_1.default.slice(list, 0, inSertPos), field, ...lodash_1.default.slice(list, inSertPos)];
+};
+// 插入一个字段到列表指定位置
+const insertInList = (fieldType, list, pos = null) => {
+    const info = (0, inputs_1.getInput)(fieldType);
+    if (info == null) {
+        antd_1.message.error('无此类型');
+        return list;
+    }
+    let key = utils_1.StringUtil.genKey();
+    const field = { id: key, type: fieldType, title: info.title, field: key };
+    if (info.defaultProperties)
+        lodash_1.default.assign(field, info.defaultProperties);
+    if (info.defaultConfig)
+        field.config = lodash_1.default.assign({}, info.defaultConfig);
+    if (info.fieldCount && info.fieldCount > 1)
+        field.field = lodash_1.default.range(info.fieldCount).map(utils_1.StringUtil.genKey).join(',');
+    if (info.hasOption) {
+        field.options = [];
+        if (field.type == 'switch') {
+            field.options.push({ id: utils_1.StringUtil.genKey(), label: '开启', value: '0' });
+            field.options.push({ id: utils_1.StringUtil.genKey(), label: '关闭', value: '1' });
+            field._default = '0';
+        }
+    }
+    return insertFieldInList(field, list, pos);
+};
+exports.insertInList = insertInList;
+// 插入一个字段到分组指定位置
+const insertInGroup = (fieldType, list, groupId, pos = null) => {
+    let idx = lodash_1.default.findIndex(list, { id: groupId });
+    if (idx < 0) {
+        return list;
+    }
+    let group = list[idx];
+    return [
+        ...lodash_1.default.slice(list, 0, idx),
+        Object.assign(Object.assign({}, group), { fields: (0, exports.insertInList)(fieldType, group.fields, pos) }),
+        ...lodash_1.default.slice(list, idx + 1)
+    ];
+};
+exports.insertInGroup = insertInGroup;
+// 在列表内字段拖拽排序
+const sortList = (id, fields, pos) => {
+    if (pos == null) {
+        return fields;
+    }
+    let idx = lodash_1.default.findIndex(fields, { id });
+    if (idx < 0) {
+        return fields;
+    }
+    let tdx = lodash_1.default.findIndex(fields, { id: pos.id });
+    if (tdx < 0 || tdx == idx) {
+        return fields;
+    }
+    if ((pos.prev && tdx - idx == 1) || (!pos.prev && idx - tdx == 1)) {
+        return fields;
+    }
+    let sorted = fields.filter(item => item.id != id);
+    tdx = lodash_1.default.findIndex(sorted, { id: pos.id });
+    let inSertPos = pos.prev ? tdx : tdx + 1;
+    return [...lodash_1.default.slice(sorted, 0, inSertPos), fields[idx], ...lodash_1.default.slice(sorted, inSertPos)];
+};
+exports.sortList = sortList;
+// 字段排序， 在分组里面
+const sortListInGroup = (id, fields, groupId, pos) => {
+    let [gdx, fdx] = [-1, -1];
+    let group = null;
+    for (let i = 0; i < fields.length; i++) {
+        group = fields[i];
+        let j = lodash_1.default.findIndex(group.fields, { id });
+        if (j >= 0) {
+            gdx = i;
+            fdx = j;
+            break;
+        }
+    }
+    if (gdx < 0 || fdx < 0) {
+        return fields;
+    }
+    // case 1 : 组内移动
+    if (group.id == groupId) {
+        return [
+            ...lodash_1.default.slice(fields, 0, gdx),
+            Object.assign(Object.assign({}, fields[gdx]), { fields: (0, exports.sortList)(id, fields[gdx].fields, pos) }),
+            ...lodash_1.default.slice(fields, gdx + 1),
+        ];
+    }
+    let tdx = lodash_1.default.findIndex(fields, { id: groupId });
+    if (tdx < 0) {
+        return fields;
+    }
+    let sourceGroup = fields[gdx];
+    let targetGroup = fields[tdx];
+    if (tdx > gdx) {
+        // case 2 : 上移到下
+        return [
+            ...lodash_1.default.slice(fields, 0, gdx),
+            Object.assign(Object.assign({}, sourceGroup), { fields: lodash_1.default.filter(sourceGroup.fields, item => item.id != id) }),
+            ...lodash_1.default.slice(fields, gdx + 1, tdx),
+            Object.assign(Object.assign({}, targetGroup), { fields: insertFieldInList(fields[gdx].fields[fdx], targetGroup.fields, pos) }),
+            ...lodash_1.default.slice(fields, tdx + 1),
+        ];
+    }
+    else {
+        // case 3 : 下移到上
+        return [
+            ...lodash_1.default.slice(fields, 0, tdx),
+            Object.assign(Object.assign({}, targetGroup), { fields: insertFieldInList(fields[gdx].fields[fdx], targetGroup.fields, pos) }),
+            ...lodash_1.default.slice(fields, tdx + 1, gdx),
+            Object.assign(Object.assign({}, sourceGroup), { fields: lodash_1.default.filter(sourceGroup.fields, item => item.id != id) }),
+            ...lodash_1.default.slice(fields, gdx + 1),
+        ];
+    }
+};
+exports.sortListInGroup = sortListInGroup;
+const setProperties = (fields, fieldId, property, value) => {
+    let idx = lodash_1.default.findIndex(fields, { id: fieldId });
+    if (idx < 0) {
+        return fields;
+    }
+    let info;
+    if (lodash_1.default.isString(property)) {
+        if (value === null) {
+            lodash_1.default.unset(info, property);
+        }
+        info = Object.assign(Object.assign({}, fields[idx]), { [property]: value });
+    }
+    else if (lodash_1.default.isPlainObject(property)) {
+        info = Object.assign(Object.assign({}, fields[idx]), property);
+    }
+    return [
+        ...(lodash_1.default.slice(fields, 0, idx)),
+        info,
+        ...(lodash_1.default.slice(fields, idx + 1))
+    ];
+};
+exports.setProperties = setProperties;
+const setPropertiesInGroup = (fields, groupId, fieldId, property, value) => {
+    let gdx = lodash_1.default.findIndex(fields, { id: groupId });
+    if (gdx < 0) {
+        return fields;
+    }
+    let group = fields[gdx];
+    let idx = lodash_1.default.findIndex(group.fields, { id: fieldId });
+    if (idx < 0) {
+        return fields;
+    }
+    return [
+        ...(lodash_1.default.slice(fields, 0, gdx)),
+        Object.assign(Object.assign({}, group), { fields: (0, exports.setProperties)(group.fields, fieldId, property, value) }),
+        ...(lodash_1.default.slice(fields, gdx + 1))
+    ];
+};
+exports.setPropertiesInGroup = setPropertiesInGroup;