288 lines
8.3 KiB
JavaScript
288 lines
8.3 KiB
JavaScript
import { httpFetch } from '../../request'
|
|
import { formatPlayTime, sizeFormate } from '../../index'
|
|
|
|
export default {
|
|
_requestObj_tags: null,
|
|
_requestObj_listInfo: null,
|
|
_requestObj_list: null,
|
|
_requestObj_listRecommend: null,
|
|
_requestObj_listDetail: null,
|
|
currentTagInfo: {
|
|
id: undefined,
|
|
info: undefined,
|
|
},
|
|
sortList: [
|
|
{
|
|
name: '推荐',
|
|
id: '5',
|
|
},
|
|
{
|
|
name: '最热',
|
|
id: '6',
|
|
},
|
|
{
|
|
name: '最新',
|
|
id: '7',
|
|
},
|
|
{
|
|
name: '热藏',
|
|
id: '3',
|
|
},
|
|
{
|
|
name: '飙升',
|
|
id: '8',
|
|
},
|
|
],
|
|
regExps: {
|
|
listData: /global\.data = (\[.+\]);/,
|
|
listInfo: /global = {[\s\S]+?name: "(.+)"[\s\S]+?pic: "(.+)"[\s\S]+?};/,
|
|
},
|
|
getInfoUrl(tagId) {
|
|
return tagId
|
|
? `http://www2.kugou.kugou.com/yueku/v9/special/getSpecial?is_smarty=1&cdn=cdn&t=5&c=${tagId}`
|
|
: 'http://www2.kugou.kugou.com/yueku/v9/special/getSpecial?is_smarty=1&'
|
|
},
|
|
getSongListUrl(sortId, tagId, page) {
|
|
if (tagId == null) tagId = ''
|
|
return `http://www2.kugou.kugou.com/yueku/v9/special/getSpecial?is_ajax=1&cdn=cdn&t=${sortId}&c=${tagId}&p=${page}`
|
|
},
|
|
getSongListDetailUrl(id) {
|
|
return `http://www2.kugou.kugou.com/yueku/v9/special/single/${id}-5-9999.html`
|
|
},
|
|
|
|
/**
|
|
* 格式化播放数量
|
|
* @param {*} num
|
|
*/
|
|
formatPlayCount(num) {
|
|
if (num > 100000000) return parseInt(num / 10000000) / 10 + '亿'
|
|
if (num > 10000) return parseInt(num / 1000) / 10 + '万'
|
|
return num
|
|
},
|
|
filterInfoHotTag(rawData) {
|
|
const result = []
|
|
if (rawData.status !== 1) return result
|
|
for (const key of Object.keys(rawData.data)) {
|
|
let tag = rawData.data[key]
|
|
result.push({
|
|
id: tag.id,
|
|
name: tag.special_name,
|
|
source: 'kg',
|
|
})
|
|
}
|
|
return result
|
|
},
|
|
filterTagInfo(rawData) {
|
|
const result = []
|
|
for (const name of Object.keys(rawData)) {
|
|
result.push({
|
|
name,
|
|
list: rawData[name].data.map(tag => ({
|
|
parent_id: tag.parent_id,
|
|
parent_name: tag.pname,
|
|
id: tag.id,
|
|
name: tag.name,
|
|
source: 'kg',
|
|
})),
|
|
})
|
|
}
|
|
return result
|
|
},
|
|
|
|
getSongList(sortId, tagId, page, tryNum = 0) {
|
|
if (this._requestObj_list) this._requestObj_list.cancelHttp()
|
|
if (tryNum > 2) return Promise.reject(new Error('try max num'))
|
|
this._requestObj_list = httpFetch(
|
|
this.getSongListUrl(sortId, tagId, page),
|
|
)
|
|
return this._requestObj_list.promise.then(({ body }) => {
|
|
if (!body || body.status !== 1) return this.getSongList(sortId, tagId, page, ++tryNum)
|
|
return this.filterList(body.special_db)
|
|
})
|
|
},
|
|
getSongListRecommend(tryNum = 0) {
|
|
if (this._requestObj_listRecommend) this._requestObj_listRecommend.cancelHttp()
|
|
if (tryNum > 2) return Promise.reject(new Error('try max num'))
|
|
this._requestObj_listRecommend = httpFetch(
|
|
'http://everydayrec.service.kugou.com/guess_special_recommend',
|
|
{
|
|
method: 'post',
|
|
headers: {
|
|
'User-Agent': 'KuGou2012-8275-web_browser_event_handler',
|
|
},
|
|
body: {
|
|
appid: 1001,
|
|
clienttime: 1566798337219,
|
|
clientver: 8275,
|
|
key: 'f1f93580115bb106680d2375f8032d96',
|
|
mid: '21511157a05844bd085308bc76ef3343',
|
|
platform: 'pc',
|
|
userid: '262643156',
|
|
return_min: 6,
|
|
return_max: 15,
|
|
},
|
|
},
|
|
)
|
|
return this._requestObj_listRecommend.promise.then(({ body }) => {
|
|
if (body.status !== 1) return this.getSongListRecommend(++tryNum)
|
|
return this.filterList(body.data.special_list)
|
|
})
|
|
},
|
|
filterList(rawData) {
|
|
return rawData.map(item => ({
|
|
play_count: item.total_play_count || this.formatPlayCount(item.play_count),
|
|
id: item.specialid,
|
|
author: item.nickname,
|
|
name: item.specialname,
|
|
time: item.publish_time || item.publishtime,
|
|
img: item.img || item.imgurl,
|
|
grade: item.grade,
|
|
desc: item.intro,
|
|
source: 'kg',
|
|
}))
|
|
},
|
|
|
|
getListDetail(id, page, tryNum = 0) { // 获取歌曲列表内的音乐
|
|
if (this._requestObj_listDetail) this._requestObj_listDetail.cancelHttp()
|
|
if (tryNum > 2) return Promise.reject(new Error('try max num'))
|
|
this._requestObj_listDetail = httpFetch(this.getSongListDetailUrl(id))
|
|
return this._requestObj_listDetail.promise.then(({ body }) => {
|
|
let listData = body.match(this.regExps.listData)
|
|
let listInfo = body.match(this.regExps.listInfo)
|
|
if (!listData) return this.getListDetail(id, page, ++tryNum)
|
|
listData = this.filterData(JSON.parse(listData[1]))
|
|
let name
|
|
let pic
|
|
if (listInfo) {
|
|
name = listInfo[1]
|
|
pic = listInfo[2]
|
|
}
|
|
return {
|
|
list: listData,
|
|
page: 1,
|
|
limit: 10000,
|
|
total: listData.length,
|
|
source: 'kg',
|
|
info: {
|
|
name,
|
|
img: pic,
|
|
// desc: body.result.info.list_desc,
|
|
// author: body.result.info.userinfo.username,
|
|
// play_count: this.formatPlayCount(body.result.listen_num),
|
|
},
|
|
}
|
|
})
|
|
},
|
|
filterData(rawList) {
|
|
// console.log(rawList)
|
|
return rawList.map(item => {
|
|
const types = []
|
|
const _types = {}
|
|
if (item.filesize !== 0) {
|
|
let size = sizeFormate(item.filesize)
|
|
types.push({ type: '128k', size, hash: item.hash })
|
|
_types['128k'] = {
|
|
size,
|
|
hash: item.hash,
|
|
}
|
|
}
|
|
if (item.filesize_320 !== 0) {
|
|
let size = sizeFormate(item.filesize_320)
|
|
types.push({ type: '320k', size, hash: item.hash_320 })
|
|
_types['320k'] = {
|
|
size,
|
|
hash: item.hash_320,
|
|
}
|
|
}
|
|
if (item.filesize_ape !== 0) {
|
|
let size = sizeFormate(item.filesize_ape)
|
|
types.push({ type: 'ape', size, hash: item.hash_ape })
|
|
_types.ape = {
|
|
size,
|
|
hash: item.hash_ape,
|
|
}
|
|
}
|
|
if (item.filesize_flac !== 0) {
|
|
let size = sizeFormate(item.filesize_flac)
|
|
types.push({ type: 'flac', size, hash: item.hash_flac })
|
|
_types.flac = {
|
|
size,
|
|
hash: item.hash_flac,
|
|
}
|
|
}
|
|
return {
|
|
singer: item.singername,
|
|
name: item.songname,
|
|
albumName: item.album_name,
|
|
albumId: item.album_id,
|
|
songmid: item.audio_id,
|
|
source: 'kg',
|
|
interval: formatPlayTime(item.duration / 1000),
|
|
img: null,
|
|
lrc: null,
|
|
hash: item.hash,
|
|
types,
|
|
_types,
|
|
typeUrl: {},
|
|
}
|
|
})
|
|
},
|
|
|
|
// 获取列表信息
|
|
getListInfo(tagId, tryNum = 0) {
|
|
if (this._requestObj_listInfo) this._requestObj_listInfo.cancelHttp()
|
|
if (tryNum > 2) return Promise.reject(new Error('try max num'))
|
|
this._requestObj_listInfo = httpFetch(this.getInfoUrl(tagId))
|
|
return this._requestObj_listInfo.promise.then(({ body }) => {
|
|
if (body.status !== 1) return this.getListInfo(tagId, ++tryNum)
|
|
return {
|
|
limit: body.data.params.pagesize,
|
|
page: body.data.params.p,
|
|
total: body.data.params.total,
|
|
source: 'kg',
|
|
}
|
|
})
|
|
},
|
|
|
|
// 获取列表数据
|
|
getList(sortId, tagId, page) {
|
|
let tasks = [this.getSongList(sortId, tagId, page)]
|
|
tasks.push(
|
|
this.currentTagInfo.id === tagId
|
|
? Promise.resolve(this.currentTagInfo.info)
|
|
: this.getListInfo(tagId).then(info => {
|
|
this.currentTagInfo.id = tagId
|
|
this.currentTagInfo.info = Object.assign({}, info)
|
|
return info
|
|
}),
|
|
)
|
|
if (!tagId && page === 1 && sortId === this.sortList[0].id) tasks.push(this.getSongListRecommend()) // 如果是所有类别，则顺便获取推荐列表
|
|
return Promise.all(tasks).then(([list, info, recommendList]) => {
|
|
if (recommendList) list.unshift(...recommendList)
|
|
return {
|
|
list,
|
|
...info,
|
|
}
|
|
})
|
|
},
|
|
|
|
// 获取标签
|
|
getTags(tryNum = 0) {
|
|
if (this._requestObj_tags) this._requestObj_tags.cancelHttp()
|
|
if (tryNum > 2) return Promise.reject(new Error('try max num'))
|
|
this._requestObj_tags = httpFetch(this.getInfoUrl())
|
|
return this._requestObj_tags.promise.then(({ body }) => {
|
|
if (body.status !== 1) return this.getTags(++tryNum)
|
|
return {
|
|
hotTag: this.filterInfoHotTag(body.data.hotTag),
|
|
tags: this.filterTagInfo(body.data.tagids),
|
|
source: 'kg',
|
|
}
|
|
})
|
|
},
|
|
}
|
|
|
|
// getList
|
|
// getTags
|
|
// getListDetail
|