mirror of
https://github.com/YunoHost/doc.git
synced 2024-09-03 20:06:26 +02:00
2493 lines
70 KiB
PHP
2493 lines
70 KiB
PHP
<?php
|
|
|
|
namespace Grav\Plugin\Admin;
|
|
|
|
use DateTime;
|
|
use Grav\Common\Data;
|
|
use Grav\Common\Data\Data as GravData;
|
|
use Grav\Common\Debugger;
|
|
use Grav\Common\File\CompiledYamlFile;
|
|
use Grav\Common\Flex\Types\Users\UserObject;
|
|
use Grav\Common\GPM\GPM;
|
|
use Grav\Common\GPM\Licenses;
|
|
use Grav\Common\Grav;
|
|
use Grav\Common\Helpers\YamlLinter;
|
|
use Grav\Common\HTTP\Response;
|
|
use Grav\Common\Language\Language;
|
|
use Grav\Common\Language\LanguageCodes;
|
|
use Grav\Common\Page\Collection;
|
|
use Grav\Common\Page\Interfaces\PageInterface;
|
|
use Grav\Common\Page\Page;
|
|
use Grav\Common\Page\Pages;
|
|
use Grav\Common\Plugins;
|
|
use Grav\Common\Security;
|
|
use Grav\Common\Session;
|
|
use Grav\Common\Themes;
|
|
use Grav\Common\Uri;
|
|
use Grav\Common\User\Interfaces\UserCollectionInterface;
|
|
use Grav\Common\User\Interfaces\UserInterface;
|
|
use Grav\Common\Utils;
|
|
use Grav\Framework\Acl\Action;
|
|
use Grav\Framework\Acl\Permissions;
|
|
use Grav\Framework\Collection\ArrayCollection;
|
|
use Grav\Framework\Flex\Flex;
|
|
use Grav\Framework\Flex\Interfaces\FlexInterface;
|
|
use Grav\Framework\Flex\Interfaces\FlexObjectInterface;
|
|
use Grav\Framework\Route\Route;
|
|
use Grav\Framework\Route\RouteFactory;
|
|
use Grav\Plugin\AdminPlugin;
|
|
use Grav\Plugin\Login\Login;
|
|
use Grav\Plugin\Login\TwoFactorAuth\TwoFactorAuth;
|
|
use JsonException;
|
|
use PicoFeed\Parser\MalformedXmlException;
|
|
use Psr\Http\Message\ServerRequestInterface;
|
|
use RocketTheme\Toolbox\Event\Event;
|
|
use RocketTheme\Toolbox\File\File;
|
|
use RocketTheme\Toolbox\File\JsonFile;
|
|
use RocketTheme\Toolbox\ResourceLocator\UniformResourceIterator;
|
|
use RocketTheme\Toolbox\ResourceLocator\UniformResourceLocator;
|
|
use RocketTheme\Toolbox\Session\Message;
|
|
use Grav\Common\Yaml;
|
|
use Composer\Semver\Semver;
|
|
use PicoFeed\Reader\Reader;
|
|
|
|
define('LOGIN_REDIRECT_COOKIE', 'grav-login-redirect');
|
|
|
|
/**
|
|
* Class Admin
|
|
* @package Grav\Plugin\Admin
|
|
*/
|
|
class Admin
|
|
{
|
|
/** @var int */
|
|
public const DEBUG = 1;
|
|
/** @var int */
|
|
public const MEDIA_PAGINATION_INTERVAL = 20;
|
|
/** @var string */
|
|
public const TMP_COOKIE_NAME = 'tmp-admin-message';
|
|
|
|
/** @var Grav */
|
|
public $grav;
|
|
/** @var ServerRequestInterface|null */
|
|
public $request;
|
|
/** @var AdminForm */
|
|
public $form;
|
|
/** @var string */
|
|
public $base;
|
|
/** @var string */
|
|
public $location;
|
|
/** @var string */
|
|
public $route;
|
|
/** @var UserInterface */
|
|
public $user;
|
|
/** @var array */
|
|
public $forgot;
|
|
/** @var string */
|
|
public $task;
|
|
/** @var array */
|
|
public $json_response;
|
|
/** @var Collection */
|
|
public $collection;
|
|
/** @var bool */
|
|
public $multilang;
|
|
/** @var string */
|
|
public $language;
|
|
/** @var array */
|
|
public $languages_enabled = [];
|
|
/** @var Uri $uri */
|
|
protected $uri;
|
|
/** @var array */
|
|
protected $pages = [];
|
|
/** @var Session */
|
|
protected $session;
|
|
/** @var Data\Blueprints */
|
|
protected $blueprints;
|
|
/** @var GPM */
|
|
protected $gpm;
|
|
/** @var int */
|
|
protected $pages_count;
|
|
/** @var bool */
|
|
protected $load_additional_files_in_background = false;
|
|
/** @var bool */
|
|
protected $loading_additional_files_in_background = false;
|
|
/** @var array */
|
|
protected $temp_messages = [];
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param Grav $grav
|
|
* @param string $base
|
|
* @param string $location
|
|
* @param string|null $route
|
|
*/
|
|
public function __construct(Grav $grav, $base, $location, $route)
|
|
{
|
|
// Register admin to grav because of calling $grav['user'] requires it.
|
|
$grav['admin'] = $this;
|
|
|
|
$this->grav = $grav;
|
|
$this->base = $base;
|
|
$this->location = $location;
|
|
$this->route = $route ?? '';
|
|
$this->uri = $grav['uri'];
|
|
$this->session = $grav['session'];
|
|
|
|
/** @var FlexInterface|null $flex */
|
|
$flex = $grav['flex_objects'] ?? null;
|
|
|
|
/** @var UserInterface $user */
|
|
$user = $grav['user'];
|
|
|
|
// Convert old user to Flex User if Flex Objects plugin has been enabled.
|
|
if ($flex && !$user instanceof FlexObjectInterface) {
|
|
$managed = !method_exists($flex, 'isManaged') || $flex->isManaged('user-accounts');
|
|
$directory = $managed ? $flex->getDirectory('user-accounts') : null;
|
|
|
|
/** @var UserObject|null $test */
|
|
$test = $directory ? $directory->getObject(mb_strtolower($user->username)) : null;
|
|
if ($test) {
|
|
$test = clone $test;
|
|
$test->access = $user->access;
|
|
$test->groups = $user->groups;
|
|
$test->authenticated = $user->authenticated;
|
|
$test->authorized = $user->authorized;
|
|
$user = $test;
|
|
}
|
|
}
|
|
$this->user = $user;
|
|
|
|
/** @var Language $language */
|
|
$language = $grav['language'];
|
|
|
|
$this->multilang = $language->enabled();
|
|
|
|
// Load utility class
|
|
if ($this->multilang) {
|
|
$this->language = $language->getActive() ?? '';
|
|
$this->languages_enabled = (array)$this->grav['config']->get('system.languages.supported', []);
|
|
|
|
//Set the currently active language for the admin
|
|
$languageCode = $this->uri->param('lang');
|
|
if (null === $languageCode && !$this->session->admin_lang) {
|
|
$this->session->admin_lang = $language->getActive() ?? '';
|
|
}
|
|
} else {
|
|
$this->language = '';
|
|
}
|
|
|
|
// Set admin route language.
|
|
RouteFactory::setLanguage($this->language);
|
|
}
|
|
|
|
/**
|
|
* @param string $message
|
|
* @param array|object $data
|
|
* @return void
|
|
*/
|
|
public static function addDebugMessage(string $message, $data = [])
|
|
{
|
|
/** @var Debugger $debugger */
|
|
$debugger = Grav::instance()['debugger'];
|
|
$debugger->addMessage($message, 'debug', $data);
|
|
}
|
|
|
|
/**
|
|
* @return string[]
|
|
*/
|
|
public static function contentEditor()
|
|
{
|
|
$options = [
|
|
'default' => 'Default',
|
|
'codemirror' => 'CodeMirror'
|
|
];
|
|
$event = new Event(['options' => &$options]);
|
|
Grav::instance()->fireEvent('onAdminListContentEditors', $event);
|
|
return $options;
|
|
}
|
|
|
|
/**
|
|
* Return the languages available in the admin
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function adminLanguages()
|
|
{
|
|
$languages = [];
|
|
|
|
$path = Grav::instance()['locator']->findResource('plugins://admin/languages');
|
|
|
|
foreach (new \DirectoryIterator($path) as $file) {
|
|
if ($file->isDir() || $file->isDot() || Utils::startsWith($file->getFilename(), '.')) {
|
|
continue;
|
|
}
|
|
|
|
$lang = $file->getBasename('.yaml');
|
|
|
|
$languages[$lang] = LanguageCodes::getNativeName($lang);
|
|
|
|
}
|
|
|
|
// sort languages
|
|
asort($languages);
|
|
|
|
return $languages;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function getLanguage(): string
|
|
{
|
|
return $this->language ?: $this->grav['language']->getLanguage() ?: 'en';
|
|
}
|
|
|
|
/**
|
|
* Return the found configuration blueprints
|
|
*
|
|
* @param bool $checkAccess
|
|
* @return array
|
|
*/
|
|
public static function configurations(bool $checkAccess = false): array
|
|
{
|
|
$grav = Grav::instance();
|
|
|
|
/** @var Admin $admin */
|
|
$admin = $grav['admin'];
|
|
|
|
/** @var UniformResourceIterator $iterator */
|
|
$iterator = $grav['locator']->getIterator('blueprints://config');
|
|
|
|
// Find all main level configuration files.
|
|
$configurations = [];
|
|
foreach ($iterator as $file) {
|
|
if ($file->isDir() || !preg_match('/^[^.].*.yaml$/', $file->getFilename())) {
|
|
continue;
|
|
}
|
|
|
|
$name = $file->getBasename('.yaml');
|
|
|
|
// Check that blueprint exists and is not hidden.
|
|
$data = $admin->getConfigurationData('config/'. $name);
|
|
if (!is_callable([$data, 'blueprints'])) {
|
|
continue;
|
|
}
|
|
|
|
$blueprint = $data->blueprints();
|
|
if (!$blueprint) {
|
|
continue;
|
|
}
|
|
|
|
$test = $blueprint->toArray();
|
|
if (empty($test['form']['hidden']) && (!empty($test['form']['field']) || !empty($test['form']['fields']))) {
|
|
$configurations[$name] = true;
|
|
}
|
|
}
|
|
|
|
// Remove scheduler and backups configs (they belong to the tools).
|
|
unset($configurations['scheduler'], $configurations['backups']);
|
|
|
|
// Sort configurations.
|
|
ksort($configurations);
|
|
$configurations = ['system' => true, 'site' => true] + $configurations + ['info' => true];
|
|
|
|
if ($checkAccess) {
|
|
// ACL checks.
|
|
foreach ($configurations as $name => $value) {
|
|
if (!$admin->authorize(['admin.configuration.' . $name, 'admin.super'])) {
|
|
unset($configurations[$name]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return array_keys($configurations);
|
|
}
|
|
|
|
/**
|
|
* Return the tools found
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function tools()
|
|
{
|
|
$tools = [];
|
|
Grav::instance()->fireEvent('onAdminTools', new Event(['tools' => &$tools]));
|
|
|
|
return $tools;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public static function toolsPermissions()
|
|
{
|
|
$tools = static::tools();
|
|
$perms = [];
|
|
|
|
foreach ($tools as $tool) {
|
|
$perms = array_merge($perms, $tool[0]);
|
|
}
|
|
|
|
return array_unique($perms);
|
|
}
|
|
|
|
/**
|
|
* Return the languages available in the site
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function siteLanguages()
|
|
{
|
|
$languages = [];
|
|
$lang_data = (array) Grav::instance()['config']->get('system.languages.supported', []);
|
|
|
|
foreach ($lang_data as $index => $lang) {
|
|
$languages[$lang] = LanguageCodes::getNativeName($lang);
|
|
}
|
|
|
|
return $languages;
|
|
}
|
|
|
|
/**
|
|
* Static helper method to return the admin form nonce
|
|
*
|
|
* @param string $action
|
|
* @return string
|
|
*/
|
|
public static function getNonce(string $action = 'admin-form')
|
|
{
|
|
return Utils::getNonce($action);
|
|
}
|
|
|
|
/**
|
|
* Static helper method to return the last used page name
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getLastPageName()
|
|
{
|
|
return Grav::instance()['session']->lastPageName ?: 'default';
|
|
}
|
|
|
|
/**
|
|
* Static helper method to return the last used page route
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getLastPageRoute()
|
|
{
|
|
/** @var Session $session */
|
|
$session = Grav::instance()['session'];
|
|
$route = $session->lastPageRoute;
|
|
if ($route) {
|
|
return $route;
|
|
}
|
|
|
|
/** @var Admin $admin */
|
|
$admin = Grav::instance()['admin'];
|
|
|
|
return $admin->getCurrentRoute();
|
|
}
|
|
|
|
/**
|
|
* @param string $path
|
|
* @param string|null $languageCode
|
|
* @return Route
|
|
*/
|
|
public function getAdminRoute(string $path = '', $languageCode = null): Route
|
|
{
|
|
/** @var Language $language */
|
|
$language = $this->grav['language'];
|
|
$languageCode = $languageCode ?? ($language->getActive() ?: null);
|
|
$languagePrefix = $languageCode ? '/' . $languageCode : '';
|
|
|
|
$root = $this->grav['uri']->rootUrl();
|
|
$subRoute = rtrim($this->grav['pages']->base(), '/');
|
|
$adminRoute = rtrim($this->grav['config']->get('plugins.admin.route'), '/');
|
|
|
|
$parts = [
|
|
'path' => $path,
|
|
'query' => '',
|
|
'query_params' => [],
|
|
'grav' => [
|
|
// TODO: Make URL to be /admin/en, not /en/admin.
|
|
'root' => preg_replace('`//+`', '/', $root . $subRoute . $languagePrefix . $adminRoute),
|
|
'language' => '', //$languageCode,
|
|
'route' => ltrim($path, '/'),
|
|
'params' => ''
|
|
],
|
|
];
|
|
|
|
return RouteFactory::createFromParts($parts);
|
|
}
|
|
|
|
/**
|
|
* @param string $route
|
|
* @param string|null $languageCode
|
|
* @return string
|
|
*/
|
|
public function adminUrl(string $route = '', $languageCode = null)
|
|
{
|
|
return $this->getAdminRoute($route, $languageCode)->toString(true);
|
|
}
|
|
|
|
/**
|
|
* Static helper method to return current route.
|
|
*
|
|
* @return string
|
|
* @deprecated 1.10 Use $admin->getCurrentRoute() instead
|
|
*/
|
|
public static function route()
|
|
{
|
|
user_error(__CLASS__ . '::' . __FUNCTION__ . '() is deprecated since Admin 1.9.7, use $admin->getCurrentRoute() instead', E_USER_DEPRECATED);
|
|
|
|
$admin = Grav::instance()['admin'];
|
|
|
|
return $admin->getCurrentRoute();
|
|
}
|
|
|
|
/**
|
|
* @return string|null
|
|
*/
|
|
public function getCurrentRoute()
|
|
{
|
|
$pages = static::enablePages();
|
|
|
|
$route = '/' . ltrim($this->route, '/');
|
|
|
|
/** @var PageInterface $page */
|
|
$page = $pages->find($route);
|
|
$parent_route = null;
|
|
if ($page) {
|
|
/** @var PageInterface $parent */
|
|
$parent = $page->parent();
|
|
$parent_route = $parent->rawRoute();
|
|
}
|
|
|
|
return $parent_route;
|
|
}
|
|
|
|
/**
|
|
* Redirect to the route stored in $this->redirect
|
|
*
|
|
* Route may or may not be prefixed by /en or /admin or /en/admin.
|
|
*
|
|
* @param string $redirect
|
|
* @param int $redirectCode
|
|
* @return void
|
|
*/
|
|
public function redirect($redirect, $redirectCode = 303)
|
|
{
|
|
// No redirect, do nothing.
|
|
if (!$redirect) {
|
|
return;
|
|
}
|
|
|
|
Admin::DEBUG && Admin::addDebugMessage("Admin redirect: {$redirectCode} {$redirect}");
|
|
|
|
$redirect = '/' . ltrim(preg_replace('`//+`', '/', $redirect), '/');
|
|
$base = $this->base;
|
|
$root = Grav::instance()['uri']->rootUrl();
|
|
if ($root === '/') {
|
|
$root = '';
|
|
}
|
|
|
|
$pattern = '`^((' . preg_quote($root, '`') . ')?(/[^/]+)?)' . preg_quote($base, '`') . '`ui';
|
|
// Check if we already have an admin path: /admin, /en/admin, /root/admin or /root/en/admin.
|
|
if (preg_match($pattern, $redirect)) {
|
|
$redirect = preg_replace('|^' . preg_quote($root, '|') . '|', '', $redirect);
|
|
|
|
$this->grav->redirect($redirect, $redirectCode);
|
|
}
|
|
|
|
if ($this->isMultilang()) {
|
|
// Check if URL does not have language prefix.
|
|
if (!Utils::pathPrefixedByLangCode($redirect)) {
|
|
/** @var Language $language */
|
|
$language = $this->grav['language'];
|
|
|
|
// Prefix path with language prefix: /en
|
|
// TODO: Use /admin/en instead of /en/admin in the future.
|
|
$redirect = $language->getLanguageURLPrefix($this->grav['session']->admin_lang) . $base . $redirect;
|
|
} else {
|
|
// TODO: Use /admin/en instead of /en/admin in the future.
|
|
//$redirect = preg_replace('`^(/[^/]+)/admin`', '\\1', $redirect);
|
|
|
|
// Check if we already have language prefixed admin path: /en/admin
|
|
$this->grav->redirect($redirect, $redirectCode);
|
|
}
|
|
} else {
|
|
// TODO: Use /admin/en instead of /en/admin in the future.
|
|
// Prefix path with /admin
|
|
$redirect = $base . $redirect;
|
|
}
|
|
|
|
$this->grav->redirect($redirect, $redirectCode);
|
|
}
|
|
|
|
/**
|
|
* Return true if multilang is active
|
|
*
|
|
* @return bool True if multilang is active
|
|
*/
|
|
protected function isMultilang()
|
|
{
|
|
return count($this->grav['config']->get('system.languages.supported', [])) > 1;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public static function getTempDir()
|
|
{
|
|
try {
|
|
$tmp_dir = Grav::instance()['locator']->findResource('tmp://', true, true);
|
|
} catch (\Exception $e) {
|
|
$tmp_dir = Grav::instance()['locator']->findResource('cache://', true, true) . '/tmp';
|
|
}
|
|
|
|
return $tmp_dir;
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public static function getPageMedia()
|
|
{
|
|
$files = [];
|
|
$grav = Grav::instance();
|
|
|
|
$pages = static::enablePages();
|
|
|
|
$route = '/' . ltrim($grav['admin']->route, '/');
|
|
|
|
/** @var PageInterface $page */
|
|
$page = $pages->find($route);
|
|
$parent_route = null;
|
|
if ($page) {
|
|
$media = $page->media()->all();
|
|
$files = array_keys($media);
|
|
}
|
|
return $files;
|
|
|
|
}
|
|
|
|
/**
|
|
* Get current session.
|
|
*
|
|
* @return Session
|
|
*/
|
|
public function session()
|
|
{
|
|
return $this->session;
|
|
}
|
|
|
|
/**
|
|
* Fetch and delete messages from the session queue.
|
|
*
|
|
* @param string|null $type
|
|
* @return array
|
|
*/
|
|
public function messages($type = null)
|
|
{
|
|
/** @var Message $messages */
|
|
$messages = $this->grav['messages'];
|
|
|
|
return $messages->fetch($type);
|
|
}
|
|
|
|
/**
|
|
* Authenticate user.
|
|
*
|
|
* @param array $credentials User credentials.
|
|
* @param array $post
|
|
* @return never-return
|
|
*/
|
|
public function authenticate($credentials, $post)
|
|
{
|
|
/** @var Login $login */
|
|
$login = $this->grav['login'];
|
|
|
|
// Remove login nonce from the form.
|
|
$credentials = array_diff_key($credentials, ['admin-nonce' => true]);
|
|
$twofa = $this->grav['config']->get('plugins.admin.twofa_enabled', false);
|
|
|
|
$rateLimiter = $login->getRateLimiter('login_attempts');
|
|
|
|
$userKey = (string)($credentials['username'] ?? '');
|
|
$ipKey = Uri::ip();
|
|
$redirect = $post['redirect'] ?? $this->base . $this->route;
|
|
|
|
// Pseudonymization of the IP
|
|
$ipKey = sha1($ipKey . $this->grav['config']->get('security.salt'));
|
|
|
|
// Check if the current IP has been used in failed login attempts.
|
|
$attempts = count($rateLimiter->getAttempts($ipKey, 'ip'));
|
|
|
|
$rateLimiter->registerRateLimitedAction($ipKey, 'ip')->registerRateLimitedAction($userKey);
|
|
|
|
// Check rate limit for both IP and user, but allow each IP a single try even if user is already rate limited.
|
|
if ($rateLimiter->isRateLimited($ipKey, 'ip') || ($attempts && $rateLimiter->isRateLimited($userKey))) {
|
|
Admin::DEBUG && Admin::addDebugMessage('Admin login: rate limit, redirecting', $credentials);
|
|
|
|
$this->setMessage(static::translate(['PLUGIN_LOGIN.TOO_MANY_LOGIN_ATTEMPTS', $rateLimiter->getInterval()]), 'error');
|
|
|
|
$this->grav->redirect('/');
|
|
}
|
|
|
|
Admin::DEBUG && Admin::addDebugMessage('Admin login', $credentials);
|
|
|
|
// Fire Login process.
|
|
$event = $login->login(
|
|
$credentials,
|
|
['admin' => true, 'twofa' => $twofa],
|
|
['authorize' => 'admin.login', 'return_event' => true]
|
|
);
|
|
$user = $event->getUser();
|
|
|
|
Admin::DEBUG && Admin::addDebugMessage('Admin login: user', $user);
|
|
|
|
if ($user->authenticated) {
|
|
$rateLimiter->resetRateLimit($ipKey, 'ip')->resetRateLimit($userKey);
|
|
if ($user->authorized) {
|
|
$event->defMessage('PLUGIN_ADMIN.LOGIN_LOGGED_IN', 'info');
|
|
|
|
$event->defRedirect($post['redirect'] ?? $redirect);
|
|
} else {
|
|
$this->session->redirect = $redirect;
|
|
}
|
|
} else {
|
|
if ($user->authorized) {
|
|
$event->defMessage('PLUGIN_LOGIN.ACCESS_DENIED', 'error');
|
|
} else {
|
|
$event->defMessage('PLUGIN_LOGIN.LOGIN_FAILED', 'error');
|
|
}
|
|
}
|
|
|
|
$event->defRedirect($redirect);
|
|
|
|
$message = $event->getMessage();
|
|
if ($message) {
|
|
$this->setMessage(static::translate($message), $event->getMessageType());
|
|
}
|
|
|
|
/** @var Pages $pages */
|
|
$pages = $this->grav['pages'];
|
|
$redirect = $pages->baseRoute() . $event->getRedirect();
|
|
|
|
$this->grav->redirect($redirect, $event->getRedirectCode());
|
|
}
|
|
|
|
/**
|
|
* Check Two-Factor Authentication.
|
|
*
|
|
* @param array $data
|
|
* @param array $post
|
|
* @return never-return
|
|
*/
|
|
public function twoFa($data, $post)
|
|
{
|
|
/** @var Pages $pages */
|
|
$pages = $this->grav['pages'];
|
|
$baseRoute = $pages->baseRoute();
|
|
|
|
/** @var Login $login */
|
|
$login = $this->grav['login'];
|
|
|
|
/** @var TwoFactorAuth $twoFa */
|
|
$twoFa = $login->twoFactorAuth();
|
|
$user = $this->grav['user'];
|
|
|
|
$code = $data['2fa_code'] ?? null;
|
|
|
|
$secret = $user->twofa_secret ?? null;
|
|
|
|
if (!$code || !$secret || !$twoFa->verifyCode($secret, $code)) {
|
|
$login->logout(['admin' => true]);
|
|
|
|
$this->grav['session']->setFlashCookieObject(Admin::TMP_COOKIE_NAME, ['message' => $this->translate('PLUGIN_ADMIN.2FA_FAILED'), 'status' => 'error']);
|
|
|
|
$this->grav->redirect($baseRoute . $this->uri->route(), 303);
|
|
}
|
|
|
|
$this->setMessage($this->translate('PLUGIN_ADMIN.LOGIN_LOGGED_IN'), 'info');
|
|
|
|
$user->authorized = true;
|
|
|
|
$redirect = $baseRoute . $post['redirect'];
|
|
|
|
$this->grav->redirect($redirect);
|
|
}
|
|
|
|
/**
|
|
* Logout from admin.
|
|
*
|
|
* @param array $data
|
|
* @param array $post
|
|
* @return never-return
|
|
*/
|
|
public function logout($data, $post)
|
|
{
|
|
/** @var Login $login */
|
|
$login = $this->grav['login'];
|
|
|
|
$event = $login->logout(['admin' => true], ['return_event' => true]);
|
|
|
|
$event->defMessage('PLUGIN_ADMIN.LOGGED_OUT', 'info');
|
|
$message = $event->getMessage();
|
|
if ($message) {
|
|
$this->grav['session']->setFlashCookieObject(Admin::TMP_COOKIE_NAME, ['message' => $this->translate($message), 'status' => $event->getMessageType()]);
|
|
}
|
|
|
|
$this->grav->redirect($this->base);
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public static function doAnyUsersExist()
|
|
{
|
|
$accounts = Grav::instance()['accounts'] ?? null;
|
|
|
|
return $accounts && $accounts->count() > 0;
|
|
}
|
|
|
|
/**
|
|
* Add message into the session queue.
|
|
*
|
|
* @param string $msg
|
|
* @param string $type
|
|
* @return void
|
|
*/
|
|
public function setMessage($msg, $type = 'info')
|
|
{
|
|
/** @var Message $messages */
|
|
$messages = $this->grav['messages'];
|
|
$messages->add($msg, $type);
|
|
}
|
|
|
|
/**
|
|
* @param string $msg
|
|
* @param string $type
|
|
* @return void
|
|
*/
|
|
public function addTempMessage($msg, $type)
|
|
{
|
|
$this->temp_messages[] = ['message' => $msg, 'scope' => $type];
|
|
}
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
public function getTempMessages()
|
|
{
|
|
return $this->temp_messages;
|
|
}
|
|
|
|
/**
|
|
* Translate a string to the user-defined language
|
|
*
|
|
* @param array|string $args
|
|
* @param array|null $languages
|
|
* @return string|string[]|null
|
|
*/
|
|
public static function translate($args, $languages = null)
|
|
{
|
|
$grav = Grav::instance();
|
|
|
|
if (is_array($args)) {
|
|
$lookup = array_shift($args);
|
|
} else {
|
|
$lookup = $args;
|
|
$args = [];
|
|
}
|
|
|
|
if (!$languages) {
|
|
if ($grav['config']->get('system.languages.translations_fallback', true)) {
|
|
$languages = $grav['language']->getFallbackLanguages();
|
|
} else {
|
|
$languages = (array)$grav['language']->getDefault();
|
|
}
|
|
$languages = $grav['user']->authenticated ? [$grav['user']->language] : $languages;
|
|
} else {
|
|
$languages = (array)$languages;
|
|
}
|
|
|
|
foreach ((array)$languages as $lang) {
|
|
$translation = $grav['language']->getTranslation($lang, $lookup, true);
|
|
|
|
if (!$translation) {
|
|
$language = $grav['language']->getDefault() ?: 'en';
|
|
$translation = $grav['language']->getTranslation($language, $lookup, true);
|
|
}
|
|
|
|
if (!$translation) {
|
|
$language = 'en';
|
|
$translation = $grav['language']->getTranslation($language, $lookup, true);
|
|
}
|
|
|
|
if ($translation) {
|
|
if (count($args) >= 1) {
|
|
return vsprintf($translation, $args);
|
|
}
|
|
|
|
return $translation;
|
|
}
|
|
}
|
|
|
|
return $lookup;
|
|
}
|
|
|
|
/**
|
|
* Checks user authorisation to the action.
|
|
*
|
|
* @param string|string[] $action
|
|
* @return bool
|
|
*/
|
|
public function authorize($action = 'admin.login')
|
|
{
|
|
$action = (array)$action;
|
|
|
|
$user = $this->user;
|
|
|
|
foreach ($action as $a) {
|
|
// Ignore 'admin.super' if it's not the only value to be checked.
|
|
if ($a === 'admin.super' && count($action) > 1 && $user instanceof FlexObjectInterface) {
|
|
continue;
|
|
}
|
|
if ($user->authorize($a)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Gets configuration data.
|
|
*
|
|
* @param string $type
|
|
* @param array $post
|
|
* @return object
|
|
* @throws \RuntimeException
|
|
*/
|
|
public function data($type, array $post = [])
|
|
{
|
|
if (!$post) {
|
|
$post = $this->preparePost($this->grav['uri']->post()['data'] ?? []);
|
|
}
|
|
|
|
try {
|
|
return $this->getConfigurationData($type, $post);
|
|
} catch (\RuntimeException $e) {
|
|
return new Data\Data();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get configuration data.
|
|
*
|
|
* Note: If you pass $post, make sure you pass all the fields in the blueprint or data gets lost!
|
|
*
|
|
* @param string $type
|
|
* @param array|null $post
|
|
* @return object
|
|
* @throws \RuntimeException
|
|
*/
|
|
public function getConfigurationData($type, array $post = null)
|
|
{
|
|
static $data = [];
|
|
|
|
if (isset($data[$type])) {
|
|
$obj = $data[$type];
|
|
if ($post) {
|
|
if ($obj instanceof Data\Data) {
|
|
$obj = $this->mergePost($obj, $post);
|
|
} elseif ($obj instanceof UserInterface) {
|
|
$obj->update($this->cleanUserPost($post));
|
|
}
|
|
}
|
|
|
|
return $obj;
|
|
}
|
|
|
|
// Check to see if a data type is plugin-provided, before looking into core ones
|
|
$event = $this->grav->fireEvent('onAdminData', new Event(['type' => &$type]));
|
|
if ($event) {
|
|
if (isset($event['data_type'])) {
|
|
return $event['data_type'];
|
|
}
|
|
|
|
if (is_string($event['type'])) {
|
|
$type = $event['type'];
|
|
}
|
|
}
|
|
|
|
/** @var UniformResourceLocator $locator */
|
|
$locator = $this->grav['locator'];
|
|
|
|
// Configuration file will be saved to the existing config stream.
|
|
$filename = $locator->findResource('config://') . "/{$type}.yaml";
|
|
$file = CompiledYamlFile::instance($filename);
|
|
|
|
if (preg_match('|plugins/|', $type)) {
|
|
$obj = Plugins::get(preg_replace('|plugins/|', '', $type));
|
|
if (null === $obj) {
|
|
throw new \RuntimeException("Plugin '{$type}' doesn't exist!");
|
|
}
|
|
$obj->file($file);
|
|
|
|
} elseif (preg_match('|themes/|', $type)) {
|
|
/** @var Themes $themes */
|
|
$themes = $this->grav['themes'];
|
|
$obj = $themes->get(preg_replace('|themes/|', '', $type));
|
|
if (null === $obj) {
|
|
throw new \RuntimeException("Theme '{$type}' doesn't exist!");
|
|
}
|
|
$obj->file($file);
|
|
|
|
} elseif (preg_match('|users?/|', $type)) {
|
|
/** @var UserCollectionInterface $users */
|
|
$users = $this->grav['accounts'];
|
|
|
|
$obj = $users->load(preg_replace('|users?/|', '', $type));
|
|
|
|
} elseif (preg_match('|config/|', $type)) {
|
|
$type = preg_replace('|config/|', '', $type);
|
|
$blueprints = $this->blueprints("config/{$type}");
|
|
if (!$blueprints->form()) {
|
|
throw new \RuntimeException("Configuration type '{$type}' doesn't exist!");
|
|
}
|
|
|
|
// Configuration file will be saved to the existing config stream.
|
|
$filename = $locator->findResource('config://') . "/{$type}.yaml";
|
|
$file = CompiledYamlFile::instance($filename);
|
|
|
|
$config = $this->grav['config'];
|
|
$obj = new Data\Data($config->get($type, []), $blueprints);
|
|
$obj->file($file);
|
|
|
|
} elseif (preg_match('|media-manager/|', $type)) {
|
|
$filename = base64_decode(preg_replace('|media-manager/|', '', $type));
|
|
|
|
$file = File::instance($filename);
|
|
|
|
$pages = static::enablePages();
|
|
|
|
$obj = new \stdClass();
|
|
$obj->title = $file->basename();
|
|
$obj->path = $file->filename();
|
|
$obj->file = $file;
|
|
$obj->page = $pages->get(dirname($obj->path));
|
|
|
|
$fileInfo = Utils::pathinfo($obj->title);
|
|
$filename = str_replace(['@3x', '@2x'], '', $fileInfo['filename']);
|
|
if (isset($fileInfo['extension'])) {
|
|
$filename .= '.' . $fileInfo['extension'];
|
|
}
|
|
|
|
if ($obj->page && isset($obj->page->media()[$filename])) {
|
|
$obj->metadata = new Data\Data($obj->page->media()[$filename]->metadata());
|
|
}
|
|
|
|
} else {
|
|
throw new \RuntimeException("Data type '{$type}' doesn't exist!");
|
|
}
|
|
|
|
$data[$type] = $obj;
|
|
if ($post) {
|
|
if ($obj instanceof Data\Data) {
|
|
$obj = $this->mergePost($obj, $post);
|
|
} elseif ($obj instanceof UserInterface) {
|
|
$obj->update($this->cleanUserPost($post));
|
|
}
|
|
}
|
|
|
|
return $obj;
|
|
}
|
|
|
|
/**
|
|
* @param Data\Data $object
|
|
* @param array $post
|
|
* @return Data\Data
|
|
*/
|
|
protected function mergePost(Data\Data $object, array $post)
|
|
{
|
|
$object->merge($post);
|
|
|
|
$blueprint = $object->blueprints();
|
|
$data = $blueprint->flattenData($post, true);
|
|
|
|
foreach ($data as $key => $val) {
|
|
if ($val === null) {
|
|
$object->set($key, $val);
|
|
}
|
|
}
|
|
|
|
return $object;
|
|
}
|
|
|
|
/**
|
|
* Clean user form post and remove extra stuff that may be passed along
|
|
*
|
|
* @param array $post
|
|
* @return array
|
|
*/
|
|
public function cleanUserPost($post)
|
|
{
|
|
// Clean fields for all users
|
|
unset($post['hashed_password']);
|
|
|
|
// Clean field for users who shouldn't be able to modify these fields
|
|
if (!$this->authorize(['admin.user', 'admin.super'])) {
|
|
unset($post['access'], $post['state']);
|
|
}
|
|
|
|
return $post;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
protected function hasErrorMessage()
|
|
{
|
|
$msgs = $this->grav['messages']->all();
|
|
foreach ($msgs as $msg) {
|
|
if (isset($msg['scope']) && $msg['scope'] === 'error') {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns blueprints for the given type.
|
|
*
|
|
* @param string $type
|
|
* @return Data\Blueprint
|
|
*/
|
|
public function blueprints($type)
|
|
{
|
|
if ($this->blueprints === null) {
|
|
$this->blueprints = new Data\Blueprints('blueprints://');
|
|
}
|
|
|
|
return $this->blueprints->get($type);
|
|
}
|
|
|
|
/**
|
|
* Converts dot notation to array notation.
|
|
*
|
|
* @param string $name
|
|
* @return string
|
|
*/
|
|
public function field($name)
|
|
{
|
|
$path = explode('.', $name);
|
|
|
|
return array_shift($path) . ($path ? '[' . implode('][', $path) . ']' : '');
|
|
}
|
|
|
|
/**
|
|
* Get all routes.
|
|
*
|
|
* @param bool $unique
|
|
* @return array
|
|
*/
|
|
public function routes($unique = false)
|
|
{
|
|
$pages = static::enablePages();
|
|
|
|
if ($unique) {
|
|
$routes = array_unique($pages->routes());
|
|
} else {
|
|
$routes = $pages->routes();
|
|
}
|
|
|
|
return $routes;
|
|
}
|
|
|
|
/**
|
|
* Count the pages
|
|
*
|
|
* @return int
|
|
*/
|
|
public function pagesCount()
|
|
{
|
|
if (!$this->pages_count) {
|
|
$pages = static::enablePages();
|
|
$this->pages_count = count($pages->all());
|
|
}
|
|
|
|
return $this->pages_count;
|
|
}
|
|
|
|
/**
|
|
* Get all template types
|
|
*
|
|
* @param array|null $ignore
|
|
* @return array
|
|
*/
|
|
public function types(?array $ignore = [])
|
|
{
|
|
if (null === $ignore) {
|
|
return AdminPlugin::pagesTypes();
|
|
}
|
|
|
|
$types = Pages::types();
|
|
|
|
return $ignore ? array_diff_key($types, array_flip($ignore)) : $types;
|
|
}
|
|
|
|
/**
|
|
* Get all modular template types
|
|
*
|
|
* @param array|null $ignore
|
|
* @return array
|
|
*/
|
|
public function modularTypes(?array $ignore = [])
|
|
{
|
|
if (null === $ignore) {
|
|
return AdminPlugin::pagesModularTypes();
|
|
}
|
|
|
|
$types = Pages::modularTypes();
|
|
|
|
return $ignore ? array_diff_key($types, array_flip($ignore)) : $types;
|
|
}
|
|
|
|
/**
|
|
* Get all access levels
|
|
*
|
|
* @return array
|
|
*/
|
|
public function accessLevels()
|
|
{
|
|
$pages = static::enablePages();
|
|
|
|
if (method_exists($pages, 'accessLevels')) {
|
|
return $pages->accessLevels();
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* @param string|null $package_slug
|
|
* @return string[]|string
|
|
*/
|
|
public function license($package_slug)
|
|
{
|
|
return Licenses::get($package_slug);
|
|
}
|
|
|
|
/**
|
|
* Generate an array of dependencies for a package, used to generate a list of
|
|
* packages that can be removed when removing a package.
|
|
*
|
|
* @param string $slug The package slug
|
|
* @return array|bool
|
|
*/
|
|
public function dependenciesThatCanBeRemovedWhenRemoving($slug)
|
|
{
|
|
$gpm = $this->gpm();
|
|
if (!$gpm) {
|
|
return false;
|
|
}
|
|
|
|
$dependencies = [];
|
|
|
|
$package = $this->getPackageFromGPM($slug);
|
|
|
|
if ($package && $package->dependencies) {
|
|
foreach ($package->dependencies as $dependency) {
|
|
// if (count($gpm->getPackagesThatDependOnPackage($dependency)) > 1) {
|
|
// continue;
|
|
// }
|
|
if (isset($dependency['name'])) {
|
|
$dependency = $dependency['name'];
|
|
}
|
|
|
|
if (!in_array($dependency, $dependencies, true) && !in_array($dependency, ['admin', 'form', 'login', 'email', 'php'])) {
|
|
$dependencies[] = $dependency;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $dependencies;
|
|
}
|
|
|
|
/**
|
|
* Get the GPM instance
|
|
*
|
|
* @return GPM The GPM instance
|
|
*/
|
|
public function gpm()
|
|
{
|
|
if (!$this->gpm) {
|
|
try {
|
|
$this->gpm = new GPM();
|
|
} catch (\Exception $e) {
|
|
$this->setMessage($e->getMessage(), 'error');
|
|
}
|
|
}
|
|
|
|
return $this->gpm;
|
|
}
|
|
|
|
/**
|
|
* @param string $package_slug
|
|
* @return mixed
|
|
*/
|
|
public function getPackageFromGPM($package_slug)
|
|
{
|
|
$package = $this->plugins(true)[$package_slug];
|
|
if (!$package) {
|
|
$package = $this->themes(true)[$package_slug];
|
|
}
|
|
|
|
return $package;
|
|
}
|
|
|
|
/**
|
|
* Get all plugins.
|
|
*
|
|
* @param bool $local
|
|
* @return mixed
|
|
*/
|
|
public function plugins($local = true)
|
|
{
|
|
$gpm = $this->gpm();
|
|
|
|
if (!$gpm) {
|
|
return false;
|
|
}
|
|
|
|
if ($local) {
|
|
return $gpm->getInstalledPlugins();
|
|
}
|
|
|
|
$plugins = $gpm->getRepositoryPlugins();
|
|
if ($plugins) {
|
|
return $plugins->filter(function ($package, $slug) use ($gpm) {
|
|
return !$gpm->isPluginInstalled($slug);
|
|
});
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Get all themes.
|
|
*
|
|
* @param bool $local
|
|
* @return mixed
|
|
*/
|
|
public function themes($local = true)
|
|
{
|
|
$gpm = $this->gpm();
|
|
|
|
if (!$gpm) {
|
|
return false;
|
|
}
|
|
|
|
if ($local) {
|
|
return $gpm->getInstalledThemes();
|
|
}
|
|
|
|
$themes = $gpm->getRepositoryThemes();
|
|
if ($themes) {
|
|
return $themes->filter(function ($package, $slug) use ($gpm) {
|
|
return !$gpm->isThemeInstalled($slug);
|
|
});
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Get list of packages that depend on the passed package slug
|
|
*
|
|
* @param string $slug The package slug
|
|
*
|
|
* @return array|bool
|
|
*/
|
|
public function getPackagesThatDependOnPackage($slug)
|
|
{
|
|
$gpm = $this->gpm();
|
|
if (!$gpm) {
|
|
return false;
|
|
}
|
|
|
|
return $gpm->getPackagesThatDependOnPackage($slug);
|
|
}
|
|
|
|
/**
|
|
* Check the passed packages list can be updated
|
|
*
|
|
* @param array $packages
|
|
* @return bool
|
|
* @throws \Exception
|
|
*/
|
|
public function checkPackagesCanBeInstalled($packages)
|
|
{
|
|
$gpm = $this->gpm();
|
|
if (!$gpm) {
|
|
return false;
|
|
}
|
|
|
|
$this->gpm->checkPackagesCanBeInstalled($packages);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get an array of dependencies needed to be installed or updated for a list of packages
|
|
* to be installed.
|
|
*
|
|
* @param array $packages The packages slugs
|
|
* @return array|bool
|
|
*/
|
|
public function getDependenciesNeededToInstall($packages)
|
|
{
|
|
$gpm = $this->gpm();
|
|
if (!$gpm) {
|
|
return false;
|
|
}
|
|
|
|
return $this->gpm->getDependencies($packages);
|
|
}
|
|
|
|
/**
|
|
* Used by the Dashboard in the admin to display the X latest pages
|
|
* that have been modified
|
|
*
|
|
* @param int $count number of pages to pull back
|
|
* @return array|null
|
|
*/
|
|
public function latestPages($count = 10)
|
|
{
|
|
/** @var Flex $flex */
|
|
$flex = $this->grav['flex_objects'] ?? null;
|
|
$directory = $flex ? $flex->getDirectory('pages') : null;
|
|
if ($directory) {
|
|
return $directory->getIndex()->sort(['timestamp' => 'DESC'])->slice(0, $count);
|
|
}
|
|
|
|
$pages = static::enablePages();
|
|
|
|
$latest = [];
|
|
|
|
if (null === $pages->routes()) {
|
|
return null;
|
|
}
|
|
|
|
foreach ($pages->routes() as $url => $path) {
|
|
$page = $pages->find($url, true);
|
|
if ($page && $page->routable()) {
|
|
$latest[$page->route()] = ['modified' => $page->modified(), 'page' => $page];
|
|
}
|
|
}
|
|
|
|
// sort based on modified
|
|
uasort($latest, function ($a, $b) {
|
|
if ($a['modified'] == $b['modified']) {
|
|
return 0;
|
|
}
|
|
|
|
return ($a['modified'] > $b['modified']) ? -1 : 1;
|
|
});
|
|
|
|
// build new array with just pages in it
|
|
$list = [];
|
|
foreach ($latest as $item) {
|
|
$list[] = $item['page'];
|
|
}
|
|
|
|
return array_slice($list, 0, $count);
|
|
}
|
|
|
|
/**
|
|
* Get log file for fatal errors.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function logEntry()
|
|
{
|
|
$file = File::instance($this->grav['locator']->findResource("log://{$this->route}.html"));
|
|
$content = $file->content();
|
|
$file->free();
|
|
|
|
return $content;
|
|
}
|
|
|
|
/**
|
|
* Search in the logs when was the latest backup made
|
|
*
|
|
* @return array Array containing the latest backup information
|
|
*/
|
|
public function lastBackup()
|
|
{
|
|
$file = JsonFile::instance($this->grav['locator']->findResource('log://backup.log'));
|
|
$content = $file->content();
|
|
if (empty($content)) {
|
|
return [
|
|
'days' => '∞',
|
|
'chart_fill' => 100,
|
|
'chart_empty' => 0
|
|
];
|
|
}
|
|
|
|
$backup = new \DateTime();
|
|
$backup->setTimestamp($content['time']);
|
|
$diff = $backup->diff(new \DateTime());
|
|
|
|
$days = $diff->days;
|
|
$chart_fill = $days > 30 ? 100 : round($days / 30 * 100);
|
|
|
|
return [
|
|
'days' => $days,
|
|
'chart_fill' => $chart_fill,
|
|
'chart_empty' => 100 - $chart_fill
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Determine if the plugin or theme info passed is from Team Grav
|
|
*
|
|
* @param object $info Plugin or Theme info object
|
|
* @return bool
|
|
*/
|
|
public function isTeamGrav($info)
|
|
{
|
|
return isset($info['author']['name']) && ($info['author']['name'] === 'Team Grav' || Utils::contains($info['author']['name'], 'Trilby Media'));
|
|
}
|
|
|
|
/**
|
|
* Determine if the plugin or theme info passed is premium
|
|
*
|
|
* @param object $info Plugin or Theme info object
|
|
* @return bool
|
|
*/
|
|
public function isPremiumProduct($info)
|
|
{
|
|
return isset($info['premium']);
|
|
}
|
|
|
|
/**
|
|
* Renders phpinfo
|
|
*
|
|
* @return string The phpinfo() output
|
|
*/
|
|
public function phpinfo()
|
|
{
|
|
if (function_exists('phpinfo')) {
|
|
ob_start();
|
|
phpinfo();
|
|
$pinfo = ob_get_clean();
|
|
$pinfo = preg_replace('%^.*<body>(.*)</body>.*$%ms', '$1', $pinfo);
|
|
|
|
return $pinfo;
|
|
}
|
|
|
|
return 'phpinfo() method is not available on this server.';
|
|
}
|
|
|
|
/**
|
|
* Guest date format based on euro/US
|
|
*
|
|
* @param string|null $date
|
|
* @return string
|
|
*/
|
|
public function guessDateFormat($date)
|
|
{
|
|
static $guess;
|
|
|
|
$date_formats = [
|
|
'm/d/y',
|
|
'm/d/Y',
|
|
'n/d/y',
|
|
'n/d/Y',
|
|
'd-m-Y',
|
|
'd-m-y',
|
|
];
|
|
|
|
$time_formats = [
|
|
'H:i',
|
|
'G:i',
|
|
'h:ia',
|
|
'g:ia'
|
|
];
|
|
|
|
$date = (string)$date;
|
|
if (!isset($guess[$date])) {
|
|
$guess[$date] = 'd-m-Y H:i';
|
|
foreach ($date_formats as $date_format) {
|
|
foreach ($time_formats as $time_format) {
|
|
$full_format = "{$date_format} {$time_format}";
|
|
if ($this->validateDate($date, $full_format)) {
|
|
$guess[$date] = $full_format;
|
|
break 2;
|
|
}
|
|
$full_format = "{$time_format} {$date_format}";
|
|
if ($this->validateDate($date, $full_format)) {
|
|
$guess[$date] = $full_format;
|
|
break 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $guess[$date];
|
|
}
|
|
|
|
/**
|
|
* @param string $date
|
|
* @param string $format
|
|
* @return bool
|
|
*/
|
|
public function validateDate($date, $format)
|
|
{
|
|
$d = DateTime::createFromFormat($format, $date);
|
|
|
|
return $d && $d->format($format) == $date;
|
|
}
|
|
|
|
/**
|
|
* @param string $php_format
|
|
* @return string
|
|
*/
|
|
public function dateformatToMomentJS($php_format)
|
|
{
|
|
$SYMBOLS_MATCHING = [
|
|
// Day
|
|
'd' => 'DD',
|
|
'D' => 'ddd',
|
|
'j' => 'D',
|
|
'l' => 'dddd',
|
|
'N' => 'E',
|
|
'S' => 'Do',
|
|
'w' => 'd',
|
|
'z' => 'DDD',
|
|
// Week
|
|
'W' => 'W',
|
|
// Month
|
|
'F' => 'MMMM',
|
|
'm' => 'MM',
|
|
'M' => 'MMM',
|
|
'n' => 'M',
|
|
't' => '',
|
|
// Year
|
|
'L' => '',
|
|
'o' => 'GGGG',
|
|
'Y' => 'YYYY',
|
|
'y' => 'yy',
|
|
// Time
|
|
'a' => 'a',
|
|
'A' => 'A',
|
|
'B' => 'SSS',
|
|
'g' => 'h',
|
|
'G' => 'H',
|
|
'h' => 'hh',
|
|
'H' => 'HH',
|
|
'i' => 'mm',
|
|
's' => 'ss',
|
|
'u' => '',
|
|
// Timezone
|
|
'e' => '',
|
|
'I' => '',
|
|
'O' => 'ZZ',
|
|
'P' => 'Z',
|
|
'T' => 'z',
|
|
'Z' => '',
|
|
// Full Date/Time
|
|
'c' => '',
|
|
'r' => 'llll ZZ',
|
|
'U' => 'X'
|
|
];
|
|
$js_format = '';
|
|
$escaping = false;
|
|
$len = strlen($php_format);
|
|
for ($i = 0; $i < $len; $i++) {
|
|
$char = $php_format[$i];
|
|
if ($char === '\\') // PHP date format escaping character
|
|
{
|
|
$i++;
|
|
if ($escaping) {
|
|
$js_format .= $php_format[$i];
|
|
} else {
|
|
$js_format .= '\'' . $php_format[$i];
|
|
}
|
|
$escaping = true;
|
|
} else {
|
|
if ($escaping) {
|
|
$js_format .= "'";
|
|
$escaping = false;
|
|
}
|
|
if (isset($SYMBOLS_MATCHING[$char])) {
|
|
$js_format .= $SYMBOLS_MATCHING[$char];
|
|
} else {
|
|
$js_format .= $char;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $js_format;
|
|
}
|
|
|
|
/**
|
|
* Gets the entire permissions array
|
|
*
|
|
* @return array
|
|
* @deprecated 1.10 Use $grav['permissions']->getInstances() instead.
|
|
*/
|
|
public function getPermissions()
|
|
{
|
|
user_error(__METHOD__ . '() is deprecated since Admin 1.10, use $grav[\'permissions\']->getInstances() instead', E_USER_DEPRECATED);
|
|
|
|
$grav = $this->grav;
|
|
/** @var Permissions $permissions */
|
|
$permissions = $grav['permissions'];
|
|
|
|
return array_fill_keys(array_keys($permissions->getInstances()), 'boolean');
|
|
}
|
|
|
|
/**
|
|
* Sets the entire permissions array
|
|
*
|
|
* @param array $permissions
|
|
* @deprecated 1.10 Use PermissionsRegisterEvent::class event instead.
|
|
*/
|
|
public function setPermissions($permissions)
|
|
{
|
|
user_error(__METHOD__ . '() is deprecated since Admin 1.10, use PermissionsRegisterEvent::class event instead', E_USER_DEPRECATED);
|
|
|
|
$this->addPermissions($permissions);
|
|
}
|
|
|
|
/**
|
|
* Adds a permission to the permissions array
|
|
*
|
|
* @param array $permissions
|
|
* @deprecated 1.10 Use RegisterPermissionsEvent::class event instead.
|
|
*/
|
|
public function addPermissions($permissions)
|
|
{
|
|
user_error(__METHOD__ . '() is deprecated since Admin 1.10, use RegisterPermissionsEvent::class event instead', E_USER_DEPRECATED);
|
|
|
|
$grav = $this->grav;
|
|
/** @var Permissions $object */
|
|
$object = $grav['permissions'];
|
|
foreach ($permissions as $name => $type) {
|
|
if (!$object->hasAction($name)) {
|
|
$action = new Action($name);
|
|
$object->addAction($action);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function getNotifications($force = false)
|
|
{
|
|
$last_checked = null;
|
|
$filename = $this->grav['locator']->findResource('user://data/notifications/' . md5($this->grav['user']->username) . YAML_EXT, true, true);
|
|
$userStatus = $this->grav['locator']->findResource('user://data/notifications/' . $this->grav['user']->username . YAML_EXT, true, true);
|
|
|
|
$notifications_file = CompiledYamlFile::instance($filename);
|
|
$notifications_content = (array)$notifications_file->content();
|
|
|
|
$userStatus_file = CompiledYamlFile::instance($userStatus);
|
|
$userStatus_content = (array)$userStatus_file->content();
|
|
|
|
$last_checked = $notifications_content['last_checked'] ?? null;
|
|
$notifications = $notifications_content['data'] ?? array();
|
|
$timeout = $this->grav['config']->get('system.session.timeout', 1800);
|
|
|
|
if ($force || !$last_checked || empty($notifications) || (time() - $last_checked > $timeout)) {
|
|
$body = Response::get('https://getgrav.org/notifications.json?' . time());
|
|
// $body = Response::get('http://localhost/notifications.json?' . time());
|
|
$notifications = json_decode($body, true);
|
|
|
|
// Sort by date
|
|
usort($notifications, function ($a, $b) {
|
|
return strcmp($a['date'], $b['date']);
|
|
});
|
|
|
|
// Reverse order and create a new array
|
|
$notifications = array_reverse($notifications);
|
|
$cleaned_notifications = [];
|
|
|
|
foreach ($notifications as $key => $notification) {
|
|
|
|
if (isset($notification['permissions']) && !$this->authorize($notification['permissions'])) {
|
|
continue;
|
|
}
|
|
|
|
if (isset($notification['dependencies'])) {
|
|
foreach ($notification['dependencies'] as $dependency => $constraints) {
|
|
if ($dependency === 'grav') {
|
|
if (!Semver::satisfies(GRAV_VERSION, $constraints)) {
|
|
continue 2;
|
|
}
|
|
} else {
|
|
$packages = array_merge($this->plugins()->toArray(), $this->themes()->toArray());
|
|
if (!isset($packages[$dependency])) {
|
|
continue 2;
|
|
} else {
|
|
$version = $packages[$dependency]['version'];
|
|
if (!Semver::satisfies($version, $constraints)) {
|
|
continue 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
$cleaned_notifications[] = $notification;
|
|
|
|
}
|
|
|
|
// reset notifications
|
|
$notifications = [];
|
|
|
|
foreach($cleaned_notifications as $notification) {
|
|
foreach ($notification['location'] as $location) {
|
|
$notifications = array_merge_recursive($notifications, [$location => [$notification]]);
|
|
}
|
|
}
|
|
|
|
|
|
$notifications_file->content(['last_checked' => time(), 'data' => $notifications]);
|
|
$notifications_file->save();
|
|
}
|
|
|
|
foreach ($notifications as $location => $list) {
|
|
$notifications[$location] = array_filter($list, function ($notification) use ($userStatus_content) {
|
|
$element = $userStatus_content[$notification['id']] ?? null;
|
|
if (isset($element)) {
|
|
if (isset($notification['reappear_after'])) {
|
|
$now = new \DateTime();
|
|
$hidden_on = new \DateTime($element);
|
|
$hidden_on->modify($notification['reappear_after']);
|
|
|
|
if ($now >= $hidden_on) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
}
|
|
|
|
|
|
return $notifications;
|
|
}
|
|
|
|
/**
|
|
* Get https://getgrav.org news feed
|
|
*
|
|
* @return mixed
|
|
* @throws MalformedXmlException
|
|
*/
|
|
public function getFeed($force = false)
|
|
{
|
|
$last_checked = null;
|
|
$filename = $this->grav['locator']->findResource('user://data/feed/' . md5($this->grav['user']->username) . YAML_EXT, true, true);
|
|
|
|
$feed_file = CompiledYamlFile::instance($filename);
|
|
$feed_content = (array)$feed_file->content();
|
|
|
|
$last_checked = $feed_content['last_checked'] ?? null;
|
|
$feed = $feed_content['data'] ?? array();
|
|
$timeout = $this->grav['config']->get('system.session.timeout', 1800);
|
|
|
|
if ($force || !$last_checked || empty($feed) || ($last_checked && (time() - $last_checked > $timeout))) {
|
|
$feed_url = 'https://getgrav.org/blog.atom';
|
|
$body = Response::get($feed_url);
|
|
|
|
$reader = new Reader();
|
|
$parser = $reader->getParser($feed_url, $body, 'utf-8');
|
|
$data = $parser->execute()->getItems();
|
|
|
|
// Get top 10
|
|
$data = array_slice($data, 0, 10);
|
|
|
|
$feed = array_map(function ($entry) {
|
|
$simple_entry['title'] = $entry->getTitle();
|
|
$simple_entry['url'] = $entry->getUrl();
|
|
$simple_entry['date'] = $entry->getDate()->getTimestamp();
|
|
$simple_entry['nicetime'] = $this->adminNiceTime($simple_entry['date']);
|
|
return $simple_entry;
|
|
}, $data);
|
|
|
|
$feed_file->content(['last_checked' => time(), 'data' => $feed]);
|
|
$feed_file->save();
|
|
}
|
|
|
|
return $feed;
|
|
|
|
}
|
|
|
|
public function adminNiceTime($date, $long_strings = true)
|
|
{
|
|
if (empty($date)) {
|
|
return $this->translate('GRAV.NICETIME.NO_DATE_PROVIDED', null);
|
|
}
|
|
|
|
if ($long_strings) {
|
|
$periods = [
|
|
'NICETIME.SECOND',
|
|
'NICETIME.MINUTE',
|
|
'NICETIME.HOUR',
|
|
'NICETIME.DAY',
|
|
'NICETIME.WEEK',
|
|
'NICETIME.MONTH',
|
|
'NICETIME.YEAR',
|
|
'NICETIME.DECADE'
|
|
];
|
|
} else {
|
|
$periods = [
|
|
'NICETIME.SEC',
|
|
'NICETIME.MIN',
|
|
'NICETIME.HR',
|
|
'NICETIME.DAY',
|
|
'NICETIME.WK',
|
|
'NICETIME.MO',
|
|
'NICETIME.YR',
|
|
'NICETIME.DEC'
|
|
];
|
|
}
|
|
|
|
$lengths = ['60', '60', '24', '7', '4.35', '12', '10'];
|
|
|
|
$now = time();
|
|
|
|
// check if unix timestamp
|
|
if ((string)(int)$date === (string)$date) {
|
|
$unix_date = $date;
|
|
} else {
|
|
$unix_date = strtotime($date);
|
|
}
|
|
|
|
// check validity of date
|
|
if (empty($unix_date)) {
|
|
return $this->translate('GRAV.NICETIME.BAD_DATE', null);
|
|
}
|
|
|
|
// is it future date or past date
|
|
if ($now > $unix_date) {
|
|
$difference = $now - $unix_date;
|
|
$tense = $this->translate('GRAV.NICETIME.AGO', null);
|
|
|
|
} else {
|
|
$difference = $unix_date - $now;
|
|
$tense = $this->translate('GRAV.NICETIME.FROM_NOW', null);
|
|
}
|
|
|
|
$len = count($lengths) - 1;
|
|
for ($j = 0; $difference >= $lengths[$j] && $j < $len; $j++) {
|
|
$difference /= $lengths[$j];
|
|
}
|
|
|
|
$difference = round($difference);
|
|
|
|
if ($difference !== 1) {
|
|
$periods[$j] .= '_PLURAL';
|
|
}
|
|
|
|
if ($this->grav['language']->getTranslation($this->grav['user']->language,
|
|
$periods[$j] . '_MORE_THAN_TWO')
|
|
) {
|
|
if ($difference > 2) {
|
|
$periods[$j] .= '_MORE_THAN_TWO';
|
|
}
|
|
}
|
|
|
|
$periods[$j] = $this->translate('GRAV.'.$periods[$j], null);
|
|
|
|
return "{$difference} {$periods[$j]} {$tense}";
|
|
}
|
|
|
|
public function findFormFields($type, $fields, $found_fields = [])
|
|
{
|
|
foreach ($fields as $key => $field) {
|
|
|
|
if (isset($field['type']) && $field['type'] == $type) {
|
|
$found_fields[$key] = $field;
|
|
} elseif (isset($field['fields'])) {
|
|
$result = $this->findFormFields($type, $field['fields'], $found_fields);
|
|
if (!empty($result)) {
|
|
$found_fields = array_merge($found_fields, $result);
|
|
}
|
|
}
|
|
}
|
|
|
|
return $found_fields;
|
|
}
|
|
|
|
public function getPagePathFromToken($path, $page = null)
|
|
{
|
|
return Utils::getPagePathFromToken($path, $page ?: $this->page(true));
|
|
}
|
|
|
|
/**
|
|
* Returns edited page.
|
|
*
|
|
* @param bool $route
|
|
*
|
|
* @param null $path
|
|
*
|
|
* @return PageInterface
|
|
*/
|
|
public function page($route = false, $path = null)
|
|
{
|
|
if (!$path) {
|
|
$path = $this->route;
|
|
}
|
|
|
|
if ($route && !$path) {
|
|
$path = '/';
|
|
}
|
|
|
|
if (!isset($this->pages[$path])) {
|
|
$this->pages[$path] = $this->getPage($path);
|
|
}
|
|
|
|
return $this->pages[$path];
|
|
}
|
|
|
|
/**
|
|
* Returns the page creating it if it does not exist.
|
|
*
|
|
* @param string $path
|
|
*
|
|
* @return PageInterface|null
|
|
*/
|
|
public function getPage($path)
|
|
{
|
|
$pages = static::enablePages();
|
|
|
|
if ($path && $path[0] !== '/') {
|
|
$path = "/{$path}";
|
|
}
|
|
|
|
// Fix for entities in path causing looping...
|
|
$path = urldecode($path);
|
|
|
|
$page = $path ? $pages->find($path, true) : $pages->root();
|
|
|
|
if (!$page) {
|
|
$slug = Utils::basename($path);
|
|
|
|
if ($slug === '') {
|
|
return null;
|
|
}
|
|
|
|
$ppath = str_replace('\\', '/', dirname($path));
|
|
|
|
// Find or create parent(s).
|
|
$parent = $this->getPage($ppath !== '/' ? $ppath : '');
|
|
|
|
// Create page.
|
|
$page = new Page();
|
|
$page->parent($parent);
|
|
$page->filePath($parent->path() . '/' . $slug . '/' . $page->name());
|
|
|
|
// Add routing information.
|
|
$pages->addPage($page, $path);
|
|
|
|
// Set if Modular
|
|
$page->modularTwig($slug[0] === '_');
|
|
|
|
// Determine page type.
|
|
if (isset($this->session->{$page->route()})) {
|
|
// Found the type and header from the session.
|
|
$data = $this->session->{$page->route()};
|
|
|
|
// Set the key header value
|
|
$header = ['title' => $data['title']];
|
|
|
|
if (isset($data['visible'])) {
|
|
if ($data['visible'] === '' || $data['visible']) {
|
|
// if auto (ie '')
|
|
$pageParent = $page->parent();
|
|
$children = $pageParent ? $pageParent->children() : [];
|
|
foreach ($children as $child) {
|
|
if ($child->order()) {
|
|
// set page order
|
|
$page->order(AdminController::getNextOrderInFolder($pageParent->path()));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ((int)$data['visible'] === 1 && !$page->order()) {
|
|
$header['visible'] = $data['visible'];
|
|
}
|
|
|
|
}
|
|
|
|
if ($data['name'] === 'modular') {
|
|
$header['body_classes'] = 'modular';
|
|
}
|
|
|
|
$name = $page->isModule() ? str_replace('modular/', '', $data['name']) : $data['name'];
|
|
$page->name($name . '.md');
|
|
|
|
// Fire new event to allow plugins to manipulate page frontmatter
|
|
$this->grav->fireEvent('onAdminCreatePageFrontmatter', new Event(['header' => &$header,
|
|
'data' => $data]));
|
|
|
|
$page->header($header);
|
|
$page->frontmatter(Yaml::dump((array)$page->header(), 20));
|
|
} else {
|
|
// Find out the type by looking at the parent.
|
|
$type = $parent->childType() ?: $parent->blueprints()->get('child_type', 'default');
|
|
$page->name($type . CONTENT_EXT);
|
|
$page->header();
|
|
}
|
|
}
|
|
|
|
return $page;
|
|
}
|
|
|
|
public function generateReports()
|
|
{
|
|
$reports = new ArrayCollection();
|
|
|
|
$pages = static::enablePages();
|
|
|
|
// Default to XSS Security Report
|
|
$result = Security::detectXssFromPages($pages, true);
|
|
|
|
$reports['Grav Security Check'] = $this->grav['twig']->processTemplate('reports/security.html.twig', [
|
|
'result' => $result,
|
|
]);
|
|
|
|
// Linting Issues
|
|
|
|
$result = YamlLinter::lint();
|
|
|
|
$reports['Grav Yaml Linter'] = $this->grav['twig']->processTemplate('reports/yamllinter.html.twig', [
|
|
'result' => $result,
|
|
]);
|
|
|
|
// Fire new event to allow plugins to manipulate page frontmatter
|
|
$this->grav->fireEvent('onAdminGenerateReports', new Event(['reports' => $reports]));
|
|
|
|
return $reports;
|
|
}
|
|
|
|
public function getRouteDetails()
|
|
{
|
|
return [$this->base, $this->location, $this->route];
|
|
}
|
|
|
|
/**
|
|
* Get the files list
|
|
*
|
|
* @param bool $filtered
|
|
* @param int $page_index
|
|
* @return array|null
|
|
* @todo allow pagination
|
|
*/
|
|
public function files($filtered = true, $page_index = 0)
|
|
{
|
|
$param_type = $this->grav['uri']->param('type');
|
|
$param_date = $this->grav['uri']->param('date');
|
|
$param_page = $this->grav['uri']->param('page');
|
|
$param_page = str_replace('\\', '/', $param_page);
|
|
|
|
$files_cache_key = 'media-manager-files';
|
|
|
|
if ($param_type) {
|
|
$files_cache_key .= "-{$param_type}";
|
|
}
|
|
if ($param_date) {
|
|
$files_cache_key .= "-{$param_date}";
|
|
}
|
|
if ($param_page) {
|
|
$files_cache_key .= "-{$param_page}";
|
|
}
|
|
|
|
$page_files = null;
|
|
|
|
$cache_enabled = $this->grav['config']->get('plugins.admin.cache_enabled');
|
|
if (!$cache_enabled) {
|
|
$this->grav['cache']->setEnabled(true);
|
|
}
|
|
|
|
$page_files = $this->grav['cache']->fetch(md5($files_cache_key));
|
|
|
|
if (!$cache_enabled) {
|
|
$this->grav['cache']->setEnabled(false);
|
|
}
|
|
|
|
if (!$page_files) {
|
|
$page_files = [];
|
|
$pages = static::enablePages();
|
|
|
|
if ($param_page) {
|
|
$page = $pages->find($param_page);
|
|
|
|
$page_files = $this->getFiles('images', $page, $page_files, $filtered);
|
|
$page_files = $this->getFiles('videos', $page, $page_files, $filtered);
|
|
$page_files = $this->getFiles('audios', $page, $page_files, $filtered);
|
|
$page_files = $this->getFiles('files', $page, $page_files, $filtered);
|
|
} else {
|
|
$allPages = $pages->all();
|
|
|
|
if ($allPages) foreach ($allPages as $page) {
|
|
$page_files = $this->getFiles('images', $page, $page_files, $filtered);
|
|
$page_files = $this->getFiles('videos', $page, $page_files, $filtered);
|
|
$page_files = $this->getFiles('audios', $page, $page_files, $filtered);
|
|
$page_files = $this->getFiles('files', $page, $page_files, $filtered);
|
|
}
|
|
}
|
|
|
|
if (count($page_files) >= self::MEDIA_PAGINATION_INTERVAL) {
|
|
$this->shouldLoadAdditionalFilesInBackground(true);
|
|
}
|
|
|
|
if (!$cache_enabled) {
|
|
$this->grav['cache']->setEnabled(true);
|
|
}
|
|
$this->grav['cache']->save(md5($files_cache_key), $page_files, 600); //cache for 10 minutes
|
|
if (!$cache_enabled) {
|
|
$this->grav['cache']->setEnabled(false);
|
|
}
|
|
|
|
}
|
|
|
|
if (count($page_files) >= self::MEDIA_PAGINATION_INTERVAL) {
|
|
$page_files = array_slice($page_files, $page_index * self::MEDIA_PAGINATION_INTERVAL, self::MEDIA_PAGINATION_INTERVAL);
|
|
}
|
|
|
|
return $page_files;
|
|
}
|
|
|
|
public function shouldLoadAdditionalFilesInBackground($status = null)
|
|
{
|
|
if ($status) {
|
|
$this->load_additional_files_in_background = true;
|
|
}
|
|
|
|
return $this->load_additional_files_in_background;
|
|
}
|
|
|
|
public function loadAdditionalFilesInBackground($status = null)
|
|
{
|
|
if (!$this->loading_additional_files_in_background) {
|
|
$this->loading_additional_files_in_background = true;
|
|
$this->files(false, false);
|
|
$this->shouldLoadAdditionalFilesInBackground(false);
|
|
$this->loading_additional_files_in_background = false;
|
|
}
|
|
}
|
|
|
|
private function getFiles($type, $page, $page_files, $filtered)
|
|
{
|
|
$page_files = $this->getMediaOfType($type, $page, $page_files);
|
|
|
|
if ($filtered) {
|
|
$page_files = $this->filterByType($page_files);
|
|
$page_files = $this->filterByDate($page_files);
|
|
}
|
|
|
|
return $page_files;
|
|
}
|
|
|
|
/**
|
|
* Get all the media of a type ('images' | 'audios' | 'videos' | 'files')
|
|
*
|
|
* @param string $type
|
|
* @param PageInterface|null $page
|
|
* @param array $files
|
|
*
|
|
* @return array
|
|
*/
|
|
private function getMediaOfType($type, ?PageInterface $page, array $files)
|
|
{
|
|
if ($page) {
|
|
$media = $page->media();
|
|
$mediaOfType = $media->$type();
|
|
|
|
foreach($mediaOfType as $title => $file) {
|
|
$files[] = [
|
|
'title' => $title,
|
|
'type' => $type,
|
|
'page_route' => $page->route(),
|
|
'file' => $file->higherQualityAlternative()
|
|
];
|
|
}
|
|
|
|
return $files;
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Filter media by type
|
|
*
|
|
* @param array $filesFiltered
|
|
*
|
|
* @return array
|
|
*/
|
|
private function filterByType($filesFiltered)
|
|
{
|
|
$filter_type = $this->grav['uri']->param('type');
|
|
if (!$filter_type) {
|
|
return $filesFiltered;
|
|
}
|
|
|
|
$filesFiltered = array_filter($filesFiltered, function ($file) use ($filter_type) {
|
|
return $file['type'] == $filter_type;
|
|
});
|
|
|
|
return $filesFiltered;
|
|
}
|
|
|
|
/**
|
|
* Filter media by date
|
|
*
|
|
* @param array $filesFiltered
|
|
*
|
|
* @return array
|
|
*/
|
|
private function filterByDate($filesFiltered)
|
|
{
|
|
$filter_date = $this->grav['uri']->param('date');
|
|
if (!$filter_date) {
|
|
return $filesFiltered;
|
|
}
|
|
|
|
$year = substr($filter_date, 0, 4);
|
|
$month = substr($filter_date, 5, 2);
|
|
|
|
$filesFilteredByDate = [];
|
|
|
|
foreach($filesFiltered as $file) {
|
|
$filedate = $this->fileDate($file['file']);
|
|
$fileYear = $filedate->format('Y');
|
|
$fileMonth = $filedate->format('m');
|
|
|
|
if ($fileYear == $year && $fileMonth == $month) {
|
|
$filesFilteredByDate[] = $file;
|
|
}
|
|
}
|
|
|
|
return $filesFilteredByDate;
|
|
}
|
|
|
|
/**
|
|
* Return the DateTime object representation of a file modified date
|
|
*
|
|
* @param File $file
|
|
*
|
|
* @return DateTime
|
|
*/
|
|
private function fileDate($file) {
|
|
$datetime = new \DateTime();
|
|
$datetime->setTimestamp($file->toArray()['modified']);
|
|
return $datetime;
|
|
}
|
|
|
|
/**
|
|
* Get the files dates list to be used in the Media Files filter
|
|
*
|
|
* @return array
|
|
*/
|
|
public function filesDates()
|
|
{
|
|
$files = $this->files(false);
|
|
$dates = [];
|
|
|
|
foreach ($files as $file) {
|
|
$datetime = $this->fileDate($file['file']);
|
|
$year = $datetime->format('Y');
|
|
$month = $datetime->format('m');
|
|
|
|
if (!isset($dates[$year])) {
|
|
$dates[$year] = [];
|
|
}
|
|
|
|
if (!isset($dates[$year][$month])) {
|
|
$dates[$year][$month] = 1;
|
|
} else {
|
|
$dates[$year][$month]++;
|
|
}
|
|
}
|
|
|
|
return $dates;
|
|
}
|
|
|
|
/**
|
|
* Get the pages list to be used in the Media Files filter
|
|
*
|
|
* @return array
|
|
*/
|
|
public function pages()
|
|
{
|
|
$pages = static::enablePages();
|
|
|
|
$collection = $pages->all();
|
|
|
|
$pagesWithFiles = [];
|
|
foreach ($collection as $page) {
|
|
if (count($page->media()->all())) {
|
|
$pagesWithFiles[] = $page;
|
|
}
|
|
}
|
|
|
|
return $pagesWithFiles;
|
|
}
|
|
|
|
/**
|
|
* @return Pages
|
|
*/
|
|
public static function enablePages()
|
|
{
|
|
static $pages;
|
|
|
|
if ($pages) {
|
|
return $pages;
|
|
}
|
|
|
|
$grav = Grav::instance();
|
|
$admin = $grav['admin'];
|
|
|
|
/** @var Pages $pages */
|
|
$pages = Grav::instance()['pages'];
|
|
$pages->enablePages();
|
|
|
|
// If page is null, the default page does not exist, and we cannot route to it
|
|
$page = $pages->find('/', true);
|
|
if ($page) {
|
|
// Set original route for the home page.
|
|
$home = '/' . trim($grav['config']->get('system.home.alias'), '/');
|
|
|
|
$page->route($home);
|
|
}
|
|
|
|
$admin->routes = $pages->routes();
|
|
|
|
// Remove default route from routes.
|
|
if (isset($admin->routes['/'])) {
|
|
unset($admin->routes['/']);
|
|
}
|
|
|
|
return $pages;
|
|
}
|
|
|
|
/**
|
|
* Return HTTP_REFERRER if set
|
|
*
|
|
* @return null
|
|
*/
|
|
public function getReferrer()
|
|
{
|
|
return $_SERVER['HTTP_REFERER'] ?? null;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get Grav system log files
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getLogFiles()
|
|
{
|
|
$logs = new GravData(['grav.log' => 'Grav System Log', 'email.log' => 'Email Log']);
|
|
Grav::instance()->fireEvent('onAdminLogFiles', new Event(['logs' => &$logs]));
|
|
return $logs->toArray();
|
|
}
|
|
|
|
/**
|
|
* Get changelog for a given GPM package based on slug
|
|
*
|
|
* @param string|null $slug
|
|
* @return array
|
|
*/
|
|
public function getChangelog($slug = null)
|
|
{
|
|
$gpm = $this->gpm();
|
|
$changelog = [];
|
|
|
|
if (!empty($slug)) {
|
|
$package = $gpm->findPackage($slug);
|
|
} else {
|
|
$package = $gpm->grav;
|
|
}
|
|
|
|
|
|
if ($package) {
|
|
$changelog = $package->getChangelog();
|
|
}
|
|
|
|
return $changelog;
|
|
}
|
|
|
|
/**
|
|
* Prepare and return POST data.
|
|
*
|
|
* @param array $post
|
|
* @return array
|
|
*/
|
|
public function preparePost($post): array
|
|
{
|
|
if (!is_array($post)) {
|
|
return [];
|
|
}
|
|
|
|
unset($post['task']);
|
|
|
|
// Decode JSON encoded fields and merge them to data.
|
|
if (isset($post['_json'])) {
|
|
$post = array_replace_recursive($post, $this->jsonDecode($post['_json']));
|
|
unset($post['_json']);
|
|
}
|
|
|
|
return $this->cleanDataKeys($post);
|
|
}
|
|
|
|
/**
|
|
* Recursively JSON decode data.
|
|
*
|
|
* @param array $data
|
|
* @return array
|
|
* @throws JsonException
|
|
*/
|
|
private function jsonDecode(array $data): array
|
|
{
|
|
foreach ($data as &$value) {
|
|
if (is_array($value)) {
|
|
$value = $this->jsonDecode($value);
|
|
} else {
|
|
$value = json_decode($value, true, 512, JSON_THROW_ON_ERROR);
|
|
}
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* @param array $source
|
|
* @return array
|
|
*/
|
|
private function cleanDataKeys(array $source): array
|
|
{
|
|
$out = [];
|
|
foreach ($source as $key => $value) {
|
|
$key = str_replace(['%5B', '%5D'], ['[', ']'], $key);
|
|
if (is_array($value)) {
|
|
$out[$key] = $this->cleanDataKeys($value);
|
|
} else {
|
|
$out[$key] = $value;
|
|
}
|
|
}
|
|
|
|
return $out;
|
|
}
|
|
}
|