w-front-end / activityAds · Files

import Vue from "vue";
import Vuex from "vuex";
import 'babel-polyfill';
import Es6Promise from 'es6-promise';
require('es6-promise').polyfill();
import 'url-search-params-polyfill';
import router from "./router/";
import VueResource from "vue-resource";
import VueHead from "vue-head";
import sha1 from "sha1";
import 'mint-ui/lib/style.css';
import { Indicator, InfiniteScroll } from 'mint-ui';
import { Toast, Lazyload} from 'vant';
//VideoPlayer视频播放
import VideoPlayer from 'vue-video-player';
import hls from 'videojs-contrib-hls';
import App from "./App";

Vue.use(Vuex);
Vue.use(VueResource);
Vue.use(VueHead, { separator: " " });
Vue.use(Indicator).use(InfiniteScroll);
Vue.use(VideoPlayer);
// HLSL视频流
Vue.use(hls);

Vue.use(Toast);

Vue.use(Lazyload,{
    preload: 90,
    loading: "static/img/x.jpg",
    error: "static/img/x.jpg",
    attempt: 3
});

Es6Promise.polyfill();

Vue.config.productionTip = false;

// 部署模式设置（开发模式："dev"，测试模式："test"，生产模式："prod"）
Vue.prototype.mode = "prod";

// 微信JS-SDK对象
Vue.prototype.jweixin = {
	value: null
}

// 是否是iPhone平台，默认不是，common.vue进行判断设置
Vue.prototype.isiPhone = {
	value: false
}

// 是否是iPad平台，默认不是，common.vue进行判断设置
Vue.prototype.isiPad = {
	value: false
}

// 是否是Android平台，默认不是，common.vue进行判断设置
Vue.prototype.isAndroid = {
	value: false
}

// 是否在App内，默认不在，common.vue进行判断设置
Vue.prototype.isCNLive = {
	value: false
}

// 是否在一组App内，默认不在，common.vue进行判断设置
Vue.prototype.isCNLive1 = {
	value: false
}

// 是否在支付宝内，默认不在，common.vue进行判断设置
Vue.prototype.isAliPay = {
	value: false
}

// 是否在微信内，默认不在，common.vue进行判断设置
Vue.prototype.isWeChat = {
	value: false
}

// 是否在QQ内，默认不在，common.vue进行判断设置
Vue.prototype.isQQ = {
	value: false
}

/* 后端API版本控制参数 开始 */

// 参数设置
Vue.prototype.apiVersion = {
	index: "Index3",
	miniapp: "Miniapp2"
}

/**
 * 获取后端API版本
 */
Vue.prototype.getApiVersion = function() {
	return this.apiVersion;
}
/* 后端API版本控制参数 结束 */

/* 设置图片尺寸参数 开始 */

// 参数设置
Vue.prototype.SIGN = {
	SMALL: "?imageMogr2/thumbnail/200",
	MIDDLE: "?imageMogr2/thumbnail/400",
	BIG: "?imageMogr2/thumbnail/750",
	SOURCE: ""
}

/**
 * 处理加水印图片链接
 * @param {string} imageUrl [图片链接]
 * @param {string} SIGN [缩略图参数字符串]
 */
Vue.prototype.formatPicLink = function(imageUrl, SIGN = "") {

	// 返回结果
	let result = imageUrl;

	// 如果没有SIGN，直接返回
	if (!SIGN) {
		return result;
	}

	// 处理加水印图片链接
	if (imageUrl.indexOf("?") !== -1) {
		result = imageUrl + SIGN.replace("?", "/");
	}

	// 返回结果
	return result;
}
/* 设置图片尺寸参数 结束 */

/* 通用跳转封装 开始 */

/**
 * 获取跳转参数
 * @param {object} params [参数对象]
 * @param {object} keysArr [所需key数组]
 * @param {string} symbol [链接字符串，默认 &]
 */
Vue.prototype.getGotoDetailParams = function(params, keysArr = [], symbol = "&") {
	
	let paramsString = "";
	
	// 判断是否有参数
	if (typeof params === "object") {
		
		// 参数字符串数组
		let paramsStringArr = new Array();
		
		// 如果未设置需要数组，取全部key
		if (!keysArr.length) {
			keysArr = Object.keys(params);
		}
		
		// 遍历参数对象，取出需要的keys和value
		for (let i = 0; i < keysArr.length; i++) {
			
			// 判断key如果存在，推入数组
			if (params[keysArr[i]]) {
				paramsStringArr.push(keysArr[i] + "=" + params[keysArr[i]]);
			}
		}
		
		// 判断数组，设置返回参数
		if (paramsStringArr.length) {
			paramsString = symbol + paramsStringArr.join("&");
		}
	}
	
	return paramsString;
}

