@jzez-libs/custom_sku/dist/es5.js

/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "/";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 7);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var keyMap = __webpack_require__(8);
module.exports = function (plant) {
    return {
        responsiveData: function responsiveData(data, cb) {
            var obj = {};
            for (var k in data) {
                Object.defineProperty(obj, k, {
                    get: function get() {
                        return initValue;
                    },
                    set: function set(value) {
                        initValue = value;
                        cb && cb(k, value);
                    }
                });
            }
            return obj;
        },
        // 标准验证
        staValidFun: function staValidFun(prefix, v) {
            if (!v || v === '') return prefix + '必填';
            if (v * 1 <= 0) return prefix + '需填写合法数值';
            return '';
        },
        getKey: function getKey(name) {
            return keyMap[name][plant] || '';
        },
        runAction: function runAction(runs) {
            var msg = '';
            for (var i = 0; i < runs.length; i++) {
                var runOne = runs[i];
                runOne.condition() && (msg = runOne.msg);
                if (msg != '') break;
            }
            return msg;
        }
    };
};

/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

module.exports = function (row, plant) {
    var _this = this,
        _validateMap;

    /**
     * 
     */
    var codes = ['024', // -平开门（木门)
    '082' // 平开门（铝框门）
    ];

    // 构造表单
    var forms = [{
        key: this.utils.getKey('门洞宽'),
        label: '门洞宽',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row[this.utils.getKey('门洞宽最小值')] + '~' + row[this.utils.getKey('门洞宽极限值')] + '\u4E4B\u95F4',
        value: ""
    }, {
        key: this.utils.getKey('门洞高'),
        label: '门洞高',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row[this.utils.getKey('门洞高最小值')] + '~' + row[this.utils.getKey('门洞高极限值')] + '\u4E4B\u95F4',
        value: ""
    }, {
        key: this.utils.getKey('门洞深'),
        label: '门洞深',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row[this.utils.getKey('门洞深最小值')] + '~' + row[this.utils.getKey('门洞深极限值')] + '\u4E4B\u95F4',
        value: ""
    }, {
        key: this.utils.getKey('是否开孔'),
        label: '是否开孔',
        type: 'select',
        value: "",
        collections: [{
            label: '是',
            value: '是'
        }, {
            label: '否',
            value: '否'
        }]
    }, {
        key: this.utils.getKey('合页'),
        label: '合页',
        type: 'select',
        value: "",
        collections: row[this.utils.getKey('合页集合')] || []
    }, {
        key: this.utils.getKey('门锁'),
        label: '门锁',
        type: 'select',
        value: "",
        collections: row[this.utils.getKey('门锁集合')] || []
    }, {
        key: this.utils.getKey('开启方向'),
        label: '开启方向',
        value: "",
        type: 'select',
        collections: [{
            label: '左开',
            value: '左开'
        }, {
            label: '右开',
            value: '右开'
        }]
    }];

    var validateMap = (_validateMap = {}, _defineProperty(_validateMap, this.utils.getKey('门洞宽') + '_valid', function undefined(value, fd, fo) {
        var errorMsg = '';
        errorMsg = _this.utils.staValidFun('门洞宽', value);
        errorMsg = _this.utils.runAction([{ condition: function condition() {
                return errorMsg;
            }, msg: errorMsg }, { condition: function condition() {
                return value * 1 < row[_this.utils.getKey('门洞宽最小值')] || value * 1 > row[_this.utils.getKey('门洞宽极限值')];
            }, msg: '\u95E8\u6D1E\u5BBD' + fo.tip }]);
        return errorMsg;
    }), _defineProperty(_validateMap, this.utils.getKey('门洞高') + '_valid', function undefined(value, fd, fo) {
        var errorMsg = '';
        errorMsg = _this.utils.staValidFun('门洞高', value);
        errorMsg = _this.utils.runAction([{ condition: function condition() {
                return errorMsg;
            }, msg: errorMsg }, { condition: function condition() {
                return value * 1 < row[_this.utils.getKey('门洞高最小值')] || value * 1 > row[_this.utils.getKey('门洞高极限值')];
            }, msg: '\u95E8\u6D1E\u9AD8' + fo.tip }]);
        return errorMsg;
    }), _defineProperty(_validateMap, this.utils.getKey('门洞深') + '_valid', function undefined(value, fd, fo) {
        var errorMsg = '';
        errorMsg = _this.utils.staValidFun('门洞深', value);
        errorMsg = _this.utils.runAction([{ condition: function condition() {
                return errorMsg;
            }, msg: errorMsg }, { condition: function condition() {
                return value * 1 < row[_this.utils.getKey('门洞深最小值')] || value * 1 > row[_this.utils.getKey('门洞深极限值')];
            }, msg: '\u95E8\u6D1E\u6DF1' + fo.tip }]);
        return errorMsg;
    }), _defineProperty(_validateMap, this.utils.getKey('是否开孔') + '_valid', function undefined(value) {}), _defineProperty(_validateMap, this.utils.getKey('合页') + '_valid', function undefined(value, fd) {
        if (fd[_this.utils.getKey('是否开孔')] == '否') {
            fd[_this.utils.getKey('合页')] = ''; // 重置合页
            return '';
        } else {
            var errorMsg = '';
            errorMsg = _this.utils.staValidFun('合页', value);
            return errorMsg;
        }
    }), _defineProperty(_validateMap, this.utils.getKey('门锁') + '_valid', function undefined(value, fd) {
        if (fd[_this.utils.getKey('是否开孔')] == '否') {
            fd[_this.utils.getKey('门锁')] = ''; // 重置门锁
            return '';
        } else {
            var errorMsg = '';
            errorMsg = _this.utils.staValidFun('门锁', value);
            return errorMsg;
        }
    }), _defineProperty(_validateMap, this.utils.getKey('开启方向') + '_valid', function undefined(value, fd) {
        if (fd[_this.utils.getKey('是否开孔')] == '否') {
            fd[_this.utils.getKey('开启方向')] = ''; // 重置开启方式
            return '';
        } else {
            var errorMsg = '';
            errorMsg = _this.utils.staValidFun(value);
            return errorMsg;
        }
    }), _validateMap);

    return {
        validateMap: validateMap,
        // 更新form的 disabled
        refreshForm: function refreshForm() {
            var formData = {};
            for (var i = 0; i < this.forms.length; i++) {
                var rone = this.forms[i];
                formData[rone.key] = rone.value;
            }
            this.forms.map(function (item) {
                // 是否开孔为否的时候 
                if (formData[this.utils.getKey('是否开孔')] == '否') {
                    // 都要隐掉合页门锁和开启方式
                    if ([this.utils.getKey('合页'), this.utils.getKey('门锁'), this.utils.getKey('开启方向')].indexOf(item.key) != -1) Object.assign(item, { disabled: true });
                } else {
                    Object.assign(item, { disabled: false });
                }
            });
        },
        codes: codes,
        forms: forms

    };
};

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(0);
module.exports = function (row) {
    /**
     * 
     */
    var codes = ['097', // （铝框门门扇
    '089' // (门扇木门)
    ];

    // 构造表单

    var forms = [{
        key: 'U_DSWide',
        label: '门洞宽',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DWWideMin + '~' + row.U_DWWideL + '\u4E4B\u95F4\uFF08\u5982\u679C\u586B\u5199\u4E86\u95E8\u6247\u5BBD\uFF0C\u5219\u8303\u56F4\u4F1A\u6709\u6D6E\u52A8\uFF09',
        value: ""
    }, {
        key: 'U_DSHigh',
        label: '门洞高',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DWHighMin + '~' + row.U_DWHighL + '\u4E4B\u95F4\uFF08\u5982\u679C\u586B\u5199\u4E86\u95E8\u6247\u9AD8\uFF0C\u5219\u8303\u56F4\u4F1A\u6709\u6D6E\u52A8\uFF09',
        value: ""
    }, {
        key: 'U_DSThick',
        label: '门洞深',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DWDeepMin + '~' + row.U_DWDeepL + '\u4E4B\u95F4',
        value: ""
    }, {
        key: 'U_TDWide',
        label: '门扇宽',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DLWideMin + '~' + row.U_DLWideL + '\u4E4B\u95F4\uFF08\u5982\u679C\u586B\u5199\u4E86\u95E8\u6D1E\u5BBD\uFF0C\u5219\u8303\u56F4\u4F1A\u6709\u6D6E\u52A8\uFF09',
        value: ""
    }, {
        key: 'U_TDHigh',
        label: '门扇高',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DLHighMin + '~' + row.U_DLHighL + '\u4E4B\u95F4\uFF08\u5982\u679C\u586B\u5199\u4E86\u95E8\u6D1E\u9AD8\uFF0C\u5219\u8303\u56F4\u4F1A\u6709\u6D6E\u52A8\uFF09',
        value: ""
    }];

    var validateMap = {
        U_DSWide_valid: function U_DSWide_valid(value, fd, fo) {
            var errorMsg = '';
            // 如果不填写就不验证（特殊逻辑）
            if (!value || value == '') return '';
            errorMsg = utils.staValidFun('门洞宽', value);

            if (!!errorMsg) return errorMsg;
            // 如果填写了门扇宽
            // 门扇数是双扇       门扇宽*2-60<=门洞宽<=门扇宽*2-10；
            // 门扇数是四扇      门扇宽*4-180<=门洞宽<=门扇宽*4-130；
            if (fd.U_TDWide != '' && !isNaN(fd.U_TDWide)) {
                if (row.U_DLNum == "双扇") {
                    if (value < fd.U_TDWide * 2 - 60 || value > fd.U_TDWide * 2 - 10) {
                        errorMsg = '门洞宽范围应在' + (fd.U_TDWide * 2 - 60) + '~' + (fd.U_TDWide * 2 - 10) + '之间';
                    }
                } else if (row.U_DLNum == "四扇") {
                    if (value < fd.U_TDWide * 4 - 180 || value > fd.U_TDWide * 4 - 130) {
                        errorMsg = '门洞宽范围应在' + (fd.U_TDWide * 4 - 180) + '~' + (fd.U_TDWide * 4 - 130) + '之间';
                    }
                }
                // 走常规最值验证
                else if (value < row.U_DWWideMin || value > row.U_DWWideL) errorMsg = '\u95E8\u6D1E\u5BBD' + fo.tip;
            }
            // 走常规最值验证
            else {
                    if (value < row.U_DWWideMin || value > row.U_DWWideL) errorMsg = '\u95E8\u6D1E\u5BBD' + fo.tip;
                }
            return errorMsg;
        },
        U_DSHigh_valid: function U_DSHigh_valid(value, fd, fo) {
            var errorMsg = '';
            // 如果不填写就不验证（特殊逻辑）
            if (!value || value == '') return '';
            errorMsg = utils.staValidFun('门洞高', value);
            if (!!errorMsg) return errorMsg;
            //如果填写了，门扇高   
            //门扇数是双扇       门扇高+80<=门洞高<=门扇高+110；
            //门扇数是四扇      门扇高+80<=门洞高<=门扇高+110；
            if (fd.U_TDHigh !== '' && !isNaN(fd.U_TDHigh)) {
                if (value < fd.U_TDHigh * 1 + 80 || value > fd.U_TDHigh * 1 + 110) {
                    errorMsg = '门洞高范围应在' + (fd.U_TDHigh * 1 + 80) + '~' + (fd.U_TDHigh * 1 + 110) + '之间';
                }
            } else {
                if (value < row.U_DWHighMin || value > row.U_DWHighL) errorMsg = '\u95E8\u6D1E\u9AD8' + fo.tip;
            }
            return errorMsg;
        },
        U_DSThick_valid: function U_DSThick_valid(value, fd, fo) {
            var errorMsg = '';
            // 如果不填写就不验证（特殊逻辑）
            if (!value || value == '') return '';
            errorMsg = utils.staValidFun('门洞深', value);
            errorMsg = utils.runAction([{ condition: function condition() {
                    return errorMsg;
                }, msg: errorMsg }, { condition: function condition() {
                    return value < row.U_DWDeepMin || value > row.U_DWDeepL;
                }, msg: '\u95E8\u6D1E\u6DF1' + fo.tip }]);
            return errorMsg;
        },

        // 门扇宽
        U_TDWide_valid: function U_TDWide_valid(value, fd, fo) {
            var errorMsg = '';
            errorMsg = utils.staValidFun('门扇宽', value);
            if (!!errorMsg) return errorMsg;
            //如果填写了，门洞宽  
            //  门扇数是双扇       （门洞宽+10）/2<=门扇宽<=（门洞宽+60）/2；
            //  门扇数是四扇      （门洞宽+130）/4<=门扇宽<=（门洞宽+180）/4；
            if (fd.U_DSWide !== '' && !isNaN(fd.U_DSWide)) {
                if (row.U_DLNum == "双扇") {
                    if (value < (fd.U_DSWide * 1 + 10) / 2 || value > (fd.U_DSWide * 1 + 60) / 2) {
                        errorMsg = '门扇宽范围应在' + (fd.U_DSWide * 1 + 10) / 2 + '~' + (fd.U_DSWide * 1 + 60) / 2 + '之间';
                    }
                } else if (row.U_DLNum == "四扇") {
                    if (value < (fd.U_DSWide * 1 + 130) / 4 || value > (fd.U_DSWide * 1 + 180) / 4) {
                        errorMsg = '门扇宽范围应在' + (fd.U_DSWide * 1 + 130) / 4 + '~' + (fd.U_DSWide * 1 + 180) / 4 + '之间';
                    }
                } else if (value < row.U_DLWideMin || value > row.U_DLWideL) errorMsg = '\u95E8\u6247\u5BBD' + fo.tip;
            } else {
                if (value < row.U_DLWideMin || value > row.U_DLWideL) errorMsg = '\u95E8\u6247\u5BBD' + fo.tip;
            }
            return errorMsg;
        },
        // 门扇高
        U_TDHigh_valid: function U_TDHigh_valid(value, fd, fo) {
            var errorMsg = '';
            errorMsg = utils.staValidFun('门扇高', value);
            if (!!errorMsg) return errorMsg;
            //如果填写了，门洞高  
            //  门扇数是双扇      门洞高-110<=门扇高<=门洞高-80；
            //  门扇数是四扇      门洞高-110<=门扇高<=门洞高-80；
            if (fd.U_DSHigh !== '' && !isNaN(fd.U_DSHigh)) {
                if (value < fd.U_DSHigh * 1 - 110 || value > fd.U_DSHigh * 1 - 80) {
                    errorMsg = '门扇高范围应在' + (fd.U_DSHigh * 1 - 110) + '~' + (fd.U_DSHigh * 1 - 80) + '之间';
                }
            } else {
                if (value < row.U_DLHighMin || value > row.U_DLHighL) errorMsg = '\u95E8\u6247\u9AD8' + fo.tip;
            }
            return errorMsg;
        }

    };

    return {
        validateMap: validateMap,
        codes: codes,
        forms: forms
    };
};

