510 lines
17 KiB
JavaScript
510 lines
17 KiB
JavaScript
;(function () {
|
|
var defaultGatewayBase = 'http://127.0.0.1:1100'
|
|
var defaultGatewayPrefix = '/go'
|
|
var defaultLocalGoBase = 'http://127.0.0.1:2900'
|
|
var hostApiBaseMap = {
|
|
'h5.haiyihy.com': 'https://jvapi.haiyihy.com/go'
|
|
}
|
|
var defaultSysOrigin = 'LIKEI'
|
|
var defaultReqClient = 'Android'
|
|
var defaultReqAppIntel = {
|
|
version: '1.0.0',
|
|
build: '1',
|
|
model: 'SM-G9550',
|
|
sysVersion: '9',
|
|
channel: 'Google'
|
|
}
|
|
var defaultReqImei = '8fa54d728ab449e04f9292329ed44bda'
|
|
var defaultReqVersion = 'V2'
|
|
var legacyGoldImage = 'assets/common/yumi_coin.png'
|
|
var legacySemanticRoutes = {
|
|
'Action/TreasureHunt.getPrizeList': '/h5/smash-golden-egg/config',
|
|
'Action/TreasureHunt.startHunt': '/h5/smash-golden-egg/draw',
|
|
'Action/TreasureHunt.getMyHuntRecord': '/h5/smash-golden-egg/records',
|
|
'Action/TreasureHunt.getHuntRecord': '/h5/smash-golden-egg/notices',
|
|
'Action/TreasureHunt.getDayRank': '/h5/smash-golden-egg/rank/day'
|
|
}
|
|
var semanticLegacyActions = {
|
|
'/h5/smash-golden-egg/config': 'Action/TreasureHunt.getPrizeList',
|
|
'/h5/smash-golden-egg/draw': 'Action/TreasureHunt.startHunt',
|
|
'/h5/smash-golden-egg/records': 'Action/TreasureHunt.getMyHuntRecord',
|
|
'/h5/smash-golden-egg/notices': 'Action/TreasureHunt.getHuntRecord',
|
|
'/h5/smash-golden-egg/rank/day': 'Action/TreasureHunt.getDayRank'
|
|
}
|
|
var sysOriginAliases = {
|
|
ATYOU: 'LIKEI',
|
|
YUMI: 'LIKEI',
|
|
SOULLA: 'LIKEI',
|
|
'4PARTY': 'LIKEI',
|
|
FOURPARTY: 'LIKEI'
|
|
}
|
|
|
|
function readParams() {
|
|
var pairs = []
|
|
if (window.location.search) pairs.push(window.location.search.slice(1))
|
|
var hash = window.location.hash || ''
|
|
var hashQueryIndex = hash.indexOf('?')
|
|
if (hashQueryIndex >= 0) pairs.push(hash.slice(hashQueryIndex + 1))
|
|
|
|
var params = {}
|
|
pairs.forEach(function (query) {
|
|
query.split('&').forEach(function (item) {
|
|
if (!item) return
|
|
var index = item.indexOf('=')
|
|
var key = index >= 0 ? item.slice(0, index) : item
|
|
var value = index >= 0 ? item.slice(index + 1) : ''
|
|
try {
|
|
key = decodeURIComponent(key)
|
|
value = decodeURIComponent(value.replace(/\+/g, ' '))
|
|
} catch (error) {}
|
|
if (key) params[key] = value
|
|
})
|
|
})
|
|
return params
|
|
}
|
|
|
|
function normalizeBase(value) {
|
|
return String(value || '').replace(/\/+$/, '')
|
|
}
|
|
|
|
function normalizePrefix(value) {
|
|
value = String(value || '')
|
|
if (!value) return ''
|
|
if (value.charAt(0) !== '/') value = '/' + value
|
|
return value.replace(/\/+$/, '')
|
|
}
|
|
|
|
function resolveHostApiBase() {
|
|
var host = ''
|
|
try {
|
|
host = String(window.location.hostname || '').toLowerCase()
|
|
} catch (error) {}
|
|
return hostApiBaseMap[host] || ''
|
|
}
|
|
|
|
function storageGet(storage, key) {
|
|
try {
|
|
return storage.getItem(key) || ''
|
|
} catch (error) {
|
|
return ''
|
|
}
|
|
}
|
|
|
|
function storageSet(storage, key, value) {
|
|
try {
|
|
if (value) storage.setItem(key, value)
|
|
} catch (error) {}
|
|
}
|
|
|
|
function bearer(value) {
|
|
value = String(value || '').trim()
|
|
if (!value) return ''
|
|
return /^bearer\s+/i.test(value) ? value : 'Bearer ' + value
|
|
}
|
|
|
|
function bearerToken(value) {
|
|
return String(value || '').replace(/^bearer\s+/i, '').trim()
|
|
}
|
|
|
|
function sameOrigin(rawUrl) {
|
|
try {
|
|
return new URL(rawUrl, window.location.href).origin === window.location.origin
|
|
} catch (error) {
|
|
return false
|
|
}
|
|
}
|
|
|
|
function parseHeaderPairs(value) {
|
|
var result = {}
|
|
String(value || '').split(';').forEach(function (item) {
|
|
var index = item.indexOf('=')
|
|
if (index < 0) return
|
|
var key = item.slice(0, index).trim()
|
|
var val = item.slice(index + 1).trim()
|
|
if (key) result[key] = val
|
|
})
|
|
return result
|
|
}
|
|
|
|
function parseReqSysOrigin(value) {
|
|
var result = { origin: '', originChild: '' }
|
|
value = String(value || '').trim()
|
|
if (!value) return result
|
|
if (value.indexOf('=') === -1) {
|
|
result.origin = value
|
|
result.originChild = value
|
|
return result
|
|
}
|
|
value.split(';').forEach(function (item) {
|
|
var index = item.indexOf('=')
|
|
if (index < 0) return
|
|
var key = item.slice(0, index).trim().toLowerCase()
|
|
var val = item.slice(index + 1).trim()
|
|
if (key === 'origin') result.origin = val
|
|
if (key === 'originchild' || key === 'origin_child') result.originChild = val
|
|
})
|
|
if (result.origin && !result.originChild) result.originChild = result.origin
|
|
return result
|
|
}
|
|
|
|
function normalizeSysOrigin(value) {
|
|
value = String(value || '').trim()
|
|
if (!value) return ''
|
|
if (value.indexOf('=') >= 0) value = parseReqSysOrigin(value).origin
|
|
value = String(value || '').trim().toUpperCase()
|
|
return sysOriginAliases[value] || value
|
|
}
|
|
|
|
function decodeBase64(value) {
|
|
value = String(value || '').replace(/-/g, '+').replace(/_/g, '/')
|
|
while (value.length % 4) value += '='
|
|
try {
|
|
return decodeURIComponent(escape(window.atob(value)))
|
|
} catch (error) {
|
|
try {
|
|
return window.atob(value)
|
|
} catch (innerError) {
|
|
return ''
|
|
}
|
|
}
|
|
}
|
|
|
|
function tokenSysOrigin(value) {
|
|
var token = bearerToken(value)
|
|
if (!token) return ''
|
|
|
|
var payload = ''
|
|
var dotIndex = token.indexOf('.')
|
|
if (dotIndex >= 0) {
|
|
payload = token.slice(dotIndex + 1)
|
|
} else {
|
|
payload = token
|
|
}
|
|
payload = decodeBase64(payload)
|
|
if (!payload) return ''
|
|
|
|
var parts = payload.split(':')
|
|
if (parts.length < 3) return ''
|
|
return normalizeSysOrigin(parts[2])
|
|
}
|
|
|
|
function normalizeReqClient(value) {
|
|
value = String(value || '').trim()
|
|
if (/^ios$/i.test(value)) return 'iOS'
|
|
if (/^android$/i.test(value)) return 'Android'
|
|
if (/^h5$/i.test(value)) return 'H5'
|
|
if (/^ops$/i.test(value)) return 'Ops'
|
|
return ''
|
|
}
|
|
|
|
function resolveReqClient() {
|
|
return normalizeReqClient(params.reqClient || params.client) || defaultReqClient
|
|
}
|
|
|
|
function resolveReqAppIntel() {
|
|
var raw = parseHeaderPairs(params.reqAppIntel)
|
|
var version = String(params.appVersion || raw.version || defaultReqAppIntel.version).trim()
|
|
var build = String(params.buildVersion || params.build || raw.build || defaultReqAppIntel.build).trim()
|
|
var model = String(params.model || raw.model || defaultReqAppIntel.model).trim()
|
|
var sysVersion = String(params.sysVersion || raw.sysVersion || defaultReqAppIntel.sysVersion).trim()
|
|
var channel = String(params.appChannel || params.channel || raw.channel || defaultReqAppIntel.channel).trim()
|
|
if (!/^[1-9]\d*$/.test(build)) build = defaultReqAppIntel.build
|
|
return [
|
|
'version=' + (version || defaultReqAppIntel.version),
|
|
'build=' + build,
|
|
'model=' + (model || defaultReqAppIntel.model),
|
|
'sysVersion=' + (sysVersion || defaultReqAppIntel.sysVersion),
|
|
'channel=' + (channel || defaultReqAppIntel.channel)
|
|
].join(';')
|
|
}
|
|
|
|
function resolveReqLang() {
|
|
return String(params.appLanguage || params.lang || navigator.language || 'en').trim() || 'en'
|
|
}
|
|
|
|
function resolveReqZone() {
|
|
var timezone = ''
|
|
try {
|
|
timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || ''
|
|
} catch (error) {}
|
|
return String(params.reqZone || params.timeZone || timezone || 'Asia/Shanghai').trim()
|
|
}
|
|
|
|
function resolveSysOrigin() {
|
|
return (
|
|
tokenSysOrigin(explicitToken) ||
|
|
tokenSysOrigin(explicitAuthorization) ||
|
|
normalizeSysOrigin(params.sysOrigin || params.originSys || params.reqSysOrigin || window.__SMASH_EGG_SYS_ORIGIN__) ||
|
|
defaultSysOrigin
|
|
)
|
|
}
|
|
|
|
function resolveUID() {
|
|
return String(params._login_uid || params.uid || params.userId || params.loginUid || '').trim()
|
|
}
|
|
|
|
function setHeader(headers, name, value) {
|
|
if (!headers || !value) return
|
|
var exists = false
|
|
Object.keys(headers).forEach(function (key) {
|
|
if (String(key).toLowerCase() === String(name).toLowerCase()) exists = true
|
|
})
|
|
if (!exists) headers[name] = value
|
|
}
|
|
|
|
function removeHeader(headers, name) {
|
|
if (!headers) return
|
|
Object.keys(headers).forEach(function (key) {
|
|
if (String(key).toLowerCase() === String(name).toLowerCase()) {
|
|
delete headers[key]
|
|
}
|
|
})
|
|
}
|
|
|
|
function ensureQueryParam(url, key, value) {
|
|
if (!value || url.searchParams.get(key)) return
|
|
url.searchParams.set(key, value)
|
|
}
|
|
|
|
function isLegacySmashUrl(url) {
|
|
return (
|
|
url.pathname === '/index.php' &&
|
|
String(url.searchParams.get('action') || '').indexOf('Action/TreasureHunt.') === 0
|
|
)
|
|
}
|
|
|
|
function isAppSmashUrl(url) {
|
|
return (
|
|
url.pathname.indexOf('/app/smash-golden-egg/') === 0 ||
|
|
url.pathname.indexOf('/h5/smash-golden-egg/') === 0
|
|
)
|
|
}
|
|
|
|
function rewriteLegacyActionToSemanticPath(url) {
|
|
var action = String(url.searchParams.get('action') || '')
|
|
var pathname = legacySemanticRoutes[action]
|
|
if (!pathname) return
|
|
if (action === 'Action/TreasureHunt.startHunt') {
|
|
var num = url.searchParams.get('num')
|
|
if (num && !url.searchParams.get('times')) url.searchParams.set('times', num)
|
|
url.searchParams.delete('num')
|
|
}
|
|
if (action === 'Action/TreasureHunt.getMyHuntRecord') {
|
|
var start = url.searchParams.get('start')
|
|
var limit = url.searchParams.get('num')
|
|
if (start && !url.searchParams.get('offset')) url.searchParams.set('offset', start)
|
|
if (limit && !url.searchParams.get('limit')) url.searchParams.set('limit', limit)
|
|
url.searchParams.delete('start')
|
|
url.searchParams.delete('num')
|
|
}
|
|
url.searchParams.delete('action')
|
|
url.pathname = pathname
|
|
}
|
|
|
|
function rewriteSemanticPathToLegacyAction(url) {
|
|
var pathname = url.pathname.replace(/^\/app\/smash-golden-egg/, '/h5/smash-golden-egg')
|
|
var action = semanticLegacyActions[pathname]
|
|
if (!action) return
|
|
if (action === 'Action/TreasureHunt.startHunt') {
|
|
var times = url.searchParams.get('times')
|
|
if (times && !url.searchParams.get('num')) url.searchParams.set('num', times)
|
|
url.searchParams.delete('times')
|
|
}
|
|
if (action === 'Action/TreasureHunt.getMyHuntRecord') {
|
|
var offset = url.searchParams.get('offset')
|
|
var limit = url.searchParams.get('limit')
|
|
if (offset && !url.searchParams.get('start')) url.searchParams.set('start', offset)
|
|
if (limit && !url.searchParams.get('num')) url.searchParams.set('num', limit)
|
|
url.searchParams.delete('offset')
|
|
url.searchParams.delete('limit')
|
|
}
|
|
url.searchParams.set('action', action)
|
|
url.pathname = '/index.php'
|
|
}
|
|
|
|
function shouldUseSemanticLegacyRoutes() {
|
|
var explicit = String(params.semanticApi || window.__SMASH_EGG_SEMANTIC_API__ || '').trim().toLowerCase()
|
|
if (explicit === '1' || explicit === 'true' || explicit === 'yes') return true
|
|
if (explicit === '0' || explicit === 'false' || explicit === 'no') return false
|
|
if (resolveHostApiBase()) return true
|
|
return !!gatewayPrefix
|
|
}
|
|
|
|
function replaceQueryPlaceholders(url) {
|
|
var uid = resolveUID()
|
|
var rid = String(params.rid || params.room_id || '').trim()
|
|
var replacements = {
|
|
uid: uid,
|
|
userId: uid,
|
|
_login_uid: uid,
|
|
token: explicitToken,
|
|
rid: rid
|
|
}
|
|
Object.keys(replacements).forEach(function (key) {
|
|
var value = url.searchParams.get(key)
|
|
if (/^\{[^}]+\}$/.test(value || '')) {
|
|
url.searchParams.set(key, replacements[key] || '')
|
|
}
|
|
})
|
|
}
|
|
|
|
function resolveBase() {
|
|
var explicitBase = params.gatewayBase || window.__SMASH_EGG_GATEWAY_BASE__ || ''
|
|
var apiBase = params.apiBase || window.__SMASH_EGG_API_BASE__ || ''
|
|
var hostBase = resolveHostApiBase()
|
|
if (explicitBase) return normalizeBase(explicitBase)
|
|
if (apiBase && !sameOrigin(apiBase)) return normalizeBase(apiBase)
|
|
if (hostBase) return normalizeBase(hostBase)
|
|
return explicitToken || explicitAuthorization ? defaultGatewayBase : defaultLocalGoBase
|
|
}
|
|
|
|
function resolvePrefix() {
|
|
if (params.gatewayBase || window.__SMASH_EGG_GATEWAY_BASE__) {
|
|
return normalizePrefix(params.gatewayPrefix || window.__SMASH_EGG_GATEWAY_PREFIX__ || defaultGatewayPrefix)
|
|
}
|
|
if (gatewayBase === defaultGatewayBase) {
|
|
return normalizePrefix(params.gatewayPrefix || window.__SMASH_EGG_GATEWAY_PREFIX__ || defaultGatewayPrefix)
|
|
}
|
|
return normalizePrefix(params.gatewayPrefix || window.__SMASH_EGG_GATEWAY_PREFIX__ || '')
|
|
}
|
|
|
|
var params = readParams()
|
|
var explicitAuthorization = bearer(
|
|
params.Authorization ||
|
|
params.authorization ||
|
|
params.auth ||
|
|
storageGet(window.sessionStorage, 'Authorization') ||
|
|
storageGet(window.localStorage, 'smashEggAuthorization') ||
|
|
''
|
|
)
|
|
var explicitToken = String(
|
|
params.token ||
|
|
storageGet(window.sessionStorage, 'token') ||
|
|
storageGet(window.localStorage, 'smashEggToken') ||
|
|
''
|
|
).trim()
|
|
|
|
if (explicitAuthorization && !explicitToken) explicitToken = bearerToken(explicitAuthorization)
|
|
if (explicitToken && !explicitAuthorization) explicitAuthorization = bearer(explicitToken)
|
|
|
|
storageSet(window.sessionStorage, 'Authorization', explicitAuthorization)
|
|
storageSet(window.sessionStorage, 'token', explicitToken)
|
|
storageSet(window.localStorage, 'smashEggAuthorization', explicitAuthorization)
|
|
storageSet(window.localStorage, 'smashEggToken', explicitToken)
|
|
|
|
var gatewayBase = normalizeBase(resolveBase())
|
|
var gatewayPrefix = normalizePrefix(resolvePrefix())
|
|
|
|
function rewriteUrl(rawUrl) {
|
|
if (!gatewayBase) return rawUrl
|
|
|
|
var parsed
|
|
try {
|
|
parsed = new URL(rawUrl, window.location.href)
|
|
} catch (error) {
|
|
return rawUrl
|
|
}
|
|
|
|
if (!isLegacySmashUrl(parsed) && !isAppSmashUrl(parsed)) return rawUrl
|
|
|
|
var uid = resolveUID()
|
|
var legacyUrl = isLegacySmashUrl(parsed)
|
|
var appUrl = isAppSmashUrl(parsed)
|
|
if (legacyUrl || appUrl) {
|
|
ensureQueryParam(parsed, 'sysOrigin', resolveSysOrigin())
|
|
ensureQueryParam(parsed, 'originSys', resolveSysOrigin())
|
|
ensureQueryParam(parsed, '_login_uid', uid)
|
|
ensureQueryParam(parsed, 'uid', uid)
|
|
ensureQueryParam(parsed, 'token', explicitToken)
|
|
}
|
|
if (legacyUrl) {
|
|
if (shouldUseSemanticLegacyRoutes()) rewriteLegacyActionToSemanticPath(parsed)
|
|
} else if (appUrl && !shouldUseSemanticLegacyRoutes()) {
|
|
rewriteSemanticPathToLegacyAction(parsed)
|
|
}
|
|
replaceQueryPlaceholders(parsed)
|
|
|
|
return gatewayBase + gatewayPrefix + parsed.pathname + parsed.search
|
|
}
|
|
|
|
function injectHeaders(config) {
|
|
config.headers = config.headers || {}
|
|
if (!gatewayPrefix && !explicitToken && !explicitAuthorization) {
|
|
removeHeader(config.headers, 'sign')
|
|
removeHeader(config.headers, 'timestamp')
|
|
}
|
|
setHeader(config.headers, 'Authorization', explicitAuthorization)
|
|
setHeader(config.headers, 'token', explicitToken)
|
|
setHeader(config.headers, 'req-sys-origin', 'origin=' + resolveSysOrigin() + ';originChild=' + resolveSysOrigin())
|
|
setHeader(config.headers, 'req-client', resolveReqClient())
|
|
setHeader(config.headers, 'req-app-intel', resolveReqAppIntel())
|
|
setHeader(config.headers, 'req-imei', params.reqImei || defaultReqImei)
|
|
if (gatewayPrefix || explicitToken || explicitAuthorization) {
|
|
setHeader(config.headers, 'req-version', params.reqVersion || defaultReqVersion)
|
|
}
|
|
setHeader(config.headers, 'req-zone', resolveReqZone())
|
|
setHeader(config.headers, 'req-lang', resolveReqLang())
|
|
}
|
|
|
|
function normalizeLegacyPrizeImage(item) {
|
|
if (!item || typeof item !== 'object') return
|
|
if (item.type === 1 || !item.image) {
|
|
item.image = legacyGoldImage
|
|
}
|
|
if (item.type === 1) {
|
|
var displayGold = Number(item.price || item.goldAmount || item.value || 0)
|
|
if ((!item.num || Number(item.num) <= 1) && displayGold > 1) {
|
|
item.num = displayGold
|
|
}
|
|
}
|
|
}
|
|
|
|
function normalizeLegacyPrizeList(list) {
|
|
if (!Array.isArray(list)) return
|
|
list.forEach(function (item) {
|
|
normalizeLegacyPrizeImage(item)
|
|
if (Array.isArray(item && item.prizeList)) normalizeLegacyPrizeList(item.prizeList)
|
|
})
|
|
}
|
|
|
|
function normalizeLegacyResponse(data) {
|
|
var payload = data && data.response_data
|
|
if (!payload || typeof payload !== 'object') return
|
|
normalizeLegacyPrizeList(payload.normalList)
|
|
normalizeLegacyPrizeList(payload.superList)
|
|
normalizeLegacyPrizeList(payload.list)
|
|
normalizeLegacyPrizeList(payload.notices)
|
|
}
|
|
|
|
if (window.axios && window.axios.interceptors) {
|
|
window.axios.interceptors.request.use(function (config) {
|
|
if (config && typeof config.url === 'string') {
|
|
var nextUrl = rewriteUrl(config.url)
|
|
if (nextUrl !== config.url) {
|
|
window.__SMASH_EGG_LAST_API_REWRITE__ = {
|
|
from: config.url,
|
|
to: nextUrl,
|
|
at: Date.now()
|
|
}
|
|
config.url = nextUrl
|
|
injectHeaders(config)
|
|
}
|
|
}
|
|
return config
|
|
})
|
|
window.axios.interceptors.response.use(function (response) {
|
|
normalizeLegacyResponse(response && response.data)
|
|
return response
|
|
})
|
|
}
|
|
|
|
window.__SMASH_EGG_GATEWAY__ = {
|
|
base: gatewayBase,
|
|
prefix: gatewayPrefix,
|
|
reqSysOrigin: function () {
|
|
return 'origin=' + resolveSysOrigin() + ';originChild=' + resolveSysOrigin()
|
|
},
|
|
rewriteUrl: rewriteUrl
|
|
}
|
|
})()
|