src/AppBundle/Controller/TimerController.php line 24

Open in your IDE?
  1. <?php
  2. namespace AppBundle\Controller;
  3. use Symfony\Component\Routing\Annotation\Route;
  4. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  5. use Symfony\Component\HttpFoundation\JsonResponse;
  6. use Symfony\Component\HttpFoundation\Request;
  7. use AppBundle\Controller\AcroNetAuthenticatedControllerInterface;
  8. use AppBundle\Service\TimeLogger;
  9. /**
  10.  * Controller for the overall timer functionality.
  11.  */
  12. class TimerController extends AbstractController implements AcroNetAuthenticatedControllerInterface
  13. {
  14.     /**
  15.      * @Route("/", name="timer")
  16.      *
  17.      * @param Request $request
  18.      *
  19.      * @return Response
  20.      */
  21.     public function formAction(Request $request)
  22.     {
  23.         return $this->render('timer/timer.html.twig');
  24.     }
  25.     /**
  26.      * @Route("/request/lookup/account", name="timer_account_lookup")
  27.      *
  28.      * @param Request $request
  29.      *
  30.      * @return JsonResponse
  31.      */
  32.     public function timerLookupAccountAction(Request $request)
  33.     {
  34.         $searchTerm $request->request->get('q');
  35.         $data = array();
  36.         $where 'a.status = :status';
  37.         $repo $this->getDoctrine()->getRepository('AcroMediaAcroNetBundle:Account''ami');
  38.         $queryBuilder $repo->createQueryBuilder('a')
  39.             ->setParameter(':status'1);
  40.         if ($searchTerm) {
  41.             $where .= ' AND LOWER(a.name) LIKE :term';
  42.             $queryBuilder->setParameter('term''%'.strtolower($searchTerm).'%');
  43.         }
  44.         $query $queryBuilder->where($where)
  45.             ->orderBy('a.name''ASC')
  46.             ->getQuery();
  47.         $accounts $query->getResult();
  48.         foreach ($accounts as $account) {
  49.             $data[] = array(
  50.                 'value' => $account->getName(),
  51.                 'id' => $account->getAccountID(),
  52.             );
  53.         }
  54.         $response = new JsonResponse($data);
  55.         return $response;
  56.     }
  57.     /**
  58.      * @Route("/request/lookup/project/{accountID}", name="timer_project_lookup")
  59.      *
  60.      * @param int        $accountID
  61.      * @param Request    $request
  62.      * @param TimeLogger $timeLogger
  63.      *
  64.      * @return JsonResponse
  65.      */
  66.     public function timerLookupProjectAction($accountIDRequest $requestTimeLogger $timeLogger)
  67.     {
  68.         $response = new JsonResponse($timeLogger->getProjects($accountID$request->request->get('q')));
  69.         return $response;
  70.     }
  71.     /**
  72.      * @Route("/request/lookup/task/{accountID}/{projectID}", name="timer_task_lookup")
  73.      *
  74.      * @param int        $accountID
  75.      * @param int        $projectID
  76.      * @param Request    $request
  77.      * @param TimeLogger $timeLogger
  78.      *
  79.      * @return JsonResponse
  80.      */
  81.     public function timerLookupTaskAction($accountID$projectIDRequest $requestTimeLogger $timeLogger)
  82.     {
  83.         $response = new JsonResponse($timeLogger->getTasks($accountID$projectID$request->request->get('q')));
  84.         return $response;
  85.     }
  86.     /**
  87.      * @Route("/request/start-entry", name="timer_start_entry")
  88.      *
  89.      * @param Request    $request
  90.      * @param TimeLogger $timeLogger
  91.      *
  92.      * @return Response
  93.      */
  94.     public function timerStartEntry(Request $requestTimeLogger $timeLogger)
  95.     {
  96.         $entryData $request->request->get('entry');
  97.         $data $timeLogger->createEntry($entryData);
  98.         return $timeLogger->generateResponse($data);
  99.     }
  100.     /**
  101.      * @Route("/request/stop-entry", name="timer_stop_entry")
  102.      *
  103.      * @param Request    $request
  104.      * @param TimeLogger $timeLogger
  105.      *
  106.      * @return Response
  107.      */
  108.     public function timerStopEntry(Request $requestTimeLogger $timeLogger)
  109.     {
  110.         $data $timeLogger->stopEntry($request->request->get('entryID'));
  111.         $data = array('entryToLog' => $data);
  112.         return $timeLogger->generateResponse($data);
  113.     }
  114.     /**
  115.      * @Route("/request/recently-logged", name="timer_recently_logged")
  116.      *
  117.      * @param Request    $request
  118.      * @param TimeLogger $timeLogger
  119.      *
  120.      * @return Response
  121.      */
  122.     public function recentlyLogged(Request $requestTimeLogger $timeLogger)
  123.     {
  124.         $day $request->request->get('day');
  125.         $recentlyLogged $timeLogger->getRecentlyLogged($day);
  126.         return $timeLogger->generateResponse($recentlyLogged);
  127.     }
  128.     /**
  129.      * @Route("/request/day-queue", name="timer_day_queue")
  130.      *
  131.      * @param TimeLogger $timeLogger
  132.      *
  133.      * @return Response
  134.      */
  135.     public function dayQueue(TimeLogger $timeLogger)
  136.     {
  137.         $dayQueue $timeLogger->getDayQueue();
  138.         return $timeLogger->generateResponse($dayQueue);
  139.     }
  140.     /**
  141.      * @Route("/request/day-queue/add", name="timer_day_queue_add")
  142.      *
  143.      * @param Request    $request
  144.      * @param TimeLogger $timeLogger
  145.      *
  146.      * @return null|Response
  147.      */
  148.     public function dayQueueAdd(Request $requestTimeLogger $timeLogger)
  149.     {
  150.         if ($taskID $request->request->get('taskID')) {
  151.             $newEntryData $timeLogger->addDayQueueItem($taskID);
  152.             return $timeLogger->generateResponse($newEntryData);
  153.         }
  154.         return null;
  155.     }
  156.     /**
  157.      * @Route("/request/day-queue/remove", name="timer_day_queue_remove")
  158.      *
  159.      * @param Request    $request
  160.      * @param TimeLogger $timeLogger
  161.      *
  162.      * @return Response
  163.      */
  164.     public function dayQueueRemove(Request $requestTimeLogger $timeLogger)
  165.     {
  166.         $removeInfo $timeLogger->removeDayQueueItem($request->request->get('itemID'));
  167.         return $timeLogger->generateResponse($removeInfo);
  168.     }
  169.     /**
  170.      * @Route("/request/day-queue/reorder", name="timer_day_queue_reorder")
  171.      *
  172.      * @param TimeLogger $timeLogger
  173.      *
  174.      * @return Response
  175.      */
  176.     public function dayQueueReorder(TimeLogger $timeLogger)
  177.     {
  178.         $timeLogger->reorderDayQueueItems($_POST);
  179.         $dayQueue $timeLogger->getDayQueue();
  180.         return $timeLogger->generateResponse($dayQueue);
  181.     }
  182.     /**
  183.      * @Route("/request/current-entry", name="timer_current_entry")
  184.      *
  185.      * @param TimeLogger $timeLogger
  186.      *
  187.      * @return Response
  188.      */
  189.     public function currentEntry(TimeLogger $timeLogger)
  190.     {
  191.         $entry $timeLogger->getCurrentEntry();
  192.         $data $timeLogger->buildJsonEntry($entry);
  193.         return $timeLogger->generateResponse($data);
  194.     }
  195.     /**
  196.      * @Route("/request/update-entry"), name="timer_update_entry")
  197.      *
  198.      * @param Request    $request
  199.      * @param TimeLogger $timeLogger
  200.      *
  201.      * @return Response
  202.      */
  203.     public function updateEntry(Request $requestTimeLogger $timeLogger)
  204.     {
  205.         $entryData $request->request->get('entry');
  206.         return $timeLogger->generateResponse($timeLogger->updateEntry($entryData));
  207.     }
  208.     /**
  209.      * @Route("/request/log-time", name="timer_log_time")
  210.      *
  211.      * @param Request    $request
  212.      * @param TimeLogger $timeLogger
  213.      *
  214.      * @return Response
  215.      */
  216.     public function logTime(Request $requestTimeLogger $timeLogger)
  217.     {
  218.         $logData $request->request->get('entryToLog');
  219.         $timeLogger->logTime($logData);
  220.         return $timeLogger->generateResponse($timeLogger->getRecentlyLogged());
  221.     }
  222.     /**
  223.      * @Route("/request/remove-taskless-time", name="remove_taskless_time")
  224.      *
  225.      * @param Request    $request
  226.      * @param TimeLogger $timeLogger
  227.      *
  228.      * @return Response
  229.      */
  230.     public function removeTasklessTime(Request $requestTimeLogger $timeLogger)
  231.     {
  232.         $result false;
  233.         if ($entryIds $request->request->get('entryIds')) {
  234.             $result $timeLogger->removeTasklessTime($entryIds);
  235.         }
  236.         return $timeLogger->generateResponse(array('result' => (bool) $result));
  237.     }
  238. }