mirror of
https://github.com/jeffvli/feishin.git
synced 2026-05-08 13:00:13 +02:00
add initial files
This commit is contained in:
jeffvli
@@ -0,0 +1,5 @@
|
||||
export * from './subsonic/subsonic-api';
|
||||
export * from './subsonic/subsonic-tasks';
|
||||
export * from './jellyfin/jellyfin-api';
|
||||
export * from './jellyfin/jellyfin-tasks';
|
||||
export * from './scanner-queue';
|
||||
@@ -0,0 +1,92 @@
|
||||
import axios from 'axios';
|
||||
import { Server } from '../../types/types';
|
||||
import {
|
||||
JFAlbumArtistsResponse,
|
||||
JFAlbumsResponse,
|
||||
JFArtistsResponse,
|
||||
JFGenreResponse,
|
||||
JFMusicFoldersResponse,
|
||||
JFRequestParams,
|
||||
JFSongsResponse,
|
||||
} from './jellyfin-types';
|
||||
|
||||
export const api = axios.create({});
|
||||
|
||||
export const getMusicFolders = async (server: Partial<Server>) => {
|
||||
const { data } = await api.get<JFMusicFoldersResponse>(
|
||||
`${server.url}/users/${server.remoteUserId}/items`,
|
||||
{ headers: { 'X-MediaBrowser-Token': server.token! } }
|
||||
);
|
||||
|
||||
const musicFolders = data.Items.filter(
|
||||
(folder) => folder.CollectionType === 'music'
|
||||
);
|
||||
|
||||
return musicFolders;
|
||||
};
|
||||
|
||||
export const getGenres = async (server: Server, params: JFRequestParams) => {
|
||||
const { data } = await api.get<JFGenreResponse>(`${server.url}/genres`, {
|
||||
headers: { 'X-MediaBrowser-Token': server.token },
|
||||
params,
|
||||
});
|
||||
|
||||
return data;
|
||||
};
|
||||
|
||||
export const getAlbumArtists = async (
|
||||
server: Server,
|
||||
params: JFRequestParams
|
||||
) => {
|
||||
const { data } = await api.get<JFAlbumArtistsResponse>(
|
||||
`${server.url}/artists/albumArtists`,
|
||||
{
|
||||
headers: { 'X-MediaBrowser-Token': server.token },
|
||||
params,
|
||||
}
|
||||
);
|
||||
|
||||
return data;
|
||||
};
|
||||
|
||||
export const getArtists = async (server: Server, params: JFRequestParams) => {
|
||||
const { data } = await api.get<JFArtistsResponse>(`${server.url}/artists`, {
|
||||
headers: { 'X-MediaBrowser-Token': server.token },
|
||||
params,
|
||||
});
|
||||
|
||||
return data;
|
||||
};
|
||||
|
||||
export const getAlbums = async (server: Server, params: JFRequestParams) => {
|
||||
const { data } = await api.get<JFAlbumsResponse>(
|
||||
`${server.url}/users/${server.remoteUserId}/items`,
|
||||
{
|
||||
headers: { 'X-MediaBrowser-Token': server.token },
|
||||
params: { includeItemTypes: 'MusicAlbum', ...params },
|
||||
}
|
||||
);
|
||||
|
||||
return data;
|
||||
};
|
||||
|
||||
export const getSongs = async (server: Server, params: JFRequestParams) => {
|
||||
const { data } = await api.get<JFSongsResponse>(
|
||||
`${server.url}/users/${server.remoteUserId}/items`,
|
||||
{
|
||||
headers: { 'X-MediaBrowser-Token': server.token },
|
||||
params: { includeItemTypes: 'Audio', ...params },
|
||||
}
|
||||
);
|
||||
|
||||
return data;
|
||||
};
|
||||
|
||||
export const jellyfinApi = {
|
||||
getAlbumArtists,
|
||||
getAlbums,
|
||||
getArtists,
|
||||
getGenres,
|
||||
getMusicFolders,
|
||||
getSongs,
|
||||
};
|
||||
@@ -0,0 +1,631 @@
|
||||
import uniqBy from 'lodash/uniqBy';
|
||||
import { prisma } from '../../lib';
|
||||
import { Server, ServerFolder, Task } from '../../types/types';
|
||||
import { groupByProperty, uniqueArray } from '../../utils';
|
||||
import { completeTask, q } from '../scanner-queue';
|
||||
import { jellyfinApi } from './jellyfin-api';
|
||||
import { JFSong } from './jellyfin-types';
|
||||
|
||||
const scanGenres = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder,
|
||||
task: Task
|
||||
) => {
|
||||
const taskId = `[${server.name} (${serverFolder.name})] genres`;
|
||||
|
||||
q.push({
|
||||
fn: async () => {
|
||||
await prisma.task.update({
|
||||
data: { message: 'Scanning genres' },
|
||||
where: { id: task.id },
|
||||
});
|
||||
|
||||
const genres = await jellyfinApi.getGenres(server, {
|
||||
parentId: serverFolder.remoteId,
|
||||
});
|
||||
|
||||
const genresCreate = genres.Items.map((genre) => {
|
||||
return { name: genre.Name };
|
||||
});
|
||||
|
||||
await prisma.genre.createMany({
|
||||
data: genresCreate,
|
||||
skipDuplicates: true,
|
||||
});
|
||||
|
||||
return { task };
|
||||
},
|
||||
id: taskId,
|
||||
});
|
||||
};
|
||||
|
||||
const scanAlbumArtists = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder,
|
||||
task: Task
|
||||
) => {
|
||||
const taskId = `[${server.name} (${serverFolder.name})] album artists`;
|
||||
|
||||
q.push({
|
||||
fn: async () => {
|
||||
await prisma.task.update({
|
||||
data: { message: 'Scanning album artists' },
|
||||
where: { id: task.id },
|
||||
});
|
||||
const albumArtists = await jellyfinApi.getAlbumArtists(server, {
|
||||
fields: 'Genres,DateCreated,ExternalUrls,Overview',
|
||||
parentId: serverFolder.remoteId,
|
||||
});
|
||||
|
||||
for (const albumArtist of albumArtists.Items) {
|
||||
const genresConnectOrCreate = albumArtist.Genres.map((genre) => {
|
||||
return { create: { name: genre }, where: { name: genre } };
|
||||
});
|
||||
|
||||
const imagesConnectOrCreate = [];
|
||||
for (const [key, value] of Object.entries(albumArtist.ImageTags)) {
|
||||
imagesConnectOrCreate.push({
|
||||
create: { name: key, url: value },
|
||||
where: { uniqueImageId: { name: key, url: value } },
|
||||
});
|
||||
}
|
||||
|
||||
const externalsConnectOrCreate = albumArtist.ExternalUrls.map(
|
||||
(external) => {
|
||||
return {
|
||||
create: { name: external.Name, url: external.Url },
|
||||
where: {
|
||||
uniqueExternalId: { name: external.Name, url: external.Url },
|
||||
},
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
await prisma.albumArtist.upsert({
|
||||
create: {
|
||||
biography: albumArtist.Overview,
|
||||
externals: { connectOrCreate: externalsConnectOrCreate },
|
||||
genres: { connectOrCreate: genresConnectOrCreate },
|
||||
images: { connectOrCreate: imagesConnectOrCreate },
|
||||
name: albumArtist.Name,
|
||||
remoteCreatedAt: albumArtist.DateCreated,
|
||||
remoteId: albumArtist.Id,
|
||||
serverFolders: { connect: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
},
|
||||
update: {
|
||||
biography: albumArtist.Overview,
|
||||
deleted: false,
|
||||
externals: { connectOrCreate: externalsConnectOrCreate },
|
||||
genres: { connectOrCreate: genresConnectOrCreate },
|
||||
images: { connectOrCreate: imagesConnectOrCreate },
|
||||
name: albumArtist.Name,
|
||||
remoteCreatedAt: albumArtist.DateCreated,
|
||||
remoteId: albumArtist.Id,
|
||||
serverFolders: { connect: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
},
|
||||
where: {
|
||||
uniqueAlbumArtistId: {
|
||||
remoteId: albumArtist.Id,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
return { task };
|
||||
},
|
||||
id: taskId,
|
||||
});
|
||||
};
|
||||
|
||||
const scanAlbums = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder,
|
||||
task: Task
|
||||
) => {
|
||||
const check = await jellyfinApi.getAlbums(server, {
|
||||
enableUserData: false,
|
||||
includeItemTypes: 'MusicAlbum',
|
||||
limit: 1,
|
||||
parentId: serverFolder.remoteId,
|
||||
recursive: true,
|
||||
});
|
||||
|
||||
const albumCount = check.TotalRecordCount;
|
||||
const chunkSize = 5000;
|
||||
const albumChunkCount = Math.ceil(albumCount / chunkSize);
|
||||
|
||||
const taskId = `(${task.id}) [${server.name} (${serverFolder.name})] albums`;
|
||||
|
||||
q.push({
|
||||
fn: async () => {
|
||||
await prisma.task.update({
|
||||
data: { message: 'Scanning albums' },
|
||||
where: { id: task.id },
|
||||
});
|
||||
|
||||
for (let i = 0; i < albumChunkCount; i += 1) {
|
||||
const albums = await jellyfinApi.getAlbums(server, {
|
||||
enableImageTypes: 'Primary,Logo,Backdrop',
|
||||
enableUserData: false,
|
||||
fields: 'Genres,DateCreated,ExternalUrls,Overview',
|
||||
imageTypeLimit: 1,
|
||||
limit: chunkSize,
|
||||
parentId: serverFolder.remoteId,
|
||||
recursive: true,
|
||||
startIndex: i * chunkSize,
|
||||
});
|
||||
|
||||
for (const album of albums.Items) {
|
||||
const genresConnectOrCreate = album.Genres.map((genre) => {
|
||||
return { create: { name: genre }, where: { name: genre } };
|
||||
});
|
||||
|
||||
const imagesConnectOrCreate = [];
|
||||
for (const [key, value] of Object.entries(album.ImageTags)) {
|
||||
imagesConnectOrCreate.push({
|
||||
create: { name: key, url: value },
|
||||
where: { uniqueImageId: { name: key, url: value } },
|
||||
});
|
||||
}
|
||||
|
||||
const externalsConnectOrCreate = album.ExternalUrls.map(
|
||||
(external) => {
|
||||
return {
|
||||
create: { name: external.Name, url: external.Url },
|
||||
where: {
|
||||
uniqueExternalId: { name: external.Name, url: external.Url },
|
||||
},
|
||||
};
|
||||
}
|
||||
);
|
||||
|
||||
const albumArtist =
|
||||
album.AlbumArtists.length > 0
|
||||
? await prisma.albumArtist.findUnique({
|
||||
where: {
|
||||
uniqueAlbumArtistId: {
|
||||
remoteId: album.AlbumArtists && album.AlbumArtists[0].Id,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
})
|
||||
: undefined;
|
||||
|
||||
await prisma.album.upsert({
|
||||
create: {
|
||||
albumArtistId: albumArtist?.id,
|
||||
date: album.PremiereDate,
|
||||
externals: { connectOrCreate: externalsConnectOrCreate },
|
||||
genres: { connectOrCreate: genresConnectOrCreate },
|
||||
images: { connectOrCreate: imagesConnectOrCreate },
|
||||
name: album.Name,
|
||||
remoteCreatedAt: album.DateCreated,
|
||||
remoteId: album.Id,
|
||||
serverFolders: { connect: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
year: album.ProductionYear,
|
||||
},
|
||||
update: {
|
||||
albumArtistId: albumArtist?.id,
|
||||
date: album.PremiereDate,
|
||||
deleted: false,
|
||||
externals: { connectOrCreate: externalsConnectOrCreate },
|
||||
genres: { connectOrCreate: genresConnectOrCreate },
|
||||
images: { connectOrCreate: imagesConnectOrCreate },
|
||||
name: album.Name,
|
||||
remoteCreatedAt: album.DateCreated,
|
||||
remoteId: album.Id,
|
||||
serverFolders: { connect: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
year: album.ProductionYear,
|
||||
},
|
||||
where: {
|
||||
uniqueAlbumId: {
|
||||
remoteId: album.Id,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
const currentTask = await prisma.task.findUnique({
|
||||
where: { id: task.id },
|
||||
});
|
||||
|
||||
const newCount =
|
||||
Number(currentTask?.progress || 0) + Number(albums.Items.length);
|
||||
|
||||
await prisma.task.update({
|
||||
data: { progress: String(newCount) },
|
||||
where: { id: task.id },
|
||||
});
|
||||
}
|
||||
|
||||
return { task };
|
||||
},
|
||||
id: taskId,
|
||||
});
|
||||
};
|
||||
|
||||
const insertSongGroup = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder,
|
||||
songs: JFSong[],
|
||||
remoteAlbumId: string
|
||||
) => {
|
||||
const songsUpsert = songs.map((song) => {
|
||||
const artistsConnectOrCreate = song.ArtistItems.map((artist) => {
|
||||
return {
|
||||
create: {
|
||||
name: artist.Name,
|
||||
remoteId: artist.Id,
|
||||
serverFolders: { connect: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
},
|
||||
where: {
|
||||
uniqueArtistId: {
|
||||
remoteId: artist.Id,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
const genresConnectOrCreate = song.Genres.map((genre) => {
|
||||
return { create: { name: genre }, where: { name: genre } };
|
||||
});
|
||||
|
||||
const imagesConnectOrCreate = [];
|
||||
for (const [key, value] of Object.entries(song.ImageTags)) {
|
||||
imagesConnectOrCreate.push({
|
||||
create: { name: key, url: value },
|
||||
where: { uniqueImageId: { name: key, url: value } },
|
||||
});
|
||||
}
|
||||
|
||||
const externalsConnectOrCreate = song.ExternalUrls.map((external) => {
|
||||
return {
|
||||
create: { name: external.Name, url: external.Url },
|
||||
where: {
|
||||
uniqueExternalId: { name: external.Name, url: external.Url },
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
const pathSplit = song.MediaSources[0].Path.split('/');
|
||||
const parentPath = pathSplit.slice(0, pathSplit.length - 1).join('/');
|
||||
|
||||
return {
|
||||
create: {
|
||||
artists: { connectOrCreate: artistsConnectOrCreate },
|
||||
bitRate: Math.floor(song.MediaSources[0].Bitrate / 1000),
|
||||
container: song.MediaSources[0].Container,
|
||||
date: song.PremiereDate,
|
||||
disc: song.ParentIndexNumber,
|
||||
duration: Math.floor(song.MediaSources[0].RunTimeTicks / 1e7),
|
||||
externals: { connectOrCreate: externalsConnectOrCreate },
|
||||
folders: {
|
||||
connect: {
|
||||
uniqueFolderId: { path: parentPath, serverId: server.id },
|
||||
},
|
||||
},
|
||||
genres: { connectOrCreate: genresConnectOrCreate },
|
||||
images: { connectOrCreate: imagesConnectOrCreate },
|
||||
name: song.Name,
|
||||
remoteCreatedAt: song.DateCreated,
|
||||
remoteId: song.Id,
|
||||
serverFolders: { connect: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
track: song.IndexNumber,
|
||||
year: song.ProductionYear,
|
||||
},
|
||||
update: {
|
||||
artists: { connectOrCreate: artistsConnectOrCreate },
|
||||
bitRate: Math.floor(song.MediaSources[0].Bitrate / 1000),
|
||||
container: song.MediaSources[0].Container,
|
||||
date: song.PremiereDate,
|
||||
disc: song.ParentIndexNumber,
|
||||
duration: Math.floor(song.MediaSources[0].RunTimeTicks / 1e7),
|
||||
externals: { connectOrCreate: externalsConnectOrCreate },
|
||||
folders: {
|
||||
connect: {
|
||||
uniqueFolderId: { path: parentPath, serverId: server.id },
|
||||
},
|
||||
},
|
||||
genres: { connectOrCreate: genresConnectOrCreate },
|
||||
images: { connectOrCreate: imagesConnectOrCreate },
|
||||
name: song.Name,
|
||||
remoteCreatedAt: song.DateCreated,
|
||||
remoteId: song.Id,
|
||||
serverFolders: { connect: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
track: song.IndexNumber,
|
||||
year: song.ProductionYear,
|
||||
},
|
||||
where: {
|
||||
uniqueSongId: {
|
||||
remoteId: song.Id,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
const artists = uniqBy(
|
||||
songs.flatMap((song) => {
|
||||
return song.ArtistItems.map((artist) => ({
|
||||
name: artist.Name,
|
||||
remoteId: artist.Id,
|
||||
serverFolders: { connect: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
}));
|
||||
}),
|
||||
'remoteId'
|
||||
);
|
||||
|
||||
const uniqueArtistIds = songs
|
||||
.flatMap((song) => {
|
||||
return song.ArtistItems.flatMap((artist) => artist.Id);
|
||||
})
|
||||
.filter(uniqueArray);
|
||||
|
||||
const artistsConnect = uniqueArtistIds.map((artistId) => {
|
||||
return {
|
||||
uniqueArtistId: {
|
||||
remoteId: artistId!,
|
||||
serverId: server.id,
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
artists.forEach(async (artist) => {
|
||||
await prisma.artist.upsert({
|
||||
create: artist,
|
||||
update: artist,
|
||||
where: {
|
||||
uniqueArtistId: {
|
||||
remoteId: artist.remoteId,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
await prisma.$transaction([
|
||||
prisma.artist.updateMany({
|
||||
data: { deleted: false },
|
||||
where: {
|
||||
remoteId: { in: uniqueArtistIds },
|
||||
serverId: server.id,
|
||||
},
|
||||
}),
|
||||
prisma.album.update({
|
||||
data: {
|
||||
artists: { connect: artistsConnect },
|
||||
deleted: false,
|
||||
songs: { upsert: songsUpsert },
|
||||
},
|
||||
where: {
|
||||
uniqueAlbumId: {
|
||||
remoteId: remoteAlbumId,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
}),
|
||||
]);
|
||||
};
|
||||
|
||||
const scanSongs = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder,
|
||||
task: Task
|
||||
) => {
|
||||
const check = await jellyfinApi.getSongs(server, {
|
||||
enableUserData: false,
|
||||
limit: 0,
|
||||
parentId: serverFolder.remoteId,
|
||||
recursive: true,
|
||||
});
|
||||
|
||||
// Fetch in chunks
|
||||
const songCount = check.TotalRecordCount;
|
||||
const chunkSize = 10000;
|
||||
const songChunkCount = Math.ceil(songCount / chunkSize);
|
||||
const taskId = `[${server.name} (${serverFolder.name})] songs`;
|
||||
|
||||
q.push({
|
||||
fn: async () => {
|
||||
await prisma.task.update({
|
||||
data: { message: 'Scanning songs' },
|
||||
where: { id: task.id },
|
||||
});
|
||||
|
||||
for (let i = 0; i < songChunkCount; i += 1) {
|
||||
const songs = await jellyfinApi.getSongs(server, {
|
||||
enableImageTypes: 'Primary,Logo,Backdrop',
|
||||
enableUserData: false,
|
||||
fields: 'Genres,DateCreated,ExternalUrls,MediaSources',
|
||||
imageTypeLimit: 1,
|
||||
limit: chunkSize,
|
||||
parentId: serverFolder.remoteId,
|
||||
recursive: true,
|
||||
sortBy: 'DateCreated,Album',
|
||||
sortOrder: 'Descending',
|
||||
startIndex: i * chunkSize,
|
||||
});
|
||||
|
||||
const folderGroups = songs.Items.map((song) => {
|
||||
const songPaths = song.MediaSources[0].Path.split('/');
|
||||
const paths = [];
|
||||
for (let b = 0; b < songPaths.length - 1; b += 1) {
|
||||
paths.push({
|
||||
name: songPaths[b],
|
||||
path: songPaths.slice(0, b + 1).join('/'),
|
||||
});
|
||||
}
|
||||
|
||||
return paths;
|
||||
});
|
||||
|
||||
const uniqueFolders = uniqBy(
|
||||
folderGroups.flatMap((folder) => folder).filter((f) => f.path !== ''),
|
||||
'path'
|
||||
);
|
||||
|
||||
const folderSave: any[] = [];
|
||||
|
||||
for (let f = 0; f < uniqueFolders.length; f += 1) {
|
||||
const t = await prisma.folder.upsert({
|
||||
create: {
|
||||
name: uniqueFolders[f].name,
|
||||
path: uniqueFolders[f].path,
|
||||
serverFolders: {
|
||||
connect: {
|
||||
uniqueServerFolderId: {
|
||||
remoteId: serverFolder.remoteId,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
},
|
||||
serverId: server.id,
|
||||
},
|
||||
update: {
|
||||
name: uniqueFolders[f].name,
|
||||
path: uniqueFolders[f].path,
|
||||
serverFolders: {
|
||||
connect: {
|
||||
uniqueServerFolderId: {
|
||||
remoteId: serverFolder.remoteId,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
where: {
|
||||
uniqueFolderId: {
|
||||
path: uniqueFolders[f].path,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
folderSave.push(t);
|
||||
}
|
||||
|
||||
folderSave.forEach(async (f) => {
|
||||
if (f.parentId) return;
|
||||
|
||||
const pathSplit = f.path.split('/');
|
||||
const parentPath = pathSplit.slice(0, pathSplit.length - 1).join('/');
|
||||
|
||||
const parentPathData = folderSave.find(
|
||||
(save) => save.path === parentPath
|
||||
);
|
||||
|
||||
if (parentPathData) {
|
||||
await prisma.folder.update({
|
||||
data: {
|
||||
parentId: parentPathData.id,
|
||||
},
|
||||
where: { id: f.id },
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
const albumSongGroups = groupByProperty(songs.Items, 'AlbumId');
|
||||
|
||||
const keys = Object.keys(albumSongGroups);
|
||||
|
||||
for (let b = 0; b < keys.length; b += 1) {
|
||||
const songGroup = albumSongGroups[keys[b]];
|
||||
await insertSongGroup(server, serverFolder, songGroup, keys[b]);
|
||||
|
||||
const currentTask = await prisma.task.findUnique({
|
||||
where: { id: task.id },
|
||||
});
|
||||
|
||||
const newCount =
|
||||
Number(currentTask?.progress || 0) + Number(songGroup.length);
|
||||
|
||||
await prisma.task.update({
|
||||
data: { progress: String(newCount) },
|
||||
where: { id: task.id },
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return { completed: true, task };
|
||||
},
|
||||
id: taskId,
|
||||
});
|
||||
};
|
||||
|
||||
const checkDeleted = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder,
|
||||
task: Task
|
||||
) => {
|
||||
q.push({
|
||||
fn: async () => {
|
||||
await prisma.$transaction([
|
||||
prisma.albumArtist.updateMany({
|
||||
data: { deleted: true },
|
||||
where: {
|
||||
serverFolders: { some: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
updatedAt: { lte: task.createdAt },
|
||||
},
|
||||
}),
|
||||
prisma.artist.updateMany({
|
||||
data: { deleted: true },
|
||||
where: {
|
||||
serverFolders: { some: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
updatedAt: { lte: task.createdAt },
|
||||
},
|
||||
}),
|
||||
prisma.album.updateMany({
|
||||
data: { deleted: true },
|
||||
where: {
|
||||
serverFolders: { some: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
updatedAt: { lte: task.createdAt },
|
||||
},
|
||||
}),
|
||||
prisma.song.updateMany({
|
||||
data: { deleted: true },
|
||||
where: {
|
||||
serverFolders: { some: { id: serverFolder.id } },
|
||||
serverId: server.id,
|
||||
updatedAt: { lte: task.createdAt },
|
||||
},
|
||||
}),
|
||||
]);
|
||||
},
|
||||
id: `${task.id}-difference`,
|
||||
});
|
||||
};
|
||||
|
||||
const scanAll = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder,
|
||||
task: Task
|
||||
) => {
|
||||
await scanGenres(server, serverFolder, task);
|
||||
await scanAlbumArtists(server, serverFolder, task);
|
||||
await scanAlbums(server, serverFolder, task);
|
||||
await scanSongs(server, serverFolder, task);
|
||||
await checkDeleted(server, serverFolder, task);
|
||||
await completeTask(task);
|
||||
};
|
||||
|
||||
export const jellyfinTasks = {
|
||||
scanAlbumArtists,
|
||||
scanAlbums,
|
||||
scanAll,
|
||||
scanGenres,
|
||||
scanSongs,
|
||||
};
|
||||
@@ -0,0 +1,263 @@
|
||||
export interface JFBaseResponse {
|
||||
StartIndex: number;
|
||||
TotalRecordCount: number;
|
||||
}
|
||||
|
||||
export interface JFMusicFoldersResponse extends JFBaseResponse {
|
||||
Items: JFMusicFolder[];
|
||||
}
|
||||
|
||||
export interface JFGenreResponse extends JFBaseResponse {
|
||||
Items: JFGenre[];
|
||||
}
|
||||
|
||||
export interface JFAlbumArtistsResponse extends JFBaseResponse {
|
||||
Items: JFAlbumArtist[];
|
||||
}
|
||||
|
||||
export interface JFArtistsResponse extends JFBaseResponse {
|
||||
Items: JFAlbumArtist[];
|
||||
}
|
||||
|
||||
export interface JFAlbumsResponse extends JFBaseResponse {
|
||||
Items: JFAlbum[];
|
||||
}
|
||||
|
||||
export interface JFSongsResponse extends JFBaseResponse {
|
||||
Items: JFSong[];
|
||||
}
|
||||
|
||||
export interface JFRequestParams {
|
||||
albumArtistIds?: string;
|
||||
artistIds?: string;
|
||||
enableImageTypes?: string;
|
||||
enableTotalRecordCount?: boolean;
|
||||
enableUserData?: boolean;
|
||||
excludeItemTypes?: string;
|
||||
fields?: string;
|
||||
imageTypeLimit?: number;
|
||||
includeItemTypes?: string;
|
||||
isFavorite?: boolean;
|
||||
limit?: number;
|
||||
parentId?: string;
|
||||
recursive?: boolean;
|
||||
searchTerm?: string;
|
||||
sortBy?: string;
|
||||
sortOrder?: 'Ascending' | 'Descending';
|
||||
startIndex?: number;
|
||||
userId?: string;
|
||||
}
|
||||
|
||||
export interface JFMusicFolder {
|
||||
BackdropImageTags: any[];
|
||||
ChannelId: null;
|
||||
CollectionType: string;
|
||||
Id: string;
|
||||
ImageBlurHashes: ImageBlurHashes;
|
||||
ImageTags: ImageTags;
|
||||
IsFolder: boolean;
|
||||
LocationType: string;
|
||||
Name: string;
|
||||
ServerId: string;
|
||||
Type: string;
|
||||
UserData: UserData;
|
||||
}
|
||||
|
||||
export interface JFGenre {
|
||||
BackdropImageTags: any[];
|
||||
ChannelId: null;
|
||||
Id: string;
|
||||
ImageBlurHashes: any;
|
||||
ImageTags: any;
|
||||
LocationType: string;
|
||||
Name: string;
|
||||
ServerId: string;
|
||||
Type: string;
|
||||
}
|
||||
|
||||
export interface JFAlbumArtist {
|
||||
BackdropImageTags: string[];
|
||||
ChannelId: null;
|
||||
DateCreated: string;
|
||||
ExternalUrls: ExternalURL[];
|
||||
GenreItems: GenreItem[];
|
||||
Genres: string[];
|
||||
Id: string;
|
||||
ImageBlurHashes: any;
|
||||
ImageTags: string[];
|
||||
LocationType: string;
|
||||
Name: string;
|
||||
Overview?: string;
|
||||
RunTimeTicks: number;
|
||||
ServerId: string;
|
||||
Type: string;
|
||||
}
|
||||
|
||||
export interface JFArtist {
|
||||
BackdropImageTags: string[];
|
||||
ChannelId: null;
|
||||
DateCreated: string;
|
||||
ExternalUrls: ExternalURL[];
|
||||
GenreItems: GenreItem[];
|
||||
Genres: string[];
|
||||
Id: string;
|
||||
ImageBlurHashes: any;
|
||||
ImageTags: string[];
|
||||
LocationType: string;
|
||||
Name: string;
|
||||
Overview?: string;
|
||||
RunTimeTicks: number;
|
||||
ServerId: string;
|
||||
Type: string;
|
||||
}
|
||||
|
||||
export interface JFAlbum {
|
||||
AlbumArtist: string;
|
||||
AlbumArtists: GenericItem[];
|
||||
ArtistItems: GenericItem[];
|
||||
Artists: string[];
|
||||
ChannelId: null;
|
||||
DateCreated: string;
|
||||
ExternalUrls: ExternalURL[];
|
||||
GenreItems: GenericItem[];
|
||||
Genres: string[];
|
||||
Id: string;
|
||||
ImageBlurHashes: ImageBlurHashes;
|
||||
ImageTags: ImageTags;
|
||||
IsFolder: boolean;
|
||||
LocationType: string;
|
||||
Name: string;
|
||||
ParentLogoImageTag: string;
|
||||
ParentLogoItemId: string;
|
||||
PremiereDate?: string;
|
||||
ProductionYear: number;
|
||||
RunTimeTicks: number;
|
||||
ServerId: string;
|
||||
Type: string;
|
||||
}
|
||||
|
||||
export interface JFSong {
|
||||
Album: string;
|
||||
AlbumArtist: string;
|
||||
AlbumArtists: GenericItem[];
|
||||
AlbumId: string;
|
||||
AlbumPrimaryImageTag: string;
|
||||
ArtistItems: GenericItem[];
|
||||
Artists: string[];
|
||||
BackdropImageTags: string[];
|
||||
ChannelId: null;
|
||||
DateCreated: string;
|
||||
ExternalUrls: ExternalURL[];
|
||||
GenreItems: GenericItem[];
|
||||
Genres: string[];
|
||||
Id: string;
|
||||
ImageBlurHashes: ImageBlurHashes;
|
||||
ImageTags: ImageTags;
|
||||
IndexNumber: number;
|
||||
IsFolder: boolean;
|
||||
LocationType: string;
|
||||
MediaSources: MediaSources[];
|
||||
MediaType: string;
|
||||
Name: string;
|
||||
ParentIndexNumber: number;
|
||||
PremiereDate?: string;
|
||||
ProductionYear: number;
|
||||
RunTimeTicks: number;
|
||||
ServerId: string;
|
||||
Type: string;
|
||||
}
|
||||
|
||||
interface ImageBlurHashes {
|
||||
Backdrop?: any;
|
||||
Logo?: any;
|
||||
Primary?: any;
|
||||
}
|
||||
|
||||
interface ImageTags {
|
||||
Logo?: string;
|
||||
Primary?: string;
|
||||
}
|
||||
|
||||
interface UserData {
|
||||
IsFavorite: boolean;
|
||||
Key: string;
|
||||
PlayCount: number;
|
||||
PlaybackPositionTicks: number;
|
||||
Played: boolean;
|
||||
}
|
||||
|
||||
interface ExternalURL {
|
||||
Name: string;
|
||||
Url: string;
|
||||
}
|
||||
|
||||
interface GenreItem {
|
||||
Id: string;
|
||||
Name: string;
|
||||
}
|
||||
|
||||
interface GenericItem {
|
||||
Id: string;
|
||||
Name: string;
|
||||
}
|
||||
|
||||
interface MediaSources {
|
||||
Bitrate: number;
|
||||
Container: string;
|
||||
DefaultAudioStreamIndex: number;
|
||||
ETag: string;
|
||||
Formats: any[];
|
||||
GenPtsInput: boolean;
|
||||
Id: string;
|
||||
IgnoreDts: boolean;
|
||||
IgnoreIndex: boolean;
|
||||
IsInfiniteStream: boolean;
|
||||
IsRemote: boolean;
|
||||
MediaAttachments: any[];
|
||||
MediaStreams: MediaStream[];
|
||||
Name: string;
|
||||
Path: string;
|
||||
Protocol: string;
|
||||
ReadAtNativeFramerate: boolean;
|
||||
RequiredHttpHeaders: any;
|
||||
RequiresClosing: boolean;
|
||||
RequiresLooping: boolean;
|
||||
RequiresOpening: boolean;
|
||||
RunTimeTicks: number;
|
||||
Size: number;
|
||||
SupportsDirectPlay: boolean;
|
||||
SupportsDirectStream: boolean;
|
||||
SupportsProbing: boolean;
|
||||
SupportsTranscoding: boolean;
|
||||
Type: string;
|
||||
}
|
||||
|
||||
interface MediaStream {
|
||||
AspectRatio?: string;
|
||||
BitDepth?: number;
|
||||
BitRate?: number;
|
||||
ChannelLayout?: string;
|
||||
Channels?: number;
|
||||
Codec: string;
|
||||
CodecTimeBase: string;
|
||||
ColorSpace?: string;
|
||||
Comment?: string;
|
||||
DisplayTitle?: string;
|
||||
Height?: number;
|
||||
Index: number;
|
||||
IsDefault: boolean;
|
||||
IsExternal: boolean;
|
||||
IsForced: boolean;
|
||||
IsInterlaced: boolean;
|
||||
IsTextSubtitleStream: boolean;
|
||||
Level: number;
|
||||
PixelFormat?: string;
|
||||
Profile?: string;
|
||||
RealFrameRate?: number;
|
||||
RefFrames?: number;
|
||||
SampleRate?: number;
|
||||
SupportsExternalStream: boolean;
|
||||
TimeBase: string;
|
||||
Type: string;
|
||||
Width?: number;
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
import Queue from 'better-queue';
|
||||
import { prisma } from '../lib';
|
||||
import { Task } from '../types/types';
|
||||
|
||||
interface QueueTask {
|
||||
fn: any;
|
||||
id: string;
|
||||
task: Task;
|
||||
}
|
||||
|
||||
// interface QueueResult {
|
||||
// completed?: boolean;
|
||||
// message?: string;
|
||||
// task: Task;
|
||||
// }
|
||||
|
||||
export const q: Queue = new Queue(
|
||||
async (task: QueueTask, cb: any) => {
|
||||
const result = await task.fn();
|
||||
return cb(null, result);
|
||||
},
|
||||
{
|
||||
afterProcessDelay: 1000,
|
||||
cancelIfRunning: true,
|
||||
concurrent: 1,
|
||||
filo: false,
|
||||
maxRetries: 5,
|
||||
maxTimeout: 600000,
|
||||
retryDelay: 2000,
|
||||
}
|
||||
);
|
||||
|
||||
// q.on('task_finish', async (_taskId, result: QueueResult) => {});
|
||||
|
||||
q.on('task_failed', async (taskId, errorMessage) => {
|
||||
const dbTaskId = taskId.split('(')[1].split(')')[0];
|
||||
await prisma.task.update({
|
||||
data: {
|
||||
completed: true,
|
||||
inProgress: false,
|
||||
isError: true,
|
||||
message: errorMessage,
|
||||
},
|
||||
where: { id: dbTaskId },
|
||||
});
|
||||
});
|
||||
|
||||
q.on('drain', async () => {
|
||||
await prisma.task.updateMany({
|
||||
data: { completed: true, inProgress: false },
|
||||
where: {
|
||||
OR: [{ inProgress: true }, { completed: false }],
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
export const completeTask = async (task: Task) => {
|
||||
q.push({
|
||||
fn: async () => {
|
||||
await prisma.task.update({
|
||||
data: {
|
||||
completed: true,
|
||||
inProgress: false,
|
||||
message: 'Completed',
|
||||
progress: '',
|
||||
},
|
||||
where: { id: task.id },
|
||||
});
|
||||
|
||||
return { task };
|
||||
},
|
||||
id: `${task.id}-complete`,
|
||||
});
|
||||
};
|
||||
@@ -0,0 +1,129 @@
|
||||
import axios from 'axios';
|
||||
import { Server } from '../../types/types';
|
||||
import {
|
||||
SSAlbumListEntry,
|
||||
SSAlbumListResponse,
|
||||
SSAlbumResponse,
|
||||
SSAlbumsParams,
|
||||
SSArtistIndex,
|
||||
SSArtistInfoResponse,
|
||||
SSArtistsResponse,
|
||||
SSGenresResponse,
|
||||
SSMusicFoldersResponse,
|
||||
} from './subsonic-types';
|
||||
|
||||
const api = axios.create({
|
||||
validateStatus: (status) => status >= 200,
|
||||
});
|
||||
|
||||
api.interceptors.response.use(
|
||||
(res: any) => {
|
||||
res.data = res.data['subsonic-response'];
|
||||
return res;
|
||||
},
|
||||
(err: any) => {
|
||||
return Promise.reject(err);
|
||||
}
|
||||
);
|
||||
|
||||
const getMusicFolders = async (server: Partial<Server>) => {
|
||||
const { data } = await api.get<SSMusicFoldersResponse>(
|
||||
`${server.url}/rest/getMusicFolders.view?v=1.13.0&c=sonixd&f=json&${server.token}`
|
||||
);
|
||||
|
||||
return data.musicFolders.musicFolder;
|
||||
};
|
||||
|
||||
const getArtists = async (server: Server, musicFolderId: string) => {
|
||||
const { data } = await api.get<SSArtistsResponse>(
|
||||
`${server.url}/rest/getArtists.view?v=1.13.0&c=sonixd&f=json&${server.token}`,
|
||||
{ params: { musicFolderId } }
|
||||
);
|
||||
|
||||
const artists = (data.artists?.index || []).flatMap(
|
||||
(index: SSArtistIndex) => index.artist
|
||||
);
|
||||
|
||||
return artists;
|
||||
};
|
||||
|
||||
const getGenres = async (server: Server) => {
|
||||
const { data: genres } = await api.get<SSGenresResponse>(
|
||||
`${server.url}/rest/getGenres.view?v=1.13.0&c=sonixd&f=json&${server.token}`
|
||||
);
|
||||
|
||||
return genres;
|
||||
};
|
||||
|
||||
const getAlbum = async (server: Server, id: string) => {
|
||||
const { data: album } = await api.get<SSAlbumResponse>(
|
||||
`${server.url}/rest/getAlbum.view?v=1.13.0&c=sonixd&f=json&${server.token}`,
|
||||
{ params: { id } }
|
||||
);
|
||||
|
||||
return album;
|
||||
};
|
||||
|
||||
const getAlbums = async (
|
||||
server: Server,
|
||||
params: SSAlbumsParams,
|
||||
recursiveData: any[] = []
|
||||
) => {
|
||||
const albums: any = api
|
||||
.get<SSAlbumListResponse>(
|
||||
`${server.url}/rest/getAlbumList2.view?v=1.13.0&c=sonixd&f=json&${server.token}`,
|
||||
{ params }
|
||||
)
|
||||
.then((res) => {
|
||||
if (
|
||||
!res.data.albumList2.album ||
|
||||
res.data.albumList2.album.length === 0
|
||||
) {
|
||||
// Flatten and return once there are no more albums left
|
||||
return recursiveData.flatMap((album) => album);
|
||||
}
|
||||
|
||||
// On every iteration, push the existing combined album array and increase the offset
|
||||
recursiveData.push(res.data.albumList2.album);
|
||||
return getAlbums(
|
||||
server,
|
||||
{
|
||||
musicFolderId: params.musicFolderId,
|
||||
offset: (params.offset || 0) + (params.size || 0),
|
||||
size: params.size,
|
||||
type: 'newest',
|
||||
},
|
||||
|
||||
recursiveData
|
||||
);
|
||||
})
|
||||
.catch((err) => console.log(err));
|
||||
|
||||
return albums as SSAlbumListEntry[];
|
||||
};
|
||||
|
||||
const getArtistInfo = async (server: Server, id: string) => {
|
||||
const { data: artistInfo } = await api.get<SSArtistInfoResponse>(
|
||||
`${server.url}/rest/getArtistInfo2.view?v=1.13.0&c=sonixd&f=json&${server.token}`,
|
||||
{ params: { id } }
|
||||
);
|
||||
|
||||
return {
|
||||
...artistInfo,
|
||||
artistInfo2: {
|
||||
...artistInfo.artistInfo2,
|
||||
biography: artistInfo.artistInfo2.biography
|
||||
.replaceAll(/<a target.*<\/a>/gm, '')
|
||||
.replace('Biography not available', ''),
|
||||
},
|
||||
};
|
||||
};
|
||||
|
||||
export const subsonicApi = {
|
||||
getAlbum,
|
||||
getAlbums,
|
||||
getArtistInfo,
|
||||
getArtists,
|
||||
getGenres,
|
||||
getMusicFolders,
|
||||
};
|
||||
@@ -0,0 +1,462 @@
|
||||
/* eslint-disable no-await-in-loop */
|
||||
import { prisma, throttle } from '../../lib';
|
||||
import { Server, ServerFolder, Task } from '../../types/types';
|
||||
import { groupByProperty, uniqueArray } from '../../utils';
|
||||
import { completeTask, q } from '../scanner-queue';
|
||||
import { subsonicApi } from './subsonic-api';
|
||||
import { SSAlbumListEntry } from './subsonic-types';
|
||||
|
||||
export const scanGenres = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder
|
||||
) => {
|
||||
const taskId = `[${server.name} (${serverFolder.name})] genres`;
|
||||
|
||||
q.push({
|
||||
fn: async () => {
|
||||
const task = await prisma.task.create({
|
||||
data: {
|
||||
inProgress: true,
|
||||
name: taskId,
|
||||
serverFolderId: serverFolder.id,
|
||||
},
|
||||
});
|
||||
|
||||
const res = await subsonicApi.getGenres(server);
|
||||
|
||||
const genres = res.genres.genre.map((genre) => {
|
||||
return { name: genre.value };
|
||||
});
|
||||
|
||||
const createdGenres = await prisma.genre.createMany({
|
||||
data: genres,
|
||||
skipDuplicates: true,
|
||||
});
|
||||
|
||||
const message = `Imported ${createdGenres.count} new genres.`;
|
||||
|
||||
return { message, task };
|
||||
},
|
||||
id: taskId,
|
||||
});
|
||||
};
|
||||
|
||||
export const scanAlbumArtists = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder
|
||||
) => {
|
||||
const taskId = `[${server.name} (${serverFolder.name})] album artists`;
|
||||
|
||||
q.push({
|
||||
fn: async () => {
|
||||
const task = await prisma.task.create({
|
||||
data: {
|
||||
inProgress: true,
|
||||
name: taskId,
|
||||
serverFolderId: serverFolder.id,
|
||||
},
|
||||
});
|
||||
|
||||
const artists = await subsonicApi.getArtists(
|
||||
server,
|
||||
serverFolder.remoteId
|
||||
);
|
||||
|
||||
for (const artist of artists) {
|
||||
await prisma.albumArtist.upsert({
|
||||
create: {
|
||||
name: artist.name,
|
||||
remoteId: artist.id,
|
||||
serverId: server.id,
|
||||
},
|
||||
update: {
|
||||
name: artist.name,
|
||||
remoteId: artist.id,
|
||||
serverId: server.id,
|
||||
},
|
||||
where: {
|
||||
uniqueAlbumArtistId: {
|
||||
remoteId: artist.id,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
await prisma.artist.upsert({
|
||||
create: {
|
||||
name: artist.name,
|
||||
remoteId: artist.id,
|
||||
serverId: server.id,
|
||||
},
|
||||
update: {
|
||||
name: artist.name,
|
||||
remoteId: artist.id,
|
||||
serverId: server.id,
|
||||
},
|
||||
where: {
|
||||
uniqueArtistId: {
|
||||
remoteId: artist.id,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
const message = `Scanned ${artists.length} album artists.`;
|
||||
|
||||
return { message, task };
|
||||
},
|
||||
id: taskId,
|
||||
});
|
||||
};
|
||||
|
||||
export const scanAlbums = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder
|
||||
) => {
|
||||
const taskId = `[${server.name} (${serverFolder.name})] albums`;
|
||||
|
||||
q.push({
|
||||
fn: async () => {
|
||||
const task = await prisma.task.create({
|
||||
data: {
|
||||
inProgress: true,
|
||||
name: taskId,
|
||||
serverFolderId: serverFolder.id,
|
||||
},
|
||||
});
|
||||
|
||||
const promises: any[] = [];
|
||||
const albums = await subsonicApi.getAlbums(server, {
|
||||
musicFolderId: serverFolder.id,
|
||||
offset: 0,
|
||||
size: 500,
|
||||
type: 'newest',
|
||||
});
|
||||
|
||||
const albumArtistGroups = groupByProperty(albums, 'artistId');
|
||||
|
||||
const addAlbums = async (
|
||||
a: SSAlbumListEntry[],
|
||||
albumArtistRemoteId: string
|
||||
) => {
|
||||
const albumArtist = await prisma.albumArtist.findUnique({
|
||||
where: {
|
||||
uniqueAlbumArtistId: {
|
||||
remoteId: albumArtistRemoteId,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
if (albumArtist) {
|
||||
a.forEach(async (album) => {
|
||||
const imagesConnectOrCreate = album.coverArt
|
||||
? {
|
||||
create: { name: 'Primary', url: album.coverArt },
|
||||
where: {
|
||||
uniqueImageId: { name: 'Primary', url: album.coverArt },
|
||||
},
|
||||
}
|
||||
: [];
|
||||
|
||||
await prisma.album.upsert({
|
||||
create: {
|
||||
albumArtistId: albumArtist.id,
|
||||
images: { connectOrCreate: imagesConnectOrCreate },
|
||||
name: album.title,
|
||||
remoteCreatedAt: album.created,
|
||||
remoteId: album.id,
|
||||
serverId: server.id,
|
||||
year: album.year,
|
||||
},
|
||||
update: {
|
||||
albumArtistId: albumArtist.id,
|
||||
images: { connectOrCreate: imagesConnectOrCreate },
|
||||
name: album.title,
|
||||
remoteCreatedAt: album.created,
|
||||
remoteId: album.id,
|
||||
serverId: server.id,
|
||||
year: album.year,
|
||||
},
|
||||
where: {
|
||||
uniqueAlbumId: {
|
||||
remoteId: album.id,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
});
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
Object.keys(albumArtistGroups).forEach((key) => {
|
||||
promises.push(addAlbums(albumArtistGroups[key], key));
|
||||
});
|
||||
|
||||
await Promise.all(promises);
|
||||
|
||||
const message = `Scanned ${albums.length} albums.`;
|
||||
|
||||
return { message, task };
|
||||
},
|
||||
id: taskId,
|
||||
});
|
||||
};
|
||||
|
||||
const throttledAlbumFetch = throttle(
|
||||
async (server: Server, serverFolder: ServerFolder, album: any, i: number) => {
|
||||
const albumRes = await subsonicApi.getAlbum(server, album.remoteId);
|
||||
|
||||
console.log('fetch', i);
|
||||
|
||||
if (albumRes) {
|
||||
const songsUpsert = albumRes.album.song.map((song) => {
|
||||
const genresConnectOrCreate = song.genre
|
||||
? {
|
||||
create: { name: song.genre },
|
||||
where: { name: song.genre },
|
||||
}
|
||||
: [];
|
||||
|
||||
const imagesConnectOrCreate = song.coverArt
|
||||
? {
|
||||
create: { name: 'Primary', url: song.coverArt },
|
||||
where: { uniqueImageId: { name: 'Primary', url: song.coverArt } },
|
||||
}
|
||||
: [];
|
||||
|
||||
const artistsConnect = song.artistId
|
||||
? {
|
||||
uniqueArtistId: {
|
||||
remoteId: song.artistId,
|
||||
serverId: server.id,
|
||||
},
|
||||
}
|
||||
: [];
|
||||
|
||||
return {
|
||||
create: {
|
||||
artistName: !song.artistId ? song.artist : undefined,
|
||||
artists: { connect: artistsConnect },
|
||||
bitRate: song.bitRate,
|
||||
container: song.suffix,
|
||||
disc: song.discNumber,
|
||||
duration: song.duration,
|
||||
genres: { connectOrCreate: genresConnectOrCreate },
|
||||
images: { connectOrCreate: imagesConnectOrCreate },
|
||||
name: song.title,
|
||||
remoteCreatedAt: song.created,
|
||||
remoteId: song.id,
|
||||
serverId: server.id,
|
||||
track: song.track,
|
||||
year: song.year,
|
||||
},
|
||||
update: {
|
||||
artistName: !song.artistId ? song.artist : undefined,
|
||||
artists: { connect: artistsConnect },
|
||||
bitRate: song.bitRate,
|
||||
container: song.suffix,
|
||||
disc: song.discNumber,
|
||||
duration: song.duration,
|
||||
genres: { connectOrCreate: genresConnectOrCreate },
|
||||
images: { connectOrCreate: imagesConnectOrCreate },
|
||||
name: song.title,
|
||||
remoteCreatedAt: song.created,
|
||||
remoteId: song.id,
|
||||
track: song.track,
|
||||
year: song.year,
|
||||
},
|
||||
where: {
|
||||
uniqueSongId: {
|
||||
remoteId: song.id,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
const uniqueArtistIds = albumRes.album.song
|
||||
.map((song) => song.artistId)
|
||||
.filter(uniqueArray);
|
||||
|
||||
const artistsConnect = uniqueArtistIds.map((artistId) => {
|
||||
return {
|
||||
uniqueArtistId: {
|
||||
remoteId: artistId!,
|
||||
serverId: server.id,
|
||||
},
|
||||
};
|
||||
});
|
||||
|
||||
try {
|
||||
await prisma.album.update({
|
||||
data: {
|
||||
artists: { connect: artistsConnect },
|
||||
songs: { upsert: songsUpsert },
|
||||
},
|
||||
where: {
|
||||
uniqueAlbumId: {
|
||||
remoteId: albumRes.album.id,
|
||||
serverId: server.id,
|
||||
},
|
||||
},
|
||||
});
|
||||
} catch (err) {
|
||||
console.log(err);
|
||||
}
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
export const scanAlbumDetail = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder
|
||||
) => {
|
||||
const taskId = `[${server.name} (${serverFolder.name})] albums detail`;
|
||||
|
||||
q.push({
|
||||
fn: async () => {
|
||||
const task = await prisma.task.create({
|
||||
data: {
|
||||
inProgress: true,
|
||||
name: taskId,
|
||||
serverFolderId: serverFolder.id,
|
||||
},
|
||||
});
|
||||
|
||||
const promises = [];
|
||||
const dbAlbums = await prisma.album.findMany({
|
||||
where: {
|
||||
serverId: server.id,
|
||||
},
|
||||
});
|
||||
|
||||
for (let i = 0; i < dbAlbums.length; i += 1) {
|
||||
promises.push(
|
||||
throttledAlbumFetch(server, serverFolder, dbAlbums[i], i)
|
||||
);
|
||||
}
|
||||
|
||||
await Promise.all(promises);
|
||||
const message = `Scanned ${dbAlbums.length} albums.`;
|
||||
|
||||
return { message, task };
|
||||
},
|
||||
id: taskId,
|
||||
});
|
||||
};
|
||||
|
||||
const throttledArtistDetailFetch = throttle(
|
||||
async (
|
||||
server: Server,
|
||||
artistId: number,
|
||||
artistRemoteId: string,
|
||||
i: number
|
||||
) => {
|
||||
console.log('artisdetail', i);
|
||||
|
||||
const artistInfo = await subsonicApi.getArtistInfo(server, artistRemoteId);
|
||||
|
||||
const externalsConnectOrCreate = [];
|
||||
if (artistInfo.artistInfo2.lastFmUrl) {
|
||||
externalsConnectOrCreate.push({
|
||||
create: {
|
||||
name: 'Last.fm',
|
||||
url: artistInfo.artistInfo2.lastFmUrl,
|
||||
},
|
||||
where: {
|
||||
uniqueExternalId: {
|
||||
name: 'Last.fm',
|
||||
url: artistInfo.artistInfo2.lastFmUrl,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
if (artistInfo.artistInfo2.musicBrainzId) {
|
||||
externalsConnectOrCreate.push({
|
||||
create: {
|
||||
name: 'MusicBrainz',
|
||||
url: `https://musicbrainz.org/artist/${artistInfo.artistInfo2.musicBrainzId}`,
|
||||
},
|
||||
where: {
|
||||
uniqueExternalId: {
|
||||
name: 'MusicBrainz',
|
||||
url: `https://musicbrainz.org/artist/${artistInfo.artistInfo2.musicBrainzId}`,
|
||||
},
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
try {
|
||||
await prisma.albumArtist.update({
|
||||
data: {
|
||||
biography: artistInfo.artistInfo2.biography,
|
||||
externals: { connectOrCreate: externalsConnectOrCreate },
|
||||
},
|
||||
where: { id: artistId },
|
||||
});
|
||||
} catch (err) {
|
||||
console.log(err);
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
export const scanAlbumArtistDetail = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder
|
||||
) => {
|
||||
const taskId = `[${server.name} (${serverFolder.name})] artists detail`;
|
||||
|
||||
q.push({
|
||||
fn: async () => {
|
||||
const task = await prisma.task.create({
|
||||
data: {
|
||||
inProgress: true,
|
||||
name: taskId,
|
||||
serverFolderId: serverFolder.id,
|
||||
},
|
||||
});
|
||||
|
||||
const promises = [];
|
||||
const dbArtists = await prisma.albumArtist.findMany({
|
||||
where: {
|
||||
serverId: server.id,
|
||||
},
|
||||
});
|
||||
|
||||
for (let i = 0; i < dbArtists.length; i += 1) {
|
||||
promises.push(
|
||||
throttledArtistDetailFetch(
|
||||
server,
|
||||
dbArtists[i].id,
|
||||
dbArtists[i].remoteId,
|
||||
i
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
return { task };
|
||||
},
|
||||
id: taskId,
|
||||
});
|
||||
};
|
||||
|
||||
const scanAll = async (
|
||||
server: Server,
|
||||
serverFolder: ServerFolder,
|
||||
task: Task
|
||||
) => {
|
||||
await scanGenres(server, serverFolder);
|
||||
await scanAlbumArtists(server, serverFolder);
|
||||
await scanAlbumArtistDetail(server, serverFolder);
|
||||
await scanAlbums(server, serverFolder);
|
||||
await scanAlbumDetail(server, serverFolder);
|
||||
await completeTask(task);
|
||||
};
|
||||
|
||||
export const subsonicTasks = {
|
||||
scanAll,
|
||||
scanGenres,
|
||||
};
|
||||
@@ -0,0 +1,139 @@
|
||||
export interface SSBaseResponse {
|
||||
serverVersion?: 'string';
|
||||
status: 'string';
|
||||
type?: 'string';
|
||||
version: 'string';
|
||||
}
|
||||
|
||||
export interface SSMusicFoldersResponse extends SSBaseResponse {
|
||||
musicFolders: {
|
||||
musicFolder: SSMusicFolder[];
|
||||
};
|
||||
}
|
||||
|
||||
export interface SSGenresResponse extends SSBaseResponse {
|
||||
genres: {
|
||||
genre: SSGenre[];
|
||||
};
|
||||
}
|
||||
|
||||
export interface SSArtistsResponse extends SSBaseResponse {
|
||||
artists: {
|
||||
ignoredArticles: string;
|
||||
index: SSArtistIndex[];
|
||||
lastModified: number;
|
||||
};
|
||||
}
|
||||
|
||||
export interface SSAlbumListResponse extends SSBaseResponse {
|
||||
albumList2: {
|
||||
album: SSAlbumListEntry[];
|
||||
};
|
||||
}
|
||||
|
||||
export interface SSAlbumResponse extends SSBaseResponse {
|
||||
album: SSAlbum;
|
||||
}
|
||||
|
||||
export interface SSArtistInfoResponse extends SSBaseResponse {
|
||||
artistInfo2: SSArtistInfo;
|
||||
}
|
||||
|
||||
export interface SSArtistInfo {
|
||||
biography: string;
|
||||
largeImageUrl?: string;
|
||||
lastFmUrl?: string;
|
||||
mediumImageUrl?: string;
|
||||
musicBrainzId?: string;
|
||||
smallImageUrl?: string;
|
||||
}
|
||||
|
||||
export interface SSMusicFolder {
|
||||
id: number;
|
||||
name: string;
|
||||
}
|
||||
|
||||
export interface SSGenre {
|
||||
albumCount: number;
|
||||
songCount: number;
|
||||
value: string;
|
||||
}
|
||||
|
||||
export interface SSArtistIndex {
|
||||
artist: SSArtistListEntry[];
|
||||
name: string;
|
||||
}
|
||||
|
||||
export interface SSArtistListEntry {
|
||||
albumCount: string;
|
||||
artistImageUrl?: string;
|
||||
coverArt?: string;
|
||||
id: string;
|
||||
name: string;
|
||||
}
|
||||
|
||||
export interface SSAlbumListEntry {
|
||||
album: string;
|
||||
artist: string;
|
||||
artistId: string;
|
||||
coverArt: string;
|
||||
created: string;
|
||||
duration: number;
|
||||
genre?: string;
|
||||
id: string;
|
||||
isDir: boolean;
|
||||
isVideo: boolean;
|
||||
name: string;
|
||||
parent: string;
|
||||
songCount: number;
|
||||
starred?: boolean;
|
||||
title: string;
|
||||
userRating?: number;
|
||||
year: number;
|
||||
}
|
||||
|
||||
export interface SSAlbum extends SSAlbumListEntry {
|
||||
song: SSSong[];
|
||||
}
|
||||
|
||||
export interface SSSong {
|
||||
album: string;
|
||||
albumId: string;
|
||||
artist: string;
|
||||
artistId?: string;
|
||||
bitRate: number;
|
||||
contentType: string;
|
||||
coverArt: string;
|
||||
created: string;
|
||||
discNumber?: number;
|
||||
duration: number;
|
||||
genre: string;
|
||||
id: string;
|
||||
isDir: boolean;
|
||||
isVideo: boolean;
|
||||
parent: string;
|
||||
path: string;
|
||||
playCount: number;
|
||||
size: number;
|
||||
starred?: boolean;
|
||||
suffix: string;
|
||||
title: string;
|
||||
track: number;
|
||||
type: string;
|
||||
userRating?: number;
|
||||
year: number;
|
||||
}
|
||||
|
||||
export interface SSAlbumsParams {
|
||||
fromYear?: number;
|
||||
genre?: string;
|
||||
musicFolderId?: number;
|
||||
offset?: number;
|
||||
size?: number;
|
||||
toYear?: number;
|
||||
type: string;
|
||||
}
|
||||
|
||||
export interface SSArtistsParams {
|
||||
musicFolderId?: number;
|
||||
}
|
||||
Reference in New Issue
Block a user