src/Ox/HoardBundle/Controller/ReferenceController.php line 325

Open in your IDE?
  1. <?php
  3. namespace App\Ox\HoardBundle\Controller;
  5. use Symfony\Component\HttpFoundation\Request;
  6. use Symfony\Component\HttpFoundation\Response;
  7. use Symfony\Component\HttpFoundation\JsonResponse;
  8. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  9. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
  10. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
  11. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
  12. use Symfony\Component\HttpFoundation\File\File;
  13. use Symfony\Component\Filesystem\Filesystem;
  14. use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  15. use Symfony\Component\Form\Extension\Core\Type\SubmitType;
  16. use Symfony\Component\Form\Extension\Core\Type\ButtonType;
  17. use Knp\Component\Pager\PaginatorInterface;
  19. use App\Ox\HoardBundle\Entity\Reference;
  20. use App\Ox\HoardBundle\Form\ReferenceType;
  22. /**
  23.  * Reference controller.
  24.  *
  25.  * @Route("/reference")
  26.  */
  27. class ReferenceController extends AbstractController
  28. {
  32.     /**
  33.      * Suggest
  34.      * @Route("/suggest", name="suggest_reference", methods={"GET"})
  35.      */
  36.     public function suggestReference(Request $request)
  37.     {
  38.         $em = $this->getDoctrine()->getManager();
  40.         //get query params
  41.         $query = $request->get('q');
  43.         $typeID = $request->get('type');
  45.         $queryBuilder = $em->createQueryBuilder();
  46.         $queryBuilder->select('r.title, r.id, r.authors, r.year, r.abbreviation, r.sortValue')
  47.             ->from('OxHoardBundle:Reference', 'r')
  48.             ->orderBy('r.sortValue', 'DESC')
  49.             ->addOrderBy('r.authors', 'ASC')
  50.             ->addOrderBy('r.abbreviation', 'ASC')
  51.             ->addOrderBy('r.title', 'ASC')
  52.             ;
  54.         //match query against year, title or authors
  55.         if($query) {
  56.             $queryBuilder = $queryBuilder->where('r.title LIKE :query')
  57.                                         ->orWhere('r.abbreviation LIKE :query')
  58.                                         ->orWhere('r.authors LIKE :query')
  59.                                         ->orWhere('r.year LIKE :query')
  60.                                         ->setParameter('query', '%'.$query.'%')
  61.                                         ;
  62.         }
  64.         //check type
  65.         if($typeID) {
  66.             $type = $em->getRepository('OxHoardBundle:ReferenceType')->find($typeID);
  68.             $queryBuilder = $queryBuilder->andWhere('r.referenceType = :refType')
  69.                 ->setParameter('refType', $type);
  70.         }
  72.         $query = $queryBuilder->getQuery();
  75.         $queryResult = $query->getArrayResult();
  76.         $response = array();
  78.         foreach($queryResult as $result) {
  79.             //compile the text version of the reference
  80.             $text = '';
  81.             if($result['abbreviation']) { $text .= $result['abbreviation']; }
  82.             else {
  83.                 if( $result['authors'] ) { $text.=$result['authors'].' - '; }
  84.                 if( $result['year'] ) { $text.=$result['year'].' - '; }
  85.                 if( $result['title'] ) {
  86.                     $text.=$result['title'];
  87.                 } else {
  88.                     $text.='Untitled';
  89.                 }
  90.             }
  91.             $result['text'] = $text;
  92.             $response[] = $result;
  93.         }
  94.         return new JsonResponse($response);
  96.     }
  99.     /**
  100.      * Lists all Reference entities.
  101.      *
  102.      * @Route("/", name="reference", methods={"GET"})
  103.      * @Template()
  104.      */
  105.     public function indexAction(Request $request, PaginatorInterface $paginator)
  106.     {
  107.         $limit = 20;
  108.         $em = $this->getDoctrine()->getManager();
  109.         $em->getFilters()->enable('softdeleteable');
  110.         
  111.         $queryBuilder = $em->createQueryBuilder();
  112.         $queryBuilder->select('r, type')
  113.             ->from('OxHoardBundle:Reference', 'r')
  114.             ->leftJoin('r.referenceType', 'type');
  115.         $activeTab = $request->query->get('active-tab');
  116.         if ($activeTab == '#tabs-2') {
  117.             // advanced search
  118.             $title = $request->query->get('title');
  119.             if ($title) {
  120.                 $queryBuilder->andWhere('r.title LIKE :chosenTitle')
  121.                 ->setParameter('chosenTitle', '%'.$title.'%');
  122.             }
  124.             $titleEdition = $request->query->get('title-edition');
  125.             if ($titleEdition) {
  126.                 $queryBuilder->andWhere('r.titleEdition LIKE :chosenTitleEdition')
  127.                 ->setParameter('chosenTitleEdition', '%'.$titleEdition.'%');
  128.             }
  130.             $abbreviation = $request->query->get('abbreviation');
  131.             if ($abbreviation) {
  132.                 $queryBuilder->andWhere('r.abbreviation LIKE :chosenAbbreviation')
  133.                 ->setParameter('chosenAbbreviation', '%'.$abbreviation.'%');
  134.             }
  135.             
  136.             $yearFrom = $request->query->get('year-from');
  137.             if ($yearFrom) {
  138.                 $queryBuilder->andWhere('r.year >= :chosenYearFrom')
  139.                 ->setParameter('chosenYearFrom', $yearFrom);
  140.             }
  141.             
  142.             $yearTo = $request->query->get('year-to');
  143.             if ($yearTo) {
  144.                 $queryBuilder->andWhere('r.year <= :chosenYearTo')
  145.                 ->setParameter('chosenYearTo', $yearTo);
  146.             }
  147.             
  148.             $referenceType = null;
  149.             $referenceTypeId = $request->query->get('reference-type');
  150.             if($referenceTypeId) {
  151.                 $referenceType = $em->getRepository('OxHoardBundle:ReferenceType')->find($referenceTypeId);
  152.                 if ($referenceType) {
  153.                     $queryBuilder->andWhere('r.referenceType = :chosenReferenceType')
  154.                         ->setParameter('chosenReferenceType', $referenceType);
  155.                 }
  156.             }
  157.             
  158.             $author = $request->query->get('author');
  159.             if ($author) {
  160.                 $queryBuilder->andWhere('r.authors LIKE :chosenAuthor')
  161.                 ->setParameter('chosenAuthor', '%'.$author.'%');
  162.             }
  163.             
  164.             $internalNote = $request->query->get('internal-note');
  165.             if ($internalNote) {
  166.                 $queryBuilder->andWhere('r.internalNote LIKE :chosenInternalNote')
  167.                 ->setParameter('chosenInternalNote', '%'.$internalNote.'%');
  168.             }
  170.             $volume = $request->query->get('volume');
  171.             if ($volume) {
  172.                 $queryBuilder->andWhere('r.volume = :chosenVolume')
  173.                 ->setParameter('chosenVolume', $volume);
  174.             }
  176.         } else { //simple search
  177.             if(isset($_GET['search']))
  178.             {
  179.                 $searchValue = $_GET['search'];
  180.                 $queryBuilder->where('r.title LIKE :search')
  181.                     ->orWhere('r.authors LIKE :search') 
  182.                     ->orWhere('r.abbreviation LIKE :search')
  183.                     ->orWhere('r.titleEdition LIKE :search')
  184.                     ->setParameter('search','%'.$searchValue.'%');
  185.             }
  186.         }
  188.         $query = $queryBuilder->getQuery()
  189.             ->setFirstResult(0)
  190.             ->setMaxResults($limit);
  192.         $pagination = $paginator->paginate(
  193.             $query,
  194.             $request->query->getInt('page', 1),/* page number */
  195.             $limit
  196.         );
  198.         $isAuthenticated = false;
  199.         if($this->getUser()) {
  200.             $isAuthenticated = true;
  201.         }
  203.         $sortFields = array();
  204.         if ($isAuthenticated) {
  205.             $sortFields[] = array('label' => 'ID', 'key' => 'r.id', 'defaultDirection' => 'asc');
  206.         }
  207.         $sortFields = array_merge($sortFields, array(
  208.             array('label' => 'Author', 'key' => 'r.authors', 'defaultDirection' => 'asc'),
  209.             array('label' => 'Year', 'key' => 'r.year', 'defaultDirection' => 'desc'),
  210.             array('label' => 'Title', 'key' => 'r.title', 'defaultDirection' => 'asc'),
  211.             array('label' => 'Title (journal, series)', 'key' => 'r.titleEdition', 'defaultDirection' => 'asc'),
  212.         ));
  213.         if ($isAuthenticated) {
  214.             $sortFields[] = array('label' => 'Sort Value', 'key' => 'r.sortValue', 'defaultDirection' => 'desc');
  215.         }
  216.         
  217.         $isAdmin = $this->userIsAdmin();
  219.         $referenceTypes = $em->createQuery('SELECT rt FROM OxHoardBundle:ReferenceType rt ORDER BY rt.referenceType')->getResult();
  221.         return $this->render('@OxHoardBundle/reference/list.html.twig', array(
  222.             'pagination' => $pagination,
  223.             'sort_fields' => $sortFields,
  224.             'is_authenticated' => $isAuthenticated,
  225.             'is_admin' => $isAdmin,
  226.             'reference_types' => $referenceTypes,
  227.             // 'filtered_type' => $filteredType,
  228.             // 'abbreviations' => $onlyAbbreviated,
  229.             // 'own_column_only' => $ownColumnOnly,
  230.             'search_term' => isset($searchValue)?$searchValue:null,
  231.             'title' => isset($title) ? $title : null,
  232.             'title_edition' => isset($titleEdition) ? $titleEdition : null,
  233.             'abbreviation' => isset($abbreviation) ? $abbreviation : null,
  234.             'volume' => isset($volume) ? $volume : null,
  235.             'year_from' => isset($yearFrom) ? $yearFrom : null,
  236.             'year_to' => isset($yearTo) ? $yearTo : null,
  237.             'reference_type' => isset($referenceTypeId) ? $referenceTypeId : null,
  238.             'author' => isset($author) ? $author : null,
  239.             'internalNote' => isset($internalNote) ? $internalNote : null,
  240.             'active_tab' => isset($activeTab) ? $activeTab: "#tabs-1",
  241.         ));
  242.     }
  243.     /**
  244.      * Creates a new Reference entity.
  245.      *
  246.      * @Route("/", name="reference_create", methods={"POST"})
  247.      * @Template("@OxHoardBundle/reference/new.html.twig")
  248.      */
  249.     public function createAction(Request $request)
  250.     {
  251.         //only logged in users can create
  252.         if(!$this->getUser()) {
  253.             throw new AccessDeniedException("Only logged in contributors may create a reference entry");
  254.         }
  256.         $reference = new Reference();
  257.         $form = $this->createCreateForm($reference);
  258.         $form->handleRequest($request);
  260.         if ($form->isValid()) {
  261.             $em = $this->getDoctrine()->getManager();
  262.             $em->persist($reference);
  263.             $em->flush();
  265.             return $this->redirect($this->generateUrl('reference_show', array('id' => $reference->getId())));
  266.         }
  268.         return array(
  269.             'reference' => $reference,
  270.             'form'   => $form->createView(),
  271.         );
  272.     }
  274.     /**
  275.      * Creates a form to create a Reference entity.
  276.      *
  277.      * @param Reference $reference The entity
  278.      *
  279.      * @return \Symfony\Component\Form\Form The form
  280.      */
  281.     private function createCreateForm(Reference $reference)
  282.     {
  283.         $form = $this->createForm(ReferenceType::class, $reference, array(
  284.             'action' => $this->generateUrl('reference_create'),
  285.             'method' => 'POST',
  286.         ));
  288.         $form->add('submit', SubmitType::class, array('label' => 'Create'));
  290.         return $form;
  291.     }
  293.     /**
  294.      * Displays a form to create a new Reference entity.
  295.      *
  296.      * @Route("/new", name="reference_new", methods={"GET"})
  297.      * @Template()
  298.      */
  299.     public function newAction()
  300.     {
  301.         //only logged in users can create
  302.         if(!$this->getUser()) {
  303.             throw new AccessDeniedException("Only logged in contributors may create a reference entry");
  304.         }
  307.         $reference = new Reference();
  308.         $form   = $this->createCreateForm($reference);
  310.         return $this->render('@OxHoardBundle/reference/new.html.twig', array(
  311.             'reference' => $reference,
  312.             'edit_form'   => $form->createView(),
  313.             'is_admin' => $this->userIsAdmin(),
  314.         ));
  315.     }
  317.     /**
  318.      * Finds and displays a Reference entity.
  319.      *
  320.      * @Route("/{id}", name="reference_show", methods={"GET"})
  321.      * @Template()
  322.      */
  323.     public function showAction(Request $request, $id)
  324.     {
  325.         $em = $this->getDoctrine()->getManager();
  327.         $reference = $em->getRepository('OxHoardBundle:Reference')->find($id);
  329.         // if the hoard is not fount check if it soft-deleted
  330.         if (!$reference) {
  331.             $em->getFilters()->disable('softdeleteable');
  332.             $reference = $em->getRepository('OxHoardBundle:Reference')->find($id);
  333.             $em->getFilters()->enable('softdeleteable');
  335.             // if it is not soft-deleted return "not found"
  336.             if (!$reference) {
  337.                 throw $this->createNotFoundException('Unable to find Reference entity.');
  338.             } else {
  339.                 // else check if it is really soft-deleted and redirect ti the redirectId
  340.                 $redirect_id = $reference->getRedirectToReference();
  341.                 if ($reference->getDeletedAt() && $redirect_id) {
  342.                     return $this->redirect($this->generateUrl('reference_show', array('id' => $redirect_id)));
  343.                 } else {
  344.                     throw $this->createNotFoundException('Unable to find Reference entity.');
  345.                 }
  346.             }
  347.         }
  349.         // $isAuthenticated = false;
  350.         // if($this->getUser()) {
  351.         //     $isAuthenticated = true;
  352.         // }
  354.         $isAuthenticated = false;
  355.         if($this->getUser()) {
  356.             $isAuthenticated = true;
  357.         }
  359.         $hoards = [];
  360.         foreach($reference->getHoardReferences() as $hoardReference) {
  361.             $hoardId = $hoardReference->getHoard()->getId();
  362.             $em->getFilters()->disable('softdeleteable');
  363.             $hoard = $em->getRepository('OxHoardBundle:Hoard')->find($hoardId);
  364.             if (!$hoard->getDeletedAt()) {
  365.                 if ($isAuthenticated || ($hoard->getValidatedByUser())) {
  366.                     $hoards[] = $hoard;
  367.                 }
  368.             }
  369.             $em->getFilters()->enable('softdeleteable');
  370.         }
  371.     
  372.         usort($hoards, array($this, "cmp"));
  373.         
  374.         $deleteForm = $this->createDeleteForm($id);
  376.         $referer = $request->get('referer');
  377.         if(!$referer) {
  378.             $referer = $request->headers->get('referer');
  379.         }
  380.         if (!strpos($referer, "/reference/")) {
  381.             $referer = null;
  382.         }
  383.         if (strpos($referer, "/edit")) {
  384.             $referer = null;
  385.         }
  387.         return array(
  388.             'reference' => $reference,
  389.             'hoards' => $hoards,
  390.             'delete_form' => $deleteForm->createView(),
  391.             'is_authorised_to_edit' => $this->checkAccess($reference, 'edit', false),
  392.             'is_authenticated' => $isAuthenticated,
  393.             'referer' => $referer,
  394.         );
  395.     }
  397.     function cmp($a, $b)
  398.     {
  399.         $aCountry = $a->getCountries()[0].'';
  400.         $bCountry = $b->getCountries()[0].'';
  401.         $aName = $a.'';
  402.         $bName = $b.'';
  403.         $aStr = $aCountry . $aName;
  404.         $bStr = $bCountry . $bName;
  405.         return strcasecmp($aStr,$bStr);
  406.     }
  408.     /**
  409.      * Displays a form to edit an existing Reference entity.
  410.      *
  411.      * @Route("/{id}/edit", name="reference_edit", methods={"GET"})
  412.      * @Template()
  413.      */
  414.      public function editAction(Request $request, $id)
  415.     {
  416.         $em = $this->getDoctrine()->getManager();
  418.         $reference = $em->getRepository('OxHoardBundle:Reference')->find($id);
  420.         if (!$reference) {
  421.             throw $this->createNotFoundException('Unable to find Reference entity.');
  422.         }
  423.     
  424.         $this->checkAccess($reference, 'edit');
  426.         $editForm = $this->createEditForm($reference, $request);
  427.         $deleteForm = $this->createDeleteForm($id);
  429.         $hoards = $request->getSession()->get('hoards');
  430.         $coins = $request->getSession()->get('coins');
  431.         $objects = $request->getSession()->get('objects');
  432.         $request->getSession()->clear('hoards');
  433.         $request->getSession()->clear('coins');
  434.         $request->getSession()->clear('objects');
  436.         return array(
  437.             'hoards' => $hoards,
  438.             'coins'       => $coins,
  439.             'objects'       => $objects,
  440.             'reference'      => $reference,
  441.             'edit_form'   => $editForm->createView(),
  442.             'delete_form' => $deleteForm->createView(),
  443.             'is_admin' => $this->userIsAdmin(),
  444.         );
  445.     }
  447.     /**
  448.     * Creates a form to edit a Reference entity.
  449.     *
  450.     * @param Reference $reference The entity
  451.     *
  452.     * @return \Symfony\Component\Form\Form The form
  453.     */
  454.     private function createEditForm(Reference $reference, $request)
  455.     {
  456.         $referer = $request->get('referer');
  457.         if(!$referer)
  458.         {
  459.             $referer = $request->headers->get('referer');
  460.         }
  461.                
  462.         $action = $this->generateUrl('reference_update', array('id' => $reference->getId()));
  463.         if($referer) {
  464.             $action .= '?referer='.$referer;
  465.         }
  466.         $form = $this->createForm(ReferenceType::class, $reference, array(
  467.             'action' => $action,
  468.             'method' => 'PUT',
  469.         ));
  470.         if($this->userIsAdmin())
  471.         {
  472.             $form->add('hasOwnColumn');
  473.         }
  474.         $form->add('submit', SubmitType::class, array('label' => 'Update'));
  476.         return $form;
  477.     }
  478.     /**
  479.      * Edits an existing Reference entity.
  480.      *
  481.      * @Route("/{id}", name="reference_update", methods={"PUT"})
  482.      * @Template("@OxHoardBundle/reference/edit.html.twig")
  483.      */
  484.     public function updateAction(Request $request, $id)
  485.     {
  486.        // echo $request->get('referer');exit;
  487.         $em = $this->getDoctrine()->getManager();
  489.         $reference = $em->getRepository('OxHoardBundle:Reference')->find($id);
  491.         if (!$reference) {
  492.             throw $this->createNotFoundException('Unable to find Reference entity.');
  493.         }
  495.         $this->checkAccess($reference, 'edit');
  497.         $deleteForm = $this->createDeleteForm($id);
  498.         $editForm = $this->createEditForm($reference, $request);
  499.         $editForm->handleRequest($request);
  500.         $hoards = [];
  501.         $coins = [];
  502.         $objects = [];
  504.         if ($editForm->isValid()) {
  505.             $em->flush();
  506.   
  507.             $referer = $request->get('referer');
  508.             if(!$referer) {
  509.                 $referer = $request->headers->get('referer');
  510.             }
  511.             
  512.             $page = $request->get('page');
  514.             if(isset($page)) {
  515.                 $referer .= '&page=' . $page;
  516.             }
  518.             return $this->redirect($referer);
  519.             
  520.         }
  522.         return array(
  523.             'hoards'      => $hoards,
  524.             'coins'       => $coins,
  525.             'objects'     => $objects,
  526.             'reference'      => $reference,
  527.             'edit_form'   => $editForm->createView(),
  528.             'delete_form' => $deleteForm->createView(),
  529.         );
  530.     }
  531.     /**
  532.      * Deletes a Reference entity.
  533.      *
  534.      * @Route("/{id}", name="reference_delete", methods={"DELETE"})
  535.      */
  536.     public function deleteAction(Request $request, $id)
  537.     {
  538.         $form = $this->createDeleteForm($id);
  539.         $form->handleRequest($request);
  541.         if ($form->isValid()) {
  542.             try {
  543.                 $em = $this->getDoctrine()->getManager();
  544.                 $reference = $em->getRepository('OxHoardBundle:Reference')->find($id);
  546.                 if (!$reference) {
  547.                     throw $this->createNotFoundException('Unable to find Reference entity.');
  548.                 }
  550.                 if (!$this->getUser() || !($this->getUser()->hasRole('ROLE_ADMIN') || $this->getUser()->hasRole('ROLE_SUPER_ADMIN'))) {
  551.                     $request->getSession()->getFlashBag()
  552.                         ->add('error', 'Unable to delete Reference. Only admins can delete references.');
  553.                     return $this->redirect($this->generateUrl('reference_edit', array('id' => $reference->getId())));
  554.                 }
  556.                 // check whether it is in use
  557.                 $queryBuilder = $em->createQueryBuilder();
  558.                 $queryBuilder->select('hrdref, h')
  559.                             ->from('OxHoardBundle:HoardReference', 'hrdref')
  560.                             ->leftJoin('hrdref.hoard', 'h')
  561.                             ->leftJoin('hrdref.reference', 'r')
  562.                             ->where('r.id = :query')
  563.                             ->setParameter('query', $id);
  565.                 $query = $queryBuilder->getQuery();
  566.                 $hoards = $query->getResult();
  567.                 $queryBuilder = $em->createQueryBuilder();
  568.                 $queryBuilder->select('coiref, h')
  569.                             ->from('OxHoardBundle:CoinReference', 'coiref')
  570.                             ->leftJoin('coiref.coin', 'h')
  571.                             ->leftJoin('coiref.reference', 'r')
  572.                             ->where('r.id = :query')
  573.                             ->setParameter('query', $id);
  575.                 $query = $queryBuilder->getQuery();
  576.                 $coins = $query->getResult();
  577.                 $queryBuilder = $em->createQueryBuilder();
  578.                 $queryBuilder->select('objref, o')
  579.                             ->from('OxHoardBundle:ObjectReference', 'objref')
  580.                             ->leftJoin('objref.object', 'o')
  581.                             ->leftJoin('objref.reference', 'r')
  582.                             ->where('r.id = :query')
  583.                             ->setParameter('query', $id);
  585.                 $query = $queryBuilder->getQuery();
  586.                 $objects = $query->getResult();
  588.                 if(count($hoards) > 0 || count($coins) > 0 || count($objects) > 0) {
  589.                   $request->getSession()->set('hoards', $hoards);
  590.                   $request->getSession()->set('coins', $coins);
  591.                   $request->getSession()->set('objects', $objects);
  592.                   return $this->redirect($this->generateUrl('reference_edit', array('id' => $reference->getId())));
  593.                 } else {
  594.                   $em->remove($reference);
  595.                   $em->flush();
  596.                   return $this->redirect($this->generateUrl('reference'));
  597.                 }
  598.             } catch (\Exception $e) {
  599.                 //an exception is thrown if the entity is used by any non-deleted coins. Tell the user that this is probably the case.
  601.                 $request->getSession()
  602.                     ->getFlashBag()
  603.                     ->add('error', 'Unable to delete Reference. It may currently be in use on a coin, object or hoard.');
  605.                 return $this->redirect($this->generateUrl('reference_edit', array('id' => $reference->getId())));
  607.             }
  608.         }
  610.         return $this->redirect($this->generateUrl('reference'));
  611.     }
  613.     /**
  614.      * Creates a form to delete a Reference entity by id.
  615.      *
  616.      * @param mixed $id The entity id
  617.      *
  618.      * @return \Symfony\Component\Form\Form The form
  619.      */
  620.     private function createDeleteForm($id)
  621.     {
  622.         return $this->createFormBuilder()
  623.             ->setAction($this->generateUrl('reference_delete', array('id' => $id)))
  624.             ->setMethod('DELETE')
  625.             ->add('submit', ButtonType::class, array(
  626.                 'label' => 'Delete this reference',
  627.                 'attr' => array(
  628.                     'class' => 'delete-button btn btn-danger'
  629.                 )
  630.             ))
  631.             ->getForm()
  632.         ;
  633.     }
  634.     
  635.     
  636.     /**
  637.      * Upload a new pdf file for the reference
  638.      *
  639.      * @Route("/{id}/ajax_add_file", methods={"POST"})
  640.      */
  641.     public function setFile(Request $request, $id)
  642.     {
  643.         $em = $this->getDoctrine()->getManager();
  644.         
  645.         $file = $request->files->get('file');
  646.         
  647.         $reference = $em->getRepository('OxHoardBundle:Reference')->find($id);
  648.         if(!$reference)
  649.         {
  650.             throw $this->createNotFoundException('Unable to find Reference entity.');
  651.         }
  652.         if(!$file->getMimeType() == 'application/pdf')
  653.         {
  654.             return new JsonResponse(array('success'=> 0, 'error'=> 'Invalid file type. Only pdf files may be uploaded'));
  655.         }
  656.         $isValid = true;
  657.         
  658.         //build new fileName
  659.         $now = new \DateTime();
  660.         $nowString = $now->format('Ymd-His');
  661.         $fileName = $id.'-'.$nowString.'.'.$file->guessExtension();
  662.         
  663.         $file = $file->move($this->getPermanentReferenceRootDir(), $fileName);
  664.         
  665.         $reference->setFilePath($fileName);
  667.         $em->flush();
  668.         
  669.         return new JsonResponse( array('success' => 1, 'filepath' => $reference->getFilePath()));
  670.     }
  671.     
  672.     /**
  673.      * Retrieve pdf file
  674.      * @Route("/{id}/file", name="reference_file", requirements={"id": "\d+"}, methods={"GET"})
  675.      */
  676.     public function getFile($id)
  677.     {
  678.         $em = $this->getDoctrine()->getManager();
  679.         
  680.         $reference = $em->getRepository('OxHoardBundle:Reference')->find($id);
  681.         if(!$reference)
  682.         {
  683.             throw $this->createNotFoundException('Unable to find Reference entity.');
  684.         }
  685.         
  686.         if(!$reference->getIsFilePublic() && !$this->getUser())
  687.         {
  688.             throw $this->createNotFoundException('Unable to find Reference file.');
  689.         }
  690.         $pdf = new File($this->getPermanentReferenceRootDir().$reference->getFilePath());
  691.         
  692.         $file = $pdf->openFile();
  693.         
  694.         $contents = file_get_contents($file->getRealPath());
  695.         $response = new Response($contents);
  696.         $response->headers->set('Content-Type', $pdf->getMimeType());
  697.         $response->headers->set('Content-Length', $file->getSize());
  698.         $response->headers->set('ETag', md5($contents));
  699.         $response->headers->set('Last-Modified', $reference->getModifiedDate()->format('D, d M Y H:i:s T'));
  700.         
  701.         return $response;
  702.     }
  704.     /**
  705.      * Delete pdf file
  706.      * @Route("/{id}/ajax_delete_file", methods={"POST"})
  707.      */
  708.     public function deleteFile(Request $request, $id)
  709.     {
  710.         $em = $this->getDoctrine()->getManager();
  711.         $reference = $em->getRepository('OxHoardBundle:Reference')->find($id);
  712.         if(!$reference)
  713.         {
  714.             throw $this->createNotFoundException('Unable to find Reference entity.');
  715.         }
  716.         $this->checkAccess($reference, 'edit');
  717.         $pdf = new File($this->getPermanentReferenceRootDir().$reference->getFilePath());
  718.         $filesystem = new Filesystem();
  719.         $filesystem->remove($pdf);
  720.         
  721.         $reference->setFilePath(null);
  723.         $em->flush();
  724.          
  725.         return new JsonResponse( array('success' => 1));
  726.     }
  728.     private function cleanZenonField($input) {
  729.         //use a regex to strip any extraneous punctuation chars from the end
  730.         // e.g. "London :" --> "London"
  731.         // e.g. "Ionian magistrates. Caracalla or Elagabalus? -." -> "Ionian magistrates. Caracalla or Elagabalus?"
  732.         $cleanRegex = '/(.*)(\s+[^\w\d\s]*\s*)$/';
  733.         $matches = null;
  734.         if( preg_match($cleanRegex, $input, $matches)) {
  735.             return $matches[1];
  736.         } else {
  737.             //match failed (it really shouldn't though)
  738.             return $input;
  739.         }
  740.     }
  742.     //return an array of strings from matches for the given tag (e.g. '300') and code (e.g. 'a')
  743.     private function extractZenonParam($xpath, $tag, $code, $clean = true) {
  744.         $query = '//marc:datafield[@tag="'.$tag.'"]';
  745.         if($code) {
  746.             $query .= '/marc:subfield[@code="'.$code.'"]';
  747.         }
  748.         $els = $xpath->query($query);
  749.         
  750.         $resp = [];
  751.         foreach($els as $el) {
  752.             $content = $el->textContent;
  753.             if($clean) {
  754.                 $resp[] = $this->cleanZenonField($content);
  755.             } else {
  756.                 $resp[] = $content;
  757.             }
  758.         }
  759.         return $resp;
  760.     }
  762.     /**
  763.      *  Look up zenon reference
  764.      *  @Route("/zenon_lookup/{id}", name="zenon_lookup", methods={"GET"})
  765.      */
  766.     public function zenonLookupAction($id) {
  767.         
  768.         $output = $this->getZenonInfo($id);
  769.         return new JsonResponse($output);
  770.     }
  771.     
  772.     // given an array of strings ["A", "B", "C", "D"], join them as "A, B, C and D"
  773.     private function joinZenonEntries($entries) {
  774.         $out = "";
  775.         $len = count($entries);
  776.         foreach($entries as $i => $entry) {
  777.             if($i === 0) {
  778.                 //first
  779.                 $out .= $entry;
  780.             } else if($i < $len -1) {
  781.                 //middle
  782.                 $out .= ", ".$entry;
  783.             } else {
  784.                 //last
  785.                 $out .= " and ".$entry;
  786.             }
  787.         }
  788.         return $out;
  789.     }
  790.     
  791.     private function getZenonInfo($id) {
  792.         // $url = "http://opac.dainst.org/OAI?verb=GetRecord&identifier=oai:dai-all:DAI01-".$id."&metadataPrefix=marc21";
  793.         $url = "https://zenon.dainst.org/Record/".$id."/Export?style=MARCXML";
  794.         $defaults = array(
  795.             CURLOPT_URL => $url,
  796.             CURLOPT_HEADER => 0,
  797.             CURLOPT_RETURNTRANSFER => TRUE,
  798.             CURLOPT_TIMEOUT => 4
  799.         );
  800.         
  801.         $ch = curl_init();
  802.         curl_setopt_array($ch, $defaults);
  803.         if( ! $result = curl_exec($ch))
  804.         { 
  805.             return new JsonResponse("Error querying zenon");
  806.         } 
  807.         curl_close($ch);
  808.         
  809.         $xmlDoc = new \DOMDocument();
  810.         $xmlDoc->loadXml($result);
  811.         $xpath = new \DomXPath($xmlDoc);
  812.         $xpath->registerNamespace('marc', 'http://www.loc.gov/MARC21/slim');
  813.         // $xpath->registerNamespace('', 'http://www.openarchives.org/OAI/2.0/');
  814.         //extract the relevant fields
  815.         //tag 245a = Title
  816.         //tag 245b = Subtitle
  817.         //tag 110 = Corporate authors
  818.         //tag 100a = author
  819.         //tag 710a = Other authors
  820.         // see http://zenon.dainst.org/Record/000294077 where other authors is at 700a
  821.         //tag 260a = place
  822.         //tag 260b = publisher
  823.         //tag 260c = publication year
  824.         //tag 440a = Title Edition?
  825.         //tag 995n = Included in = Title edition
  826.         //tag 300a = pages
  827.         //tag 440v = volume
  828.         //tag 700a = additional authors
  829.         
  830.         //tag 995b = included in zenon ID
  831.         
  832.         //Assuming any field could yield multiple results from zenon (authors, editors often will)
  833.         // concatenate all results with a comma
  834.         
  835.         $output = [
  836.             'zenon_url' => $url
  837.         ];
  838.         
  839.         $errs = $xmlDoc->getElementsByTagName('error');
  840.         if($errs->length) {
  841.             $output['zenon_error'] = $errs->item(0)->textContent;
  842.         } else {
  843.             //title
  844.             $titles = $this->extractZenonParam($xpath, '245', 'a', false);
  845.             $subtitles = $this->extractZenonParam($xpath, '245', 'b', false);
  846.             //combine subtitles. Unlikely to be more than one of each, but just in case
  847.             // $output['title'] = $this->cleanZenonField(implode(', ', $titles) ." ". implode(', ', $subtitles));
  848.             $output['title'] = $this->cleanZenonField($this->joinZenonEntries($titles) ." ". $this->joinZenonEntries($subtitles));
  849.             
  850.             //authors
  851.             $mainAuthors = $this->extractZenonParam($xpath, '100', 'a');
  852.             $output['mainAuthors'] = $this->joinZenonEntries($mainAuthors);
  853.             $additionalAuthors = $this->extractZenonParam($xpath, '700', 'a');
  854.             $output['additionalAuthors'] = $this->joinZenonEntries($additionalAuthors);
  855.             $allAuthors = array_merge($mainAuthors, $additionalAuthors);
  856.             $output['authors'] = $this->joinZenonEntries($allAuthors);
  857.             
  858.             //place
  859.             $places = $this->extractZenonParam($xpath, '260', 'a');
  860.             $output['place'] = $this->joinZenonEntries($places);
  861.             
  862.             //publisher
  863.             $publishers = $this->extractZenonParam($xpath, '260', 'a');
  864.             $output['publisher'] = $this->joinZenonEntries($publishers);
  865.             
  866.             //publication year
  867.             $pubYears = $this->extractZenonParam($xpath, '260', 'c');
  868.             $output['year'] = $this->joinZenonEntries($pubYears);
  869.             
  870.             //title edition, might be tag 440a or 995n (for a chapter)
  871.             $titleEds = $this->extractZenonParam($xpath, '440', 'a');
  872.             // don't use the 995 field - get by following link to parent
  873.             // if(count($titleEds) == 0) {
  874.             //     $titleEds = $this->extractZenonParam($xpath, '995', 'n');
  875.             // }
  876.             $output['titleEdition'] = $this->joinZenonEntries($titleEds);
  877.             
  878.             //pages
  879.             $pagesSet = $this->extractZenonParam($xpath, '300', 'a');
  880.             $output['pages'] = $this->joinZenonEntries($pagesSet);
  881.             
  882.             //volume - might be tag 440v, or if this is a parent record representing a volume, tag 245n
  883.             $volumes = $this->extractZenonParam($xpath, '440', 'v');
  884.             if(count($volumes) == 0) {
  885.                 $volumes = $this->extractZenonParam($xpath, '245', 'n');
  886.             }
  887.             $output['volume'] = $this->joinZenonEntries($volumes);
  888.             
  889.             //additional authors
  890.             $additionalAuthors = $this->extractZenonParam($xpath, '700', 'a');
  891.             $output['additionalAuthors'] = $this->joinZenonEntries($additionalAuthors);
  892.             
  893.             // get further info from the publication which this is included in (e.g. for article / chapter)
  894.             $parentIds = $this->extractZenonParam($xpath, '995', 'b');
  895.             if(count($parentIds) > 0) {
  896.                 //assume only 1 parent
  897.                 $parentId = $parentIds[0];
  898.                 $parentData = $this->getZenonInfo($parentId);
  899.                 if(!isset($output['place']) || $output['place'] == '') {
  900.                     $output['place'] = $parentData['place'];
  901.                 }
  902.                 if(!isset($output['publisher']) || $output['publisher'] == '') {
  903.                     $output['publisher'] = $parentData['publisher'];
  904.                 }
  905.                 if(!isset($output['year']) || $output['year'] == '') {
  906.                     $output['year'] = $parentData['year'];
  907.                 }
  908.                 if(!isset($output['editors']) || $output['editors'] == '') {
  909.                     $output['editors'] = $parentData['additionalAuthors'];
  910.                 }
  911.                 // Use the author of the parent reference as editor of this reference?
  912.                 
  913.                 if(!isset($output['volume']) || $output['volume'] == '') {
  914.                     $output['volume'] = $parentData['volume'];
  915.                 }
  916.                 if(!isset($output['titleEdition']) || $output['titleEdition'] == '') {
  917.                     $output['titleEdition'] = $parentData['title'];
  918.                 }
  919.             }
  920.         }
  922.         return $output;
  923.     }
  925.     /**
  926.      *  Look up ocre reference
  927.      *  @Route("/ocre_lookup/{id}", name="ocre_lookup", methods={"GET"})
  928.      */
  929.     public function ocreLookupAction($id) {
  930.         $output = $this->getOcreInfo($id);
  931.         if (is_array($output) && $output['error_code']) {
  932.             return new JsonResponse($output['error'], $output['error_code']);
  933.         } else {
  934.             return new JsonResponse($output);
  935.         }
  936.     }
  937.     
  938.     private function getOcreInfo($id) {
  939.         $url = "http://numismatics.org/ocre/id/". $id .".jsonld";
  940.         $defaults = array(
  941.             CURLOPT_URL => $url,
  942.             CURLOPT_HEADER => 0,
  943.             CURLOPT_RETURNTRANSFER => TRUE,
  944.             CURLOPT_TIMEOUT => 4
  945.         );
  946.         
  947.         $ch = curl_init();
  948.         curl_setopt_array($ch, $defaults);
  949.         $result = curl_exec($ch);
  950.         $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
  951.         curl_close($ch);
  952.         if($httpCode != "200")
  953.         {
  954.             return [
  955.                 'error' => 'Error querying '. $url,
  956.                 'error_code' => $httpCode
  957.             ];
  958.         }
  959.         $output = json_decode($result);
  960.         return $output;
  961.     }
  963.     /**
  964.      * checks permission of user's current request
  965.      *
  966.      * @param mixed $entity The entity being validated
  967.      *
  968.      * @param string $attribute - 'view' or 'edit' or 'delete'
  969.      *
  970.      * @param boolean $throwException - whether to throw an exception if false - defaults to true
  971.      *
  972.      * @return boolean
  973.      *
  974.      * @throws \Symfony\Component\Security\Core\Exception\AccessDeniedException
  975.      */
  976.     private function checkAccess($entity, $attribute, $throwException = true) {
  977.         // call security voter(s)
  978.         if (!$this->getUser()) {
  979.             if ($throwException) {
  980.                 throw new AccessDeniedException('Unauthorised access!');
  981.             }
  982.             return false;
  983.         }
  984.         return true;
  985.     }
  987.     private function userIsAdmin() {
  988.         if($this->getUser() && ($this->getUser()->hasRole('ROLE_ADMIN') || $this->getUser()->hasRole('ROLE_SUPER_ADMIN')))
  989.         {
  990.             return true;
  991.         }
  992.         return false;
  993.     }
  995.     private function getPermanentReferenceRootDir() {
  996.         return "/srv/hoards_references/";
  997.     }
  998.     
  999. }