react-app-shell/activity/src/store/bargain-store.js

react打包脚本和example, 这里的版本请忽略

import {observable, computed, action} from 'mobx';
import moment from 'moment';

import {bargainService} from '../service';
import {
    ADS_STATUS,
    ACTIVE_STATUS,
    ACTIVE_RUN_STATUS,
    BARGAIN_OWNER,
    BARGAIN_STATUS,
    USER_STATUS,
    CAMP_STATUS,
    BARGAIN_TYPE
} from '../constants';
import {tools, message} from '../utils';
import {shareConfig} from '../config';


/**
 * 默认分享
 * @type {shareConfig.group|{title, desc, imgUrl, type, dataUrl}}
 */
const defaultShareOptions = shareConfig.bargain;

class BargainStore {
    @observable state = {
        loading: false,
        activeId: '', // 活动Id,
        recordId: '', // 砍价ID
        activeType: BARGAIN_TYPE.UNKNOWN, // 活动类型
        activeStatus: ACTIVE_STATUS.UNKNOWN, // 活动状态 未开始、已结束、进行中、未知
        status: {
            bargainOwner: BARGAIN_OWNER.UNKNOWN, // 活动所属
            bargainStatus: BARGAIN_STATUS.UNSTART, // 砍价状态
            userStatus: USER_STATUS.NOT_JOIN, // 当前用户砍价状态
            campStatus: CAMP_STATUS.NOT_JOIN,  // 训练营状态: 未加入 本期 非本期
            adsStatus: ADS_STATUS.ADD_ADS, // 地址状态: 新增, 查看
        },
        bargainRank: 0,
        myRecordId: 0
    };
    /**
     * 训练营信息
     * @type {{}}
     */
    @observable campInfo = {};

    /**
     * 活动数据
     * @type {{}}
     */
    @observable activeInfo = {};

    /**
     * 砍价信息
     * @type {{}}
     */
    @observable bargainData = {};

    /**
     * 分享配置信息
     */
    @computed get shareOptions() {
        const shareOptions = {
            ...defaultShareOptions,
            title: this.activeInfo.shareTitle || defaultShareOptions.title, // 分享标题
            desc: this.activeInfo.shareDesc || defaultShareOptions.desc, // 分享描述
            imgUrl: this.activeInfo.shareImgs || defaultShareOptions.imgUrl, // 分享图标, 必填
        };
        return shareOptions;
    }

    /**
     * 加载砍价数据, 同时更新活动状态
     * @param activeId
     * @param recordId
     * @returns {Promise<void>}
     */
    @action loadData = async (activeId, recordId) => {

        this.state.loading = true;

        // 活动状态
        let activeStatus = ACTIVE_STATUS.UNKNOWN;
        // 活动类型
        let activeType = BARGAIN_TYPE.UNKNOWN;

        try {
            // 获取活动信息
            const activityPromise = bargainService.getActivityInfo(activeId);
            // 获取砍价信息
            let bargainPromise;
            if (recordId) {
                bargainPromise = bargainService.loadRecordInfo(activeId, recordId);
            } else {
                bargainPromise = Promise.resolve({});
            }

            const [activeInfo, bargainData] = await Promise.all([activityPromise, bargainPromise]);
            // 设置活动类型
            if (activeInfo['bargainActivityType']) {
                activeType = activeInfo['bargainActivityType'];
            }
            // 设置活动状态
            let {startTime, endTime, now, activityStatus} = activeInfo;
            startTime = moment(startTime).format('X');
            endTime = moment(endTime).format('X');
            now = moment(now).format('X');
            if (endTime && startTime) {
                if (now < startTime || activityStatus === ACTIVE_RUN_STATUS.ACTIVITY_NOT_BEGIN) {
                    activeStatus = ACTIVE_STATUS.NOT_BEGIN;
                }// 在活动时间内并且活动是进行中的状态
                else if (now >= startTime && now < endTime && activityStatus === ACTIVE_RUN_STATUS.ACTIVITY_ALREADY_BEGIN) {
                    // 活动进行中
                    activeStatus = ACTIVE_STATUS.ACTIVE;
                } else {
                    // 活动已结束
                    activeStatus = ACTIVE_STATUS.END;
                }
            }

            this.state = {
                ...this.state,
                activeStatus,
                activeType,
                serviceError: false,
                activeId,
                recordId,
            };
            this.activeInfo = activeInfo || {};
            this.bargainData = bargainData || {};

            // 加载砍价状态逻辑数据, 同时更新活动状态
            this.loadBargainLogic(activeId, recordId);
        }
        catch (error) {
            this.state = {
                ...this.state,
                loading: false,
                activeId,
                recordId,
                activeStatus,
                activeType,
                serviceError: true,
            };
            this.activeInfo = {};
            this.bargainData = {};
            tools.delayEvent(0).then(() => {
                message.error(error && error.msg || '获取砍价信息失败');
            });
            console.error('loadData', error);
        }
    };