/**
 * 通用跳转
 * @param {object} goods [商品详情对象]
 * @param {object} params [地址栏传参]
 */
Vue.prototype.gotoDetail = function(goods, params) {
	
	// 提取key，判断是广告位还是详情
	let keyArr = Object.keys(goods);
	
	// 判断是Ads还是Detail
	let isAds = (keyArr.includes("type") && keyArr.includes("to") && keyArr.includes("shop_type"));
	
	// 通用所需附加参数key
	let keysArr = [];
	
	// 好家园App内跳转处理
	if (this.isCNLive.value) {
		
		// 初始化参数
		let options = {};
		
		// 广告处理
		if (isAds) {
			
			// 设置参数
			options = {
				type: goods.type,
				to: goods.to,
				shop_type: goods.shop_type
			};
			
		// 商品详情处理
		} else {
			
			// 设置参数
			options = {
				type: "2",
				to: goods.id,
				shop_type: goods.shop_type
			};
		}
		
		// 调用App，提交参数
		if(window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.wjjToAppOnlineRetailers) {
			window.webkit.messageHandlers.wjjToAppOnlineRetailers.postMessage({body: options});
		} else if(window.obj && window.obj.wjjToAppOnlineRetailers) {
			window.obj.wjjToAppOnlineRetailers(JSON.stringify(options));
		}
	} else {	// H5页面跳转处理

		if (isAds) {
			
			// 判断广告类型，进行处理
			switch (goods.type) {
				case "2":		// 跳转商品详情，shop_type 1跳转普通商品 2跳转文创商品 to为商品id  为0不跳转
					
					// 判断是否需要跳转
					if (goods.to) {
						
						// 判断跳转详情对应页面类型
						switch (goods.shop_type) {
							case "2":
								
								// 跳转文创商品详情页
								// uni.navigateTo({
								// 	url: "/pages/main/cultureDetail/cultureDetail?id=" + goods.to + this.getGotoDetailParams(params, keysArr)
								// });

								window.location.href = this.params.shop.apiAddress + "/#/pages/main/cultureDetail/cultureDetail?id=" + goods.to + this.getGotoDetailParams(params, keysArr);
								break;
							case "1":
							default:
								
								// 跳转详情页
								// uni.navigateTo({
								// 	url: "/pages/main/detail/detail?id=" + goods.to + this.getGotoDetailParams(params, keysArr)
								// });
								window.location.href = this.params.shop.apiAddress + "/#/pages/main/cultureDetail/cultureDetail?id=" + goods.to + this.getGotoDetailParams(params, keysArr);

						}
					}
					break;
				case "5":		// webView页 to Url地址
					
					// 跳转URL
					if (goods.to) {
						window.location.href = goods.to;
					}
					break;
				case "12":		// 商城总分类 to  分类id   shop_type  1,2,3 级分类
					
					// 跳转商品列表页面，带着参数，平台分类（groupid）
					if (goods.to) {
						
						// TODO
					}
					break;
				case "14":		// 商城首页
					
					// 跳转商城首页
					uni.redirectTo({
						url: "/" + this.HomePage + this.getGotoDetailParams(params, keysArr, "?")
					});
					break;
				case "20":		// 商城店铺分类 to  分类id   shop_type  1,2 级分类
					
					// 跳转商品列表页面，带着参数，商家分类（categoryId）
					if (goods.to) {
						
						// 跳转商城分类列表页
						uni.navigateTo({
							url: "/pages/goods/goodsList/goodsList?categoryId=" + goods.to + this.getGotoDetailParams(params, keysArr)
						});
					}
					break;
				case "21":		// 跳转店铺首页 to 店铺id shop_type 页面地址
					
					// 跳转店铺首页
					uni.navigateTo({
						url: "/pages/main/shopIndex/shop?shop_id=" + goods.to + this.getGotoDetailParams(params, keysArr)
					});
					break;
			}
		} else {

			// 判断是否需要跳转
			if (goods.id) {
				
				// 判断跳转详情对应页面类型
				switch (goods.shop_type) {
					case "2":
						
						// 跳转文创商品详情页
						// uni.navigateTo({
						// 	url: "/pages/main/cultureDetail/cultureDetail?id=" + goods.id + this.getGotoDetailParams(params, keysArr)
						// });
						
						window.location.href = this.params.shop.apiAddress + "/#/pages/main/cultureDetail/cultureDetail?id=" + goods.id + this.getGotoDetailParams(params, keysArr);
						break;
					case "1":
					default:
						
						// 跳转详情页
						uni.navigateTo({
							url: "/pages/main/detail/detail?id=" + goods.id + this.getGotoDetailParams(params, keysArr)
						});
				}
			}
		}
	}
}

