/** * @param Request $request * @return \Symfony\Component\HttpFoundation\Response * @throws \Exception */ public function __invoke(Request $request) { $user = $this->getUser(); if (!$user) { throw $this->createAccessDeniedException(); } $createWalletCommand = $this->createCreateWalletCommand(); $createWalletForm = $this->walletFormFactory->createCreateForm($createWalletCommand); $createWalletForm->handleRequest($request); if (!$createWalletForm->isValid()) { $validationMsg = $this->getAllFormErrorMessagesAsString($createWalletForm); $this->addFlash('error', $this->trans('create_transaction_form.flash.invalid_form') . ' ' . $validationMsg); } else { /** @var CreateWalletCommand $createWalletCommand */ $createWalletCommand = $createWalletForm->getData(); $createWalletCommand->setWalletOwnerId($user->getId()->getValue()); $createWalletCommand->setToken($user->getBlockCypherToken()); try { $commandValidator = new CreateWalletCommandValidator(); $commandValidator->validate($createWalletCommand); $this->commandBus->handle($createWalletCommand); $this->addFlash('success', $this->trans('wallet.flash.create_successfully')); $url = $this->router->generate('bc_app_wallet_wallet.index'); return new RedirectResponse($url); } catch (\Exception $e) { $this->addFlash('error', $e->getMessage()); } } return $this->renderWalletShowNew($request, $createWalletForm->createView()); }
/** * @param Request $request * @return Response * @throws \Exception */ public function __invoke(Request $request) { $walletId = $request->get('walletId'); $walletDto = $this->walletServiceFacade->getWallet($walletId); $this->checkAuthorizationForWallet($walletDto); $createTransactionCommand = $this->createCreateTransactionCommand($walletId); $user = $this->getUser(); $createTransactionForm = $this->transactionFormFactory->createCreateForm($createTransactionCommand, $user->getId()->getValue()); $createTransactionForm->handleRequest($request); if (!$createTransactionForm->isValid()) { $validationMsg = $this->getAllFormErrorMessagesAsString($createTransactionForm); $this->addFlash('error', $this->trans('create_transaction_form.flash.invalid_form') . ' ' . $validationMsg); } else { /** @var CreateTransactionCommand $createTransactionCommand */ $createTransactionCommand = $createTransactionForm->getData(); try { $commandValidator = new CreateTransactionCommandValidator(); $commandValidator->validate($createTransactionCommand); $this->commandBus->handle($createTransactionCommand); $this->addFlash('success', $this->trans('transaction.flash.create_successfully')); $url = $this->router->generate('bc_app_wallet_transaction.index', array('walletId' => $createTransactionCommand->getWalletId())); return new RedirectResponse($url); } catch (\Exception $e) { $this->addFlash('error', $e->getMessage()); } } $walletDto = $this->walletServiceFacade->getWallet($walletId); return $this->renderTransactionShowNew($request, $createTransactionForm->createView(), $walletDto); }
/** * @param LogicInterface $logic * @param array $parameters * * @return mixed * @throws \Exception */ public function handle(LogicInterface $logic, $parameters) { if (count($logic->getRules()) > 0) { foreach ($logic->getRules() as $rule) { $result = $this->language->evaluate($rule->getExpression(), $parameters); foreach ($rule->getActions() as $action) { if ($result == $action->getResult()) { switch ($action->getType()) { case ActionInterface::EXCEPTION: throw new \Exception($action->getParameter()); break; case ActionInterface::COMMAND: $command = $this->createCommand($action, $parameters); $this->commandBus->handle($command); break; case ActionInterface::EVENT: $event = $this->createEvent($action, $parameters); $this->eventBus->handle($event); break; default: throw new \Exception("Unkown type"); break; } } } } } }
public function orderAction($id) { $query = new GetOrderByIdQuery($id); $this->queryBus->handle($query); if (!$this->checker->isGranted('read', $query->getResult())) { throw new AccessDeniedException(); } return new Response($this->engine->render(':order:order.html.twig', ['order' => $query->getResult()])); }
/** * @param string $serializedEnvelope */ public function consume($serializedEnvelope) { // Unserialize $envelope = $this->messageInEnvelopeSerializer->unwrapAndDeserialize($serializedEnvelope); // Tell the world $this->dispathcer->dispatch(PreHandleMessage::NAME, new PreHandleMessage($envelope)); // Handle the message $this->messageBus->handle($envelope->message()); }
public function updateProfile(UpdateProfileCommand $command) { $user = $this->getActualUser(); $address = $command->getAddress(); $user->changeAddress(new Address($address->getCountry(), $address->getCity(), $address->getStreet(), $address->getZipCode())); $this->repository->save($user); $event = new ProfileUpdatedEvent($user); $this->eventBus->handle($event); }
public function verifyRequest(VerifyRequestCommand $command) { $token = $this->requestVerifier->verify($command->getRequest()); $gateway = $this->registry->getGateway($token->getGatewayName()); $gateway->execute($status = new GetHumanStatus($token)); $payment = $status->getFirstModel(); $this->requestVerifier->invalidate($token); $event = new RequestVerifiedEvent($status, $payment); $this->eventBus->handle($event); }
/** * @param \Psr\Http\Message\ServerRequestInterface $request * @param \Slim\Http\Response $response * * @return \Slim\Http\Response * @throws \livetyping\hermitage\app\exceptions\BadRequestException */ public function __invoke(Request $request, Response $response) : Response { $mime = (string) current($request->getHeader('Content-Type')); $binary = (string) $request->getBody(); if (empty($mime) || empty($binary) || !in_array($mime, Util::supportedMimeTypes())) { throw new BadRequestException('Invalid mime-type or body.'); } $command = new StoreImageCommand($mime, $binary); $this->bus->handle($command); return $response->withStatus(201)->withJson(['filename' => $command->getPath()]); }
/** * @Route("/dodaj", name="pracownik.dodaj") * @Template() * * @param Request $request * @return array */ public function dodajAction(Request $request) { $form = $this->createForm(PracownikType::class, $this->dodajPracownikaCommand); $form->handleRequest($request); if ($form->isValid()) { $this->commandBus->handle($this->dodajPracownikaCommand); $this->unitOfWork->commit(); return new RefererRedirectResponse($request); } return ['form' => $form->createView()]; }
public function registerAction(Request $request) { $form = $this->formFactory->create('Shop\\Presentation\\Form\\UserType'); $form->handleRequest($request); if ($form->isValid() && $form->isSubmitted()) { $command = $form->getData(); $this->commandBus->handle($command); return new RedirectResponse('/'); } return new Response($this->engine->render(':security:register.html.twig', ['form' => $form->createView()])); }
/** * @param object $message * @param callable $next */ public function handle($message, callable $next) { $this->logger->debug('NotifiesDomainEvents calls next before collect events'); $next($message); $events = $this->collectsEventsFromEntities->recordedMessages(); $this->collectsEventsFromEntities->eraseMessages(); $this->logger->debug('NotifiesDomainEvents notifies ' . count($events) . ' events'); foreach ($events as $event) { $this->eventBus->handle($event); } }
public function run() { try { $requestWithParsedBody = $this->requestBodyParser->enrichRequestWithParsedBody($this->requestKnowledge->getRequest()); $this->requestKnowledge->setRequest($requestWithParsedBody); $command = $this->router->getCommand(); $this->commandBus->handle($command); } catch (HttpException $e) { $this->exceptionHandler->handle($e); } }
/** * @param MessageBus $commandBus * @param PersistentMessage $command * @param PersistentCommandRepository $commandRepository */ protected function handleCommandAndAssertTraced(MessageBus $commandBus, PersistentMessage $command, PersistentCommandRepository $commandRepository) { $commandBus->handle($command); $this->assertInstanceOf(Identity::class, $command->getId()); $foundCommand = $commandRepository->get($command->getId()); $this->assertSame($command, $foundCommand); if (!$command instanceof TraceableCommand) { $this->fail(sprintf('The message %s is not Traceable', get_class($command))); } $this->assertInstanceOf(Trace::class, $trace = $command->getTrace()); $this->assertInstanceOf(Context::class, $trace->getContext()); }
public function handle($message, callable $next) { try { $next($message); } catch (Exception $exception) { $this->messageRecorder->eraseMessages(); throw $exception; } $recordedMessages = $this->messageRecorder->recordedMessages(); $this->messageRecorder->eraseMessages(); foreach ($recordedMessages as $recordedMessage) { $this->messageBus->handle($recordedMessage); } }
public function createOrder(CreateOrderCommand $command) { $cart = $this->cartRepository->getCart(); if ($cart->getLineItems()->count() === 0) { throw new \RuntimeException("The cart is empty"); } $address = $command->getAddress(); $order = new Order(new UuidIdentity(Uuid::uuid4()), $this->tokenStorage->getToken()->getUser(), new Address($address->getCountry(), $address->getCity(), $address->getStreet(), $address->getZipCode())); foreach ($cart->getLineItems() as $lineItem) { $order->addProduct($lineItem->getProduct(), $lineItem->getQuantity()); } $this->orderRepository->save($order); $event = new OrderCreatedEvent($order, $command->getGatewayName()); $this->eventBus->handle($event); }
/** * Shoot the create dojo command into the command bus * * @param $externalDojo */ private function createDojo($externalDojo) { $this->progressBar->setMessage('Creating new dojo'); $this->commandBus->handle($externalDojo); $this->progressBar->advance(); $this->countNew++; }
public function handleChangeUserEmail(ChangeUserEmail $changeUserEmail) { $user = $this->userManager->find($changeUserEmail->userId()); $oldEmail = $user->getEmail(); $newEmail = $changeUserEmail->newEmail(); // perform action only if email address has changed if (false === $newEmail->equals($oldEmail)) { $user->setEmail($changeUserEmail->newEmail()); // normally we would call something like: // $this->userManager->save($user); // but we are changing in-memory value // notify subscribers using specific event $changedUserEmailEvent = new ChangedUserEmail($changeUserEmail->userId(), $oldEmail, $newEmail); $this->eventBus->handle($changedUserEmailEvent); } }
private function getCategoryById($id) { if ($id) { $query = new GetCategoryByIdQuery($id); if ($query->getId()) { $this->queryBus->handle($query); } return $query->getResult(); } return null; }
/** * Post a new search request * * @ApiDoc( * parameters={ * { * "name"="queryString", * "dataType"="string", * "format"="non-empty string", * "required"=true, * "description"="Search string" * } * }, * requirements={ * { * "name"="_format", * "dataType"="string", * "requirement"="json|xml", * "description"="Response format" * } * }, * ) * * @param Request $request * @return array * @View() */ public function postSearchAction(Request $request) { $queryString = $request->request->get('queryString', ''); // Check if the queryString is not empty if (!empty($queryString)) { $command = new SaveSearchRequestCommand($queryString); $this->commandBus->handle($command); return $this->getResultsAction($queryString); } throw new BadRequestHttpException('You must provide a (non empty) query string'); }
public function viewAction($id, Request $request) { $query = new GetProductByIdQuery($id); $this->queryBus->handle($query); /** @var ProductView $product */ $product = $query->getResult(); $command = new UpdateProductCommand($product->getId(), $product->getName(), $product->getPrice(), $product->getCategory()->getId(), $product->getDescription(), $product->isAvailable(), $product->getImageUrl()); $command->setProductOptions(array_map(function (ProductOptionView $optionView) { $productOption = new ProductOption(); $productOption->setOption($optionView->getOption()->getId()); $productOption->setValue($optionView->getValue()); return $productOption; }, $product->getProductOptions())); $form = $this->formFactory->create('Shop\\Presentation\\Form\\ProductType', $command); $form->handleRequest($request); if ($form->isSubmitted() && $form->isValid()) { $this->commandBus->handle($command); return new RedirectResponse($this->router->generate('admin_product', ['id' => $command->getId()])); } return new Response($this->engine->render(':admin/product:form.html.twig', ['form' => $form->createView()])); }
public function updateProduct(UpdateProductCommand $command) { $product = $this->repository->findByIdentity(new UuidIdentity($command->getId())); $category = $this->categoryRepository->findByIdentity(new UuidIdentity($command->getCategory())); $product->updateInfo($command->getName(), new Money($command->getPrice()), $category, $command->getDescription(), $command->isAvailable(), $command->getImageUrl()); $productOptions = $command->getProductOptions(); foreach ($product->getProductOptions() as $key => $productOption) { if (isset($productOptions[$key])) { $productOption->changeValue($productOptions[$key]->getValue()); unset($productOptions[$key]); } else { $product->getProductOptions()->remove($key); } } foreach ($productOptions as $productOption) { $option = $this->optionRepository->getReference(new UuidIdentity($productOption->getOption())); $product->addOption($option, $productOption->getValue()); } $this->repository->save($product); $event = new ProductSavedEvent($product); $this->eventBus->handle($event); }
/** * @param string $filename * * @throws \livetyping\hermitage\foundation\exceptions\ImageNotFoundException */ protected function makeVersion(string $filename) { $original = Util::original($filename); $command = new MakeImageVersionCommand($original, Util::version($filename)); $this->bus->handle($command); }
public function navAction() { $query = new GetCartQuery(); $this->queryBus->handle($query); return new Response($this->engine->render(':profile:nav.html.twig', ['cart' => $query->getResult()])); }
public function removeProductAction($id) { $command = new RemoveProductCommand($id); $this->commandBus->handle($command); return new Response('', Response::HTTP_NO_CONTENT); }
public function consume($serializedEnvelope) { $envelope = $this->messageInEnvelopeSerializer->unwrapAndDeserialize($serializedEnvelope); $this->messageBus->handle($envelope->message()); }
/** * @param string $filename * @param \Psr\Http\Message\ServerRequestInterface $request * @param \Psr\Http\Message\ResponseInterface $response * * @return \Psr\Http\Message\ResponseInterface * @throws \livetyping\hermitage\foundation\exceptions\ImageNotFoundException */ public function __invoke(string $filename, Request $request, Response $response) : Response { $command = new DeleteImageCommand($filename); $this->bus->handle($command); return $response->withStatus(204); }
public function doneAction(Request $request) { $command = new VerifyRequestCommand($request); $this->commandBus->handle($command); return new RedirectResponse($this->router->generate('homepage')); }
public function run(OutputInterface $output) { $output->writeln('**********************************'); $output->writeln('Starting sync for Events'); $progressbar = $this->newProgressBar($output); $zenIds = $this->doctrine->getRepository('CoderDojoWebsiteBundle:Dojo')->getZenIds(); $externalEvents = $this->zen->getEvents($zenIds); $progressbar->start(count($externalEvents)); $progressbar->setMessage('Iterating Events...'); $countNew = 0; $countUpdated = 0; $countNoMatch = 0; foreach ($externalEvents as $externalEvent) { $progressbar->setMessage('Handling ' . $externalEvent->getName()); $internalEvent = $this->doctrine->getRepository('CoderDojoWebsiteBundle:DojoEvent')->findOneBy(['zenId' => $externalEvent->getZenId()]); /** @var Dojo $dojo */ $internalDojo = $this->doctrine->getRepository('CoderDojoWebsiteBundle:Dojo')->findOneBy(['zenId' => $externalEvent->getZenDojoId()]); if (null === $internalDojo) { $progressbar->setMessage('No internal dojo found!'); $progressbar->advance(); $countNoMatch++; continue; } if (null === $internalEvent) { $progressbar->setMessage('No internal event found'); $command = new CreateEventCommand($internalDojo->getId(), $externalEvent->getName(), $externalEvent->getStartTime(), $internalDojo->getZenUrl(), $externalEvent->getZenId(), DojoEvent::TYPE_ZEN); $this->commandBus->handle($command); $progressbar->advance(); $countNew++; } else { $progressbar->setMessage('Internal event found'); $internalEvent->setName($externalEvent->getName()); $internalEvent->setDate($externalEvent->getStartTime()); $internalEvent->setUrl($internalDojo->getZenUrl()); $progressbar->advance(); $countUpdated++; } } $progressbar->setMessage('Flushing'); $this->doctrine->flush(); $progressbar->setMessage('Finished syncing Events!'); $progressbar->finish(); $output->writeln($countNew . ' New events added'); $output->writeln($countUpdated . ' Existing events updated'); $output->writeln($countNoMatch . ' events could not be matched with a dojo'); $message = "Zen synchronizer just handled events."; $attachments = []; $attachment = new Attachment(); $attachment->setFallback($countNew . " events added."); $attachment->setText($countNew . " events added."); $attachment->setColor('good'); $attachments[] = $attachment; $attachment = new Attachment(); $attachment->setFallback($countUpdated . " events updated."); $attachment->setText($countUpdated . " events updated."); $attachment->setColor('warning'); $attachments[] = $attachment; $attachment = new Attachment(); $attachment->setFallback($countNoMatch . " events not matched."); $attachment->setText($countNoMatch . " events not matched."); $attachment->setColor('danger'); $attachments[] = $attachment; $this->slackService->sendToChannel('#website-nl', $message, $attachments); }
function it_handles_a_command(MessageBus $messageBus, $command) { $messageBus->handle($command)->shouldBeCalled(); $this->handle($command); }