122 lines
4.3 KiB
TypeScript
122 lines
4.3 KiB
TypeScript
import type { Box, Artist, Track } from '~/../types/types'
|
||
|
||
// stores/data.ts
|
||
import { defineStore } from 'pinia'
|
||
import { useUiStore } from '~/store/ui'
|
||
|
||
export const useDataStore = defineStore('data', {
|
||
state: () => ({
|
||
boxes: [] as Box[], // Store your box data here
|
||
artists: [] as Artist[], // Store artist data here
|
||
tracks: [] as Track[], // Store track data here
|
||
isLoaded: false // Remember if data is already loaded
|
||
}),
|
||
|
||
actions: {
|
||
async loadData() {
|
||
if (this.isLoaded) return
|
||
|
||
this.boxes = await $fetch<Box[]>('/api/boxes')
|
||
this.artists = await $fetch<Artist[]>('/api/artists')
|
||
const compilationTracks = await $fetch<Track[]>('/api/tracks/compilation')
|
||
const playlistTracks = await $fetch<Track[]>('/api/tracks/playlist')
|
||
|
||
// Mapper les tracks pour remplacer l'artist avec un objet Artist cohérent
|
||
const artistMap = new Map(this.artists.map((a) => [a.id, a]))
|
||
const allTracks = [...(compilationTracks ?? []), ...(playlistTracks ?? [])]
|
||
|
||
this.tracks = allTracks.map((track) => {
|
||
const a = track.artist as unknown
|
||
let artistObj: Artist
|
||
if (typeof a === 'number') {
|
||
artistObj = artistMap.get(a) ?? { id: a, name: String(a), url: '', coverId: '' }
|
||
} else if (typeof a === 'string') {
|
||
artistObj = { id: 0, name: a, url: '', coverId: '' }
|
||
} else if (a && typeof a === 'object' && 'id' in (a as any)) {
|
||
const idVal = (a as any).id as number | undefined
|
||
artistObj = idVal != null ? artistMap.get(idVal) ?? (a as Artist) : (a as Artist)
|
||
} else {
|
||
artistObj = { id: 0, name: '', url: '', coverId: '' }
|
||
}
|
||
|
||
return {
|
||
...track,
|
||
artist: artistObj
|
||
}
|
||
})
|
||
this.isLoaded = true
|
||
const uiStore = useUiStore()
|
||
uiStore.closeBox()
|
||
}
|
||
},
|
||
|
||
getters: {
|
||
// Obtenir toutes les boxes
|
||
getBoxById: (state) => {
|
||
return (id: string) => {
|
||
return state.boxes.find((box) => box.id === id)
|
||
}
|
||
},
|
||
// Obtenir toutes les pistes d'une box donnée
|
||
getTracksByboxId: (state) => (id: string) => {
|
||
return state.tracks.filter((track) => track.boxId === id)
|
||
},
|
||
// Filtrer les artistes selon certains critères
|
||
getArtistById: (state) => (id: number) => state.artists.find((artist) => artist.id === id),
|
||
|
||
// Obtenir toutes les pistes d'un artiste donné
|
||
getTracksByArtistId: (state) => (artistId: number) => {
|
||
return state.tracks.filter(
|
||
(track) =>
|
||
typeof track.artist === 'object' &&
|
||
!!track.artist &&
|
||
'id' in track.artist &&
|
||
(track.artist as Artist).id === artistId
|
||
)
|
||
},
|
||
getFirstTrackOfBox() {
|
||
return (box: Box) => {
|
||
const tracks = this.getTracksByboxId(box.id)
|
||
.slice()
|
||
.sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
|
||
return tracks.length > 0 ? tracks[0] : null
|
||
}
|
||
},
|
||
getNextPlaylistTrack: (state) => {
|
||
return (track: Track) => {
|
||
const tracksInPlaylist = state.tracks
|
||
.filter((t) => t.boxId === track.boxId)
|
||
.sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
|
||
|
||
const index = tracksInPlaylist.findIndex((t) => t.id === track.id)
|
||
return index >= 0 && index < tracksInPlaylist.length - 1
|
||
? tracksInPlaylist[index + 1]
|
||
: null
|
||
}
|
||
},
|
||
getNextTrack: (state) => {
|
||
return (track: Track) => {
|
||
// Récupérer toutes les tracks de la même box et les trier par ordre
|
||
const tracksInBox = state.tracks
|
||
.filter((t) => t.boxId === track.boxId)
|
||
.sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
|
||
|
||
// Trouver l’index de la track courante
|
||
const index = tracksInBox.findIndex((t) => t.id === track.id)
|
||
// Retourner la track suivante ou null si c’est la dernière
|
||
return index >= 0 && index < tracksInBox.length - 1 ? tracksInBox[index + 1] : null
|
||
}
|
||
},
|
||
getPrevTrack: (state) => {
|
||
return (track: Track) => {
|
||
const tracksInBox = state.tracks
|
||
.filter((t) => t.boxId === track.boxId)
|
||
.sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
|
||
|
||
const index = tracksInBox.findIndex((t) => t.id === track.id)
|
||
return index > 0 ? tracksInBox[index - 1] : null
|
||
}
|
||
}
|
||
}
|
||
})
|