ftdsy-attr 1.0.0

package/src/main.js

@@ -0,0 +1,590 @@
+
+import { checkPlatform } from "./config/platform.js";
+import utils from "./utils/utils.js";
+
+import pdd from "./platform/pdd.js";
+import tb from "./platform/tb.js";
+import dy from "./platform/dy.js";
+
+import propertyTools from "./tools/property.js";
+
+export default {
+    createCategoryProperties
+}
+
+/*
+* 匹配属性值
+* @param {String} pt_type 平台编码（生成平台编码）
+* @param {Array} pt_attrs 平台属性列表（生成平台属性）
+* @param {Array} orgrin_attrs 匹配来源属性列表（来源属性，用于生成平台属性属性值匹配）
+* */
+function createCategoryProperties(cate, pt_type, pt_attrs, orgrin_attrs=[], goods={}) {
+
+    return new Promise((resolve, reject) => {
+        try {
+
+
+            // console.log("待处理属性列表", pt_attrs)
+            // console.log("来源属性", orgrin_attrs)
+
+            // 获取平台，检测平台是否正确
+            let platform = checkPlatform(pt_type)?.code || ''
+            console.log("开始进行匹配", JSON.stringify(cate), platform)
+
+            let properties = []
+
+            switch (platform) {
+                case 'pdd':
+                    // 拼多多
+                    properties = pdd.createCategoryProperties(pt_attrs)
+                    break;
+                case 'tb':
+                    // 淘宝
+                    properties = tb.createCategoryProperties(pt_attrs)
+                    break;
+                case 'tm':
+                    // 天猫
+                    break;
+                case 'jd':
+                    // 京东
+                    break;
+                case 'dy':
+                    // 抖音
+                    properties = dy.createCategoryProperties(pt_attrs)
+                    break;
+                case 'xp':
+                    // 虾皮
+                    break;
+                case 'xhs':
+                    // 小红书
+                    break;
+                case 'ks':
+                    // 快手
+                    break;
+                case 'dsy':
+                    // 电商园
+                    break;
+                case '1688':
+                    // 1688
+                    break;
+                case 'sph':
+                    // 微信小店
+                    break;
+                case 'tk':
+                    // Tiktio
+                    break;
+                default:
+                    // 其他类型，报错
+                    reject({
+                        msg: '检测不到类目来源平台！',
+                        code: -1,
+                        type: 'pt_type参数错误'
+                    })
+                    break;
+            }
+
+            console.log("待处理属性列表（转换后）",properties)
+
+            // 获取转换来源数据
+            let attrs = checkOriginAttrs(orgrin_attrs, goods)
+            console.log("来源属性（转换后）", attrs)
+
+            let propertiesDatas = matchCategroyProperties(properties, attrs)
+
+            console.log("匹配结果", JSON.stringify(propertiesDatas))
+
+            resolve ({
+                msg: '成功',
+                data: propertiesDatas,
+                code: 1,
+            })
+
+        } catch (err) {
+            console.log(err)
+            reject({
+                msg: err.message,
+                code: -10000,
+                type: '系统报错'
+            })
+        }
+    })
+}
+
+/*
+* 检测并装换来源参数
+*  */
+function checkOriginAttrs(orgrin_attrs, goods) {
+
+    var attrs = orgrin_attrs.map(item => {
+
+        if (item?.property_id !== undefined && item?.property_value !== undefined && item.property_type !== undefined) {
+            // 当前属性为自定义属性
+            var attrItem = {
+                id: item.property_id,
+                attr_name: item.property_name,
+                value_id: '',
+                value: '',
+            }
+
+            let property_type = item?.property_type || 0
+
+            if (property_type == 1 || property_type == 5) {
+                // 纯文本、日期选择
+                attrItem.value = item?.property_value || ''
+            } else if (property_type == 2) {
+                // 单选
+                attrItem.value = item?.property_value.name || ''
+                attrItem.value_id = item?.property_value.value_id || ''
+            } else if (property_type == 3) {
+                // 多选
+                let valueList = item?.property_value || []
+                if (valueList.length) {
+                    attrItem.value = valueList.map(item => item.name)
+                    attrItem.value_id = valueList.map(item => item.value_id)
+                }
+            } else if (property_type == 4) {
+                // 输入 + 规格
+                if (item?.property_value) {
+                    // 有输入值
+                    attrItem.value = item?.property_value || '' + item?.property_unit || ''
+                }
+
+            } else if (property_type == 6) {
+                // 组合多选（'面料材质'）
+            } else if (property_type == 7) {
+                // 分级选择
+                attrItem.value = item?.property_value?.parent_id ? item?.property_value?.parent_name || '' + ' - ' + item?.property_value?.name || '' : item?.property_value?.name || ''
+                attrItem.value_id = item?.property_value?.value_id
+            } else if (property_type == 8) {
+                // 范围输入
+                attrItem.value = item?.property_value || '' + item?.property_unit || ''
+            }
+
+            return attrItem
+        }
+
+        return {
+            id: item?.id || '',
+            attr_name: item?.attr_name,
+            value_id: item?.value_id || '',
+            value: item?.value || '',
+        }
+    }).filter(item => item.value)
+
+    if (goods?.goodsSn) {
+        // 有货号数据
+        let result = attrs.find(item => item.attr_name.includes('货号'))
+        if (result) {
+            // 有货号的属性
+            if (!result?.value) {
+                // 货号没有值
+                result.value = goods.goodsSn
+            }
+        } else {
+            // 没有货号属性，添加货号属性
+            attrs.push({
+                id: '',
+                attr_name: '货号',
+                value_id: '',
+                value: goods.goodsSn,
+            })
+        }
+    }
+
+    if (goods?.ccc_code) {
+        // 商品有3c编码
+        let result = attrs.find(item => item.attr_name.includes('CCC') || item.attr_name.includes('3C'))
+        if (result) {
+            // 有货号的属性
+            if (!result?.value) {
+                // 货号没有值
+                result.value = goods.ccc_code
+            }
+        } else {
+            // 没有货号属性，添加货号属性
+            attrs.push({
+                id: '',
+                attr_name: '3C证书',
+                value_id: '',
+                value: goods.ccc_code,
+            })
+        }
+    }
+
+    return attrs
+
+}
+
+
+function matchCategroyProperties(properties, attrs) {
+
+    let goodsPropertys = [].concat(attrs || [])
+
+    let propertiesDatas = {
+        list: [], // 正常属性列表（不包含‘品牌’属性 以及 子属性）
+
+        require_total: 0,	// 必填属性总数
+        require_count: 0, 	// 必填属性已填数
+        required_list: [], 	// 必填属性列表
+        other_list: [], 	// 非必填属性列表
+        children_list: []	,// 子属性列表
+
+        brand_property: {}, // '品牌'属性
+        material_quality_property: {}, // ‘材料成分’属性
+    }
+
+    // 第一步，先进行筛选，分出“品牌”属性，必填属性，非必填属性，子属性， 其中‘材料成分’属性外部登记（方便后期进行检测）
+    properties.forEach(item => {
+
+        if (item.property_name === '品牌') {
+            // 品牌，跳过
+            propertiesDatas.brand_property = item
+
+        } else if (item.show_condition.length) {
+            // 子属性，有显示条件
+            item.show = false
+            propertiesDatas.children_list.push(item)
+
+            // 子属性初始化
+            if (item.property_type == 1 || item.property_type == 4 || item.property_type == 5 || item.property_type == 7 || item.property_type == 8) {
+                // 纯文本，数字，日期
+                item.property_value = ''
+            } else if (item.property_type == 2) {
+                // 单选
+                item.property_value = {}
+            } else if (item.property_type == 3) {
+                // 多选
+                item.property_value = []
+            }
+
+        } else {
+            // 固定属性，区分必填项，与 非必填项
+            item.show = true
+            if (item.property_required) {
+                // 必填
+                propertiesDatas.required_list.push(item)
+            } else {
+                // 非必填
+                propertiesDatas.other_list.push(item)
+            }
+
+            switch (item.property_type) {
+                case 1: // 纯文本
+                {
+                    item.property_value = propertyTools.matchInputProperty(item, goodsPropertys)
+                    // let index = goodsPropertys.findIndex(attr => attr.attr_name === item.property_name)
+                    // if (index != -1) {
+                    // 	// 匹配到，直接赋值
+                    // 	let attr = goodsPropertys[index]
+                    // 	// 移除商品属性列表（减少后期匹配循环次数）,目前不可能属性列表存在相同的属性名称
+                    // 	goodsPropertys.splice(index, 1)
+                    // 	item.property_value = attr.value
+                    // } else {
+                    // 	// 没有匹配到，默认为空字符
+                    // 	item.property_value = ''
+                    // }
+                    // 输入文本数量
+                    item.input_num = utils.getTextLength(item.property_value)
+                }
+                    break;
+                case 2: // 单选类型 (根据可以选择的选项多少判断)
+                {
+                    // 搜索关键词
+                    item.search_key = ''
+
+                    if (item.property_name === '货号') {
+                        // 货号（快手’货号‘属性为单选）
+
+                        let property_value = item.property_values.find(property_value => property_value.name === goods.goods_sn)
+                        if (!property_value) {
+                            // 原数据没有当前货号的选项，新增一个
+                            property_value = {
+                                name: goods.goods_sn,
+                                value_id: 0,
+                                value: 0,
+                                parent_value: []
+                            }
+                            item.property_values.unshift(property_value)
+                        }
+                        item.property_value = property_value
+                    } else {
+                        // 其他
+
+                        let index = goodsPropertys.findIndex(attr => attr.attr_name === item.property_name)
+                        if (index != -1) {
+                            // 匹配到了
+                            let attr = goodsPropertys[index]
+                            // 移除商品属性列表（减少后期匹配循环次数）,目前不可能属性列表存在相同的属性名称
+                            goodsPropertys.splice(index, 1)
+
+                            let property_values = item.show_condition.length ? item.condition_values : item.property_values
+                            item.property_value = propertyTools.matchSingleSelectPropertyValue(property_values, attr)
+
+                        } else {
+                            // 未匹配到，默认为空对象
+                            item.property_value = {}
+                        }
+                    }
+                }
+                    break;
+                case 3: // 多选类型
+                {
+                    // 搜索关键词
+                    item.search_key = ''
+
+                    let index = goodsPropertys.findIndex(attr => attr.attr_name === item.property_name)
+                    if (index != -1) {
+                        // 匹配到了
+                        let attr = goodsPropertys[index]
+                        // 移除商品属性列表（减少后期匹配循环次数）,目前不可能属性列表存在相同的属性名称
+                        goodsPropertys.splice(index, 1)
+
+                        let value = []
+                        if (attr) {
+                            // 商品有该属性，进行匹配
+                            if (attr.value instanceof Array) {
+                                // 数组（原商品属性多选），字符串数组
+                                attr.value.forEach(attrValue => {
+
+                                    if (item.select_max_num > value.length) {
+                                        // 未到限制多选数量，进行匹配
+                                        let valueItem = item.property_values.find(valueItem => valueItem.name === attrValue)
+                                        if (valueItem) {
+                                            // 有匹配到属性值, 并且未到最大选中值
+                                            valueItem.isSelect = true
+                                            value.push(valueItem)
+                                        }
+                                    }
+                                })
+                            } else {
+                                // 对象（原商品属性单选）
+                                if (item.select_max_num > value.length) {
+                                    let valueItem = item.property_values.find(value => value.name === attr.value)
+                                    if (valueItem) {
+                                        // 有匹配到属性值, 并且未到最大选中值
+                                        valueItem.isSelect = true
+                                        value.push(valueItem)
+                                    }
+                                }
+                            }
+                        }
+                        item.property_value = value ? value : []
+                    } else {
+                        // 匹配不到
+                        item.property_value = []
+                    }
+
+                    if (item.select_max_num) {
+                        // 有限制选择个数
+                        item.property_tips = `限最多选${item.select_max_num}个`
+                    }
+                }
+                    break;
+                case 4: // 输入，带单位
+                {
+                    item.property_value = ''
+                }
+                    break;
+                case 5: // 日期
+                {
+                    item.property_value = ''
+                    item.property_tips = ''
+                }
+                    break;
+                case 6: // 组合多选，目前仅’材质成分‘
+                {
+                    // 外部登记出来，方便进行检测
+                    propertiesDatas.material_quality_property = item
+                    if (item.select_max_num) {
+                        // 有限制选择个数
+                        item.property_tips = `限最多选${item.select_max_num}个, 且需填写每项【材质】的含量，填写完成后材质成分占比总和必须为100%`
+                    }
+
+                }
+                    break;
+                case 7: // 日期
+                {
+                    item.property_value = {}
+                    item.property_tips = ''
+                }
+                    break;
+                case 8: // 范围输入，带单位
+                {
+                    item.property_value = ''
+                }
+                    break;
+                default:
+                {
+                    item.property_type = 0
+                    item.property_value = ''
+                }
+                    break;
+            }
+        }
+    })
+
+    // 第二步，进行数据重组排序，必填属性 与 非必填属性 加入子属性
+    if (propertiesDatas.children_list.length) {
+        // 有子属性, 需要将子属性添加到对应的属性下，子属性多条件显示，添加到列表最后
+        // console.log("============= 当前分类存在子分类，需要进行处理 =============")
+        let required_list = []
+        let other_list = []
+        let children_list = [...propertiesDatas.children_list].sort((a, b) => { return b.has_children}) // 排序有子属性的排前
+
+        propertiesDatas.required_list.forEach(item => {
+            // 加入新列表
+            required_list.push(item)
+            if (item.has_children) {
+                // 有子分类，将子分类添加进列表来
+                propertyTools.getChildrenProperty(required_list, item, children_list)
+            }
+        })
+
+        propertiesDatas.other_list.forEach(item => {
+            // 加入临时 非必填属性列表
+            other_list.push(item)
+            if (item.has_children) {
+                // 有子分类，将子分类添加进列表来
+                propertyTools.getChildrenProperty(other_list, item, children_list)
+            }
+        })
+
+        // 开始合并成新的完整属性列表
+        children_list.forEach(item => {
+
+            if (item.property_required) {
+                required_list.push(item)
+            } else {
+                other_list.push(item)
+            }
+        })
+
+        propertiesDatas.required_list = required_list
+        propertiesDatas.other_list = other_list
+
+        // console.log("排序完 必选项", JSON.stringify(required_list))
+        // console.log('排序完 非必填项', JSON.stringify(other_list))
+    }
+
+    // 第三步，合成完整的列表
+    propertiesDatas.list = [...propertiesDatas.required_list, ...propertiesDatas.other_list]
+
+    // 第四步，进行属性值匹配填写（必填项，非必填项，子项）
+    propertiesDatas.list.forEach(item => {
+
+        switch (item.property_type){
+            case 1: // 文本
+            {
+                if (!item.property_value) {
+                    // 没有选项，进行模糊匹配
+                    item.property_value = propertyTools.matchInputProperty(item, goodsPropertys)
+                }
+                if (item.property_required && item.property_value) {
+                    // 必填 且 有选中项，
+                    propertiesDatas.require_count++
+                }
+            }
+                break;
+            case 2: // 单选
+            {
+                if (!item.property_value || !Object.keys(item.property_value).length) {
+                    // 没有选项，进行匹配
+                    item.property_value = propertyTools.matchSingleSelectProperty(false ,item, goodsPropertys)
+                }
+                if (item.property_required && Object.keys(item.property_value).length) {
+                    // 必填 且 有选中项，
+                    propertiesDatas.require_count++
+                }
+            }
+                break;
+            case 3:	// 多选
+            {
+
+                if (!item.property_value || !item.property_value.length) {
+                    // 没有选项，进行匹配
+                    item.property_value = propertyTools.matchMultipleSelectProperty(item, goodsPropertys)
+                }
+                if (item.property_required && item.property_value.length) {
+                    // 必填 且 有选中项，
+                    propertiesDatas.require_count++
+                }
+            }
+                break;
+            case 4: // 输入，带单位
+            {
+
+                // if (!item.property_value) {
+                // 	// 没有选项，进行匹配
+                // 	item.property_value = propertyTools.matchMultipleSelectProperty(item, goodsPropertys)
+                // }
+                if (item.property_required && item.property_value) {
+                    // 必填 且 有选中项，
+                    propertiesDatas.require_count++
+                }
+            }
+                break;
+            case 5: // 日期
+            {
+                if (item.property_required && item.property_value) {
+                    // 必填 且 有选中项，
+                    propertiesDatas.require_count++
+                }
+            }
+                break;
+            case 6: // 组合多选 ('材质成分')
+            {
+                if (!item.property_value || !item.property_value.length) {
+                    // 没有选项，进行匹配
+                    item.property_value = propertyTools.matchMaterialQualityProperty(item, goodsPropertys)
+                }
+
+                // item.property_value = []
+
+                if (item.property_required && item.property_value.length) {
+                    // 必填 且 有选中项，
+                    propertiesDatas.require_count++
+                }
+            }
+                break;
+            default:
+                break;
+        }
+
+        if (item.has_children) {
+            // 当前属性有子属性，判断起是否显示
+
+            propertiesDatas.children_list.forEach(childrenItem => {
+                let isShow = true
+
+                if (childrenItem.show_condition.length) {
+                    // 子属性 遍历显示条件
+                    let result = childrenItem.show_condition.find(conditionItem => item.property_id === conditionItem.parent_property_id)
+                    if (result) {
+                        // 查询到为当前属性的子属性
+                        if (!Object.keys(item.property_value).length) {
+                            // 当前属性没有属性值，子属性不显示
+                            isShow = false
+                        } else {
+                            // 当前属性有选择属性值
+                            if (result.parent_property_value.includes(item.property_value.value_id)) {
+                                // 当前子属性需显示，根据父属性选项，筛选子属性可使用的属性
+                                childrenItem.condition_values = childrenItem.property_values.filter(valueItem => !valueItem.parent_value || !valueItem.parent_value.length || (valueItem.parent_value.length && valueItem.parent_value.includes(item.property_value.value_id)))
+                            } else {
+                                // 当前子属性不需要显示
+                                isShow = false
+                            }
+                        }
+                        childrenItem.show = isShow
+                    }
+                }
+            })
+        }
+    })
+
+    // 第五步，计算必填项数量
+    propertyTools.calculateCategroyProperty(propertiesDatas)
+
+    return propertiesDatas
+
+}
+