/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(0);
module.exports = function (row) {
    /**
     * 
     */
    var codes = ['025', // -移门（木门)
    '083' // 移门（铝框门）
    ];

    // 构造表单

    var forms = [{
        key: 'U_DSWide',
        label: '门洞宽',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DWWideMin + '~' + row.U_DWWideL + '\u4E4B\u95F4',
        value: ""
    }, {
        key: 'U_DSHigh',
        label: '门洞高',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DWHighMin + '~' + row.U_DWHighL + '\u4E4B\u95F4',
        value: ""
    }, {
        key: 'U_DSThick',
        label: '门洞深',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DWDeepMin + '~' + row.U_DWDeepL + '\u4E4B\u95F4',
        value: ""
    }];

    var validateMap = {
        U_DSWide_valid: function U_DSWide_valid(value, fd, fo) {
            var errorMsg = '';
            errorMsg = utils.staValidFun('门洞宽', value);
            errorMsg = utils.runAction([{ condition: function condition() {
                    return errorMsg;
                }, msg: errorMsg }, { condition: function condition() {
                    return value * 1 < row.U_DWWideMin || value * 1 > row.U_DWWideL;
                }, msg: '\u95E8\u6D1E\u5BBD' + fo.tip }]);
            return errorMsg;
        },
        U_DSHigh_valid: function U_DSHigh_valid(value, fd, fo) {
            var errorMsg = '';
            errorMsg = utils.staValidFun('门洞高', value);
            errorMsg = utils.runAction([{ condition: function condition() {
                    return errorMsg;
                }, msg: errorMsg }, { condition: function condition() {
                    return value * 1 < row.U_DWHighMin || value * 1 > row.U_DWHighL;
                }, msg: '\u95E8\u6D1E\u9AD8' + fo.tip }]);
            return errorMsg;
        },
        U_DSThick_valid: function U_DSThick_valid(value, fd, fo) {
            var errorMsg = '';
            errorMsg = utils.staValidFun('门洞深', value);
            errorMsg = utils.runAction([{ condition: function condition() {
                    return errorMsg;
                }, msg: errorMsg }, { condition: function condition() {
                    return value * 1 < row.U_DWDeepMin || value * 1 > row.U_DWDeepL;
                }, msg: '\u95E8\u6D1E\u6DF1' + fo.tip }]);
            return errorMsg;
        }
    };

    return {
        validateMap: validateMap,
        codes: codes,
        forms: forms
    };
};

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var utils = __webpack_require__(0);
module.exports = function (row) {
    /**
     * 
     */
    var codes = {
        // 以下类型输出门洞宽高深，并且仅验证门洞深必填，其他填写则验证
        types1: ['029', //门套（木门）
        '091', //筒子板（木门）
        '093', // 筒子板（铝框门）
        '084', //门套（铝框门）
        '028' //飘窗板
        ],
        // 以下两个类型输出门洞宽高深并且严格验证
        types2: ['026', //垭口木门
        '027' // 窗套
        ],
        // 以下类型 仅输出一个form 为 门洞深
        types3: ['098', // "遮轮板（木门）"
        '099' // "遮轮板（铝框门）"
        ]
    };

    var allCodes = [].concat(_toConsumableArray(codes.types1), _toConsumableArray(codes.types2), _toConsumableArray(codes.types3));
    // 构造表单

    var form1 = [{
        key: 'U_DSWide',
        label: '门洞宽',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DWWideMin + '~' + row.U_DWWideL + '\u4E4B\u95F4',
        value: ""
    }, {
        key: 'U_DSHigh',
        label: '门洞高',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DWHighMin + '~' + row.U_DWHighL + '\u4E4B\u95F4',
        value: ""
    }, {
        key: 'U_DSThick',
        label: '门洞深',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DWDeepMin + '~' + row.U_DWDeepL + '\u4E4B\u95F4',
        value: ""
    }];
    var form2 = [{
        key: 'U_DSThick',
        label: '门洞深',
        type: 'txt',
        tip: '\u8303\u56F4\u5E94\u5728' + row.U_DWDeepMin + '~' + row.U_DWDeepL + '\u4E4B\u95F4',
        value: ""
    }];
    var validateMap = {
        U_DSWide_valid: function U_DSWide_valid(value, fd, fo) {
            var errorMsg = '';
            // 校验type1的时候  非必填的验证
            if (codes.types1.indexOf(row.Code) != -1) {
                if (!value || value == '') return '';
            }
            errorMsg = utils.staValidFun('门洞宽', value);
            errorMsg = utils.runAction([{ condition: function condition() {
                    return errorMsg;
                }, msg: errorMsg }, { condition: function condition() {
                    return value * 1 < row.U_DWWideMin || value * 1 > row.U_DWWideL;
                }, msg: '\u95E8\u6D1E\u5BBD' + fo.tip }]);
            return errorMsg;
        },
        U_DSHigh_valid: function U_DSHigh_valid(value, fd, fo) {
            var errorMsg = '';
            // 校验type1的时候  非必填的验证
            if (codes.types1.indexOf(row.Code) != -1) {
                if (!value || value == '') return '';
            }
            errorMsg = utils.staValidFun('门洞高', value);
            errorMsg = utils.runAction([{ condition: function condition() {
                    return errorMsg;
                }, msg: errorMsg }, { condition: function condition() {
                    return value * 1 < row.U_DWHighMin || value * 1 > row.U_DWHighL;
                }, msg: '\u95E8\u6D1E\u9AD8' + fo.tip }]);
            return errorMsg;
        },
        U_DSThick_valid: function U_DSThick_valid(value, fd, fo) {
            var errorMsg = '';
            errorMsg = utils.staValidFun('门洞深', value);
            errorMsg = utils.runAction([{ condition: function condition() {
                    return errorMsg;
                }, msg: errorMsg }, { condition: function condition() {
                    return value * 1 < row.U_DWDeepMin || value * 1 > row.U_DWDeepL;
                }, msg: '\u95E8\u6D1E\u6DF1' + fo.tip }]);
            return errorMsg;
        }
    };

    return {
        validateMap: validateMap,
        codes: allCodes,
        forms: codes.types3.indexOf(row.Code) == -1 ? form1 : form2
    };
};

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(0);
module.exports = function (row) {
    /**
     * 
     */
    var codes = ['032']; // 智能门锁

    // 构造表单

    var forms = [{
        key: 'U_DThick',
        label: '门厚度',
        type: 'txt',
        value: ""
    }, {
        key: 'U_LBLength',
        label: '锁体挡板长度',
        type: 'txt',
        tip: '\u5355\u4F4D\uFF08mm\uFF09',
        value: ""
    }, {
        key: 'U_LBWide',
        label: '锁体挡板宽度',
        type: 'txt',
        tip: '\u5355\u4F4D\uFF08mm\uFF09',
        value: ""
    }, {
        key: 'U_AbDis',
        label: '锁体档板左右螺丝十字中心孔距',
        type: 'txt',
        tip: '\u5355\u4F4D\uFF08mm\uFF09',
        value: ""
    }, {
        key: 'U_UDDis',
        label: '锁体档板上下螺丝十字中心孔距',
        type: 'txt',
        tip: '\u5355\u4F4D\uFF08mm\uFF09',
        value: ""
    }, {
        key: 'U_LTRDis',
        label: '门边到锁面板右侧的距离',
        type: 'txt',
        tip: '\u5355\u4F4D\uFF08mm\uFF09',
        value: ""
    }, {
        key: 'U_TLLength',
        label: '门锁面板总长度',
        type: 'txt',
        tip: '\u5355\u4F4D\uFF08mm\uFF09',
        value: ""
    }, {
        key: 'U_DType',
        label: '门的类别',
        type: 'select',
        collections: [{ value: "木门", label: "木门" }, { value: "铁门", label: "铁门" }],
        value: ""
    }, {
        key: 'U_DoorO',
        label: '门锁门开向',
        type: 'select',
        collections: [{ value: "左内开", label: "左内开" }, { value: "左外开", label: "左外开" }, { value: "右内开", label: "右内开" }, { value: "右外开", label: "右外开" }],
        value: ""
    }, {
        key: 'U_LoPro',
        label: '是否有天地钩',
        type: 'select',
        collections: [{ label: "是", value: "是" }, { label: "否", value: "否" }],
        value: ""
    }];
    var validateMap = {
        U_DThick_valid: function U_DThick_valid(value, fd, fo) {
            return utils.staValidFun('门厚度', value);
        },
        U_LBLength_valid: function U_LBLength_valid(value, fd, fo) {
            return utils.staValidFun('锁体挡板长度', value);
        },
        U_LBWide_valid: function U_LBWide_valid(value, fd, fo) {
            return utils.staValidFun('锁体挡板宽度', value);
        },
        U_AbDis_valid: function U_AbDis_valid(value, fd, fo) {
            return utils.staValidFun('锁体档板左右螺丝十字中心孔距', value);
        },
        U_UDDis_valid: function U_UDDis_valid(value, fd, fo) {
            return utils.staValidFun('锁体档板上下螺丝十字中心孔距', value);
        },
        U_LTRDis_valid: function U_LTRDis_valid(value, fd, fo) {
            return utils.staValidFun('门边到锁面板右侧的距离', value);
        },
        U_TLLength_valid: function U_TLLength_valid(value, fd, fo) {
            return utils.staValidFun('门锁面板总长度', value);
        },
        U_DType_valid: function U_DType_valid(value, fd, fo) {
            return value == '' ? '请选择门类别' : '';
        },
        U_DoorO_valid: function U_DoorO_valid(value, fd, fo) {
            return value == '' ? '请选择门锁方向' : '';
        },
        U_LoPro_valid: function U_LoPro_valid(value, fd, fo) {
            return value == '' ? '请选择手否有天地钩' : '';
        }
    };

    return {
        validateMap: validateMap,
        codes: codes,
        forms: forms
    };
};

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(0);
module.exports = function (row) {
    /**
     * 
     */
    var codes = ['017']; // 台面

    // 构造表单

    var forms = [{
        key: 'U_putOrderType',
        label: '下单分类',
        type: 'select',
        collections: [{ label: "台面", value: "台面" }, { label: "包管", value: "包管" }, { label: "台面+包管", value: "台面+包管" }],
        value: ""
    }, {
        key: 'U_FModeling',
        label: '前沿造型',
        type: 'selct',
        collections: [{ label: "DM-008-直边", value: "DM-008-直边" }, { label: "DM-002-罗马边", value: "DM-002-罗马边" }, { lable: "DM-006-前翘边", value: "DM-006-前翘边" }],
        value: ""
    }, {
        key: 'U_BasinT',
        label: '台盆工艺',
        type: 'select',
        collections: [{ label: "台上工艺", value: "台上工艺" }, { label: "台下工艺", value: "台下工艺" }],
        value: ""
    }, {
        key: 'U_TableB',
        label: '台面进深',
        type: 'txt',
        tip: '\u8303\u56F4' + row.U_PSDeepMin + '~' + row.U_PSDeepMax,
        value: ""
    }, {
        key: 'U_HeightWR',
        label: '挡水高度',
        type: 'txt',
        value: ""
    }, {
        key: 'U_ASWide',
        label: '包管展开宽',
        type: 'txt',
        value: ""
    }, {
        key: 'U_ASDeep',
        label: '包管展开深',
        type: 'txt',
        value: ""
    }];
    // 包管
    var baoguan = ['U_FModeling', 'U_BasinT', 'U_TableB', 'U_HeightWR'];
    // 台面
    var taimian = ['U_ASWide', 'U_ASDeep'];
    var validateMap = {
        U_putOrderType_valid: function U_putOrderType_valid(value, fd, fo) {
            if (!value || value == '') return '请选择下单分类';
            return '';
        },

        U_FModeling_valid: function U_FModeling_valid(value, fd, fo) {
            // 下单类型为包管的时候不需要验证前沿造型，并且要清除前沿造型
            if (fd.U_putOrderType == '包管') {
                fd.U_FModeling = '';
                return '';
            }
            if (!value || value == '') return '请选择前沿造型';
            return '';
        },

        U_BasinT_valid: function U_BasinT_valid(value, fd, fo) {
            // 下单类型为包管的时候不需要验证台盆工艺，并且要清除台盆工艺
            if (fd.U_putOrderType == '包管') {
                fd.U_BasinT = '';
                return '';
            }
            if (!value || value == '') return '请选择台盆工艺';
            return '';
        },

        U_TableB_valid: function U_TableB_valid(value, fd, fo) {
            var errorMsg = '';
            // 下单类型为包管的时候不需要验证台面进深，并且要清除台面进深
            if (fd.U_putOrderType == '包管') {
                fd.U_TableB = '';
                return '';
            }
            errorMsg = utils.staValidFun('台面进深', value);
            errorMsg = utils.runAction([{ condition: function condition() {
                    return errorMsg;
                }, msg: errorMsg }, { condition: function condition() {
                    return value * 1 < row.U_PSDeepMin || value * 1 > row.U_PSDeepMax;
                }, msg: '\u53F0\u9762\u8FDB\u6DF1' + fo.tip }]);
            return errorMsg;
        },

        U_HeightWR_valid: function U_HeightWR_valid(value, fd, fo) {
            // 下单类型为包管的时候不需要验证挡水高度，并且要清除挡水高度
            if (fd.U_putOrderType == '包管') {
                fd.U_HeightWR = '';
                return '';
            }
            return utils.staValidFun('挡水高度', value);
        },

        U_ASWide_valid: function U_ASWide_valid(value, fd, fo) {
            // 下单类型为台面的时候不需要验证包管展开宽，并且要清除包管展开宽
            if (fd.U_putOrderType == '台面') {
                fd.U_ASWide = '';
                return '';
            }
            return utils.staValidFun('包管展开宽', value);
        },

        U_ASDeep_valid: function U_ASDeep_valid(value, fd, fo) {
            // 下单类型为台面的时候不需要验证包管展开深，并且要清除包管展开深
            if (fd.U_putOrderType == '台面') {
                fd.U_ASDeep = '';
                return '';
            }
            return utils.staValidFun('包管展开深', value);
        }
    };

    return {
        validateMap: validateMap,
        // 更新form的 disabled
        refreshForm: function refreshForm() {
            var formData = {};
            for (var i = 0; i < this.forms.length; i++) {
                var rone = this.forms[i];
                formData[rone.key] = rone.value;
            }
            this.forms.map(function (item) {
                if (formData.U_putOrderType == '台面') {
                    // 包管都要隐掉
                    if (baoguan.indexOf(item.key) != -1) Object.assign(item, { disabled: true });
                } else if (formData.U_putOrderType == '包管') {
                    // 台面都要隐掉
                    if (taimian.indexOf(item.key) != -1) Object.assign(item, { disabled: true });
                } else {
                    Object.assign(item, { disabled: false });
                }
            });
        },
        codes: codes,
        forms: forms
    };
};

