/** * @param Channel $channel * @param string $entity * * @throws \Exception */ protected function fillChannelToEntity(Channel $channel, $entity) { $interfaces = class_implements($entity) ?: []; if (!in_array('OroCRM\\Bundle\\ChannelBundle\\Model\\ChannelAwareInterface', $interfaces)) { return; } /** @var QueryBuilder $qb */ $qb = $this->em->getRepository($entity)->createQueryBuilder('e'); $iterator = new BufferedQueryResultIterator($qb); $writeCount = 0; $toWrite = []; try { $this->em->beginTransaction(); /** @var ChannelAwareInterface $data */ foreach ($iterator as $data) { $writeCount++; if (!$data->getDataChannel()) { $channelReference = $this->em->getReference(ClassUtils::getClass($channel), $channel->getId()); $data->setDataChannel($channelReference); $toWrite[] = $data; } if (0 === $writeCount % static::BATCH_SIZE) { $this->write($toWrite); $toWrite = []; } } if (count($toWrite) > 0) { $this->write($toWrite); } $this->em->commit(); } catch (\Exception $exception) { $this->em->rollback(); throw $exception; } }
public function execute(InputInterface $input, OutputInterface $output) { $output->writeln('Migrating translations...'); $this->setEntityManager($this->getContainer()->get('doctrine.orm.entity_manager')); /* @var EntityRepository $repo */ $repo = $this->em->getRepository('KunstmaanTranslatorBundle:Translation'); /** * @var QueryBuilder $qb */ $qb = $repo->createQueryBuilder('t'); $uniqueTranslations = $qb->select('t.domain,t.keyword')->distinct()->where('t.translationId IS NULL')->getQuery()->getArrayResult(); $this->em->beginTransaction(); try { foreach ($uniqueTranslations as $uniqueTranslation) { // Fetch new unique translation ID & update records $newId = $repo->getUniqueTranslationId(); // Update translations... $qb->update()->set('t.translationId', $newId)->where('t.domain = :domain')->andWhere('t.keyword = :keyword')->setParameter('domain', $uniqueTranslation['domain'])->setParameter('keyword', $uniqueTranslation['keyword'])->getQuery()->execute(); } $this->em->commit(); $output->writeln('<info>' . count($uniqueTranslations) . ' translations have been migrated.</info>'); } catch (\Exception $e) { $this->em->rollback(); $output->writeln('An error occured while migrating translations : <error>' . $e->getMessage() . '</error>'); } }
/** * Persists data into DB in single transaction * * @param string $locale * @param array $data translations strings, format same as MassageCatalog::all() returns * * @throws \Exception */ public function persist($locale, array $data) { $writeCount = 0; try { $this->em->beginTransaction(); foreach ($data as $domain => $domainData) { foreach ($domainData as $key => $translation) { if (strlen($key) > MySqlPlatform::LENGTH_LIMIT_TINYTEXT) { continue; } $writeCount++; $this->toWrite[] = $this->getTranslationObject($key, $locale, $domain, $translation); if (0 === $writeCount % $this->batchSize) { $this->write($this->toWrite); $this->toWrite = []; } } } if (count($this->toWrite) > 0) { $this->write($this->toWrite); } $this->em->commit(); } catch (\Exception $exception) { $this->em->rollback(); throw $exception; } // update timestamp in case when persist succeed $this->metadataCache->updateTimestamp($locale); }
public function groupMembershipAction() { /** @var AccountInterface $account */ $account = $this->entityManager->getRepository(AccountInterface::class)->find($this->bodyParam('account')); if (!$account) { return new ApiProblem(404, 'The account could not be found.'); } /** @var Group $group */ $group = $this->entityManager->getRepository(Group::class)->find($this->bodyParam('group')); if (!$group) { return new ApiProblem(404, 'The group could not be found.'); } if ($this->getRequest()->getMethod() === 'POST' && !$account->getGroups()->contains($group)) { $account->getGroups()->add($group); } elseif ($this->getRequest()->getMethod() === 'DELETE' && $account->getGroups()->contains($group)) { $account->getGroups()->removeElement($group); } try { $this->entityManager->beginTransaction(); $this->entityManager->persist($account); $this->entityManager->flush(); $this->entityManager->commit(); } catch (Exception $e) { $this->entityManager->rollback(); return new ApiProblemResponse(new ApiProblem(500, $e->getMessage(), null, null, ['exception' => $e])); } return new ViewModel(['group' => $group->getId(), 'account' => $account->getId()]); }
/** * @param string $jobType * @param string $jobName * @param array $configuration * @return JobResult */ public function executeJob($jobType, $jobName, array $configuration = array()) { // create and persist job instance and job execution $jobInstance = new JobInstance(self::CONNECTOR_NAME, $jobType, $jobName); $jobInstance->setCode($this->generateJobCode($jobName)); $jobInstance->setLabel(sprintf('%s.%s', $jobType, $jobName)); $jobInstance->setRawConfiguration($configuration); $jobExecution = new JobExecution(); $jobExecution->setJobInstance($jobInstance); $jobResult = new JobResult(); $jobResult->setSuccessful(false); $this->entityManager->beginTransaction(); try { $job = $this->jobRegistry->getJob($jobInstance); if (!$job) { throw new RuntimeException(sprintf('Can\'t find job "%s"', $jobName)); } // TODO: Refactor whole logic of job execution to perform actions in transactions $job->execute($jobExecution); $failureExceptions = $this->collectFailureExceptions($jobExecution); if ($jobExecution->getStatus()->getValue() == BatchStatus::COMPLETED && !$failureExceptions) { $this->entityManager->commit(); $jobResult->setSuccessful(true); } else { $this->entityManager->rollback(); foreach ($failureExceptions as $failureException) { $jobResult->addFailureException($failureException); } } } catch (\Exception $exception) { $this->entityManager->rollback(); $jobExecution->addFailureException($exception); $jobResult->addFailureException($exception->getMessage()); } // save job instance $this->entityManager->persist($jobInstance); $this->entityManager->flush($jobInstance); // set data to JobResult $jobResult->setJobId($jobInstance->getId()); $jobResult->setJobCode($jobInstance->getCode()); /** @var JobExecution $jobExecution */ $jobExecution = $jobInstance->getJobExecutions()->first(); if ($jobExecution) { $stepExecution = $jobExecution->getStepExecutions()->first(); if ($stepExecution) { $context = $this->contextRegistry->getByStepExecution($stepExecution); $jobResult->setContext($context); } } return $jobResult; }
/** * @param EmailBodyAdded $event * * @throws \Exception */ public function updateActivityDescription(EmailBodyAdded $event) { $this->entityManager->beginTransaction(); try { $email = $event->getEmail(); $activityList = $this->chainProvider->getUpdatedActivityList($email, $this->entityManager); if ($activityList) { $this->entityManager->persist($activityList); $this->entityManager->flush(); } $this->entityManager->commit(); } catch (\Exception $e) { $this->entityManager->rollback(); throw $e; } }
public function insertUpdateProcessing(EntityManager $em, $data, $id = null) { $update = !is_null($id); try { $em->beginTransaction(); if ($update) { $language = $em->find('Model\\Language', $id); } else { $language = new Language(); } $language->setCode($data['code']); $language->setDescription($data['description']); $language->setFlagImageURL($data['flagimageurl']); $menu = $em->find('Model\\Menu', $data['menuid']); $language->setMenu($menu); if ($update) { $em->merge($language); } else { $em->persist($language); } $em->flush(); $em->commit(); } catch (\Exception $e) { $em->rollback(); throw $e; } return $language->getId(); }
/** * @param JobExecution $jobExecution * @param JobInstance $jobInstance * @return JobResult */ protected function doJob(JobInstance $jobInstance, JobExecution $jobExecution) { $jobResult = new JobResult(); $jobResult->setSuccessful(false); $isTransactionRunning = $this->isTransactionRunning(); if (!$isTransactionRunning) { $this->entityManager->beginTransaction(); } try { $job = $this->batchJobRegistry->getJob($jobInstance); if (!$job) { throw new RuntimeException(sprintf('Can\'t find job "%s"', $jobInstance->getAlias())); } $job->execute($jobExecution); $isSuccessful = $this->handleJobResult($jobExecution, $jobResult); if (!$isTransactionRunning && $isSuccessful && !$this->validationMode) { $this->entityManager->commit(); } elseif (!$isTransactionRunning) { $this->entityManager->rollback(); } // trigger save of JobExecution and JobInstance $this->batchJobRepository->getJobManager()->flush(); if (!$this->isClearSkipped($jobExecution)) { $this->batchJobRepository->getJobManager()->clear(); } } catch (\Exception $exception) { if (!$isTransactionRunning) { $this->entityManager->rollback(); } $jobExecution->addFailureException($exception); $jobResult->addFailureException($exception->getMessage()); $this->saveFailedJobExecution($jobExecution); } return $jobResult; }
/** * @param JobExecution $jobExecution * @param JobInstance $jobInstance * @return JobResult */ protected function doJob(JobInstance $jobInstance, JobExecution $jobExecution) { $jobResult = new JobResult(); $jobResult->setSuccessful(false); $this->entityManager->beginTransaction(); try { $job = $this->batchJobRegistry->getJob($jobInstance); if (!$job) { throw new RuntimeException(sprintf('Can\'t find job "%s"', $jobInstance->getAlias())); } $job->execute($jobExecution); $failureExceptions = $this->collectFailureExceptions($jobExecution); if ($jobExecution->getStatus()->getValue() == BatchStatus::COMPLETED && !$failureExceptions) { $this->entityManager->commit(); $jobResult->setSuccessful(true); } else { $this->entityManager->rollback(); foreach ($failureExceptions as $failureException) { $jobResult->addFailureException($failureException); } } } catch (\Exception $exception) { $this->entityManager->rollback(); $jobExecution->addFailureException($exception); $jobResult->addFailureException($exception->getMessage()); } return $jobResult; }
public static function rollback(EntityManager $entityManager) { if ($entityManager->getConnection()->isTransactionActive()) { //This place tried to commit without an active transaction $entityManager->rollback(); $entityManager->beginTransaction(); } }
/** * {@inheritDoc} */ public function handle(MassActionHandlerArgs $args) { $data = $args->getData(); $massAction = $args->getMassAction(); $options = $massAction->getOptions()->toArray(); $this->entityManager->beginTransaction(); try { set_time_limit(0); $iteration = $this->handleHeadEmails($options, $data); $this->handleThreadEmails($options); $this->entityManager->commit(); } catch (\Exception $e) { $this->entityManager->rollback(); throw $e; } return $this->getResponse($args, $iteration); }
/** * {@inheritDoc} */ public function handle(MassActionHandlerArgs $args) { $iteration = 0; $entityName = null; $entityIdentifiedField = null; $results = new DeletionIterableResult($args->getResults()->getSource()); $results->setBufferSize(self::FLUSH_BATCH_SIZE); // batch remove should be processed in transaction $this->entityManager->beginTransaction(); try { // if huge amount data must be deleted set_time_limit(0); foreach ($results as $result) { /** @var $result ResultRecordInterface */ $entity = $result->getRootEntity(); if (!$entity) { // no entity in result record, it should be extracted from DB if (!$entityName) { $entityName = $this->getEntityName($args); } if (!$entityIdentifiedField) { $entityIdentifiedField = $this->getEntityIdentifierField($args); } $entity = $this->getEntity($entityName, $result->getValue($entityIdentifiedField)); } if ($entity) { if ($this->securityFacade->isGranted('DELETE', $entity)) { $this->entityManager->remove($entity); $iteration++; } if ($iteration % self::FLUSH_BATCH_SIZE == 0) { $this->finishBatch(); } } } if ($iteration % self::FLUSH_BATCH_SIZE > 0) { $this->finishBatch(); } $this->entityManager->commit(); } catch (\Exception $e) { $this->entityManager->rollback(); throw $e; } return $this->getResponse($args, $iteration); }
/** * {@inheritDoc} */ public function handle(MassActionMediatorInterface $mediator) { $iteration = 0; $entityName = null; $entityIdentifiedField = null; $results = $this->prepareIterableResult($mediator->getResults()); $results->setBufferSize(self::FLUSH_BATCH_SIZE); // batch remove should be processed in transaction $this->entityManager->beginTransaction(); try { foreach ($results as $result) { /** @var $result ResultRecordInterface */ $entity = $result->getRootEntity(); if (!$entity) { // no entity in result record, it should be extracted from DB if (!$entityName) { $entityName = $this->getEntityName($mediator); } if (!$entityIdentifiedField) { $entityIdentifiedField = $this->getEntityIdentifierField($mediator); } $entity = $this->getEntity($entityName, $result->getValue($entityIdentifiedField)); } if ($entity) { $this->entityManager->remove($entity); $iteration++; if ($iteration % self::FLUSH_BATCH_SIZE == 0) { $this->entityManager->flush(); $this->entityManager->clear(); } } } if ($iteration % self::FLUSH_BATCH_SIZE > 0) { $this->entityManager->flush(); $this->entityManager->clear(); } $this->entityManager->commit(); } catch (\Exception $e) { $this->entityManager->rollback(); throw $e; } return $this->getResponse($mediator, $iteration); }
/** * Runs static repository restriction query and stores it state into snapshot entity * Doctrine does not supports insert in DQL. To increase the speed of query here uses plain sql query. * * @param Segment $segment * * @throws \LogicException * @throws \Exception */ public function run(Segment $segment) { if ($segment->getType()->getName() !== SegmentType::TYPE_STATIC) { throw new \LogicException('Only static segments could have snapshots.'); } $entityMetadata = $this->em->getClassMetadata($segment->getEntity()); if (count($entityMetadata->getIdentifierFieldNames()) > 1) { throw new \LogicException('Only entities with single identifier supports.'); } $this->em->getRepository('OroSegmentBundle:SegmentSnapshot')->removeBySegment($segment); try { $this->em->beginTransaction(); $date = new \DateTime('now', new \DateTimeZone('UTC')); $dateString = '\'' . $date->format('Y-m-d H:i:s') . '\''; if ($this->em->getConnection()->getDriver()->getName() === DatabaseDriverInterface::DRIVER_POSTGRESQL) { $dateString = sprintf('TIMESTAMP %s', $dateString); } $insertString = sprintf(', %d, %s ', $segment->getId(), $dateString); $qb = $this->dynamicSegmentQB->getQueryBuilder($segment); $this->applyOrganizationLimit($segment, $qb); $query = $qb->getQuery(); $segmentQuery = $query->getSQL(); $segmentQuery = substr_replace($segmentQuery, $insertString, stripos($segmentQuery, 'from'), 0); $fieldToSelect = 'entity_id'; if ($entityMetadata->getTypeOfField($entityMetadata->getSingleIdentifierFieldName()) === 'integer') { $fieldToSelect = 'integer_entity_id'; } $dbQuery = 'INSERT INTO oro_segment_snapshot (' . $fieldToSelect . ', segment_id, createdat) (%s)'; $dbQuery = sprintf($dbQuery, $segmentQuery); $statement = $this->em->getConnection()->prepare($dbQuery); $this->bindParameters($statement, $query->getParameters()); $statement->execute(); $this->em->commit(); } catch (\Exception $exception) { $this->em->rollback(); throw $exception; } $segment = $this->em->merge($segment); $segment->setLastRun(new \DateTime('now', new \DateTimeZone('UTC'))); $this->em->persist($segment); $this->em->flush(); }
/** * @param ImageResourceInterface $resource * @param ImageBindInterface $binder * @throws \Exception */ public function bind(ImageResourceInterface $resource, ImageBindInterface $binder) { try { $this->entityManager->beginTransaction(); $imageEntity = $resource->getEntity(); $this->entityManager->persist($imageEntity); $this->entityManager->persist($binder); if (is_null($resource->getEntity())) { throw new DomainException("Could not get entity from resource,\n resource not loaded correctly"); } $imageEntity->setTemporary(false); $binder->addImage($imageEntity); $this->entityManager->flush($binder); $this->entityManager->flush($imageEntity); $this->entityManager->commit(); } catch (\Exception $e) { $this->entityManager->rollback(); throw $e; } }
/** * Comita as alterações/inserções para o banco de dados. * * Por padrão o Doctrine2 não comita * * @return bool */ public function flush() { try { $this->manager->flush(); } catch (\Exception $e) { $this->manager->rollback(); Error::log($e); return false; } return true; }
/** * вывести деньги * * @ApiDoc( * section="Billing API", * input="Vifeed\PaymentBundle\Form\WithdrawalType", * output={ * "class"="Vifeed\PaymentBundle\Entity\Withdrawal", * "groups"={"default"} * }, * resource=true, * statusCodes={ * 201="Returned when successful", * 400="Returned when something is wrong", * 403="Returned when the user is not authorized to use this method" * } * ) * * @return Response */ public function putWithdrawalAction() { $form = $this->createForm(new WithdrawalType()); $form->submit($this->get('request')); if ($form->isValid()) { /** @var Withdrawal $withdrawal */ $withdrawal = $form->getData(); if ($withdrawal->getWallet()->getUser() != $this->getUser()) { throw new AccessDeniedHttpException('Можно вывести только на свой кошелёк'); } if ($withdrawal->getAmount() > $this->getUser()->getBalance()) { $form->get('amount')->addError(new FormError('Недостаточно денег на балансе')); } else { $userRepo = $this->em->getRepository('VifeedUserBundle:User'); $this->em->beginTransaction(); $this->em->lock($this->getUser(), LockMode::PESSIMISTIC_WRITE); try { $withdrawal->setUser($this->getUser())->setStatus(Withdrawal::STATUS_CREATED); $this->em->persist($withdrawal); $userRepo->updateBalance($this->getUser(), -$withdrawal->getAmount()); $this->em->flush(); $this->em->commit(); } catch (\Exception $e) { $this->em->rollback(); $this->em->close(); throw $e; } $mailer = $this->get('vifeed.mailer'); $message = $mailer->renderMessage('VifeedPaymentBundle:Email:withdrawal.html.twig', ['withdrawal' => $withdrawal]); $mailer->sendMessage('Запрос на вывод средств', $message, $this->container->getParameter('withdrawal.notification.email')); $context = new SerializationContext(); $context->setGroups(array('default')); $view = new View($withdrawal, 201); $view->setSerializationContext($context); } } if (!$form->isValid()) { $view = new View($form, 400); } return $this->handleView($view); }
/** * Runs static repository restriction query and stores it state into snapshot entity * * @param Segment $segment * * @throws \LogicException * @throws \Exception */ public function run(Segment $segment) { if ($segment->getType()->getName() !== SegmentType::TYPE_STATIC) { throw new \LogicException('Only static segments could have snapshots.'); } $this->em->getRepository('OroSegmentBundle:SegmentSnapshot')->removeBySegment($segment); $qb = $this->dynamicSegmentQB->build($segment); $iterator = new BufferedQueryResultIterator($qb); $writeCount = 0; try { $this->em->beginTransaction(); $this->em->clear(ClassUtils::getClass($segment)); foreach ($iterator as $data) { // only not composite identifiers are supported $id = reset($data); $writeCount++; /** @var Segment $reference */ $reference = $this->em->getReference(ClassUtils::getClass($segment), $segment->getId()); $snapshot = new SegmentSnapshot($reference); $snapshot->setEntityId($id); $this->toWrite[] = $snapshot; if (0 === $writeCount % $this->batchSize) { $this->write($this->toWrite); $this->toWrite = []; } } if (count($this->toWrite) > 0) { $this->write($this->toWrite); } $this->em->commit(); } catch (\Exception $exception) { $this->em->rollback(); throw $exception; } $segment = $this->em->merge($segment); $segment->setLastRun(new \DateTime('now', new \DateTimeZone('UTC'))); $this->em->persist($segment); $this->em->flush(); }
/** * {@inheritdoc} */ public function write(array $items) { try { $this->em->beginTransaction(); foreach ($items as $item) { $this->em->persist($item); } $this->em->flush(); $this->em->commit(); $configuration = $this->contextRegistry->getByStepExecution($this->stepExecution)->getConfiguration(); if (empty($configuration[EntityWriter::SKIP_CLEAR])) { $this->em->clear(); } } catch (\Exception $exception) { $this->em->rollback(); $this->ensureEntityManagerReady(); $jobName = $this->stepExecution->getJobExecution()->getJobInstance()->getAlias(); $event = new WriterErrorEvent($items, $jobName, $exception); $this->eventDispatcher->dispatch(WriterErrorEvent::NAME, $event); if ($event->getCouldBeSkipped()) { $importContext = $this->contextRegistry->getByStepExecution($this->stepExecution); $importContext->setValue('error_entries_count', (int) $importContext->getValue('error_entries_count') + count($items)); $importContext->addError($event->getWarning()); if ($event->getException() === $exception) { // exception are already handled and job can move forward throw new InvalidItemException($event->getWarning(), []); } else { // exception are already created and ready to be rethrown throw $event->getException(); } } else { throw $exception; } } $this->eventDispatcher->dispatch(WriterAfterFlushEvent::NAME, new WriterAfterFlushEvent($this->em)); }
public function insert(array $params) { try { $class = new $this->entity_name(); $entity = $this->setData($class, $params); $this->_em->persist($entity); $this->_em->flush(); $this->_em->clear(); return $this->get($entity->getId()); } catch (Exception $e) { ErrorModel::addError(array('code' => 'no_insert_this_data', 'message' => 'Not insert this data')); ErrorModel::addError(array('code' => $e->getCode(), 'message' => $e->getMessage())); $this->_em->rollback(); } }
/** * * @param EntityManager $em * @throws Exception */ public function install(EntityManager $em) { try { $em->beginTransaction(); $em->persist($this->create(_('Raíz'), _('Grupo Raíz'))); $em->commit(); $em->flush(); } catch (Exception $e) { try { $em->rollback(); } catch (Exception $ex) { } throw $e; } }
/** * @param EntityManager $em * * @throws Exception */ public function install(EntityManager $em) { try { $em->beginTransaction(); $em->persist($this->create(_('Administrador'), _('Administrador geral do sistema'))); $em->commit(); $em->flush(); } catch (Exception $e) { try { $em->rollback(); } catch (Exception $ex) { } throw $e; } }
/** * * @param EntityManager $em * @throws Exception */ public function install(EntityManager $em) { try { $grupo = $em->find('Novosga\\Model\\Grupo', 1); $em->beginTransaction(); $em->persist($this->create(_('Unidade Padrão'), _('Novo SGA'), $grupo)); $em->commit(); $em->flush(); } catch (Exception $e) { try { $em->rollback(); } catch (Exception $ex) { } throw $e; } }
/** * @param $id * @param $username * @return DBALException|\Exception|null|object */ public function updateUser($id, $username) { $this->entityManager->beginTransaction(); try { $user = $this->userRepository->find($id); $user->setUsername($username); $user->setEmail($username); $this->entityManager->persist($user); $this->entityManager->flush(); $this->entityManager->commit(); return $user; } catch (DBALException $e) { $this->entityManager->rollback(); return $e; } }
/** * @param Annee $annee * @param UploadedFile $fichier * @param array $erreurs * @return number */ public function importAdherents($annee, $fichier, &$erreurs) { $this->em->beginTransaction(); try { $nbLignes = 0; $handle = fopen($fichier->getRealPath(), "r"); $headers = fgetcsv($handle); while ($data = fgetcsv($handle)) { if (count($data) != 10) { array_push($erreurs, $this->translator->trans('patlenain_gas.adherent.import.erreur.nombreChampsIncorrect', array('%ligne%' => $nbLignes + 1))); } else { $adherent = new Adherent(); $adherent->setNom($data[0]); $adherent->setPrenom($data[1]); $adherent->setEmail($data[2]); $adherent->setAdresse($data[3]); $adherent->setCodePostal($data[4]); $adherent->setVille($data[5]); $adherent->setNumeroFixe($data[6]); $adherent->setNumeroPortable($data[7]); $dateNaissance = DateTime::createFromFormat("d/m/Y", $data[8]); $adherent->setDateNaissance($dateNaissance); $dateAdhesion = null; if ($data[9]) { $dateAdhesion = DateTime::createFromFormat("d/m/Y", $data[9]); } $adherent->setDateNaissance($dateNaissance); $adherent->setAnnee($annee); $this->em->persist($adherent); } $nbLignes++; } if (count($erreurs) > 0) { $this->em->rollback(); } else { $this->em->commit(); } fclose($handle); } catch (\Exception $e) { $this->em->rollback(); fclose($handle); throw $e; } return $nbLignes; }
/** * {@inheritDoc} */ public function update($id, $data) { $data = $this->convertData($data); $repository = $this->entityManager->getRepository($this->getEntityClass()); $entity = $repository->find($id); $hydrator = new DoctrineObject($this->entityManager, true); $entity = $hydrator->hydrate((array) $data, $entity); $this->entityManager->beginTransaction(); try { $this->entityManager->persist($entity); $this->entityManager->flush($entity); $this->entityManager->commit(); } catch (Exception $e) { $this->entityManager->rollback(); return new ApiProblem(500, $e); } return $entity; }
/** * @param EntityManager $em * * @throws Exception */ public function install(EntityManager $em) { try { $em->beginTransaction(); $em->persist($this->create(_('Sem prioridade'), _('Atendimento normal'), 0)); $em->persist($this->create(_('Portador de Deficiência'), _('Atendimento prioritáro para portadores de deficiência'), 1)); $em->persist($this->create(_('Gestante'), _('Atendimento prioritáro para gestantes'), 1)); $em->persist($this->create(_('Idoso'), _('Atendimento prioritáro para idosos'), 1)); $em->persist($this->create(_('Outros'), _('Qualquer outra prioridade'), 1)); $em->commit(); $em->flush(); } catch (Exception $e) { try { $em->rollback(); } catch (Exception $ex) { } throw $e; } }
/** * @param ConfigurationEntryInterface $entry */ public function save(ConfigurationEntryInterface $entry) { if (!$entry instanceof ConfigurationEntry) { throw new InvalidArgumentException('$entry must be an instance of ' . ConfigurationEntry::clazz()); } $this->em->beginTransaction(); try { if ($this->uniquityValidator) { if (!$this->uniquityValidator->isValidForSaving($entry)) { throw new ConfigurationEntryAlreadyExistsException(sprintf('Configuration property with name "%s" already exists.', $entry->getName())); } } $this->em->persist($entry); $this->em->flush($entry); } catch (\Exception $e) { $this->em->rollback(); throw $e; } $this->em->commit(); }
/** * @inheritdoc */ public function unsubscribeUser(User $user, $listId) { $driver = $this->getDriverByListId($listId); $this->checkDriverConfiguration($driver); $this->em->beginTransaction(); try { $newsletter = $this->em->getRepository('NecktieNewsletterBundle:Newsletter'); $row = $newsletter->findOneBy(['user' => $user, 'listID' => $listId]); if ($row) { $us = $driver->unsubscribe($row->getMemberID(), $listId); $this->em->remove($row); $this->em->flush(); $this->em->commit(); return $us; } } catch (\Exception $ex) { $this->em->rollback(); $this->logger->addWarning($ex); } return null; }
/** * рефанд всех показов с площадок заданного паблишера * * @param User $publisher */ public function refundAllFromPublisher(User $publisher) { $platforms = $this->em->getRepository('VifeedPlatformBundle:Platform')->findByUserIndexed($publisher, true); $chargePublisherSum = 0; $payAdvertiserSum = 0; if ($platforms) { $userRepo = $this->em->getRepository('VifeedUserBundle:User'); $filter = $this->em->getFilters()->getFilter('softdeleteable'); $filter->disableForEntity('Vifeed\\CampaignBundle\\Entity\\Campaign'); $refundGroups = $this->em->getRepository('VifeedPaymentBundle:VideoViewPayment')->createQueryBuilder('p')->select('IDENTITY(c.user) user_id, SUM(p.charged) charged, SUM(p.paid) paid, COUNT(v.id) paid_views')->innerJoin('p.videoView', 'v')->innerJoin('v.campaign', 'c')->where('v.platform IN (:platforms)')->groupBy('user_id')->setParameter('platforms', $platforms)->getQuery()->getResult(); $filter->enableForEntity('Vifeed\\CampaignBundle\\Entity\\Campaign'); $this->em->beginTransaction(); try { foreach ($refundGroups as $refundGroup) { $advertiser = $this->em->getReference('VifeedUserBundle:User', $refundGroup['user_id']); $userRepo->updateBalance($advertiser, $refundGroup['charged']); $chargePublisherSum += $refundGroup['paid']; $payAdvertiserSum += $refundGroup['charged']; } $userRepo->updateBalance($publisher, -$chargePublisherSum); $this->em->getRepository('VifeedVideoViewBundle:VideoView')->createQueryBuilder('v')->update('VifeedVideoViewBundle:VideoView', 'v')->set('v.isPaid', ':isPaid')->set('v.isInStats', ':isInStats')->where('v.platform IN (:platforms)')->setParameters(['platforms' => $platforms, 'isPaid' => false, 'isInStats' => false])->getQuery()->execute(); $this->em->getRepository('VifeedPaymentBundle:VideoViewPayment')->createQueryBuilder('p')->delete('VifeedPaymentBundle:VideoViewPayment', 'p')->where('p.videoView IN (select v from VifeedVideoViewBundle:VideoView v where v.platform IN (:platforms))')->setParameter('platforms', $platforms)->getQuery()->execute(); // пересчитываем количество показов и просмотров // todo: можно оптимизировать - считать только кампании выбранных юзеров $sqlQuery = 'UPDATE campaign c SET c.total_views = (SELECT COUNT(1) FROM video_views v WHERE v.campaign_id = c.id AND v.is_in_stats=1), c.paid_views = (SELECT COUNT(1) FROM video_views v WHERE v.campaign_id = c.id AND v.is_in_stats=1 AND v.is_paid=1)'; $this->em->getConnection()->executeQuery($sqlQuery); $this->em->commit(); } catch (\Exception $e) { $this->em->rollback(); throw $e; } } return ['charged' => $chargePublisherSum, 'paid' => $payAdvertiserSum]; }