src/Controller/Api/ExerciseController.php line 195

Open in your IDE?
  1. <?php
  2. namespace App\Controller\Api;
  3. use App\Entity\Category;
  4. use App\Entity\Material;
  5. use App\Entity\Customer;
  6. use App\Entity\Exercise;
  7. use App\Entity\ExerciseCalendar;
  8. use App\Entity\ExerciseQualification;
  9. use App\Entity\ExerciseTranslation;
  10. use App\Entity\ExerciseUser;
  11. use App\Entity\PlayerJustification;
  12. use App\Entity\TrainingAsist;
  13. use App\Services\Api\ExerciseManager;
  14. use DateTime;
  15. use Doctrine\ORM\EntityManagerInterface;
  16. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  17. use Symfony\Component\HttpFoundation\JsonResponse;
  18. use Symfony\Component\HttpFoundation\Request;
  19. use Symfony\Component\Routing\Annotation\Route;
  20. use Symfony\Component\Validator\Constraints\Date;
  21. use Symfony\Contracts\Translation\TranslatorInterface;
  22. class ExerciseController extends ApiController
  23. {
  24.   /** @var ExerciseManager $exerciseManager */
  25.   protected $exerciseManager;
  26.   /**
  27.    * @param ExerciseManager $exerciseManager
  28.    */
  29.   public function __construct(EntityManagerInterface $emParameterBagInterface $parameterBagExerciseManager $exerciseManager)
  30.   {
  31.     parent::__construct($em$parameterBag);
  32.     $this->exerciseManager $exerciseManager;
  33.   }
  34.   /**
  35.    * @param Request $request
  36.    * @return JsonResponse
  37.    *
  38.    * @Route("/exercise/list", name="api_exercise_list", methods={"POST"})
  39.    */
  40.   public function listExercise(Request $request)
  41.   {
  42.     $request $this->transformJsonBody($request);
  43.     $exercises = [];
  44.     $prefixFile $this->getParameter("app.path.exercise_images");
  45.     $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  46.     /** @var Customer $customer */
  47.     $customer $this->getUser();
  48.     $season $customer->getSeasonActive();
  49.     if (!empty($season)) {
  50.       $exercises_user $this->em->getRepository(ExerciseUser::class)->findBy([
  51.         'user_id' => $customer->getId(),
  52.       ]);
  53.       /** @var Exercise $exercise */
  54.       foreach ($exercises_user as $exercise) {
  55.         $exercises[] = $exercise->__toArray($baseurl $prefixFile "/");
  56.       }
  57.     }
  58.     return $this->response($exercises);
  59.   }
  60.   /**
  61.    * @param Request $request
  62.    * @return JsonResponse
  63.    *
  64.    * @Route("/exercise/add", name="api_exercise_add", methods={"POST"})
  65.    */
  66.   public function addExercise(Request $request)
  67.   {
  68.     $request $this->transformJsonBody($request);
  69.     $data $this->getDataForAddFromRequest($request);
  70.     // if ($request->get('is_customer')) {
  71.     // $data['customerId'] = $this->getUser()->getId();
  72.     //}
  73.     if ($request->get('is_customer')) {
  74.       if ($request->get('customerId')) {
  75.         $data['customerId'] = $request->get('customerId');
  76.       } else {
  77.         $data['customerId'] = $this->getUser()->getId();
  78.       }
  79.     }
  80.     $response $this->exerciseManager->addExercise($data$request);
  81.     if ($response['code'] == 200) {
  82.       $prefixFile $this->getParameter("app.path.exercise_images");
  83.       $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  84.       $response['exercise'] = $response['exercise']->__toArray($baseurl $prefixFile "/");
  85.     }
  86.     $this->setStatusCode($response["code"]);
  87.     return $this->response($response);
  88.   }
  89.   /**
  90.    * @param Request $request
  91.    * @return JsonResponse
  92.    *
  93.    * @Route("/exercise/user/list", name="api_exercise_user_list", methods={"POST"})
  94.    */
  95.   public function listExerciseUser(Request $request)
  96.   {
  97.     $request $this->transformJsonBody($request);
  98.     $exercises = [];
  99.     $prefixFile $this->getParameter("app.path.exercise_images");
  100.     $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  101.     /** @var Customer $customer */
  102.     $customer $this->getUser();
  103.     $urlImages $baseurl $prefixFile "/";
  104.     $response $this->exerciseManager->list($customer$urlImages);
  105.     return $this->response($response);
  106.   }
  107.   /**
  108.    * @param Request $request
  109.    * @return JsonResponse
  110.    *
  111.    * @Route("/exercise/shared", name="api_exercise_shared_list", methods={"POST"})
  112.    */
  113.   public function listExerciseShared(Request $request)
  114.   {
  115.     $request $this->transformJsonBody($request);
  116.     $prefixFile $this->getParameter("app.path.exercise_images");
  117.     $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  118.     /** @var Customer $customer */
  119.     $customer $this->getUser();
  120.     $urlImages $baseurl $prefixFile "/";
  121.     $exercises $this->exerciseManager->listShared($customer$urlImages);
  122.     return $this->response($exercises);
  123.   }
  124.   /**
  125.    * @param Request $request
  126.    * @return JsonResponse
  127.    *
  128.    * @Route("/exercise/shared/public", name="api_exercise_shared_public_list", methods={"POST"})
  129.    */
  130.   public function listExerciseSharedPublic(Request $request)
  131.   {
  132.     $request $this->transformJsonBody($request);
  133.     $prefixFile $this->getParameter("app.path.exercise_images");
  134.     $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  135.     $urlImages $baseurl $prefixFile "/";
  136.     $exercises $this->exerciseManager->listSharedAll($urlImages);
  137.     return $this->response($exercises);
  138.   }
  139.   /**
  140.    * @param Request $request
  141.    * @return JsonResponse
  142.    *
  143.    * @Route("/exercise/delete/{exercise}", name="api_exercise_delete", methods={"POST"})
  144.    */
  145.   public function deleteExercise(Exercise $exercise)
  146.   {
  147.     /** @var Customer $customer */
  148.     $prefixFile $this->getParameter("app.path.exercise_images");
  149.     $customer $this->getUser();
  150.     $response $this->exerciseManager->deleteExercise($exercise$prefixFile);
  151.     $this->setStatusCode($response["code"]);
  152.     return $this->response($response);
  153.   }
  154.   /**
  155.    * @param Request $request
  156.    * @return JsonResponse
  157.    *
  158.    * @Route("/exercise/categories", name="api_exercise_categories", methods={"POST"})
  159.    */
  160.   public function exerciseCategories(Request $request)
  161.   {
  162.     $prefixFile $this->getParameter("app.path.exercise_images");
  163.     $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  164.     $categories = [];
  165.     /** @var Category $cat */
  166.     foreach ($this->em->getRepository(Category::class)->findAll() as $cat) {
  167.       $categories[] = $cat->__toArray($baseurl $prefixFile "/");
  168.     }
  169.     return $this->response($categories);
  170.   }
  171.   /**
  172.    * @param Request $request
  173.    * @return JsonResponse
  174.    *
  175.    * @Route("/exercise/materials", name="api_exercise_materials", methods={"POST"})
  176.    */
  177.   public function exerciseMaterials(Request $request)
  178.   {
  179.     $materials = [];
  180.     /** @var Material $cat */
  181.     foreach ($this->em->getRepository(Material::class)->findAll() as $mat) {
  182.       $materials[] = $mat->__toArray();
  183.     }
  184.     return $this->response($materials);
  185.   }
  186.   /**
  187.    * @param Request $request
  188.    * @return JsonResponse
  189.    *
  190.    * @Route("/exercise/search", name="api_exercises_by_search", methods={"POST"})
  191.    */
  192.   public function exercisesBySearch(Request $requestTranslatorInterface $i18n)
  193.   {
  194.     $prefixFile $this->getParameter("app.path.exercise_images");
  195.     $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  196.     $request $this->transformJsonBody($request);
  197.     $criteria = ["search" => $request->get('search')];
  198.     $exercises = [];
  199.     /** @var ExerciseTranslation $exerciseTranslation */
  200.     /** @var Exercise $exercise */
  201.     $exerciseRepo $this->em->getRepository(Exercise::class);
  202.     $customer_id $this->getUser()->getId();
  203.     $exercisesWithUser $exerciseRepo->createQueryBuilder('e')
  204.       ->where("e.customer_id IS NULL or e.customer_id = '$customer_id'")
  205.       ->getQuery()
  206.       ->getResult();
  207.     foreach ($exercisesWithUser as $exe) {
  208.       $exerciseId $exe->getTranslatableId();
  209.       $exercise = (!empty($exerciseId)) ? $exerciseRepo->find($exerciseId) : null;
  210.       if (!empty($exercise)) {
  211.         $data = [
  212.           "id" => $exercise->getId(),
  213.           "name" => $exe->getName(),
  214.           "description" => $exe->getDescription(),
  215.           "categoryId" => $exe->getCategory() ? $exe->getCategory()->getId() : null,
  216.           "image" => !empty($exercise->getImage()) ? $baseurl $prefixFile "/" $exercise->getImage() : "",
  217.           "poster" => !empty($exercise->getPoster()) ? $baseurl $prefixFile "/" $exercise->getPoster() : "",
  218.           "dificulty" => $exercise->getDificulty(),
  219.           "intensity" => $exercise->getIntensity(),
  220.           "duration" => $exercise->getDuration(),
  221.           "materials" => $exercise->getMaterialsArray(),
  222.         ];
  223.       } else {
  224.         $exercise $exerciseRepo->find($exe->getId());
  225.         $data[] = $exercise->__toArray($baseurl $prefixFile "/");
  226.       }
  227.       $exercises[] = $data;
  228.     }
  229.     return $this->response($exercises);
  230.   }
  231.   /**
  232.    * @param Request $request
  233.    * @return JsonResponse
  234.    *
  235.    * @Route("/exercise/exercises/{category}", name="api_exercises_by_category", methods={"POST"})
  236.    */
  237.   public function exercisesByCategories($categoryRequest $request)
  238.   {
  239.     $prefixFile $this->getParameter("app.path.exercise_images");
  240.     $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  241.     $filter = ["category" => $category];
  242.     $exercises = [];
  243.     /** @var Exercise $exe */
  244.     foreach ($this->em->getRepository(Exercise::class)->findBy($filter) as $exe) {
  245.       $exercises[] = [
  246.         "id" => $exe->getId(),
  247.         "image" => !empty($exe->getImage()) ? $baseurl $prefixFile "/" $exe->getImage() : "",
  248.         "poster" => !empty($exe->getPoster()) ? $baseurl $prefixFile "/" $exe->getPoster() : "",
  249.         "name" => $exe->getName(),
  250.         "duaration" => $exe->getDuration(),
  251.       ];
  252.     }
  253.     return $this->response($exercises);
  254.   }
  255.   /**
  256.    * @param Request $request
  257.    * @return JsonResponse
  258.    *
  259.    * @Route("/exercise/data/{exerciseId}", name="api_exercise_by_id", methods={"POST"})
  260.    */
  261.   public function exerciseById($exerciseIdRequest $requestTranslatorInterface $i18n)
  262.   {
  263.     $prefixFile $this->getParameter("app.path.exercise_images");
  264.     $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  265.     /** @var Exercise $exercise */
  266.     $exercise $this->em->getRepository(Exercise::class)->find($exerciseId);
  267.     if (!empty($exercise)) {
  268.       $exercise $exercise->__toArray($baseurl $prefixFile "/");
  269.       $exercise["dificulty"] = $i18n->trans("label." $exercise["dificulty"]);
  270.       $exercise["intensity"] = $i18n->trans("label." $exercise["intensity"]);
  271.     } else {
  272.       $exercise = [];
  273.     }
  274.     return $this->response($exercise);
  275.   }
  276.   /**
  277.    * @param Request $request
  278.    * @return JsonResponse
  279.    *
  280.    * @Route("/exercise/edit/{exercise}", name="api_exercise_edit", methods={"POST"})
  281.    */
  282.   public function exerciseEdit(Exercise $exerciseRequest $request)
  283.   {
  284.     $request $this->transformJsonBody($request);
  285.     $data $this->getDataFromRequest($request);
  286.     $response $this->exerciseManager->edit($exercise$data);
  287.     $this->setStatusCode($response["code"]);
  288.     return $this->response($response);
  289.   }
  290.   /**
  291.    * @param Request $request
  292.    * @return JsonResponse
  293.    *
  294.    * @Route("/exercise/update/{id}", name="api_exercise_update", methods={"POST"})
  295.    */
  296.   public function exerciseUpdate($idRequest $request)
  297.   {
  298.     $request $this->transformJsonBody($request);
  299.     $data $this->getDataForAddFromRequest($request);
  300.     $response $this->exerciseManager->updateExercise($id$data$request);
  301.     $this->setStatusCode($response["code"]);
  302.     return $this->response($response);
  303.   }
  304.   protected function getDataForAddFromRequest(Request $request)
  305.   {
  306.     if ($request->get('categoryId')) {
  307.       $category $this->em->getRepository(Category::class)->find($request->get('categoryId'));
  308.       if (!$category) {
  309.         $category $this->em->getRepository(Category::class)->findAll()[0];
  310.       }
  311.     } else {
  312.       $category $this->em->getRepository(Category::class)->findAll()[0];
  313.     }
  314.     $data = [
  315.       "title" => $request->get('title'),
  316.       "description" => $request->get('description'),
  317.       "image" => $request->files->get('image'),
  318.       "material" => $request->get('material'),
  319.       "dificulty" => $request->get('dificulty'),
  320.       "intensity" => $request->get('intensity'),
  321.       "duration" => $request->get('duration'),
  322.       "category" => $category,
  323.     ];
  324.     return $data;
  325.   }
  326.   protected function getDataFromRequest(Request $request)
  327.   {
  328.     $data = [
  329.       "duration" => $request->get('duration')
  330.     ];
  331.     return $data;
  332.   }
  333.   /**
  334.    * @param Request $request
  335.    * @return JsonResponse
  336.    *
  337.    * @Route("/exercise/calendars/{date}", name="api_exercise_calendars", methods={"POST"})
  338.    */
  339.   public function getCalendarExercises(DateTime $date)
  340.   {
  341.     $date = new \DateTime($date->format('Y-m-d H:i:s'));
  342.     /** @var Customer $customer */
  343.     $customer $this->getUser();
  344.     $season $customer->getSeasonActive();
  345.     $filter = [
  346.       [
  347.         "prop" => "season",
  348.         "comp" => "=",
  349.         "val" => $season->getId()
  350.       ],
  351.       [
  352.         "prop" => "date",
  353.         "comp" => ">=",
  354.         "val" => $date->format('Y-m') . '-01'
  355.       ],
  356.       [
  357.         "prop" => "date",
  358.         "comp" => "<=",
  359.         "val" => $date->format('Y-m-t')
  360.       ],
  361.     ];
  362.     // se suman los tiempos de los ejercicios
  363.     $listExercises = [];
  364.     /** @var ExerciseCalendar $exerciseCalendar */
  365.     foreach ($this->em->getRepository(ExerciseCalendar::class)->findByOwnCriteria($filter) as  $key => $exerciseCalendar) {
  366.       if (isset($listExercises[$exerciseCalendar->getDate()->format("Y-m-d")])) {
  367.         $listExercises[$exerciseCalendar->getDate()->format("Y-m-d")] += is_null($exerciseCalendar->getExercise()) ? $exerciseCalendar->getExercise()->getDuration();
  368.       }
  369.       if (!isset($listExercises[$exerciseCalendar->getDate()->format("Y-m-d")])) {
  370.         $listExercises[$exerciseCalendar->getDate()->format("Y-m-d")] = is_null($exerciseCalendar->getExercise()) ? $exerciseCalendar->getExercise()->getDuration();
  371.       }
  372.     }
  373.     $trainingsAsists $this->em->getRepository(TrainingAsist::class)->findByOwnCriteria($filter, [
  374.       'sort' => 'date',
  375.       'dir' => 'asc'
  376.     ]);
  377.     $list = [];
  378.     foreach ($trainingsAsists as $key => $value) {
  379.       $data $value->__toArrayWithPlayers();
  380.       $data['exercise_duration'] = isset($listExercises[$data['date']]) ? $listExercises[$data['date']] : 0;
  381.       if ($data['exercise_duration'] || count($data['players'])) {
  382.         $list[] = $data;
  383.       } else {
  384.         $deleteAsist $this->em->getRepository(TrainingAsist::class)->find($data['id']);
  385.         if ($deleteAsist) {
  386.           $this->em->remove($deleteAsist);
  387.           $this->em->flush();
  388.         }
  389.       }
  390.     }
  391.     // eliminar ejericios sobrantes
  392.     return $this->response($list);
  393.   }
  394.   /**
  395.    * @param Request $request
  396.    * @return JsonResponse
  397.    *
  398.    * @Route("/exercise/calendar/{month}", name="api_exercise_calendar", methods={"POST"})
  399.    */
  400.   public function calendarExercises($month)
  401.   {
  402.     $exercises = [];
  403.     /** @var Customer $customer */
  404.     $customer $this->getUser();
  405.     $season $customer->getSeasonActive();
  406.     if (!empty($season)) {
  407.       $filter = [
  408.         [
  409.           "prop" => "season",
  410.           "comp" => "=",
  411.           "val" => $season->getId()
  412.         ],
  413.         [
  414.           "prop" => "date",
  415.           "comp" => ">=",
  416.           "val" => \DateTime::createFromFormat("dd/m/Y""01/" . ($month) . "/" date('Y'))
  417.         ],
  418.         [
  419.           "prop" => "date",
  420.           "comp" => "<=",
  421.           "val" => \DateTime::createFromFormat("d/m/Y""31/" . ($month) . "/" date('Y'))
  422.         ],
  423.       ];
  424.       /** @var ExerciseCalendar $exerciseCalendar */
  425.       foreach ($this->em->getRepository(ExerciseCalendar::class)->findByOwnCriteria($filter) as $exerciseCalendar) {
  426.         $exercises[] = [
  427.           "id" => $exerciseCalendar->getId(),
  428.           "date" => $exerciseCalendar->getDate()->format("Y-m-d"),
  429.           "exercise_duration" => $exerciseCalendar->getExercise()->getDuration()
  430.         ];
  431.       }
  432.     }
  433.     return $this->response($exercises);
  434.   }
  435.   /**
  436.    * @param Request $request
  437.    * @return JsonResponse
  438.    *
  439.    * @Route("/exercise/calendar/{date}/get", name="api_exercise_calendar_get", methods={"POST"})
  440.    */
  441.   public function calendarExercisesGet($dateRequest $request)
  442.   {
  443.     $exercises = [];
  444.     $prefixFile $this->getParameter("app.path.exercise_images");
  445.     $baseurl $request->getScheme() . '://' $request->getHttpHost() . $request->getBasePath();
  446.     /** @var Customer $customer */
  447.     $customer $this->getUser();
  448.     $season $customer->getSeasonActive();
  449.     if (!empty($season)) {
  450.       $filter = [
  451.         'season' => $season->getId(),
  452.         'date' => \DateTime::createFromFormat("d-m-Y"$date),
  453.       ];
  454.       /** @var ExerciseCalendar $exerciseCalendar */
  455.       foreach ($this->em->getRepository(ExerciseCalendar::class)->findBy($filter) as $exerciseCalendar) {
  456.         $exercise $exerciseCalendar->getExercise();
  457.         $exercises[] = [
  458.           "id" => $exercise->getId(),
  459.           "image" => !empty($exercise->getImage()) ? $baseurl $prefixFile "/" $exercise->getImage() : "",
  460.           "poster" => !empty($exercise->getPoster()) ? $baseurl $prefixFile "/" $exercise->getPoster() : "",
  461.           "name" => $exercise->getName(),
  462.           "categoryId" => $exercise->getCategory() ? $exercise->getCategory()->getId() : null,
  463.           "duration" => $exercise->getDuration(),
  464.           "customer" => $exercise->getCustomerId(),
  465.         ];
  466.       }
  467.     }
  468.     return $this->response($exercises);
  469.   }
  470.   /**
  471.    * @param Request $request
  472.    * @return JsonResponse
  473.    *
  474.    * @Route("/exercise/calendar/{date}/add", name="api_exercise_calendar_add", methods={"POST"})
  475.    */
  476.   public function calendarExerciseAdd($dateRequest $request)
  477.   {
  478.     $request $this->transformJsonBody($request);
  479.     $exercise $request->get('exercise');
  480.     $data = [
  481.       'date' => $date,
  482.       'exercise' => $exercise,
  483.       'type' => $request->get('type'),
  484.     ];
  485.     $response $this->exerciseManager->addCalendar($data);
  486.     $this->setStatusCode($response["code"]);
  487.     return $this->response($response);
  488.   }
  489.   /**
  490.    * @param Request $request
  491.    * @return JsonResponse
  492.    *
  493.    * @Route("/exercise/calendar/{date}/remove", name="api_exercise_calendar_remove", methods={"POST"})
  494.    */
  495.   public function calendarExerciseRemove($dateRequest $request)
  496.   {
  497.     $request $this->transformJsonBody($request);
  498.     $exercise $request->get('exercise');
  499.     $data = [
  500.       'date' => $date,
  501.       'exercise' => $exercise,
  502.     ];
  503.     $response $this->exerciseManager->removeCalendar($data$request);
  504.     $this->setStatusCode($response["code"]);
  505.     return $this->response($response);
  506.   }
  507.   /**
  508.    * @param Request $request
  509.    * @return JsonResponse
  510.    *
  511.    * @Route("/exercise/{exerciseId}/shared", name="api_exercise_shared", methods={"POST"})
  512.    */
  513.   public function sharedExercise($exerciseIdRequest $request)
  514.   {
  515.     $request $this->transformJsonBody($request);
  516.     $isShared $request->get('isShared');
  517.     $response $this->exerciseManager->shared($request$exerciseId$isShared);
  518.     $this->setStatusCode($response["code"]);
  519.     return $this->response($response);
  520.   }
  521.   /**
  522.    * @param Request $request
  523.    * @return JsonResponse
  524.    *
  525.    * @Route("/exercise/{exerciseId}/qualification", name="api_exercise_add_qualification", methods={"POST"})
  526.    */
  527.   public function exerciseQualification($exerciseIdRequest $request)
  528.   {
  529.     $request $this->transformJsonBody($request);
  530.     $quantity $request->get('quantity');
  531.     $response $this->exerciseManager->addQualification($exerciseId$quantity);
  532.     $this->setStatusCode($response["code"]);
  533.     return $this->response($response);
  534.   }
  535. }