/**
* Migrate data to plugin database from core table
*
* @param EntityManager $em
* @param OutputInterface $output
*
* @return void
*/
public function migrateData($em, $output)
{
$rsm = new ResultSetMapping();
$rsm->addEntityResult('Newscoop\\CommunityTickerBundle\\Entity\\CommunityTickerEvent', 'e');
$rsm->addFieldResult('e', 'id', 'id');
$rsm->addFieldResult('e', 'event', 'event');
$rsm->addFieldResult('e', 'params', 'params');
$rsm->addFieldResult('e', 'created', 'created');
$rsm->addJoinedEntityResult('Newscoop\\Entity\\User', 'u', 'e', 'user');
$rsm->addFieldResult('u', 'Id', 'id');
$query = $em->createNativeQuery('SELECT e.id, e.event, e.params, e.created, u.Id FROM community_ticker_event e ' . 'LEFT JOIN liveuser_users u ON u.id = e.user_id', $rsm);
$events = $query->getArrayResult();
foreach ($events as $key => $event) {
$user = $em->getRepository('Newscoop\\Entity\\User')->findOneBy(array('id' => $event['user']['id']));
$existingEvent = $em->getRepository('Newscoop\\CommunityTickerBundle\\Entity\\CommunityTickerEvent')->findOneBy(array('created' => $event['created'], 'params' => $event['params']));
if (!$existingEvent) {
$newEvent = new CommunityTickerEvent();
$newEvent->setEvent($event['event']);
$newEvent->setParams($event['params'] != '[]' ? json_decode($event['params'], true) : array());
$newEvent->setCreated($event['created']);
$newEvent->setIsActive(true);
if ($user) {
$newEvent->setUser($user);
}
$em->persist($newEvent);
}
}
$em->flush();
$output->writeln('<info>Data migrated to plugin table!</info>');
$output->writeln('<info>Removing old table...</info>');
}
/**
* {@inheritDoc}
*/
public function getOrCreateUser($email, $googleId)
{
if ($this->isConfiguredDomain($email)) {
$user = $this->userFinder->findUserByGoogleSignInData($email, $googleId);
if (!$user instanceof $this->userClass) {
//User not present in database, create new one
$user = new $this->userClass();
$user->setUsername($email);
$user->setEmail($email);
$user->setPlainPassword($googleId . $email . time());
$user->setEnabled(true);
$user->setLocked(false);
$user->setAdminLocale('en');
$user->setPasswordChanged(true);
}
foreach ($this->getAccessLevels($email) as $accessLevel) {
$user->addRole($accessLevel);
}
$user->setGoogleId($googleId);
// Persist
$this->em->persist($user);
$this->em->flush();
}
return isset($user) ? $user : null;
}
public function testReverseTransform()
{
$transformer = $this->createTransformer();
$tag = new Tag("name");
$this->em->persist($tag);
$this->em->flush();
$this->assertSame($tag, $transformer->reverseTransform(1, null));
}
/**
* {@inheritdoc}
*/
public function setUp()
{
$this->em = $this->getEntityManager();
$this->purgeDatabase();
$this->setUpTestData();
$this->em->flush();
$this->client = $this->createAuthenticatedClient();
}
protected function persist(array $entities)
{
foreach ($entities as $entity) {
$this->em->persist($entity);
}
$this->em->flush();
// no clear, because entities managed by the choice field must
// be managed!
}
public function insert(Entity\AvaliadorArea $avaliadorArea)
{
try {
$this->em->persist($avaliadorArea);
$this->em->flush();
} catch (Exception $ex) {
$this->CI->log->write_log('error', $ex->getMessage() . ' - avaliador_area_dao::insert ');
}
}
/**
* Save schema
*
* @param SchemaInterface $schema
*
* @return SchemaInterface
*/
public function save(SchemaInterface $schema)
{
foreach ($schema->getAttributes() as $attribute) {
$attribute->setSchema($schema);
$this->em->persist($attribute);
}
$this->em->persist($schema);
$this->em->flush();
return $schema;
}
/**
* Save template
*
* @param TemplateInterface $template
*
* @return TemplateInterface
*/
public function save(TemplateInterface $template)
{
foreach ($template->getAttributes() as $attribute) {
$attribute->setTemplate($template);
$this->em->persist($attribute);
}
$this->em->persist($template);
$this->em->flush();
return $template;
}
public function createTagCollection()
{
$tags = new ArrayCollection();
$tags->add(new Tag("foo"));
$tags->add(new Tag("bar"));
foreach ($tags as $tag) {
$this->em->persist($tag);
}
$this->em->flush();
$this->em->clear();
return $tags;
}
/**
* Method actually invoked upon dispatching an event "kernel.response"
*
* @param FilterResponseEvent $event
*
* @return void
*/
public function onKernelRequest(GetResponseEvent $event)
{
if (HttpKernelInterface::MASTER_REQUEST !== $event->getRequestType()) {
return;
}
$token = $this->securityContext->getToken();
if ($token instanceof UsernamePasswordToken and $token->isAuthenticated()) {
$user = $token->getUser();
$user->setLastActive(new \DateTime(date('Y-m-d H:i:s', time())));
$this->entityManager->persist($user);
$this->entityManager->flush();
}
}
/**
* method invoked everytime an event is dispatched(guide updates)
* @param EguideEvent $event
*/
public function updateFreeSearchField(EguideEvent $event)
{
$eguide = $event->getEguide();
$keywords = array();
/**
* needs improvement
* @var string
*/
$categories = $eguide->getCategories();
foreach ($categories as $category) {
$categoryName = strtolower($category->getName());
$keywords[] = 'activity:' . $categoryName;
}
$country = strtolower($eguide->getCountry()->getName());
$locations = $eguide->getLocations();
foreach ($locations as $location) {
$address = 'location:' . $location->getAddress();
$keywords[] = $address;
}
$keywords[] = $country;
$keywords = implode(" ", $keywords);
$eguide->setFreeSearch($keywords);
$this->entityManager->persist($eguide);
$this->entityManager->flush();
}
/**
* Duplicate a content item
*
* @param ContentInterface $content
* @param NestedValue $nestedIn
*/
public function duplicate(ContentInterface $content, NestedValue $nestedIn = null)
{
//get valueset to clone
$valueset = $content->getValueSet();
//clone valueset
$duplicatedValueset = clone $valueset;
$this->detachAndPersist($duplicatedValueset);
//duplicate content
$duplicatedContent = clone $content;
$duplicatedContent->setSlug(null);
$duplicatedContent->setValueSet($duplicatedValueset);
if (!is_null($nestedIn)) {
$duplicatedContent->setNestedIn($nestedIn);
}
$this->detachAndPersist($duplicatedContent);
//iterate values, clone each and assign duplicate valueset to it
foreach ($valueset->getValues() as $value) {
//skip empty attributes
if (is_null($value->getId())) {
continue;
}
$duplicatedValue = clone $value;
$duplicatedValue->setValueSet($duplicatedValueset);
$this->detachAndPersist($duplicatedValue);
//if type nested, find content that has nested_in value same as id of value
if ($value instanceof \Opifer\EavBundle\Entity\NestedValue) {
$nestedContents = $this->getRepository()->findby(['nestedIn' => $value->getId()]);
foreach ($nestedContents as $nestedContent) {
$this->duplicate($nestedContent, $duplicatedValue);
}
}
}
$this->em->flush();
return $duplicatedContent->getId();
}
public function testPaginator()
{
$reader = $this->getAuditReader();
$query = $reader->paginateRevisionsQuery();
$paginatorAdapter = new \ZF2EntityAudit\Paginator\DbalAdapter($query);
$paginator = new \Zend\Paginator\Paginator($paginatorAdapter);
for ($i = 0; $i < 20; $i++) {
$writer = new Writer("tawfek" . rand());
$article = new Article("title", "text", $writer);
$this->em->persist($writer);
$this->em->persist($article);
}
$this->em->flush();
$this->assertEquals($reader->countRevisions(), "1");
$this->assertEquals($paginator->count(), "1");
for ($i = 0; $i < 20; $i++) {
$writer = new Writer("tawfek" . rand());
$article = new Article("title", "text", $writer);
$this->em->persist($writer);
$this->em->persist($article);
$this->em->flush();
}
// its 21 because (20 flushes + 1 flush as bluk flush in line 330 )
$this->assertEquals($reader->countRevisions(), "21");
$this->assertEquals($paginator->getAdapter()->count(), "21");
$this->assertEquals(count($paginator->getAdapter()->getItems(1, 12)), "12");
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(__DIR__ . '/_files');
$config->setProxyNamespace('DoctrineExtensions\\LargeCollections\\Proxies');
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
#$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
$this->em = \Doctrine\ORM\EntityManager::create($conn, $config);
$schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em);
$schemaTool->createSchema(array($this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Article'), $this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Tag'), $this->em->getClassMetadata('DoctrineExtensions\\LargeCollections\\Comment')));
$article = new Article();
$tag1 = new Tag();
$tag2 = new Tag();
$comment1 = new Comment();
$comment2 = new Comment();
$article->addComment($comment1);
$article->addComment($comment2);
$article->addTag($tag1);
$article->addTag($tag2);
$this->em->persist($article);
$this->em->persist($tag1);
$this->em->persist($tag2);
$this->em->persist($comment1);
$this->em->persist($comment2);
$this->em->flush();
$this->articleId = $article->id();
$this->em->clear();
}
/**
* Saves a message
*
* @param MessageInterface $message
* @param Boolean $andFlush Whether to flush the changes (default true)
*/
public function saveMessage(MessageInterface $message, $andFlush = true)
{
$this->denormalize($message);
$this->em->persist($message);
if ($andFlush) {
$this->em->flush();
}
}
/**
* Clears old webcode
*
* @param EntityManager $em Entity Manager
* @param string $articleNumber Article
*
* @return void
*/
private function clearWebcode($em, $articleNumber, $articleLanguage)
{
$webcode = $em->getRepository('Newscoop\\Entity\\Webcode')->createQueryBuilder('w')->leftJoin('w.article', 'a')->where('a.number = :number')->andWhere('a.language = :language')->setParameter('number', $articleNumber)->setParameter('language', $articleLanguage)->getQuery()->getOneOrNullResult();
if ($webcode) {
$em->remove($webcode);
$em->flush();
}
}
/**
* Test helper to reset testing data
*
* @return void
*/
public function testHelperReset()
{
$test_transaction = $this->testHelperGet();
if (!is_null($test_transaction)) {
$this->em->remove($test_transaction);
$this->em->flush();
}
}
/**
* Delete controller
*
* @param Request $request
* @param Response $response
* @param array $args
*
* @return Response
*/
public function delete(Request $request, Response $response, array $args)
{
$entity = $this->em->getRepository($this->entityClass)->find($args['id']);
if ($entity) {
$this->em->remove($entity);
$this->em->flush();
}
return new RedirectResponse($this->route);
}
/**
* Make sure activities cannot have the same activityId per spec
*/
public function testActivityUniqueness()
{
$activity = $this->activityService->denormalize(json_encode($this->getActivityData()));
$this->em->persist($activity);
$this->em->flush();
$newActivity = clone $activity;
$constraintViolationList = $this->validator->validate($newActivity);
$this->assertEquals($constraintViolationList->count(), 1);
$this->assertEquals($constraintViolationList->get(0)->getInvalidValue(), $activity->getActivityId());
}
/**
* @depends testReverseTransformNewKnownEntity
*/
public function testReverseTransformNewUnknownEntity()
{
$transformer = $this->createTransformer();
$tags = $this->createTagCollection();
$tags = $transformer->reverseTransform("foo, bar, baz", $tags);
$this->assertEquals(3, count($tags));
$this->em->flush();
$this->assertSame($this->em, $transformer->getOption('em'));
$this->assertEquals(1, count($this->em->getRepository('Symfony\\Bundle\\DoctrineBundle\\Tests\\Form\\ValueTransformer\\Tag')->findAll()));
}
/**
/**
* Create comment
*
* @param Request $request
* @param string $slug
* @throws NotFoundHttpException
* @return array
*
* @Route("/{slug}/create-comment")
* @Method("POST")
* @Template("CoreBundle:Post:show.html.twig")
*/
public function createCommentAction(Request $request, $slug)
{
// exit(\Doctrine\Common\Util\Debug::dump($slug));
// var_dump($request); exit;
$post = $this->em->getRepository('ModelBundle:Post')->findOneBy(array('slug' => $slug));
if ($post === null) {
throw createNotFoundException('Post Was Not Found');
}
$comment = new Comment();
$comment->setPost($post);
$form = $this->createForm(new CommentType(), $comment);
$form->handleRequest($request);
if ($form->isValid()) {
$this->em->persist($comment);
$this->em->flush();
$this->get('session')->getFlashBag()->add('success', 'Your comment was submitted successfully');
return $this->redirect($this->generateUrl('blog_core_post_show', array('slug' => $post->getSlug())));
}
return array('post' => $post, 'form' => $form->createView());
}
/**
* Test helper to reset testing data
*
* @return void
*/
public function testHelperReset()
{
$test_SubProject = $this->testHelperGet();
if (!is_null($test_SubProject)) {
$this->em->remove($test_SubProject);
$this->em->flush();
}
$test_SubProject_2 = $this->repo->findOneByName('TestDelprosjekt2');
if (!is_null($test_SubProject_2)) {
$this->em->remove($test_SubProject_2);
$this->em->flush();
}
}
/**
* Test helper to reset testing data
*
* @return void
*/
public function testHelperReset()
{
$test_budget = $this->testHelperGet();
if (!is_null($test_budget)) {
$this->em->remove($test_budget);
$this->em->flush();
}
$test_budget_2 = $this->repo->findOneByName('TestBudsjett2');
if (!is_null($test_budget_2)) {
$this->em->remove($test_budget_2);
$this->em->flush();
}
}
protected function createArticleFixtures()
{
$articles = new ArrayCollection();
$articles->add(new Article('foo', 'toto'));
$articles->add(new Article('bar', 'toto'));
$articles->add(new Article('bar', 'titi'));
$articles->add(new Article('foo', 'titi'));
$articles->add(new Article('barfoo', 'tata'));
foreach ($articles as $article) {
$this->em->persist($article);
}
$this->em->flush();
$this->em->clear();
return $articles;
}
public function testFindCurrentRevision()
{
$user = new UserAudit('Broncha');
$this->em->persist($user);
$this->em->flush();
$user->setName("Rajesh");
$this->em->flush();
$reader = $this->auditManager->createAuditReader($this->em);
$revision = $reader->getCurrentRevision(get_class($user), $user->getId());
$this->assertEquals(2, $revision);
$user->setName("David");
$this->em->flush();
$revision = $reader->getCurrentRevision(get_class($user), $user->getId());
$this->assertEquals(3, $revision);
}
/**
* Get a marketProduct record for an incoming product, if it does not exist, create it
*
* @param IncomingProduct $product
*
* @return MarketProduct
*
* @throws \Exception
*/
protected function getMarketProduct(IncomingProduct $product)
{
$market = $this->getMarket();
$marketProduct = $this->entityManager->getRepository('AppBundle:MarketProduct')->findOneBy(['market' => $market, 'foreignId' => $product->getMarketId()]);
if ($marketProduct) {
return $marketProduct;
}
$variant = $this->getProductVariantRecord($product);
$marketProduct = new MarketProduct();
$marketProduct->setMarket($market);
$marketProduct->setForeignId($product->getMarketId());
$marketProduct->setProductVariantSku($variant);
$this->entityManager->persist($marketProduct);
$this->entityManager->flush();
return $marketProduct;
}
/**
* @param integer $ownerId
* @param integer $rootVersion
*/
public function discardAll($ownerId)
{
$owner = $this->find($ownerId);
if (!$owner instanceof BlockOwnerInterface) {
throw new \Exception('Discard all changes is only possible on Block owners');
}
$this->killLoggableListener();
$this->killSoftDeletableListener();
$this->em->getRepository('OpiferContentBundle:BlockLogEntry')->discardAll($ownerId);
if ($this->em->getFilters()->isEnabled('softdeleteable')) {
$this->em->getFilters()->disable('softdeleteable');
}
$stubs = $this->getRepository()->findBy(['owner' => $owner, 'version' => 0]);
foreach ($stubs as $stub) {
$this->em->remove($stub);
}
$this->em->flush();
}
public function testGlobalIgnoreColumns()
{
$user = new UserAudit("welante");
$article = new ArticleAudit("testcolumn", "yadda!", $user, 'text');
$this->em->persist($user);
$this->em->persist($article);
$this->em->flush();
$article->setText("testcolumn2");
$this->em->persist($article);
$this->em->flush();
$reader = $this->auditManager->createAuditReader($this->em);
$revision = $reader->getCurrentRevision(get_class($article), $article->getId());
$this->assertEquals(2, $revision);
$article->setIgnoreme("textnew");
$this->em->persist($article);
$this->em->flush();
$revision = $reader->getCurrentRevision(get_class($article), $article->getId());
$this->assertEquals(2, $revision);
}
/**
* Save attribute.
*
* @param Form $form
*
* @return Form
*/
public function save(Form $form)
{
$this->em->persist($form);
$this->em->flush();
return $form;
}
/**
* Deletes a thread
*
* @param ThreadInterface $thread the thread to delete
*/
public function deleteThread(ThreadInterface $thread)
{
$this->em->remove($thread);
$this->em->flush();
}
