ftdsy-attr 1.0.0

package/src/tools/property.js

@@ -0,0 +1,351 @@
+
+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

@@ -0,0 +1,111 @@
+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
+    }
+
+}