ftdsy-attr 1.0.0 → 1.0.2

package/src/platform/dy.js

@@ -1,156 +0,0 @@
-export default {
-    createCategoryProperties
-}
-
-function createCategoryProperties(categoryPropertys) {
-
-    let propertys = categoryPropertys.map(item => {
-
-        if (item?.property_id !== undefined && item?.property_value !== undefined && item.property_type !== undefined) {
-            return item
-        }
-
-        // 属性可选选项
-        var property_values = []
-
-        if (item.options) {
-            // 存在可选选项
-            property_values = item.options.map(value => {
-                return {
-                    name: value.name,
-                    value_id: value.value_id,
-                    value: value.value,
-                    parent_value: []
-                }
-            })
-        }
-
-        var property_type = 0
-
-        var property_units = []
-        var property_unit = ''
-
-
-        var select_max_num = 0
-
-        var input_max_num = 0
-        var input_type = ''
-        var input_format = ''
-
-        var date_format = ''
-
-        var measure_templates = {} // 组合模版
-
-        if (item.type === 'text') {
-            // 文本
-            property_type = 1
-        } else if (item.type === 'select') {
-            // 单选
-            property_type = 2
-            select_max_num = 1
-        } else if (item.type === 'multi_select') {
-            // 多选
-            property_type = 3
-            select_max_num = item.multi_select_max
-        } else if (item.type === 'measure') {
-            // 单位输入
-            property_type = 4
-
-            if (item.measure_templates.length) {
-                let measure_templatesItem = item.measure_templates[0]
-
-                let moduleItem = measure_templatesItem.value_modules[0]
-                moduleItem.units.forEach(unit => {
-                    property_units.push(unit.unit_name)
-                })
-            }
-            property_unit = property_units[0]
-
-        } else if (item.type === 'multi_value_measure') {
-            // 组合多选 ('面料材质')
-            property_type = 6
-            select_max_num = item.multi_select_max
-
-            let measure_values = []
-            //
-            if (item.measure_templates.length) {
-                let measure_templatesItem = item.measure_templates[0]
-                measure_templates = {
-                    template_id: measure_templatesItem.template_id,
-                    value_modules: measure_templatesItem.value_modules.map(moduleItem => {
-                        return {
-                            input_type: moduleItem.input_type,
-                            module_id: moduleItem.module_id,
-                            prefix: moduleItem.prefix,
-                            suffix: moduleItem.suffix,
-                            unit: moduleItem.units.length ? moduleItem.units[0] : {
-                                unit_id: 0,
-                                unit_name: ''
-                            }
-                        }
-                    })
-                }
-
-                let moduleItem = measure_templatesItem.value_modules.find(moduleItem => moduleItem.input_type === 'enum_diy')
-                if (moduleItem) {
-                    // 查询到需要的带单位的
-                    measure_values = moduleItem.values
-                }
-            }
-
-            property_values = item.options.map(value => {
-
-                // let disableContent = measure_values.findIndex(valueItem => valueItem.value_name === value.name)
-
-                return {
-                    name: value.name,
-                    value_id: value.value_id,
-                    value: value.value,
-
-                    disableContent: false, // 是否需要成分
-                    content: '', // 成分
-                }
-            })
-        }
-
-        let show_condition = []
-
-
-        return {
-
-            property_id: item.property_id, // 属性id
-            property_required: item.required == 1, // 是否必填
-            property_name: item.property_name, // 属性名称
-
-            property_type: property_type, // 属性类型，0:未知 1:文本，2:单选，3:多选, 4:单位输入（数字）5：日期选择，6：组合多选
-            property_value: undefined ,// 属性值（根据具体属性类型，属性值类型不同）
-
-            property_values: property_values, // 属性可选值列表（单选、多选）
-
-            property_unit: property_unit, // 单位
-            property_units: property_units, // 单位列表
-
-            select_max_num: select_max_num ,// 最多选择多少个选项（多选，组合多选使用）
-            select_custom: false, // 是否支持自定义选项
-
-            input_max_num: input_max_num, // 输入文本最大字数（纯文本输入使用）
-            input_num: 0, // 当前文本输入字数
-
-            input_type: input_type, // 输入类型(单位输入使用)，number: 整数，float: 价格
-
-            input_format: input_format, // 输入格式（单位输入使用）
-            input_min_value: '', // 范围输入，最小值
-            input_max_value: '', // 范围输入，最大值
-
-            date_format: date_format, // 日期格式（日期使用）
-
-            measure_templates: measure_templates, // 属性模版 (组合模版)
-
-            has_children: false, // 没有子属性，
-            show_condition: show_condition ,// 显示条件，有数据即为子属性
-            condition_values: [], // 子属性根据父属性筛选后的 选项列表
-        }
-    })
-
-    return propertys
-}

