/**
* @param Container $container
* @throws \DI\NotFoundException
*/
public function __construct(Container $container)
{
/** @var \GeoVisualizer\Collector\Twitter\ApiFactory $apiFactory */
$apiFactory = $container->get('\\GeoVisualizer\\Collector\\Twitter\\ApiFactory');
/** @var \TwitterOAuth\Api $api */
$this->api = $apiFactory->create($container);
}
/**
* @param Container $container
* @throws \DI\NotFoundException
*/
public function __construct(Container $container)
{
/** @var Configuration $configuration */
$configuration = $container->get('\\GeoVisualizer\\Visualizer\\GoogleMaps\\Configuration');
$array = $configuration->parseConfiguration();
$this->apiKey = $array[Configuration::API_KEY];
}
protected function readyApiMock()
{
$this->apiMock = \Mockery::mock(QiitaAPIInterface::class);
$this->container->set('api', $this->apiMock);
$this->container->set(QiitaAPIInterface::class, $this->apiMock);
Model::setApi($this->apiMock);
}
/**
* @param InvokeAction $message
* @param mixed $actionResult
*
* @return void
*/
private function respond(InvokeAction $message, $actionResult)
{
if ($message->action->getResponder() === null) {
return;
}
$this->container->call($message->action->getResponder(), $actionResult ? ['data' => $actionResult] : []);
}
public function createFeatureFromClassName(string $featureClassName) : Feature
{
if (!in_array($featureClassName, $this->listFeatures())) {
throw new UnknownFeatureException(sprintf('Unknown feature class `%s`', $featureClassName));
}
return $this->container->get($featureClassName);
}
public function resolve(ServerRequestInterface $request, Container $container) : Command
{
if (!$this->isResolvable($request)) {
throw new UnresolvableCommandException();
}
return $container->get($this->commandClassName);
}
/**
* @param Container $container
* @return Api
* @throws \DI\NotFoundException
*/
public function create(Container $container)
{
/** @var Configuration $configuration */
$configuration = $container->get('\\GeoVisualizer\\Collector\\Twitter\\Configuration');
$array = $configuration->parseConfiguration();
return new Api($array[Configuration::CONSUMER_KEY], $array[Configuration::CONSUMER_SECRET], $array[Configuration::OAUTH_TOKEN], $array[Configuration::OAUTH_TOKEN_SECRET]);
}
public function run()
{
$this->db = $this->container->get('db');
$this->db['last_run'] = date('Y-m-d H:i:s');
\Util::debug('Connecting to Skype');
$this->core->initSkypeConnection();
\Util::debug('Initializing plugins');
$this->container->get('Bot\\Plugins\\Infrastructure\\Broker')->initPlugins();
/** @var LoopInterface $loop */
$loop = $this->container->get('loop');
/** @var EventEmitter $ev */
$ev = $this->container->get('event');
if (isset($this->db['restart']) && $this->db['restart']) {
list($chatName, $restartTime) = $this->db['restart'];
$this->core->send($chatName, 'Я сделяль!');
unset($this->db['restart']);
}
$loop->addPeriodicTimer(0.0001, function () use($ev, $loop) {
$this->core->poll();
// $this->webCore->poll();
$ev->emit('tick', [microtime(true)]);
});
\Util::debug('Running main loop');
$loop->run();
}
/**
* Create a collector registry, then add each collector
* @todo Refactor so it does not use the DI container like a service locator
* @param Container $container
* @return Registry
*/
public function create(Container $container)
{
$registry = new Registry();
$collector = $container->get('\\GeoVisualizer\\Collector\\Twitter\\Collector');
$registry->addCollector($collector);
return $registry;
}
/**
* @param string $configName
* @return array|null
* @throws \DI\NotFoundException
* @throws ParseException
* @throws \InvalidArgumentException
* @throws DependencyException
*/
private function loadPluginConfig($configName)
{
$configPath = $this->container->get('config.path') . DS . 'plugins' . DS . $configName . '.yml';
if (!file_exists($configPath)) {
return null;
}
return Yaml::parse($configPath);
}
protected function createContainer()
{
$container = new Container();
$container->set('array_iterator', new \ArrayIterator(range(1, 5)));
$container->set('error', function () {
throw new \RuntimeException();
});
return new PHPDIContainerAdapter($container);
}
public function create(Container $c)
{
$host = $c->get("parameters")['database']['host'];
$dbName = $c->get("parameters")['database']['dbName'];
$user = $c->get("parameters")['database']['user'];
$password = $c->get("parameters")['database']['password'];
$pdo = new \PDO("mysql:host={$host};dbname={$dbName}", $user, $password);
return $pdo;
}
/**
* Handle an incoming request.
*
* @param Container $container
* @param Closure $next
* @return mixed
* @throws \DI\NotFoundException
*/
public function handle(Container $container, Closure $next)
{
$request = $container->get(Request::class);
if (!$request->ajax()) {
$view = $container->get(View::class)->render('errors.403');
return $container->get(Response::class)->forbidden($view);
}
return $next();
}
/**
* Configure the engine and start it.
*
* Compute and register some information such as computed global configuration,
* input, output etc to the DI container for easier access later to
* lower level components.
*
* @param \Symfony\Component\Console\Input\InputInterface $input
* @param \Symfony\Component\Console\Output\OutputInterface $output
*
* @return void
*/
public function configAndStart(InputInterface $input, OutputInterface $output)
{
$startUpMsg = "\n" . "Starting the test run. Version ( " . Application::APP_VERSION . " )\n" . "Type character h for help when prompted for an input value.\n";
$output->writeln($startUpMsg);
$config = $this->configFactory->config($input, $output);
$this->container->set('Box\\TestScribe\\Config\\GlobalComputedConfig', $config);
App::Init($this->appInstance);
$this->engine->start();
}
public function getController(Request $request)
{
$controller = $this->resolver->getController($request);
if (!$controller instanceof \Closure) {
$instance = is_array($controller) ? reset($controller) : $controller;
if (is_object($instance)) {
$this->container->injectOn($instance);
}
}
return $controller;
}
/**
* @param GetResponseEvent $event
*/
public function handle(GetResponseEvent $event)
{
$securityAuthRealm = $this->container->get('security.authRealm');
$request = $event->getRequest();
$uri = $request->getRequestUri();
foreach ($securityAuthRealm as $authRealm => $realmConfig) {
if (isset($realmConfig['authRoute']) && preg_match('#' . $realmConfig['authRoute'] . '#', $uri)) {
$event->setResponse($event->getKernel()->handle($request, HttpKernelInterface::SUB_REQUEST, true));
return;
}
}
}
/**
* @param $path
* @return null
* @throws \DI\NotFoundException
*/
private function getAuthRealm($path)
{
$realm = null;
foreach ($this->container->get('security.firewall') as $route => $config) {
$regex = '#' . $route . '#';
if (preg_match($regex, $path) && isset($config['authRealm'])) {
$realm = $config['authRealm'];
break;
}
}
return $realm;
}
/**
* Returns the dependency injection container
*
* @return \DI\Container
*/
public function getDiContainer()
{
if (!$this->diContainer) {
$builder = new ContainerBuilder();
// $builder->setDefinitionCache(new \Doctrine\Common\Cache\ArrayCache());
$builder->setDefinitionCache(new FilesystemCache(__DIR__ . '/../../var/Cache/'));
$builder->addDefinitions(__DIR__ . '/../../Classes/Configuration/dependencyInjectionConfiguration.php');
$this->diContainer = $builder->build();
// $this->diContainer = ContainerBuilder::buildDevContainer();
$this->diContainer->get('Cundd\\PersistentObjectStore\\Event\\SharedEventEmitter');
}
return $this->diContainer;
}
public function createProcessorsFor(IndexedEntity $entity) : array
{
switch ($entityClassName = get_class($entity)) {
default:
throw new NoProcessorForEntityException(sprintf('No entity processor available for `%s`', $entityClassName));
case Profile::class:
return [$this->container->get(PublicProfilesProcessor::class), $this->container->get(PublicExpertsProcessor::class)];
case Collection::class:
return [$this->container->get(PublicCollectionsProcessor::class)];
case Community::class:
return [$this->container->get(PublicCommunitiesProcessor::class)];
case Post::class:
return [$this->container->get(ProfileProcessor::class), $this->container->get(CollectionProcessor::class), $this->container->get(CommunityProcessor::class), $this->container->get(PublicContentProcessor::class), $this->container->get(PublicDiscussionsProcessor::class)];
}
}
/**
* Run middleware
*
* @param $routeParams
* @return mixed
* @throws \DI\NotFoundException
*/
private function handleMiddleware($routeParams)
{
$middlewareInstance = $this->container->get($routeParams['middleware']);
return $middlewareInstance->handle($this->container, function () use($routeParams) {
return $this->handleController($routeParams['controller']);
});
}
/**
* Отправить ответ.
*
* @param Response $response
*/
protected function sendResponse(Response $response)
{
/** @var Request $request */
$request = $this->container->get(Request::class);
$response->prepare($request);
$response->send();
}
/**
* run Application
*/
public function run()
{
$response = $this->container->get(TwigResponse::class);
$response->setTemplate('error/404');
try {
$this->eventDispatcher->addSubscriber($this->routerListener);
$response = $this->httpKernel->handle($this->request);
} catch (ResourceNotFoundException $e) {
$response->setContent(['message' => $e->getMessage()]);
} catch (\Exception $e) {
// $response->setContent(['message' => $e->getMessage()]);
throw $e;
} finally {
$response->send();
$this->httpKernel->terminate($this->request, $response);
}
}
/**
* Returns an entry of the container by its name.
*
* @see \DI\Container::get
*
* @param string $name
*
* @throws \Slim\Exception\ContainerValueNotFoundException
*
* @return mixed
*/
public function get($name)
{
try {
return parent::get($name);
} catch (\Exception $exception) {
throw new ContainerValueNotFoundException($exception->getMessage());
}
}
/**
* @param $class
* @return ControllerInterface
* @throws RouterException
*/
private function constructController($class)
{
if (class_exists($class)) {
$controller = $this->container->get($class);
return $controller;
} else {
throw new RouterException("Controller can not be found.");
}
}
/**
* Executa o watcher determinado para a rota encontrada.
*
* @param string $watcher_name
* @param $controller
* @param array $params
* @return
*/
private function runWatcher($watcher_name, $controller, $params = [])
{
$watcher_name = ucfirst($watcher_name) . 'Watcher';
$full_name_watcher = mountCtrlFullName($watcher_name, [$this->app_root_namespace, 'Watchers']);
$watcher = $this->di->get($full_name_watcher);
$watcher->setController($controller);
$watcher->setUrlParams($params);
return $watcher->run();
}
/**
* Returns an instantiated controller
*
* @param string $class A class name
*
* @return object
*/
protected function instantiateController($class)
{
$obj = $this->container->get($class);
if ($obj instanceof LoggerAwareInterface) {
$obj->setLogger($this->logger);
}
if ($obj instanceof ContainerAwareInterface) {
$obj->setContainer($this->container);
}
return $obj;
}
protected function registerMocks()
{
$parser = new PhpDocReader();
$class = new ReflectionClass($this);
$registeredNames = array();
//Find every member that begins with "mock" or "spy"
foreach ($class->getProperties() as $property) {
if (strpos($property->name, 'mock') === 0 || strpos($property->name, 'spy') === 0) {
if ($property->name == "mockObjects") {
//This is inherited from PHPUnit_Framework_TestCase and we can't mock it
continue;
}
//Use the type as the DI name
$name = $parser->getPropertyType($property);
//TODO: Check for duplicates
//$this->DIContainer->getDefinitionManager()->getDefinition()
$property->setAccessible(true);
$this->DIContainer->set($name, $property->getValue($this));
}
}
}
/**
* start the application
*
* Call the module controller and the appropriate method
*
* @throws \DI\NotFoundException
*/
public function run()
{
/**
* @var ControllerInterface $controller
*/
$controller = $this->moduleDiContainer->get('Controller');
if ($controller instanceof ControllerInterface) {
$controller->setDic($this->moduleDiContainer);
}
$method = $this->method;
$controller->{$method}();
}
/**
* @inheritdoc
*/
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
{
$route = $request->getAttribute('route');
/**
* Controller Class name
*/
$controllerClass = $this->getFullControllerName($route->attributes['module'], $route->attributes['controller']);
/**
* Check class existence
*/
if ($this->controllerClassExists($controllerClass)) {
// Instance of controller
$controller = $this->diContainer->get($controllerClass);
$action = $this->getFullActionName($route->attributes['action']);
// Check existence of controller action
if (!method_exists($controller, $action)) {
throw new NotFoundHttpException(sprintf('Controller "%s" has no action "%s".', $controllerClass, $action));
}
// Call controller action
return $next($request, $controller->{$action}($request, $response), $next);
}
}
/**
* @param string $controller
*
* @return GenericController
*/
private function getControllerInstance(string $controller)
{
if ($this->container && $this->container->has($controller)) {
$obj = $this->container->get($controller);
}
if (!isset($obj)) {
$obj = new $controller();
if ($this->container) {
$this->container->injectOn($obj);
}
}
return $obj;
}
