src/Controller/CalculatorController.php line 234

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\BusinessCardOption;
  6. use App\Entity\Calculator;
  7. use App\Entity\CalculatorProductBusinessCard;
  8. use App\Entity\Imposition;
  9. use App\Entity\Machine;
  10. use App\Entity\MachinePaperSizeMatrix;
  11. use App\Entity\PaperSize;
  12. use App\Entity\Product;
  13. use App\Entity\Task;
  14. use App\Form\CalculatorProductBusinessCardType;
  15. use App\Form\CalculatorSettingsType;
  16. use App\Form\CalculatorType;
  17. use App\Repository\CalculatorProductBusinessCardRepository;
  18. use App\Repository\CalculatorRepository;
  19. use App\Repository\ImpositionRepository;
  20. use App\Repository\MachinePaperSizeMatrixRepository;
  21. use App\Repository\MachineRepository;
  22. use App\Repository\PaperSizeRepository;
  23. use App\Repository\ProductRepository;
  24. use App\Repository\TaskRepository;
  25. use App\Service\BusinessCardCalculator;
  26. use Doctrine\ORM\EntityManagerInterface;
  27. use Knp\Component\Pager\PaginatorInterface;
  28. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  29. use Symfony\Component\HttpFoundation\JsonResponse;
  30. use Symfony\Component\HttpFoundation\Request;
  31. use Symfony\Component\HttpFoundation\Response;
  32. use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
  33. use Symfony\Component\Routing\Annotation\Route;
  34. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  35. use Symfony\Component\Serializer\Encoder\JsonEncoder;
  36. use Symfony\Component\Serializer\Normalizer\ArrayDenormalizer;
  37. use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
  38. use Symfony\Component\Serializer\Serializer;
  40. /**
  41.  * @Route("/admin/calculator")
  42.  */
  43. class CalculatorController extends AbstractController
  44. {
  45.     /**
  46.      * @Route("/", name="calculator_index")
  47.      */
  48.     public function index(CalculatorRepository $calculatorRepository,
  49.                           PaginatorInterface $paginator,Request $request,
  50.                           EntityManagerInterface $em
  51.     ): Response
  52.     {
  54.         //$queryParams = $this->get_params_from_search_query($request);
  56.         $name = trim($request->query->get('name'));
  58.         $query = $calculatorRepository->findBySearchQuery($name);
  60.         //$product = $query->getResult();
  61.         //$products = $productRepository->findAll();
  63.         $pagination = $paginator->paginate(
  64.             $query, /* query NOT result */
  65.             $request->query->getInt('page', 1), /*page number*/
  66.             20, /*limit per page*/
  67.             [
  68.                 'defaultSortFieldName'      => 'c.createdAt',
  69.                 'defaultSortDirection' => 'desc'
  70.             ]
  71.         );
  73.         return $this->render('calculator/index.html.twig', [
  74.             'pagination' => $pagination
  75.         ]);
  77.     }
  80.     /**
  81.      * @Route("/new", name="calculator_new", methods={"GET", "POST"})
  82.      */
  83.     public function new(Request $request, CalculatorRepository $calculatorRepository): Response
  84.     {
  85.         $calculator = new Calculator();
  86.         $form = $this->createForm(CalculatorType::class, $calculator);
  87.         $form->handleRequest($request);
  89.         if ($form->isSubmitted() && $form->isValid()) {
  90.             $calculatorRepository->add($calculator, true);
  92.             return $this->redirectToRoute('app_calculator_index', [], Response::HTTP_SEE_OTHER);
  93.         }
  95.         return $this->renderForm('calculator/new.html.twig', [
  96.             'calculator' => $calculator,
  97.             'form' => $form,
  98.         ]);
  99.     }
  101.     /**
  102.      * @Route("/get_printing_types", name="calculator_get_printing_types", methods={"GET"}, options={"expose"=true})
  103.      */
  104.     public function getPrintingTypes(Request $request, MachineRepository $machineRepository): Response
  105.     {
  106.         $query = $request->query->get('q', '');
  108.         $machines = $machineRepository->findPrintingTypesByNameOrCode($query);
  110.         $results = [];
  111.         foreach ($machines as $machine) {
  112.             /* @var $machine Machine */
  113.             $results['results'][] = [
  114.                 'id' => htmlspecialchars($machine->getId(), \ENT_COMPAT | \ENT_HTML5),
  115.                 'text' => htmlspecialchars('[' . $machine->getCode() . '] ' . $machine->getName(),
  116.                     \ENT_COMPAT | \ENT_HTML5)
  117.             ];
  118.         }
  120.         return $this->json($results);
  121.     }
  123.     /**
  124.      * @Route("/get_machines", name="calculator_get_machines", methods={"GET"}, options={"expose"=true})
  125.      */
  126.     public function getMachines(Request $request, MachineRepository $machineRepository): Response
  127.     {
  128.         $query = $request->query->get('q', '');
  129.         $printingTypeId = $request->query->get('machine_id', '');
  130.         $parentMachine = $machineRepository->find($printingTypeId);
  132.         $machines = $machineRepository->findMachinesByNameOrCode($query, $parentMachine);
  134.         $results = [];
  135.         foreach ($machines as $machine) {
  136.             /* @var Machine $machine */
  137.             $results['results'][] = [
  138.                 'id' => htmlspecialchars($machine->getId(), \ENT_COMPAT | \ENT_HTML5),
  139.                 'text' => htmlspecialchars($machine->getCalculatorDisplayName(),
  140.                     \ENT_COMPAT | \ENT_HTML5)
  141.             ];
  142.         }
  144.         return $this->json($results);
  145.     }
  147.     /**
  148.      * @Route("/get_machine_paper", name="calculator_get_machine_paper", methods={"GET"}, options={"expose"=true})
  150.      */public function get_machine_papers(Request $request, MachineRepository $machineRepository): Response
  151.     {
  152.         $results = [];
  153.         $machineId = $request->query->get('machine_id', '');
  154.         $machine = $machineRepository->find($machineId);
  155.         $paperSizes = $machine->getPaperSizes()->toArray();
  157.         foreach ($paperSizes as $paperSize){
  158.             /* @var PaperSize $paperSize */
  159.             $results['results'][] = [
  160.                 'id' => htmlspecialchars($paperSize->getId(), \ENT_COMPAT | \ENT_HTML5),
  161.                 'text' => htmlspecialchars($paperSize->getCalculatorDisplayName(),
  162.                     \ENT_COMPAT | \ENT_HTML5)
  163.             ];
  164.         }
  166.         return $this->json($results, 200,
  167.             [],
  168.             [
  169.                 'groups' => ['machine']
  170.             ]);
  171.     }
  173.     /**
  174.      * @Route("/get_imposition", name="calculator_get_imposition", methods={"GET"}, options={"expose"=true})
  175.      */
  176.     public function get_imposition(Request $request, ImpositionRepository $impositionRepository): Response
  177.     {
  178.         $results = [];
  179.         $query = $request->query->get('q', '');
  180.         $finishedSizeX = $request->query->get('finished_size_x');
  181.         $finishedSizeY = $request->query->get('finished_size_y');
  183.         $impositions = $impositionRepository->findBy([
  184.             'impositionAcross' => $finishedSizeX,
  185.             'impositionDown' => $finishedSizeY,
  186.         ]);
  189.         foreach ($impositions as $imposition){
  190.             /* @var Imposition $imposition */
  191.             $results['results'][] = [
  192.                 'id' => htmlspecialchars($imposition->getId(), \ENT_COMPAT | \ENT_HTML5),
  193.                 'text' => htmlspecialchars($imposition->getCalculatorDisplayName(),
  194.                     \ENT_COMPAT | \ENT_HTML5)
  195.             ];
  196.         }
  198.         return $this->json($results);
  199.     }
  201.     /**
  202.      * @Route("/get_paper_type", name="calculator_get_paper_type", methods={"GET"}, options={"expose"=true})
  203.      */
  204.     public function get_paper_type(Request $request, PaperSizeRepository $paperSizeRepository, ProductRepository $productRepository): Response
  205.     {
  207.         $results = [];
  209.         $paperSizeId = $request->query->get('paper_size_id');
  210.         $query = $request->query->get('q', '');
  211.         $paperSize = $paperSizeRepository->find($paperSizeId);
  213.         if ($paperSize){
  214.             $products = $productRepository->findPapersBySize($query, $paperSize->getWidth(), $paperSize->getHeight());
  216.             foreach ($products as $product){
  218.                 /* @var Product $product */
  219.                 $results['results'][] = [
  220.                     'id' => htmlspecialchars($product->getId(), \ENT_COMPAT | \ENT_HTML5),
  221.                     'text' => htmlspecialchars($product->getCalculatorPaperDisplayName(),
  222.                         \ENT_COMPAT | \ENT_HTML5)
  223.                 ];
  225.             }
  226.         }
  228.         return $this->json($results);
  229.     }
  231.     /**
  232.      * @Route("/get_task", methods="GET", name="calculator_get_task", options={"expose"=true})
  233.      */
  234.     public function get_task(Request $request, TaskRepository $taskRepository): JsonResponse
  235.     {
  237.         $query = $request->query->get('q', '');
  239.         $tasks = $taskRepository->findByNameOrCode($query);
  241.         $results = [];
  242.         foreach ($tasks as $task) {
  243.             /* @var $task Task */
  244.             $results['results'][] = [
  245.                 'id' => htmlspecialchars($task->getId(), \ENT_COMPAT | \ENT_HTML5),
  246.                 'text' => htmlspecialchars($task->getCalculatorDisplayName(),
  247.                     \ENT_COMPAT | \ENT_HTML5),
  248.                 'name'=> $task->getName(),
  249.                 'code'=> $task->getCode(),
  250.                 'invoice_description' => $task->getInvoiceDescription(),
  251.                 'technical_notes' => $task->getTechnicalNotes()
  252.             ];
  253.         }
  255.         return $this->json($results);
  256.     }
  258.     /**
  259.      * @Route("/get_side_click_labels", name="get_side_click_labels", methods={"GET"}, options={"expose"=true})
  260.      */
  261.     public function get_side_click_labels(Request $request, MachinePaperSizeMatrixRepository $machinePaperSizeMatrixRepositoryRepository
  262.     ): Response
  263.     {
  265.         $results = [];
  267.         $paperSizeId = $request->query->get('paper_size_id');
  268.         $machineId = $request->query->get('machine_id');
  269.         $sideTwo = $request->query->get('side_two');
  271.         /** @var  $machinePaperSizeMatrix MachinePaperSizeMatrix*/
  272.         $machinePaperSizeMatrix = $machinePaperSizeMatrixRepositoryRepository->findOneBy([
  273.             'paperSize' => $paperSizeId,
  274.             'machine' => $machineId
  275.         ]);
  277.         if ($machinePaperSizeMatrix){
  278.             if (!empty($sideTwo) && $sideTwo === 'true'){
  279.                 $results['results'][] = [
  280.                     'id' => 'none',
  281.                     'text' => 'none'
  282.                 ];
  283.             }
  285.             $results['results'][] = [
  286.                 'id' => htmlspecialchars($machinePaperSizeMatrix->getColourClickLabel(), \ENT_COMPAT | \ENT_HTML5),
  287.                 'text' => htmlspecialchars($machinePaperSizeMatrix->getColourClickLabel(),
  288.                     \ENT_COMPAT | \ENT_HTML5)
  289.             ];
  291.             $results['results'][] = [
  292.                 'id' => htmlspecialchars($machinePaperSizeMatrix->getBlackOnlyClickLabel(), \ENT_COMPAT | \ENT_HTML5),
  293.                 'text' => htmlspecialchars($machinePaperSizeMatrix->getBlackOnlyClickLabel(),
  294.                     \ENT_COMPAT | \ENT_HTML5)
  295.             ];
  296.         }
  298.         return $this->json($results);
  299.     }
  301.     /**
  302.      * @Route("/{id}", name="app_calculator_show", methods={"GET"})
  303.      */
  304.     public function show(Calculator $calculator): Response
  305.     {
  306.         return $this->render('calculator/show.html.twig', [
  307.             'calculator' => $calculator,
  308.         ]);
  309.     }
  311.     /**
  312.      * @Route("/{id}/edit", name="calculator_edit", methods={"GET", "POST"})
  313.      */
  314.     public function edit(Request $request, Calculator $calculator, CalculatorRepository $calculatorRepository): Response
  315.     {
  316.         $form = $this->createForm(CalculatorType::class, $calculator);
  317.         $form->handleRequest($request);
  319.         if ($form->isSubmitted() && $form->isValid()) {
  320.             //$calculatorRepository->add($calculator, true);
  322.             return $this->redirectToRoute('calculator_index', [], Response::HTTP_SEE_OTHER);
  323.         }
  325.         $template = $calculator->getTemplate();
  327.         return $this->renderForm(empty($template)?'calculator/edit.html.twig':'calculator/'.$template, [
  328.             'calculator' => $calculator,
  329.             'form' => $form,
  330.         ]);
  331.     }
  333.     /**
  334.      * @Route("/{id}", name="calculator_delete", methods={"POST"})
  335.      */
  336.     public function delete(Request $request, Calculator $calculator, CalculatorRepository $calculatorRepository): Response
  337.     {
  338.         if ($this->isCsrfTokenValid('delete'.$calculator->getId(), $request->request->get('_token'))) {
  339.             $calculatorRepository->remove($calculator, true);
  340.         }
  342.         return $this->redirectToRoute('calculator_index', [], Response::HTTP_SEE_OTHER);
  343.     }
  345.     /**
  346.      * @Route("/{id}/settings", name="calculator_settings", methods={"GET", "POST"})
  347.      */
  348.     public function settings(Request $request, Calculator $calculator, CalculatorRepository $calculatorRepository): Response
  349.     {
  350.         $form = $this->createForm(CalculatorSettingsType::class, $calculator);
  351.         $form->handleRequest($request);
  353.         if ($form->isSubmitted() && $form->isValid()) {
  354.             $calculatorRepository->add($calculator, true);
  355.             $this->addFlash('success', 'Calculator updated.');
  356.             return $this->redirectToRoute('calculator_settings', ['id' => $calculator->getId()], Response::HTTP_SEE_OTHER);
  357.         }
  359.         $template = $calculator->getTemplate();
  361.         return $this->renderForm('calculator/settings.html.twig', [
  362.             'calculator' => $calculator,
  363.             'form' => $form,
  364.         ]);
  365.     }
  367.     /**
  368.      * @Route("/{id}/calculate", name="calculate", methods={"POST"})
  369.      */
  370.     public function calculate(Request $request, Calculator $calculator, BusinessCardCalculator $calculatorHelper
  371.                                           ): Response
  372.     {
  373.         $result = [
  374.             'result' => 'Error',
  375.             'html' => '<p>Error</>'
  376.         ];
  377.         //Get all data
  378.         $data = $request->request->all();
  379.         //Business card
  380.         if ($calculator->getId() == 1 ){
  381.             $result = $calculatorHelper->getPricing($data, $calculator);
  383.             return $this->json([
  384.                 'result' => $result,
  385.                 'html' => $this->renderView('calculator/business_card_calculator_result.html.twig', [
  386.                     'pricing' => $result
  387.                 ])
  388.             ]);
  389.         }elseif($calculator->getId() == 2 ){
  392.             $result = $calculatorHelper->getOptionPricing($data, $calculator);
  394.             return $this->json([
  395.                 'result' => $result,
  396.                 'html' => $this->renderView('calculator/business_card_calculator_result.html.twig', [
  397.                     'pricing' => $result
  398.                 ])
  399.             ]);
  400.         }
  402.         return $this->json($result);
  404.     }
  406.     /**
  407.      * @Route("/{id}/show", name="calculator_show", methods={"GET", "POST"})
  408.      */
  409.     public function showCalculator(Request $request, Calculator $calculator,
  410.     CalculatorRepository $calculatorRepository, BusinessCardCalculator $calculatorHelper,
  411.     CalculatorProductBusinessCardRepository $bcRepository
  412.     ): Response
  413.     {
  414.         $form = $this->createForm(CalculatorType::class, $calculator);
  416.         //Business card
  417.         if ($calculator->getId() == 2 ){
  418.             $calculatorProductBusinessCard = new CalculatorProductBusinessCard();
  419.             $calculatorProductBusinessCard->setCalculator($calculator);
  420.             $form = $this->createForm(CalculatorProductBusinessCardType::class, $calculatorProductBusinessCard,['testing' => true]);
  421.         }
  423.         $form->handleRequest($request);
  425.         if ($form->isSubmitted() ) {
  426.             $formData = $form->getData();
  427.             //get product code.
  428.             /*$formData->getPrintingType();*/
  429.             //Business card prefix
  430.             $productCode = $calculatorHelper->getProductCode($formData);
  432.             if ($form->getClickedButton() && 'saveAndAddBtn' === $form->getClickedButton()->getName()) {
  433.                 //Save as new cal
  434.                 /* @var $calculatorProductBusinessCard CalculatorProductBusinessCard */
  435.                 $calculatorProductBusinessCard = new CalculatorProductBusinessCard();
  436.                 $calculatorProductBusinessCard = $form->getData();
  437.                 $calculatorProductBusinessCard->setName('test');
  438.                 $calculatorProductBusinessCard->setCode('test '.time());
  439.                 $bcRepository->add($calculatorProductBusinessCard, true);
  441.                 /*try{
  442.                     $calculatorHelper->denormalizeBusinessCardProduct($calculatorProductBusinessCard, $formData);
  443.                 }catch (\Exception $exception){
  444.                     return $this->json(['result' => 'error']);
  445.                 }*/
  447.                 $this->addFlash('success', 'Calculator: '.$calculatorProductBusinessCard->getCode().' created.');
  448.                 return $this->redirectToRoute('calculator_product_business_card_show',
  449.                     ['id' => $calculatorProductBusinessCard->getId()], Response::HTTP_SEE_OTHER);
  450.             }
  452.             //Calculate Only
  453.             if ($form->get('calculateBtnClicked')->getData() == '1'){
  454.                 $result = $calculatorHelper->getOptionPricing($form->getData(), $calculator);
  456.                 return $this->json([
  457.                     'result' => $result,
  458.                     'productCode' => $productCode,
  459.                     'html' => $this->renderView('calculator/business_card_calculator_result.html.twig', [
  460.                         'pricing' => $result
  461.                     ])
  462.                 ]);
  463.             }
  465.             return $this->redirectToRoute('calculator_index', [], Response::HTTP_SEE_OTHER);
  466.         }
  468.         $template = $calculator->getTemplate();
  470.         return $this->renderForm(empty($template)?'calculator/edit.html.twig':$template, [
  471.             'calculator' => $calculator,
  472.             'form' => $form,
  473.         ]);
  474.     }
  476.     /**
  477.      * @Route("/show/calculator_product_business_card/{product_id}",
  478.      *     name="calculator_show_calculator_product_business_card", methods={"GET", "POST"})
  479.      *@ParamConverter("product", options={"id" = "product_id"})
  480.      */
  481.     function showCalculatorProductBusinessCard(Request $request,
  482.         CalculatorProductBusinessCard $product): Response
  483.     {
  485.         $form = $this->createForm(CalculatorProductBusinessCardType::class, $product);
  486.         $calculator = $product->getCalculator();
  489.         return $this->renderForm('calculator/calculator_product_business_card.html.twig', [
  490.             'calculator' => $calculator,
  491.             'product' => $product,
  492.             'form' => $form,
  493.         ]);
  494.     }
  496.     /**
  497.      * @Route("/show/calculator_product_business_card_test/{product_id}",
  498.      *      name="calculator_show_calculator_product_business_card_test", methods={"GET", "POST"})
  499.      * @ParamConverter("product", options={"id" = "product_id"})
  500.      * @param CalculatorProductBusinessCard $product
  501.      * @param BusinessCardCalculator $calculatorHelper
  502.      * @return Response
  503.      */
  504.     function showCalculatorProductBusinessCardTest(
  505.        CalculatorProductBusinessCard $product, BusinessCardCalculator $calculatorHelper): Response
  506.     {
  507.         $calculator = $product->getCalculator();
  509.         $result = $calculatorHelper->getOptionPricing($product, $calculator);
  511.         return $this->render('calculator/business_card_calculator_result_test.html.twig', [
  512.             'pricing' => $result
  513.         ]);
  514.     }
  516.     /**
  517.      * @Route("/calculator_product_business_card/create",name="create_calculator_product_business_card", methods={"POST"})
  518.      * @param Request $request
  519.      * @return JsonResponse
  520.      */
  521.     function createCalculatorProductBusinessCard(Request $request): JsonResponse
  522.     {
  523.         $data = $request->request->all();
  524.         return $this->json(['result' => 'test']);
  525.     }
  527.     /**
  528.      * @Route("/calculator_product_business_card/save/{product_id}",
  529.      *      name="save_calculator_product_business_card", methods={"POST"})
  530.      * @ParamConverter("product", options={"id" = "product_id"})
  531.      * @param Request $request
  532.      * @param CalculatorProductBusinessCard $product
  533.      * @param BusinessCardCalculator $businessCardCalculator
  534.      * @param EntityManagerInterface $entityManager
  535.      * @return JsonResponse
  536.      */
  537.     function saveCalculatorBusinessCard(Request $request, CalculatorProductBusinessCard $product,
  538.             BusinessCardCalculator $businessCardCalculator, EntityManagerInterface $entityManager
  540.         ): JsonResponse
  541.     {
  543.         //Get all data
  544.         $data = $request->request->all();
  546.         $product = $businessCardCalculator->denormalizeBusinessCardProduct($product, $data);
  550.         return $this->json(['result' => 'saved']);
  552.     }
  555. }