2025-05-01 23:10:05 +02:00

238 lines
6.4 KiB
TypeScript

import { useMemo } from 'react';
import { ObjectId, Track, TrackResource } from '@/back-api';
import { useServiceContext } from '@/service/ServiceContext';
import { SessionServiceProps } from '@/service/session';
import { DataStoreType, useDataStore } from '@/utils/data-store';
import { DataTools, TypeCheck } from '@/utils/data-tools';
import { isArrayOf, isString } from '@/utils/validator';
export type TrackServiceProps = {
store: DataStoreType<Track>;
};
export const useTrackService = (): TrackServiceProps => {
const { track } = useServiceContext();
return track;
};
export const useTrackServiceWrapped = (
session: SessionServiceProps
): TrackServiceProps => {
const store = useDataStore<Track>(
{
restApiName: 'TRACK',
primaryKey: 'oid',
available: session.isConnected,
getsCall: () => {
return TrackResource.gets({
restConfig: session.getRestConfig(),
});
},
},
[session.isConnected]
);
return { store };
};
export const useSpecificTrack = (id?: ObjectId) => {
const { store } = useTrackService();
const dataTrack = useMemo(() => {
return store.get(id);
}, [store.data, id]);
return { isLoading: store.isLoading, dataTrack };
};
/**
* Get all the track for a specific artist
* @param idArtist - Id of the artist.
* @returns a promise on the list of track elements
*/
export const useTracksOfAnArtist = (idArtist?: ObjectId) => {
const { store } = useTrackService();
const tracksOnAnArtist = useMemo(() => {
if (idArtist) {
return DataTools.getsWhere(
store.data,
[
{
check: TypeCheck.CONTAINS,
key: 'artists',
value: idArtist,
},
],
['track', 'name']
);
}
return [];
}, [store.data, idArtist]);
return { isLoading: store.isLoading, tracksOnAnArtist };
};
/**
* Get the number of track in this artist ID
* @param id - Id of the artist.
* @returns The number of track present in this artist
*/
export const useCountTracksOfAnArtist = (idArtist?: ObjectId) => {
const { isLoading, tracksOnAnAlbum } = useTracksOfAnAlbum(idArtist);
const countTracksOnAnArtist = useMemo(
() => tracksOnAnAlbum?.length ?? 0,
[tracksOnAnAlbum]
);
return { isLoading, countTracksOnAnArtist };
};
/**
* Get all the track for a specific artist
* @param idGender - Id of the artist.
* @returns a promise on the list of track elements
*/
export const useTracksOfAGender = (idGender?: ObjectId) => {
const { store } = useTrackService();
const tracksOnAGender = useMemo(() => {
if (idGender) {
return DataTools.getsWhere(
store.data,
[
{
check: TypeCheck.CONTAINS,
key: 'genderId',
value: idGender,
},
],
['name', 'track']
);
}
return [];
}, [store.data, idGender]);
return { isLoading: store.isLoading, tracksOnAGender };
};
/**
* Get the number of track in this artist ID
* @param id - Id of the gender.
* @returns The number of track present in this artist
*/
export const useCountTracksOfAGender = (idGender?: ObjectId) => {
const { isLoading, tracksOnAGender } = useTracksOfAGender(idGender);
const countTracksOnAGender = useMemo(
() => tracksOnAGender?.length ?? 0,
[tracksOnAGender]
);
return { isLoading, countTracksOnAGender };
};
/**
* Get all the album of a specific artist
* @param artistId - ID of the artist
* @returns the required List.
*/
export const useAlbumIdsOfAnArtist = (idArtist?: ObjectId) => {
const { isLoading, tracksOnAnArtist } = useTracksOfAnArtist(idArtist);
const albumIdsOfAnArtist = useMemo(() => {
// extract a single time all value "id" in an array
const listAlbumId = DataTools.extractLimitOne(tracksOnAnArtist, 'albumId');
if (isArrayOf(listAlbumId, isString)) {
return listAlbumId;
} else {
console.log(
'Fail to parse the result of the list value (impossible case)'
);
return [];
}
}, [tracksOnAnArtist]);
return { isLoading, albumIdsOfAnArtist };
};
export const useTracksOfAnAlbum = (idAlbum?: ObjectId) => {
const { store } = useTrackService();
const tracksOnAnAlbum = useMemo(() => {
if (idAlbum) {
return DataTools.getsWhere(
store.data,
[
{
check: TypeCheck.EQUAL,
key: 'albumId',
value: idAlbum,
},
],
['track', 'name', 'iid']
);
}
}, [store.data, idAlbum]);
return { isLoading: store.isLoading, tracksOnAnAlbum };
};
/**
* Get the number of track in this season ID
* @param AlbumId - Id of the album.
* @returns The number of element present in this season
*/
export const useCountTracksWithAlbumId = (albumId?: ObjectId) => {
const { isLoading, tracksOnAnAlbum } = useTracksOfAnAlbum(albumId);
const countTracksOfAnAlbum = useMemo(
() => tracksOnAnAlbum?.length ?? 0,
[tracksOnAnAlbum]
);
return { isLoading, countTracksOfAnAlbum };
};
/**
* Get all the track for a specific artist
* @param idArtist - Id of the artist.
* @returns a promise on the list of track elements
*/
export const useTracksOfArtistWithNoAlbum = (idArtist: number) => {
const { store } = useTrackService();
const tracksOnAnArtistWithNoAlbum = useMemo(() => {
if (idArtist) {
return DataTools.getsWhere(
store.data,
[
{
check: TypeCheck.CONTAINS,
key: 'artists',
value: idArtist,
},
{
check: TypeCheck.EQUAL,
key: 'albumId',
value: undefined,
},
],
['track', 'name']
);
}
return [];
}, [store.data, idArtist]);
return { isLoading: store.isLoading, tracksOnAnArtistWithNoAlbum };
};
/**
* Get all the track for a specific artist
* @param startName - basic starting name.
* @returns a promise on the list of track elements
*/
export const useTracksWithStartName = (
startName: string | string[],
invert: boolean
) => {
const { store } = useTrackService();
const tracksStartsWith = useMemo(() => {
return DataTools.getsWhere(
store.data,
[
{
check: invert ? TypeCheck.STARTS_NOT_WITH : TypeCheck.STARTS_WITH,
key: 'name',
value: startName,
},
],
['name', 'track']
);
}, [store.data, startName, invert]);
return { isLoading: store.isLoading, tracksStartsWith };
};