/**
 * 商品详情models
 * @author: xuqi<qi.xu@yoho.cn>
 * @date: 2016/5/6
 */

'use strict';

const library = '../../../library';
const API = require(`${library}/api`).API;
const sign = require(`${library}/sign`);
const _ = require('lodash');
const helpers = require(`${library}/helpers`);

var api = new API();

/**
 * 处理品牌关联店铺信息
 * @param  {array}
 * @return {array}
 */
const getShopsInfo = (data) => {
    var enterStore = {};

    _.forEach(data, function(value, key) {
        enterStore[key] = {};
        enterStore[key].img = value.brand_ico;
        enterStore[key].storeName = value.brand_name;

        if (value.shop_id !== null && typeof value.shop_id !== 'undefined') {
            let params = {};

            params.shop_id = value.shop_id;
            enterStore[key].url =
                helpers.url('/product/index/brand', params);
        } else {
            enterStore[key].url =
                helpers.url('', null, value.brand_domain);
        }
    });
    return enterStore;
};

/**
 * 处理限购商品的有关按钮状态（或取现购买以及底部商品购买按钮）
 * @param  {array} 需要处理的数据
 * @param  {int} 限购商品的关联状态
 * @param  {Boolean} 限购商品是否已开售
 * @return {array}
 */
const procShowStatus = (data, showStatus, isBeginSale) => {
    switch (showStatus) {
        case 1:// 开售前/后，立即分享获得限购码（用户未领取限购码）
            // 显示获取限购码按钮
            data.canGetLimitCode = true;

            if (isBeginSale) { // 开售后
                data.cartInfo.noLimitCode = true;
            } else {
                data.cartInfo.limitNotForSale = true;
            }
            break;
        case 2: // 开售后，限购码已抢光（用户未领取限购码）
            data.codeEmpty = true;
            data.cartInfo.noLimitCode = true;
            break;
        case 3: // 开售后，商品已经售罄
            data.noLimitGoodsBtn = true;
            data.cartInfo.soldOut = true;
            break;
        case 4: // 开售后，立即购买（用户已领取限购码）
            data.gotCode = true;
            data.cartInfo.canBuyLimit = true;
            break;
        case 5: // 开售前，限购码已被抢光（用户未领取限购码）
            data.codeEmpty = true;
            data.cartInfo.limitNotForSale = true;
            break;
        case 6: // 开售前，即将开售（用户已领取限购码）
            data.gotCode = true;
            data.cartInfo.limitNotForSale = true;
            break;
        case 7: // 开售后，用户已经用获得的限购码购买过商品
            data.gotCode = true;
            data.cartInfo.noLimitCode = true;
            break;
        default:
            break;
    }

    return data;
};

/**
 * 根据设备类型获得限购商品跳转app的url 待处理
 * @param  {[string]} productCode 限购商品码
 * @param  {[string]} skn 限购商品skn
 * @return {[string]} 限购商品跳转url
 */
const getLimitCodeUrl = (productCode, skn, ua) => {
    var url = 'yohoapp://yoho.app/openwith?limit_product_code=' + productCode +
        '&product_skn=' + skn;

    let isIphone = String(ua).indexOf('iPhone') >= 0;
    let isIpad = ua.indexOf('iPad') >= 0;

    if (isIphone || isIpad) {
        let params = {};

        params.lp = productCode;
        url = 'yohobuy://' + helpers.url('/limitpurchase', params);
    }
    return url;
};

/**
 * 详情页数据格式化
 * @param origin Object 原始数据
 * @return dest Object 格式化数据
 */
