/** * @param PostFlushEventArgs $args */ public function postFlush(PostFlushEventArgs $args) { if ($this->isInProgress) { return; } $this->initializeFromEventArgs($args); if (count($this->queued) > 0) { $toOutDate = []; foreach ($this->queued as $customerIdentity => $groupedByEntityUpdates) { foreach ($groupedByEntityUpdates as $data) { /** @var Account $account */ $account = is_object($data['account']) ? $data['account'] : $this->em->getReference('OroCRMAccountBundle:Account', $data['account']); /** @var Channel $channel */ $channel = is_object($data['channel']) ? $data['channel'] : $this->em->getReference('OroCRMChannelBundle:Channel', $data['channel']); $entity = $this->createHistoryEntry($customerIdentity, $account, $channel); $toOutDate[] = [$account, $channel, $entity]; $this->em->persist($entity); } } $this->isInProgress = true; $this->em->flush(); foreach (array_chunk($toOutDate, self::MAX_UPDATE_CHUNK_SIZE) as $chunks) { $this->lifetimeRepo->massStatusUpdate($chunks); } $this->queued = []; $this->isInProgress = false; } }
/** * @param Todo $entity */ public function run(EntityInterface $entity) { assert($entity instanceof Todo); $entity->setStatus(new TodoStatus()); $this->repository->add($entity); $this->entityManager->flush(); }
protected function setUp() { if (!class_exists('Symfony\\Component\\Form\\Form')) { $this->markTestSkipped('The "Form" component is not available'); } if (!class_exists('Doctrine\\DBAL\\Platforms\\MySqlPlatform')) { $this->markTestSkipped('Doctrine DBAL is not available.'); } if (!class_exists('Doctrine\\Common\\Version')) { $this->markTestSkipped('Doctrine Common is not available.'); } if (!class_exists('Doctrine\\ORM\\EntityManager')) { $this->markTestSkipped('Doctrine ORM is not available.'); } $this->em = DoctrineOrmTestCase::createTestEntityManager(); parent::setUp(); $schemaTool = new SchemaTool($this->em); $classes = array($this->em->getClassMetadata(self::ENTITY_CLASS)); try { $schemaTool->dropSchema($classes); } catch (\Exception $e) { } try { $schemaTool->createSchema($classes); } catch (\Exception $e) { } $ids = range(1, 300); foreach ($ids as $id) { $name = 65 + chr($id % 57); $this->em->persist(new SingleIdentEntity($id, $name)); } $this->em->flush(); }
public function down(Schema $schema) { $lookingFor = new Profile\LookingFor(); $lookingFor->setName('Intimate'); $this->em->persist($lookingFor); $this->em->flush(); }
/** * Flush on kernel terminate. */ public function onKernelTerminate() { if ($this->em->isOpen()) { $this->em->flush(); // That was not so hard... And you need a bundle to do that! Poor guy... } }
/** * Update the user "lastActivity" on each request * * @param FilterControllerEvent $event */ public function onCoreController(FilterControllerEvent $event) { // Here we are checking that the current request is a "MASTER_REQUEST", // and ignore any // subrequest in the process (for example when // doing a render() in a twig template) if ($event->getRequestType() !== HttpKernel::MASTER_REQUEST) { return; } // We are checking a token authentification is available before using // the User if ($this->securityContext->getToken()) { $user = $this->securityContext->getToken()->getUser(); // We are using a delay during wich the user will be considered as // still active, in order to // avoid too much UPDATE in the // database // $delay = new \DateTime (); // $delay->setTimestamp (strtotime ('2 minutes ago')); // We are checking the Admin class in order to be certain we can // call "getLastActivity". // && $user->getLastActivity() < $delay) { if ($user instanceof User) { $user->isActiveNow(); $this->em->persist($user); $this->em->flush(); } } }
public function schedule() { $licenseRepo = $this->em->getRepository('AppBundle:License'); $drillSchemaEventsRepo = $this->em->getRepository('AppBundle:DrillSchemaEvent'); $licensesWithoutSchema = $licenseRepo->findWithoutRegisteredSchema(); foreach ($licensesWithoutSchema as $license) { $drillSchemaEvents = $drillSchemaEventsRepo->findByAddonKey($license->getAddonKey()); if (empty($drillSchemaEvents)) { continue; } $drillRegisteredSchema = new DrillRegisteredSchema(); $drillRegisteredSchema->setLicenseId($license->getLicenseId()); $drillRegisteredSchema->setAddonKey($license->getAddonKey()); $this->em->persist($drillRegisteredSchema); foreach ($drillSchemaEvents as $drillSchemaEvent) { $sendDate = $this->calculateSendDate($drillSchemaEvent, $license); $today = new \DateTime(); // prevent creating events from past if ($sendDate < $today->modify('-2 days')) { continue; } $drillRegisteredEvent = new DrillRegisteredEvent(); $drillRegisteredEvent->setDrillRegisteredSchema($drillRegisteredSchema); $drillRegisteredEvent->setDrillSchemaEvent($drillSchemaEvent); // Calculate $drillRegisteredEvent->setSendDate($sendDate); $drillRegisteredEvent->setStatus('new'); $this->em->persist($drillRegisteredEvent); } } $this->em->flush(); }
/** * @param ProviderLocation $providerLocation * @param bool $withFlush */ public function save(ProviderLocation $providerLocation, $withFlush = true) { $this->entityManager->persist($providerLocation); if ($withFlush) { $this->entityManager->flush(); } }
public function get($name) { $uppername = strtoupper($name); /* //create unique key for kind and uppercased name $key = md5('kind.' . $uppername); //cache has value return this one $cached = Cache::get($key); if ($cached) { return $cached; }*/ //find or create in store $kind = $this->em->getRepository($this->class)->findOneBy(['name' => $uppername]); if (!$kind) { $kind = new Kind(new Name($uppername)); $this->em->persist($kind); $this->em->flush(); } /* //cache it for next request Cache::forever($key, $kind); return Cache::get($key); */ return $kind; }
public function onKernelTerminate(PostResponseEvent $event) { /** @var Request $request */ $request = $event->getRequest(); if (!$this->isEnable || !$this->isLoggableRequest($request)) { return; } try { /** @var Response $response */ $response = $event->getResponse(); $route = $request->get('_route'); $content = $this->cleanSensitiveContent($route, $request->getContent()); $token = $this->tokenStorage->getToken(); $user = !is_null($token) ? $token->getUser() : null; $logRequest = new LogRequest(); $logRequest->setRoute($route)->setPath($request->getPathInfo())->setMethod($request->getMethod())->setQuery(urldecode($request->getQueryString()))->setContent($content)->setStatus($response->getStatusCode())->setIp($request->getClientIp())->setUser(!is_string($user) ? $user : null); if ($this->logResponse($response)) { $logRequest->setResponse($response->getContent()); } $this->em->persist($logRequest); $this->em->flush(); } catch (\Exception $e) { $this->logger->error(sprintf("LogRequest couldn't be persist : %s", $e->getMessage())); } }
public function testRemovePage() { $page = new Page(); $page->setTitle('Test')->setContent('<p>test</p>')->setCurrentSlugUrl('/remove'); $this->entityManager->persist($page); $childPage1 = new Page(); $childPage1->setTitle('Test child Page 1')->setContent('<p>test child page</p>')->setCurrentSlugUrl('/child1'); $this->entityManager->persist($childPage1); $childPage2 = new Page(); $childPage2->setTitle('Test child Page 2')->setContent('<p>test child page</p>')->setCurrentSlugUrl('/child2'); $this->entityManager->persist($childPage2); $page->addChildPage($childPage1); $page->addChildPage($childPage2); $this->entityManager->flush($page); $pageSlugId = $page->getCurrentSlug()->getId(); $childPage1SlugId = $childPage1->getCurrentSlug()->getId(); $childPage2SlugId = $childPage2->getCurrentSlug()->getId(); $this->entityManager->remove($page); $this->entityManager->flush(); // make sure data updated correctly $this->entityManager->clear(); $this->assertNull($this->entityManager->find('OroB2BRedirectBundle:Slug', $pageSlugId)); $this->assertNull($this->entityManager->find('OroB2BRedirectBundle:Slug', $childPage1SlugId)); $this->assertNull($this->entityManager->find('OroB2BRedirectBundle:Slug', $childPage2SlugId)); }
/** * Process onReslonse event, updates user history information * * @param FilterResponseEvent $event * @return bool|void */ public function onResponse(FilterResponseEvent $event) { if (HttpKernel::MASTER_REQUEST != $event->getRequestType()) { // Do not do anything return; } $request = $event->getRequest(); $response = $event->getResponse(); // do not process requests other than in html format // with 200 OK status using GET method and not _internal and _wdt if (!$this->matchRequest($response, $request)) { return false; } $postArray = ['url' => $request->getRequestUri(), 'user' => $this->user]; /** @var $historyItem NavigationHistoryItem */ $historyItem = $this->em->getRepository('Oro\\Bundle\\NavigationBundle\\Entity\\NavigationHistoryItem')->findOneBy($postArray); if (!$historyItem) { /** @var $historyItem \Oro\Bundle\NavigationBundle\Entity\NavigationItemInterface */ $historyItem = $this->navItemFactory->createItem(NavigationHistoryItem::NAVIGATION_HISTORY_ITEM_TYPE, $postArray); } $historyItem->setTitle($this->titleService->getSerialized()); // force update $historyItem->doUpdate(); $this->em->persist($historyItem); $this->em->flush($historyItem); return true; }
/** * Finish processed batch */ protected function finishBatch() { $this->entityManager->flush(); if ($this->entityManager->getConnection()->getTransactionNestingLevel() == 1) { $this->entityManager->clear(); } }
/** * Duplicate Jam entities * * For details see * {@link http://stackoverflow.com/questions/9071094/how-to-re-save-the-entity-as-another-row-in-doctrine-2} * * @param Jam $entity * @param integer $count */ public function duplicate(Jam $entity, $count = 0) { for ($i = 0; $i < $count; $i++) { $this->em->persist($this->cloneService->cloneObject($entity)); } $this->em->flush(); }
/** * Callback method, that is called once form is successfully submitted, without validation errors. * * @param Form $form * @param Nette\Utils\ArrayHash $values */ public function formSucceeded(Form $form, $values) { if (!($user = $this->userRepository->findOneBy(['email' => $values->email]))) { $form['email']->addError("User with given email doesn't exist"); return; } // this is not a very secure way of getting new password // but it's the same way the symfony app is doing it... $newPassword = $user->generateRandomPassword(); $this->em->flush(); try { $message = new Nette\Mail\Message(); $message->setSubject('Notejam password'); $message->setFrom('*****@*****.**'); $message->addTo($user->getEmail()); // !!! Never send passwords through email !!! // This is only for demonstration purposes of Notejam. // Ideally, you can create a unique link where user can change his password // himself for limited amount of time, and then send the link. $message->setBody("Your new password is {$newPassword}"); $this->mailer->send($message); } catch (Nette\Mail\SendException $e) { Debugger::log($e, 'email'); $form->addError('Could not send email with new password'); } $this->onSuccess($this); }
/** * Publishes a gif and posts a link on social networks * @param Gif $gif * @return bool */ public function publish(Gif $gif) { if (!$gif) { return false; } if (!$gif->getGifStatus() == GifState::ACCEPTED) { return false; } $gif->setPublishDate(new DateTime()); $gif->setGifStatus(GifState::PUBLISHED); $gif->generateUrlReadyPermalink(); // Check if permalink is unique /** @var GifRepository $gifsRepo */ $gifsRepo = $this->em->getRepository('LjdsBundle:Gif'); $permalink = $gif->getPermalink(); $i = 1; while (!empty($gifsRepo->findBy(['permalink' => $gif->getPermalink(), 'gifStatus' => GifState::PUBLISHED]))) { // Generate a new permalink $gif->setPermalink($permalink . $i); $i++; } $this->em->flush(); if ($this->facebookAutopost) { $this->facebookService->postGif($gif); } if ($this->twitterAutopost) { $this->twitterService->postGif($gif); } return true; }
/** * Run all new tasks * * @throws \InvalidArgumentException * @return void */ public function runJobs() { $cronRepo = $this->entityManager->getRepository('KingdomHallTaskBundle:Task'); $jobs = $cronRepo->getNewJobs(); foreach ($jobs as $job) { $task = $job->getTask(); if (!array_key_exists($task, $this->taskServices)) { throw new \InvalidArgumentException($task . ' service not found. Available task services : ' . implode(', ', array_keys($this->taskServices))); } $service = $this->taskServices[$task]; $parameters = json_decode($job->getParameters()); $job->setStatus(Task::TASK_STATUS_PENDING); $this->entityManager->persist($job); $this->entityManager->flush(); try { $service->process($job->getId(), $parameters); } catch (\Exception $e) { $job->setStatus(Task::TASK_STATUS_ERROR); $job->setErrorMessage($e->getMessage()); $this->entityManager->persist($job); $this->entityManager->flush(); return; } $job->setStatus(Task::TASK_STATUS_SUCCESS); $this->entityManager->persist($job); $this->entityManager->flush(); } // Purge old jobs $cronRepo->purge(); }
/** * @param Tournament $tournament * @return void */ public function makeDrawForNextRound(Tournament $tournament) { $nextRound = $tournament->getCurrentRound() + 1; $this->makeDraw($tournament, $nextRound); $tournament->setCurrentRound($nextRound); $this->manager->flush($tournament); }
/** * @param Organization $organization * @param bool $flush */ public function updateOrganization(Organization $organization, $flush = true) { $this->em->persist($organization); if ($flush) { $this->em->flush(); } }
/** * @param int $id * @param string $state */ protected function saveState($id, $state) { $notification = $this->getById($id); $notification->setState($state); $this->entityManager->persist($notification); $this->entityManager->flush(); }
/** * Imports units. * * @return array An array with the keys "skipped" and "imported" which contain the number of units skipped and imported * @throws \Exception If an error occured */ public function importUnits() { $path = $this->kernel->locateResource(self::UNIT_PATH . self::UNIT_DATA); $yaml = new Parser(); $data = $yaml->parse(file_get_contents($path)); $count = 0; $skipped = 0; foreach ($data as $unitName => $unitData) { $unit = $this->getUnit($unitName); if ($unit === null) { $unit = new Unit(); $unit->setName($unitName); $unit->setSymbol($unitData["symbol"]); if (array_key_exists("prefixes", $unitData)) { if (!is_array($unitData["prefixes"])) { throw new \Exception($unitName . " doesn't contain a prefix list, or the prefix list is not an array."); } foreach ($unitData["prefixes"] as $name) { $prefix = $this->getSiPrefix($name); if ($prefix === null) { throw new \Exception("Unable to find SI Prefix " . $name); } $unit->getPrefixes()->add($prefix); } } $this->entityManager->persist($unit); $this->entityManager->flush(); $count++; } else { $skipped++; } } return array("imported" => $count, "skipped" => $skipped); }
/** * @param object $object * @param string $flush */ public function delete($object, $flush = true) { $this->entityManager->remove($object); if ($flush) { $this->entityManager->flush(); } }
public function sendAction(Request $request) { $message = $this->messageBuilder->getMessage($request->request->all()); $this->eventDispatcher->dispatch('slack.message_received', new MessageEvent($message)); $this->entityManager->flush(); return new JsonResponse([]); }
/** * @param $entity * @param bool $andFlush */ public function delete($entity, $andFlush = true) { $this->em->remove($entity); if ($andFlush) { $this->em->flush(); } }
protected function createImage(LoaderResult $loaderResult, $mimeType) : ImageInterface { $image = ($image = new Image())->setPath($loaderResult->getPath())->setSize($loaderResult->getSize())->setMimeType($mimeType)->setUploadedAt(new \DateTime()); $this->em->persist($image); $this->em->flush($image); return $image; }
/** * Make sure the menu objects exist in the database for each locale. */ public function makeSureMenusExist() { $locales = array_unique($this->getLocales()); $required = array(); foreach ($this->menuNames as $name) { $required[$name] = $locales; } $menuObjects = $this->em->getRepository('KunstmaanMenuBundle:Menu')->findAll(); foreach ($menuObjects as $menu) { if (array_key_exists($menu->getName(), $required)) { $index = array_search($menu->getLocale(), $required[$menu->getName()]); if ($index !== false) { unset($required[$menu->getName()][$index]); } } } foreach ($required as $name => $locales) { foreach ($locales as $locale) { $menu = new Menu(); $menu->setName($name); $menu->setLocale($locale); $this->em->persist($menu); } } $this->em->flush(); }
public function clearCustomerShoppingCarts() { $customer = $this->getCustomer(); $customer->setSessionId(new ArrayCollection()); $this->entityManager->persist($customer); $this->entityManager->flush(); }
/** * onAuthenticationSuccess * * @author Joe Sexton <*****@*****.**> * @param InteractiveLoginEvent $event */ public function onAuthenticationSuccess(InteractiveLoginEvent $event) { $user = $this->getUser(); $user->setLoginAttempts(0); $this->em->persist($user); $this->em->flush(); }
protected function setUpOperators() { $this->op1 = $this->createSimpleOperator(DataTypes::NUMBER_TYPE, 'input', '>', 'groesser'); $this->op2 = $this->createSimpleOperator(DataTypes::NUMBER_TYPE, 'input', '<', 'kleiner'); $this->op3 = $this->createOperator(DataTypes::DATETIME_TYPE, 'datepicker', '<', 'kleiner'); $this->em->flush(); }
/** * @param $entity */ public function removeEntity($entity) { $this->em->remove($entity); $this->em->flush(); $isFound = $this->em->getRepository(get_class($entity))->findOneBy(['id' => $entity->getId()]); $this->assertNull($isFound); }