    /**
     * 加载砍价状态逻辑数据, 同时更新活动状态
     * @param activeId
     * @param recordId
     */
    @action loadBargainLogic = async (activeId, recordId) => {
        let bargainOwner = BARGAIN_OWNER.UNKNOWN; // 活动所属
        let bargainStatus = BARGAIN_STATUS.UNSTART; // 当前砍价ID砍价状态
        let userStatus = USER_STATUS.NOT_JOIN; // 当前用户砍价状态
        let campStatus = CAMP_STATUS.NOT_JOIN;  // 训练营状态: 未加入 本期 非本期
        let adsStatus = ADS_STATUS.ADD_ADS; // 地址状态: 新增, 查看
        let bargainRank = 0;
        let myRecordId = 0;
        let campInfo = {};

        try {
            const bargainStatusInfo = await bargainService.loadBargainLogic(activeId, recordId);
            const {activeType} = this.state;
            if (bargainStatusInfo.isHasMaker) { // 当前砍价ID是否有发起人
                // 是否登录
                if (bargainStatusInfo.isLogin) {
                    // 是否发起过砍价
                    if (bargainStatusInfo.isMakedActivity) {
                        userStatus = USER_STATUS.JOIN_BARGAIN; // 当前用户一发起过砍价
                        // 活动所属
                    } else {
                        userStatus = USER_STATUS.NOT_JOIN; // 当前用户未发起过砍价
                    }

                    if (bargainStatusInfo.isSameUser) {
                        bargainOwner = BARGAIN_OWNER.MY_BARGAIN; // 当前砍价ID是当前登录用户发起
                    } else {
                        bargainOwner = BARGAIN_OWNER.OTHER_BARGAIN; // 当前砍价ID非当前登录用户发起
                    }
                } else {
                    // 未登录
                    userStatus = USER_STATUS.NOT_JOIN; // 当前用户未发起过砍价
                    bargainOwner = BARGAIN_OWNER.OTHER_BARGAIN; // 当前砍价ID非当前登录用户发起
                }

                // 是否砍价成功
                if (bargainStatusInfo.isSuccess) {
                    // 活动进行中，第一档为砍价成功，isSuccess为false
                    // 活动进行中，全部档位砍价成功， isSuccess为true
                    // 活动已结束，第一档位砍价成功，isSuccess为true
                    // 活动已结束，第一档位砍价未成功，isSuccess为false
                    if (activeType === BARGAIN_TYPE.BARGAIN_ACTIVITY_TRAINING_CAMP) { // 训练营
                        bargainStatus = BARGAIN_STATUS.SUCCESS_CAMP; // 当前砍价ID状态为训练营砍价成功
                        // 是否首批训练营
                        if (bargainStatusInfo.isFirstTrainingCampUser) {
                            campStatus = CAMP_STATUS.CURRENT_CAMP; // 首批训练营
                        } else {
                            campStatus = CAMP_STATUS.NOT_CURRENT_CAMP; // 非首批训练营
                        }
                    } else if (activeType === BARGAIN_TYPE.BARGAIN_ACTIVITY_ENLIGHTENMENT) { // 大礼包
                        bargainStatus = BARGAIN_STATUS.SUCCESS_GIFT; // 当前砍价ID状态为大礼包砍价成功
                        // 是否填写地址
                        if (bargainStatusInfo.isHasPostAddress) {
                            adsStatus = ADS_STATUS.VIEW_ADS; // 地址状态为查看地址
                        } else {
                            adsStatus = ADS_STATUS.ADD_ADS; // 地址状态为新增地址
                        }
                    }
                } else {
                    bargainStatus = BARGAIN_STATUS.BARGAINING; // 当前砍价ID状态为砍价中
                }
            } else {
                // 当前砍价ID没有发起人
                if (bargainStatusInfo.isLogin && bargainStatusInfo.isMakedActivity) { // 登录且发起过砍价
                    userStatus = USER_STATUS.JOIN_BARGAIN; // 当前用户一发起过砍价
                }
            }

            // 砍价成功时获取我是第多少位砍价成功的用户
            if (bargainOwner === BARGAIN_OWNER.MY_BARGAIN && (bargainStatus === BARGAIN_STATUS.SUCCESS_CAMP || bargainStatus === BARGAIN_STATUS.SUCCESS_GIFT)) {
                // 砍价成功时获取我是第多少位砍价成功的用户
                bargainRank = await bargainService.getBargainRank(activeId, recordId);

                if (activeType === BARGAIN_TYPE.BARGAIN_ACTIVITY_TRAINING_CAMP) {
                    // 获取续训练营信息
                    campInfo = await bargainService.getCampInfo(activeId, recordId);
                }
            }

            // 获取我发起的砍价ID
            if (userStatus === USER_STATUS.JOIN_BARGAIN) {
                myRecordId = await bargainService.getMyRecordId(activeId);
                // await this.getMyRecordId(activeId);
            }

            // 砍价活动信息
            this.state = {
                ...this.state,
                loading: false,
                serviceError: false,
                bargainRank,
                myRecordId,
                status: {
                    bargainOwner,
                    bargainStatus,
                    userStatus,
                    campStatus,
                    adsStatus
                }
            };

            // 训练营
            this.campInfo = campInfo;

        } catch (error) {
            this.state = {
                ...this.state,
                loading: false,
                serviceError: true,
                bargainRank: 0,
                myRecordId: 0,
                status: {
                    bargainOwner,
                    bargainStatus,
                    userStatus,
                    campStatus,
                    adsStatus
                }
            };
            this.campInfo = {};

            tools.delayEvent(0).then(() => {
                message.error(error && error.msg || '获取砍价信息失败');
            });
        }

    };

}

export default new BargainStore();