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

'use strict';

const Promise = require('bluebird');
const co = Promise.coroutine;
const _ = require('lodash');
const helpers = global.yoho.helpers;

const ERROR_400_MESSAGE = '系统繁忙，请稍候再试！';
const ProductAPI = require('./product-api');
const CartApi = require('./cart-api');
const chelper = require('./cart-helper');

const pager = require(`${global.utils}/pager`).setPager;

module.exports = class extends global.yoho.BaseModel {
    constructor(ctx) {
        super(ctx);
    }

    _getProductIntroAsync(productSkn) {
        let that = this;

        return co(function * () {
            let result = yield Promise.props({
                sizeInfo: new ProductAPI(that.ctx).sizeInfoAsync(productSkn)
            });

            return result;
        })();
    }

    /**
     * 获得sku商品数据
     */
    _getSkuDataByProductBaseInfo(data) {
        let totalStorageNum = 0;
        let skuGoods = null;// sku商品
        let defaultImage = '';// 默认图
        let chooseSkuFlag = false; // 选中状态

        if (_.isEmpty(_.get(data, 'goods_list', []))) {
            return {
                totalStorageNum,
                skuGoods,
                defaultImage
            };
        }

        skuGoods = _.get(data, 'goods_list', []).reduce((acc, cur, pos)=> {

            // 如果status为0，即skc下架时就跳过该商品$value['status'] === 0
            let goodsGroup = {};

            if (_.isEmpty(cur.color_image)) {
                return acc;
            }

            if (cur.images_list) {
                // 商品列表
                goodsGroup.productSkc = cur.product_skc;
                goodsGroup.src = helpers.image(cur.color_image, 25, 35);
                goodsGroup.title = `${_.trim(data.product_name)} ${cur.color_name}`;
                goodsGroup.name = cur.factory_goods_name;
                goodsGroup.focus = false;
                goodsGroup.total = 0;
                goodsGroup.thumbs = [];
                goodsGroup.size = [];
            }

            _.get(cur, 'images_list', []).forEach((good) => {
                if (good.image_url) {
                    goodsGroup.thumbs.push({
                        url: '',
                        shower: helpers.image(good.image_url, 420, 560),
                        img: helpers.image(good.image_url, 75, 100)
                    });
                }
            });

            // 缩略图空，不显示
            if (_.isEmpty(goodsGroup.thumbs)) {
                return acc;
            }

            // 默认第一张图片
            if (pos === 0) {
                defaultImage = helpers.image(cur.color_image, 420, 560);
            }

            // 商品的尺码列表
            _.get(cur, 'size_list', []).forEach((size) => {
                if (data.attribute === 3) {
                    // 虚拟商品,门票默认最大为4,
                    size.storage_number = size.storage_number > 4 ? 4 : size.storage_number;
                }

                // 如果status为0，即skc下架时就跳过该商品
                if (cur.status === 0) {
                    size.storage_number = 0;
                }

                goodsGroup.size.push({
                    name: size.size_name,
                    sku: size.product_sku,
                    num: _.parseInt(size.storage_number),
                    goodsId: size.size_id
                });

                // 单个sku商品的总数
                goodsGroup.total += _.parseInt(size.storage_number);

                if (goodsGroup.total > 0 && !chooseSkuFlag) { // 默认选中该sku商品
                    goodsGroup.focus = true;
                    chooseSkuFlag = true;// 选中sku商品
                }

                totalStorageNum += _.parseInt(size.storage_number);

            });

            acc.push(goodsGroup);
            return acc;
        }, []);

        if (!_.isEmpty(skuGoods) && !chooseSkuFlag) { // 没有选中一个sku商品，默认选中第一个sku商品
            _.head(skuGoods).focus = true;
        }

        return {
            defaultImage: defaultImage,
            skuGoods: skuGoods,
            totalStorageNum: totalStorageNum
        };
    }

    /**
     * 使sizeBoList id以 sizeAttributeBos id顺序一样
     * @param sizeInfoBo
     */
    _sizeInfoBoSort(sizeInfoBo) {
        if (!sizeInfoBo.sizeBoList || !sizeInfoBo.sizeAttributeBos) {
            return {};
        }

        _.get(sizeInfoBo, 'sizeBoList', []).forEach((sizeBoList, sizek)=> {
            let sortAttr = {};

            sizeBoList.sortAttributes.forEach(sortAttributes => {
                sortAttr[sortAttributes.id] = sortAttributes;
            });

            sizeInfoBo.sizeBoList[sizek].sortAttributes = sortAttr;
        });

        _.get(sizeInfoBo, 'sizeBoList', []).forEach((sizeBoList, sizek)=> {
            let sortAttr = [];

            sizeInfoBo.sizeAttributeBos.forEach(val => {
                if (sizeBoList.sortAttributes[val.id]) {
                    sortAttr.push(sizeBoList.sortAttributes[val.id]);
                }
            });

            sizeInfoBo.sizeBoList[sizek].sortAttributes = sortAttr;

        });

        return sizeInfoBo;
    }

    /**
     * 获取尺寸信息
     * @param sizeInfo
     * @returns {{}}
     */
    _getSizeData(sizeInfo) {

        // 尺码信息
        if (!_.has(sizeInfo, 'sizeInfoBo')) {
            return {};
        }

        sizeInfo.sizeInfoBo = this._sizeInfoBoSort(sizeInfo.sizeInfoBo);

        let boyReference = _.get(sizeInfo, 'productExtra.boyReference', false);
        let girlReference = _.get(sizeInfo, 'productExtra.girlReference', false);
        let gender = _.get(sizeInfo, 'productDescBo.gender', 3);
        let referenceName = (function() {
            if (gender === 3 && boyReference) {
                return '参考尺码(男)';
            } else if (gender === 3 && girlReference) {
                return '参考尺码(女)';
            } else {
                return '参考尺码';
            }
        }());

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

        if (!_.has(sizeInfo, 'sizeInfoBo.sizeAttributeBos')) {
            return {};
        }

        // 尺码信息头部
        let size = {
            thead: [{name: '吊牌尺码', id: ''}],
            tbody: []
        };

        // 显示参考尺码
        if (showReference) {
            size.thead[1] = {name: referenceName, id: ''};
        }

        _.get(sizeInfo, 'sizeInfoBo.sizeAttributeBos', []).forEach((value) => {
            size.thead.push({
                name: value.attributeName || ' ',
                id: value.id
            });
        });

        _.get(sizeInfo, 'sizeInfoBo.sizeBoList', []).forEach((value) => {
            let sizes = [];

            // 吊牌尺码
            sizes.push(value.sizeName);

            // 判断是否显示参考尺码
            if (boyReference && (gender === 1 || gender === 3) && showReference) {
                sizes.push(_.get(value, 'boyReferSize.referenceName', ' '));
            } else if (girlReference && (gender === 2 || gender === 3) && showReference) {
                sizes.push(_.get(value, 'girlReferSize.referenceName', ' '));
            } else {
                if (size.thead[1] && showReference) {
                    size.thead[1] = {};
                }
            }

            // 其他尺码信息
            _.get(value, 'sortAttributes', []).forEach(attr => {
                sizes.push(_.get(attr, 'sizeValue', ' '));
            });

            // 尺码信息
            size.tbody.push(sizes);
        });

        // 参考尺码为空
        if (_.isEmpty(size.thead[1]) && showReference) {
            // 移除这个值
            size.thead.splice(1, 1);
        }

        // 测量方式
        if (sizeInfo.sizeImage) {
            size.sizeImg = sizeInfo.sizeImage;
        }

        return size;
    }

    /**
     * 商品尺码信息
     *
     * @param productSkn
     * @param maxSortId
     * @return object
     */
    _getIntroInfo(productSkn, additionalData) {
        if (!productSkn) {
            return {};
        }

        let sizeInfo = additionalData.sizeInfo;

        if (_.isEmpty(sizeInfo)) {
            return {};
        }

        let result = {};

        // 尺寸数据
        result.size = this._getSizeData(sizeInfo);

        return result;
    }

    /**
     * 详情页数据格式化
     * @param origin Object 原始数据
     * @return result Object 格式化数据
     */
    _detailDataPkg(origin) {
        if (_.isEmpty(origin) || _.isEmpty(origin)) {
            return {};
        }

        let result = {};
        let propOrigin = _.partial(_.get, origin);

        // 商品名称
        if (!propOrigin('product_name')) {
            return result;
        }

        result.name = propOrigin('product_name');
        result.skn = propOrigin('product_skn');
        result.productId = propOrigin('product_id');

        // 商品价格
        result.marketPrice = propOrigin('format_market_price');
        result.salePrice = propOrigin('format_sales_price');
        result.hasOtherPrice = true;

        if (result.salePrice === '0') {
            delete result.salePrice;
            result.hasOtherPrice = false;
        }

        // 上市期
        if (propOrigin('expect_arrival_time')) {
            result.arrivalDate = `${propOrigin('expect_arrival_time')}月`;
            result.presalePrice = propOrigin('format_sales_price');
            delete result.salePrice;
            result.hasOtherPrice = false;
        }

        // sku商品信息
        let skuData = this._getSkuDataByProductBaseInfo(origin);

        // 商品购买状态
        let soldOut = !!(propOrigin('status') === 0 || skuData.totalStorageNum === 0);
        let virtualGoods = propOrigin('attribute') === 3; // 虚拟商品

        if (!soldOut && !virtualGoods) {
            result.addToCart = 1;
        }

        result.isCollect = propOrigin('is_collect');
        result.colors = skuData.skuGoods;

        return result;
    }

    /**
     *  获取某一个商品详情主页面
     */
    getProductInfoAsync(pid) {
        let that = this;

        return co(function * () {
            if (!pid) {
                return {};
            }

            // 获取商品基本信息
            let productData = yield new ProductAPI(that.ctx).getProductAsync(pid);

            if (_.isEmpty(productData.data)) {
                return Promise.reject({
                    code: 404,
                    message: 'app.product.data api wrong'
                });
            }

            let productSkn = _.get(productData, 'data.product_skn');

            let productDescription = yield that._getProductIntroAsync(productSkn);
            let productInfo = that._detailDataPkg(productData.data);
            let intro = that._getIntroInfo(productSkn, productDescription);

            return Object.assign(productInfo, intro);
        })();
    }

    // 获取优惠券列表
    getCoupons(uid) {
        let params = {
            method: 'app.Shopping.listCoupon',
            uid: uid
        };

        return this.get({data: params}).then(result => {

            if (result.code === 200) {
                let unuse = [];
                let use = [];

                _.get(result, 'data.unusable_coupons', []).forEach(i => {
                    unuse.push({
                        code: i.coupon_code,
                        name: i.coupon_name,
                        value: i.coupon_value,
                        canuse: false
                    });
                });

                _.get(result, 'data.usable_coupons', []).forEach(i => {
                    use.push({
                        code: i.coupon_code,
                        name: i.coupon_name,
                        value: i.coupon_value
                    });
                });

                result.data = _.concat(use, unuse);
            }

            return result;
        });
    }

    /**
     * 购物车数据
     * @param uid
     * @param shoppingKey
     * @param cartDelList
     * @returns {*}
     */
    getCartData(uid, shoppingKey, cartDelList) {
        return new CartApi(this.ctx).cartData(uid, shoppingKey).then(cartDataRet => {
            return chelper.formatCart(cartDataRet, uid, shoppingKey, cartDelList);
        });
    }

    /**
     * 获取购物车总数
     *
     * @param int $uid 用户ID
     * @param string $shoppingKey 客户端购物标识
     * @return array
     */
    getCartCount(uid, shoppingKey) {
        return new CartApi(this.ctx).cartCount(uid, shoppingKey);
    }

    /**
     * 加入购物车 获取数量
     *
     * @param int $productSku 商品SKU
     * @param int $buyNumber 购买数量
     * @param int $goodsType 商品类型，0表示普通商品，1表示加价购商品
     * @param int $isEdit 是否是编辑商品SKU，0表示不是编辑
     * @param null|int $promotionId 促销id，默认null（加价购有关）
     * @param null|int $uid 用户UID，可以不传
     * @param string $shoppingKey 购物车在浏览器的唯一识别码，可以不传
     * @return array 加入购物车接口返回的数据
     */
    addCart(productSku, buyNumber, goodsType, isEdit, promotionId, uid, shoppingKey) {
        let that = this;

        return co(function * () {
            let result = {
                code: 400,
                message: ERROR_400_MESSAGE
            };

            if (!productSku) {
                return result;
            }

            let ret = yield new CartApi(that.ctx).addToCart(
                productSku, buyNumber, goodsType, isEdit, promotionId, uid, shoppingKey
            );

            if (ret && ret.code) {
                result = ret;
            }

            return result;
        })();
    }

    /**
     * 加入购物车
     *
     * @param int $productSku 商品SKU
     * @param int $buyNumber 购买数量
     * @param int $goodsType 商品类型，0表示普通商品，1表示加价购商品
     * @param int $isEdit 是否是编辑商品SKU，0表示不是编辑
     * @param null|int $promotionId 促销id，默认null（加价购有关）
     * @param null|int $uid 用户UID，可以不传
     * @param string $shoppingKey 购物车在浏览器的唯一识别码，可以不传
     * @return array 加入购物车接口返回的数据
     */
    addToCart(productSku, buyNumber, goodsType, isEdit, promotionId, uid, shoppingKey, cartDelList) {
        let that = this;

        return co(function * () {
            let result = {
                code: 400,
                message: ERROR_400_MESSAGE
            };

            if (!productSku) {
                return result;
            }

            let ret = yield new CartApi(that.ctx).addToCart(
                productSku, buyNumber, goodsType, isEdit, promotionId, uid, shoppingKey
            );

            if (ret && ret.code) {
                result = {
                    code: ret.code,
                    data: yield that.getCartData(uid, shoppingKey || _.get(ret, 'data.shopping_key'), cartDelList)
                };
            }

            if (!shoppingKey && result.data) {
                result.data.shopping_key = _.get(ret, 'data.shopping_key');
            }

            return result;
        })();
    }

    /**
     * 购物车商品选择与取消接口返回的数据处理
     *
     * @param int $uid 用户ID
     * @param string $skuList 商品sku列表json格式, 如{"744403":1}
     * @param string $shoppingKey 未登录用户唯一识别码
     * @param bool hasPromotion 标识是不是有promotion_id参数, 后端会去调用不同的接口
     * @return array 处理之后的数据的数据
     */
    selectGoods(uid, skuList, shoppingKey, hasPromotion, cartDelList) {
        let that = this;

        return co(function * () {
            let result = {
                code: 400,
                message: ERROR_400_MESSAGE
            };

            if (!skuList) {
                return result;
            }

            let select = yield new CartApi(that.ctx).selectGoods(uid, skuList, shoppingKey, hasPromotion);

            if (select && select.code) {
                result = {
                    code: select.code,
                    data: chelper.formatCart(select, uid, shoppingKey, cartDelList)
                };
            }

            return result;
        })();
    }

    /**
     * 修改购物车商品数量
     *
     * @param int $uid 用户ID
     * @param string $sku 商品SKU
     * @param int $increaseNum 增加的数目
     * @param int $decreaseNum 减少的数目
     * @param string $shoppingKey 未登录用户唯一识别码
     * @return array 接口返回的数据
     */
    modifyProductNum(uid, sku, increaseNum, decreaseNum, shoppingKey, cartDelList) {
        let that = this;

        return co(function * () {
            let result = {
                code: 400,
                message: ERROR_400_MESSAGE
            };

            if (!sku) {
                return result;
            }

            let ret = yield new CartApi(that.ctx).modifyProductNum(uid, sku, increaseNum, decreaseNum, shoppingKey);

            if (ret && ret.code) {
                result = {
                    code: ret.code,
                    data: yield that.getCartData(uid, shoppingKey, cartDelList)
                };
            }

            return result;
        })();

    }

    /**
     * 移出购物车
     *
     * @param int $uid 用户ID
     * @param string $skuList 商品sku列表json格式, 如{"744403":1}
     * @param string $count 要删除的数目
     * @param string $shoppingKey 未登录用户唯一识别码
     * @param bool hasPromotion 标识是不是有promotion_id参数, 后端会去调用不同的接口
     * @return array 接口返回的数据
     */
    removeFromCart(uid, shoppingKey, skuList, hasPromotion, cartDelList) {
        let that = this;

        return co(function * () {
            let result = {
                code: 400,
                message: ERROR_400_MESSAGE
            };

            if (!skuList) {
                return result;
            }

            let ret = yield new CartApi(that.ctx).removeFromCart(uid, shoppingKey, skuList, hasPromotion);

            if (!hasPromotion) {
                return ret;
            }

            if (ret && ret.code) {
                result = {
                    code: ret.code,
                    data: chelper.formatCart(ret, uid, shoppingKey, cartDelList)
                };
            }

            return result;
        })();
    }

    /**
     * 移入收藏夹
     *
     * @param int $uid 用户ID
     * @param string $skuList 商品sku列表
     * @param bool hasPromotion 标识是不是有promotion_id参数, 后端会去调用不同的接口
     * @return array 接口返回的数据
     */
    addToFav(uid, skuList, hasPromotion, cartDelList) {
        let that = this;

        return co(function * () {
            let result = {
                code: 400,
                message: ERROR_400_MESSAGE
            };

            if (!uid) {
                return {
                    code: 403,
                    message: '请先登录！',
                    data: {
                        url: helpers.urlFormat('/signin.html', {
                            refer: helpers.urlFormat('/cart/cart')
                        })
                    }
                };
            }

            if (!skuList) {
                return result;
            }

            let ret = yield new CartApi(that.ctx).addToFav(uid, skuList, hasPromotion);

            if (ret && ret.code) {
                result = {
                    code: ret.code,
                    data: chelper.formatCart(ret, uid, null, cartDelList)
                };
            }

            return result;
        })();

    }

    /**
     * 检查用户是否收藏这一批商品
     *
     * @param int $uid 用户ID
     * @param array $skuList 商品SKU列表
     * @return array
     */
    checkUserIsFav(uid, skuList) {
        let that = this;

        return co(function * () {
            let result = {};

            if (!skuList) {
                return result;
            }

            if (!uid || !_.isNumber(uid)) {

                _.forEach(skuList, it => {
                    result[it] = false;
                });

                return result;
            }

            return yield new CartApi(that.ctx).checkUserIsFavProductList(uid, skuList);
        })();
    }

    /**
     * 获取为你优选商品 待处理
     *
     * @param $channel 频道
     * @param $uid 用户id
     * @param $udid 设备id
     * @param int $page 分页页码
     * @return array
     * @internal param $rec_pos
     * @internal param $limit
     */
    getRecommendProduct(channelNum, uid, udid, page) {
        let that = this;

        return co(function * () {

            let result = {
                code: 200,
                message: '',
                data: {
                    header: '为您优选',
                    hasPrev: false,
                    hasNext: false,
                    item: null
                }
            };

            if (!_.isNumber(page)) {
                return result;
            }

            let together = yield new CartApi(that.ctx).newPreference(channelNum, uid, udid, '100003', 30);
            let plist = _.get(together, 'data.product_list');

            if (!plist || !plist.length) {
                return result;
            }

            if (page > 5) {
                page = 1;
            }

            let begin = (page - 1) * 6;
            let end = begin + 7;
            let items = _.map(_.slice(plist, begin, end), it => {

                let item = {
                    id: it.product_id,
                    skn: it.product_skn,
                    title: it.product_name,
                    img: it.default_images ? helpers.image(it.default_images, 190, 250) : '',
                    alt: it.product_name,
                    price: '¥' + chelper.transPrice(it.sales_price),
                    marketPrice: (it.market_price && +it.market_price > +it.sales_price) ?
                        '¥' + chelper.transPrice(it.market_price) : ''
                };

                item.href = helpers.getUrlBySkc(it.product_skn);

                if (+it.sales_price !== +it.market_price) {
                    it.marketPrice = chelper.transPrice(it.market_price);
                }
                return item;
            });

            Object.assign(result.data, {
                item: items
            });

            return result;
        })();
    }

    /**
     * 获取凑单商品
     *
     * @param object $params 查询参数
     * @return array
     */
    getTogetherProduct(params) {
        const cartApi = new CartApi(this.ctx);
        const maxNum = 100;
        let page = parseInt(`0${params.page}`, 10) || 1,
            limit = parseInt(`0${params.limit}`, 10) || 8;

        return co(function * () {
            let tabs;

            if (!params.price) {
                tabs = _.get(yield cartApi.getTogetherProductPriceTabAsync(), 'data', []);
                _.set(tabs, '[0].active', true);
            }

            let price = params.price || _.get(tabs, '[0].price', '0,300');
            let productInfo = yield cartApi.getTogetherProductListAsync(price, page, limit).then(result => {
                let total = _.get(result, 'data.total', 0);

                // 接口不限制总数量，需要前端限制商品总数量
                if (total > maxNum) {
                    _.set(result, 'data.total', maxNum);
                    _.set(result, 'data.page_total', _.ceil(maxNum / limit));

                    if (page * limit > maxNum && _.has(result, 'data.product_list')) {
                        result.data.product_list.length = 100 - (page - 1) * limit;
                    }
                }

                return result;
            });

            if (productInfo.code === 200) {
                let footPager = pager(_.get(productInfo, 'data.page_total'), {page: page});
                let total = _.get(productInfo, 'data.total'),
                    start = (page - 1) * limit + 1,
                    end = start + limit > total ? total : start + limit - 1;

                footPager.tip = {totalText: `${start} - ${end} / 共${total}件商品`};

                _.set(productInfo, 'data.product_list', _.map(_.get(productInfo, 'data.product_list', []), it => {
                    return {
                        id: it.product_id,
                        skn: it.product_skn,
                        name: it.product_name,
                        img: it.default_images ? helpers.image(it.default_images, 190, 256) : '',
                        price: '¥' + chelper.transPrice(it.sales_price),
                        href: helpers.getUrlBySkc(it.product_skn),
                        marketPrice: (it.market_price && +it.market_price > +it.sales_price) ?
                            '¥' + chelper.transPrice(it.market_price) : ''
                    };
                }));

                _.set(productInfo, 'data.pager', footPager);
                _.set(productInfo, 'data.tabs', tabs);
            }

            return productInfo;
        })();
    }

    /**
     * 修改购物车商品
     * @param param
     * @param uid
     * @param shoppingKey
     * @param cartDelList
     */
    modifyProduct(param, uid, shoppingKey, cartDelList) {
        let that = this;

        return co(function * () {
            let result = {
                code: 400,
                message: ERROR_400_MESSAGE
            };

            let ret = yield new CartApi(that.ctx).modifyProduct(param);

            if (ret && ret.code) {
                result = {
                    code: ret.code,
                    data: yield that.getCartData(uid, shoppingKey, cartDelList)
                };
            }

            return result;
        })();
    }

    /**
     * 重选赠品或加价购商品
     * @param uid
     * @param shoppingKey
     * @param promotionId
     * @param newSkn
     * @param newSku
     * @param cartDelList
     */
    swapGift(uid, shoppingKey, promotionId, newSkn, newSku, cartDelList) {
        let that = this;

        return co(function * () {

            let result = {
                code: 400,
                message: ERROR_400_MESSAGE
            };

            let ret = yield new CartApi(that.ctx).swapGift(uid, shoppingKey, promotionId, newSkn, newSku);

            if (ret && ret.code) {
                result = {
                    code: ret.code,
                    data: yield that.getCartData(uid, shoppingKey, cartDelList)
                };
            }

            return result;
        })();

    }

    /**
     * 查询指定优惠下的可选赠品或加价购
     * @param promotionId 优惠ID
     * @param uid
     * @param shoppingKey
     */
    queryUserPromotionGift(promotionId, uid, shoppingKey) {
        let that = this;
        let cartApiModel = new CartApi(that.ctx);

        return co(function * () {
            let promotionGifts = yield cartApiModel.queryPromotionGift(promotionId);
            let cartDataRet = yield cartApiModel.cartData(uid, shoppingKey);
            let selectedGift = chelper.formatCartGoods(_.get(cartDataRet, 'data.ordinary_cart_data.goods_list'));
            let currentProduct = null; // 默认展示第一个商品

            if (promotionGifts && promotionGifts.code === 200) {
                let promotionList = chelper.formatPriceGifts(_.get(promotionGifts, 'data.arrays', []));

                promotionGifts.data = _.get(promotionList, '[0]', {});

                let goodsList = [];
                let checked;

                _.forEach(promotionList, value => {
                    if (!value.goodsList || !value.goodsList.length) {
                        return;
                    }

                    _.forEach(value.goodsList, it => {
                        if (!checked) {
                            checked = true;
                            it.active = true;
                            currentProduct = it;
                            promotionGifts.data.promotionDesc = value.promotionTitle;
                        }

                        Object.assign(it, {
                            isSelected: !!_.find(selectedGift, ['skn', it.skn]),
                            promotionId: value.promotionId,
                            promotionTitle: value.promotionTitle,
                            maxSelectNumber: value.maxSelectNumber
                        });

                        goodsList.push(it);
                    });
                });

                promotionGifts.data.goodsList = goodsList;

                // 获取选中商品的数据详情
                if (currentProduct && currentProduct.id) {
                    let prodInfo = yield that.getProductInfoAsync(currentProduct.id);

                    // 价格为活动价
                    if (prodInfo) {
                        prodInfo.salePrice = '¥' + currentProduct.subjoinPrice;
                    }

                    promotionGifts.data.productInfo = prodInfo;
                }
            }


            return promotionGifts;
        })();

    }

    /**
     * 首页mini购物车数据
     * @param uid
     * @param shoppingKey
     */
    getMiniCartData(uid, shoppingKey) {
        let that = this;

        return co(function * () {
            let cartDataRet = yield new CartApi(that.ctx).cartData(uid, shoppingKey);

            if (!cartDataRet || cartDataRet.code !== 200) {
                return null;
            }

            let ret = cartDataRet && cartDataRet.data;
            let advCart = _.get(ret, 'advance_cart_data');
            let comCart = _.get(ret, 'ordinary_cart_data');
            let advGoodsList = _.flatten(_.map(_.get(advCart, 'goods_pool_list'), 'goods_list'));
            let comGoodsList = _.flatten(_.map(_.get(comCart, 'goods_pool_list'), 'goods_list'));
            let comSubs = _.flatten(_.map(_.get(comCart, 'goods_pool_list'), 'sub_pool'));
            let subsGoodsList = _.flatten(_.map(comSubs, 'goods_list'));

            let advOffShe = _.get(advCart, 'off_shelves_goods_list');
            let comOffShe = _.get(comCart, 'off_shelves_goods_list');

            let advSoldOuts = _.get(advCart, 'sold_out_goods_list');
            let comSoldOuts = _.get(comCart, 'sold_out_goods_list');

            let goodsList = _(advGoodsList).concat(comGoodsList, subsGoodsList,
                advOffShe, comOffShe,
                advSoldOuts, comSoldOuts);

            goodsList = _.filter(goodsList.value(), it => !!it);

            let glist = _.map(goodsList, g => {
                let goods = {
                    is_advance: g.is_advance,
                    default_img: g.goods_images ? helpers.image(g.goods_images, 46, 62) : '',
                    product_name: g.product_name,
                    factory_goods_name: g.factory_goods_name,
                    size_name: g.size_name,
                    show_price: chelper.transPrice(g.real_price),
                    buy_number: g.buy_number,
                    goods_incart_id: g.shopping_cart_id,
                    product_sku: g.product_sku,
                    promotion_id: g.promotion_id
                };

                goods.product_url = helpers.getUrlBySkc(g.product_skn);
                return goods;
            });

            let advCount = _.get(ret, 'advance_cart_data.shopping_cart_data.goods_count') || 0;
            let comCount = _.get(ret, 'ordinary_cart_data.shopping_cart_data.goods_count') || 0;

            return {
                main_goods: glist,
                total: Number(advCount) + Number(comCount)
            };
        })();
    }

    // 套餐添加购物车
    addBundleData(params) {
        return new CartApi(this.ctx).addBundle(params);
    }

    // 套餐增减购物车
    bundleNumData(params, cartDelList) {
        let that = this;

        return co(function * () {
            let result = {
                code: 400,
                message: ERROR_400_MESSAGE
            };

            if (!params.activity_id) {
                return {
                    code: 400,
                    message: '无效的活动'
                };
            }

            let ret = yield new CartApi(that.ctx).bundleNum(params);

            if (ret && ret.code) {
                result = {
                    code: ret.code,
                    data: yield that.getCartData(params.uid, params.shopping_key, cartDelList)
                };
            }

            return result;
        })();
    }
};