/** * @param FileUpload $file * @return Image * @throws NotImageUploadedException * @throws FileSizeException * @throws DBALException * @throws InvalidStateException */ public function processImage(FileUpload $file) { if (!$file->isImage()) { throw new NotImageUploadedException(); } if (\filesize($file->getTemporaryFile()) > Image::MAX_FILE_SIZE) { throw new FileSizeException(); } try { $this->em->beginTransaction(); $image = new Image($file); $this->em->persist($image)->flush(); $file->move($this->composeImageLocation($image)); $this->em->commit(); } catch (InvalidStateException $is) { $this->em->rollback(); $this->em->close(); $this->logger->addError('Error occurs while moving temp. image file to new location.'); throw $is; } catch (DBALException $e) { $this->em->rollback(); $this->em->close(); $this->logger->addError('Image error'); // todo err message throw $e; } return $image; }
/** * @param SentMessage $message * @param array $recipients * @return ReceivedMessage[] * @throws \Exception */ public function sendMessage(SentMessage $message, array $recipients) { $receivedMessages = []; try { $this->em->beginTransaction(); $this->em->persist($message); foreach ($recipients as $recipient) { if (!$recipient instanceof User) { throw new InvalidArgumentException('Argument $recipients can only contains instances of ' . User::class); } $m = $receivedMessages[$recipient->getId()] = new ReceivedMessage($message, $recipient); $this->em->persist($m); //if (count($receivedMessages) % 5 === 0) { // todo // $this->em->flush(); // $this->em->clear(); //} } $this->em->flush(); $this->em->commit(); } catch (\Exception $e) { $this->em->rollback(); $this->em->close(); $this->onError('Message sending failed.', $e, self::class); throw $e; } return $receivedMessages; }
/** * @param Url $oldUrl * @param Url $newUrl * @return void * @throws \Exception */ public function linkUrls(Url $oldUrl, Url $newUrl) { if ($oldUrl->getId() === null or $newUrl->getId() === null) { throw new UrlNotPersistedException(); } try { $this->em->beginTransaction(); $alreadyRedirectedUrls = $this->findByActualUrl($oldUrl->getId()); /** @var Url $url */ foreach ($alreadyRedirectedUrls as $url) { $url->setRedirectTo($newUrl); $this->em->persist($url); $this->cache->clean([Cache::TAGS => [$url->getCacheKey()]]); } $oldUrl->setRedirectTo($newUrl); $this->em->persist($oldUrl); $this->cache->clean([Cache::TAGS => [$oldUrl->getCacheKey()]]); $this->em->flush(); $this->em->commit(); } catch (\Exception $e) { $this->em->rollback(); $this->em->close(); throw $e; } }
/** * @param array $values * @return Comment * @throws ActionFailedException */ public function save(array $values) { $numberOfComments = $this->getNumberOfComments($values['page']); $repliesReferences = $this->findRepliesReferences($values['text']); try { $this->em->beginTransaction(); // no replies references found if (empty($repliesReferences)) { $comment = new Comment($values['author'], $this->texy->process($values['text']), $values['page'], $numberOfComments + 1, $this->request->getRemoteAddress()); $this->em->persist($comment)->flush(); $this->em->commit(); return $comment; } $commentsToReply = $this->findCommentsToReply($values['page'], $repliesReferences); $values['text'] = $this->replaceReplyReferencesByAuthors($values['text'], $commentsToReply); $comment = new Comment($values['author'], $this->texy->process($values['text']), $values['page'], $numberOfComments + 1); $this->em->persist($comment); /** @var Comment $comment */ foreach ($commentsToReply as $commentToReply) { $commentToReply->addReaction($comment); $this->em->persist($commentToReply); } $this->em->flush(); $this->em->commit(); } catch (\Exception $e) { $this->em->rollback(); $this->em->close(); throw new ActionFailedException(); } return $comment; }
/** * @param User $user * @param array $albums */ public function assignAlbums(User $user, array $albums) { $user->albums->clear(); $user->setAlbums($albums); $this->em->persist($user); $this->em->flush(); }
public function save($entity, $immediately = true) { $this->em->persist($entity); if ($immediately) { $this->em->flush(); } }
/** * @param $entity1 * @param $entity2 */ private function switchEntities($entity1, $entity2) { $x = $entity1->priority; $entity1->priority = $entity2->priority; $entity2->priority = $x; $this->entityManager->persist($entity1, $entity2); $this->entityManager->flush(); }
/** * @param Privilege $privilege * @param Role $role * @return $this */ public function addDefinition(Privilege $privilege, Role $role) { $accessDefinition = new AccessDefinition($this->resource, $privilege); $this->em->persist($accessDefinition); $permission = new Permission($role, $this->resource, $privilege); $this->em->persist($permission); return $this; }
private function logDb($message, $status = NULL, $consumerTitle = NULL) { $log = new RmqLogConsumer(); $log->consumerTitle = $consumerTitle; $log->message = $message; $log->status = $status; $this->em->persist($log); $this->em->flush(); }
public function addGenre(string $name) { if ($this->genreExists($name)) { return; } $genre = new Genre($name); $this->entityManager->persist($genre); $this->entityManager->flush($genre); }
/** * @param string $searchString * @return Search */ public function saveSearch($searchString) { if ($search = $this->search(Strings::webalize($searchString))) { return $search; } $search = new Search($searchString); $this->entityManager->persist($search); $this->entityManager->flush($search); return $search; }
/** * @param User $user * @return User * @throws \Exception */ public function saveUser(User $user) { try { $this->em->persist($user)->flush(); return $user; } catch (\Exception $e) { $this->onError(sprintf('Saving of user "%s" #id(%s) failed', $user->username, $user->getId()), $e, self::class); throw $e; } }
/** * @param $albumId */ public function delete($albumId) { /** * @var Album $album */ $album = $this->albumDao->find($albumId); $album->delete(); $this->em->persist($album); $this->em->flush(); }
/** * @param Listing $listing * @return Listing * @throws \Exception */ public function saveListing(Listing $listing) { try { $this->em->persist($listing)->flush(); return $listing; } catch (\Exception $e) { $this->onCritical('Saving of Listing failed. [saveListing]', $e, self::class); throw $e; } }
public function update($entityClass, array $items) { $position = 1; foreach ($items as $id) { $entity = $this->em->find($entityClass, $id); $entity->setPosition($position * 10); $this->em->persist($entity); $position++; } $this->em->flush(); }
/** * @param Entity\Event $event */ public function save(Entity\Event $event) { foreach ($event->performances as $performance) { foreach ($performance->children as $child) { $this->em->persist($child); } $this->em->persist($performance); } $this->em->persist($event); $this->em->flush(); }
/** * Save entity into DB * * @param BaseEntity $baseEntity * @return BaseEntity * @throws \Exception */ protected function saveEntity(BaseEntity $baseEntity) { $isPersisted = UnitOfWork::STATE_MANAGED === $this->entityManager->getUnitOfWork()->getEntityState($baseEntity); if ($isPersisted) { $this->entityManager->merge($baseEntity); } else { $this->entityManager->persist($baseEntity); } $this->entityManager->flush(); return $baseEntity; }
/** * @param FileEntityInterface $entity */ public function removeFile(FileEntityInterface $entity) { --$entity->joints; if ($entity->joints === 0) { $this->em->remove($entity); $this->em->flush(); $this->unlinkFile($this->uploadDir . '/' . $entity->year . '/' . $entity->month . '/' . $entity->name . '.' . $entity->extension); } else { $this->em->persist($entity); $this->em->flush(); } }
private function generateAndPersistNewAddresses(int $count) { $qb = $this->entityManager->createQueryBuilder(); $qb->select('MAX(address.bip32index)')->from(Address::getClassName(), 'address'); $index = (int) $qb->getQuery()->getSingleScalarResult(); for ($i = 0; $i < $count; $i++) { list($address, $index) = $this->generateNewAddress($index); $addressEntity = new Address($address, $index); $this->entityManager->persist($addressEntity); } $this->entityManager->flush(); file_put_contents($this->newAddressesFile, true); }
/** * @param string $entityName * @param int $id * @return mixed * @throws \Exception */ public function findOrCreateEntity($entityName, $id) { if ($id === NULL) { $entity = new $entityName(); $this->em->persist($entity); return $entity; } $entity = $this->em->getRepository($entityName)->find($id); if ($entity === NULL) { throw new \Exception('Entity was not fount.'); } return $entity; }
/** * @param Nette\Utils\ArrayHash $values * @return boolean Vytvoreni nove rubriky problehlo uspesne? */ protected function newTag($values) { $result = TRUE; try { $newTag = new \App\Model\Entities\Tag($values->title); //pridani nove rubriky a ulozeni zmen $this->em->persist($newTag); $this->em->flush(); } catch (\Exception $e) { \Tracy\Debugger::log($e, \Tracy\Debugger::INFO); $result = FALSE; } return $result; }
/** * @param ListingItem $listingItem * @return ListingItem * @throws ListingItemDayAlreadyExistsException * @throws \Exception */ public function saveListingItem(ListingItem $listingItem) { try { $this->em->persist($listingItem)->flush(); } catch (UniqueConstraintViolationException $u) { $this->em->close(); throw new ListingItemDayAlreadyExistsException(); } catch (\Exception $e) { $this->em->close(); $this->onCritical('Listing item saving of Listing #id(' . $listingItem->getListing()->getId() . ') failed.', $e, self::class); throw $e; } return $listingItem; }
/** * @param Listing $baseListing * @param Listing $listingToMerge * @param array $selectedCollisionItems * @param User $ownerOfOutputListing * @return Listing * @throws NoCollisionListingItemSelectedException * @throws \Exception */ public function mergeListings(Listing $baseListing, Listing $listingToMerge, array $selectedCollisionItems = [], User $ownerOfOutputListing) { if (!$this->haveListingsSamePeriod($baseListing, $listingToMerge)) { throw new RuntimeException('Given Listings must have same Period(Year and Month).'); } try { $this->em->beginTransaction(); $items = $this->itemsService->getMergedListOfItems($this->listingItemsReader->findListingItems($baseListing->getId()), $this->listingItemsReader->findListingItems($listingToMerge->getId()), $selectedCollisionItems); $newListing = new Listing($baseListing->year, $baseListing->month, $ownerOfOutputListing); $this->em->persist($newListing); foreach ($items as $item) { /** @var ListingItem $item */ $item->setListing($newListing); $this->em->persist($item); } $this->em->flush(); $this->em->commit(); return $newListing; } catch (\Exception $e) { $this->em->rollback(); $this->em->close(); $this->onError('Merging of listings #id(' . $baseListing->getId() . ') and #id(' . $listingToMerge->getId() . ') failed.', $e, self::class); throw $e; } }
/** * @param File $file * @param string|null $genreId * @param bool $copy * @return bool returns true if file already exists * @throws \Exception */ private function addSong(File $file, string $genreId = null, $copy = false) : bool { if ($this->songExists($file->getDestination())) { return true; } // $albumURL = $this->albumCoverProvider->getAlbumCoverURL($file->getDestination()); $albumURL = ''; if ($genreId) { $genre = $this->genresRepository->find($genreId); } else { $genre = null; } $hash = md5_file($file->getDestination()); $song = new Song($file->getName(), $albumURL, $hash, $genre); $this->entityManager->persist($song); $destination = $this->getSongPath($song->getId()); if ($copy) { $file->copy($destination); } else { $file->move($destination); } $this->processSong($song); $this->entityManager->flush($song); return false; }
/** * @param array $values * @param User|null $user * @return ValidationObject */ public function update(array $values, User $user) { $this->em->beginTransaction(); $user->setFirstName($values['first_name']); $user->setLastName($values['last_name']); $validationObject = new ValidationObject(); // todo could be optimized $user->clearRoles(); $role = $this->getRole($values['role'], $validationObject); if (!$validationObject->isValid()) { $this->em->rollback(); return $validationObject; } $user->addRole($role); $this->em->persist($user); $this->em->flush(); if ($validationObject->isValid()) { $this->em->commit(); $this->onSuccessUserEditing($user); $this->cache->remove($user->getCacheKey()); } else { $this->em->rollback(); } return $validationObject; }
/** * @param ElasticIndex $oldIndex * @param ElasticIndex $newIndex */ private function moveDataBetweenIndices(ElasticIndex $oldIndex, ElasticIndex $newIndex) { CrossIndex::reindex($oldIndex, $newIndex); $newIndexEntity = new Index($newIndex->getName()); $this->entityManager->persist($newIndexEntity); $this->entityManager->flush($newIndexEntity); }
public function setup() { $this->entityManager->transactional(function () { $privileges = $this->createPrivileges(); if (!empty($privileges)) { $this->entityManager->persist($privileges); } $invalidPrivileges = $this->findInvalidPrivileges($privileges); if (!empty($invalidPrivileges)) { $this->entityManager->remove($invalidPrivileges); } $roles = $this->createRoles($privileges); if (!empty($roles)) { $this->entityManager->persist($roles); } }); }
public function setText($ident, $text) { if ($this->authorizator->canWrite($ident)) { $et = $this->editableTextRepository->find($ident); $action = "saved"; if ($et === NULL) { $et = new EditableText($ident); $this->em->persist($et); $action = "created"; } $et->setText($text); $this->em->flush(); return ['action' => $action]; } else { throw new AuthenticationException("You have no authorization to edit text"); } }
/** * @param array $values * @param Tag $tag * @return Tag * @throws \Exception */ private function update(array $values, Tag $tag) { $this->em->beginTransaction(); $this->fillTag($values, $tag); $this->em->persist($tag)->flush(); $this->em->commit(); return $tag; }
public function save(array $values) { $options = $this->prepareOptions($this->findOptions()); foreach ((array) $values as $key => $value) { $options[$key]->setValue($value == '' ? null : $value); $this->em->persist($options[$key]); } try { $this->em->flush(); $this->cache->remove(Option::getCacheKey()); $this->onSuccessOptionsSaving(); } catch (\Exception $e) { $this->em->rollback(); $this->em->close(); $this->logger->addError(sprintf('Save Options error: %s | error message: %s', date('Y-m-d H:i:s'), $e->getMessage())); throw $e; } }