195 lines
No EOL
6 KiB
JavaScript
195 lines
No EOL
6 KiB
JavaScript
const metadata = require('../libs/metadata.js');
|
|
const { extname } = require('path');
|
|
|
|
const Artist = require('../models/Artist.js');
|
|
const Album = require('../models/Album.js');
|
|
const Track = require('../models/Track.js');
|
|
const TrackToArtist = require('../models/TrackToArtist.js');
|
|
const TrackToAlbum = require('../models/TrackToAlbum.js');
|
|
const AlbumToArtist = require('../models/AlbumToArtist.js');
|
|
|
|
class Queue {
|
|
|
|
constructor() {
|
|
this.queue = [];
|
|
this.filter = this.getFilter();
|
|
this.handleQueue();
|
|
}
|
|
|
|
add(event, file, stats) {
|
|
if (file === undefined || !this.filter.includes(extname(file))) {
|
|
return;
|
|
}
|
|
const element = { file: file };
|
|
switch (event) {
|
|
case constants.FS_EVENT_ADD:
|
|
element.event = constants.FS_EVENT_ADD;
|
|
break;
|
|
case constants.FS_EVENT_UNLINK:
|
|
element.event = constants.FS_EVENT_UNLINK;
|
|
break;
|
|
case constants.FS_EVENT_CHANGE:
|
|
element.event = constants.FS_EVENT_CHANGE;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
this.queue.push(element);
|
|
}
|
|
|
|
async handleQueue() {
|
|
if (this.queue.length === 0) {
|
|
if (this.timeout === undefined) {
|
|
this.timeout = 10;
|
|
} else {
|
|
if (this.timeout > 60000) {
|
|
this.timeout = 60000;
|
|
} else {
|
|
this.timeout += 10;
|
|
}
|
|
}
|
|
logger.debug('queue is currently empty - sleeping for ' + this.timeout + 'ms...');
|
|
setTimeout(() => {
|
|
this.handleQueue()
|
|
}, this.timeout);
|
|
return;
|
|
}
|
|
if (this.timeout !== undefined) {
|
|
this.timeout = undefined;
|
|
}
|
|
const element = this.queue[0];
|
|
this.queue.shift();
|
|
const timestamp = new Date().getTime();
|
|
logger.debug('handling event \'' + element.event + '\' for queued file \'' + element.file + '\'...');
|
|
switch (element.event) {
|
|
case constants.FS_EVENT_ADD:
|
|
await this.eventAdd(element.file);
|
|
break;
|
|
case constants.FS_EVENT_UNLINK:
|
|
await this.eventUnlink(element.file);
|
|
break;
|
|
case constants.FS_EVENT_CHANGE:
|
|
await this.eventChange(element.file);
|
|
break;
|
|
}
|
|
logger.debug('event \'' + element.event + '\' for file \'' + element.file + '\' handled after ' + (new Date().getTime() - timestamp) + 'ms');
|
|
this.handleQueue();
|
|
}
|
|
|
|
async eventAdd(file) {
|
|
if (file === undefined) {
|
|
return;
|
|
}
|
|
const tags = await metadata.parseFile(file);
|
|
const artists = await this.addArtist(tags);
|
|
const album = await this.addAlbum(tags);
|
|
const track = await this.addTrack(tags, file);
|
|
this.linkTrackToArtists(track, artists);
|
|
this.linkTrackToAlbum(track, album);
|
|
this.linkAlbumToArtists(album, artists);
|
|
}
|
|
|
|
async eventUnlink(file) {
|
|
if (file === undefined) {
|
|
return;
|
|
}
|
|
try {
|
|
await database.models.Track.destroy({
|
|
where: { file: file }
|
|
});
|
|
} catch (err) {
|
|
logger.error(err);
|
|
}
|
|
}
|
|
|
|
async eventChange(file) {
|
|
if (file === undefined) {
|
|
return;
|
|
}
|
|
let artist = tags.common.artist;
|
|
const artists = tags.common.artists || [];
|
|
if (artist !== undefined && !artists.includes(artist)) {
|
|
artists.push(artist);
|
|
}
|
|
for (let index = 0; index < artists.length; index++) {
|
|
artist = new Artist(artists[index]);
|
|
await artist.save();
|
|
artists[index] = artist;
|
|
}
|
|
return artists;
|
|
}
|
|
|
|
async addArtist(tags) {
|
|
if (tags?.common?.artist === undefined && tags?.common?.artists === undefined) {
|
|
return;
|
|
}
|
|
let artist = tags.common.artist;
|
|
const artists = tags.common.artists || [];
|
|
if (artist !== undefined && !artists.includes(artist)) {
|
|
artists.push(artist);
|
|
}
|
|
for (let index = 0; index < artists.length; index++) {
|
|
artist = new Artist(artists[index]);
|
|
await artist.save();
|
|
artists[index] = artist;
|
|
}
|
|
return artists;
|
|
}
|
|
|
|
async addAlbum(tags) {
|
|
if (tags?.common?.album === undefined) {
|
|
return;
|
|
}
|
|
let album = new Album(tags.common.album);
|
|
await album.save();
|
|
return album;
|
|
}
|
|
|
|
async addTrack(tags, file) {
|
|
if (tags?.common?.title === undefined || file === undefined) {
|
|
return;
|
|
}
|
|
let track = new Track(tags, file);
|
|
await track.save();
|
|
return track;
|
|
}
|
|
|
|
async linkTrackToArtists(track, artists) {
|
|
if (track === undefined || artists === undefined || artists.length === 0) {
|
|
return;
|
|
}
|
|
for (let index = 0; index < artists.length; index++) {
|
|
await new TrackToArtist(track, artists[index]).save();
|
|
}
|
|
}
|
|
|
|
async linkTrackToAlbum(track, album) {
|
|
if (track === undefined || album === undefined) {
|
|
return;
|
|
}
|
|
await new TrackToAlbum(track, album).save();
|
|
}
|
|
|
|
async linkAlbumToArtists(album, artists) {
|
|
if (album === undefined || artists === undefined || artists.length === 0) {
|
|
return;
|
|
}
|
|
for (let index = 0; index < artists.length; index++) {
|
|
await new AlbumToArtist(album, artists[index]).save();
|
|
}
|
|
}
|
|
|
|
getFilter() {
|
|
let filter = config?.library?.formats || ['.mp3'];
|
|
for (let index = 0; index < filter.length; index++) {
|
|
if (filter[index].startsWith(".")) {
|
|
continue;
|
|
}
|
|
filter[index] = '.' + filter[index];
|
|
}
|
|
return filter;
|
|
}
|
|
|
|
}
|
|
|
|
module.exports = Queue; |