mirror of
https://github.com/alchemy-fr/Phraseanet.git
synced 2025-10-07 10:04:27 +00:00
1979ad0f79
* wip do not merge * fix event EXPORT_CREATE for basket download * fix bad conf (not a worker) * fix bad table name
814 lines
28 KiB
PHP
814 lines
28 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of Phraseanet
|
|
*
|
|
* (c) 2005-2016 Alchemy
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Alchemy\Phrasea;
|
|
|
|
use Alchemy\Geonames\GeonamesServiceProvider;
|
|
use Alchemy\Phrasea\Application\Environment;
|
|
use Alchemy\Phrasea\Application\Helper\AclAware;
|
|
use Alchemy\Phrasea\Application\Helper\ApplicationBoxAware;
|
|
use Alchemy\Phrasea\Application\Helper\AuthenticatorAware;
|
|
use Alchemy\Phrasea\Application\RouteLoader;
|
|
use Alchemy\Phrasea\Authorization\AuthorizationServiceProvider;
|
|
use Alchemy\Phrasea\Core\Event\Subscriber\BasketSubscriber;
|
|
use Alchemy\Phrasea\Core\Event\Subscriber\BridgeSubscriber;
|
|
use Alchemy\Phrasea\Core\Event\Subscriber\ExpiringRightsSubscriber;
|
|
use Alchemy\Phrasea\Core\Event\Subscriber\ExportSubscriber;
|
|
use Alchemy\Phrasea\Core\Event\Subscriber\FeedEntrySubscriber;
|
|
use Alchemy\Phrasea\Core\Event\Subscriber\LazaretSubscriber;
|
|
use Alchemy\Phrasea\Core\Event\Subscriber\PhraseaInstallSubscriber;
|
|
use Alchemy\Phrasea\Core\Event\Subscriber\RegistrationSubscriber;
|
|
use Alchemy\Phrasea\Core\Event\Subscriber\ValidationSubscriber;
|
|
use Alchemy\Phrasea\Core\Event\Subscriber\WebhookUserEventSubscriber;
|
|
use Alchemy\Phrasea\Core\LazyLocator;
|
|
use Alchemy\Phrasea\Core\MetaProvider\DatabaseMetaProvider;
|
|
use Alchemy\Phrasea\Core\MetaProvider\HttpStackMetaProvider;
|
|
use Alchemy\Phrasea\Core\MetaProvider\MediaUtilitiesMetaServiceProvider;
|
|
use Alchemy\Phrasea\Core\MetaProvider\TemplateEngineMetaProvider;
|
|
use Alchemy\Phrasea\Core\MetaProvider\TranslationMetaProvider;
|
|
use Alchemy\Phrasea\Core\Middleware\ApiApplicationMiddlewareProvider;
|
|
use Alchemy\Phrasea\Core\Middleware\BasketMiddlewareProvider;
|
|
use Alchemy\Phrasea\Core\Middleware\TokenMiddlewareProvider;
|
|
use Alchemy\Phrasea\Core\PhraseaExceptionHandler;
|
|
use Alchemy\Phrasea\Core\Provider\AccountServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\ACLServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\APIServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\AuthenticationManagerServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\BorderManagerServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\BrowserServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\CacheConnectionServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\CacheServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\ConfigurationServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\ConfigurationTesterServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\ConvertersServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\CSVServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\DataboxServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\FeedServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\FileServeServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\FtpServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\InstallerServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\JMSSerializerServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\LocaleServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\ManipulatorServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\NotificationDelivererServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\OrderServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\PhraseaEventServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\PhraseanetServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\PhraseaVersionServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\PluginServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\RandomGeneratorServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\RegistrationServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\RepositoriesServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\SearchEngineServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\SerializerServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\StatusServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\SubdefServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\TasksServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\TokensServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\UnicodeServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\WebhookServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\WorkerConfigurationServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\ZippyServiceProvider;
|
|
use Alchemy\Phrasea\Core\Provider\WebProfilerServiceProvider as PhraseaWebProfilerServiceProvider;
|
|
use Alchemy\Phrasea\Databox\Caption\CaptionServiceProvider;
|
|
use Alchemy\Phrasea\Databox\Subdef\MediaSubdefServiceProvider;
|
|
use Alchemy\Phrasea\Exception\InvalidArgumentException;
|
|
use Alchemy\Phrasea\Filesystem\FilesystemServiceProvider;
|
|
use Alchemy\Phrasea\Filesystem\ApplicationPathServiceGenerator;
|
|
use Alchemy\Phrasea\Form\Extension\HelpTypeExtension;
|
|
use Alchemy\Phrasea\Media\DatafilesResolver;
|
|
use Alchemy\Phrasea\Media\MediaAccessorResolver;
|
|
use Alchemy\Phrasea\Media\PermalinkMediaResolver;
|
|
use Alchemy\Phrasea\Media\TechnicalDataServiceProvider;
|
|
use Alchemy\Phrasea\Model\Entities\User;
|
|
use Alchemy\Phrasea\WorkerManager\Provider\AlchemyWorkerServiceProvider;
|
|
use Alchemy\Phrasea\WorkerManager\Provider\QueueWorkerServiceProvider;
|
|
use Alchemy\QueueProvider\QueueServiceProvider;
|
|
use Alchemy\WorkerProvider\WorkerServiceProvider;
|
|
use MediaVorus\Media\MediaInterface;
|
|
use MediaVorus\MediaVorus;
|
|
use Monolog\Handler\ErrorLogHandler;
|
|
use Monolog\Handler\NullHandler;
|
|
use Monolog\Handler\RotatingFileHandler;
|
|
use Monolog\Handler\StreamHandler;
|
|
use Monolog\Logger;
|
|
use Psr\Log\LoggerInterface;
|
|
use Silex\Application as SilexApplication;
|
|
use Silex\Application\TranslationTrait;
|
|
use Silex\Application\UrlGeneratorTrait;
|
|
use Silex\Provider\FormServiceProvider;
|
|
use Silex\Provider\MonologServiceProvider;
|
|
use Silex\Provider\ServiceControllerServiceProvider;
|
|
use Silex\Provider\SwiftmailerServiceProvider;
|
|
use Silex\Provider\ValidatorServiceProvider;
|
|
use Silex\Provider\WebProfilerServiceProvider;
|
|
use Sorien\Provider\PimpleDumpProvider;
|
|
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
|
|
use Symfony\Component\Form\Exception\ExceptionInterface;
|
|
use Symfony\Component\Form\Exception\FormException;
|
|
use Symfony\Component\Form\FormBuilderInterface;
|
|
use Symfony\Component\Form\FormInterface;
|
|
use Symfony\Component\Form\FormTypeInterface;
|
|
use Symfony\Component\HttpFoundation\RedirectResponse;
|
|
use Symfony\Component\Process\ExecutableFinder;
|
|
use Unoconv\UnoconvServiceProvider;
|
|
use XPDF\PdfToText;
|
|
use XPDF\XPDFServiceProvider;
|
|
|
|
class Application extends SilexApplication
|
|
{
|
|
use AclAware;
|
|
use ApplicationBoxAware;
|
|
use AuthenticatorAware;
|
|
use UrlGeneratorTrait;
|
|
use TranslationTrait;
|
|
|
|
const ENV_DEV = 'dev';
|
|
const ENV_PROD = 'prod';
|
|
const ENV_TEST = 'test';
|
|
|
|
protected static $availableLanguages = [
|
|
'de' => 'Deutsch',
|
|
'en' => 'English',
|
|
'fr' => 'Français',
|
|
'nl' => 'Dutch',
|
|
];
|
|
|
|
private static $flashTypes = ['warning', 'info', 'success', 'error'];
|
|
|
|
/**
|
|
* @var Environment
|
|
*/
|
|
private $environment;
|
|
|
|
/**
|
|
* @param Environment|string $environment
|
|
*/
|
|
public function __construct($environment = null)
|
|
{
|
|
if (is_string($environment)) {
|
|
$environment = new Environment($environment, false);
|
|
}
|
|
|
|
$this->environment = $environment ?: new Environment(self::ENV_PROD, false);
|
|
|
|
parent::__construct([
|
|
'debug' => $this->environment->isDebug()
|
|
]);
|
|
|
|
$this->setupCharset();
|
|
$this->setupApplicationPaths();
|
|
$this->setupConstants();
|
|
|
|
if ('allowed' == getenv('APP_CONTAINER_DUMP')) {
|
|
$this->register(new PimpleDumpProvider());
|
|
}
|
|
|
|
$this->register(new ConfigurationServiceProvider());
|
|
$this->register(new MonologServiceProvider());
|
|
$this->setupMonolog();
|
|
$this->register(new FilesystemServiceProvider());
|
|
$this->register(new CacheServiceProvider());
|
|
$this->register(new CacheConnectionServiceProvider());
|
|
$this->register(new PhraseanetServiceProvider());
|
|
$this->register(new ConfigurationTesterServiceProvider());
|
|
|
|
$this->register(new DatabaseMetaProvider());
|
|
|
|
$this->register(new BasketMiddlewareProvider());
|
|
$this->register(new TokenMiddlewareProvider());
|
|
$this->register(new AccountServiceProvider());
|
|
$this->register(new ApiApplicationMiddlewareProvider());
|
|
$this->register(new ACLServiceProvider());
|
|
$this->register(new APIServiceProvider());
|
|
$this->register(new AuthenticationManagerServiceProvider());
|
|
$this->register(new AuthorizationServiceProvider());
|
|
$this->register(new BrowserServiceProvider());
|
|
$this->register(new ConvertersServiceProvider());
|
|
$this->register(new CSVServiceProvider());
|
|
$this->register(new RegistrationServiceProvider());
|
|
|
|
$this->register(new JMSSerializerServiceProvider());
|
|
$this->register(new FeedServiceProvider());
|
|
$this->register(new FtpServiceProvider());
|
|
$this->register(new GeonamesServiceProvider());
|
|
$this->register(new StatusServiceProvider());
|
|
$this->setupGeonames();
|
|
$this->register(new NotificationDelivererServiceProvider());
|
|
$this->register(new RepositoriesServiceProvider());
|
|
$this->register(new TechnicalDataServiceProvider());
|
|
$this->register(new MediaSubdefServiceProvider());
|
|
$this->register(new CaptionServiceProvider());
|
|
$this->register(new InstallerServiceProvider());
|
|
$this->register(new PhraseaVersionServiceProvider());
|
|
|
|
$this->register(new RandomGeneratorServiceProvider());
|
|
$this->register(new SubdefServiceProvider());
|
|
$this->register(new ZippyServiceProvider());
|
|
|
|
if ($this['configuration.store']->isSetup()) {
|
|
$this->register(new SearchEngineServiceProvider());
|
|
$this->register(new BorderManagerServiceProvider());
|
|
}
|
|
|
|
$this->register(new SerializerServiceProvider());
|
|
$this->register(new ServiceControllerServiceProvider());
|
|
$this->register(new SwiftmailerServiceProvider());
|
|
$this->setupSwiftMailer();
|
|
$this->register(new TasksServiceProvider());
|
|
$this->register(new TokensServiceProvider());
|
|
|
|
$this->register(new TemplateEngineMetaProvider());
|
|
$this->register(new HttpStackMetaProvider());
|
|
$this->register(new MediaUtilitiesMetaServiceProvider());
|
|
$this->register(new TranslationMetaProvider());
|
|
|
|
$this->register(new FormServiceProvider());
|
|
$this->setupForm();
|
|
$this->register(new UnoconvServiceProvider());
|
|
|
|
$this->register(new UnicodeServiceProvider());
|
|
$this->register(new ValidatorServiceProvider());
|
|
|
|
if ($this['configuration.store']->isSetup()) {
|
|
$binariesConfig = $this['conf']->get(['main', 'binaries']);
|
|
$executableFinder = new ExecutableFinder();
|
|
$this->register(new XPDFServiceProvider(), [
|
|
'xpdf.configuration' => [
|
|
'pdftotext.binaries' => isset($binariesConfig['pdftotext_binary']) ? $binariesConfig['pdftotext_binary'] : $executableFinder->find('pdftotext'),
|
|
]
|
|
]);
|
|
|
|
$this->setupXpdf();
|
|
}
|
|
|
|
$this->register(new FileServeServiceProvider());
|
|
$this->register(new ManipulatorServiceProvider());
|
|
$this->register(new PluginServiceProvider());
|
|
$this->register(new PhraseaEventServiceProvider());
|
|
|
|
$this->register(new LocaleServiceProvider());
|
|
|
|
$this->setupEventDispatcher();
|
|
$this->setupRecaptacha();
|
|
|
|
$this->register(new DataboxServiceProvider());
|
|
$this->register(new QueueServiceProvider());
|
|
$this->register(new WorkerServiceProvider());
|
|
$this->register(new WorkerConfigurationServiceProvider());
|
|
|
|
$this->register(new OrderServiceProvider());
|
|
$this->register(new WebhookServiceProvider());
|
|
|
|
if ($this['configuration.store']->isSetup()) {
|
|
$this->register(new QueueWorkerServiceProvider());
|
|
$this->register(new AlchemyWorkerServiceProvider());
|
|
}
|
|
|
|
$this['monolog'] = $this->share(
|
|
$this->extend('monolog', function (LoggerInterface $logger, Application $app) {
|
|
|
|
if ($this->getEnvironment() === self::ENV_TEST) {
|
|
$logger->pushHandler(new NullHandler());
|
|
} else {
|
|
$logger->pushHandler(new ErrorLogHandler(
|
|
ErrorLogHandler::SAPI,
|
|
Logger::ERROR
|
|
));
|
|
|
|
$logger->pushHandler(new StreamHandler(
|
|
fopen('php://stderr', 'w'),
|
|
Logger::ERROR
|
|
));
|
|
}
|
|
|
|
return $logger;
|
|
})
|
|
);
|
|
|
|
$this['phraseanet.exception_handler'] = $this->share(function ($app) {
|
|
/** @var PhraseaExceptionHandler $handler */
|
|
$handler = PhraseaExceptionHandler::register($app['debug']);
|
|
|
|
$handler->setTranslator($app['translator']);
|
|
$handler->setLogger($app['monolog']);
|
|
|
|
return $handler;
|
|
});
|
|
|
|
$resolvers = $this['alchemy_embed.resource_resolvers'];
|
|
$resolvers['datafile'] = $resolvers->share(function () {
|
|
return new DatafilesResolver($this->getApplicationBox());
|
|
});
|
|
|
|
$resolvers['permalinks_permalink'] = $resolvers->share(function () {
|
|
return new PermalinkMediaResolver($this->getApplicationBox());
|
|
});
|
|
|
|
$resolvers['media_accessor'] = $resolvers->share(function () {
|
|
return new MediaAccessorResolver(
|
|
$this->getApplicationBox(), $this['controller.media_accessor']
|
|
);
|
|
});
|
|
|
|
if (self::ENV_DEV === $this->getEnvironment()) {
|
|
$this->register($p = new WebProfilerServiceProvider(), [
|
|
'profiler.cache_dir' => $this['cache.path'].'/profiler',
|
|
]);
|
|
|
|
$this->register(new PhraseaWebProfilerServiceProvider());
|
|
$this->mount('/_profiler', $p);
|
|
|
|
if ($this['phraseanet.configuration-tester']->isInstalled()) {
|
|
$this['db'] = $this->share(function (self $app) {
|
|
return $app['orm.em']->getConnection();
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
public function getEnvironment()
|
|
{
|
|
return $this->environment->getName();
|
|
}
|
|
|
|
/**
|
|
* Loads Phraseanet plugins
|
|
*/
|
|
public function loadPlugins()
|
|
{
|
|
call_user_func(function ($app) {
|
|
if (file_exists($app['plugin.path'] . '/services.php')) {
|
|
require $app['plugin.path'] . '/services.php';
|
|
}
|
|
}, $this);
|
|
}
|
|
|
|
/**
|
|
* Returns a form.
|
|
*
|
|
* @see FormFactory::create()
|
|
*
|
|
* @param string|FormTypeInterface $type The type of the form
|
|
* @param mixed $data The initial data
|
|
* @param array $options The options
|
|
* @param FormBuilderInterface $parent The parent builder
|
|
*
|
|
* @return FormInterface The form named after the type
|
|
*
|
|
* @throws ExceptionInterface if any given option is not applicable to the given type
|
|
*/
|
|
public function form($type = 'form', $data = null, array $options = [], FormBuilderInterface $parent = null)
|
|
{
|
|
return $this['form.factory']->create($type, $data, $options, $parent);
|
|
}
|
|
|
|
/**
|
|
* Returns a redirect response with a relative path related to a route name.
|
|
*
|
|
* @param string $route The name of the route
|
|
* @param mixed $parameters An array of parameters
|
|
*
|
|
* @return RedirectResponse
|
|
*/
|
|
public function redirectPath($route, $parameters = [])
|
|
{
|
|
return $this->redirect($this->path($route, $parameters));
|
|
}
|
|
|
|
/**
|
|
* Returns a redirect response with a fully qualified URI related to a route name.
|
|
*
|
|
* @param string $route The name of the route
|
|
* @param mixed $parameters An array of parameters
|
|
*
|
|
* @return RedirectResponse
|
|
*/
|
|
public function redirectUrl($route, $parameters = [])
|
|
{
|
|
return $this->redirect($this->url($route, $parameters));
|
|
}
|
|
|
|
/**
|
|
* Adds a flash message for type.
|
|
*
|
|
* In Phraseanet, valid types are "warning", "info", "success" and "error"
|
|
*
|
|
* @param string $type
|
|
* @param string $message
|
|
*
|
|
* @return Application
|
|
*
|
|
* @throws InvalidArgumentException In case the type is not valid
|
|
*/
|
|
public function addFlash($type, $message)
|
|
{
|
|
if (!in_array($type, self::$flashTypes)) {
|
|
throw new InvalidArgumentException(sprintf(
|
|
'Invalid flash message type `%s`, valid type are %s', $type, implode(', ', self::$flashTypes)
|
|
));
|
|
}
|
|
|
|
$this['session']->getFlashBag()->add($type, $message);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Gets and clears flash from the stack.
|
|
*
|
|
* @param string $type
|
|
* @param array $default Default value if $type does not exist.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getFlash($type, array $default = [])
|
|
{
|
|
return $this['session']->getFlashBag()->get($type, $default);
|
|
}
|
|
|
|
/**
|
|
* Adds a temporary unlock data for an account-locked user
|
|
*
|
|
* @param integer $data
|
|
*/
|
|
public function addUnlockAccountData($data)
|
|
{
|
|
$this['session']->set('unlock_account_data', $data);
|
|
}
|
|
|
|
/**
|
|
* Returns the temporary unlock account data
|
|
*
|
|
* @return null|integer
|
|
*/
|
|
public function getUnlockAccountData()
|
|
{
|
|
if ($this['session']->has('unlock_account_data')) {
|
|
return $this['session']->remove('unlock_account_data');
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Asks for a captcha ar next authentication
|
|
*
|
|
* @return Application
|
|
*/
|
|
public function requireCaptcha()
|
|
{
|
|
if ($this['conf']->get(['registry', 'webservices', 'captcha-provider']) != 'none') {
|
|
$this['session']->set('require_captcha', true);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function isDebug()
|
|
{
|
|
return $this->environment->isDebug();
|
|
}
|
|
|
|
/**
|
|
* Returns true if a captcha is required for next authentication
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isCaptchaRequired()
|
|
{
|
|
if ($this['session']->has('require_captcha')) {
|
|
$this['session']->remove('require_captcha');
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns true if guest access is allowed.
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isGuestAllowed()
|
|
{
|
|
if (null === $user = $this['repo.users']->findByLogin(User::USER_GUEST)) {
|
|
return false;
|
|
}
|
|
|
|
return count($this->getAclForUser($user)->get_granted_base()) > 0;
|
|
}
|
|
|
|
/**
|
|
* Returns true if application has terms of use
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function hasTermsOfUse()
|
|
{
|
|
return '' !== \databox_cgu::getHome($this);
|
|
}
|
|
|
|
/**
|
|
* Returns an an array of available collection for offline queries
|
|
*
|
|
* @return array
|
|
*/
|
|
public function getOpenCollections()
|
|
{
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Mount all controllers
|
|
*/
|
|
public function bindRoutes()
|
|
{
|
|
$loader = new RouteLoader();
|
|
|
|
$loader->registerProviders(RouteLoader::$defaultProviders);
|
|
|
|
$loader->bindRoutes($this);
|
|
$this->bindPluginRoutes('plugin.controller_providers.root');
|
|
}
|
|
|
|
/**
|
|
* Return available language for phraseanet
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function getAvailableLanguages()
|
|
{
|
|
return static::$availableLanguages;
|
|
}
|
|
|
|
/**
|
|
* Returns available flash message types for Phraseanet
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function getAvailableFlashTypes()
|
|
{
|
|
return static::$flashTypes;
|
|
}
|
|
|
|
/**
|
|
* Get Media instance given a file uri.
|
|
*
|
|
* @param string $uri
|
|
*
|
|
* @return MediaInterface
|
|
*/
|
|
public function getMediaFromUri($uri)
|
|
{
|
|
/** @var MediaVorus $mediavorus */
|
|
$mediavorus = $this['mediavorus'];
|
|
|
|
return $mediavorus->guess($uri);
|
|
}
|
|
|
|
private function setupApplicationPaths()
|
|
{
|
|
// app root path
|
|
$this['root.path'] = realpath(__DIR__ . '/../../..');
|
|
// temporary resources default path such as download zip, quarantined documents etc ..
|
|
$this['tmp.path'] = getenv('PHRASEANET_TMP') ?: $this['root.path'].'/tmp';
|
|
|
|
// plugin path
|
|
$this['plugin.path'] = $this['root.path'].'/plugins';
|
|
// thumbnails path
|
|
$this['thumbnail.path'] = $this['root.path'].'/www/thumbnails';
|
|
|
|
$factory = new ApplicationPathServiceGenerator();
|
|
|
|
$this['cache.path'] = $factory->createDefinition(
|
|
['main', 'storage', 'cache'],
|
|
function (Application $app) {
|
|
return $app['root.path'].'/cache';
|
|
}
|
|
);
|
|
$this['cache.paths'] = function (Application $app) {
|
|
return new \ArrayObject([
|
|
$app['cache.path'],
|
|
]);
|
|
};
|
|
|
|
$this['log.path'] = $factory->createDefinition(
|
|
['main', 'storage', 'log'],
|
|
function (Application $app) {
|
|
return $app['root.path'].'/logs';
|
|
}
|
|
);
|
|
|
|
$this['tmp.download.path'] = $factory->createDefinition(
|
|
['main', 'storage', 'download'],
|
|
function (Application $app) {
|
|
return $app['tmp.path'].'/download';
|
|
}
|
|
);
|
|
|
|
$this['tmp.lazaret.path'] = $factory->createDefinition(
|
|
['main', 'storage', 'lazaret'],
|
|
function (Application $app) {
|
|
return $app['tmp.path'].'/lazaret';
|
|
}
|
|
);
|
|
|
|
$this['tmp.caption.path'] = $factory->createDefinition(
|
|
['main', 'storage', 'caption'],
|
|
function (Application $app) {
|
|
return $app['tmp.path'].'/caption';
|
|
}
|
|
);
|
|
}
|
|
|
|
|
|
private function setupXpdf()
|
|
{
|
|
$this['xpdf.pdftotext'] = $this->share(
|
|
$this->extend('xpdf.pdftotext', function (PdfToText $pdftotext, Application $app) {
|
|
if ($app['conf']->get(['registry', 'executables', 'pdf-max-pages'])) {
|
|
$pdftotext->setPageQuantity($app['conf']->get(['registry', 'executables', 'pdf-max-pages']));
|
|
}
|
|
|
|
return $pdftotext;
|
|
})
|
|
);
|
|
}
|
|
|
|
private function setupForm()
|
|
{
|
|
$this['form.type.extensions'] = $this->share($this->extend('form.type.extensions', function ($extensions, Application $app) {
|
|
$extensions[] = new HelpTypeExtension();
|
|
|
|
return $extensions;
|
|
}));
|
|
}
|
|
|
|
private function setupRecaptacha()
|
|
{
|
|
$this['recaptcha.public-key'] = $this->share(function (Application $app) {
|
|
if ($app['conf']->get(['registry', 'webservices', 'captcha-provider']) != 'none') {
|
|
return $app['conf']->get(['registry', 'webservices', 'recaptcha-public-key']);
|
|
}
|
|
});
|
|
$this['recaptcha.private-key'] = $this->share(function (Application $app) {
|
|
if ($app['conf']->get(['registry', 'webservices', 'captcha-provider']) != 'none') {
|
|
return $app['conf']->get(['registry', 'webservices', 'recaptcha-private-key']);
|
|
}
|
|
});
|
|
}
|
|
|
|
private function setupGeonames()
|
|
{
|
|
$this['geonames.server-uri'] = $this->share(function (Application $app) {
|
|
return $app['conf']->get(['registry', 'webservices', 'geonames-server'], 'https://geonames.alchemyasp.com/');
|
|
});
|
|
}
|
|
|
|
private function setupSwiftMailer()
|
|
{
|
|
$this['swiftmailer.transport'] = $this->share(function (Application $app) {
|
|
if ($app['conf']->get(['registry', 'email', 'smtp-enabled'])) {
|
|
$transport = new \Swift_Transport_EsmtpTransport(
|
|
$app['swiftmailer.transport.buffer'],
|
|
[$app['swiftmailer.transport.authhandler']],
|
|
$app['swiftmailer.transport.eventdispatcher']
|
|
);
|
|
|
|
$encryption = null;
|
|
$secureMode = '';
|
|
|
|
if (in_array($app['conf']->get(['registry', 'email', 'smtp-secure-mode']), ['ssl', 'tls', 'tlsv1.1', 'tlsv1.2'])) {
|
|
$secureMode = $app['conf']->get(['registry', 'email', 'smtp-secure-mode']);
|
|
|
|
if ($secureMode == 'ssl') {
|
|
$encryption = 'ssl';
|
|
} else {
|
|
$encryption = 'tls';
|
|
if ($secureMode == 'tls') {
|
|
// by default use tlsv1.2
|
|
$secureMode = 'tlsv1.2';
|
|
}
|
|
}
|
|
}
|
|
|
|
$options = $app['swiftmailer.options'] = array_replace([
|
|
'host' => $app['conf']->get(['registry', 'email', 'smtp-host']),
|
|
'port' => $app['conf']->get(['registry', 'email', 'smtp-port']),
|
|
'username' => $app['conf']->get(['registry', 'email', 'smtp-user']),
|
|
'password' => $app['conf']->get(['registry', 'email', 'smtp-password']),
|
|
'encryption' => $encryption,
|
|
'auth_mode' => null,
|
|
], $app['swiftmailer.options']);
|
|
|
|
$transport->setHost($options['host']);
|
|
$transport->setPort($options['port']);
|
|
// tls or ssl
|
|
$transport->setEncryption($options['encryption']);
|
|
|
|
if ($options['encryption'] == 'tls') {
|
|
$transport->setStreamOptions(['ssl' =>[$secureMode => true]]);
|
|
}
|
|
|
|
if ($app['conf']->get(['registry', 'email', 'smtp-auth-enabled'])) {
|
|
$transport->setUsername($options['username']);
|
|
$transport->setPassword($options['password']);
|
|
$transport->setAuthMode($options['auth_mode']);
|
|
}
|
|
} else {
|
|
$transport = new \Swift_Transport_MailTransport(
|
|
new \Swift_Transport_SimpleMailInvoker(),
|
|
$app['swiftmailer.transport.eventdispatcher']
|
|
);
|
|
}
|
|
|
|
return $transport;
|
|
});
|
|
}
|
|
|
|
private function setupMonolog()
|
|
{
|
|
$this['monolog.name'] = 'phraseanet';
|
|
$this['monolog.handler'] = $this->share(function (Application $app) {
|
|
return new RotatingFileHandler(
|
|
$app['log.path'] . '/app_error.log',
|
|
10,
|
|
Logger::ERROR,
|
|
$app['monolog.bubble'],
|
|
$app['monolog.permission']
|
|
);
|
|
});
|
|
}
|
|
|
|
private function setupEventDispatcher()
|
|
{
|
|
$this['dispatcher'] = $this->share(
|
|
$this->extend('dispatcher', function (EventDispatcherInterface $dispatcher, Application $app) {
|
|
$dispatcher->addSubscriber(new PhraseaInstallSubscriber($app));
|
|
$dispatcher->addSubscriber(new FeedEntrySubscriber($app));
|
|
$dispatcher->addSubscriber(new RegistrationSubscriber($app));
|
|
$dispatcher->addSubscriber(new BridgeSubscriber($app));
|
|
$dispatcher->addSubscriber(new ExportSubscriber($app));
|
|
$dispatcher->addSubscriber(new BasketSubscriber($app));
|
|
$dispatcher->addSubscriber(new LazaretSubscriber($app));
|
|
$dispatcher->addSubscriber(new ValidationSubscriber($app));
|
|
if ($this['configuration.store']->isSetup()) {
|
|
$dispatcher->addSubscriber(new WebhookUserEventSubscriber($app));
|
|
}
|
|
|
|
$dispatcher->addSubscriber(new ExpiringRightsSubscriber($app, new LazyLocator($app, 'phraseanet.appbox')));
|
|
|
|
return $dispatcher;
|
|
})
|
|
);
|
|
}
|
|
|
|
private function setupConstants()
|
|
{
|
|
if (!defined('JETON_MAKE_SUBDEF')) {
|
|
define('JETON_MAKE_SUBDEF', 0x01);
|
|
}
|
|
|
|
if (!defined('JETON_WRITE_META_DOC')) {
|
|
define('JETON_WRITE_META_DOC', 0x02);
|
|
}
|
|
|
|
if (!defined('JETON_WRITE_META_SUBDEF')) {
|
|
define('JETON_WRITE_META_SUBDEF', 0x04);
|
|
}
|
|
|
|
if (!defined('JETON_WRITE_META')) {
|
|
define('JETON_WRITE_META', 0x06);
|
|
}
|
|
}
|
|
|
|
private function setupCharset()
|
|
{
|
|
$this['charset'] = 'UTF-8';
|
|
mb_internal_encoding($this['charset']);
|
|
}
|
|
|
|
/**
|
|
* @param $routeParameter
|
|
*/
|
|
public function bindPluginRoutes($routeParameter)
|
|
{
|
|
$loader = new RouteLoader();
|
|
|
|
$loader->bindPluginRoutes($this, $routeParameter);
|
|
}
|
|
}
|