/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var utils = __webpack_require__(0);
var vArray = [];
var v1 = __webpack_require__(1);
var v2 = __webpack_require__(2);
var v3 = __webpack_require__(3);
var v4 = __webpack_require__(4);
var v5 = __webpack_require__(5);
var v6 = __webpack_require__(6);
vArray.push(v1);
vArray.push(v2);
vArray.push(v3);
vArray.push(v4);
vArray.push(v5);
vArray.push(v6);
(function (f) {
    module.exports = f;
    window.ecomps = { actionFun: f };
})(function (row) {
    var plant = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;

    var funMap = {
        validate: function validate(newforms) {
            var realForms = newforms || this.forms;
            // 构造新formData
            var formData = {};
            for (var i = 0; i < realForms.length; i++) {
                var rone = realForms[i];
                formData[rone.key] = rone.value;
            }
            var errorMsg = '';
            for (var _i = 0; _i < realForms.length; _i++) {
                var _rone = realForms[_i];
                errorMsg = this.validateMap[_rone.key + '_valid'](_rone.value, formData, _rone);
                if (errorMsg) break;
            }
            return {
                errorMsg: errorMsg,
                formData: formData
            };
        }
    };
    vArray.map(function (v) {
        v.prototype.utils = new utils(plant);
        // 1大写  2 小写
        var itemMap = new v(row);
        if (itemMap.codes.indexOf(row.Code) != -1) {
            Object.assign(funMap, itemMap);
            funMap.forms.map(function (item) {
                Object.assign(item, { disabled: false });
            });
        }
    });
    return funMap;
});

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