/* 通用跳转封装 结束 */

/* 根据模式，获取相关请求参数 开始 */
Vue.prototype.getParams = function(mode) {

	// 返回参数
	let params = {};

	let app_key = "769_jnjxdh3w53";
	let timestamp = new Date().getTime().toString().substr(0, 10);

	switch (mode.toLowerCase()) {
		case "test":
			// 请求头
			 app_key = "769_jnjxdh3w53";
			 timestamp = new Date().getTime().toString().substr(0, 10);
			 nonce = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCpeLgK0vk5POU5PQ";

			params.shop = {
				apiAddress: "https://wjjshop.cnlive.com",
				headers: {
					 "App-Key": app_key,
				    "Timestamp": timestamp,
				    "Signature": sha1(app_key + nonce + timestamp),
					"content-type": "application/x-www-form-urlencoded"
				},
				sellerCategory: {
					url: "http://wjjh5test.cnlive.com/hqyw.html"
				}
			}
			params.cnlive = {
				apiAddress: "https://api.cnlive.com",
				params: {
					appId: "802_jhbqccxw08",
					appKey: "9c5619e9be747bb3b925dd215ca5923d86f12c09b9394f",
					secret: "1e6380cb347255e777f72b5aa60f41daa68443a132aaea",
					ver: "1.0",
					page_url: "https://wjjshop.cnlive.com/html/votes/1/#/pages/redirect/redirect",
					timestamp: new Date().getTime().toString().substr(0, 10)
				},
				headers: {
					"content-type": "application/x-www-form-urlencoded"
				}
			}
			break;
		case "prod":

			// 请求头
			app_key = "769_jnjxdh3w53";
			timestamp = new Date().getTime().toString().substr(0, 10);
			let nonce = "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCpeLgK0vk5POU5PQ";

			params.shop = {
				apiAddress: "https://managemall.cnlive.com",
				headers: {
				    "App-Key": app_key,
				    "Timestamp": timestamp,
				    "Signature": sha1(app_key + nonce + timestamp),
					"content-type": "application/x-www-form-urlencoded"
				},
				sellerCategory: {
					url: "http://wjjh5.cnlive.com/hqyw.html"
				}
			}
			params.cnlive = {
				apiAddress: "https://api.cnlive.com",
				params: {
					appId: "769_jetj7bq525",
					appKey: "0d57b045ec0c3988a682d94c644e66b9b8e0d2b8ef937d",
					secret: "275e8dc29274a1186d82f65bc607c231d02bcb3bfd8976",
					ver: "1.0",
					page_url: "https://managemall.cnlive.com/html/votes/1/#/pages/redirect/redirect",
					timestamp: new Date().getTime().toString().substr(0, 10)
				},
				headers: {
					"content-type": "application/x-www-form-urlencoded"
				}
			}
			break;
		case "dev":
		default:
			params.shop = {
				apiAddress: "https://wjjshop.cnlive.com",
				headers: {
					"content-type": "application/x-www-form-urlencoded"
				},
				sellerCategory: {
					url: "http://wjjh5test.cnlive.com/hqyw.html"
				}
			}
			params.cnlive = {
				apiAddress: "https://api.cnlive.com",
				params: {
					appId: "802_jhbqccxw08",
					appKey: "9c5619e9be747bb3b925dd215ca5923d86f12c09b9394f",
					secret: "1e6380cb347255e777f72b5aa60f41daa68443a132aaea",
					ver: "1.0",
					page_url: "http://172.16.2.171:8083/html/votes/1/#/pages/redirect/redirect",
					timestamp: new Date().getTime().toString().substr(0, 10)
				},
				headers: {
					"content-type": "application/x-www-form-urlencoded"
				}
			}
	}

	return params;
}
/* 根据模式，获取相关请求参数 结束 */