package/src/platform/pdd.js

@@ -1,152 +0,0 @@
-
-export default {
-    createCategoryProperties
-}
-
-/**
- * 根据拼多多分类规则与属性，生成自定义 上货属性
- * */
-function createCategoryProperties(categoryPropertys) {
-
-    // 是否包含了子分类
-    var hasChildren = false
-
-    let propertys = categoryPropertys.filter(item => !item.is_sale).map(item => {
-
-        if (item?.property_id !== undefined && item?.property_value !== undefined && item.property_type !== undefined) {
-            if (item?.show_condition.length) {
-                // 有条件，即为 子属性
-                hasChildren = true
-            }
-            return item
-        }
-
-        var property_values = []
-        if (item.values) {
-            // 选项列表
-            property_values = item.values.map(value => {
-
-                return {
-                    name: value.value,
-                    value_id: value.vid,
-                    value: value.vid,
-                    parent_value: value.parent_vids ? value.parent_vids : []
-                }
-            })
-        }
-
-        var property_type = 0
-
-        var property_units = item.value_unit.filter(unitItem => unitItem)
-        var property_unit = property_units.length ? property_units[0] : ''
-
-        var select_max_num = 0
-
-        var input_max_num = 0
-        var input_type = ''
-        var input_format = ''
-
-        var date_format = ''
-
-        if (item.choose_max_num == 0) {
-            // 文本
-            if (item.property_value_type == 5) {
-                // 日期（拼多多日期格式为‘yyyy-MM-dd’, 目前仅发现”生产日期“）
-                property_type = 5
-                date_format = "yyyy-MM-dd"
-            } else if (property_unit) {
-                // 有带单位 （拼多多 仅发现整数输入）
-                property_type = 4
-                input_type = 'number'
-            } else {
-                // 纯文本
-                property_type = 1
-                input_max_num = Number(item.max_value) // “input_max_num“ 不可用，一直为0
-            }
-
-        } else if (item.choose_max_num == 1) {
-            // 单选
-            property_type = 2
-            select_max_num = 1
-        } else if (item.choose_max_num > 1) {
-            // 多选
-            property_type = 3
-            select_max_num = item.choose_max_num
-        }
-
-        // 显示条件
-        var show_condition = []
-        if (item.show_condition) {
-            // 当前属性，条件
-            show_condition = item.show_condition.map(conditionItem => {
-                return {
-                    parent_property_id: conditionItem.parent_ref_pid,
-                    parent_property_value: conditionItem.parent_vids
-                }
-            })
-        }
-
-        if (show_condition.length) {
-            // 有条件，即为 子属性
-            hasChildren = true
-        }
-
-        return {
-            property_id: item.ref_pid, // 属性id
-            property_required: item.required, // 是否必填
-            property_name: item.name, // 属性名称
-
-            property_values: property_values, // 属性可选值列表
-            property_type: property_type, // 属性类型，0:未知 1:文本，2:单选，3:多选, 4:单位输入（数字）5：日期选择，6：组合多选
-            property_value: undefined ,// 属性值（根据具体属性类型，属性值类型不同）
-
-            property_unit: property_unit, // 单位
-            property_units: property_units, // 单位列表
-
-            select_max_num: select_max_num ,// 最多选择多少个选项（多选，组合多选使用）
-            select_custom: false, // 是否支持自定义选项
-
-            input_max_num: input_max_num, // 输入文本最大字数（纯文本输入使用）
-            input_num: 0, // 当前文本输入字数
-
-            input_type: input_type, // 输入类型(单位输入使用)，number: 整数，float: 价格
-
-            input_format: input_format, // 输入格式（单位输入使用）
-            input_min_value: '', // 范围输入，最小值
-            input_max_value: '', // 范围输入，最大值
-
-            date_format: date_format, // 日期格式（日期使用）
-
-            has_children: false, // 没有子属性，
-            show_condition: show_condition ,// 显示条件，有数据即为子属性
-            condition_values: [], // 子属性根据父属性筛选后的 选项列表
-        }
-    })
-
-    if (hasChildren) {
-        // 当前属性列表中存在 子属性，给子属性的父属性设置
-        propertys.forEach(item => {
-            if (item.show_condition.length) {
-                // 当前属性为 子属性， 找到父属性
-                item.show_condition.forEach(conditionItem => {
-
-                    let result = propertys.find(propertyItem => propertyItem.property_id === conditionItem.parent_property_id)
-                    if (result) {
-                        // 找到父属性，并设置父属性 有子属性标识
-                        result.has_children = true
-                    }
-                })
-
-                // 排序 子属性放至最前面 (方便后续分组)
-                let index = propertys.findIndex(propertyItem => propertyItem.property_id === item.property_id)
-                if (index != -1) {
-                    propertys.splice(index , 1)
-                    propertys.unshift(item)
-                }
-            }
-        })
-    }
-    // console.log("自定义属性列表", JSON.stringify(propertys))
-    return propertys
-
-}

