arthur/artdanj-api
1
0
Fork 0
mirror of https://github.com/ArthurDanjou/artdanj-api.git synced 2026-01-14 12:14:33 +01:00
Code Issues 2 Packages Projects Releases Wiki Activity

Delete: Song history

Browse Source
This commit is contained in:
Arthur Danjou
2022-04-14 23:25:29 +02:00
parent 55b197f64d
commit cbad29dfd9
10 changed files with 60 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
app/Controllers/Http/SongsController.ts
View File

@@ -1,37 +1,28 @@
import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
import {
fetchTopArtist,
fetchTopTrack,
fetchTopArtist, fetchTopTracks,
getAuthorizationURI,
getCurrentPlayingFromCache,
getHistory,
setupSpotify,
} from 'App/Utils/SongUtils'
import SongHistoryValidator from 'App/Validators/song/SongHistoryValidator'
import SongRangeValidator from 'App/Validators/song/SongRangeValidator'
export default class SongsController {
public async getCurrentSong({ response }: HttpContextContract) {
return response.status(200).send(await getCurrentPlayingFromCache())
}
public async getHistory({ request, response }: HttpContextContract) {
const { range } = await request.validate(SongHistoryValidator)
const history = await getHistory(range || 'day')
public async getTopTrack({ request, response }: HttpContextContract) {
const { range } = await request.validate(SongRangeValidator)
return response.status(200).send({
range: range || 'day',
history,
tracks: await fetchTopTracks(range || 'short'),
})
}
public async getTopTrack({ response }: HttpContextContract) {
public async getTopArtist({ request, response }: HttpContextContract) {
const { range } = await request.validate(SongRangeValidator)
return response.status(200).send({
tracks: await fetchTopTrack(),
})
}
public async getTopArtist({ response }: HttpContextContract) {
return response.status(200).send({
tracks: await fetchTopArtist(),
tracks: await fetchTopArtist(range || 'short'),
})
}

32
app/Models/Song.ts
View File

@@ -1,32 +0,0 @@
import { BaseModel, column } from '@ioc:Adonis/Lucid/Orm'
export default class Song extends BaseModel {
public static table = 'spotify_songs_history'
@column({ isPrimary: true })
public date: Date
@column()
public device_name: string
@column()
public device_type: string
@column()
public item_name: string
@column()
public item_id: string
@column()
public item_type: string
@column()
public author: string
@column()
public image: string
@column()
public duration: number
}

37
app/Tasks/HistorySongsTask.ts
View File

@@ -1,37 +0,0 @@
import Logger from '@ioc:Adonis/Core/Logger'
import { getCurrentPlayingFromCache } from 'App/Utils/SongUtils'
import Song from 'App/Models/Song'
const MS = 3000 // 3 seconds
let taskId
async function LogSpotifyHistory(): Promise<void> {
const current = await getCurrentPlayingFromCache()
if (!current.is_playing) return
if (current.progress && current.progress < 5000) return
await Song.create({
date: new Date(current.started_at!),
duration: current.duration,
item_name: current.name,
item_type: current.type,
item_id: current.id,
author: current.author,
device_name: current.device_name,
device_type: current.device_type,
image: current.image?.url,
})
}
export async function Activate(): Promise<void> {
Logger.info(`Starting task runner for tracking spotify listen history [${MS} ms]`)
await LogSpotifyHistory()
taskId = setInterval(LogSpotifyHistory, MS)
}
export function ShutDown(): void {
clearInterval(taskId)
Logger.info('Shutdown task runner for getting current developing state')
}

3
app/Types/ISpotify.ts
View File

@@ -62,7 +62,7 @@ interface Album {
uri: string
}
interface Item {
export interface Item {
album: Album & { album_group: 'album' | 'single' | 'compilation' | 'appears_on' ; artists: Artist[] }
artists: Artist[]
available_markets: string[]
@@ -82,6 +82,7 @@ interface Item {
type: string
uri: string
is_local: boolean
device: Device
}
export interface PlayerResponse {

122
app/Utils/SongUtils.ts
View File

@@ -2,11 +2,12 @@ import axios, { AxiosRequestConfig, AxiosResponse } from 'axios'
import Env from '@ioc:Adonis/Core/Env'
import Redis from '@ioc:Adonis/Addons/Redis'
import { SpotifyArtist, SpotifyTrack } from 'App/Types/ILocalSpotify'
import { Artist, InternalPlayerResponse, PlayerResponse, SpotifyToken } from 'App/Types/ISpotify'
import Song from 'App/Models/Song'
import { Artist, InternalPlayerResponse, Item, PlayerResponse, SpotifyToken } from 'App/Types/ISpotify'
import queryString from 'query-string'
import { updateGithubReadmeSpotify } from 'App/Utils/UpdateGithubReadme'
type Range = 'short' | 'medium' | 'long'
export async function getSpotifyAccount(): Promise<SpotifyToken> {
return await Redis.exists('spotify:account')
? JSON.parse(await Redis.get('spotify:account') || '{}')
@@ -117,7 +118,6 @@ export async function getCurrentPlayingFromSpotify(): Promise<InternalPlayerResp
author: current_track.data.item.artists.map(artist => artist.name).join(', ') || '',
id: current_track.data.item.id,
image: current_track.data.item.album.images[0],
progress: current_track.data.progress_ms,
duration: current_track.data.item.duration_ms,
started_at: current_track.data.timestamp,
}
@@ -147,39 +147,56 @@ export async function updateCurrentSong(song: InternalPlayerResponse): Promise<v
// todo send message to Rabbit
}
export async function getHistory(range: 'day' | 'week' | 'month' | 'total') {
if (await Redis.exists(`spotify:history:range:${range || 'day'}`))
return JSON.parse(await Redis.get(`spotify:history:range:${range || 'day'}`) || '{}')
let startDate = new Date(new Date().getTime() - 24 * 60 * 60 * 1000)
if (range === 'week') startDate = new Date(new Date().getTime() - 7 * 24 * 60 * 60 * 1000)
else if (range === 'month') startDate = new Date(new Date().setMonth(new Date().getMonth() - 1))
const endDate = new Date()
const songs = await Song
.query()
.where('date', '<=', endDate)
.where('date', '>=', startDate)
.orderBy('date', 'desc')
if (songs.length <= 0)
return { history: 'no_tracks_in_that_range' }
await Redis.set(`spotify:history:range:${range || 'day'}`, JSON.stringify({
cached: new Date().toUTCString(),
expiration: new Date(new Date().setMinutes(new Date().getMinutes() + 5)).toUTCString(),
history: songs,
}), 'ex', 300)
return { history: songs }
function getTermForRange(range: Range): String {
return `${range}_term`
}
export async function fetchTopArtist(): Promise<SpotifyArtist[] | { artists: string }> {
export async function fetchTopTracks(range: Range) {
if (await Redis.exists(`spotify:top:tracks:${range || 'short'}`))
return JSON.parse(await Redis.get(`spotify:top:tracks:${range || 'short'}`) || '{}')
const fetched_tracks = await RequestWrapper<{ items: Item[] }>(`https://api.spotify.com/v1/me/top/tracks?limit=10?range=${getTermForRange(range)}`)
const tracks: SpotifyTrack[] = []
if (fetched_tracks) {
for (const track of fetched_tracks.data.items) {
tracks.push({
author: track.artists.map(artist => artist.name).join(', ') || '',
device: {
name: track.device.name,
type: track.device.type,
},
image: track.album.images[0].url,
item: {
name: track.name,
type: track.type,
id: track.id,
},
duration: track.duration_ms,
})
}
}
else {
return {
tracks: 'cannot_fetch_tracks',
}
}
await Redis.set(`spotify:top:tracks:${range || 'short'}`, JSON.stringify({
cached: new Date().toUTCString(),
expiration: new Date(new Date().setMinutes(new Date().getMinutes() + 5)).toUTCString(),
top: tracks,
}), 'ex', 300)
return tracks
}
export async function fetchTopArtist(range: Range): Promise<SpotifyArtist[] | { artists: string }> {
if (await Redis.exists('spotify:top:artists'))
return JSON.parse(await Redis.get('spotify:top:artists') || '{}')
const fetched_artists = await RequestWrapper<{ items: Artist[] }>('https://api.spotify.com/v1/me/top/artists?limit=10')
const fetched_artists = await RequestWrapper<{ items: Artist[] }>(`https://api.spotify.com/v1/me/top/artists?limit=10?range=${getTermForRange(range)}`)
const artists: SpotifyArtist[] = []
@@ -209,46 +226,3 @@ export async function fetchTopArtist(): Promise<SpotifyArtist[] | { artists: str
return artists
}
export async function fetchTopTrack(): Promise<Array<SpotifyTrack & { times: number }>> {
if (await Redis.exists('spotify:top:tracks'))
return JSON.parse(await Redis.get('spotify:top:tracks') || '{}')
// Fetch all songs
const fetched_tracks = await Song.query()
if (fetched_tracks.length <= 0)
return []
const filtered = fetched_tracks.map((track) => {
return {
...{
item: {
name: track.item_name,
type: track.item_type,
id: track.item_id,
},
device: {
name: track.device_name,
type: track.device_type,
},
duration: track.duration,
author: track.author,
image: track.image,
},
times: fetched_tracks.filter(i => i.item_id === track.item_id).length,
}
})
const sorted = filtered.sort((itemA, itemB) => itemB.times - itemA.times)
const remove_dupes = sorted.filter((thing, index, self) => index === self.findIndex(t => t.item.id === thing.item.id)).slice(0, 10)
await Redis.set('spotify:top:tracks', JSON.stringify({
cached: new Date().toUTCString(),
expiration: new Date(new Date().setMinutes(new Date().getMinutes() + 5)).toUTCString(),
top: remove_dupes,
}), 'ex', 300)
return remove_dupes
}

4
app/Validators/song/SongHistoryValidator.ts → app/Validators/song/SongRangeValidator.ts
View File

@@ -1,12 +1,12 @@
import { schema } from '@ioc:Adonis/Core/Validator'
import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
export default class SongHistoryValidator {
export default class SongRangeValidator {
constructor(protected ctx: HttpContextContract) {
}
public schema = schema.create({
range: schema.enum.optional(['day', 'week', 'month', 'total'] as const),
range: schema.enum.optional(['short', 'medium', 'long'] as const),
})
public messages = {

23
database/migrations/1642256040742_spotify_songs_history.ts
View File

@@ -1,23 +0,0 @@
import BaseSchema from '@ioc:Adonis/Lucid/Schema'
export default class SpotifySongsHistory extends BaseSchema {
protected tableName = 'spotify_songs_history'
public async up() {
this.schema.createTable(this.tableName, (table) => {
table.timestamp('date').primary().unique().defaultTo(this.now())
table.string('device_name').notNullable()
table.string('device_type').notNullable()
table.string('item_id').notNullable()
table.string('item_name').notNullable()
table.string('item_type').notNullable()
table.string('author').notNullable()
table.string('image').notNullable()
table.bigInteger('duration').notNullable()
})
}
public async down() {
this.schema.dropTable(this.tableName)
}
}

5
providers/AppProvider.ts
View File

@@ -1,6 +1,5 @@
import { ApplicationContract } from '@ioc:Adonis/Core/Application'
import Logger from '@ioc:Adonis/Core/Logger'
export default class AppProvider {
public static needsApplication = true
@@ -21,12 +20,10 @@ export default class AppProvider {
const StatsTask = await import('App/Tasks/StatsTask')
const StatesTask = await import('App/Tasks/StatesTask')
const CurrentSongTask = await import('App/Tasks/CurrentSongTask')
const HistorySongsTask = await import('App/Tasks/HistorySongsTask')
await StatsTask.Activate()
await StatesTask.Activate()
await CurrentSongTask.Activate()
await HistorySongsTask.Activate()
Logger.info('Application is ready!')
}
@@ -36,12 +33,10 @@ export default class AppProvider {
const StatsTask = await import('App/Tasks/StatsTask')
const StatesTask = await import('App/Tasks/StatesTask')
const CurrentSongTask = await import('App/Tasks/CurrentSongTask')
const HistorySongsTask = await import('App/Tasks/HistorySongsTask')
await StatsTask.ShutDown()
await StatesTask.ShutDown()
await CurrentSongTask.ShutDown()
await HistorySongsTask.ShutDown()
Logger.info('Application is closing. Bye...')
}

1
start/routes/api.ts
View File

@@ -8,7 +8,6 @@ Route.resource('/locations', 'LocationsController').only(['index', 'store'])
Route.group(() => {
Route.get('/', 'SongsController.getCurrentSong')
Route.get('/history', 'SongsController.getHistory')
Route.get('/top/tracks', 'SongsController.getTopTrack')
Route.get('/top/artists', 'SongsController.getTopArtist')

1
start/routes/home.ts
View File

@@ -17,7 +17,6 @@ Route.get('/', async({ response }: HttpContextContract) => {
states: `${BASE_URL}/states`,
songs: {
current_song: `${BASE_URL}/spotify`,
history: `${BASE_URL}/spotify/history`,
top_artists: `${BASE_URL}/spotify/top/artists`,
top_tracks: `${BASE_URL}/spotify/top/tracks`,
},