/** * Construct AclFilter * * @param AbstractManagerRegistry $doctrine * @param SecurityContextInterface $securityContext * @param array $options */ public function __construct(AbstractManagerRegistry $doctrine, SecurityContextInterface $securityContext, array $options = array()) { $this->em = $doctrine->getManager(); $this->securityContext = $securityContext; $this->aclConnection = $doctrine->getConnection('default'); list($this->aclWalker, $this->roleHierarchy) = $options; }
/** * @param ClassMetadata $classMetadata * @return \Doctrine\Common\Persistence\ObjectRepository */ protected function getRepository(ClassMetadata $classMetadata) { $repository = $this->managerRegistry->getRepository($classMetadata->getName()); if (!$repository instanceof ManagedRepositoryInterface) { return false; } return $repository; }
/** * Persist block * * This block defines if entity must be persisted using desired * manager. * * This manager is defined as default in bundle parameters, but can * be overwritten in each annotation * * Same logic in perisist option. This variable is defined in bundle * parameters and can be overwritten there. Can also be defined in * every single annotation * * @param AnnotationEntity $annotation Annotation * @param Object $entity Entity * * @return EntityAnnotationResolver self Object */ protected function resolvePersist(AnnotationEntity $annotation, $entity) { /** * Persist block * * This block defines if entity must be persisted using desired * manager. * * Given the entity we can find which manager manages it * * Same logic in perisist option. This variable is defined in bundle * parameters and can be overwritten there. Can also be defined in * every single annotation */ /** * Get the persist variable. If not defined, is set as defined in * parameters */ $persist = !is_null($annotation->getPersist()) ? $annotation->getPersist() : $this->defaultPersist; if ($persist) { /** * Loading locally desired Doctrine manager */ $this->doctrine->getManagerForClass(get_class($entity))->persist($entity); } return $this; }
/** * Specific annotation evaluation. * * @param Request $request Request * @param Annotation $annotation Annotation * @param ReflectionMethod $method Method * * @return EntityAnnotationResolver self Object * * @throws EntityNotFoundException */ public function evaluateAnnotation(Request $request, Annotation $annotation, ReflectionMethod $method) { /** * Annotation is only laoded if is typeof AnnotationEntity */ if ($annotation instanceof AnnotationObjectManager) { /** * Creating new instance of desired entity */ $entity = $this->entityProvider->provide($annotation->getClass()); $objectManager = $this->doctrine->getManagerForClass(get_class($entity)); /** * Get the parameter name. If not defined, is set as defined in * parameters */ $parameterName = $annotation->getName() ?: $this->defaultName; $request->attributes->set($parameterName, $objectManager); } return $this; }
public function __construct(array $connections, array $managers, $defaultConnection, $defaultManager, Nette\DI\Container $serviceLocator) { parent::__construct('ORM', $connections, $managers, $defaultConnection, $defaultManager, 'Doctrine\\ORM\\Proxy\\Proxy'); $this->serviceLocator = $serviceLocator; }
/** * Generate QueryBuilder * * @param Object $entity Entity instance * * @return QueryBuilder Query builder */ public function createQueryBuilder($entity) { $entityNamespace = get_class($entity); return $this->doctrine->getManagerForClass(get_class($entity))->createQueryBuilder()->select(array('x'))->from($entityNamespace, 'x'); }
/** * Constructor. * * @param Container $app A Container instance * @param string $proxyInterfaceName The proxy interface name */ public function __construct(Container $app, $proxyInterfaceName = 'Doctrine\\ORM\\Proxy\\Proxy') { $this->app = $app; parent::__construct(null, [], ['default' => 'orm.em'], null, 'default', $proxyInterfaceName); }
public function __construct(Application $app, $name, array $connections, array $managers, $defaultConnection, $defaultManager, $proxyInterfaceName) { $this->app = $app; parent::__construct($name, $connections, $managers, $defaultConnection, $defaultManager, $proxyInterfaceName); }
public function __construct($serviceCreator, $name = 'anonymous', array $connections = array('default' => 'default_connection'), array $managers = array('default' => 'default_manager'), $defaultConnection = null, $defaultManager = null, $proxyInterface = 'Doctrine\\Common\\Persistence\\Proxy') { if (null === $defaultConnection) { list($defaultConnection, ) = each($connections); } if (null === $defaultManager) { list($defaultManager, ) = each($managers); } parent::__construct($name, $connections, $managers, $defaultConnection, $defaultManager, $proxyInterface); if (!is_callable($serviceCreator)) { throw new \InvalidArgumentException('$serviceCreator must be a valid callable.'); } $this->serviceCreator = $serviceCreator; }
public function __construct(EntityManager $em) { parent::__construct(null, [], ['em' => 'em'], null, 'em', Proxy::class); $this->services = new ArrayCollection(); $this->addService('em', $em); }
/** * @param Container $container * @param array $connections * @param array $entityManagers * @param string $defaultConnection * @param string $defaultEntityManager */ public function __construct(Container $container, array $connections, array $entityManagers, $defaultConnection, $defaultEntityManager) { $this->setContainer($container); parent::__construct('ORM', $connections, $entityManagers, $defaultConnection, $defaultEntityManager, 'Doctrine\\ORM\\Proxy\\Proxy'); }
/** * Constructor. * * @param string $name * @param array $connections * @param array $managers * @param string $defaultConnection * @param string $defaultManager * @param string $proxyInterfaceName * @param ServiceManager $serviceManager */ public function __construct($name, array $connections, array $managers, $defaultConnection, $defaultManager, $proxyInterfaceName, ServiceManager $serviceManager) { parent::__construct($name, $connections, $managers, $defaultConnection, $defaultManager, $proxyInterfaceName); $this->serviceManager = $serviceManager; }
/** * Given an entity namespace, return associated object Manager. * * @param string $entityNamespace Entity Namespace * * @return ObjectManager|null Object manager */ public function getManagerByEntityNamespace($entityNamespace) { return $this->manager->getManagerForClass($entityNamespace); }
public function __construct($c, $name, array $connections, array $managers, $defaultConnection, $defaultManager, $proxyInterfaceName) { $this->c = $c; parent::__construct($name, $connections, $managers, $defaultConnection, $defaultManager, $proxyInterfaceName); }