269 lines
8.4 KiB
JavaScript
269 lines
8.4 KiB
JavaScript
console.log("service/cover_excluder INIT");
|
|
console.log("service/cover_excluder REQUIRE fs");
|
|
const fs = require("fs");
|
|
console.log("service/cover_excluder REQUIRE path");
|
|
const path = require("path");
|
|
console.log("service/cover_excluder REQUIRE request");
|
|
const request = require("request");
|
|
|
|
console.log("service/cover_excluder INCLUDE notifier");
|
|
const notifier = require("./notifier");
|
|
console.log("service/cover_excluder INCLUDE database");
|
|
const database = require("./database");
|
|
console.log("service/cover_excluder INCLUDE music_brainz");
|
|
const music_brainz = require("./music_brainz");
|
|
console.log("service/cover_excluder INCLUDE the_movie_db");
|
|
const the_movie_db = require("./the_movie_db");
|
|
console.log("service/cover_excluder INCLUDE resizer")
|
|
const resizer = require("../services/cover/resizer")
|
|
|
|
|
|
console.log("service/cover_excluder LOAD server settings")
|
|
const server = require("../server");
|
|
const status = server.status;
|
|
const config = server.config;
|
|
const cache_folder = config.cache_folder + "/";
|
|
|
|
|
|
console.log("service/cover_excluder SET notifiers")
|
|
notifier.on("exclude_metadata_finished", () => {
|
|
process.stdout.write("music scann finished…\n");
|
|
checkMissingAlbumCovers();
|
|
checkMissingArtistCovers();
|
|
status.scanning_music = false;
|
|
});
|
|
|
|
notifier.on("exclude_pathdata_finished", () => {
|
|
process.stdout.write("video scann finished…\n");
|
|
checkMissingBoxCovers();
|
|
status.scanning_video = false;
|
|
});
|
|
|
|
notifier.on("metadata_picture_excluded", album => {
|
|
resizer.resize_image_for_album(album.picture[0].data, covers => {
|
|
if (Object.keys(covers).length > 0) {
|
|
process.stdout.write("cover from metadata…\n");
|
|
database.albums.updateCovers(album, covers);
|
|
} else {
|
|
process.stdout.write("no cover from metadata…\n");
|
|
music_brainz.find_album_cover(album);
|
|
}
|
|
});
|
|
});
|
|
|
|
notifier.on("no_metadata_picture_excluded", album => {
|
|
music_brainz.find_album_cover(album);
|
|
});
|
|
|
|
notifier.on("found_music_brainz_album_cover", result => {
|
|
process.stdout.write("MB album result: " + result.mb + "\n");
|
|
|
|
let album_id = result.album._id.toString();
|
|
let tmp_file = cache_folder + album_id;
|
|
|
|
let writer = fs.createWriteStream(tmp_file);
|
|
|
|
writer.on("finish", () => {
|
|
resizer.resize_image_for_album(tmp_file, covers => {
|
|
if (Object.keys(covers).length > 0) {
|
|
process.stdout.write("album cover from musicbrainz…\n");
|
|
database.albums.updateCovers(result.album, covers);
|
|
}
|
|
fs.unlinkSync(tmp_file);
|
|
});
|
|
});
|
|
|
|
request(result.mb).pipe(writer);
|
|
});
|
|
|
|
notifier.on("found_music_brainz_artist_cover", result => {
|
|
process.stdout.write("MB artist result: " + result.mb + "\n");
|
|
|
|
let artist_id = result.artist._id.toString();
|
|
let tmp_file = cache_folder + artist_id;
|
|
let writer = fs.createWriteStream(tmp_file);
|
|
|
|
writer.on("finish", () => {
|
|
resizer.resize_image_for_artist(tmp_file, covers => {
|
|
if (Object.keys(covers).length > 0) {
|
|
process.stdout.write("artist cover from musicbrainz…\n");
|
|
database.artists.updateCovers(result.artist, covers);
|
|
}
|
|
fs.unlinkSync(tmp_file);
|
|
});
|
|
});
|
|
|
|
request(result.mb).pipe(writer);
|
|
});
|
|
|
|
notifier.on("found_movie_db_box_cover", box => {
|
|
process.stdout.write("TMVD box result: " + box.tmdb + "\n");
|
|
|
|
let box_id = box._id.toString();
|
|
let tmp_file = cache_folder + box_id;
|
|
let writer = fs.createWriteStream(tmp_file);
|
|
|
|
writer.on("finish", () => {
|
|
resizer.resize_image_for_box(tmp_file, covers => {
|
|
if (Object.keys(covers).length > 0) {
|
|
process.stdout.write("box covers from tmvd…\n");
|
|
database.boxes.updateCovers(box, covers);
|
|
}
|
|
fs.unlinkSync(tmp_file);
|
|
});
|
|
});
|
|
|
|
request(box.tmdb).pipe(writer);
|
|
});
|
|
|
|
function checkMissingAlbumCovers() {
|
|
process.stdout.write("started cover excluding for albums…\n");
|
|
database.albums.collection(-1, null, albums => {
|
|
albums.forEach(album => {
|
|
database.albums.tracks(album._id, album_tracks => {
|
|
if (!album_tracks || !album_tracks.tracks || album.covers) {
|
|
return;
|
|
}
|
|
album.tracks = album_tracks.tracks;
|
|
let cover_found = false;
|
|
album.tracks.forEach(track => {
|
|
if (cover_found) {
|
|
return;
|
|
}
|
|
|
|
let file_path = config.music_folder + track.path;
|
|
let directory = path.dirname(file_path);
|
|
|
|
config.album_cover_files.forEach(file => {
|
|
let img = directory + "/" + file;
|
|
if (fs.existsSync(img)) {
|
|
cover_found = true;
|
|
resizer.resize_image_for_album(img, covers => {
|
|
if (Object.keys(covers).length > 0) {
|
|
process.stdout.write("covers from file…\n");
|
|
database.albums.updateCovers(album, covers);
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
});
|
|
});
|
|
|
|
if (!cover_found) {
|
|
export_from_id3(album);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
function export_from_id3(album) {
|
|
album.tracks.forEach(track => {
|
|
track.parent = album;
|
|
});
|
|
notifier.emit("album_cover_request", album.tracks[0]);
|
|
}
|
|
|
|
function checkMissingArtistCovers() {
|
|
process.stdout.write("started cover excluding for artists…\n");
|
|
database.artists.collection(-1, undefined, artists => {
|
|
artists.forEach(artist => {
|
|
database.artists.tracks(artist._id.toString(), true, artist_full => {
|
|
if (!artist_full || !artist_full.albums || artist.covers) {
|
|
return;
|
|
}
|
|
let cover_found = false;
|
|
artist_full.albums.forEach(album => {
|
|
album.tracks.forEach(track => {
|
|
if (cover_found) {
|
|
return;
|
|
}
|
|
config.artist_cover_files.forEach(file => {
|
|
if (cover_found) {
|
|
return;
|
|
}
|
|
let file_path = config.music_folder + track.path;
|
|
let directory = path.dirname(file_path);
|
|
let img = directory + "/" + file;
|
|
if (fs.existsSync(img)) {
|
|
cover_found = true;
|
|
resizer.resize_image_for_artist(img, covers => {
|
|
if (Object.keys(covers).length > 0) {
|
|
process.stdout.write("artist covers from file…\n");
|
|
database.artists.updateCovers(artist, covers);
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
|
|
directory = path.dirname(directory);
|
|
img = directory + "/" + file;
|
|
if (fs.existsSync(img)) {
|
|
cover_found = true;
|
|
resizer.resize_image_for_artist(img, covers => {
|
|
if (Object.keys(covers).length > 0) {
|
|
process.stdout.write("artist covers from file…\n");
|
|
database.artists.updateCovers(artist, covers);
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
|
|
directory = path.dirname(directory);
|
|
img = directory + "/" + file;
|
|
if (fs.existsSync(img)) {
|
|
cover_found = true;
|
|
resizer.resize_image_for_artist(img, covers => {
|
|
if (Object.keys(covers).length > 0) {
|
|
process.stdout.write("artist covers from file…\n");
|
|
database.artists.updateCovers(artist, covers);
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
if (!cover_found) {
|
|
music_brainz.find_artist_cover(artist_full);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
function checkMissingBoxCovers() {
|
|
process.stdout.write("started cover excluding for boxes…\n");
|
|
database.boxes.collection(-1, undefined, boxes => {
|
|
boxes.forEach(box => {
|
|
database.boxes.videos(box._id.toString(), true, box_full => {
|
|
if (box_full.covers) {
|
|
return;
|
|
}
|
|
let cover_found = false;
|
|
let directory = config.video_folder + box_full.path;
|
|
config.box_cover_files.forEach(file => {
|
|
if (cover_found) {
|
|
return;
|
|
}
|
|
let img = directory + "/" + file;
|
|
if (fs.existsSync(img)) {
|
|
cover_found = true;
|
|
resizer.resize_image_for_box(img, covers => {
|
|
if (Object.keys(covers).length > 0) {
|
|
process.stdout.write("box covers from file…\n");
|
|
database.boxes.updateCovers(box_full, covers);
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
});
|
|
|
|
if (!cover_found) {
|
|
the_movie_db.find_box_cover(box);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
} |