/* cnlive接口，sign处理 开始 */
Vue.prototype.getCnliveParams = function(datas, params, method = "GET") {

	// 返回结果，根据method返回不同值，Object or Array
	let result = {};

	// 构造参数对象
	let p = {};

	// 单独取出appKey
	let appKey = params.appKey;

	// 删除appKey
	delete params.appKey;

	// 删除secret
	delete params.secret;

	// 合并对象/排序key
	let keySortArr = Object.keys(Object.assign(p, params, datas)).sort();

	// 整理签名字符串数组
	let stringArr = new Array();

	// OPEN方式参数
	let paramsArr = new Array();

	for (let i in keySortArr) {
		if (p[keySortArr[i]]) {

			// 签名数组
			stringArr.push(keySortArr[i] + "=" + p[keySortArr[i]]);

			// OPEN方式参数
			if (method.toUpperCase() == "OPEN") {
				p[keySortArr[i]] = encodeURIComponent(p[keySortArr[i]]);
				paramsArr.push(keySortArr[i] + "=" + p[keySortArr[i]]);
			}
		}
	}

	// 签名字符串
	let strings = stringArr.join("&") + "&key=" + appKey;

	// 签名
	let sign = sha1(strings).toUpperCase();

	// OPEN方式参数
	if (method.toUpperCase() == "OPEN") {

		// 加入签名
		paramsArr.push("sign=" + sign);

		// 设置返回
		result = paramsArr;
	} else {

		// 加入签名
		p.sign = sign;

		// 设置返回
		result = p;
	}

	return result;
}
/* cnlive接口，sign处理 结束 */

/* AJAX请求 开始 */

/**
 * Vue.$http封装
 * @param {string} path         [请求URL]
 * @param {object} data         [请求数据]
 * @param {function} callback   [回调函数]
 * @param {object} ext          [扩展参数]
 */
Vue.prototype.http = function(path, data, callback, ext) {

    /**
     * get请求处理
     * @param {object} context      [Vue对象]
     * @param {string} path         [请求URL]
     * @param {object} data         [请求数据]
     * @param {function} callback   [回调函数]
     * @param {object} ext          [扩展参数]
     * @param {object} headers      [请求头]
     */
    function get(context, path, data, callback, ext, headers) {

        // 时间戳
        data._timestamp = new Date().getTime();

        let params = {
            emulateJSON: true,           // 按照普通表单形式传送
            // withCredentials: true,
            params: data,
            _timeout: 30000,
            headers
        }

        // HTTP请求
        context.$http.get(path, params).then(resp => {

                // 获取返回数据
                let respBody = resp.body;

                // 处理回调
                if (typeof callback === "function") {
                    if (ext) {

                        // 回调，同时返回扩展参数
                        callback(respBody, ext);
                    } else {

                        // 回调
                        callback(respBody);
                    }
                }
            }, err => {

				/* 加载错误处理 开始 */
				Indicator.close();
				Toast("请求出错");
				/* 加载错误处理 结束 */

            });
    }

    /**
     * post请求处理
     * @param {object} context      [Vue对象]
     * @param {string} path         [请求URL]
     * @param {object} data         [请求数据]
     * @param {function} callback   [回调函数]
     * @param {object} ext          [扩展参数]
     * @param {object} headers      [请求头]
     */
    function post(context, path, data, callback, ext, headers) {

        // 时间戳
        data._timestamp = new Date().getTime();

        // 请求配置
        let requestConfig = {
            emulateJSON: true,           // 按照普通表单形式传送
            // withCredentials: true,
			headers,
			_timeout: 30000
		}

        // HTTP请求
        context.$http.post(path, data, requestConfig).then(resp => {

            // 获取返回数据
            let respBody = resp.body;

            // 处理回调
            if (typeof(callback) === "function") {
                if (ext) {

                    // 回调，同时返回扩展参数
                    callback(respBody, ext);
                } else {

                    // 回调
                    callback(respBody);
                }
            }
        }, err => {

			/* 加载错误处理 开始 */
			Indicator.close();
			Toast("请求出错");
			/* 加载错误处理 结束 */

		});
    }

    if(path) {

        // 上下文
        let context = this;

		// 获取相关请求参数
		let params = this.getParams(this.mode);

		// 允许method数组
		let methodsArr = ["GET", "POST", "OPEN"];

		// 默认请求方式（GET）
		let method = "GET";

		// 允许的请求地址
		let apiArr = ["shop", "cnlive"];

		// 默认请求接口（shop）
		let api = "shop";

		// 请求方式
		if (typeof(ext) === "object" && ext.method) {
		    if(methodsArr.includes(ext.method.toUpperCase())) {
		        method = ext.method.toUpperCase();
		    }
		}

		// 请求地址
		if (typeof(ext) === "object" && ext.api) {
		    if(apiArr.includes(ext.api.toLowerCase())) {
		        api = ext.api.toLowerCase();
		    }
		}

		// cnlive接口，sign处理
		if (api == "cnlive") {

			// 获取cnlive接口所需参数（包括sign获取等封装）
			data = this.getCnliveParams(data, params[api].params, method);
		}

		// 判断请求方式
		if (method.toUpperCase() === "OPEN") {

			// 打开页面
			window.location.href = params[api].apiAddress + path + "?" + data.join("&");
		} else {

			// 判断请求类型
            switch (method) {
                case "POST":

                    // 调用post方法
                    post(context, params[api].apiAddress + path, data, callback, ext, params.shop.headers);
                    break;
                case "GET":
                default:

                    // 调用get方法
                    get(context, params[api].apiAddress + path, data, callback, ext, params.shop.headers);
                    break;
            }
		}
	}
};