package/src/platform/tb.js

@@ -1,321 +0,0 @@
-
-export default {
-    createCategoryProperties
-}
-
-function createCategoryProperties(categoryPropertys) {
-
-    console.log(categoryPropertys)
-
-    let propertys = categoryPropertys.map(item => {
-
-        if (item?.property_id && item?.property_name && item?.property_type) {
-            // 已经转换为自定义完成
-            return item
-        }
-
-        if (!item.values) {
-            item.values = []
-        }
-
-        var property_required = false
-
-        var select_max_num = 0
-        var input_max_num = 0
-
-        var has_children = false
-
-        if (item.rules) {
-            // 属性有规则
-            var rule = item.rules?.rule || []
-
-            var ruleList = []
-            if (rule instanceof Array) {
-                ruleList = [...rule]
-            } else {
-                ruleList = [rule]
-            }
-
-            ruleList.forEach(ruleItem => {
-                if (ruleItem.name === 'requiredRule') {
-                    // 有找到必须标识
-                    property_required = Boolean(ruleItem.value)
-                } else if (ruleItem.name === 'maxLengthRule') {
-                    // 输入限制
-                    input_max_num = Number(ruleItem.value)
-                } else if (ruleItem.name === 'maxInputNumRule') {
-                    // 选择限制
-                    select_max_num = Number(ruleItem.value)
-                } else if (ruleItem.name === 'devTipRule') {
-                    // 有子属性
-                    has_children = true
-                }
-            })
-
-            // if (rule instanceof Array) {
-            // 	// 数组
-
-            // } else {
-            // 	// 对象
-            // 	if (rule.name === 'requiredRule') {
-            // 		// 有找到必须标识
-            // 		property_required = Boolean(rule.value)
-            // 	} else if (rule.name === 'maxLengthRule') {
-            // 		// 输入限制
-            // 		input_max_num = Number(rule.value)
-            // 	} else if (rule.name === 'maxInputNumRule') {
-            // 		// 选择限制
-            // 		select_max_num = Number(rule.value)
-            // 	}
-            // }
-        }
-
-        var property_values = []
-        if (item.options) {
-            // 单选，多选
-            if (item.options.option) {
-                let option = item.options.option
-                if (option instanceof Array) {
-                    property_values = item.options.option.map(value => {
-                        return {
-                            name: value.displayName,
-                            value_id: value.value,
-                            value: value.value
-                        }
-                    })
-                } else {
-                    property_values = [{
-                        name: option.displayName,
-                        value_id: option.value,
-                        value: option.value
-                    }]
-                }
-            }
-        }
-
-        var property_unit = ''
-        var property_units = []
-        var property_unit_type = ''
-
-        var input_format = '' // 值输入格式，单值输入为空
-        var input_operator = '' // 多值输入中间分隔符
-        var input_type = ''
-        var input_values = [] // 多值输入内容
-
-        var property_tips = ''
-
-        if (item?.properties) {
-            // 有属性限制
-            var property = item.properties.property
-            if (property.unitNames) {
-                // 需要上传单位
-                var unit = property.unitNames.unitName
-                if (unit instanceof Object) {
-                    // 对象
-                    property_unit = unit.value
-                    property_units = [unit.value]
-                } else if (unit instanceof Array) {
-                    // 数组（当前未遇到）
-                }
-            }
-
-            if (property.formats) {
-                // 输入格式
-                let format = property.formats.format
-                // console.log(format)
-                format.forEach((formatItem, formatIndex) => {
-
-                    input_format += formatItem.text || ''
-
-                    if (formatItem.type === 'input' && input_format && formatIndex != 0) {
-                        // 多值
-                        input_values.push({
-                            title: format[formatIndex - 1].text || '',
-                            value: ''
-                        })
-                    }
-
-                    if (formatItem.type === 'operator') {
-                        // 获取多值分割符
-                        input_operator = formatItem.text
-                    }
-                })
-
-            }
-
-            if (property.precision) {
-                // 输入限制（数字，小数点后几位，0为整数）
-                input_type = property.precision.value > 0 ? 'float' : 'number'
-            }
-
-            if (property.taoSirType) {
-                // 限制类型
-                property_unit_type = property.taoSirType.value
-            }
-
-
-            if (property.tip) {
-                // 有提示语
-                property_tips = property.tip?.value || ''
-            }
-        }
-
-        var property_type = 0
-
-        var date_format = ''
-
-        if (item.type === 'input') {
-            // 文本
-
-            select_max_num = 0
-            if (property_unit) {
-                // 需要使用到 单位
-                if (property_unit_type == 'date') {
-                    // 日期类型 （淘宝日期格式为‘yyyy-MM’, 目前仅发现”“）
-                    property_type = 5
-                    if (property_unit === '年') {
-                        date_format = 'yyyy'
-                    } else if (property_unit === '年月') {
-                        date_format = 'yyyy-MM'
-                    } else if (property_unit === '年月日') {
-                        date_format = 'yyyy-MM-dd'
-                    } else {
-                        date_format = 'yyyy-MM'
-                    }
-                } else {
-                    // 规格输入（数字、带单位）
-                    if (input_format !== '') {
-                        // 需要输入范围值
-                        property_type = 8
-                    } else {
-                        // 只需要输入一个值
-                        property_type = 4
-                    }
-                }
-            } else {
-                // 正常 纯文本
-                property_type = 1
-            }
-
-        } else if (item.type === 'singleCheck') {
-            // 单选
-            property_type = 2
-            select_max_num = 1
-        } else if (item.type === 'multiCheck') {
-            // 多选
-            property_type = 3
-            if (!select_max_num) {
-                // 没有现在，最多选5个
-                select_max_num = 5
-            }
-
-        } else if (item.type === 'multiComplex') {
-            // 组合 （当前仅“材质成分”）
-            property_type = 6
-            var field = item.fields.field
-
-            // 材质（选项）
-            var material_prop_name = field.find(fieldItem => fieldItem.id === 'material_prop_name')
-            // 含量（输入）
-            var material_prop_content = field.find(fieldItem => fieldItem.id === 'material_prop_content')
-
-            // 组合多选 选项内容
-            if (material_prop_name.options) {
-
-                if (material_prop_name.options.option) {
-                    property_values = material_prop_name.options.option.map(value => {
-                        return {
-                            name: value.displayName,
-                            value_id: value.value,
-                            value: value.value,
-
-                            disableContent: false, // 是否需要成分
-                            content: '', // 成分
-                        }
-                    })
-                }
-
-            }
-
-            // 设置组合规则
-            if (material_prop_content.rules) {
-                // 有规则
-                if (material_prop_content.rules.rule) {
-
-                    // 获取不可用
-                    var disableRule = material_prop_content.rules.rule.find(rule => rule.name === 'disableRule')
-                    if (disableRule) {
-                        // 有不可用的规则
-                        var express = disableRule["depend-group"]["depend-express"]
-                        if (express) {
-                            // 获取到无需设置 成分的
-                            express.forEach(expressItem => {
-
-                                if (expressItem.fieldId === 'material_prop_name') {
-
-                                    property_values.push({
-                                        name: expressItem.value,
-                                        value_id: expressItem.value,
-                                        value: expressItem.value,
-
-                                        disableContent: true, // 是否需要成分
-                                        content: '', // 成分
-                                    })
-                                }
-                            })
-                        }
-                    }
-                }
-            }
-            // console.log("材质面料选项", JSON.stringify(property_values))
-
-            if (!select_max_num) {
-                // 没有现在，最多选5个
-                select_max_num = 7
-            }
-            property_tips = '最多设置' + select_max_num + '个'
-        }
-
-
-        let show_condition = []
-
-        return {
-            property_id: item.id, // 属性id
-            property_required: property_required, // 是否必填
-            property_name: item.name, // 属性名称
-
-            property_values: property_values, // 属性可选值列表
-            property_type: property_type, // 属性类型，0:未知 1:文本，2:单选，3:多选, 4:单位输入（数字）5：日期选择，6：组合多选
-            property_value: undefined ,// 属性值（根据具体属性类型，属性值类型不同）
-
-            property_unit: property_unit, // 单位
-            property_units: property_units, // 单位列表
-
-            select_max_num: select_max_num ,// 最多选择多少个选项（多选，组合多选使用）
-            select_custom: false, // 是否支持自定义选项
-
-            input_max_num: input_max_num, // 输入文本最大字数（纯文本输入使用）
-            input_num: 0, // 当前文本输入字数
-
-            input_type: input_type, // 输入类型(单位输入使用)，number: 整数，float: 价格
-
-            input_format: input_format, // 输入格式（单位输入使用）
-            input_values: input_values, // 多值输入内容
-            input_operator: input_operator, // 多值输入分格符
-            input_min_value: '', // 范围输入，最小值
-            input_max_value: '', // 范围输入，最大值
-
-            date_format: date_format, // 日期格式（日期使用）
-
-            property_tips: property_tips, // 提示
-
-            has_children: has_children, // 没有子属性，
-            show_condition: show_condition ,// 显示条件，有数据即为子属性
-            condition_values: [], // 子属性根据父属性筛选后的 选项列表
-        }
-    })
-
-    console.log(propertys)
-
-    return propertys;
-}