HummingBirdAnimeClient/src/AnimeClient/AnimeClient.php

387 lines
7.9 KiB
PHP
Raw Normal View History

2016-10-20 22:09:36 -04:00
<?php declare(strict_types=1);
2015-11-16 19:30:04 -05:00
/**
* Hummingbird Anime List Client
2015-11-16 19:30:04 -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 19:30:04 -05:00
*
* PHP version 7.4
2016-08-30 10:01:18 -04:00
*
2015-11-16 19:30:04 -05:00
* @package HummingbirdAnimeClient
2016-08-30 10:01:18 -04:00
* @author Timothy J. Warren <tim@timshomepage.net>
2020-01-08 15:39:49 -05:00
* @copyright 2015 - 2020 Timothy J. Warren
2016-08-30 10:01:18 -04:00
* @license http://www.opensource.org/licenses/mit-license.html MIT License
2020-08-04 09:30:21 -04:00
* @version 5.1
* @link https://git.timshomepage.net/timw4mail/HummingBirdAnimeClient
2015-11-16 19:30:04 -05:00
*/
namespace Aviat\AnimeClient;
2020-08-26 15:22:14 -04:00
use Aviat\AnimeClient\Kitsu;
2020-05-08 19:15:21 -04:00
use Psr\SimpleCache\CacheInterface;
use Psr\SimpleCache\InvalidArgumentException;
2018-11-29 11:00:50 -05:00
use function Amp\Promise\wait;
use Amp\Http\Client\Request;
2020-03-11 16:26:17 -04:00
use Amp\Http\Client\Response;
use Amp\Http\Client\HttpClient;
use Amp\Http\Client\HttpClientBuilder;
2018-11-29 11:00:50 -05:00
use Aviat\Ion\ConfigInterface;
2018-08-20 13:01:16 -04:00
use Yosymfony\Toml\{Toml, TomlBuilder};
2020-05-08 19:15:21 -04:00
use Throwable;
// ----------------------------------------------------------------------------
//! TOML Functions
// ----------------------------------------------------------------------------
/**
* Load configuration options from .toml files
*
* @param string $path - Path to load config
* @return array
*/
function loadToml(string $path): array
2017-12-06 14:40:13 -05:00
{
$output = [];
$files = glob("{$path}/*.toml");
foreach ($files as $file)
{
$key = str_replace('.toml', '', basename($file));
if ($key === 'admin-override')
{
continue;
}
$config = Toml::parseFile($file);
if ($key === 'config')
{
foreach($config as $name => $value)
{
$output[$name] = $value;
}
continue;
}
$output[$key] = $config;
}
return $output;
2017-12-06 14:40:13 -05:00
}
/**
* Load config from one specific TOML file
*
* @param string $filename
* @return array
*/
function loadTomlFile(string $filename): array
{
return Toml::parseFile($filename);
}
/**
2020-08-26 15:22:14 -04:00
* Serialize config data into a Toml file
*
2020-08-26 15:22:14 -04:00
* @param mixed $data
* @return string
*/
2020-08-26 15:22:14 -04:00
function arrayToToml(iterable $data): string
2018-08-20 13:01:16 -04:00
{
2020-08-26 15:22:14 -04:00
$builder = new TomlBuilder();
function _iterateToml(TomlBuilder $builder, iterable $data, $parentKey = NULL): void
2018-08-20 13:01:16 -04:00
{
2020-08-26 15:22:14 -04:00
foreach ($data as $key => $value)
2018-08-20 13:01:16 -04:00
{
2020-08-26 15:22:14 -04:00
if ($value === NULL)
{
continue;
}
2018-08-20 13:01:16 -04:00
2020-08-26 15:22:14 -04:00
if (is_scalar($value) || isSequentialArray($value))
{
// $builder->addTable('');
$builder->addValue($key, $value);
continue;
}
2018-08-20 13:01:16 -04:00
2020-08-26 15:22:14 -04:00
$newKey = ($parentKey !== NULL)
? "{$parentKey}.{$key}"
: $key;
2018-08-20 13:01:16 -04:00
2020-08-26 15:22:14 -04:00
if ( ! isSequentialArray($value))
{
$builder->addTable($newKey);
}
2018-08-20 13:01:16 -04:00
2020-08-26 15:22:14 -04:00
_iterateToml($builder, $value, $newKey);
}
2018-08-20 13:01:16 -04:00
}
_iterateToml($builder, $data);
return $builder->getTomlString();
}
/**
* Serialize toml back to an array
*
* @param string $toml
* @return array
*/
function tomlToArray(string $toml): array
{
return Toml::parse($toml);
}
// ----------------------------------------------------------------------------
//! Misc Functions
// ----------------------------------------------------------------------------
/**
* Is the array sequential, not associative?
*
* @param mixed $array
* @return bool
*/
function isSequentialArray($array): bool
{
if ( ! is_array($array))
{
return FALSE;
}
$i = 0;
foreach ($array as $k => $v)
{
if ($k !== $i++)
{
return FALSE;
}
}
return TRUE;
}
/**
* Check that folder permissions are correct for proper operation
*
* @param ConfigInterface $config
* @return array
*/
function checkFolderPermissions(ConfigInterface $config): array
{
$errors = [];
$publicDir = $config->get('asset_dir');
$pathMap = [
'app/config' => realpath(__DIR__ . '/../../app/config'),
'app/logs' => realpath(__DIR__ . '/../../app/logs'),
'public/images/avatars' => "{$publicDir}/images/avatars",
'public/images/anime' => "{$publicDir}/images/anime",
'public/images/characters' => "{$publicDir}/images/characters",
'public/images/manga' => "{$publicDir}/images/manga",
'public/images/people' => "{$publicDir}/images/people",
];
foreach ($pathMap as $pretty => $actual)
{
// Make sure the folder exists first
if ( ! is_dir($actual))
{
$errors['missing'][] = $pretty;
continue;
}
$writable = is_writable($actual) && is_executable($actual);
if ( ! $writable)
{
$errors['writable'][] = $pretty;
}
}
return $errors;
}
/**
* Get an API Client, with better defaults
*
2020-04-21 19:22:56 -04:00
* @return HttpClient
*/
2020-04-21 19:22:56 -04:00
function getApiClient (): HttpClient
{
static $client;
if ($client === NULL)
{
2020-03-11 16:26:17 -04:00
$client = HttpClientBuilder::buildDefault();
}
return $client;
}
2018-11-29 11:00:50 -05:00
/**
2020-03-11 16:26:17 -04:00
* Simplify making a request with Http\Client
2018-11-29 11:00:50 -05:00
*
* @param string|Request $request
2018-11-29 11:00:50 -05:00
* @return Response
2020-05-08 19:15:21 -04:00
* @throws Throwable
2018-11-29 11:00:50 -05:00
*/
function getResponse ($request): Response
{
$client = getApiClient();
if (is_string($request))
{
$request = new Request($request);
}
return wait($client->request($request));
2018-11-29 11:00:50 -05:00
}
/**
* Generate the path for the cached image from the original image
*
* @param string $kitsuUrl
* @param bool $webp
* @return string
*/
function getLocalImg ($kitsuUrl, $webp = TRUE): string
{
2020-05-08 19:15:21 -04:00
if (empty($kitsuUrl) || ( ! is_string($kitsuUrl)))
{
return 'images/placeholder.webp';
}
$parts = parse_url($kitsuUrl);
if ($parts === FALSE)
{
return 'images/placeholder.webp';
}
$file = basename($parts['path']);
$fileParts = explode('.', $file);
$ext = array_pop($fileParts);
$ext = $webp ? 'webp' : $ext;
$segments = explode('/', trim($parts['path'], '/'));
$type = $segments[0] === 'users' ? $segments[1] : $segments[0];
$id = $segments[count($segments) - 2];
return implode('/', ['images', $type, "{$id}.{$ext}"]);
}
/**
* Create a transparent placeholder image
*
* @param string $path
* @param int $width
* @param int $height
* @param string $text
*/
2020-04-21 19:22:56 -04:00
function createPlaceholderImage ($path, ?int $width, ?int $height, $text = 'Image Unavailable'): void
{
$width = $width ?? 200;
$height = $height ?? 200;
$img = imagecreatetruecolor($width, $height);
imagealphablending($img, TRUE);
$path = rtrim($path, '/');
// Background is the first color by default
$fillColor = imagecolorallocatealpha($img, 255, 255, 255, 127);
imagefill($img, 0, 0, $fillColor);
$textColor = imagecolorallocate($img, 64, 64, 64);
imagealphablending($img, TRUE);
// Generate placeholder text
$fontSize = 10;
$fontWidth = imagefontwidth($fontSize);
$fontHeight = imagefontheight($fontSize);
2018-11-09 10:38:35 -05:00
$length = \strlen($text);
$textWidth = $length * $fontWidth;
$fxPos = (int) ceil((imagesx($img) - $textWidth) / 2);
$fyPos = (int) ceil((imagesy($img) - $fontHeight) / 2);
// Add the image text
imagestring($img, $fontSize, $fxPos, $fyPos, $text, $textColor);
// Save the images
imagesavealpha($img, TRUE);
imagepng($img, $path . '/placeholder.png', 9);
imagedestroy($img);
$pngImage = imagecreatefrompng($path . '/placeholder.png');
imagealphablending($pngImage, TRUE);
imagesavealpha($pngImage, TRUE);
imagewebp($pngImage, $path . '/placeholder.webp');
imagedestroy($pngImage);
2020-04-30 15:33:16 -04:00
}
/**
* Check that there is a value for at least one item in a collection with the specified key
*
* @param array $search
* @param string $key
* @return bool
*/
2020-08-26 15:22:14 -04:00
function colNotEmpty(array $search, string $key): bool
2020-04-30 15:33:16 -04:00
{
$items = array_filter(array_column($search, $key), fn ($x) => ( ! empty($x)));
return count($items) > 0;
2020-05-08 19:15:21 -04:00
}
/**
* Clear the cache, but save user auth data
*
* @param CacheInterface $cache
* @return bool
* @throws InvalidArgumentException
*/
function clearCache(CacheInterface $cache): bool
{
// Save the user data, if it exists, for priming the cache
$userData = $cache->getMultiple([
Kitsu::AUTH_USER_ID_KEY,
Kitsu::AUTH_TOKEN_CACHE_KEY,
Kitsu::AUTH_TOKEN_EXP_CACHE_KEY,
Kitsu::AUTH_TOKEN_REFRESH_CACHE_KEY,
], NULL);
$userData = array_filter((array)$userData, fn ($value) => $value !== NULL);
$cleared = $cache->clear();
$saved = ( ! empty($userData))
? $cache->setMultiple($userData)
: TRUE;
return $cleared && $saved;
2020-08-26 17:26:42 -04:00
}
/**
* Render a PHP code template as a string
*
* @param string $path
* @param array $data
* @return string
*/
function renderTemplate(string $path, array $data): string
{
ob_start();
extract($data, EXTR_OVERWRITE);
include $path;
return ob_get_clean();
}