238 lines
6.4 KiB
TypeScript
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 };
|
|
};
|