/**
* @param Url $url
* @return Url|object
* @throws \Doctrine\DBAL\ConnectionException
* @throws \Exception
*/
public function encode(Url $url)
{
$this->em->beginTransaction();
try {
$urlRepository = $this->em->getRepository('Rz\\Bundle\\UrlShortenerBundle\\Entity\\Url');
$entity = $urlRepository->findOneBy(['url' => $url->getUrl()]);
if ($entity) {
/** @var Url $url */
$url = $entity;
} else {
$url->setNew(true);
$this->em->persist($url);
$this->em->flush();
$url->setCode($this->encoder->encode($url->getId()));
$params = ['code' => $url->getCode()];
if (!$url->isDefaultSequence()) {
$params['index'] = $url->getSequence();
}
$url->setShortUrl($this->router->generate(UrlShortenerBundle::URL_GO, $params, UrlGeneratorInterface::ABSOLUTE_URL));
$this->em->persist($url);
$this->em->flush();
}
$this->em->getConnection()->commit();
return $url;
} catch (\Exception $e) {
$this->em->getConnection()->rollBack();
throw $e;
}
}
/**
* Writes the record down to the log of the implementing handler
*
* @param array $record
*
* @return void
*/
protected function write(array $record)
{
// Ensure the doctrine channel is ignored (unless its greater than a warning error), otherwise you will create an infinite loop, as doctrine like to log.. a lot..
if ('doctrine' == $record['channel']) {
if ((int) $record['level'] >= Logger::WARNING) {
error_log($record['message']);
}
return;
}
// Only log errors greater than a warning
//@todo - you could ideally add this into configuration variable
if ((int) $record['level'] >= Logger::INFO && (string) $record['channel'] == 'backtrace') {
try {
// Create entity and fill with data
$entity = new SystemLog();
$entity->setChannel($record['channel'])->setLevel($record['level'])->setLog($record['message'])->setFormattedMsg($record['formatted'])->setCreatedAt(new \DateTime());
$this->em->persist($entity);
$this->em->flush();
} catch (\Exception $e) {
// Fallback to just writing to php error logs if something really bad happens
error_log($record['message']);
error_log($e->getMessage());
}
}
}
/**
* Persists and flushes all provided models to the database storage.
*
* @param ...$models
*/
protected function persist(...$models)
{
foreach ($models as $model) {
$this->entityManager->persist($model);
}
$this->entityManager->flush();
}
public function setUp()
{
$this->em = $this->prophesize(EntityManagerInterface::class);
$this->em->persist(Argument::any())->willReturn(null);
$this->em->flush()->willReturn(null);
$this->service = new ShortUrlService($this->em->reveal());
}
public function delete(BaseEntityInterface $entity)
{
$this->entityManager->remove($entity);
if ($this->autoFlush) {
$this->entityManager->flush();
}
}
/**
* Creates and persists a unique shortcode generated for provided url
*
* @param UriInterface $url
* @param string[] $tags
* @return string
* @throws InvalidUrlException
* @throws RuntimeException
*/
public function urlToShortCode(UriInterface $url, array $tags = [])
{
// If the url already exists in the database, just return its short code
$shortUrl = $this->em->getRepository(ShortUrl::class)->findOneBy(['originalUrl' => $url]);
if (isset($shortUrl)) {
return $shortUrl->getShortCode();
}
// Check that the URL exists
$this->checkUrlExists($url);
// Transactionally insert the short url, then generate the short code and finally update the short code
try {
$this->em->beginTransaction();
// First, create the short URL with an empty short code
$shortUrl = new ShortUrl();
$shortUrl->setOriginalUrl($url);
$this->em->persist($shortUrl);
$this->em->flush();
// Generate the short code and persist it
$shortCode = $this->convertAutoincrementIdToShortCode($shortUrl->getId());
$shortUrl->setShortCode($shortCode)->setTags($this->tagNamesToEntities($this->em, $tags));
$this->em->flush();
$this->em->commit();
return $shortCode;
} catch (ORMException $e) {
if ($this->em->getConnection()->isTransactionActive()) {
$this->em->rollback();
$this->em->close();
}
throw new RuntimeException('An error occurred while persisting the short URL', -1, $e);
}
}
/**
* Persists an entity via the EntityManager
*
* @param mixed $built A built entity
*/
public function persist($built)
{
$this->entityManager->persist($built);
if ($this->flushAfterPersist) {
$this->entityManager->flush();
}
}
/**
* @param $configKey
* @param $objectId
* @param $value
* @param null|string $dataField
* @throws ContentEditableException
*/
public function updateEntity($configKey, $objectId, $value, $dataField = null)
{
if (!array_key_exists($configKey, $this->configuration['configurations'])) {
throw new ContentEditableException('Missing configuration "' . $configKey . '"');
}
$config = $this->configuration['configurations'][$configKey];
if ($dataField == null) {
if (!array_key_exists('data_field', $config)) {
throw new ContentEditableException('Missing data_field');
}
$dataField = $config['data_field'];
}
$idField = 'id';
if (array_key_exists('id_field', $config)) {
$idField = $config['id_field'];
}
$repository = $this->entityManager->getRepository($config['repository_class']);
$entity = $repository->findOneBy([$idField => $objectId]);
$setter = 'set' . ucfirst($dataField);
if (!method_exists($entity, $setter)) {
throw new ContentEditableException('No setter "' . $setter . '" found for "' . get_class($entity) . '"');
}
$entity->{$setter}(trim($value));
$this->entityManager->persist($entity);
$this->entityManager->flush();
}
/**
* @param array|Student[] $students
*/
public function saveAll(array $students)
{
foreach ($students as $student) {
$this->em->persist($student);
}
$this->em->flush();
}
/**
* @param MailingList $list
*/
public function saveList(MailingList $list)
{
if (!$list->getId()) {
$this->em->persist($list);
}
$this->em->flush($list);
}
/**
* @param $type
* @param $id
* @param $loader
* @return Link
*/
protected function createLink($type, $id, $loader)
{
$link = new Link($type, $id, $loader);
$this->entityManager->persist($link);
$this->entityManager->flush($link);
return $link;
}
public function __invoke()
{
if (null === ($renderer = $this->_renderer)) {
return '';
}
if (null === ($page = $renderer->getCurrentPage())) {
return '';
}
$metadata = $page->getMetadata();
if (null === $metadata || $metadata->count() === 0) {
// @todo gvf
$metadata = new MetaDataBag($this->metadataConfig, $page);
$page->setMetaData($metadata);
if ($this->entityManager->contains($page)) {
$this->entityManager->flush($page);
}
}
$result = '';
foreach ($metadata as $meta) {
if (0 < $meta->count() && 'title' !== $meta->getName()) {
$result .= '<meta ';
foreach ($meta as $attribute => $value) {
if (false !== strpos($meta->getName(), 'keyword') && 'content' === $attribute) {
$keywords = explode(',', $value);
foreach ($this->getKeywordObjects($keywords) as $object) {
$value = trim(str_replace($object->getUid(), $object->getKeyWord(), $value), ',');
}
}
$result .= $attribute . '="' . html_entity_decode($value, ENT_COMPAT, 'UTF-8') . '" ';
}
$result .= '/>' . PHP_EOL;
}
}
return $result;
}
public function execute()
{
$criteria = new Criteria(['owner' => $this->user], null, null, null);
$items = $this->basketRepository->findByCriteria($criteria);
$order = $this->orderRepository->findActive();
$connection = $this->entityManager->getConnection();
$connection->beginTransaction();
try {
$orderItems = [];
foreach ($items as $item) {
/** @var Basket $item */
$previousOrderItem = $this->orderItemRepository->findOneByCriteria(new Criteria(['owner' => $item->getOwner(), 'product' => $item->getProduct()]));
if ($previousOrderItem) {
/** @var OrderItem $orderItem */
$orderItem = $previousOrderItem;
$orderItem->increaseQuantityBy($item->getQuantity());
} else {
$orderItem = OrderItem::createFromBasket($item, $order);
}
$this->entityManager->persist($orderItem);
$this->entityManager->remove($item);
$orderItems[] = $orderItem;
}
$this->entityManager->flush();
$connection->commit();
} catch (\Exception $e) {
$connection->rollBack();
return $e->getMessage();
}
}
public function notify(UrlEvent $event)
{
if (!$this->isEnabled() || !$event->getUrl() || $event->getType() !== Shortener::NOTIFY_TYPE_REDIRECT) {
return false;
}
$additional = $event->getAdditional();
$ip = !empty($additional['ip']) ? $additional['ip'] : null;
if (!$ip) {
return false;
}
$urlRepository = $this->em->getRepository('Rz\\Bundle\\UrlShortenerBundle\\Entity\\Url');
$urlStatRepository = $this->em->getRepository('Rz\\Bundle\\UrlShortenerBundle\\Entity\\UrlStat');
/** @var Url $url */
$url = $urlRepository->find($event->getUrl()->getId());
$url->incrementRedirectCount();
$url->setLastRedirectOn(new \DateTime());
$urlStat = $urlStatRepository->findOneBy(['Url' => $url, 'ip' => $ip]);
if (!$urlStat) {
$url->incrementUniqueRedirectCount();
$urlStat = new UrlStat();
$urlStat->setUrl($url);
$urlStat->setCreated(new \DateTime());
$urlStat->setIp($ip);
if (!empty($additional['user-agent'])) {
$urlStat->setUserAgent($additional['user-agent']);
}
$this->em->persist($urlStat);
}
$this->em->persist($url);
$this->em->flush();
return true;
}
/**
* Update the users last login.
*
* @param UserInterface $user
*/
protected function updateLastLogin($user)
{
if ($user instanceof BaseUser) {
$user->setLastLogin(new \DateTime());
$this->entityManager->flush();
}
}
/**
* @param array|Doctrine\Common\Collections\Collection|\Traversable
* @param boolean $flush
*/
function delete($entity, $flush = self::FLUSH)
{
$this->em->delete($entity);
if ($flush) {
$this->em->flush($entity);
}
}
/**
* Unregisters the smartCode from its subject.
*
* @param SubjectInterface $subject
* @param SmartCodeInterface $smartCode
*
* @return mixed
*/
public function unregister(SubjectInterface $subject, SmartCodeInterface $smartCode)
{
$subject->removeSmartCode($smartCode);
$smartCode->setUsed($smartCode->getUsed() - 1);
$this->manager->persist($subject);
$this->manager->flush();
}
/**
* @inheritdoc
*/
public function delete(MessageModel $message) : MessageModel
{
$message->delete();
$this->em->persist($message);
$this->em->flush();
return $message;
}
/**
* @param object $entity
* @param bool $doFlush
*/
public function remove($entity, $doFlush = true)
{
$this->entityManager->remove($entity);
if ($doFlush) {
$this->entityManager->flush();
}
}
public function createMessage($text, $username, $email = null)
{
$message = new GuestBookMessage();
$message->setText($text)->setUsername($username)->setEmail($email);
$this->manager->persist($message);
$this->manager->flush();
}
public function processDelete(ProcessHook $hook)
{
$repository = $this->entityManager->getRepository('CmfcmfMediaModule:HookedObject\\HookedObjectEntity');
$hookedObject = $repository->getByHookOrCreate($hook);
$this->entityManager->remove($hookedObject);
$this->entityManager->flush();
}
public function updateTranslationRoute(Routeable $routeable, $locale, $staticPrefix)
{
$route = $routeable->getRoute();
$return = null;
if (!$route instanceof Route) {
return null;
}
$translationRoute = $this->em->getRepository('EnhavoTranslationBundle:TranslationRoute')->findOneBy(['type' => $route->getType(), 'typeId' => $route->getTypeId(), 'locale' => $locale]);
if ($translationRoute === null) {
$route = new Route();
$route->setContent($routeable);
$translationRoute = new TranslationRoute();
$translationRoute->setLocale($locale);
$translationRoute->setRoute($route);
$this->em->persist($translationRoute);
}
/** @var Route $route */
$route = $translationRoute->getRoute();
$route->setStaticPrefix($staticPrefix);
$translationRoute->setPath($staticPrefix);
$this->em->flush();
$this->routeManager->update($route);
$translationRoute->setType($route->getType());
$translationRoute->setTypeId($route->getTypeId());
$this->em->flush();
return $translationRoute;
}
/**
* @inheritdoc
*/
public function delete(UserModel $user) : UserModel
{
$user->delete();
$this->em->persist($user);
$this->em->flush();
return $user;
}
/**
* Renueva el alquiler.
*
* @param Rental $rental
*
* @return Rental
*/
public function renewRental(Rental $rental)
{
if ($rental->getReturnAt()) {
throw new FinishedRentalException();
}
if ($rental->getUser()->getIsPenalized()) {
throw new PenalizedUserException();
}
if ($rental->getUser()->getFaculty()->getIsEnabled() === false) {
throw new PenalizedFacultyException();
}
if (!$rental->getIsRenewable()) {
throw new NotRenewableRentalException();
}
if ($rental->getIsExpired()) {
throw new ExpiredRentalException();
}
if ($rental->getDaysLeft() > $this->days_before_renovation) {
throw new TooEarlyRenovationException();
}
$left = $rental->getDaysLeft() + $this->days_length_rental;
$rental->setEndAt(new \DateTime($left . ' days midnight'));
$this->manager->persist($rental);
$this->manager->flush();
$event = new RentalEvent($rental);
$this->dispatcher->dispatch(RentalEvents::LOCKER_RENEWED, $event);
return $rental;
}
/**
* Activates new user by activation code
*
* @param string $code
*
* @throws IOException
*/
public function activate($code)
{
$user = $this->userRepository->findOneBy(['code' => $code, 'frozen' => true]);
$user->activate();
$this->entityManager->persist($user);
$this->entityManager->flush();
}
/**
* @param Subscription $subscription
* @param string $status
*
* @return $this
*/
public function updateStatus(Subscription $subscription, $status)
{
$subscription->setStatus($status);
$this->em->persist($subscription);
$this->em->flush($subscription);
return $this;
}
/**
* {@inheritDoc}
*
* @return void
*/
public function run(EntityInterface $user)
{
$user->setActivationKey(base64_encode($this->secureRandom->nextBytes(24)));
$user->setPassword($this->passwordEncoder->encodePassword($user->getPassword(), User::SALT));
$user->setRegistrationDate(new \DateTime());
$this->entityManager->getRepository(User::class)->add($user);
$this->entityManager->flush();
}
/**
* @param ModelInterface $entity
* @return void
*/
public function delete(ModelInterface $entity)
{
if (!$entity instanceof CourseInterface) {
throw new InvalidArgumentException('expect an CourseInterface object');
}
$this->em->remove($entity);
$this->em->flush();
}
/**
* "Success" form handler
*
* @param Contact $entity
* @param array $appendAccounts
* @param array $removeAccounts
*/
protected function onSuccess(Contact $entity, array $appendAccounts, array $removeAccounts)
{
$this->appendAccounts($entity, $appendAccounts);
$this->removeAccounts($entity, $removeAccounts);
$this->manager->persist($entity);
$this->setUpdatedAt($entity);
$this->manager->flush();
}
public function abandon(GenericEvent $event)
{
$cart = $event->getSubject();
if ($cart instanceof OrderInterface) {
$cart->setExpiresAt(new \DateTime());
}
$this->em->flush();
}
