mirror of
https://github.com/devfake/flox.git
synced 2024-11-15 22:52:32 +01:00
1a1753181f
* create genres table and translate media_type * parse genres from TMDb and modify artisan db command * parse genres on migration * Save genres in new table (via relation) * Implode genres as string. Update genres in refresh. * add tests for genres * fix icon for src * display genres on own page include few ui tweaks
396 lines
10 KiB
PHP
396 lines
10 KiB
PHP
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use App\AlternativeTitle;
|
|
use App\Item;
|
|
use App\Services\Models\EpisodeService;
|
|
use App\Services\Models\ItemService;
|
|
use App\Setting;
|
|
use GuzzleHttp\Client;
|
|
use Illuminate\Database\Eloquent\ModelNotFoundException;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Symfony\Component\HttpFoundation\Response;
|
|
|
|
class FileParser {
|
|
|
|
const ADDED = 'added';
|
|
const REMOVED = 'removed';
|
|
const UPDATED = 'updated';
|
|
|
|
// [field in local file => field in database]
|
|
const SUPPORTED_FIELDS = ['src' => 'src', 'subtitles' => 'subtitles', 'name' => 'fp_name'];
|
|
|
|
private $itemService;
|
|
private $episodeService;
|
|
private $tmdb;
|
|
private $alternativeTitle;
|
|
private $itemCategory;
|
|
private $client;
|
|
|
|
public function __construct(
|
|
ItemService $itemService,
|
|
EpisodeService $episodeService,
|
|
TMDB $tmdb,
|
|
AlternativeTitle $alternativeTitle,
|
|
Client $client
|
|
){
|
|
$this->itemService = $itemService;
|
|
$this->episodeService = $episodeService;
|
|
$this->tmdb = $tmdb;
|
|
$this->alternativeTitle = $alternativeTitle;
|
|
$this->client = $client;
|
|
}
|
|
|
|
/**
|
|
* Make a request to flox-file-parser and get local files data.
|
|
*
|
|
* @return int
|
|
*/
|
|
public function fetch()
|
|
{
|
|
logInfo("Making request to flox-file-parser...");
|
|
|
|
$timestamp = $this->lastFetched()['last_fetch_to_file_parser'];
|
|
$fpUrl = config('services.fp.host') . ':' . config('services.fp.port');
|
|
$fpUri = '/fetch/' . $timestamp;
|
|
|
|
$response = $this->client->get($fpUrl . $fpUri);
|
|
|
|
logInfo("Flox-file-parser request done!");
|
|
|
|
return $response->getStatusCode();
|
|
}
|
|
|
|
/**
|
|
* Loop over all local files.
|
|
*
|
|
* @param $files
|
|
* @return \Illuminate\Http\JsonResponse
|
|
*/
|
|
public function updateDatabase($files)
|
|
{
|
|
logInfo("FileParser.updateDatabase");
|
|
DB::beginTransaction();
|
|
|
|
$this->updateLastFetched();
|
|
|
|
foreach((array) $files as $type => $items) {
|
|
$this->itemCategory = $type;
|
|
|
|
foreach($items as $item) {
|
|
try {
|
|
logInfo("Updating data");
|
|
logInfo(print_r($item, 1));
|
|
$this->handleStatus($item);
|
|
} catch(\Exception $e) {
|
|
logInfo($e->getMessage(), [Response::HTTP_BAD_REQUEST]);
|
|
return response()->json($e->getMessage(), Response::HTTP_BAD_REQUEST);
|
|
}
|
|
}
|
|
}
|
|
|
|
logInfo("Updating data: Done!");
|
|
DB::commit();
|
|
}
|
|
|
|
/**
|
|
* Check which status the file has.
|
|
* If we can't handle the status, throw an exception.
|
|
*
|
|
* @param $item
|
|
* @return bool|mixed|void
|
|
* @throws \Exception
|
|
*/
|
|
private function handleStatus($item)
|
|
{
|
|
switch($item->status) {
|
|
case self::ADDED:
|
|
return $this->validateStore($item);
|
|
case self::UPDATED:
|
|
return $this->validateUpdate($item);
|
|
case self::REMOVED:
|
|
return $this->remove($item);
|
|
default:
|
|
$this->abortParser($item);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* See if it can find the item in our database, filtered by media_type.
|
|
* Otherwise search in TMDb or create an empty item.
|
|
*
|
|
* @param $item
|
|
* @return bool|mixed
|
|
*/
|
|
private function validateStore($item)
|
|
{
|
|
// See if file is already in our database.
|
|
if($found = $this->itemService->findBy('title_strict', $item->name, $this->itemCategory)) {
|
|
return $this->store($item, $found->tmdb_id);
|
|
}
|
|
|
|
// Otherwise make a new TMDb request.
|
|
$found = $this->searchTmdb($item);
|
|
|
|
if( ! $found) {
|
|
// Create an empty item if nothing is found.
|
|
return $this->createEmptyItem($item);
|
|
}
|
|
|
|
return $this->findOrCreateItem($found, $item);
|
|
}
|
|
|
|
/**
|
|
* See if it can find the item in our database, filtered by media_type.
|
|
* Check if it is an empty item and search against TMDb and update them.
|
|
* Otherwise create an empty item.
|
|
*
|
|
* @param $item
|
|
* @return mixed
|
|
*/
|
|
private function validateUpdate($item)
|
|
{
|
|
// See if file is already in our database.
|
|
if($found = $this->findItemByFPName($item)) {
|
|
if( ! $found->tmdb_id) {
|
|
return $this->searchTmdbAndUpdateEmptyItem($found, $item);
|
|
}
|
|
|
|
return $this->update($item, $found->tmdb_id);
|
|
}
|
|
|
|
// Create an empty item if nothing is found.
|
|
return $this->createEmptyItem($item);
|
|
}
|
|
|
|
/**
|
|
* If result was found in TMDb, remove empty item and re-create from TMDb.
|
|
* Otherwise remove and re-create empty item.
|
|
*
|
|
* @param $emptyItem
|
|
* @param $file
|
|
* @return Item|mixed
|
|
*/
|
|
private function searchTmdbAndUpdateEmptyItem($emptyItem, $file)
|
|
{
|
|
$found = $this->searchTmdb($file);
|
|
|
|
// We will create a new empty or a real item from TMDb.
|
|
$this->itemService->remove($emptyItem->id);
|
|
|
|
if( ! $found) {
|
|
return $this->createEmptyItem($file);
|
|
}
|
|
|
|
// Create a new item with TMDb specific values.
|
|
$created = $this->itemService->create($found);
|
|
|
|
// We are searching for the changed name (if available) in the next iteration.
|
|
if($this->itemCategory == 'tv') {
|
|
$created->update(['fp_name' => getFileName($file)]);
|
|
}
|
|
|
|
// Update FP specific values.
|
|
return $this->update($file, $created->tmdb_id);
|
|
}
|
|
|
|
/**
|
|
* Make a new request to TMDb and check against the database.
|
|
* Otherwise create a new item.
|
|
*
|
|
* @param $item
|
|
* @return bool|mixed
|
|
*/
|
|
private function searchTmdb($item)
|
|
{
|
|
$found = $this->tmdb->search(getFileName($item), $this->itemCategory);
|
|
|
|
if( ! $found) {
|
|
return false;
|
|
}
|
|
|
|
return $found[0];
|
|
}
|
|
|
|
/**
|
|
* If TMDb can't find anything, create a simple item with data from local file.
|
|
*
|
|
* @param $item
|
|
* @return mixed
|
|
*/
|
|
private function createEmptyItem($item)
|
|
{
|
|
return $this->itemService->createEmpty($item, $this->itemCategory);
|
|
}
|
|
|
|
/**
|
|
* Check tmdb_id against the database or create a new item.
|
|
*
|
|
* @param $firstResult
|
|
* @param $item
|
|
* @return mixed
|
|
*/
|
|
private function findOrCreateItem($firstResult, $item)
|
|
{
|
|
$tmdbId = $firstResult['tmdb_id'];
|
|
|
|
// Check against our database.
|
|
if($this->itemService->findBy('tmdb_id', $tmdbId)) {
|
|
return $this->store($item, $tmdbId);
|
|
}
|
|
|
|
// Otherwise create a new item from the result.
|
|
$created = $this->itemService->create($firstResult);
|
|
|
|
return $this->store($item, $created->tmdb_id);
|
|
}
|
|
|
|
/**
|
|
* Store current supported fields from local file into our database.
|
|
*
|
|
* @param $item
|
|
* @param $tmdbId
|
|
* @return mixed
|
|
*/
|
|
private function store($item, $tmdbId)
|
|
{
|
|
if($model = $this->findItem($item, $tmdbId)) {
|
|
foreach(self::SUPPORTED_FIELDS as $fromFile => $toDatabase) {
|
|
$model->{$toDatabase} = $item->{$fromFile};
|
|
}
|
|
|
|
return $model->save();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Iterate over all changed properties and update them in our database.
|
|
*
|
|
* @param $item
|
|
* @param $tmdbId
|
|
* @return mixed
|
|
*/
|
|
private function update($item, $tmdbId)
|
|
{
|
|
// Remove all fields, so we can start from scratch.
|
|
$this->remove($item);
|
|
|
|
if($model = $this->findItem($item, $tmdbId)) {
|
|
foreach(self::SUPPORTED_FIELDS as $fromFile => $toDatabase) {
|
|
if(isset($item->changed->{$fromFile})) {
|
|
$model->{$toDatabase} = $item->changed->{$fromFile};
|
|
} else {
|
|
// Re-populate the fields which hasn't changed.
|
|
$model->{$toDatabase} = $item->{$fromFile};
|
|
}
|
|
}
|
|
|
|
return $model->save();
|
|
}
|
|
|
|
throw new ModelNotFoundException("No item for '$item->name' found in database");
|
|
}
|
|
|
|
/**
|
|
* Reset all supported fields for local file from our database.
|
|
*
|
|
* @param $item
|
|
* @return mixed
|
|
*/
|
|
private function remove($item)
|
|
{
|
|
if($model = $this->findItemBySrc($item)) {
|
|
foreach(self::SUPPORTED_FIELDS as $fromFile => $toDatabase) {
|
|
$model->{$toDatabase} = null;
|
|
}
|
|
|
|
$model->save();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Cancel the complete fetch and make a rollback of fetched files.
|
|
*
|
|
* @param $item
|
|
* @throws \Exception
|
|
*/
|
|
private function abortParser($item)
|
|
{
|
|
DB::rollBack();
|
|
|
|
$itemAsString = json_encode($item);
|
|
|
|
throw new \Exception("Failed to parse file '$item->name' with status '$item->status'. Please open an issue: https://github.com/devfake/flox/issues and include the following content:\n\n $itemAsString");
|
|
}
|
|
|
|
/**
|
|
* @param $item
|
|
* @param $tmdbId
|
|
* @return \Illuminate\Support\Collection|mixed
|
|
*/
|
|
private function findItem($item, $tmdbId)
|
|
{
|
|
if($this->itemCategory == 'tv') {
|
|
return $this->episodeService->findBy('episode', $tmdbId, $item);
|
|
}
|
|
|
|
return $this->itemService->findBy('tmdb_id', $tmdbId);
|
|
}
|
|
|
|
/**
|
|
* @param $item
|
|
* @return mixed
|
|
*/
|
|
private function findItemByFPName($item)
|
|
{
|
|
$found = $this->itemService->findBy('fp_name', $item, $this->itemCategory);
|
|
|
|
// Search against episodes if no empty item for a tv show was found.
|
|
if( ! $found && $this->itemCategory == 'tv') {
|
|
$episode = $this->episodeService->findBy('fp_name', $item);
|
|
|
|
if($episode) {
|
|
$found = $this->itemService->findBy('tmdb_id', $episode->tmdb_id);
|
|
}
|
|
}
|
|
|
|
return $found;
|
|
}
|
|
|
|
/**
|
|
* @param $item
|
|
* @return \Illuminate\Support\Collection|mixed
|
|
*/
|
|
private function findItemBySrc($item)
|
|
{
|
|
if($this->itemCategory == 'tv') {
|
|
return $this->episodeService->findBy('src', $item->src);
|
|
}
|
|
|
|
return $this->itemService->findBy('src', $item->src);
|
|
}
|
|
|
|
/**
|
|
* Update last time we fetched flox-file-parser.
|
|
*/
|
|
private function updateLastFetched()
|
|
{
|
|
Setting::first()->update([
|
|
'last_fetch_to_file_parser' => now(),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* @return mixed
|
|
*/
|
|
public function lastFetched()
|
|
{
|
|
$lastFetch = Setting::first()->last_fetch_to_file_parser;
|
|
|
|
return [
|
|
'last_fetch_to_file_parser' => $lastFetch->timestamp ?? 0,
|
|
];
|
|
}
|
|
}
|