265 lines
11 KiB
JavaScript
265 lines
11 KiB
JavaScript
const dbUtils = global.dbUtils;
|
|
|
|
module.exports = {
|
|
song: {
|
|
insertCollection: async (songInfoList) => {
|
|
if (songInfoList.length == 0) return;
|
|
// image 因为接口没有返回，所以不更新
|
|
let result = await dbUtils.query(`
|
|
INSERT INTO song (
|
|
song_id, title, type, alias, pop, fee, quality, cd,
|
|
no, dj_id, s_id, origin_cover_type, pub_time,
|
|
no_copyright_rcmd, mv, single, version, data_version
|
|
) VALUES ? ON DUPLICATE KEY UPDATE
|
|
title = VALUES(title), type = VALUES(type), alias = VALUES(alias), pop = VALUES(pop), fee = VALUES(fee), quality = VALUES(quality), cd = VALUES(cd),
|
|
no = VALUES(no), dj_id = VALUES(dj_id), s_id = VALUES(s_id), origin_cover_type = VALUES(origin_cover_type), pub_time = VALUES(pub_time),
|
|
no_copyright_rcmd = VALUES(no_copyright_rcmd), mv = VALUES(mv), single = VALUES(single), version = VALUES(version), data_version = VALUES(data_version)
|
|
`, [songInfoList.map(songInfo => [
|
|
songInfo.id, songInfo.title, songInfo.type, songInfo.alias, songInfo.pop, songInfo.fee, songInfo.quality, songInfo.cd,
|
|
songInfo.no, songInfo.djId, songInfo.sId, songInfo.originCoverType, songInfo.pubTime,
|
|
songInfo.noCopyrightRcmd, songInfo.mv, songInfo.single, songInfo.version, 2
|
|
])]);
|
|
await dbUtils.query(`
|
|
DELETE FROM wait_fetch_song WHERE id IN ?
|
|
`, [[songInfoList.map(songInfo => songInfo.id)]])
|
|
return result;
|
|
},
|
|
|
|
getIdsToFetch: async (args) => {
|
|
let whereClause = [
|
|
args.min ? `id > ${args.min}` : '1=1',
|
|
args.max ? `id <= ${args.max}` : '1=1',
|
|
].join(' AND ');
|
|
let sql = `
|
|
SELECT id FROM wait_fetch_song WHERE ${whereClause}
|
|
${args.order ? `ORDER BY id ${args.order}` : ''}
|
|
${args.limit ? `LIMIT ${args.limit}` : ''}
|
|
`;
|
|
// 更新现有数据
|
|
// sql = `SELECT song_id FROM song WHERE data_version = 1`;
|
|
console.log(sql);
|
|
let songIds = await dbUtils.query(sql, []);
|
|
songIds = songIds.map(item => item.id);
|
|
return songIds;
|
|
},
|
|
},
|
|
|
|
|
|
album: {
|
|
insert: async (albumInfo) => {
|
|
return await dbUtils.query('INSERT IGNORE INTO album SET ?', albumInfo);
|
|
},
|
|
|
|
update: async (albumId, albumInfo) => {
|
|
return await dbUtils.query(`UPDATE album SET ? WHERE album_id = ${albumId}`, albumInfo);
|
|
},
|
|
|
|
getIdsToFetch: async (args, isUpdate) => {
|
|
let sql = "";
|
|
if (isUpdate) {
|
|
sql = `SELECT album_id FROM album WHERE (full_description = '' or full_description is null) and description like '%专辑《%》，简介：%' and description not regexp '^.*?专辑《.*?》，简介：[:space:]*?。，更多.*$'`;
|
|
} else {
|
|
let whereClause = [
|
|
args.min ? `id > ${args.min}` : '1=1',
|
|
args.max ? `id <= ${args.max}` : '1=1',
|
|
].join(' AND ');
|
|
sql = `
|
|
SELECT id FROM wait_fetch_album WHERE ${whereClause}
|
|
${args.order ? `ORDER BY id ${args.order}` : ''}
|
|
${args.limit ? `LIMIT ${args.limit}` : ''}
|
|
`;
|
|
}
|
|
console.log(sql);
|
|
let albumIds = await dbUtils.query(sql, []);
|
|
albumIds = albumIds.map(item => item.id);
|
|
return albumIds;
|
|
},
|
|
|
|
getInfoById: async (albumId, { getRelation = true }) => {
|
|
if (!albumId) return {}
|
|
// 查询出专辑
|
|
const sql = 'SELECT * FROM album WHERE album_id = ?'
|
|
let infoResultSet = await dbUtils.query(sql, [albumId]);
|
|
if (infoResultSet.length == 0) return {};
|
|
let albumInfo = JSON.parse(JSON.stringify(infoResultSet[0]));
|
|
if (getRelation) {
|
|
// 查出专辑与歌曲对应关系
|
|
const sql2 = 'SELECT * FROM song_album_relation WHERE album_id = ?'
|
|
let relationResultSet = await dbUtils.query(sql2, [albumId]);
|
|
// 拼装
|
|
albumInfo.songIds = relationResultSet.map(song => song.song_id);
|
|
} else {
|
|
albumInfo.songIds = null;
|
|
}
|
|
return albumInfo;
|
|
},
|
|
},
|
|
|
|
|
|
artist: {
|
|
insert: async (artistInfo) => {
|
|
return await dbUtils.query('INSERT IGNORE INTO artist SET ?', artistInfo);
|
|
},
|
|
|
|
getIdsToFetch: async (args) => {
|
|
let whereClause = [
|
|
args.min ? `id > ${args.min}` : '1=1',
|
|
args.max ? `id <= ${args.max}` : '1=1',
|
|
].join(' AND ');
|
|
let sql = `
|
|
SELECT id FROM wait_fetch_artist WHERE ${whereClause}
|
|
${args.order ? `ORDER BY id ${args.order}` : ''}
|
|
${args.limit ? `LIMIT ${args.limit}` : ''}
|
|
`;
|
|
console.log(sql);
|
|
let artistIds = await dbUtils.query(sql, []);
|
|
artistIds = artistIds.map(item => item.id);
|
|
return artistIds;
|
|
},
|
|
|
|
getInfoById: async (artistId, { getRelation = true }) => {
|
|
if (!artistId) return {}
|
|
// 查询出歌手
|
|
const sql = 'SELECT * FROM artist WHERE artist_id = ?'
|
|
let infoResultSet = await dbUtils.query(sql, [artistId]);
|
|
if (infoResultSet.length == 0) return {};
|
|
let artistInfo = JSON.parse(JSON.stringify(infoResultSet[0]));
|
|
if (getRelation) {
|
|
// 查出歌手与歌曲对应关系
|
|
const sql2 = 'SELECT * FROM song_artist_relation WHERE artist_id = ?'
|
|
let relationResultSet = await dbUtils.query(sql2, [artistId]);
|
|
// 拼装
|
|
artistInfo.songIds = relationResultSet.map(song => song.song_id);
|
|
} else {
|
|
artistInfo.songIds = null;
|
|
}
|
|
return artistInfo;
|
|
},
|
|
},
|
|
|
|
|
|
lyric: {
|
|
insert: async (lyricInfo) => {
|
|
return await dbUtils.query('INSERT IGNORE INTO lyric SET ?', lyricInfo);
|
|
},
|
|
|
|
getIdsToFetch: async (args) => {
|
|
let whereClause = [
|
|
args.min ? `id > ${args.min}` : '1=1',
|
|
args.max ? `id <= ${args.max}` : '1=1',
|
|
].join(' AND ');
|
|
var sql = `
|
|
SELECT id FROM wait_fetch_lyric WHERE ${whereClause}
|
|
${args.order ? `ORDER BY id ${args.order}` : ''}
|
|
${args.limit ? `LIMIT ${args.limit}` : ''}
|
|
`;
|
|
console.log(sql);
|
|
let songIds = await dbUtils.query(sql, []);
|
|
songIds = songIds.map(item => item.id);
|
|
return songIds;
|
|
},
|
|
},
|
|
|
|
|
|
comment: {
|
|
insertCollection: async (commentInfoList) => {
|
|
if (commentInfoList.length == 0) return;
|
|
return await dbUtils.query(`
|
|
INSERT INTO comment ( comment_id, parent_comment_id, user_id, song_id, content, time, like_count, comment_type ) VALUES ?
|
|
ON DUPLICATE KEY UPDATE content = VALUES(content), like_count = VALUES(like_count), comment_type = GREATEST(comment_type, VALUES(comment_type)), modify_time = CURRENT_TIMESTAMP
|
|
`, [commentInfoList]);
|
|
},
|
|
|
|
getIdsToFetch: async (args) => {
|
|
let whereClause = [
|
|
args.min ? `song_id > ${args.min}` : '1=1',
|
|
args.max ? `song_id <= ${args.max}` : '1=1',
|
|
].join(' AND ');
|
|
var sql = `
|
|
SELECT song_id FROM comment_progress WHERE ${whereClause} AND current_status != 2
|
|
ORDER BY current_status DESC${args.order ? `, song_id ${args.order}` : ''}
|
|
${args.limit ? `LIMIT ${args.limit}` : ''}
|
|
`;
|
|
console.log(sql);
|
|
let songIds = await dbUtils.query(sql, []);
|
|
songIds = songIds.map(item => item.song_id);
|
|
return songIds;
|
|
},
|
|
},
|
|
|
|
|
|
comment_progress: {
|
|
update: async (commentProgressInfo, songId) => {
|
|
return await dbUtils.query('UPDATE comment_progress SET ? WHERE song_id = ? LIMIT 1', [commentProgressInfo, songId]);
|
|
},
|
|
},
|
|
|
|
|
|
playlist: {
|
|
insertCollection: async (playlistInfo) => {
|
|
if (playlistInfo.length == 0) return;
|
|
return await dbUtils.query(`
|
|
INSERT INTO playlist ( ${Object.keys(playlistInfo).map(field => `\`${field}\``).join(",")} ) VALUES ?
|
|
ON DUPLICATE KEY UPDATE ${Object.keys(playlistInfo).map(field => `${field}=VALUES(${field})`).join(", ")}
|
|
`, [[Object.values(playlistInfo)]]);
|
|
},
|
|
},
|
|
|
|
|
|
user: {
|
|
insertCollection: async (userInfoList) => {
|
|
if (userInfoList.length == 0) return;
|
|
return await dbUtils.query(`
|
|
INSERT INTO user ( user_id, user_type, nickname, avatar_url ) VALUES ?
|
|
ON DUPLICATE KEY UPDATE user_type = VALUES(user_type), nickname = VALUES(nickname), avatar_url = VALUES(avatar_url), modify_time = CURRENT_TIMESTAMP
|
|
`, [userInfoList]);
|
|
},
|
|
},
|
|
|
|
|
|
song_album: {
|
|
insertCollection: async (songAlbumRel) => {
|
|
if (songAlbumRel.length == 0) return;
|
|
return await dbUtils.query('INSERT IGNORE INTO song_album_relation (song_id, album_id) VALUES ?', [songAlbumRel]);
|
|
},
|
|
},
|
|
|
|
|
|
song_artist: {
|
|
insertCollection: async (songArtistRel) => {
|
|
if (songArtistRel.length == 0) return;
|
|
return await dbUtils.query('INSERT IGNORE INTO song_artist_relation (song_id, artist_id) VALUES ?', [songArtistRel]);
|
|
},
|
|
},
|
|
|
|
|
|
song_playlist: {
|
|
insertCollection: async (trackIds) => {
|
|
if (trackIds.length == 0) return;
|
|
return await dbUtils.query('INSERT IGNORE INTO song_playlist_relation (song_id, playlist_id, alg) VALUES ?', [trackIds]);
|
|
},
|
|
},
|
|
|
|
|
|
/* ##################################################### */
|
|
|
|
|
|
// 将 id 插入待检查表
|
|
wait_check: {
|
|
insert: async (type, ids) => {
|
|
// 过滤掉 id 为 0 的
|
|
ids = ids.filter(id => id > 0);
|
|
if (ids.length == 0) return;
|
|
return await dbUtils.query(`INSERT IGNORE INTO wait_check_${type} (id) VALUES ?`, [ids.map(id => [id])]);
|
|
},
|
|
},
|
|
|
|
wait_fetch: {
|
|
deleteCollection: async function (type, ids) {
|
|
// console.log("wait_fetch.deleteCollection", type, ids);
|
|
if (ids.length > 0)
|
|
return await dbUtils.query(`DELETE FROM wait_fetch_${type} WHERE id IN ?`, [[ids]]);
|
|
}
|
|
}
|
|
};
|