HummingBirdAnimeClient/src/AnimeClient/Model/AnimeCollection.php

775 lines
14 KiB
PHP
Raw Normal View History

2016-10-20 22:09:36 -04:00
<?php declare(strict_types=1);
/**
2017-02-15 16:13:32 -05:00
* Hummingbird Anime List Client
2015-11-16 11:40:01 -05:00
*
2018-08-22 13:48:27 -04:00
* An API client for Kitsu to manage anime and manga watch lists
2015-11-16 11:40:01 -05:00
*
2021-02-04 11:57:01 -05:00
* PHP version 8
2016-08-30 10:01:18 -04:00
*
2017-02-15 16:13:32 -05:00
* @package HummingbirdAnimeClient
2016-08-30 10:01:18 -04:00
* @author Timothy J. Warren <tim@timshomepage.net>
2021-01-13 01:52:03 -05:00
* @copyright 2015 - 2021 Timothy J. Warren
2016-08-30 10:01:18 -04:00
* @license http://www.opensource.org/licenses/mit-license.html MIT License
2020-12-10 17:06:50 -05:00
* @version 5.2
* @link https://git.timshomepage.net/timw4mail/HummingBirdAnimeClient
*/
namespace Aviat\AnimeClient\Model;
2015-09-17 23:11:18 -04:00
use Aviat\Ion\Di\ContainerInterface;
use PDO;
use PDOException;
use function in_array;
2015-06-26 16:39:10 -04:00
/**
* Model for getting anime collection data
*/
final class AnimeCollection extends Collection {
/**
* Anime API Model
2018-01-16 14:58:07 -05:00
* @var Anime $animeModel
*/
2020-04-10 20:01:46 -04:00
protected Anime $animeModel;
/**
* Create the collection model
*
* @param ContainerInterface $container
*/
public function __construct(ContainerInterface $container)
{
parent::__construct($container);
$this->animeModel = $container->get('anime-model');
}
2015-06-11 12:54:54 -04:00
/**
* Get collection from the database, and organize by media type
*
* @return array
*/
public function getCollection(): array
{
2017-02-15 16:30:14 -05:00
$rawCollection = $this->getCollectionFromDatabase();
2015-06-11 12:54:54 -04:00
$collection = [];
2017-02-15 16:30:14 -05:00
foreach ($rawCollection as $row)
2015-06-11 12:54:54 -04:00
{
if (array_key_exists($row['media'], $collection))
{
$collection[$row['media']][] = $row;
}
else
{
$collection[$row['media']] = [$row];
}
}
return $collection;
}
2020-04-30 15:33:16 -04:00
/**
* Get the collection from the database
*
* @return array
*/
public function getFlatCollection(): array
{
if ( ! $this->validDatabase)
{
return [];
}
$query = $this->db->select('a.hummingbird_id, slug, title, alternate_title, show_type,
age_rating, episode_count, episode_length, cover_image, notes')
->from('anime_set a')
->orderBy('title')
->get();
// Add genres associated with each item
$rows = $query->fetchAll(PDO::FETCH_ASSOC);
$genres = $this->getGenreList();
$media = $this->getMediaList();
if ($rows === FALSE)
{
return [];
}
2020-04-30 15:33:16 -04:00
foreach($rows as &$row)
{
$id = $row['hummingbird_id'];
$row['genres'] = array_key_exists($id, $genres)
? $genres[$id]
: [];
$row['media'] = array_key_exists($id, $media)
? $media[$id]
: [];
sort($row['genres']);
}
return $rows;
}
/**
* Get list of media types
*
* @return array
*/
public function getMediaTypeList(): array
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return [];
}
$flatList = [];
$query = $this->db->select('id, type')
->from('media')
->get();
$rows = $query->fetchAll(PDO::FETCH_ASSOC);
if ($rows === FALSE)
{
return [];
}
foreach ($rows as $row)
{
$flatList[$row['id']] = $row['type'];
}
// Organize the media types into groups
2020-12-10 15:59:37 -05:00
// @TODO: make this more database-driven, rather than hardcoded
return [
'Common' => [
2 => $flatList[2], // Blu-ray
3 => $flatList[3], // DVD
7 => $flatList[7], // Digital
4 => $flatList[4], // Bootleg
],
'Retro' => [
5 => $flatList[5], // LaserDisc
6 => $flatList[6], // VHS
9 => $flatList[9], // Betamax
8 => $flatList[8], // Video CD
],
'Other' => [
10 => $flatList[10], // UMD
11 => $flatList[11], // Other
]
];
2015-06-11 12:54:54 -04:00
}
/**
* Add an item to the anime collection
*
* @param mixed $data
* @return void
*/
public function add(mixed $data): void
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return;
}
// Check that the anime doesn't already exist
if ($this->has($data['id']))
{
return;
}
$id = $data['id'];
$anime = (object)$this->animeModel->getAnimeById($id);
2020-04-23 20:03:55 -04:00
$this->db->set([
'hummingbird_id' => $id,
'slug' => $anime->slug,
'title' => array_shift($anime->titles),
2017-01-16 13:49:51 -05:00
'alternate_title' => implode('<br />', $anime->titles),
'show_type' => $anime->show_type,
'age_rating' => $anime->age_rating,
2017-01-16 13:49:51 -05:00
'cover_image' => $anime->cover_image,
'episode_count' => $anime->episode_count,
'episode_length' => $anime->episode_length,
'notes' => $data['notes']
])->insert('anime_set');
$this->updateMediaLink($id, $data['media_id']);
$this->updateGenres($id);
}
/**
* Verify that an item was added
*
* @param array $data
* @return bool
*/
public function wasAdded(array $data): bool
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return FALSE;
}
$row = $this->get($data['id']);
return ! empty($row);
}
/**
* Update a collection item
*
* @param array $data
* @return void
*/
public function update(array $data): void
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return;
}
// If there's no id to update, don't update
2015-11-05 11:26:03 -05:00
if ( ! array_key_exists('hummingbird_id', $data))
{
return;
}
$id = $data['hummingbird_id'];
$media = $data['media_id'];
unset($data['hummingbird_id'], $data['media_id']);
// If updating from the 'add' page, there
// might be no data to actually update in
// the anime_set table
if ( ! empty($data))
{
$this->db->set($data)
->where('hummingbird_id', $id)
->update('anime_set');
}
// Update media and genres
$this->updateMediaLink($id, $media);
$this->updateGenres($id);
}
/**
* Verify that the collection item was updated
*
* @param array $data
2019-12-09 14:41:04 -05:00
*
* @return bool
*/
public function wasUpdated(array $data): bool
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return FALSE;
}
$row = $this->get($data['hummingbird_id']);
foreach ($data as $key => $value)
{
if (is_array($row[$key]))
{
continue;
}
if ((string)$row[$key] !== (string)$value)
{
return FALSE;
}
}
return TRUE;
}
/**
2016-08-30 10:01:18 -04:00
* Remove a collection item
*
* @param array $data
* @return void
*/
public function delete(array $data): void
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return;
}
// If there's no id to update, don't delete
if ( ! array_key_exists('hummingbird_id', $data))
{
return;
}
2020-04-23 20:03:55 -04:00
$this->db->beginTransaction();
$this->db->where('hummingbird_id', $data['hummingbird_id'])
2020-04-30 15:33:16 -04:00
->delete('anime_set_genre_link');
2020-04-23 20:03:55 -04:00
$this->db->where('hummingbird_id', $data['hummingbird_id'])
->delete('anime_set_media_link');
$this->db->where('hummingbird_id', $data['hummingbird_id'])
->delete('anime_set');
2020-04-23 20:03:55 -04:00
$this->db->commit();
}
2019-12-09 14:41:04 -05:00
/**
* @param array $data
2019-12-09 16:17:25 -05:00
* @return bool
2019-12-09 14:41:04 -05:00
*/
public function wasDeleted(array $data): bool
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return FALSE;
}
return $this->has($data['hummingbird_id']) === FALSE;
}
/**
* Get the details of a collection item
*
* @param int|string $kitsuId
* @return array
*/
public function get(int|string $kitsuId): array
{
if ($this->validDatabase === FALSE)
{
return [];
}
// Get the main row data
$row = $this->db->from('anime_set')
->where('hummingbird_id', $kitsuId)
->get()
->fetch(PDO::FETCH_ASSOC);
if ($row === FALSE)
{
return [];
}
// Get the media ids
$mediaRows = $this->db->select('media_id')
->from('anime_set_media_link')
->where('hummingbird_id', $kitsuId)
->get()
->fetchAll(PDO::FETCH_ASSOC);
if ($mediaRows === FALSE)
{
return [];
}
$row['media_id'] = array_column($mediaRows, 'media_id');
return $row;
}
/**
* Does this anime already exist in the collection?
*
* @param int|string $kitsuId
* @return bool
*/
public function has(int|string $kitsuId): bool
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return FALSE;
}
$row = $this->db->select('hummingbird_id')
->from('anime_set')
2017-02-15 16:30:14 -05:00
->where('hummingbird_id', $kitsuId)
->get()
->fetch(PDO::FETCH_ASSOC);
return ! empty($row);
}
/**
* Get genres for anime collection items
*
* @param array $filter
* @return array
*/
public function getGenreList(array $filter = []): array
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return [];
}
$output = [];
// Catch the missing table PDOException
// so that the collection does not show an
// error by default
try
{
$this->db->select('hummingbird_id, genre')
2020-04-30 15:33:16 -04:00
->from('anime_set_genre_link gl')
->join('genres g', 'g.id=gl.genre_id', 'left');
if ( ! empty($filter))
{
$this->db->whereIn('hummingbird_id', $filter);
}
$query = $this->db->orderBy('hummingbird_id')
->orderBy('genre')
->get();
$rows = $query->fetchAll(PDO::FETCH_ASSOC);
if ($rows === FALSE)
{
return [];
}
foreach ($rows as $row)
{
$id = $row['hummingbird_id'];
$genre = $row['genre'];
// Empty genre names aren't useful
if (empty($genre))
{
continue;
}
if (array_key_exists($id, $output))
{
$output[$id][] = $genre;
}
else
{
$output[$id] = [$genre];
}
}
}
catch (PDOException) {}
2020-04-21 19:22:56 -04:00
$this->db->resetQuery();
return $output;
}
2020-04-30 15:33:16 -04:00
/**
* Get media for anime collection items
*
* @param array $filter
* @return array
*/
public function getMediaList(array $filter = []): array
{
if ($this->validDatabase === FALSE)
{
return [];
}
$output = [];
// Catch the missing table PDOException
// so that the collection does not show an
// error by default
try
{
$this->db->select('m.type as media, hummingbird_id')
->from('anime_set_media_link ml')
->join('media m', 'm.id=ml.media_id', 'left');
if ( ! empty($filter))
{
$this->db->whereIn('hummingbird_id', $filter);
}
$query = $this->db->orderBy('hummingbird_id')
->orderBy('media')
->get();
$rows = $query->fetchAll(PDO::FETCH_ASSOC);
if ($rows === FALSE)
{
return [];
}
foreach ($rows as $row)
2020-04-30 15:33:16 -04:00
{
$id = $row['hummingbird_id'];
$media = $row['media'];
// Empty genre names aren't useful
if (empty($media))
{
continue;
}
if (array_key_exists($id, $output))
{
$output[$id][] = $media;
}
else
{
$output[$id] = [$media];
}
}
}
catch (PDOException $e) {}
$this->db->resetQuery();
return $output;
}
private function updateMediaLink(string $animeId, array $media): void
{
$this->db->beginTransaction();
// Delete the old entries
$this->db->where('hummingbird_id', $animeId)
->delete('anime_set_media_link');
// Add the new entries
$entries = [];
foreach ($media as $id)
{
$entries[] = [
'hummingbird_id' => $animeId,
'media_id' => $id,
];
}
$this->db->insertBatch('anime_set_media_link', $entries);
$this->db->commit();
}
2015-06-11 12:54:54 -04:00
/**
* Update genre information for selected anime
2015-06-11 12:54:54 -04:00
*
* @param string $animeId The current anime
2015-06-11 12:54:54 -04:00
* @return void
*/
private function updateGenres($animeId): void
2015-06-11 12:54:54 -04:00
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return;
}
// Get api information
$anime = $this->animeModel->getAnimeById($animeId);
$this->addNewGenres($anime['genres']);
2017-02-15 16:30:14 -05:00
$genreInfo = $this->getGenreData();
$genres = $genreInfo['genres'];
$links = $genreInfo['links'];
$linksToInsert = [];
2015-06-11 12:54:54 -04:00
foreach ($anime['genres'] as $animeGenre)
{
// Update link table
// Get id of genre to put in link table
2017-02-15 16:30:14 -05:00
$flippedGenres = array_flip($genres);
$genreId = $flippedGenres[$animeGenre];
$animeLinks = $links[$animeId] ?? [];
if ( ! in_array($flippedGenres[$animeGenre], $animeLinks, TRUE))
{
$linksToInsert[] = [
'hummingbird_id' => $animeId,
'genre_id' => $genreId,
];
}
}
if ( ! empty($linksToInsert))
{
2020-04-30 15:33:16 -04:00
try
{
$this->db->insertBatch('anime_set_genre_link', $linksToInsert);
}
catch (PDOException $e) {}
}
}
/**
* Add genres to the database
*
* @param array $genres
*/
private function addNewGenres(array $genres): void
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return;
}
$existingGenres = $this->getExistingGenres();
$newGenres = array_diff($genres, $existingGenres);
$insert = [];
foreach ($newGenres as $genre)
{
$insert[] = [
'genre' => $genre,
];
}
try
{
2020-04-21 19:22:56 -04:00
$this->db->insertBatch('genres', $insert);
}
catch (PDOException)
{
// dump($e);
}
}
/**
* Get list of existing genres
*
* @return array
*/
private function getGenreData(): array
{
return [
'genres' => $this->getExistingGenres(),
'links' => $this->getExistingGenreLinkEntries(),
];
}
private function getExistingGenres(): array
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return [];
}
$genres = [];
2015-06-11 12:54:54 -04:00
// Get existing genres
$query = $this->db->select('id, genre')
->from('genres')
->get();
$rows = $query->fetchAll(PDO::FETCH_ASSOC);
if ($rows === FALSE)
{
return [];
}
foreach ($rows as $genre)
2015-06-11 12:54:54 -04:00
{
$genres[$genre['id']] = $genre['genre'];
}
2020-04-21 19:22:56 -04:00
$this->db->resetQuery();
return $genres;
}
private function getExistingGenreLinkEntries(): array
{
2019-12-09 16:17:25 -05:00
if ($this->validDatabase === FALSE)
{
return [];
}
$links = [];
2015-06-11 12:54:54 -04:00
$query = $this->db->select('hummingbird_id, genre_id')
2020-04-30 15:33:16 -04:00
->from('anime_set_genre_link')
2015-06-11 12:54:54 -04:00
->get();
$rows = $query->fetchAll(PDO::FETCH_ASSOC);
if ($rows === FALSE)
{
return [];
}
foreach ($rows as $link)
2015-06-11 12:54:54 -04:00
{
if (array_key_exists($link['hummingbird_id'], $links))
{
$links[$link['hummingbird_id']][] = $link['genre_id'];
2020-04-21 19:22:56 -04:00
}
else
2015-06-11 12:54:54 -04:00
{
$links[$link['hummingbird_id']] = [$link['genre_id']];
}
}
2020-04-21 19:22:56 -04:00
$this->db->resetQuery();
return $links;
}
/**
* Get full collection from the database
*
* @return array
*/
private function getCollectionFromDatabase(): array
{
if ( ! $this->validDatabase)
{
return [];
}
$query = $this->db->select('a.hummingbird_id, slug, title, alternate_title, show_type,
age_rating, episode_count, episode_length, cover_image, notes, media.type as media')
->from('anime_set a')
->join('anime_set_media_link ml', 'ml.hummingbird_id=a.hummingbird_id', 'inner')
->join('media', 'media.id=ml.media_id', 'inner')
->orderBy('media')
->orderBy('title')
->groupBy('a.hummingbird_id, media.type')
->get();
// Add genres associated with each item
$rows = $query->fetchAll(PDO::FETCH_ASSOC);
if ($rows === FALSE)
{
return [];
}
$genres = $this->getGenreList();
foreach($rows as &$row)
{
$id = $row['hummingbird_id'];
$row['genres'] = array_key_exists($id, $genres)
? $genres[$id]
: [];
sort($row['genres']);
}
return $rows;
}
}
// End of AnimeCollectionModel.php