362 lines
9.8 KiB
PHP
Executable File
362 lines
9.8 KiB
PHP
Executable File
<?php
|
|
|
|
namespace App\Models;
|
|
|
|
use App\Actions\Titles\HandlesEncodedTmdbId;
|
|
use App\Actions\Titles\HasCreditableRelation;
|
|
use App\Actions\Titles\HasVideoRelation;
|
|
use App\Actions\Titles\InsertsTmdbTitleOrPerson;
|
|
use App\Actions\Titles\Store\StoreTitleData;
|
|
use App\Services\Data\Tmdb\TmdbApi;
|
|
use Carbon\Carbon;
|
|
use Common\Comments\Comment;
|
|
use Common\Core\BaseModel;
|
|
use Illuminate\Database\Eloquent\Builder;
|
|
use Illuminate\Database\Eloquent\Casts\Attribute;
|
|
use Illuminate\Database\Eloquent\ModelNotFoundException;
|
|
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
|
|
use Illuminate\Database\Eloquent\Relations\HasMany;
|
|
use Illuminate\Database\Eloquent\Relations\HasManyThrough;
|
|
use Illuminate\Database\Eloquent\Relations\HasOne;
|
|
use Illuminate\Database\Eloquent\Relations\MorphMany;
|
|
use Illuminate\Database\Eloquent\Relations\MorphToMany;
|
|
use Illuminate\Support\Arr;
|
|
use Laravel\Scout\Searchable;
|
|
|
|
class Title extends BaseModel
|
|
{
|
|
use HasCreditableRelation,
|
|
HasVideoRelation,
|
|
Searchable,
|
|
HandlesEncodedTmdbId,
|
|
InsertsTmdbTitleOrPerson;
|
|
|
|
public const MOVIE_TYPE = 'movie';
|
|
public const SERIES_TYPE = 'series';
|
|
public const MODEL_TYPE = 'title';
|
|
|
|
protected $guarded = ['id', 'type'];
|
|
protected $appends = [
|
|
'rating',
|
|
'model_type',
|
|
'vote_count',
|
|
'status',
|
|
'year',
|
|
];
|
|
|
|
public $hidden = [
|
|
'imdb_rating',
|
|
'imdb_votes_num',
|
|
'tmdb_vote_average',
|
|
'local_vote_average',
|
|
'local_vote_count',
|
|
'tmdb_vote_count',
|
|
'mc_user_score',
|
|
'mc_critic_score',
|
|
];
|
|
|
|
protected $casts = [
|
|
'id' => 'integer',
|
|
'allow_update' => 'boolean',
|
|
'series_ended' => 'boolean',
|
|
'is_series' => 'boolean',
|
|
'tmdb_vote_count' => 'integer',
|
|
'runtime' => 'integer',
|
|
'views' => 'integer',
|
|
'popularity' => 'integer',
|
|
'tmdb_vote_average' => 'float',
|
|
'local_vote_average' => 'float',
|
|
'fully_synced' => 'boolean',
|
|
'adult' => 'boolean',
|
|
'rating' => 'float',
|
|
'vote_count' => 'integer',
|
|
'seasons_count' => 'integer',
|
|
'release_date' => 'date',
|
|
];
|
|
|
|
protected static function booted()
|
|
{
|
|
static::addGlobalScope('adult', function (Builder $builder) {
|
|
if (!config('tmdb.includeAdult')) {
|
|
$builder->where('adult', false);
|
|
}
|
|
});
|
|
}
|
|
|
|
public function findSeason(int $number): Season
|
|
{
|
|
return $this->seasons()
|
|
->where('number', $number)
|
|
->firstOrFail();
|
|
}
|
|
|
|
public function findEpisode(int $season, int $episode): Episode
|
|
{
|
|
return $this->episodes()
|
|
->where('season_number', $season)
|
|
->where('episode_number', $episode)
|
|
->firstOrFail();
|
|
}
|
|
|
|
public function maybeUpdateFromExternal(array $options = []): static|null
|
|
{
|
|
$tmdbImportingIsEnabled =
|
|
settings('content.title_provider') === 'tmdb' ||
|
|
Arr::get($options, 'forceAutomation');
|
|
$needsUpdating = $this->needsUpdating(
|
|
$options['ignoreLastUpdate'] ?? false,
|
|
);
|
|
|
|
// first update title itself, if needed
|
|
if ($tmdbImportingIsEnabled && $needsUpdating) {
|
|
$data = app(TmdbApi::class)->getTitle($this);
|
|
if (!$data) {
|
|
return null;
|
|
}
|
|
|
|
app(StoreTitleData::class)->execute($this, $data);
|
|
}
|
|
|
|
// then update 3 last seasons
|
|
if (
|
|
$needsUpdating &&
|
|
$this->is_series &&
|
|
Arr::get($options, 'updateLast3Seasons') &&
|
|
(settings('content.force_season_update') || $tmdbImportingIsEnabled)
|
|
) {
|
|
$this->seasons()
|
|
->orderBy('number', 'desc')
|
|
->take(3)
|
|
->get()
|
|
->each(
|
|
fn(Season $season) => $season->maybeUpdateFromExternal(
|
|
$this,
|
|
$options,
|
|
),
|
|
);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
protected function needsUpdating($force = false): bool
|
|
{
|
|
if (!$this->tmdb_id || !$this->exists) {
|
|
return false;
|
|
}
|
|
|
|
if ($force) {
|
|
return true;
|
|
}
|
|
|
|
// only partial data was fetched
|
|
if (
|
|
is_null($this->release_date) ||
|
|
(is_null($this->runtime) &&
|
|
is_null($this->revenue) &&
|
|
is_null($this->country) &&
|
|
is_null($this->budget) &&
|
|
is_null($this->imdb_id))
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
// sync every week
|
|
return $this->allow_update &&
|
|
$this->updated_at->lessThan(Carbon::now()->subWeek());
|
|
}
|
|
|
|
public static function firstOrCreateFromEncodedTmdbId(
|
|
string $encodedId,
|
|
): static {
|
|
[$tmdbId, $type] = static::decodeTmdbIdOrFail($encodedId);
|
|
|
|
if (!$tmdbId || !$type) {
|
|
throw new ModelNotFoundException();
|
|
}
|
|
|
|
return static::withoutGlobalScope('adult')->firstOrCreate([
|
|
'tmdb_id' => $tmdbId,
|
|
'is_series' => $type === Title::SERIES_TYPE,
|
|
]);
|
|
}
|
|
|
|
protected function rating(): Attribute
|
|
{
|
|
return Attribute::make(
|
|
get: function () {
|
|
return (float) Arr::get(
|
|
$this->attributes,
|
|
config('common.site.rating_column'),
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
protected function status(): Attribute
|
|
{
|
|
return Attribute::make(
|
|
get: function () {
|
|
if ($this->release_date?->isFuture()) {
|
|
return 'upcoming';
|
|
} elseif ($this->is_series) {
|
|
return $this->series_ended ? 'ended' : 'ongoing';
|
|
} else {
|
|
return 'released';
|
|
}
|
|
},
|
|
);
|
|
}
|
|
|
|
protected function voteCount(): Attribute
|
|
{
|
|
return Attribute::make(
|
|
get: function () {
|
|
$column = str_replace(
|
|
'_average',
|
|
'_count',
|
|
config('common.site.rating_column'),
|
|
);
|
|
return Arr::get($this->attributes, $column) ?: 0;
|
|
},
|
|
);
|
|
}
|
|
|
|
protected function year(): Attribute
|
|
{
|
|
return Attribute::make(
|
|
get: function () {
|
|
return $this->release_date?->year;
|
|
},
|
|
);
|
|
}
|
|
|
|
public function plays(): HasManyThrough
|
|
{
|
|
return $this->hasManyThrough(VideoPlay::class, Video::class);
|
|
}
|
|
|
|
public function genres(): BelongsToMany
|
|
{
|
|
return $this->belongsToMany(Genre::class);
|
|
}
|
|
|
|
public function keywords(): BelongsToMany
|
|
{
|
|
return $this->belongsToMany(Keyword::class);
|
|
}
|
|
|
|
public function productionCountries(): BelongsToMany
|
|
{
|
|
return $this->belongsToMany(ProductionCountry::class, 'country_title');
|
|
}
|
|
|
|
public function scopeCompact(Builder $query): Builder
|
|
{
|
|
return $query->select([
|
|
'titles.id',
|
|
'titles.name',
|
|
'titles.poster',
|
|
'titles.backdrop',
|
|
]);
|
|
}
|
|
|
|
public function images(): MorphMany
|
|
{
|
|
return $this->morphMany(Image::class, 'model')
|
|
->select(['id', 'model_id', 'model_type', 'url', 'type', 'source'])
|
|
->orderBy('order', 'asc');
|
|
}
|
|
|
|
public function newsArticles(): MorphToMany
|
|
{
|
|
return $this->morphToMany(
|
|
NewsArticle::class,
|
|
'model',
|
|
'news_article_models',
|
|
'model_id',
|
|
'article_id',
|
|
)->orderBy('created_at', 'desc');
|
|
}
|
|
|
|
public function reviews(): MorphMany
|
|
{
|
|
return $this->morphMany(Review::class, 'reviewable');
|
|
}
|
|
|
|
public function comments(): MorphMany
|
|
{
|
|
return $this->morphMany(Comment::class, 'commentable')
|
|
->orderBy('created_at', 'desc')
|
|
->orderByWeightedScore();
|
|
}
|
|
|
|
public function seasons(): HasMany
|
|
{
|
|
return $this->hasMany(Season::class);
|
|
}
|
|
|
|
public function season(): HasOne
|
|
{
|
|
return $this->hasOne(Season::class);
|
|
}
|
|
|
|
public function episodes(): HasMany
|
|
{
|
|
return $this->hasMany(Episode::class);
|
|
}
|
|
|
|
public function toSearchableArray(): array
|
|
{
|
|
return [
|
|
'id' => $this->id,
|
|
'name' => $this->name,
|
|
'original_title' => $this->original_title,
|
|
'release_date' => $this->release_date,
|
|
'popularity' => $this->popularity,
|
|
'created_at' => $this->created_at->timestamp ?? '_null',
|
|
'updated_at' => $this->updated_at->timestamp ?? '_null',
|
|
];
|
|
}
|
|
|
|
public static function filterableFields(): array
|
|
{
|
|
return ['id', 'created_at', 'updated_at', 'release_date', 'popularity'];
|
|
}
|
|
|
|
public function toNormalizedArray(): array
|
|
{
|
|
return [
|
|
'id' => $this->id,
|
|
'name' => $this->name,
|
|
'description' => $this->release_date?->format('Y'),
|
|
'image' => $this->poster
|
|
? preg_replace('/original|w1280/', 'w92', $this->poster)
|
|
: null,
|
|
'model_type' => self::MODEL_TYPE,
|
|
];
|
|
}
|
|
|
|
public static function getModelTypeAttribute(): string
|
|
{
|
|
return self::MODEL_TYPE;
|
|
}
|
|
|
|
public function resolveRouteBinding($value, $field = null): static
|
|
{
|
|
if (is_numeric($value) || ctype_digit($value)) {
|
|
return $this->findOrFail($value);
|
|
}
|
|
|
|
[$tmdbId, $type] = static::decodeTmdbIdOrFail($value);
|
|
|
|
if (!$tmdbId || !$type) {
|
|
throw new ModelNotFoundException();
|
|
}
|
|
|
|
return static::where('tmdb_id', $tmdbId)
|
|
->where('is_series', $type === Title::SERIES_TYPE)
|
|
->firstOrFail();
|
|
}
|
|
}
|