/**
* @Route("/{applicationId}")
* @Method({"GET", "POST"})
* @Template()
* @param Request $request
* @param $applicationId
* @return array
*/
public function indexAction(Request $request, $applicationId)
{
// Validate the $applicationId, throws Exception if invalid.
$application = $this->getApplication($this->irisEntityManager, $applicationId);
// Get the Case for this Tenant and put in the session, as it's needed throughout
$case = $this->getCase($this->irisEntityManager, $application->getCaseId());
$request->getSession()->set('submitted-case', serialize($case));
// Create an empty ReferencingGuarantor object.
$guarantor = new ReferencingGuarantor();
$guarantor->setCaseId($application->getCaseId());
// Build the form.
$form = $this->createForm($this->formType, $guarantor, array('guarantor_decorator' => $this->referencingGuarantorDecoratorBridgeSubscriber->getGuarantorDecorator(), 'attr' => array('id' => 'generic_step_form', 'class' => 'referencing branded individual-guarantor-form', 'novalidate' => 'novalidate')));
// Process a client round trip, if necessary
if ($request->isXmlHttpRequest()) {
$form->submit($request);
return $this->render('BarbonHostedApiLandlordReferenceBundle:NewReference/Guarantor/Validate:index.html.twig', array('form' => $form->createView()));
}
// Submit the form.
$form->handleRequest($request);
if ($form->isValid()) {
$case = $this->getCase($this->irisEntityManager, $application->getCaseId());
// Dispatch the new guarantor reference event.
$this->eventDispatcher->dispatch(NewReferenceEvents::GUARANTOR_REFERENCE_CREATED, new NewGuarantorReferenceEvent($case, $application, $guarantor));
// Send the user to the success page.
return $this->redirectToRoute('barbon_hostedapi_landlord_reference_newreference_guarantor_confirmation_index', array('applicationId' => $applicationId));
}
return array('form' => $form->createView());
}
/**
* Bulk generates and inserts full version records for the provided versionable entities
* in MongoDB.
* Return an array of ids of documents that have really changed since the last version.
*
* @param array $versionables
*
* @return array
*/
public function bulkPersist(array $versionables)
{
$versions = [];
$changedDocIds = [];
$author = VersionManager::DEFAULT_SYSTEM_USER;
$event = $this->eventDispatcher->dispatch(BuildVersionEvents::PRE_BUILD, new BuildVersionEvent());
if (null !== $event && null !== $event->getUsername()) {
$author = $event->getUsername();
}
foreach ($versionables as $versionable) {
$previousVersion = $this->getPreviousVersion($versionable);
$context = $this->versionContext->getContextInfo(get_class($versionable));
$newVersion = $this->versionBuilder->buildVersion($versionable, $author, $previousVersion, $context);
if (count($newVersion->getChangeSet()) > 0) {
$versions[] = $newVersion;
$changedDocIds[] = $versionable->getId();
}
if (null !== $previousVersion) {
$this->documentManager->detach($previousVersion);
}
}
$mongodbVersions = [];
foreach ($versions as $version) {
$mongodbVersions[] = $this->normalizer->normalize($version, VersionNormalizer::FORMAT);
}
if (count($mongodbVersions) > 0) {
$collection = $this->documentManager->getDocumentCollection($this->versionClass);
$collection->batchInsert($mongodbVersions);
}
return $changedDocIds;
}
/**
* {@inheritdoc}
*/
public function runTasks()
{
$executions = $this->taskExecutionRepository->findScheduled();
foreach ($executions as $execution) {
$handler = $this->taskHandlerFactory->create($execution->getHandlerClass());
$start = microtime(true);
$execution->setStartTime(new \DateTime());
$execution->setStatus(TaskStatus::RUNNING);
$this->taskExecutionRepository->save($execution);
try {
$this->eventDispatcher->dispatch(Events::TASK_BEFORE, new TaskExecutionEvent($execution->getTask(), $execution));
$result = $handler->handle($execution->getWorkload());
$execution->setStatus(TaskStatus::COMPLETED);
$execution->setResult($result);
$this->eventDispatcher->dispatch(Events::TASK_PASSED, new TaskExecutionEvent($execution->getTask(), $execution));
} catch (\Exception $ex) {
$execution->setException($ex->__toString());
$execution->setStatus(TaskStatus::FAILED);
$this->eventDispatcher->dispatch(Events::TASK_FAILED, new TaskExecutionEvent($execution->getTask(), $execution));
}
$execution->setEndTime(new \DateTime());
$execution->setDuration(microtime(true) - $start);
$this->eventDispatcher->dispatch(Events::TASK_FINISHED, new TaskExecutionEvent($execution->getTask(), $execution));
$this->taskExecutionRepository->save($execution);
}
}
/**
* @param ExampleNode $example
*
* @return int
*/
public function run(ExampleNode $example)
{
$startTime = microtime(true);
$this->dispatcher->dispatch('beforeExample', new ExampleEvent($example));
try {
$this->executeExample($example->getSpecification()->getClassReflection()->newInstance(), $example);
$status = ExampleEvent::PASSED;
$exception = null;
} catch (ExampleException\PendingException $e) {
$status = ExampleEvent::PENDING;
$exception = $e;
} catch (ExampleException\SkippingException $e) {
$status = ExampleEvent::SKIPPED;
$exception = $e;
} catch (ProphecyException\Prediction\PredictionException $e) {
$status = ExampleEvent::FAILED;
$exception = $e;
} catch (ExampleException\FailureException $e) {
$status = ExampleEvent::FAILED;
$exception = $e;
} catch (Exception $e) {
$status = ExampleEvent::BROKEN;
$exception = $e;
}
if ($exception instanceof PhpSpecException) {
$exception->setCause($example->getFunctionReflection());
}
$runTime = microtime(true) - $startTime;
$this->dispatcher->dispatch('afterExample', $event = new ExampleEvent($example, $runTime, $status, $exception));
return $event->getResult();
}
/**
* {@inheritdoc}
*/
protected function sendInternalRequests(array $internalRequests, $success, $error)
{
if (!empty($internalRequests)) {
$this->eventDispatcher->dispatch(Events::MULTI_PRE_SEND, $multiPreSendEvent = new MultiPreSendEvent($this, $internalRequests));
$internalRequests = $multiPreSendEvent->getRequests();
}
$exceptions = array();
try {
$responses = $this->decorate('sendRequests', array($internalRequests));
} catch (MultiHttpAdapterException $e) {
$responses = $e->getResponses();
$exceptions = $e->getExceptions();
}
if (!empty($responses)) {
$this->eventDispatcher->dispatch(Events::MULTI_POST_SEND, $postSendEvent = new MultiPostSendEvent($this, $responses));
$exceptions = array_merge($exceptions, $postSendEvent->getExceptions());
$responses = $postSendEvent->getResponses();
}
if (!empty($exceptions)) {
$this->eventDispatcher->dispatch(Events::MULTI_EXCEPTION, $exceptionEvent = new MultiExceptionEvent($this, $exceptions));
$responses = array_merge($responses, $exceptionEvent->getResponses());
$exceptions = $exceptionEvent->getExceptions();
}
foreach ($responses as $response) {
call_user_func($success, $response);
}
foreach ($exceptions as $exception) {
call_user_func($error, $exception);
}
}
/**
* @param SiteEvent $event
*/
public function onSettingUpSite(SiteEvent $event)
{
$drupal = $event->getDrupal();
$this->eventDispatcher->dispatch(WritingSiteSettingsFile::NAME, $settings = new WritingSiteSettingsFile($drupal));
$this->filesystem->mkdir($drupal->getSitePath());
file_put_contents($drupal->getSitePath() . '/settings.php', '<?php ' . $settings->getSettings());
}
/**
* Iterate over two-factor providers and ask for two-factor authentication.
* Each provider can return a response. The first response will be returned.
*
* @param AuthenticationContextInterface $context
*
* @return Response|null
*/
public function requestAuthenticationCode(AuthenticationContextInterface $context)
{
$token = $context->getToken();
// Iterate over two-factor providers and ask for completion
/** @var TwoFactorProviderInterface $provider */
foreach ($this->providers as $providerName => $provider) {
if ($this->flagManager->isNotAuthenticated($providerName, $token)) {
$response = $provider->requestAuthenticationCode($context);
// Set authentication completed
if ($context->isAuthenticated()) {
$this->eventDispatcher->dispatch(TwoFactorAuthenticationEvents::SUCCESS, new TwoFactorAuthenticationEvent());
$this->flagManager->setComplete($providerName, $token);
} else {
if ($context->getRequest()->get($this->authRequestParameter) !== null) {
$this->eventDispatcher->dispatch(TwoFactorAuthenticationEvents::FAILURE, new TwoFactorAuthenticationEvent());
}
}
// Return response
if ($response instanceof Response) {
return $response;
}
}
}
return null;
}
protected function getElement(NodeInterface $node)
{
$this->eventDispatcher->dispatch(Events::preRender($node));
// XML fragment?
if ($node instanceof FragmentInterface) {
return $this->appendXML($node->getNodeValue());
}
// Create
$element = $this->document->createElement($node->getNodeName());
// Value
if ($node->getNodeValue() !== null) {
$element->appendChild($this->document->createTextNode($node->getNodeValue()));
}
// Attributes
foreach ($node->getAttributes() as $name => $value) {
$element->setAttribute($name, $value);
}
// Children
foreach ($node->getChildren() as $child) {
$subelement = $this->getElement($child);
$element->appendChild($subelement);
}
$this->eventDispatcher->dispatch(Events::postRender($node));
return $element;
}
public function load($data)
{
if (!$this->supports($data)) {
throw new \InvalidArgumentException(sprintf('NodeLoader can only handle data implementing NodeInterface, "%s" given.', is_object($data) ? get_class($data) : gettype($data)));
}
$event = new CreateMenuItemFromNodeEvent($data);
$this->dispatcher->dispatch(Events::CREATE_ITEM_FROM_NODE, $event);
if ($event->isSkipNode()) {
if ($data instanceof Menu) {
// create an empty menu root to avoid the knp menu from failing.
return $this->menuFactory->createItem('');
}
return;
}
$item = $event->getItem() ?: $this->menuFactory->createItem($data->getName(), $data->getOptions());
if (empty($item)) {
return;
}
if ($event->isSkipChildren()) {
return $item;
}
foreach ($data->getChildren() as $childNode) {
if ($childNode instanceof NodeInterface) {
$child = $this->load($childNode);
if (!empty($child)) {
$item->addChild($child);
}
}
}
return $item;
}
/**
* Create, configure and build datagrid
*
* @param DatagridConfiguration $config
* @param ParameterBag $parameters
*
* @return DatagridInterface
*/
public function build(DatagridConfiguration $config, ParameterBag $parameters)
{
/**
* @TODO: should be refactored in BAP-6849
*/
$minified = $parameters->get(ParameterBag::MINIFIED_PARAMETERS);
if (is_array($minified) && array_key_exists('g', $minified) && is_array($minified['g'])) {
$gridParams = [];
foreach ($minified['g'] as $gridParamName => $gridParamValue) {
$gridParams[$gridParamName] = $gridParamValue;
}
$parameters->add($gridParams);
}
/**
* @TODO: should be refactored in BAP-6826
*/
$event = new PreBuild($config, $parameters);
$this->eventDispatcher->dispatch(PreBuild::NAME, $event);
$class = $config->offsetGetByPath(self::BASE_DATAGRID_CLASS_PATH, $this->baseDatagridClass);
$name = $config->getName();
/** @var DatagridInterface $datagrid */
$datagrid = new $class($name, $config, $parameters);
$datagrid->setScope($config->offsetGetOr('scope'));
$event = new BuildBefore($datagrid, $config);
$this->eventDispatcher->dispatch(BuildBefore::NAME, $event);
$acceptor = $this->createAcceptor($config, $parameters);
$datagrid->setAcceptor($acceptor);
$this->buildDataSource($datagrid, $config);
$acceptor->processConfiguration();
$event = new BuildAfter($datagrid);
$this->eventDispatcher->dispatch(BuildAfter::NAME, $event);
return $datagrid;
}
/**
* @param PostFlushEventArgs $args
*/
public function postFlush(PostFlushEventArgs $args)
{
foreach ($this->sources as $source) {
$this->dispatcher->dispatch(IoEvents::SOURCE_PROCESS, new SourceEvent($source));
}
$this->sources = [];
}
/**
* Connects to the database.
*
* @return boolean
*/
public function connect()
{
if ($connected = $this->connection->connect()) {
$this->events->dispatch(Events::postConnect, new Event\ConnectionEvent($this));
}
return $connected;
}
/**
* Renders an editor.
*
* @param string $name
* @param string $value
* @param array $attributes
* @param array $parameters
* @return string
*/
public function render($name, $value, array $attributes = [], $parameters = [])
{
if ($editor = $this->events->dispatch('editor.load', new EditorLoadEvent())->getEditor()) {
return $editor->render($value, array_merge($attributes, compact('name')));
}
return __('Editor not found.');
}
/**
* @param GetResponseForExceptionEvent $event
*/
public function onException(GetResponseForExceptionEvent $event)
{
if (!$event->isMasterRequest()) {
return;
}
$this->eventDispatcher->dispatch(Events::REQUEST_ENDS, new RequestEnded($event->getRequest(), $event->getResponse(), $event->getException()));
}
/**
* Transforms an order into an invoice
*
* @param OrderInterface $order
* @param InvoiceInterface $invoice
*/
public function transformFromOrder(OrderInterface $order, InvoiceInterface $invoice)
{
$event = new OrderTransformEvent($order);
$this->eventDispatcher->dispatch(TransformerEvents::PRE_ORDER_TO_INVOICE_TRANSFORM, $event);
$invoice->setName($order->getBillingName());
$invoice->setAddress1($order->getBillingAddress1());
$invoice->setAddress2($order->getBillingAddress2());
$invoice->setAddress3($order->getBillingAddress3());
$invoice->setCity($order->getBillingCity());
$invoice->setCountry($order->getBillingCountryCode());
$invoice->setPostcode($order->getBillingPostcode());
$invoice->setEmail($order->getBillingEmail());
$invoice->setFax($order->getBillingFax());
$invoice->setMobile($order->getBillingMobile());
$invoice->setPhone($order->getBillingPhone());
$invoice->setReference($order->getReference());
$invoice->setCurrency($order->getCurrency());
$invoice->setCustomer($order->getCustomer());
$invoice->setTotalExcl($order->getTotalExcl());
$invoice->setTotalInc($order->getTotalInc());
$invoice->setPaymentMethod($order->getPaymentMethod());
$invoice->setLocale($order->getLocale());
foreach ($order->getOrderElements() as $orderElement) {
$invoiceElement = $this->createInvoiceElementFromOrderElement($orderElement);
$invoiceElement->setInvoice($invoice);
$invoice->addInvoiceElement($invoiceElement);
}
if ($order->getDeliveryCost() > 0) {
$this->addDelivery($invoice, $order);
}
$invoice->setStatus(InvoiceInterface::STATUS_OPEN);
$event = new InvoiceTransformEvent($invoice);
$this->eventDispatcher->dispatch(TransformerEvents::POST_ORDER_TO_INVOICE_TRANSFORM, $event);
}
/**
* This will save the entity to the database as well as
* dispatch the event `bitcoin_wallet.update`
*
* @param BitcoinWallet $wallet
*
* @return BitcoinWallet
*/
public function update(BitcoinWallet $wallet)
{
$this->dispatcher->dispatch('bitcoin_wallet.update', new GenericEvent($wallet));
$this->em->persist($wallet);
$this->em->flush();
return $wallet;
}
public function testShouldDispatchEvents()
{
$notification = Email::create();
$notifyArg = Argument::allOf(Argument::type(Email::class), Argument::that(function ($arg) use($notification) {
return $arg !== $notification;
}));
$handler = $this->prophesize(NotificationHandlerInterface::class);
$handler->getName()->willReturn('default');
$handler->supports(Argument::any())->willReturn(true);
$handler->notify($notifyArg)->willReturn();
$handler2 = $this->prophesize(NotificationHandlerInterface::class);
$handler2->getName()->willReturn('default');
$handler2->supports(Argument::any())->willReturn(true);
$handler2->notify($notifyArg)->willReturn();
$this->dispatcher->dispatch('notifire.pre_notify', Argument::type(PreNotifyEvent::class))->shouldBeCalled();
$this->dispatcher->dispatch('notifire.notify', Argument::that(function ($arg) use($notification) {
if (!$arg instanceof NotifyEvent) {
return false;
}
$not = $arg->getNotification();
return $not !== $notification;
}))->shouldBeCalledTimes(2);
$this->dispatcher->dispatch('notifire.post_notify', Argument::type(PostNotifyEvent::class))->shouldBeCalled();
$this->manager->addHandler($handler->reveal());
$this->manager->addHandler($handler2->reveal());
$this->manager->notify($notification);
}
public function collectRuntimeJavaScripts(CollectAssetsEvent $event, $eventName, EventDispatcherInterface $eventDispatcher)
{
if ($eventName == ThemePlusEvents::COLLECT_HEAD_JAVASCRIPT_ASSETS && $event->getLayout()->theme_plus_default_javascript_position != 'head' || $eventName == ThemePlusEvents::COLLECT_BODY_JAVASCRIPT_ASSETS && $event->getLayout()->theme_plus_default_javascript_position != 'body') {
return;
}
if (is_array($GLOBALS['TL_JAVASCRIPT']) && !empty($GLOBALS['TL_JAVASCRIPT'])) {
foreach ($GLOBALS['TL_JAVASCRIPT'] as $javaScript) {
if ($javaScript instanceof AssetInterface) {
$event->append($javaScript);
} else {
list($javaScript, $mode) = explode('|', $javaScript);
$stripStaticDomainEvent = new StripStaticDomainEvent($event->getRenderMode(), $event->getPage(), $event->getLayout(), $javaScript);
$eventDispatcher->dispatch(ThemePlusEvents::STRIP_STATIC_DOMAIN, $stripStaticDomainEvent);
$javaScript = $stripStaticDomainEvent->getUrl();
$asset = new ExtendedFileAsset(TL_ROOT . '/' . $javaScript, [], TL_ROOT, $javaScript);
$asset->setStandalone($mode != 'static');
$generateAssetPathEvent = new GenerateAssetPathEvent($event->getRenderMode(), $event->getPage(), $event->getLayout(), $asset, $event->getDefaultFilters(), 'js');
$eventDispatcher->dispatch(ThemePlusEvents::GENERATE_ASSET_PATH, $generateAssetPathEvent);
$asset->setTargetPath($generateAssetPathEvent->getPath());
$event->append($asset);
}
}
$GLOBALS['TL_JAVASCRIPT'] = [];
}
}
/**
* @param OrderInterface $order
* @param BasketInterface $basket
*
* @return BasketInterface
*/
public function transformIntoBasket(OrderInterface $order, BasketInterface $basket)
{
$event = new OrderTransformEvent($order);
$this->eventDispatcher->dispatch(TransformerEvents::PRE_ORDER_TO_BASKET_TRANSFORM, $event);
// we reset the current basket
$basket->reset(true);
$basket->setCurrency($order->getCurrency());
$basket->setLocale($order->getLocale());
// We are free to convert !
foreach ($order->getOrderElements() as $orderElement) {
/*
* @var $orderElement OrderElementInterface
*/
$provider = $this->productPool->getProvider($orderElement->getProductType());
$manager = $this->productPool->getManager($orderElement->getProductType());
$product = $manager->findOneBy(array('id' => $orderElement->getProductId()));
if (!$product) {
continue;
}
$basketElement = $provider->createBasketElement($product, $orderElement->getOptions());
$basketElement->setQuantity($orderElement->getQuantity());
$provider->basketAddProduct($basket, $product, $basketElement);
}
$basket->setCustomer($order->getCustomer());
$basket->buildPrices();
$event = new BasketTransformEvent($basket);
$this->eventDispatcher->dispatch(TransformerEvents::POST_ORDER_TO_BASKET_TRANSFORM, $event);
return $basket;
}
/**
* {@inheritdoc}
*
* Override to do a massive save for the products
*/
public function saveAll(array $products, array $options = [])
{
if (empty($products)) {
return;
}
$this->collection = $this->objectManager->getDocumentCollection($this->productClass);
$this->eventDispatcher->dispatch(StorageEvents::PRE_SAVE_ALL, new GenericEvent($products));
$allOptions = $this->optionsResolver->resolveSaveAllOptions($options);
// TODO check the "schedule" options to remove the completeness or not
// TODO manage the "recalculate" options
$productsToInsert = [];
$productsToUpdate = [];
foreach ($products as $product) {
if (null === $product->getId()) {
$productsToInsert[] = $product;
$product->setId($this->mongoFactory->createMongoId());
} else {
$productsToUpdate[] = $product;
}
}
$insertDocs = $this->getDocsFromProducts($productsToInsert);
$updateDocs = $this->getDocsFromProducts($productsToUpdate);
if (count($insertDocs) > 0) {
$this->insertDocuments($insertDocs);
}
if (count($updateDocs) > 0) {
$this->updateDocuments($updateDocs);
}
$this->versionPersister->bulkPersist($products);
$this->eventDispatcher->dispatch(StorageEvents::POST_SAVE_ALL, new GenericEvent($products));
}
/**
* Create, configure and build datagrid
*
* @param DatagridConfiguration $config
*
* @return DatagridInterface
*/
public function build(DatagridConfiguration $config)
{
$class = $config->offsetGetByPath(self::BASE_DATAGRID_CLASS_PATH, $this->baseDatagridClass);
$name = $config->getName();
/** @var Acceptor $acceptor */
$acceptor = new $this->acceptorClass($config);
/** @var DatagridInterface $datagrid */
$datagrid = new $class($name, $acceptor);
$event = new BuildBefore($datagrid, $config);
$this->eventDispatcher->dispatch(BuildBefore::NAME, $event);
// duplicate event dispatch with grid name
$this->eventDispatcher->dispatch(BuildBefore::NAME . '.' . $name, $event);
$this->buildDataSource($datagrid, $config);
foreach ($this->extensions as $extension) {
if ($extension->isApplicable($config)) {
$acceptor->addExtension($extension);
}
}
$acceptor->processConfiguration();
$event = new BuildAfter($datagrid);
$this->eventDispatcher->dispatch(BuildAfter::NAME, $event);
// duplicate event dispatch with grid name
$this->eventDispatcher->dispatch(BuildAfter::NAME . '.' . $name, $event);
return $datagrid;
}
/**
* {@inheritdoc}
*/
public function dispatch($eventName, $eventContext = null)
{
$symfonyEvent = $this->convertResqueEvent($eventContext);
$this->symfonyDispatcher->dispatch($eventName, $symfonyEvent);
// @todo if Resque events ever have mutable context, you would translate the Symfony event changes back
// in to the Resque event here.
}
/**
* GET /order/{orderId}
*
* @param $orderId
*
* @return \Symfony\Component\HttpFoundation\JsonResponse
*/
public function getDetails($orderId)
{
$event = new OrderEvent();
$event->setOrderId($orderId);
$this->eventDispatcher->dispatch(OrderEvent::GET_DETAILS, $event);
return new JsonResponse($event->getOrder());
}
/**
* {@inheritDoc}
*/
public function visitMetadata(DatagridConfiguration $config, MetadataObject $data)
{
$params = $this->getParameters()->get(ParameterBag::ADDITIONAL_PARAMETERS, []);
$currentView = isset($params[self::VIEWS_PARAM_KEY]) ? $params[self::VIEWS_PARAM_KEY] : null;
$data->offsetAddToArray('initialState', ['gridView' => '__all__']);
$data->offsetAddToArray('state', ['gridView' => $currentView]);
$allLabel = null;
if (isset($config['options']) && isset($config['options']['gridViews']) && isset($config['options']['gridViews']['allLabel'])) {
$allLabel = $this->translator->trans($config['options']['gridViews']['allLabel']);
}
/** @var AbstractViewsList $list */
$list = $config->offsetGetOr(self::VIEWS_LIST_KEY, false);
$gridViews = ['choices' => [['label' => $allLabel, 'value' => '__all__']], 'views' => [(new View('__all__'))->getMetadata()]];
if ($list !== false) {
$configuredGridViews = $list->getMetadata();
$configuredGridViews['views'] = array_merge($gridViews['views'], $configuredGridViews['views']);
$configuredGridViews['choices'] = array_merge($gridViews['choices'], $configuredGridViews['choices']);
$gridViews = $configuredGridViews;
}
if ($this->eventDispatcher->hasListeners(GridViewsLoadEvent::EVENT_NAME)) {
$event = new GridViewsLoadEvent($config->getName(), $gridViews);
$this->eventDispatcher->dispatch(GridViewsLoadEvent::EVENT_NAME, $event);
$gridViews = $event->getGridViews();
}
$gridViews['gridName'] = $config->getName();
$gridViews['permissions'] = $this->getPermissions();
$data->offsetSet('gridViews', $gridViews);
}
/**
* {@inheritdoc}
*/
public function matchAll(LineItemInterface $line_item, array $line_items)
{
$purchased_entity = $line_item->getPurchasedEntity();
if (empty($purchased_entity)) {
// Don't support combining line items without a purchased entity.
return [];
}
$comparison_fields = ['type', 'purchased_entity'];
$event = new LineItemComparisonFieldsEvent($comparison_fields, $line_item);
$this->event_dispatcher->dispatch(CartEvents::LINE_ITEM_COMPARISON_FIELDS, $event);
$comparison_fields = $event->getComparisonFields();
$matched_line_items = [];
/** @var \Drupal\commerce_order\Entity\LineItemInterface $existing_line_item */
foreach ($line_items as $existing_line_item) {
foreach ($comparison_fields as $comparison_field) {
if (!$existing_line_item->hasField($comparison_field) || !$line_item->hasField($comparison_field)) {
// The field is missing on one of the line items.
continue 2;
}
if ($existing_line_item->get($comparison_field)->getValue() !== $line_item->get($comparison_field)->getValue()) {
// Line item doesn't match.
continue 2;
}
}
$matched_line_items[] = $existing_line_item;
}
return $matched_line_items;
}
/**
* Attempts to log the authenticated CAS user into Drupal.
*
* This method should be used to login a user after they have successfully
* authenticated with the CAS server.
*
* @param CasPropertyBag $property_bag
* CasPropertyBag containing username and attributes from CAS.
*
* @throws CasLoginException
*/
public function loginToDrupal(CasPropertyBag $property_bag, $ticket)
{
$this->eventDispatcher->dispatch(CasHelper::CAS_PROPERTY_ALTER, new CasPropertyEvent($property_bag));
$account = $this->userLoadByName($property_bag->getUsername());
if (!$account) {
$config = $this->settings->get('cas.settings');
if ($config->get('user_accounts.auto_register') === TRUE) {
if (!$property_bag->getRegisterStatus()) {
$_SESSION['cas_temp_disable'] = TRUE;
throw new CasLoginException("Cannot register user, an event listener denied access.");
}
$account = $this->registerUser($property_bag->getUsername());
} else {
throw new CasLoginException("Cannot login, local Drupal user account does not exist.");
}
}
$this->eventDispatcher->dispatch(CasHelper::CAS_USER_ALTER, new CasUserEvent($account, $property_bag));
$account->save();
if (!$property_bag->getLoginStatus()) {
$_SESSION['cas_temp_disable'] = TRUE;
throw new CasLoginException("Cannot login, an event listener denied access.");
}
$this->userLoginFinalize($account);
$this->storeLoginSessionData($this->sessionManager->getId(), $ticket);
}
/**
* {@inheritdoc}
*/
public function visitResult(DatagridConfiguration $config, ResultsObject $result)
{
$rows = $result->offsetGetByPath('[data]');
if (!is_array($rows)) {
throw new UnexpectedTypeException($rows, 'array');
}
$mappingConfig = $this->mapper->getMappingConfig();
$rows = array_map(function (ResultRecordInterface $record) use($mappingConfig) {
$entityClass = $record->getValue('entityName');
$entityId = $record->getValue('recordId');
$entityConfig = array_key_exists($entityClass, $mappingConfig) ? $entityConfig = $this->mapper->getEntityConfig($entityClass) : [];
return new ResultItem($this->em, $entityClass, $entityId, null, null, $entityConfig);
}, $rows);
$entities = $this->resultFormatter->getResultEntities($rows);
$resultRows = [];
/** @var ResultItem $item */
foreach ($rows as $item) {
$entityClass = $item->getEntityName();
$entityId = $item->getRecordId();
$entity = $entities[$entityClass][$entityId];
$this->dispatcher->dispatch(PrepareResultItemEvent::EVENT_NAME, new PrepareResultItemEvent($item, $entity));
$resultRows[] = new ResultRecord(['entity' => $entity, 'indexer_item' => $item]);
}
$result->offsetSet('data', $resultRows);
}
/**
* Builds the JSON-LD context for the given resource.
*
* @param ResourceInterface|null $resource
*
* @return array
*/
public function getContext(ResourceInterface $resource = null)
{
$context = $this->getBaseContext();
$event = new ContextBuilderEvent($context, $resource);
$this->eventDispatcher->dispatch(Event\Events::CONTEXT_BUILDER, $event);
return $event->getContext();
}
/**
* Returns the image sizes for the given user suitable for widgets.
*
* @param BackendUser $user
*
* @return array
*/
public function getOptionsForUser(BackendUser $user)
{
$this->loadOptions();
$event = new ImageSizesEvent($user->isAdmin ? $this->options : $this->filterOptions(\StringUtil::deserialize($user->imageSizes, true)), $user);
$this->eventDispatcher->dispatch(ContaoCoreEvents::IMAGE_SIZES_USER, $event);
return $event->getImageSizes();
}
/**
* Start the backup.
*
* @return bool
*/
public function execute()
{
$successful = true;
try {
// Dump all databases
$this->databaseManager->dump();
// Backup folders if specified
$this->logger->info('[dizda-backup] Copying folders.');
$this->processorManager->copyFolders();
// Compress everything
$this->logger->info(sprintf('[dizda-backup] Compressing to archive using %s', $this->processorManager->getName()));
$this->processorManager->compress();
// Transfer with all clients
$this->clientManager->upload($this->processorManager->getArchivePath());
} catch (\Exception $e) {
// Write log
$this->logger->critical('[dizda-backup] Unexpected exception.', array('exception' => $e));
$successful = false;
}
try {
// If we catch an exception or not, we would still like to try cleaning up after us
$this->logger->info('[dizda-backup] Cleaning up after us.');
$this->processorManager->cleanUp();
} catch (IOException $e) {
$this->logger->error('[dizda-backup] Cleaning up failed.', array('exception' => $e));
return false;
}
if ($successful) {
$this->eventDispatcher->dispatch(BackupEvent::BACKUP_COMPLETED, new BackupEvent());
}
return $successful;
}