/*vue-resource请求超时timeout设置*/
Vue.http.interceptors.push((request, next) => {

    let timeout;

    // 如果某个请求设置了_timeout,那么超过该时间，会中断该（abort）请求,并执行请求设置的钩子函数onTimeout方法，不会执行then方法。
    if (request._timeout) {
        timeout = setTimeout(() => {
            request.abort();
        }, request._timeout);
    }
    next(response => {
        clearTimeout(timeout);
        return response;
    });
});
/* ajax请求 结束 */

/* 过滤器 开始 */
Vue.filter("datetime", function(value, fmt) {

    // 时间戳转换日期对象
    let datetime = new Date(value);
    // datetime.setTime(value);

    let o = {
        "M+": datetime.getMonth() + 1,
        "d+": datetime.getDate(),
        "h+": datetime.getHours(),
        "H+": datetime.getHours(),
        "m+": datetime.getMinutes(),
        "s+": datetime.getSeconds(),
        "q+": Math.floor((datetime.getMonth() + 3) / 3),
        S: datetime.getMilliseconds()
    };
    let week = {
        "0": "/u65e5",
        "1": "/u4e00",
        "2": "/u4e8c",
        "3": "/u4e09",
        "4": "/u56db",
        "5": "/u4e94",
        "6": "/u516d"
    };
    if (/(y+)/.test(fmt)) {
        fmt = fmt.replace(RegExp.$1, (datetime.getFullYear() + "").substr(4 - RegExp.$1.length));
    }
    if (/(E+)/.test(fmt)) {
        fmt = fmt.replace(RegExp.$1, (RegExp.$1.length > 1 ? RegExp.$1.length > 2 ? "/u661f/u671f" : "/u5468" : "") + week[datetime.getDay() + ""]);
    }
    for (var k in o) {
        if (new RegExp("(" + k + ")").test(fmt)) {
            fmt = fmt.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length));
        }
    }

    return fmt;
});
/* 过滤器 结束 */

/* 修改页面标题指令 开始 */
Vue.directive("title", {
    inserted: function(el, binding) {
        document.getElementsByTagName("title").innerHtml(binding.value);
        el.remove();
    }
});
/* 修改页面标题指令 结束 */

/* 插入iframe，用于刷新标题 开始 */
Vue.prototype.$iFrame = {
    insertIFrame(title) {
        let i = document.createElement("iframe");
        i.src = "static/img/favicon.png";
        i.style.display = "none";
        i.onload = function() {
            setTimeout(function() {
                i.remove();
            }, 10);
        };
        document.title = title;
        document.body.appendChild(i);
    }
};
/* 插入iframe，用于刷新标题 结束 */

/* 获取Vuex参数 开始 */

/**
 * 获取Vuex参数
 * @param {string} key [参数名]
 * @returns {any}
 */
Vue.prototype.getStore = function(key) {
    return store.state[key];
}
/* 获取Vuex参数 结束 */

/* 状态管理 开始 */
const store = new Vuex.Store({
    state: {

        // debug模式
        debug: true,

        // 设备类型
        deviceType: "",

        // 浏览器类型
        browser: "",

        // uid
        uid: 0
    },
    mutations: {

        // 设置设备类型
        setDeviceType(state, deviceType) {
            state.deviceType = deviceType;
        },

        // 设置浏览器类型
        setBrowser(state, browser) {
            state.browser = browser;
        },

        // 设置浏览器类型
        setUid(state, uid) {
            state.uid = uid;
        }
    }
});
/* 状态管理 结束 */

/* eslint-disable no-new */
new Vue({
  el: "#app",
  router,
  store,
  components: { App },
  template: "<App/>"
});