ftdsy-attr 1.0.0 → 1.0.2

package/src/tools/property.js

@@ -1,351 +0,0 @@
-
-import utils from "../utils/utils.js";
-
-export default {
-
-    // 匹配文本输入
-    matchInputProperty(propertyItem, goodsProperties, goods) {
-
-        // 进行包含匹配
-        let result = goodsProperties.findIndex(item => item.attr_name.includes(propertyItem.property_name))
-        if (result != -1) {
-            // 能进行模糊匹配到, 直接文本直接赋值
-            let goodsProperty = goodsProperties[result]
-            goodsProperties.splice(result, 1) // 从匹配数据中移除
-
-            if (typeof goodsProperty.value === 'string') {
-                // 值为字符串
-                return goodsProperty.value
-            }
-
-            if (typeof goodsProperty.value === 'object') {
-                // 对象/数组
-                if (goodsProperty.value instanceof Array) {
-                    // 数组
-                    let property_values = []
-                    let reg = /(.*?)\[(\d+)%\]/
-                    goodsProperty.value.forEach(valueItem => {
-
-                        if (typeof valueItem === 'string' && reg.test(valueItem)) {
-                            // 为字符串，并且为 '其他材质[100%]'格式数据
-                            let values = reg.exec(valueItem)
-
-                            if (propertyItem.property_name.includes('含量')) {
-                                // 含量，只取含量，不取材质
-                                property_values.push(values[2])
-                            } else if (propertyItem.property_name.includes('材质成分')) {
-                                // 材质成分，直接赋值
-                                property_values.push(values[0])
-                            } else if (propertyItem.property_name.includes('材质')) {
-                                // 材质，只取材质，不取含量
-                                property_values.push(values[1])
-                            }
-                        }
-                    })
-                    return property_values.length ? property_values[0] : ''
-                }
-            }
-        }
-
-        // 没有进行模糊匹配到，进行特殊处理
-
-        if (propertyItem.property_name.includes('CCC') || propertyItem.property_name.includes('3C')) {
-            // 玩具3C认证
-            result = goodsProperties.findIndex(item => item.attr_name.includes('CCC') || item.attr_name.includes('3C'))
-            if (result != -1) {
-                let goodsProperty = goodsProperties[result]
-                goodsProperties.splice(result, 1) // 从匹配数据中移除
-                return goodsProperty.value
-            }
-        }
-
-        if (propertyItem.property_name.includes('型号') && goods.cate_path.includes('3C数码配件')) {
-
-            return goods.goods_sn
-        }
-
-        if (propertyItem.property_name.includes('生产厂家') && goods.cate_path.includes('3C数码配件')) {
-            return '国内'
-        }
-
-        return ''
-    },
-
-    /**
-     * 匹配单选
-     * @param {Boolean} isTemplate 是否模板匹配，true时以模板属性为主
-     * */
-    matchSingleSelectProperty(isTemplate, propertyItem, goodsProperties) {
-
-
-        // 子属性 使用’condition_values‘，正常属性 使用’property_values‘
-        let property_values = propertyItem.show_condition.length ? propertyItem.condition_values : propertyItem.property_values
-
-        if (property_values.length == 1) {
-            // 只有一个选项, 直接选
-            return property_values[0]
-        }
-
-        // 模糊匹配
-        let index = goodsProperties.findIndex(item => item.attr_name.includes(propertyItem.property_name))
-        if (index != -1) {
-            let attr = goodsProperties[index]
-            let valueItem = this.matchSingleSelectPropertyValue(property_values, attr)
-            if (valueItem) {
-                goodsProperties.splice(i, 1)
-                return valueItem
-            }
-        }
-
-        // 使用相似度进行匹配
-        for (var i = 0; i < goodsProperties.length; i++) {
-
-            let attr = goodsProperties[i]
-            let result = utils.getStringSimilarity(propertyItem.property_name, attr.attr_name)
-
-            if (result >= 50) {
-                // 相似程度大于等50，进行匹配属性值
-
-                let valueItem = this.matchSingleSelectPropertyValue(property_values, attr)
-                if (valueItem) {
-                    goodsProperties.splice(i, 1)
-                    return valueItem
-                }
-            }
-        }
-
-        // 指定修改
-        if (['产地'].includes(propertyItem.property_name)) {
-            //
-            let valueItem = propertyItem.property_values.find(item => item.name.includes('中国'))
-            if (valueItem) {
-                return valueItem
-            }
-        }
-
-
-        return {}
-    },
-
-    /**
-     * 匹配单选值
-     * @param {Array} propertyValues 属性值可选列表
-     * @param {Object} goodsAttr 参考属性值
-     * */
-    matchSingleSelectPropertyValue(propertyValues, goodsAttr) {
-
-        if (!goodsAttr || !Object.keys(goodsAttr).length) {
-            // 参考值为空
-            return {}
-        }
-
-        let valueItem = propertyValues.find(item => item.name === goodsAttr.value)
-        if (valueItem) {
-            // 属性值全匹配正确
-            return valueItem
-        }
-
-        // 属性值全字符匹配失败，进行字符包含匹配
-        valueItem = propertyValues.find(item => item.name.includes(goodsAttr.value) || goodsAttr.value.includes(item.name))
-        if (valueItem) {
-            // 字符包含匹配正确
-            return valueItem
-        }
-
-        // 字符包含匹配失败，进行字符相似度匹配
-        let similarity = 0
-        propertyValues.forEach(item => {
-
-            let result = utils.getStringSimilarity(item.name, goodsAttr.value)
-            if (result >= 50 && result > similarity) {
-
-                // 相似度大于50, 并且比之前相似度大（取最大相似值）
-                similarity = result
-                valueItem = item
-            }
-        })
-        if (valueItem) {
-            // 相似度匹配大于50, 获取最相似的值)
-            return valueItem
-        }
-        return {}
-    },
-
-
-    /* 匹配多选 */
-    matchMultipleSelectProperty(propertyItem, goodsProperties) {
-
-        // 子属性 使用’condition_values‘，正常属性 使用’property_values‘
-        let property_values = propertyItem.show_condition.length ? propertyItem.condition_values : propertyItem.property_values
-
-
-
-        if (['面料分类','面料材质'].includes(propertyItem.property_name)) {
-            // 多选 面料材质
-            let index = goodsProperties.findIndex(item => ['面料分类','面料材质'].includes(item.attr_name))
-
-            if (index != -1) {
-                let attr = goodsProperties[index]
-                goodsProperties.splice(index, 1)
-
-                let value = []
-                if (attr.value instanceof Array) {
-                    // 数组（原商品属性多选），字符串数组
-                    attr.value.forEach(attrValue => {
-
-                        if (propertyItem.select_max_num > value.length) {
-                            // 未到限制多选数量，进行匹配
-                            let valueItem = property_values.find(valueItem => valueItem.name === attrValue)
-                            if (valueItem) {
-                                // 有匹配到属性值, 并且未到最大选中值
-                                valueItem.isSelect = true
-                                value.push(valueItem)
-                            }
-                        }
-                    })
-                } else {
-                    // 对象（原商品属性单选）
-                    if (propertyItem.select_max_num > value.length) {
-                        let valueItem = property_values.find(value => value.name === attr.value)
-                        if (valueItem) {
-                            // 有匹配到属性值, 并且未到最大选中值
-                            valueItem.isSelect = true
-                            value.push(valueItem)
-                        }
-                    }
-                }
-
-                return value
-            }
-            return []
-        }
-
-
-        return []
-    },
-
-
-    /* 匹配组合多选（’材质成分‘） */
-    matchMaterialQualityProperty(propertyItem, goodsProperties) {
-
-        // 子属性 使用’condition_values‘，正常属性 使用’property_values‘
-        let property_values = propertyItem.show_condition.length ? propertyItem.condition_values : propertyItem.property_values
-
-        let valueList = []
-
-        // console.log("匹配材质成分", propertyItem.property_name)
-        // console.log(JSON.stringify(goodsProperties))
-        // 模糊匹配
-        let index = goodsProperties.findIndex(item => item.attr_name.includes(propertyItem.property_name))
-        if (index != -1) {
-            let attr = goodsProperties[index]
-
-            let attrValue = []
-            console.log(attr.value, typeof attr.value)
-            if (typeof attr.value === 'string') {
-                // 字符串
-                attrValue = attr.value.split(',')
-            } else {
-                // 数组
-                attrValue = [...attr.value]
-            }
-
-            if (attrValue) {
-                attrValue.forEach(item => {
-                    if (item instanceof String) {
-                        let t = item.lastIndexOf('[')
-                        if (t != -1) {
-                            let attValue = item.slice(0, t)
-                            let attContent = item.slice(t + 1, item.length - 1).replace('%', '')
-
-                            let valueItem = property_values.find(item => item.name === attValue)
-                            if (valueItem) {
-                                // 属性值全匹配正确
-                                valueItem.content = Number(attContent) ? Number(attContent) : 0
-                                valueItem.isSelect = true
-                                valueList.push(valueItem)
-                            }
-                        }
-                    }
-
-                })
-            }
-        }
-
-
-        return valueList
-    },
-
-
-
-    /* 计算属性各项属性数量，与选择数量 */
-    calculateCategroyProperty(propertiesDatas) {
-
-        let requiredTotal = 0
-        let selectCount = 0
-        propertiesDatas.required_list.forEach(item => {
-
-            if (item.show) {
-                requiredTotal++
-
-                if (item.property_type == 1 && item.property_value) {
-                    // 文本
-                    selectCount++
-                } else if (item.property_type == 2 && item.property_value && Object.keys(item.property_value).length) {
-                    // 单选
-                    selectCount++
-                } else if (item.property_type == 3 && item.property_value.length) {
-                    // 多选
-                    selectCount++
-                } else if (item.property_type == 4 && item.property_value && item.property_unit) {
-                    // 规格输入
-                    selectCount++
-                } else if (item.property_type == 5 && item.property_value) {
-                    // 日期选择
-                    selectCount++
-                } else if (item.property_type == 6 && item.property_value.length) {
-                    // 组合多选
-                    selectCount++
-                }
-            }
-        })
-
-        propertiesDatas.require_total = requiredTotal
-        propertiesDatas.require_count = selectCount
-    },
-
-
-    /* 获取子属性 */
-    getChildrenProperty(list, parentItem, children_list) {
-
-        let index = children_list.length - 1
-        while (index >= 0){
-            let childrenItem = children_list[index]
-
-            let result = childrenItem.show_condition.findIndex(conditionItem => conditionItem.parent_property_id == parentItem.property_id)
-            if (result != -1) {
-                // 当前子属性，为当前属性的子属性
-
-                if (childrenItem.show_condition.length == 1) {
-                    // 子属性只有一个显示条件，直接添加
-                    children_list.splice(index, 1) // 移除属性列表
-
-                    childrenItem.property_required = parentItem.property_required // 子属性设置为必须项
-                    list.push(childrenItem)
-                    if (childrenItem.has_children) {
-                        // 需要重新调用赋值，打破当前循序重新开始遍历子属性
-                        this.getChildrenProperty(list, childrenItem, children_list)
-                        break
-                    }
-
-                } else {
-                    // 子属性有多个显示条件
-                    childrenItem.property_required = parentItem.property_required // 先设置子属性为必填项，后续非必填筛选完成后，分别添加到列表最后面
-                }
-            }
-            index--
-        }
-
-    },
-
-}

