public function testRealSimpleTournament() { /** @var Tournament $tournament */ $tournament = $this->fixtures->getReference('tournament-0'); $engine = $this->getContainer()->get('fda.tournament.engine'); $engine->setTournament($tournament); /** @var Player $referee */ $referee = $this->fixtures->getReference('player-3'); /** @var Board $board */ $board = $this->fixtures->getReference('board-0'); $ledger = $this->getContainer()->get('fda.ledger'); $ledger->setOwner($referee); $ledger->setBoard($board); // --- init done // we should have 1 group $this->assertCount(1, $engine->getCurrentRoundGears()->getGameGearsGrouped()); // 3 players ava should result in 3 games $this->assertCount(3, $engine->getCurrentRoundGears()->getGameGearsGrouped()[0]); // - select first game and play ... $this->playGame0($engine, $ledger); $this->checkLeaderBoard0($engine->getCurrentRoundGears()->getLeaderBoard()); // - play the rest $this->playGame1($engine, $ledger); $this->playGame2($engine, $ledger); $this->checkLeaderBoardFinal($engine->getCurrentRoundGears()->getLeaderBoard()); }
/** * Populates identities for stored references * * @param LifecycleEventArgs $args */ public function postPersist(LifecycleEventArgs $args) { $object = $args->getDocument(); if (($name = $this->referenceRepository->getReferenceName($object)) !== false) { $identity = $args->getDocumentManager()->getUnitOfWork()->getDocumentIdentifier($object); $this->referenceRepository->setReferenceIdentity($name, $identity); } }
/** * Populates identities for stored references * * @param LifecycleEventArgs $args */ public function postPersist(LifecycleEventArgs $args) { $object = $args->getEntity(); if (($names = $this->referenceRepository->getReferenceNames($object)) !== false) { foreach ($names as $name) { $identity = $args->getEntityManager()->getUnitOfWork()->getEntityIdentifier($object); $this->referenceRepository->setReferenceIdentity($name, $identity); } } }
/** * @param string $name * * @return object */ protected function getFixture($name) { $manager = $this->getKernel()->getContainer()->get('doctrine.orm.default_entity_manager'); if (!$this->referenceRepository->hasReference($name)) { if (isset(static::$referenceRepositoryData[$name])) { $reference = $manager->getReference(static::$referenceRepositoryData[$name]['class'], static::$referenceRepositoryData[$name]['identifier']); $this->referenceRepository->setReference($name, $reference); } } return $this->referenceRepository->getReference($name); }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { $menuRecords = [['icon' => 'user', 'position' => 1, 'title' => 'A propos', 'page' => $this->referenceRepository->getReference('page-1')]]; foreach ($menuRecords as $menuRecord) { $menu = new Menu(); $menu->setIcon($menuRecord['icon']); $menu->setPosition($menuRecord['position']); $menu->setTitle($menuRecord['title']); $menu->setPage($menuRecord['page']); $manager->persist($menu); } $manager->flush(); }
public function testReferenceEntry() { $em = $this->getMockAnnotationReaderEntityManager(); $role = new TestEntity\Role(); $role->setName('admin'); $meta = $em->getClassMetadata(self::TEST_ENTITY_ROLE); $meta->getReflectionProperty('id')->setValue($role, 1); $referenceRepo = new ReferenceRepository($em); $referenceRepo->addReference('test', $role); $references = $referenceRepo->getReferences(); $this->assertEquals(1, count($references)); $this->assertArrayHasKey('test', $references); $this->assertInstanceOf(self::TEST_ENTITY_ROLE, $references['test']); }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { $blogTagRecords = []; for ($i = 0; $i < 10; ++$i) { $blogTagRecords[] = ['title' => 'Tag #' . ($i + 1), 'description' => 'Description of the Tag #' . ($i + 1)]; } foreach ($blogTagRecords as $blogTagRecord) { $blogTag = new BlogTag(); $blogTag->setTitle($blogTagRecord['title']); $blogTag->setDescription($blogTagRecord['description']); $manager->persist($blogTag); $manager->flush(); $this->referenceRepository->addReference('blog-tag-' . $blogTag->getId(), $blogTag); } }
/** * @param string $referenceName * @param bool $persist * @param callable $objectLoader * @return mixed */ protected function load($referenceName, $persist, \Closure $objectLoader, $defaultReferenceName = '') { if (is_null($referenceName)) { $referenceName = $defaultReferenceName; } if ($this->referenceRepository->hasReference($referenceName)) { return $this->referenceRepository->getReference($referenceName); } $object = $objectLoader($this, $referenceName); if ($persist) { $this->objectManager->persist($object); } $this->referenceRepository->setReference($referenceName, $object); return $object; }
/** * @param ReferenceRepository $referenceRepository * * @throws \RuntimeException * * @return string */ public function serialize(ReferenceRepository $referenceRepository) { $references = array(); $isORM = $referenceRepository->getManager() instanceof EntityManager; foreach ($referenceRepository->getReferences() as $name => $reference) { $reference = $referenceRepository->getReference($name); $references[$name]['identifier'] = $referenceRepository->getManager()->getUnitOfWork()->getEntityIdentifier($reference); if ($reference instanceof Proxy) { $ro = new \ReflectionObject($reference); $references[$name]['class'] = $ro->getParentClass()->getName(); } else { $references[$name]['class'] = get_class($reference); } } return serialize($references); }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { $pageRecords = [['name' => 'about', 'title' => 'A propos', 'content' => ' **ok** *about* ***a propos*** ### Hey ']]; foreach ($pageRecords as $pageRecord) { $page = new Page(); $page->setName($pageRecord['name']); $page->setTitle($pageRecord['title']); $page->setContent($pageRecord['content']); $manager->persist($page); $manager->flush(); $this->referenceRepository->addReference('page-' . $page->getId(), $page); } }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { $blogArticleRecords = []; for ($i = 0; $i < 10; ++$i) { $blogArticleRecords[] = ['title' => 'Article #' . ($i + 1), 'description' => 'Description of Article #' . ($i + 1), 'content' => 'Content of Article #' . ($i + 1)]; } foreach ($blogArticleRecords as $blogArticleRecord) { $blogArticle = new BlogArticle(); $blogArticle->setTitle($blogArticleRecord['title']); $blogArticle->setDescription($blogArticleRecord['description']); $blogArticle->setContent($blogArticleRecord['content']); $blogArticle->setImageUrl(''); $blogArticle->setPublicationDate(new \DateTime()); $manager->persist($blogArticle); $manager->flush(); $this->referenceRepository->addReference('blog-article-' . $blogArticle->getId(), $blogArticle); } }
/** * {@inheritdoc} */ public function load(ObjectManager $manager) { $blogArticleTagRecords = []; $blogTagIds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; for ($i = 0; $i < 10; ++$i) { $numberOfTags = rand(1, 10); shuffle($blogTagIds); for ($j = 0; $j < $numberOfTags; ++$j) { $blogArticleTagRecords[] = ['article' => $this->referenceRepository->getReference('blog-article-' . ($i + 1)), 'tag' => $this->referenceRepository->getReference('blog-tag-' . $blogTagIds[$j])]; } } foreach ($blogArticleTagRecords as $blogArticleTagRecord) { $blogArticleTag = new BlogArticleTag(); $blogArticleTag->setArticle($blogArticleTagRecord['article']); $blogArticleTag->setTag($blogArticleTagRecord['tag']); $manager->persist($blogArticleTag); } $manager->flush(); }
/** * Returns an object from the manager * * @param string $class * @param string $code * * @throws \Exception * * @return object */ protected function findObject($class, $code) { $reference = $class . '.' . $code; if ($this->referenceRepository && $this->referenceRepository->hasReference($reference)) { return $this->referenceRepository->getReference($reference); } else { $repository = $this->doctrine->getManagerForClass($class)->getRepository($class); if (!$repository instanceof IdentifiableObjectRepositoryInterface) { throw new \Exception(sprintf('Repository "%s" of class "%s" does not implement ' . '"Akeneo\\Component\\StorageUtils\\Repository\\IdentifiableObjectRepositoryInterface".', get_class($repository), $class)); } return $repository->findOneByIdentifier($code); } }
protected function getRealSimpleTournament() { /** @var Board[] $boards */ $boards = array($this->fixtures->getReference('board-0')); /** @var Player[] $players */ $players = array($this->fixtures->getReference('player-0'), $this->fixtures->getReference('player-1'), $this->fixtures->getReference('player-2')); $tournamentSetup = new TournamentSetup(); $tournamentSetup->setSeed(RoundSetupSeed::create([[$players[0]->getId(), $players[1]->getId(), $players[2]->getId()]])); $round1 = RoundSetupAva::createStraight(); $round1->setGameMode(new GameMode(GameMode::FIRST_TO, 3)); $round1->setLegMode(new LegMode(LegMode::SINGLE_OUT_301)); $tournamentSetup->addRound($round1); $tournament = new Tournament(); $tournament->setName('real simple'); $tournament->setSetup($tournamentSetup); $tournament->setBoards($boards); $tournament->setPlayers($players); /** @var \Doctrine\ORM\EntityManager $entityManager */ $entityManager = $this->getContainer()->get('doctrine.orm.default_entity_manager'); $entityManager->persist($tournament); return $tournament; }
/** * Returns an object from the manager * * @param string $class * @param string $code * * @return object */ protected function findObject($class, $code) { $reference = $class . '.' . $code; if ($this->referenceRepository && $this->referenceRepository->hasReference($reference)) { return $this->referenceRepository->getReference($reference); } else { $repository = $this->doctrine->getManagerForClass($class)->getRepository($class); if (!$repository instanceof ReferableEntityRepositoryInterface) { throw new \Exception(sprintf('Repository "%s" of class "%s" is not referable', get_class($repository), $class)); } return $repository->findByReference($code); } }
public function testReferenceMultipleEntries() { $em = $this->getMockSqliteEntityManager(); $referenceRepository = new ReferenceRepository($em); $em->getEventManager()->addEventSubscriber(new ORMReferenceListener($referenceRepository)); $schemaTool = new SchemaTool($em); $schemaTool->createSchema(array($em->getClassMetadata(self::TEST_ENTITY_ROLE))); $role = new TestEntity\Role(); $role->setName('admin'); $em->persist($role); $referenceRepository->addReference('admin', $role); $referenceRepository->addReference('duplicate', $role); $em->flush(); $em->clear(); $this->assertInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $referenceRepository->getReference('admin')); $this->assertInstanceOf('Doctrine\\ORM\\Proxy\\Proxy', $referenceRepository->getReference('duplicate')); }
/** * Check if an object is stored using reference * named by $name * * @param string $name * @see Doctrine\Common\DataFixtures\ReferenceRepository::hasReference * @return boolean */ public function hasReference($name) { return $this->referenceRepository->hasReference($name); }
/** * {@inheritdoc} */ protected function getReference($name) { return $this->referenceRepository->getReference($name); }
public function testGetIdentifierWhenHasNotBeenManagedYetByUnitOfWork() { $role = new Role(); $identitiesExpected = ['id' => 1]; /** @var UnitOfWork | ProphecyInterface $uow */ $uow = $this->prophesize(UnitOfWork::class); $uow->isInIdentityMap($role)->shouldBeCalledTimes(2)->willReturn(true, false); /** @var ClassMetadata $classMetadata */ $classMetadata = $this->prophesize(ClassMetadata::class); $classMetadata->getIdentifierValues($role)->shouldBeCalled()->willReturn($identitiesExpected); /** @var EntityManagerInterface | ProphecyInterface $em */ $em = $this->prophesize(EntityManagerInterface::class); $em->getUnitOfWork()->shouldBeCalled()->willReturn($uow); $em->getClassMetadata(Role::class)->shouldBeCalled()->willReturn($classMetadata); $referenceRepository = new ReferenceRepository($em->reveal()); $referenceRepository->setReference('entity', $role); $identities = $referenceRepository->getIdentities(); $this->assertEquals($identitiesExpected, $identities['entity']); }
/** * @expectedException OutOfBoundsException * @expectedExceptionMessage Reference to: (foo) does not exist */ public function testUndefinedReference() { $em = $this->getMockSqliteEntityManager(); $referenceRepository = new ReferenceRepository($em); $referenceRepository->getReference('foo'); }
public function testUndefinedReference() { $referenceRepository = new ReferenceRepository($this->getMockSqliteEntityManager()); $this->expectException(\OutOfBoundsException::class); $this->expectExceptionMessage('Reference to: (foo) does not exist'); $referenceRepository->getReference('foo'); }