const detailDataPkg = (origin, uid, vipLevel, ua) => {
    var dest = {}, // 结果输出
        colorGroup = {},
        thumbImageList = {},
        sizeGroup = {},
        totalStorageNum = 0;

    // 商品名称
    if (origin.productName === null || typeof origin.productName === 'undefined') {
        return dest;
    }

    dest.goodsName = origin.productName;

    // 用户未登录时 待处理
    if (uid === null || typeof uid === 'undefined') {
        let params = {};

        params.refer = helpers.url('/product/show_' + origin.erpProductId + '.html');
        dest.loginUrl = helpers.url('/signin.html', params);
    }

    // 商品促销短语
    if (origin.salesPhrase !== null && typeof origin.salesPhrase !== 'undefined') {
        dest.goodsSubtitle = origin.salesPhrase;
    }

    // 商品标签
    if (origin.productTagBoList !== null && typeof origin.productTagBoList !== 'undefined') {
        _.forEach(origin.productTagBoList, function(value) {
            switch (value.tagLabel) {
                case 'is_soon_sold_out':
                    dest.tags.is_soon_sold_out = true;
                    break;
                case 'is_new':
                    dest.tags.is_new = true;
                    break;
                case 'is_discount':
                    dest.tags.is_discount = true;
                    break;
                case 'is_limited':
                    dest.tags.is_limited = true;
                    break;
                case 'is_yohood':
                    dest.tags.is_yohood = true;
                    break;
                case 'is_advance':
                    dest.tags.is_advance = true;
                    break;
                default:
                    break;
            }
        });
    }

    // 商品价格
    dest.goodsPrice = {};

    if (origin.productPriceBo !== null && typeof origin.productPriceBo !== 'undefined') {
        dest.goodsPrice.currentPrice = origin.productPriceBo.formatSalesPrice;
        if (origin.productPriceBo.formatMarketPrice !== origin.productPriceBo.formatSalesPrice) {
            dest.goodsPrice.previousPrice = origin.productPriceBo.formatMarketPrice;
        }

        // 商品返回 YOHO 币
        if (origin.productPriceBo.yohoCoinNum !== null && origin.productPriceBo.yohoCoinNum !== 0) {
            dest.commodityReturn = dest.productPriceBo.yohoCoinNum;
        }
    }

    // VIP 商品价格
    dest.vipLevel = {};
    dest.vipLevel.list = {};

    if (origin.productPriceBo.vipPrices !== null && typeof origin.productPriceBo.vipPrices !== 'undefined') {
        _.forEach(origin.productPriceBo.vipPrices, function(value, key) {
            dest.vipLevel.list[key] = {};
            dest.vipLevel.list[key].level = value.vipLevel;
            dest.vipLevel.list[key].text = value.vipPrice;
            dest.vipLevel.list[key].currentLevel = (value.vipLevel === vipLevel) ? true : false;
        });
    }

    // 上市期
    if (origin.expectArrivalTime !== null && typeof origin.expectArrivalTime !== 'undefined') {
        dest.periodOfMarket = origin.expectArrivalTime + '月';
    }

    // 促销信息
    dest.goodsDiscount = {};
    dest.goodsDiscount.list = [];

    if (origin.promotionBoList !== null && typeof origin.promotionBoList !== 'undefined') {
        _.forEach(origin.promotionBoList, function(value) {
            let temp = {};

            temp.text = '【' + value.promotionType + '】' +
                value.promotionTitle;
            dest.goodsDiscount.list.push(temp);
        });
    }

    // 商品咨询
    dest.feedbacks = {};
    dest.feedbacks.consults = {};
    dest.feedbacks.consultsNum = 0;

    if (origin.consultBoWrapper !== null && typeof origin.consultBoWrapper !== 'undefined') {
        dest.feedbacks.consultsNum = origin.consultBoWrapper.consultTotal;
        _.forEach(origin.consultBoWrapper.consultBoList, function(value, key) {
            dest.feedbacks.consults[key] = {};
            dest.feedbacks.consults[key].question = value.ask;
            dest.feedbacks.consults[key].time = value.askTime;
            dest.feedbacks.consults[key].answer = value.answer;
        });

        let params = {};

        params.product_id = origin.id;
        params.total = dest.feedbacks.consultsNum;

        dest.feedbacks.consultsUrl = helpers.url('/product/detail/consults', params);

    } else { // 暂无咨询

        let params = {};

        params.product_id = origin.id;

        dest.feedbacks.consultsUrl = helpers.url('/product/detail/consultform', params);
    }

    // 商品评价
    dest.feedbacks.commentsNum = 0;
    if (origin.commentBoWrapper !== null && typeof origin.commentBoWrapper !== 'undefined') {
        dest.feedbacks.commentsNum = origin.commentBoWrapper.commentTotal;
        dest.feedbacks.comments = {};

        _.forEach(origin.commentBoWrapper.commentBoList, function(value, key) {
            dest.feedbacks.comments[key] = {};
            dest.feedbacks.comments[key].userName = value.nickName;
            dest.feedbacks.comments[key].desc = value.colorName +
                '/' + value.sizeName;
            dest.feedbacks.comments[key].content = (value.content !== null &&
                typeof value.content !== 'undefined') ? value.content : '';
            dest.feedbacks.comments[key].time = value.createTime;
        });

        let params = {};

        params.product_id = origin.id;
        params.total = dest.feedbacks.commentsNum;

        dest.feedbacks.commentsUrl = helpers.url('/product/detail/comments', params);
    }

    // 品牌信息
    if (origin.brand !== null && typeof origin.brand !== 'undefined') {

        // 为你优选的链接
        let params = {};

        params.productSkn = origin.erpProductId;
        params.brandId = origin.brand.id;
        dest.preferenceUrl = helpers.url('/product/detail/preference', params, '');
    }

    dest.productSkn = origin.erpProductId;

    // 商品信息
    if (origin.goodsList !== null && typeof origin.goodsList !== 'undefined') {
        let goodsGroup = {},
            sizeName = '',
            colorList = {},
            sizeList = {},
            allSizeList = {},
            colorStorageGroup = {},
            colorStorageNum = 0;

        _.forEach(origin.goodsList, function(value, key) {
            if (value.status === 0) {
                return true;
            }

            colorStorageNum = 0;

            // 商品分组
            if (value.goodsImagesList !== null && typeof value.goodsImagesList !== 'undefined') {
                _.forEach(value.goodsImagesList, function(good, keyForGood) {
                    goodsGroup[keyForGood] = {};
                    goodsGroup[keyForGood].goodsId = good.goodsId;
                    goodsGroup[keyForGood].img = good.imageUrl;
                });
            }

            // 商品的尺码列表
            colorStorageGroup[value.productSkc] = {};
            if (value.goodsSizeBoList !== null && typeof value.goodsSizeBoList !== 'undefined') {

                _.forEach(value.goodsSizeBoList, function(size, keyForSize) {
                    sizeList[value.productSkc] = {};
                    sizeList[value.productSkc][keyForSize] = {};
                    sizeList[value.productSkc][keyForSize].id = size.id;
                    sizeList[value.productSkc][keyForSize].skuId = size.goodsSizeSkuId;
                    sizeList[value.productSkc][keyForSize].goodsId = size.goodsId;
                    sizeList[value.productSkc][keyForSize].colorId = size.colorId;
                    sizeList[value.productSkc][keyForSize].name = size.sizeName;
                    sizeList[value.productSkc][keyForSize].sizeNum = size.goodsSizeStorageNum;

                    sizeName = size.sizeName;

                    // 所有尺码列表，赋值用于前端展示默认尺码的时候
                    // 判断出没有库存则显示灰色
                    let build = {};

                    build.storage = size.goodsSizeStorageNum;
                    build.id = size.id;
                    allSizeList[sizeName] = (allSizeList[sizeName] === null ||
                        typeof allSizeList[sizeName] === 'undefined') ? build :
                        allSizeList[sizeName];

                    colorStorageNum += parseInt(size.goodsSizeStorageNum, 10);
                    colorStorageGroup[value.productSkc][sizeName] = parseInt(size.goodsSizeStorageNum, 10);
                });

                // 颜色分组
                colorList[key] = {};
                colorList[key].id = value.colorId;
                colorList[key].skcId = value.productSkc;
                colorList[key].name = value.colorName;
                colorList[key].goodsName = value.goodsName;
                colorList[key].colorNum = colorStorageNum;
            }

            // 缩略图
            let params = {};

            params.img = value.colorImage;
            thumbImageList[key] = params;

            // 商品库存总数
            totalStorageNum += colorStorageNum;
        });

        // 遍历所有尺码，构建颜色显示数据
        let i = 1;

        _.forEach(allSizeList, function(value, key) {

            // 默认尺码
            sizeGroup[0] = {};

            sizeGroup[0].size = {};
            sizeGroup[0].size[key] = {};
            sizeGroup[0].size[key].name = sizeName;
            sizeGroup[0].size[key].sizeNum = (typeof value.storage === 'undefined' ||
                value.storage === null) ? false : true;
            sizeGroup[0].size[key].id = value.id;

            // 各个颜色的尺码, 每行显示一个尺码对应的颜色
            _.forEach(colorList, function(colorArr, keyForColorArr) {
                colorGroup[i] = {};
                colorGroup[i].color = {};
                colorGroup[i].color[keyForColorArr] = {};
                colorGroup[i].color[keyForColorArr].colorNum =
                (colorStorageGroup[colorArr.skcId][sizeName] !== null &&
                typeof colorStorageGroup[colorArr.skcId][sizeName] !== 'undefined') ?
                colorStorageGroup[colorArr.skcId][sizeName] : 0;
            });
            colorGroup[i].id = value.id;

            ++i;
        });

        // 遍历所有颜色, 构建尺码显示数据

        i = 1;
        _.forEach(colorList, function(value, key) {
            // 各个尺码的颜色， 每行显示一个颜色的对应尺码
            sizeGroup[i] = {};
            sizeGroup[i].size = sizeList[value.skcId];
            sizeGroup[i].colorId = value.skcId;

            // 默认颜色
            colorGroup[0] = {};
            colorGroup[0].color = {};
            colorGroup[0].color[key] = value;

            ++i;
        });

        // 商品图：多个
        if (goodsGroup[1] !== null && typeof goodsGroup[1] !== 'undefined') {
            _.forEach(goodsGroup, function(value, key) {
                dest.bannerTop = {};

                dest.bannerTop.list = {};
                let params = {};

                params.img = value.img;
                dest.bannerTop.list[key] = params;
            });
        } else if (goodsGroup[0] !== null && typeof goodsGroup[0] !== 'undefined') {
            dest.bannerTop = {};
            dest.bannerTop.img = goodsGroup[0].img;
        }
    }

    // 悬浮的购物车信息
    dest.cartInfo = {};
    dest.cartInfo.cartUrl = helpers.url('/cart/index/index', null);
    dest.cartInfo.numInCart = 0;
    dest.cartInfo.goodsInstore = origin.storage;

    let soldOut = (origin.storage === 0) || (origin.status === 0 || totalStorageNum === 0);
    let notForSale = origin.attribute === 2;

    // 显示加入购物车链接
    if (!soldOut && !notForSale) {
        _.orderBy(colorGroup);

        dest.cartInfo = {};
        dest.cartInfo.productId = origin.id;
        dest.cartInfo.thumbs = thumbImageList;
        dest.cartInfo.name = (dest.goodsName !== null && typeof dest.goodsName !== 'undefined') ? dest.goodsName : '';
        dest.cartInfo.price = (dest.goodsPrice.previousPrice !== null &&
            typeof dest.goodsPrice.previousPrice !== 'undefined') ? dest.goodsPrice.previousPrice : '';
        dest.cartInfo.salePrice = (dest.goodsPrice.currentPrice !== null &&
            typeof dest.goodsPrice.currentPrice !== 'undefined') ? dest.goodsPrice.currentPrice : '';
        dest.cartInfo.totalNum = totalStorageNum;
        dest.cartInfo.colors = colorGroup;
        dest.cartInfo.sizes = sizeGroup;

       // 限购商品
        if (origin.isLimitBuy === 'Y') {
            // 是否开售
            let isBeginSale = (origin.saleStatus !== null && typeof origin.saleStatus !== 'undefined' &&
                origin.saleStatus === 1);

            // 限购商品有关的展示状态
            let showStatus = 1;

            if (origin.showStatus !== null && typeof origin.showStatus !== 'undefined') {
                showStatus = parseInt(origin.showStatus, 10);
            }

            // 处理限购商品有关的按钮状态
            dest = procShowStatus(dest, showStatus, isBeginSale);
            dest.cartInfo.limitProductCode = origin.limitProductCode;
            dest.cartInfo.limitCodeUrl = getLimitCodeUrl(origin.limitProductCode, origin.erpProductId, ua);
            dest.cartInfo.limitProductPay = helpers.url('/cart/index/orderEnsure');
        } else {
            dest.cartInfo.addToCartUrl = helpers.url('/product/buy_' + origin.id + '_' +
                origin.goodsList.id + '.html'); // 待处理 确认 goodsId 的含义
        }
    } else if (notForSale) {
        dest.cartInfo.notForSale = true;
    } else if (soldOut) {
        dest.cartInfo.soldOut = true;
    }

    // 是否收藏

    dest.isCollect = false;
    if (origin.isCollect !== null && typeof origin.isCollect !== 'undefined' && origin.isCollect === 'Y') {
        dest.isCollect = true;
    }

    // 底部简介的URL链接
    dest.introUrl = helpers.url('/product/intro_' + origin.erpProductId + '/' + origin.cnAlphabet + '.html', null, '');
    dest.id = origin.id;

    return dest;
};