package/src/utils/utils.js

@@ -1,111 +0,0 @@
-export default {
-
-    /**
-     * 获取2个字符串的相似度
-     * @param {string} str1 字符串1
-     * @param {string} str2 字符串2
-     * @returns {number} 相似度
-     */
-    getStringSimilarity(str1, str2) {
-        let sameNum = 0
-        //寻找相同字符
-        for (let i = 0; i < str1.length; i++) {
-            for(let j =0;j<str2.length;j++){
-                if(str1[i]===str2[j]){
-                    sameNum ++
-                    break
-                }
-            }
-        }
-        //判断2个字符串哪个长度比较长
-        let length = str1.length > str2.length ? str1.length : str2.length
-        return (sameNum/length) * 100 || 0
-    },
-
-
-    /* 调用计算公式 */
-    evil(str) {
-        var fn = Function
-        return new fn('return ' + str)()
-    },
-
-
-    /* 检测值，true: 正常，false: 未选 */
-    checkValue(value) {
-
-        try {
-
-            if (!value) {
-                return false
-            }
-
-            if (value === '' || value === null || value === undefined) {
-                return false
-            }
-
-            if (value instanceof Array) {
-                return value.length > 0
-            }
-
-            if (value instanceof Object) {
-                return Object.keys(value).length > 0
-            }
-
-            // 其他情况
-            return true
-
-        } catch (error) {
-            //TODO handle the exception
-            console.log(error)
-            return false
-        }
-
-    },
-
-
-
-    /**
-     * 判断字符串中是否包含某些字符
-     *
-     * @param {String} text 检测字符串
-     * @param {Array} arr 检测内容字符串数组
-     * @param {string} type 检测方式，includeOne：包含一个，includeAll：包含全部，默认为 includeOne
-     * */
-    isTextInclude(text, arr, type = 'includeOne') {
-        if (Object.prototype.toString.call(text) !== '[object String]') throw new Error('text 参数错误有误，只能是String类型')
-        if (Object.prototype.toString.call(arr) !== '[object Array]') throw new Error('arr 参数错误有误，只能是Array类型')
-        if (type === 'includeOne') {
-            return arr.some(i => text.indexOf(i) > -1)
-        } else if (type === 'includeAll') {
-            return arr.filter(i => text.indexOf(i) > -1).length === arr.length
-        } else {
-            throw new Error('type 参数错误有误，只能是includeOne或includeAll')
-        }
-    },
-
-
-
-    /**
-     * 获取文本长度
-     *
-     * @param {String} text 待检查的字符串
-     * @param {Number} max 当text不是字符时返回的数字
-     * */
-    getTextLength(text, max = 0) {
-        if (Object.prototype.toString.call(text) === '[object String]') {
-            let length = 0
-            for (let i = 0; i < text.length; i++) {
-                if (text.charAt(i).match(/[^\x00-\xff]/gi) != null) {
-                    length += 2
-                } else {
-                    length += 1
-                }
-            }
-            return length
-        } else if (max === undefined) {
-            throw new Error('getTextLength 参数必须为字符串')
-        }
-        return max
-    }
-
-}