module.exports = {
    '门洞宽': { 1: 'U_DSWide', 2: 'uDswide' },
    '门洞宽最小值': { 1: 'U_DWWideMin', 2: 'uDwwidemin' },
    '门洞宽极限值': { 1: 'U_DWWideL', 2: 'uDwwidel' },

    '门洞高': { 1: 'U_DSHigh', 2: '' },
    '门洞高最小值': { 1: 'U_DWHighMin', 2: '' },
    '门洞高极限值': { 1: 'U_DWHighL', 2: '' },

    '门洞深': { 1: 'U_DSThick', 2: '' },
    '门洞深最小值': { 1: 'U_DWDeepMin', 2: '' },
    '门洞深极限值': { 1: 'U_DWDeepL', 2: '' },

    '是否开孔': { 1: 'U_IKeyHole', 2: '' },
    '开启方向': { 1: 'U_OpenWay', 2: '' },

    '合页': { 1: 'U_HiPro', 2: '' },
    '合页集合': { 1: 'U_HingeCodes', 2: '' },

    '门锁': { 1: 'U_LoPro', 2: '' },
    '门锁集合': { 1: 'U_LockCodes', 2: '' },

    '门扇宽': { 1: 'U_TDWide', 2: '' },
    '门扇宽最小值': { 1: 'U_DLWideMin', 2: '' },
    '门扇宽极限值': { 1: 'U_DLWideL', 2: '' },

    '门扇高': { 1: 'U_TDHigh', 2: '' },
    '门扇高最小值': { 1: 'U_DLHighMin', 2: '' },
    '门扇高极限值': { 1: 'U_DLHighL', 2: '' },

    '门厚度': { 1: 'U_DThick', 2: '' },
    '锁体挡板长度': { 1: 'U_LBLength', 2: '' },
    '锁体挡板宽度': { 1: 'U_LBWide', 2: '' },
    '锁体档板左右螺丝十字中心孔距': { 1: 'U_AbDis', 2: '' },
    '锁体档板上下螺丝十字中心孔距': { 1: 'U_UDDis', 2: '' },
    '门边到锁面板右侧的距离': { 1: 'U_LTRDis', 2: '' },
    '门锁面板总长度': { 1: 'U_TLLength', 2: '' },
    '门的类别': { 1: 'U_DType', 2: '' },
    '门锁门开向': { 1: 'U_DoorO', 2: '' },
    '是否有天地钩': { 1: 'U_LoPro', 2: '' },

    '下单分类': { 1: 'U_putOrderType', 2: '' },
    '前沿造型': { 1: 'U_FModeling', 2: '' },
    '台盆工艺': { 1: 'U_BasinT', 2: '' },
    '台面进深': { 1: 'U_TableB', 2: '' },
    '台面进深最小值': { 1: 'U_PSDeepMin', 2: '' },
    '台面进深最大值': { 1: 'U_PSDeepMax', 2: '' },
    '挡水高度': { 1: 'U_HeightWR', 2: '' },
    '包管展开宽': { 1: 'U_ASWide', 2: '' },
    '包管展开深': { 1: 'U_ASDeep', 2: '' },

    '三级分类': { 1: 'Code', 2: '' },
    '二级分类': { 1: 'FirmCode', 2: '' },
    '一级分类': { 1: 'ItmsGrpCod', 2: '' }
};

/***/ })
/******/ ]);