src/Controller/OrderController.php line 723

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Company;
  6. use App\Entity\File\Contract;
  7. use App\Entity\File\DigiSign;
  8. use App\Entity\File\File;
  9. use App\Entity\File\Signi;
  10. use App\Entity\File\SimpleFile;
  11. use App\Entity\Order;
  12. use App\Entity\OrderEshop;
  13. use App\Entity\Product;
  14. use App\Entity\User;
  15. use App\Exception\FulltextSearchNullResults;
  16. use App\Form\Filter\OrderFilterType;
  17. use App\Form\OrderType;
  18. use App\Helper\EnumsHelper;
  19. use App\Model\FileModel;
  20. use App\Model\RewardLineModel;
  21. use App\Model\RewardModel;
  22. use App\Model\UserModel;
  23. use App\Repository\FileRepository;
  24. use App\Repository\OrderRepository;
  25. use App\Repository\ProductRepository;
  26. use App\Repository\UserRepository;
  27. use App\Security\Voter\OrderVoter;
  28. use App\Services\GalosoftAdamna;
  29. use App\Services\GalosoftDigiSign;
  30. use App\Services\GalosoftDigiSignGenerator;
  31. use App\Services\GalosoftMailerInterface;
  32. use App\Services\GalosoftNotifications;
  33. use App\Services\GalosoftPdfGenerator;
  34. use App\Services\GalosoftRaynet;
  35. use App\Services\GalosoftSigni;
  36. use App\Services\GalosoftSigniGenerator;
  37. use App\Services\GalosoftValuablePaperGenerator;
  38. use App\Services\OrderFilter;
  39. use App\Services\OrdersExporter;
  40. use Doctrine\ORM\EntityManagerInterface;
  41. use Knp\Component\Pager\PaginatorInterface;
  42. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  43. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security;
  44. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  45. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  46. use Symfony\Component\HttpFoundation\JsonResponse;
  47. use Symfony\Component\HttpFoundation\Request;
  48. use Symfony\Component\HttpFoundation\Response;
  49. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  50. use Symfony\Component\HttpFoundation\Session\Session;
  51. use Symfony\Component\HttpFoundation\StreamedResponse;
  52. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  53. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  54. use Symfony\Component\Routing\Annotation\Route;
  56. /**
  57.  *
  58.  */
  59. class OrderController extends AbstractController
  60. {
  61.     /**
  62.      * @isGranted("ROLE_MERCHANT")
  63.      * @Route("/order", name="app_order_index", methods={"GET", "POST"})
  64.      */
  65.     public function index(FileRepository $repository,
  66.                           OrderRepository $orderRepository,
  67.                           Request $request,
  68.                           PaginatorInterface $paginator,
  69.                           GalosoftSigni $galosoftSigni,
  70.                           Session $session,
  71.                           EntityManagerInterface $entityManager,
  72.                           OrderFilter $orderFilter,
  73.                           UserModel $userModel,
  74.                           \Symfony\Component\Security\Core\Security $security
  75.     ): Response
  76.     {
  77.         // clear filter
  78.         if($orderFilter->clearFilter($session, $request) == true){
  79.             return $this->redirect($this->generateUrl('app_order_index'));
  80.         }
  82.         // ulozeni strankovace
  83.         $paginationSettings = $orderFilter->storePaginationSettings($session, $request);
  85.         // predvyplneni formulare filtrace
  86.         $data = $orderFilter->loadPrefilledData($session, $entityManager);
  87.         $formFilter = $this->createForm(OrderFilterType::class, $data, [
  88.             'action' => $this->generateUrl('app_order_index'),
  89.             'method' => 'post',
  90.             'request' => $request,
  91.         ]);
  93.         // ulozim filtr do session
  94.         $orderFilter->storeFilter($formFilter, $request, $session);
  96.         // aplikace filtru na query builder
  97.         $queryBuilder = $orderRepository->createQueryBuilder('o');
  98.         try {
  99.             $orders = $orderFilter->applyFilter($session, $request, $queryBuilder, $paginator);
  100.         }catch (FulltextSearchNullResults $e){
  101.             $orders = [];
  102.         }
  104.         return $this->render('order/index.html.twig', [
  105.             'orders' => $orders,
  106.             'filter' => $formFilter->createView(),
  107.             'ordering' => $paginationSettings['ordering'],
  108.             'pageSize' => $paginationSettings['pageSize'],
  109.             'isOnlyMetalist' => $orderRepository->isOnlyMetalist()
  110.         ]);
  111.     }
  113.     /**
  114.      * @Route("/order/export/{type}", name="app_order_export", methods={"GET"})
  115.      */
  116.     public function export(
  117.         OrderRepository $orderRepository,
  118.         Session $session,
  119.         Request $request,
  120.         OrderFilter $orderFilter,
  121.         OrdersExporter $ordersExporter,
  122.         $type = 'csv'
  123.     ){
  124.         $queryBuilder = $orderRepository->createQueryBuilder('o');
  125.         $orders = $orderFilter->applyFilter($session, $request, $queryBuilder);
  127.         $response = match ($type) {
  128.             // default 'csv'  => $ordersExporter->exportToCSV($orders->getQuery()->getResult()),
  129.             'xlsx' => $ordersExporter->exportToXlsx($orders->getQuery()->getResult()),
  130.             default => $ordersExporter->exportToCSV($orders->getQuery()->getResult()),
  131.         };
  133.         return $response;
  134.     }
  136.     /**
  137.      * @IsGranted("ROLE_ADMIN")
  138.      *
  139.      * @Route("/order/report/{type}", name="app_order_report", methods={"GET"})
  140.      */
  141.     public function report(
  142.         OrderRepository $orderRepository,
  143.         Session $session,
  144.         Request $request,
  145.         OrderFilter $orderFilter,
  146.         RewardModel $rewardModel,
  147.         OrdersExporter $ordersExporter,
  148.         $type = 'csv'
  149.     ){
  150.         $queryBuilder = $orderRepository->createQueryBuilder('o');
  151.         $orders = $orderFilter->applyFilter($session, $request, $queryBuilder);
  152.         $rewards = $rewardModel->byOrderList($orders->getQuery()->getResult());
  154.         $response = match ($type) {
  155.             // default 'csv'  => $ordersExporter->exportToCSV($orders->getQuery()->getResult()),
  156.             'xlsx' => $ordersExporter->reportToXlsx($rewards),
  157.             default => $ordersExporter->reportToCSV($rewards),
  158.         };
  160.         return $response;
  161.     }
  163.     /**
  164.      * @Route("/order/new", name="app_order_new", methods={"GET", "POST"})
  165.      */
  166.     public function new(Request $request, OrderRepository $orderRepository): Response
  167.     {
  168.         $order = new Order();
  169.         $currentPersonType = $order->getPersonType();
  170.         if(is_null($currentPersonType)){
  171.             $order->setPersonType('FO');
  172.         }
  173.         $options = [
  174.             'action' => $this->generateUrl('app_order_new_process'),
  175.             'method' => 'post',
  176.             'logged_user' => $this->getUser()
  177.         ];
  178.         $form = $this->createForm(OrderType::class, $order, $options);
  179.         $form->handleRequest($request);
  181.         return $this->render('order/new.html.twig', [
  182.             'form' => $form->createView(),
  183.             'product' => $order->getProduct(),
  184.             'reloadUrl' => $this->generateUrl('app_order_new')
  185.         ]);
  186.     }
  188.     /**
  189.      * @Route("/order/{hash}/preview", name="app_order_preview")
  190.      */
  191.     public function previewPdf(
  192.         Request $request,
  193.         $hash,
  194.         OrderRepository $orderRepository,
  195.         EntityManagerInterface $entityManager,
  196.         GalosoftPdfGenerator $pdfGenerator
  197.     ){
  198.         $order = $orderRepository->findOneBy(['hash' => $hash]);
  199.         if(!$order){
  200.             throw new NotFoundHttpException('Objednávka nenalezena');
  201.         }
  203.         $pdf = $pdfGenerator->generatePdf($order, false);
  205.         $response = new StreamedResponse(function() use ($pdf) {
  206.             $outputStream = fopen('php://output', 'wb');
  207.             $fileStream = fopen($pdf->getUrlDel(), 'r+');
  208.             stream_copy_to_stream($fileStream, $outputStream);
  209.         });
  211.         $response->headers->set('Content-Type', $pdf->getMime());
  213.         return $response;
  214.     }
  217.     /**
  218.      * @Route("/order/{order}", name="app_order_detail", requirements={"order"="\d+"})
  219.      */
  220.     public function detail(Order $order, UserModel $userModel, \Symfony\Component\Security\Core\Security $security): Response
  221.     {
  222.         $this->denyAccessUnlessGranted(OrderVoter::NOT_ANONYMIZE, $order);
  224.         return $this->render('order/view.html.twig', [
  225.             'order' => $order,
  226.             'isOrderMetalist' => $order instanceof OrderEshop
  227.         ]);
  228.     }
  231.     /**
  232.      * @Route("/order/{order}/sequence-number", name="app_order_save_sequence_number", requirements={"order"="\d+"})
  233.      */
  234.     public function saveSequenceNumber(
  235.         Request $request,
  236.         Order $order,
  237.         EntityManagerInterface $entityManager
  238.     ): Response
  239.     {
  240.         try {
  241.             //TODO: Add checking access for admin only
  242.             //$this->denyAccessUnlessGranted(OrderVoter::VIEW, $order);
  244.             $sequenceNumber = $request->get('sequenceNumber', null);
  245.             if (!is_null($sequenceNumber)) {
  246.                 $order->setSequenceNumber($sequenceNumber);
  248.                 $entityManager->flush();
  249.             }
  251.             return $this->json(['status' => 'success']);
  252.         } catch (\Exception $exception) {
  253.             return $this->json(['status' => 'error', 'message' => $exception->getMessage()]);
  254.         }
  255.     }
  257.     /**
  258.      * @Route("/order/{order}/valuable-paper/generate", name="app_order_valuable_paper_generate", requirements={"order"="\d+"})
  259.      */
  260.     public function generateValuablePaper(
  261.         Request $request,
  262.         Order $order,
  263.         EntityManagerInterface $entityManager,
  264.         GalosoftValuablePaperGenerator $galosoftValuablePaperGenerator
  265.     ): Response
  266.     {
  267.         try {
  268.             //TODO: Add checking access for admin only
  269.             //$this->denyAccessUnlessGranted(OrderVoter::VIEW, $order);
  271.             // generate and save valuable paper
  272.             $galosoftValuablePaperGenerator->generatePdf($order);
  273.             // generate and save valuable paper
  274.             $galosoftValuablePaperGenerator->generatePdf($order, true, GalosoftValuablePaperGenerator::TYPE_PDF_VALUABLE_PROTOCOL);
  276.             return $this->forward(OrderController::class . '::detail', [
  277.                 'order' => $order->getId()
  278.             ]);
  279.         } catch (\Exception $exception) {
  280.             return $this->json(['status' => 'error', 'message' => $exception->getMessage()]);
  281.         }
  282.     }
  284.     /**
  285.      * @Route("/order/{order}/edit", name="app_order_edit", requirements={"order"="\d+"})
  286.      */
  287.     public function show(Order $order): Response
  288.     {
  289.         $this->denyAccessUnlessGranted(OrderVoter::EDIT, $order);
  291.         $form = $this->createForm(OrderType::class, $order, [
  292.             'action' => $this->generateUrl('app_order_edit_process', ['order' => $order->getId()]),
  293.             'method' => 'post',
  294.             'edit_entity' => true,
  295.             'logged_user' => $this->getUser()
  296.         ]);
  298.         return $this->render('order/new.html.twig', [
  299.             'form' => $form->createView(),
  300.             'product' => $order->getProduct(),
  301.             'reloadUrl' => $this->generateUrl('app_order_new')
  302.         ]);
  303.     }
  305.     /**
  306.      * To complete data from api
  307.      *
  308.      * @Route("/dokonceni-objednavky/{hash}", name="app_order_complete")
  309.      */
  310.     public function complete(Request $request, $hash, OrderRepository $orderRepository, ProductRepository $productRepository): Response
  311.     {
  312.         $order = $orderRepository->findOneBy(['hash' => $hash]);
  313.         $now = new \DateTime('now');
  315.         if(!$order || $now > $order->getApiValidTill()){
  316.             return $this->render('errors/404.html.twig',
  317.             [
  318.                 'title' => 'Ouha! Objednávku se nepodařilo najít!',
  319.                 'description' => 'Požadovaná objednávka nebyla nalezena nebo expirovala její platnost. <br /> Pokud máte dotazy ozvěte se nám prosím na email <a href="objednavky@efsgroup.cz">objednavky@efsgroup.cz</a>.'
  320.             ]);
  321.         }
  323.         $currentPersonType = $order->getPersonType();
  324.         if(is_null($currentPersonType)){
  325.             $order->setPersonType('FO');
  326.         }
  327.         if(isset($request->get('order')['product'])
  328.             && (int)$request->get('order')['product'] != $order->getProduct()->getId()
  329.         ){
  330.             // pri zmene produktu, aby se spravne renderoval formular tj. dependece atd. vlozim do objednavky novy
  331.             // produkt jiz ted a ne az skrze handlerequest
  332.             $formSentProduct = $productRepository->findOneBy(['id' => $request->get('order')['product']]);
  333.             if(false == is_null($formSentProduct)){
  334.                 $order->setProduct($formSentProduct);
  335.                 // array data from request
  336.                 $requestOrder = $request->get('order');
  337.                 $requestOrder['company'] = $formSentProduct->getCompany()->getId();
  338.                 $request->request->set('order', $requestOrder);
  339.             }
  340.             //$order->setCompany($formSentProduct->getCompany());
  341.         }
  343.         $form = $this->createForm(OrderType::class, $order, [
  344.             'action' => $this->generateUrl('app_order_edit_process', ['order' => $order->getId()]),
  345.             'method' => 'post',
  346.             'edit_entity' => true,
  347.             'api_call' => true,
  348.             'api_complete' => true,
  349.             'logged_user' => $this->getUser()
  350.         ]);
  351.         $form->handleRequest($request);
  353.         return $this->render('order/new.html.twig', [
  354.             'form' => $form->createView(),
  355.             'completeOrder' => true,
  356.             'product' => $order->getProduct(),
  357.             'reloadUrl' => $this->generateUrl('app_order_complete', ['hash' => $hash]),
  358.         ]);
  359.     }
  362.     /**
  363.      * @Route("/order/new/process", name="app_order_new_process", methods={"POST"})
  364.      * @Route("/order/{order}/edit/process", name="app_order_edit_process", methods={"POST"})
  365.      */
  366.     public function saveProcess(
  367.         Request $request,
  368.         OrderRepository $orderRepository,
  369.         Order $order = null,
  370.         GalosoftPdfGenerator $pdfGenerator,
  371.         GalosoftSigniGenerator $signiGenerator,
  372.         GalosoftSigni $signi,
  373.         EntityManagerInterface $entityManager,
  374.         UserPasswordHasherInterface $userPasswordHasher,
  375.         GalosoftMailerInterface $galosoftMailer,
  376.         UserRepository $userRepository,
  377.         GalosoftRaynet $galosoftRaynet,
  378.         GalosoftDigiSignGenerator $digiSignGenerator,
  379.         GalosoftDigiSign $digiSign,
  380.         GalosoftAdamna $galosoftAdamna
  381.     ): Response
  382.     {
  383.         $orderEnt = is_null($order) ? new Order() : $order;
  384.         $orderData = $request->request->get('order');
  385.         if(isset($orderData['api_call']) && $orderData['api_call'] == "1") {
  386.             $orderOriginal = clone $order;
  387.         }
  389.         $form = $this->createForm(OrderType::class, $orderEnt, [
  390.             'edit_entity' => is_null($order) === false,
  391.             'allow_extra_fields' => true,
  392.             'logged_user' => $this->getUser()
  393.         ]);
  396.         $form->handleRequest($request);
  398.         // vratim do puvodni podoby disabled data
  399.         if(isset($orderData['api_call']) && $orderData['api_call'] == "1") {
  400.             $orderEnt->setUser($orderOriginal->getUser())
  401.                 ->setMerchant($orderOriginal->getMerchant())
  402.                 ->setMerchantCode($orderOriginal->getMerchantCode())
  403.                 ->setCompany($orderOriginal->getCompany());
  404.         }
  407.         if ($form->isSubmitted() && $form->isValid()) {
  409.             //try {
  410.                 $formOwnAggreements = $request->request->get('ownAgreements', []);
  411.                 $productOwnAgreements = $order->getProduct()->getOwnAgreementsFiles();
  412.                 $ownAgreementsForOrder = [];
  413.                 // pokud mame nastavene souhlasy v objednavce a na produktu provedeme sparovani a priradime dane labely
  414.                 foreach ($productOwnAgreements as $productOwnAgreement) {
  415.                     $oneOwn = [];
  416.                     // jedna se o checkbox, budeme zaznamenavat true/false
  417.                     if ($productOwnAgreement->isRequired()) {
  418.                         if ($productOwnAgreement->getFileType() == 'link' || $productOwnAgreement->getFileType() == 'file') {
  419.                             $oneOwn['label'] = $productOwnAgreement->getName();
  420.                             $oneOwn['consent'] = (bool)array_key_exists($productOwnAgreement->getId(), (array)$formOwnAggreements);
  421.                         } else {
  422.                             $oneOwn['label'] = $productOwnAgreement->getHtmlText();
  423.                             $oneOwn['consent'] = (bool)array_key_exists($productOwnAgreement->getId(), (array)$formOwnAggreements);
  424.                         }
  425.                         $ownAgreementsForOrder[] = $oneOwn;
  426.                     }
  427.                 }
  428.                 $orderEnt->setOwnAgreements($ownAgreementsForOrder);
  429. //            }catch (\Exception $exception){
  430. //
  431. //            }
  433.             $genSigni = @isset($request->request->get('order', [])['generateSigni']) ? @$request->request->get('order', [])['generateSigni'] : false;
  434.             $genPdf = @isset($request->request->get('order', [])['generatePdf']) ? @$request->request->get('order', [])['generatePdf'] : false;
  435.             $genDigiSign = @isset($request->request->get('order', [])['generateDigiSign']) ? @$request->request->get('order', [])['generateDigiSign'] : false;
  436.             $pdfPreview = true; // vzdycky generujeme pdf pro nahled
  437.             $genRaynet = $orderEnt->getProduct()->isGeneratorRaynet();
  438.             $genAdamna = $orderEnt->getProduct()->isUseAdamna();
  440.             $what = '';
  441.             if((boolean)$genPdf == true){
  442.                 $what .= 'p';
  443.             }
  444.             if((boolean)$genSigni == true){
  445.                 $what .= 's';
  446.             }
  447.             if((boolean)$genDigiSign == true){
  448.                 $what .= 'd';
  449.             }
  450.             if((boolean)$genRaynet == true){
  451.                 $what .= 'r';
  452.             }
  453.             if((boolean)$genAdamna == true){
  454.                 $what .= 'a';
  455.             }
  457.             $targetUrl = $this->generateUrl('app_order_index');
  458.             if(isset($orderData['api_call']) && $orderData['api_call'] == "1") {
  459.                 $orderEnt->setWhatGenerated($what);
  460.                 $orderEnt->setReinvest((bool)$orderData['reinvest']);
  462.                 $targetUrl = $this->generateUrl('app_order_thankyou', [
  463.                     'hash' => $orderEnt->getHash()
  464.                 ]);
  465.             }
  467.             try {
  468.                 if($orderEnt->getUser() == null){
  469.                     $alreadyStored = $userRepository->findOneBy(['email' => $orderEnt->getEmail()]);
  470.                     if(is_null($alreadyStored)) {
  471.                         $user = new User();
  472.                         $user->setEmail($orderEnt->getEmail())
  473.                             ->setActive(false)
  474.                             ->setIsVerified(false)
  475.                             ->setRoles(['ROLE_CUSTOMER'])
  476.                             ->setName($orderEnt->getName())
  477.                             ->setSurname($orderEnt->getSurname())
  478.                             ->setPassword($userPasswordHasher->hashPassword(
  479.                                 $user,
  480.                                 substr(md5(rand(10000, 999999999)), 0, 8)
  481.                             ));
  482.                         $entityManager->persist($user);
  483.                     }else{
  484.                         $user = $alreadyStored;
  485.                     }
  487.                     $orderEnt->setUser($user);
  488.                 }
  490.                 $orderRepository->store($orderEnt, true);
  492.                 if((boolean)$pdfPreview === true && $genPdf == false && $genSigni == false && $genDigiSign == false){
  493.                     return $this->json([
  494.                         'status' => 'success',
  495.                         'previewUrl' => $this->generateUrl('app_order_preview', [
  496.                             'hash' => $order->getHash()
  497.                         ])
  498.                     ]);
  499.                 }
  501.                 if ((boolean)$genPdf === true) {
  502.                     $pdf = $pdfGenerator->generatePdf($orderEnt);
  503.                     $pdfData = base64_encode(file_get_contents($pdf->getUrlDel()));
  504.                     $filename = str_replace(['.docx', '.json'], '', $pdf->getName()). ".pdf";
  505.                     if($request->get('preview', null) == "1"){
  506.                         // jedna se o preview, vracim pdfko
  507.                         return $this->json([
  508.                             'status' => 'success',
  509.                             'previewUrl' => $this->generateUrl('app_order_preview', [
  510.                                 'hash' => $order->getHash()
  511.                             ])
  512.                         ]);
  513.                     }
  515.                     if(isset($orderData['api_call']) && $orderData['api_call'] == "1") {
  516.                         // posilame soubor na email - pouze v pripade ze se jedna o prichod z emailu - tj. api_call == 1
  517.                         $galosoftMailer->send([
  518.                             "template_id" => "d-a0b8f951e1af4fa4b73e5682fd2cc5b2",
  519.                             "from" => array(
  520.                                 "name" => "EFS",
  521.                                 "email" => "info@efsgroup.cz"
  522.                             ),
  523.                             "personalizations" => array(
  524.                                 array(
  525.                                     "dynamic_template_data" => [
  526.                                         "product" => $order->getProduct()->getName(),
  527.                                         "company" => $order->getProduct()->getCompany()->getName()
  528.                                     ],
  529.                                     "to" => array(
  530.                                         array(
  531.                                             "email" => $orderEnt->getEmail()
  532.                                         ),
  533.                                     )
  534.                                 )
  535.                             ),
  536.                             "attachments" => [
  537.                                 [
  538.                                     "content" => $pdfData,
  539.                                     "type" => $pdf->getMime(),
  540.                                     "filename" => $filename
  541.                                 ]
  542.                           ]
  543.                         ]);
  544.                     }
  545.                 }
  547.                 if ((boolean)$genSigni === true && $orderEnt->getProduct()->isGeneratorSigni()) {
  548.                     $signiContract = $signiGenerator->generateSigni($orderEnt, false);
  550.                     $result = $signi->signContract($signiContract);
  552.                     if($result !== false) {
  553.                         $entityManager->flush();
  554.                     }else{
  555.                         throw new \Exception("Chyba při komunikaci se Signi.com");
  556.                     }
  557.                 }
  559.                 if ((boolean)$genDigiSign === true) {
  560.                     /** @var DigiSign $digiSignContract - Vygeneruje pdf, nasledne vytvorime obalku a posleme do digisignu */
  561.                     $digiSignContract = $digiSignGenerator->generateDigiSign($orderEnt, false);
  563.                     $result = $digiSign->send($digiSignContract->getEnvelopeId());
  565.                     if($result !== false && $result['title'] != 'Validation Failed') {
  566.                         $entityManager->flush();
  567.                     }else{
  568.                         throw new \Exception("Chyba při komunikaci se Digisign.org (".$result['detail'].")");
  569.                     }
  570.                 }
  572.                 if ((boolean)$genRaynet === true) {
  573.                     $result = $galosoftRaynet->sendContract($orderEnt);
  574.                     if($result instanceof \stdClass && $result->success != 'true'){
  575.                         throw new \Exception($result->message);
  576.                     }
  577.                 }
  579.                 if ((boolean)$genAdamna === true) {
  580.                     $result = $galosoftAdamna->sendContract($orderEnt);
  581.                     if($result instanceof \stdClass && $result->status != 'true'){
  582.                         throw new \Exception($result->message);
  583.                     }
  584.                 }
  586.                 $entityManager->flush();
  588.                 return $this->json([
  589.                     'status' => 'success',
  590.                     'target_url' => $targetUrl
  591.                 ]);
  592.             } catch (\Exception $exception) {
  593.                 return $this->json([
  594.                     'status' => 'error',
  595.                     'msg' => $exception->getMessage()
  596.                 ]);
  597.             }
  598.         } else {
  599.             return $this->json([
  600.                 'status' => 'error',
  601.                 'msg' => (string)$form->getErrors(true, false)
  602.             ]);
  603.         }
  604.     }
  606.     /**
  607.      * @Route("/dokonceni-objednavky/{hash}/dekujeme", name="app_order_thankyou", methods={"GET"})
  608.      */
  609.     public function thankyou($hash, OrderRepository $orderRepository)
  610.     {
  611.         $order = $orderRepository->findOneBy(['hash' => $hash]);
  612.         if(!$order){
  613.             throw new NotFoundHttpException('Objednávka nenalezena');
  614.         }
  616.         $what = $order->getWhatGenerated();
  618.         return $this->render('order/thankyou.html.twig', [
  619.             'what' => $what
  620.         ]);
  621.     }
  623.     /**
  624.      * @Route("/order/{order}/delete", name="app_order_delete", methods={"POST"}, requirements={"order"="\d+"})
  625.      */
  626.     public function delete(Request $request,
  627.                         Order $order,
  628.                         OrderRepository $orderRepository,
  629.                         FileRepository $fileRepository,
  630.                         EntityManagerInterface $entityManager
  631.     ): Response
  632.     {
  633.         try {
  634.             $this->denyAccessUnlessGranted(OrderVoter::DELETE, $order);
  636.             $files = $order->getFiles();
  637.             foreach ($files as $file){
  638.                 $fileRepository->remove($file);
  639.             }
  640.             $orderRepository->remove($order, true);
  641.             $entityManager->flush();
  643.             return $this->json([
  644.                 'status' => 'success'
  645.             ]);
  646.         } catch (\Exception $e) {
  647.             return $this->json([
  648.                 'status' => 'error',
  649.                 'msg' => $e->getMessage()
  650.             ]);
  651.         }
  652.     }
  654.     /**
  655.      * @Route("/order/{order}/state/{state}/date/{datechange}/{onoff}/", name="app_change_order_state", methods={"POST", "GET"}, requirements={"order"="\d+", "state"="inprogress|paid|sent|signed|paid2|paid3|transfer|vpDelivery"})
  656.      */
  657.     public function changeState(Order $order, $state, $datechange, $onoff, EntityManagerInterface $entityManager): Response
  658.     {
  659.         try {
  660.             if($datechange == 'now'){
  661.                 $date = new \DateTime('now');
  662.             }else {
  663.                 $date = \DateTime::createFromFormat('d.m.Y', $datechange);
  664.             }
  666.             if(filter_var($onoff, FILTER_VALIDATE_BOOLEAN) == false){
  667.                 $date = null;
  668.             }
  670.             switch ($state){
  671.                 case "inprogress":
  672.                     $order->setInProgress(filter_var($onoff, FILTER_VALIDATE_BOOLEAN))
  673.                         ->setInProgressDate($date);
  674.                     break;
  675.                 case "paid":
  676.                     $order->setPaid(filter_var($onoff, FILTER_VALIDATE_BOOLEAN))
  677.                         ->setPaidDate($date);
  678.                     break;
  679.                 case "paid2":
  680.                     $order->setPaid2(filter_var($onoff, FILTER_VALIDATE_BOOLEAN))
  681.                         ->setPaidDate2($date);
  682.                     break;
  683.                 case "paid3":
  684.                     $order->setPaid3(filter_var($onoff, FILTER_VALIDATE_BOOLEAN))
  685.                         ->setPaidDate3($date);
  686.                     break;
  687.                 case "transfer":
  688.                     $order->setTransfer(filter_var($onoff, FILTER_VALIDATE_BOOLEAN))
  689.                         ->setTransferDate($date);
  690.                     break;
  691.                 case "signed":
  692.                     $order->setSigned(filter_var($onoff, FILTER_VALIDATE_BOOLEAN));
  693.                     $order->setSignedDate($date);
  694.                     break;
  695.                 case "vpDelivery":
  696.                     $order->setVpDelivery(filter_var($onoff, FILTER_VALIDATE_BOOLEAN));
  697.                     $order->setVpDeliveryDate($date);
  698.                     break;
  699.                 case "sent":
  700.                     $order->setSent(filter_var($onoff, FILTER_VALIDATE_BOOLEAN))
  701.                         ->setSentDate($date);
  702.                     break;
  703.                 default:
  704.                     throw new \Exception('Nepovoleny stav');
  705.             }
  707.             $entityManager->flush();
  709.             return $this->json([
  710.                 'status' => 'success'
  711.             ]);
  712.         } catch (\Exception $e) {
  713.             return $this->json([
  714.                 'status' => 'error',
  715.                 'msg' => $e->getMessage()
  716.             ]);
  717.         }
  718.     }
  720.     /**
  721.      * @Route("/order/{order}/{file}/delete", name="app_order_file_delete", methods={"GET"}, requirements={"file"="\d+", "order"="\d+"})
  722.      */
  723.     public function deleteFile(
  724.         Request $request,
  725.         Order $order,
  726.         File $file,
  727.         FileRepository $fileRepository
  728.     ): Response
  729.     {
  730.         try {
  731.             $this->denyAccessUnlessGranted(OrderVoter::DELETE, $order);
  733.             $fileRepository->remove($file, true);
  735.             return $this->render('order/view.html.twig', [
  736.                 'order' => $order,
  737.                 'isOrderMetalist' => $order instanceof OrderEshop
  738.             ]);
  740.         } catch (\Exception $e) {
  741.             return new JsonResponse(['statue' => 'error', 'msg' => $e->getMessage()]);
  742.         }
  743.     }
  745.     /**
  746.      * @Route("/order/download/digisign/{digiSign}/{output}", name="app_order_file_download_digisign", requirements={"digiSign"="\d+","output"="combined|only_log"})
  747.      * @param DigiSign $digiSign
  748.      */
  749.     public function downloadDigiSign($digiSign, $output, GalosoftDigiSign $galosoftDigiSign, FileRepository $fileRepository)
  750.     {
  751.         $digiSignFile = $fileRepository->findOneBy(['id' => $digiSign]);
  753.         if(!$digiSignFile){
  754.             exit('Chyba aplikace');
  755.         }
  757.         $galosoftDigiSign->authenticate($digiSignFile->getProduct());
  758.         $data = $galosoftDigiSign->download($digiSignFile->getEnvelopeId(), $output);
  760.         // Vytvořte odpověď prohlížeče jako PDF soubor
  761.         $response = new Response($data);
  762.         $response->headers->set('Content-Type', 'application/pdf');
  763.         $response->headers->set('Content-Disposition', 'attachment; filename="'.$digiSignFile->getName().'.pdf"'); // Nastavte název souboru
  765.         // Odpověď odeslat
  766.         return $response;
  767.     }
  770.     /**
  771.      * @Route("/order/download/signi/{signi}", name="app_order_file_download_signi", requirements={"signi"="\d+"})
  772.      * @param Signi $signi
  773.      */
  774.     public function downloadSigni(Signi $signi, GalosoftSigni $galosoftSigni)
  775.     {
  776.         // TODO: Check rights or is owner
  777.         $filePath = $galosoftSigni->downloadSigniContract($signi);
  778.         $pdfData = file_get_contents($filePath);
  779.         $response = new Response($pdfData, 200, [
  780.             'Content-Length' => strlen($pdfData),
  781.             'Content-type' => 'application/pdf',
  782.             'Content-Transfer-Encoding' => 'binary'
  783.         ]);
  785.         $filename = str_replace(['.docx', '.json'], '', $signi->getName()). ".pdf";
  786.         $filenameFallback = preg_replace(
  787.             '#^.*\.#',
  788.             md5($filename) . '.', $filename
  789.         );
  790.         $disposition = $response->headers->makeDisposition(
  791.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  792.             $filename,
  793.             $filenameFallback
  794.         );
  795.         $response->headers->set('Content-Disposition', $disposition);
  797.         return $response;
  798.     }
  801.     /**
  802.      * @Route("/order/download/signicl/{signi}", name="app_order_file_download_signi_cl", requirements={"signi"="\d+"})
  803.      * @param Signi $signi
  804.      */
  805.     public function downloadSigniControlList(Signi $signi, GalosoftSigni $galosoftSigni)
  806.     {
  807.         // TODO: Check rights or is owner
  808.         $filePath = $galosoftSigni->downloadControlList($signi);
  809.         $pdfData = file_get_contents($filePath);
  810.         $response = new Response($pdfData, 200, [
  811.             'Content-Length' => strlen($pdfData),
  812.             'Content-type' => 'application/pdf',
  813.             'Content-Transfer-Encoding' => 'binary'
  814.         ]);
  816.         $order = $signi->getOrderEnt();
  817.         preg_match("/v\.([0-9]+)\.docx/", $signi->getName(), $parsedVersion);
  818.         $version = isset($parsedVersion[1]) ?  " v." .$parsedVersion[1] : "";
  819.         $filename = "Kontrolní list digitálního podpisu ke smlouvě č." . $order->getId() . $version. ".pdf";
  820.         $filenameFallback = preg_replace(
  821.             '#^.*\.#',
  822.             md5($filename) . '.', $filename
  823.         );
  824.         $disposition = $response->headers->makeDisposition(
  825.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  826.             $filename,
  827.             $filenameFallback
  828.         );
  829.         $response->headers->set('Content-Disposition', $disposition);
  831.         return $response;
  832.     }
  834.     /**
  835.      * @Route("/order/{id}/uploadchunk/", name="app_order_uploadefilechunk")
  836.      * @param Request $request
  837.      * @return string
  838.      */
  839.     public function uploadChunkFile(Request $request, Order $order, FileModel $fileModel){
  840.         try {
  841.             $fileModel->uploadChunkFile($request, $order);
  843.             return new JsonResponse(array(
  844.                 "success" => true
  845.             ));
  846.         } catch (Exception $e) {
  847.             return new JsonResponse(array(
  848.                 "success" => false,
  849.                 "error" => $e->getMessage()
  850.             ));
  851.         }
  852.     }
  855.     /**
  856.      * @Route("/order/{id}/upload/", name="app_order_uploadefile")
  857.      * @param Request $request
  858.      * @return string
  859.      */
  860.     public function uploadeFile(
  861.         Request $request,
  862.         EntityManagerInterface $em,
  863.         Order $order,
  864.         FileModel $fileModel,
  865.         GalosoftNotifications $galosoftNotifications
  866.     ){
  867.         try {
  868.             $result = $fileModel->uploadOrderFile($request, $order);
  870.             $simpleFile = new SimpleFile();
  871.             $simpleFile->setName($result['fileName'])
  872.                 ->setMime($result['mimeType'])
  873.                 ->setUrl($result['url'])
  874.                 ->setUrlDel($result['urlDel'])
  875.                 ->setSize($result['size'])
  876.                 ->setOrderEnt($order)
  877.                 ->setProduct($order->getProduct())
  878.                 ->setVersion('1.0')
  879.             ;
  880.             $em->persist($simpleFile);
  881.             $em->flush();
  883.             //$galosoftNotifications->manualUpload($order);
  885.             if(is_string($result['cmd'])){
  886.                 $cmd = $result['cmd'];
  887.             }else{
  888.                 $cmd = implode(" ", $result['cmd']);
  889.             }
  891.             return $this->json([
  892.                 "success" => true,
  893.                 "origName" => $result['origName'],
  894.                 "slug" => $result['slug'],
  895.                 "name" => $result['name'],
  896.                 "type" => $result['type'],
  897.                 "cmd" => $cmd,
  898.                 "out" => $result['out']
  899.             ]);
  900.         }catch (\Exception $exception){
  901.             return $this->json([
  902.                 "success" => false,
  903.                 "error" => $exception->getMessage(),
  904.                 "preventRetry" => false
  905.             ]);
  906.         }
  907.     }
  909.     /**
  910.      * @Route("/order/download/file/{file}", name="app_order_file_download", requirements={"file"="\d+"})
  911.      * @param File $file
  912.      */
  913.     public function downloadFile(File $file)
  914.     {
  915.         $fileData = file_get_contents($file->getUrlDel());
  916.         $response = new Response($fileData, 200, [
  917.             'Content-Length' => strlen($fileData),
  918.             'Content-type' => $file->getMime(),
  919.             'Content-Transfer-Encoding' => 'binary'
  920.         ]);
  922.         $filename = $file->getName();
  923.         $filenameFallback = preg_replace(
  924.             '#^.*\.#',
  925.             md5($filename) . '.', $filename
  926.         );
  927.         $disposition = $response->headers->makeDisposition(
  928.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  929.             $filename,
  930.             $filenameFallback
  931.         );
  932.         $response->headers->set('Content-Disposition', $disposition);
  934.         return $response;
  935.     }
  937.     /**
  938.      * @Route("/order/download/pdf/{file}", name="app_order_file_download_file", requirements={"file"="\d+"})
  939.      * @param File $file
  940.      */
  941.     public function downloadPdf(File $file, GalosoftSigni $galosoftSigni)
  942.     {
  943.         // TODO: Check rights or is owner
  944.         $pdfData = file_get_contents($file->getUrlDel());
  945.         $response = new Response($pdfData, 200, [
  946.             'Content-Length' => strlen($pdfData),
  947.             'Content-type' => 'application/pdf',
  948.             'Content-Transfer-Encoding' => 'binary'
  949.         ]);
  951.         $filename = str_replace(['.docx', '.json'], '', $file->getName()) . ".pdf";
  952.         $filenameFallback = preg_replace(
  953.             '#^.*\.#',
  954.             md5($filename) . '.', $filename
  955.         );
  956.         $disposition = $response->headers->makeDisposition(
  957.             ResponseHeaderBag::DISPOSITION_ATTACHMENT,
  958.             $filename,
  959.             $filenameFallback
  960.         );
  961.         $response->headers->set('Content-Disposition', $disposition);
  963.         return $response;
  964.     }
  965. }