public function __invoke(ContainerInterface $container, $reqName, $requestedName)
{
$config = $container->get('config');
$serviceConfig = $config[AbstractDataStoreFactory::KEY_DATASTORE][$requestedName];
if (isset($serviceConfig[DbTableAbstractFactory::KEY_TABLE_GATEWAY])) {
if ($container->has($serviceConfig[DbTableAbstractFactory::KEY_TABLE_GATEWAY])) {
$tableGateway = $container->get($serviceConfig[DbTableAbstractFactory::KEY_TABLE_GATEWAY]);
} else {
throw new DataStoreException('Can\'t create ' . $serviceConfig[DbTableAbstractFactory::KEY_TABLE_GATEWAY]);
}
} else {
if (isset($serviceConfig[DbTableAbstractFactory::KEY_TABLE_NAME])) {
$tableName = $serviceConfig[DbTableAbstractFactory::KEY_TABLE_NAME];
$dbServiceName = isset($serviceConfig[DbTableAbstractFactory::KEY_DB_ADAPTER]) ? $serviceConfig[DbTableAbstractFactory::KEY_DB_ADAPTER] : 'db';
$db = $container->has($dbServiceName) ? $container->get($dbServiceName) : null;
if ($container->has('TableManagerMysql')) {
$tableManager = $container->get('TableManagerMysql');
} else {
$tableManager = new TableManagerMysql($db);
}
$hasTable = $tableManager->hasTable($tableName);
if (!$hasTable) {
$tableManager->rewriteTable($tableName, $this->tablePreferenceTableData);
}
$tableGateway = new TableGateway($tableName, $db);
} else {
throw new DataStoreException('There is not table name for ' . $requestedName . 'in config \'dataStore\'');
}
}
$class = (isset($serviceConfig[AbstractFactoryAbstract::KEY_CLASS]) and is_a($serviceConfig[AbstractFactoryAbstract::KEY_CLASS], DbTable::class, true)) ? $serviceConfig[AbstractFactoryAbstract::KEY_CLASS] : DbTable::class;
return new $class($tableGateway);
}
/**
* @param ContainerInterface $container
* @return SessionManager
*
* @throws RuntimeException
* @throws ContainerException
* @throws InvalidArgumentException
*/
public function __invoke(ContainerInterface $container)
{
$c = $container->get('config');
$config = array_key_exists('session', $c) ? $c['session'] : ['name' => 'expressive'];
$sessionConfig = null;
$sessionSaveHandler = null;
$sessionStorage = null;
$sessionValidators = [];
if ($container->has(ConfigInterface::class)) {
$sessionConfig = $container->get(ConfigInterface::class);
}
if (array_key_exists('handler', $config)) {
if ($container->has($config['handler'])) {
$sessionSaveHandler = $container->get(SaveHandlerInterface::class);
}
}
if ($container->has(StorageInterface::class)) {
$sessionStorage = $container->get(StorageInterface::class);
}
if (array_key_exists('validators', $config)) {
if (!is_array($config['validators'])) {
throw new InvalidArgumentException('Session validators must be array, ' . gettype($config['validators']) . ' given');
}
$sessionValidators = $config['validators'];
}
return new SessionManager($sessionConfig, $sessionStorage, $sessionSaveHandler, $sessionValidators);
}
/**
* Resolve toResolve into a closure that that the router can dispatch.
*
* If toResolve is of the format 'class:method', then try to extract 'class'
* from the container otherwise instantiate it and then dispatch 'method'.
*
* @return \Closure
*
* @throws RuntimeException if the callable does not exist
* @throws RuntimeException if the callable is not resolvable
*/
private function resolve()
{
// if it's callable, then it's already resolved
if (is_callable($this->toResolve)) {
$this->resolved = $this->toResolve;
// check for slim callable as "class:method"
} elseif (is_string($this->toResolve)) {
$callable_pattern = '!^([^\\:]+)\\:([a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*)$!';
if (preg_match($callable_pattern, $this->toResolve, $matches)) {
$class = $matches[1];
$method = $matches[2];
if ($this->container->has($class)) {
$this->resolved = [$this->container->get($class), $method];
} else {
if (!class_exists($class)) {
throw new RuntimeException(sprintf('Callable %s does not exist', $class));
}
$this->resolved = [new $class(), $method];
}
if (!is_callable($this->resolved)) {
throw new RuntimeException(sprintf('%s is not resolvable', $this->toResolve));
}
} else {
throw new RuntimeException(sprintf('%s is not resolvable', $this->toResolve));
}
}
}
public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
{
$config = $container->get('config');
if ($this::$flag) {
$serviceConfig = $config[self::KEY_DATASTORE][self::KEY_CACHEABLE_NOTIFICATION_TYPE];
} else {
$serviceConfig = $config[self::KEY_DATASTORE][self::KEY_CACHEABLE_NOTIFICATION];
}
$requestedClassName = $serviceConfig[self::KEY_CLASS];
if (isset($serviceConfig[self::KEY_DATASOURCE])) {
if ($container->has($serviceConfig[self::KEY_DATASOURCE])) {
$getAll = $container->get($serviceConfig[self::KEY_DATASOURCE]);
if (method_exists($getAll, 'setNotificationType')) {
$getAll->setNotificationType($requestedName);
}
} else {
throw new DataStoreException('There is DataSource not created ' . $requestedName . 'in config \'dataStore\'');
}
} else {
throw new DataStoreException('There is DataSource for ' . $requestedName . 'in config \'dataStore\'');
}
$serviceConfig[self::KEY_CACHEABLE] = 'Notification' . ucfirst($requestedName);
if ($container->has($serviceConfig[self::KEY_CACHEABLE])) {
$cashStore = $container->get($serviceConfig[self::KEY_CACHEABLE]);
} else {
throw new DataStoreException('There is DataSource for ' . $serviceConfig[self::KEY_CACHEABLE] . 'in config \'dataStore\'');
}
//$cashStore = isset($serviceConfig['cashStore']) ? new $serviceConfig['cashStore']() : null;
return new $requestedClassName($getAll, $cashStore);
}
public function __get($property)
{
if ($this->container->has($property)) {
return $this->container->get($property);
}
throw new \RuntimeException(sprintf('Property %s does not exist', get_class($this) . "::{$property}"));
}
/**
* Get shared instance
*
* @param $classOrAlias
* @return mixed
*/
public function getSharedInstance($classOrAlias)
{
if ($this->container->has($classOrAlias)) {
return $this->container->get($classOrAlias);
}
return $this->diInstanceManager->getSharedInstance($classOrAlias);
}
/**
* @param string $eventName
* @param string $handlerName
* @throws EventBusException
*/
public function register($eventName, $handlerName)
{
if (!$this->locator->has($handlerName)) {
throw new EventBusException(sprintf("Event handler '%s' cannot be found by locator", $handlerName));
}
$this->map[$eventName][] = $handlerName;
}
/**
* @param AbstractFunctionCallDefinition $definition
* @param \ReflectionFunctionAbstract $functionReflection
* @param array $parameters
*
* @throws DefinitionException A parameter has no value defined or guessable.
* @return array Parameters to use to call the function.
*/
public function resolveParameters(AbstractFunctionCallDefinition $definition = null, \ReflectionFunctionAbstract $functionReflection = null, array $parameters = array())
{
$args = array();
if (!$functionReflection) {
return $args;
}
foreach ($functionReflection->getParameters() as $index => $parameter) {
if (array_key_exists($parameter->getName(), $parameters)) {
// Look in the $parameters array
$value = $parameters[$parameter->getName()];
} elseif ($definition && $definition->hasParameter($index)) {
// Look in the definition
$value = $definition->getParameter($index);
} else {
// If the parameter is optional and wasn't specified, we take its default value
if ($parameter->isOptional()) {
$args[] = $this->getParameterDefaultValue($parameter, $functionReflection);
continue;
}
throw new DefinitionException(sprintf("The parameter '%s' of %s has no value defined or guessable", $parameter->getName(), $this->getFunctionName($functionReflection)));
}
if ($value instanceof EntryReference) {
// If the container cannot produce the entry, we can use the default parameter value
if (!$this->container->has($value->getName()) && $parameter->isOptional()) {
$value = $this->getParameterDefaultValue($parameter, $functionReflection);
} else {
$value = $this->container->get($value->getName());
}
}
$args[] = $value;
}
return $args;
}
/**
* @param \Psr\Http\Message\ServerRequestInterface $request
* @param \Psr\Http\Message\ResponseInterface $response
* @param callable|null $next
*
* @throws \Wiring\Exception\MethodNotAllowedException
* @throws \Wiring\Exception\NotFoundException
* @return \Psr\Http\Message\ResponseInterface
*/
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next = null)
{
$routeInfo = $this->fastRoute->dispatch($request->getMethod(), $request->getUri()->getPath());
if ($routeInfo[0] == Dispatcher::FOUND) {
// Get request params
foreach ($routeInfo[2] as $param => $value) {
$request = $request->withAttribute($param, $value);
}
// Get request with attribute
$request = $request->withAttribute($this->attribute, $routeInfo[1]);
return $next($request, $response);
}
if ($routeInfo[0] == Dispatcher::METHOD_NOT_ALLOWED) {
// Check has handler
if (!$this->container->has(MethodNotAllowedHandlerInterface::class)) {
throw new MethodNotAllowedException($request, $response, $routeInfo[1]);
}
/** @var callable $notAllowedHandler */
$notAllowedHandler = $this->container->get(MethodNotAllowedHandlerInterface::class);
return $notAllowedHandler($request, $response, $routeInfo[1]);
}
// Check has handler
if (!$this->container->has(NotFoundHandlerInterface::class)) {
throw new NotFoundException($request, $response);
}
/** @var callable $notFoundHandler */
$notFoundHandler = $this->container->get(NotFoundHandlerInterface::class);
return $notFoundHandler($request, $response);
}
/**
* @param ContainerInterface $container
* @param string $requestedName
* @param array|null $options
* @return mixed
* @throws DataStoreException
*/
public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
{
if ($this::$KEY_IN_CREATE) {
throw new DataStoreException("Create will be called without pre call canCreate method");
}
$this::$KEY_IN_CREATE = 1;
$config = $container->get('config');
$serviceConfig = $config[self::KEY_DATASTORE][$requestedName];
$requestedClassName = $serviceConfig[self::KEY_CLASS];
if (isset($serviceConfig[self::KEY_DATASOURCE])) {
if ($container->has($serviceConfig[self::KEY_DATASOURCE])) {
$getAll = $container->get($serviceConfig[self::KEY_DATASOURCE]);
} else {
$this::$KEY_IN_CREATE = 0;
throw new DataStoreException('There is DataSource not created ' . $requestedName . 'in config \'dataStore\'');
}
} else {
$this::$KEY_IN_CREATE = 0;
throw new DataStoreException('There is DataSource for ' . $requestedName . 'in config \'dataStore\'');
}
if (isset($serviceConfig[self::KEY_CACHEABLE])) {
if ($container->has($serviceConfig[self::KEY_CACHEABLE])) {
$cashStore = $container->get($serviceConfig[self::KEY_CACHEABLE]);
} else {
$this::$KEY_IN_CREATE = 0;
throw new DataStoreException('There is DataSource for ' . $serviceConfig[self::KEY_CACHEABLE] . 'in config \'dataStore\'');
}
} else {
$cashStore = null;
}
$this::$KEY_IN_CREATE = 0;
//$cashStore = isset($serviceConfig['cashStore']) ? new $serviceConfig['cashStore']() : null;
return new $requestedClassName($getAll, $cashStore);
}
/**
* {@inherit}
*
* {@inherit}
*/
public function __invoke(ContainerInterface $container, $requestedName, array $options = null)
{
$config = $container->get('config');
$this->tableName = isset($config[self::KEY][self::KEY_TABLE_NAME]) ? $config[self::KEY][self::KEY_TABLE_NAME] : (isset($options[self::KEY_TABLE_NAME]) ? $options[self::KEY_TABLE_NAME] : self::TABLE_NAME);
$this->db = $container->has('db') ? $container->get('db') : null;
if (is_null($this->db)) {
throw new QueueException('Can\'t create db Adapter');
}
if ($container->has(TableManagerMysql::KEY_IN_CONFIG)) {
$tableManager = $container->get(TableManagerMysql::KEY_IN_CONFIG);
} else {
$tableManager = new TableManagerMysql($this->db);
}
$hasPromiseStoreTable = $tableManager->hasTable($this->tableName);
if (!$hasPromiseStoreTable) {
$tableManager->rewriteTable($this->tableName, $this->promiseTableData);
}
$messagesStore = $container->has(Message\Factory\StoreFactory::KEY) ? $container->get(Message\Factory\StoreFactory::KEY) : null;
if (is_null($messagesStore)) {
throw new QueueException('Can\'t create Messages Store');
}
$promisesStore = $container->has(Promise\Factory\StoreFactory::KEY) ? $container->get(Promise\Factory\StoreFactory::KEY) : null;
if (is_null($promisesStore)) {
throw new QueueException('Can\'t create Promises Store');
}
return new Store($this->tableName, $this->db, $messagesStore, $promisesStore);
}
public function __invoke(ContainerInterface $container)
{
if (!$container->has(Configuration::class) || !$container->has(EventManager::class) || !$container->has(Connection::class)) {
throw new ContainerNotRegisteredException('Doctrine\\Common\\EventManager::class,
Doctrine\\ORM\\Configuration::class and Doctrine\\DBAL\\Connection::class
must be registered in the container');
}
$config = $container->has('config') ? $container->get('config') : [];
$underscoreNamingStrategy = isset($config['doctrine']['orm']['underscore_naming_strategy']) ? $config['doctrine']['orm']['underscore_naming_strategy'] : false;
/** @var Configuration $configuration */
$configuration = $container->get(Configuration::class);
$configuration->setProxyDir(isset($config['doctrine']['orm']['proxy_dir']) ? $config['doctrine']['orm']['proxy_dir'] : 'data/cache/EntityProxy');
$configuration->setProxyNamespace(isset($config['doctrine']['orm']['proxy_namespace']) ? $config['doctrine']['orm']['proxy_namespace'] : 'EntityProxy');
$configuration->setAutoGenerateProxyClasses(isset($config['doctrine']['orm']['auto_generate_proxy_classes']) ? $config['doctrine']['orm']['auto_generate_proxy_classes'] : false);
// ORM mapping by Annotation
AnnotationRegistry::registerFile('vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
$driver = new AnnotationDriver(new AnnotationReader(), ['data/cache/doctrine']);
$configuration->setMetadataDriverImpl($driver);
// Cache
$cache = $container->get(Cache::class);
$configuration->setQueryCacheImpl($cache);
$configuration->setResultCacheImpl($cache);
$configuration->setMetadataCacheImpl($cache);
return EntityManager::create($container->get(Connection::class), $configuration, $container->get(EventManager::class));
}
/**
* @param ContainerInterface $container
* @returns ZendViewRenderer
*/
public function __invoke(ContainerInterface $container)
{
$config = $container->has('config') ? $container->get('config') : [];
$config = isset($config['templates']) ? $config['templates'] : [];
// Configuration
$resolver = new Resolver\AggregateResolver();
$resolver->attach(new Resolver\TemplateMapResolver(isset($config['map']) ? $config['map'] : []), 100);
// Create the renderer
$renderer = new PhpRenderer();
$renderer->setResolver($resolver);
$manager = $container->has(HelperPluginManager::class) ? $container->get(HelperPluginManager::class) : new HelperPluginManager();
// Inject helpers
$this->injectHelpers($renderer, $manager);
// Initialize renderer for HelperPluginManager
$manager->setRenderer($renderer);
// Inject renderer
$view = new ZendViewRenderer($renderer, isset($config['layout']) ? $config['layout'] : null);
// Add template paths
$allPaths = isset($config['paths']) && is_array($config['paths']) ? $config['paths'] : [];
foreach ($allPaths as $namespace => $paths) {
$namespace = is_numeric($namespace) ? null : $namespace;
foreach ((array) $paths as $path) {
$view->addPath($path, $namespace);
}
}
return $view;
}
public function __invoke(ContainerInterface $container)
{
$template = $container->has('Zend\\Expressive\\Template\\TemplateRendererInterface') ? $container->get('Zend\\Expressive\\Template\\TemplateRendererInterface') : null;
$config = $container->has('config') ? $container->get('config') : [];
$config = isset($config['zend-expressive']['error_handler']) ? $config['zend-expressive']['error_handler'] : [];
return new TemplatedErrorHandler($template, isset($config['template_404']) ? $config['template_404'] : 'error/404', isset($config['template_error']) ? $config['template_error'] : 'error/error');
}
public function testFactoryWithTemplate()
{
$factory = new PageFactory();
$this->container->has(TemplateRendererInterface::class)->willReturn(true);
$this->container->get(TemplateRendererInterface::class)->willReturn($this->prophesize(TemplateRendererInterface::class));
$this->assertTrue($factory instanceof PageFactory);
}
/**
* @param ContainerInterface $container
* @return TwigRenderer
*/
public function __invoke(ContainerInterface $container)
{
$config = $container->has('config') ? $container->get('config') : [];
$debug = array_key_exists('debug', $config) ? (bool) $config['debug'] : false;
$config = isset($config['templates']) ? $config['templates'] : [];
$cacheDir = isset($config['cache_dir']) ? $config['cache_dir'] : false;
// Create the engine instance
$loader = new TwigLoader();
$environment = new TwigEnvironment($loader, ['cache' => $debug ? false : $cacheDir, 'debug' => $debug, 'strict_variables' => $debug, 'auto_reload' => $debug]);
// Add extensions
if ($container->has(RouterInterface::class)) {
$environment->addExtension(new TwigExtension($container->get(RouterInterface::class), isset($config['assets_url']) ? $config['assets_url'] : '', isset($config['assets_version']) ? $config['assets_version'] : ''));
}
if ($debug) {
$environment->addExtension(new TwigExtensionDebug());
}
// Inject environment
$twig = new TwigRenderer($environment, isset($config['extension']) ? $config['extension'] : 'html.twig');
// Add template paths
$allPaths = isset($config['paths']) && is_array($config['paths']) ? $config['paths'] : [];
foreach ($allPaths as $namespace => $paths) {
$namespace = is_numeric($namespace) ? null : $namespace;
foreach ((array) $paths as $path) {
$twig->addPath($path, $namespace);
}
}
return $twig;
}
/**
* @param ContainerInterface $container
* @return RpcServiceModelFactory
* @throws ServiceNotCreatedException
*/
public function __invoke(ContainerInterface $container)
{
if (!$container->has(ModulePathSpec::class) || !$container->has(ConfigResourceFactory::class) || !$container->has(ModuleModel::class) || !$container->has('SharedEventManager')) {
throw new ServiceNotCreatedException(sprintf('%s is missing one or more dependencies from ZF\\Configuration', RpcServiceModelFactory::class));
}
return new RpcServiceModelFactory($container->get(ModulePathSpec::class), $container->get(ConfigResourceFactory::class), $container->get('SharedEventManager'), $container->get(ModuleModel::class));
}
/**
* @param ContainerInterface $container
* @return DoctrineRestServiceResource
*/
public function __invoke(ContainerInterface $container)
{
if (!$container->has(DoctrineRestServiceModelFactory::class) || !$container->has(InputFilterModel::class) || !$container->has(DocumentationModel::class)) {
throw new ServiceNotCreatedException(sprintf('%s is missing one or more dependencies', DoctrineRestServiceResource::class));
}
return new DoctrineRestServiceResource($container->get(DoctrineRestServiceModelFactory::class), $container->get(InputFilterModel::class), $container->get(DocumentationModel::class));
}
public function __invoke(ContainerInterface $container)
{
$config = $container->has(self::CONFIG_SERVICE_NAME) ? $container->get(self::CONFIG_SERVICE_NAME) : null;
$checks = $container->has(self::CHECKS_SERVICE_NAME) ? $container->get(self::CHECKS_SERVICE_NAME) : null;
$reporter = $container->has(self::REPORTER_SERVICE_NAME) ? $container->get(self::REPORTER_SERVICE_NAME) : null;
return new Runner($config, $checks, $reporter);
}
public function onLocateMessageHandler(ActionEvent $actionEvent)
{
$messageHandlerAlias = $actionEvent->getParam(MessageBus::EVENT_PARAM_MESSAGE_HANDLER);
if (is_string($messageHandlerAlias) && $this->serviceLocator->has($messageHandlerAlias)) {
$actionEvent->setParam(MessageBus::EVENT_PARAM_MESSAGE_HANDLER, $this->serviceLocator->get($messageHandlerAlias));
}
}
public function __invoke(ContainerInterface $container, $name, $requestedName)
{
$config = $container->get('config');
$serviceConfig = $config[self::KEY_DATASTORE][self::KEY_ALL_NOTIFICATION];
if (isset($serviceConfig[self::KEY_TABLE_GATEWAY])) {
if ($container->has($serviceConfig[self::KEY_TABLE_GATEWAY])) {
$tableGateway = $container->get($serviceConfig[self::KEY_TABLE_GATEWAY]);
} else {
throw new DataStoreException('Can\'t create ' . $serviceConfig[self::KEY_TABLE_GATEWAY]);
}
} else {
if (isset($serviceConfig[self::KEY_TABLE_NAME])) {
$tableName = $serviceConfig[self::KEY_TABLE_NAME];
$dbServiceName = isset($serviceConfig[self::KEY_DB_ADAPTER]) ? $serviceConfig[self::KEY_DB_ADAPTER] : 'db';
$db = $container->has($dbServiceName) ? $container->get($dbServiceName) : null;
/*if ($container->has('TableManagerMysql')) {
$tableManager = $container->get('TableManagerMysql');
} else {*/
$tableManager = new TableManagerMysql($db);
/*}*/
$hasTable = $tableManager->hasTable($tableName);
if (!$hasTable) {
$tableManager->rewriteTable($tableName, $this->tablePreferenceTableData);
}
$tableGateway = new TableGateway($tableName, $db);
} else {
throw new DataStoreException('There is not table name for ' . self::KEY_ALL_NOTIFICATION . 'in config \'dataStore\'');
}
}
return new DbTable($tableGateway);
}
/**
* @return array
*/
protected function middleware()
{
$middleware = [];
if ($this->container->has('command-bus.middleware')) {
$middleware = $this->container->get('command-bus.middleware');
}
return $middleware;
}
/**
* {@inheritdoc}
*/
public function has($id)
{
$metadata = ['id' => $id];
$benchmark = $this->profiler->start('Container::has', $metadata, 'Container-Interop');
$has = $this->container->has($id);
$this->profiler->stop($benchmark);
return $has;
}
/**
* Adds value.
*
* @param string $id
* @param mixed $value
* @return $this
* @throws Exception\Container
*/
public function add(string $id, $value)
{
if ($this->delegateMaster && $this->delegateMaster->has($id)) {
throw new Exception\Container('Value "%s" assignment will not take effect since master ' . 'container have value with the same id.', $id);
}
$this->values[$id] = $value;
return $this;
}
public function testRedis()
{
$redisCache = $this->prophesize(RedisCache::class);
$this->container->has(RedisCache::class)->willReturn(true);
$this->container->get(RedisCache::class)->willReturn($redisCache->reveal());
$doctrineCache = $this->callFactory();
static::assertInstanceOf(RedisCache::class, $doctrineCache);
}
public function __invoke($requestedName)
{
if (!$this->container->has($requestedName)) {
throw new \Exception("DataStore: " . $requestedName . " not found in container");
}
$dataStore = $this->container->get($requestedName);
return new ConfigureGenerator($dataStore);
}
/**
* {@inheritDoc}
* @throws \Interop\Container\Exception\ContainerException
* @throws \Interop\Container\Exception\NotFoundException
*/
public function resolve($identifier)
{
if (!$this->container->has($identifier)) {
$this->logger->error(sprintf('Could not find object defined by id "%s"', $identifier));
return null;
}
return $this->container->get($identifier);
}
/**
* @param ContainerInterface $container
* @return MongoDbEventStoreAdapter
*/
public function __invoke(ContainerInterface $container)
{
$config = $container->get('config');
$config = $this->options($config)['adapter']['options'];
$mongoClient = isset($config['mongo_connection_alias']) ? $container->get($config['mongo_connection_alias']) : new \MongoClient();
$messageFactory = $container->has(MessageFactory::class) ? $container->get(MessageFactory::class) : new FQCNMessageFactory();
$messageConverter = $container->has(MessageConverter::class) ? $container->get(MessageConverter::class) : new NoOpMessageConverter();
return new MongoDbEventStoreAdapter($messageFactory, $messageConverter, $mongoClient, $config['db_name'], $config['write_concern'], $config['transaction_timeout'], $config['stream_collection_map']);
}
public function testFactoryWithTemplate()
{
$factory = new HomePageFactory();
$this->container->has(TemplateInterface::class)->willReturn(true);
$this->container->get(TemplateInterface::class)->willReturn($this->prophesize(TemplateInterface::class));
$this->assertTrue($factory instanceof HomePageFactory);
$homePage = $factory($this->container->reveal());
$this->assertTrue($homePage instanceof HomePageAction);
}
public function __invoke(ContainerInterface $container)
{
if (!$container->has(Configuration::class) || !$container->has(EventManager::class)) {
throw new ContainerNotRegisteredException('Doctrine\\Common\\EventManager::class and
Doctrine\\ORM\\Configuration::class must be registered in the container');
}
$config = $container->get('config');
return DriverManager::getConnection(isset($config['doctrine']['connection']) ? $config['doctrine']['connection'] : [], $container->get(Configuration::class), $container->get(EventManager::class));
}