/**
 * 商品尺码信息处理
 * @param  {[type]} productSkn [description]
 * @param  {[type]} uid        [description]
 * @param  {[type]} udid       [description]
 * @return {[type]}            [description]
 */
/* const getSizeInfo = (sizeInfo) => {
    var dest = {},
        temp = {};

    if (_.isEmpty(sizeInfo.productDescBo.erpProductId)) {
        let sex = '通用';
        switch (sizeInfo.productDescBo.gender) {
            case 1:
                sex = '男款';
                break;
            case 2:
                sex = '女款';
                break;
            default:
                break;
        }

        dest.goodsDescription = {};

        dest.goodsDescription.title = '商品信息';
        dest.goodsDescription.enTitle = 'DESCRIPTION';
        dest.goodsDescription.detail = {};
        dest.goodsDescription.detail.list = {};
        dest.goodsDescription.detail.list[0].param =
            '编号：' + sizeInfo.productDescBo.erpProductId;
        dest.goodsDescription.detail.list[1].param =
            '颜色：' + sizeInfo.productDescBo.colorName;
        dest.goodsDescription.detail.list[2].param =
            '性别：' + sex;
    }

    if (_.isEmpty(sizeInfo.productDescBo.standardBos)) {
        _.forEach(sizeInfo.productDescBo.standardBos, function(value, key) {
            dest.goodsDescription.detail.list[3].param = value.standardName + '：' +
                value.standardVal;
        });
    }

    if (_.isEmpty(sizeInfo.phrase)) {
        dest.goodsDescription.desc = sizeInfo.phrase;
    }

    // 尺码信息
    if (!_.isEmpty(sizeInfo.sizeInfoBo)) {
        dest.sizeInfo = {};
        dest.sizeInfo.title = '尺码信息';
        dest.sizeInfo.enTitle = 'SIZE INFO';
        dest.sizeInfo.detail = {};
        dest.sizeInfo.detail.list = {};

        // 参考尺码
        let boyReference = !_.isEmpty(sizeInfo.productExtra.boyReference);
        let girlReference = !_.isEmpty(sizeInfo.productExtra.girlReference);
        let gender = !_.isEmpty(sizeInfo.productDescBo.gender) ? sizeInfo.productDescBo.gender : 3;
        let referenceName = '参考尺码';

        if ((gender === 1 && boyReference) || (gender === 2 && girlReference)) {
            referenceName = '参考尺码';
        } else if (gender === 3 && boyReference) {
            referenceName = '参考尺码(男)';
        } else if (gender === 3 && girlReference) {
            referenceName = '参考尺码(女)';
        }

        let referenceList = {};

        // 判断是否显示参考尺码
        let showReference = (boyReference &&
         !_.isEmpty(sizeInfo.sizeInfoBo.sizeBoList[0].boyReferSize)) || (girlReference &&
         !_.isEmpty(sizeInfo.sizeInfoBo.sizeBoList[0].girlReferSize));

        if (showReference) {
            referenceList[0] = {};
            referenceList[0].param = referenceName;
        }

        if (!_.isEmpty(sizeInfo.sizeInfoBo.sizeAttributeBos)) {
            let sizeNameList = {};

            sizeNameList[0] = {};
            sizeNameList[0].param = '吊牌尺码';

            let sizeBoGroup = {};

            _.forEach(sizeInfo.sizeInfoBo.sizeAttributeBos, function(attr) {
                sizeBoGroup[attr.id[0]].param = _.isEmpty(value.attributeName) ?
                    ' ' : attr.attributeName;
            });

            let item = {};

            _.forEach(sizeInfo.sizeInfoBo.sizeBoList, function(value) {
                item = {};

                let sizeNameList = {};

                sizeNameList[0].param = value.sizeName;

                if (boyReference && (gender === 1 || gender === 3)) {
                    temp = {};
                    temp.param = _.isEmpty(value.boyReferSize.referenceName) ?
                        ' ' : value.boyReferSize.referenceName;
                    sizeNameList.push(temp);
                } else if (girlReference && (gender === 2 || gender === 3)) {
                    temp = {};
                    temp.param = _.isEmpty(value.girlReferSize.referenceName) ?
                        ' ' : value.girlReferSize.referenceName;
                    sizeNameList.push(temp);
                } else {
                    showReference = false;
                }

                _.forEach(value.sortAttributes, function(attr) {
                    temp = {};
                    temp.param = _.isEmpty(attr.sizeValue) ? ' ' : attr.sizeValue;
                    sizeBoGroup[attr.id].push(temp);
                });
            });

            // 根据模板页面的显示，按表格一列一列来显示
            dest.sizeInfo.detail.list[0].params = sizeNameList;
            if (showReference) {
                dest.sizeInfo.detail.list[1].params = referenceList;
            }
            _.forEach(sizeBoGroup, function(value) {
                temp = {};
                temp.params = value;
                dest.sizeInfo.detail.list.push(temp);
            });
        } else {
            temp = {};
            temp[0].param = '';
            dest.sizeInfo.detail.list[0].params.push(temp);
        }
    }

    // 测量方式
    if (!_.isEmpty(sizeInfo.sizeImage)) {
        dest.measurementMethod = {};

        dest.measurementMethod.title = '测量方式';
        dest.measurementMethod.enTitle = 'MEASUREMENT METHOD';
        dest.measurementMethod.img = sizeInfo.sizeImage;
    }

    // 模特试穿, 竖着输出排列显示
    if (!_.isEmpty(sizeInfo.modelBos)) {
        dest.reference = {};
        dest.reference.title = '模特试穿';
        dest.reference.enTitle = 'REFERENCE';
        dest.reference.detail = {};
        dest.reference.detail.list = {};

        // 控制是否显示备注
        let showRemark = false;
        let remarkList = {};
        remarkList[0] = {};
        remarkList[0].param = '备注';

        for (var i = 0; i < 7; i++) {
            dest.reference.detail.list[i] = {};
            dest.reference.detail.list[i].params = {};
            dest.reference.detail.list[0].params[0] = {};
        }
        dest.reference.detail.list[0].params[0].param = '';
        dest.reference.detail.list[1].params[0].param = '模特';
        dest.reference.detail.list[2].params[0].param = '身高';
        dest.reference.detail.list[3].params[0].param = '体重';
        dest.reference.detail.list[4].params[0].param = '三围';
        dest.reference.detail.list[5].params[0].param = '吊牌尺码';
        dest.reference.detail.list[6].params[0].param = '试穿描述';

        _.forEach(sizeInfo.modelBos, function(value) {
            // 待处理
        });

        // 显示模特备注
        if (showRemark) {

        }

    }

    // 商品材质
    if (!_.isEmpty(sizeInfo.productMaterialList)) {
        dest.materials = {};
        dest.materials.title = '商品材质';
        dest.materials.enTitle = 'MATERIALS';
        dest.materials.list = {};

        _.forEach(sizeInfo.productMaterialList, function(value) {
            temp = {};
            temp.img = value.imageUrl;
            temp.desc = value.remark;
            dest.materials.list.push();
        });
    }

    // 洗涤提示
    if (!_.isEmpty(sizeInfo.washTipsBoList)) {
        dest.washTips = {};
        dest.washTips.list = {};
        _.forEach(sizeInfo.washTipsBoList, function(value) {
            dest.washTips.list.push(value);
        });
    }

    // 详情配图

    if (!_.isEmpty(sizeInfo.productIntroBo.productIntro)) {
        let productIntro = '';
        if (!_.isEmpty(sizeInfo.productDescBo.phrase)) {
            productIntro = productIntro + sizeInfo.productDescBo.phrase +
                '<br />';
        }
        productIntro = productIntro + sizeInfo.productIntroBo.productIntro;
        if (!_.isEmpty(productIntro) && productIntro !== '') {
            dest.productDetail = {};
            dest.productDetail.title = '商品详情';
            dest.productDetail.enTitle = 'DETAILS';

             // 待开发
        }

        // 清空变量，释放内存
        sizeInfo = {};
    }

    return dest;
};*/

module.exports = (data) => {
    var finalResult;

    return api.get('', sign.apiSign({
        productId: data.id,
        uid: data.uid,
        vipLevel: data.vipLevel,
        method: 'h5.product.data'
    })).then(result => {
        finalResult = detailDataPkg(result, data.uid, data.vipLevel, data.ua);

        return api.get('', sign.apiSign({
            method: 'app.shop.queryShopsByBrandId',
            brand_id: result.brand.id
        })).then(shops => {
            if (shops.code === 200) {
                finalResult.enterStore = getShopsInfo(shops.data);
            }
            return finalResult;
        });
    });
};