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 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(); }
public function offsetGet($id) { if (parent::offsetExists($id)) { return parent::offsetGet($id); } return $this->phpdi->get($id); }
/** * クライアントの準備 * @return void */ protected function boot() { $this->container->set('config', $this->config); $this->container->set('api', $this->container->get(QiitaAPIInterface::class)); Model::setFactory($this->container); Model::setApi($this->container->get('api')); }
/** * @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); }
/** * 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(); }
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; }
/** * @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; }
/** * @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; } } }
/** * 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)]; } }
/** * 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 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]); }
/** * @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]; }
/** * 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 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); }
public function resolve(ServerRequestInterface $request, Container $container) : Command { if (!$this->isResolvable($request)) { throw new UnresolvableCommandException(); } return $container->get($this->commandClassName); }
/** * Отправить ответ. * * @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; }
/** * 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}(); }
public function fetch(Filter $filter) : array { $result = []; $scripts = Chain::create($this->bundlesService->getBundles())->filter(function (Bundle $bundle) { return $bundle instanceof FrontlineBundleInjectable; })->map(function (FrontlineBundleInjectable $bundle) { return $bundle->getFrontlineScripts(); })->reduce(function (array $carry, array $scripts) { return array_merge($carry, $scripts); }, []); $scripts = array_map(function (string $script) { return $this->container->get($script); }, $scripts); foreach ($filter->filter($scripts) as $script) { if ($script instanceof FrontlineScript) { $result = array_merge_recursive($result, $script()); } else { throw new \Exception(); } } return $result; }
/** * @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; }
/** * @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 $name * @return mixed * @throws \DI\NotFoundException */ public function get($name) { $obj = parent::get($name); if ($obj instanceof LoggerAwareInterface) { $obj->setLogger($this->get(LoggerInterface::class)); } if ($obj instanceof EventDispatcherAwareInterface) { $obj->setEventDispatcher($this->get(EventDispatcherInterface::class)); } if ($obj instanceof ContainerAwareInterface) { $obj->setContainer($this); } return $obj; }
/** * Widget constructor. * * @param string $widgetClassNameOrAlias * @param Container $container */ public function __construct($widgetClassNameOrAlias, Container $container) { $instance = $container->make($widgetClassNameOrAlias, ['wpWidget' => $this]); if (!in_array(WidgetInterface::class, class_implements($instance))) { throw new RuntimeException("Incorrect widget class name or widget does not implement WidgetInterface"); } /** * Check if instance have listeners for wordpress * events which should be registered while * widget registering. */ if ($instance instanceof ActionInterface || $instance instanceof DataFilterInterface) { $container->get('EventManager')->attachListeners($instance); } $this->getInstance = function () use($instance) { return $instance; }; $params = $instance->getParams(); $controlOption = []; if ($params instanceof ControlableInterface) { $controlOption = $params->getControlOptions(); } parent::__construct($params->getId(), $params->getName(), $params->getOptions(), $controlOption); }
public function __invoke(Container $container) : EntityRepository { $em = $container->get(EntityManager::class); /** @var EntityManager $em */ return $em->getRepository($this->entityClassName); }