src/Trinity/BlogBundle/Repository/EntryRepository.php line 12

Open in your IDE?
  1. <?php
  2. namespace App\Trinity\BlogBundle\Repository;
  3. use Doctrine\Common\Collections\ArrayCollection;
  4. use Doctrine\ORM\EntityRepository;
  5. class EntryRepository extends EntityRepository
  6. {
  7.     public function filter($blogid$doCount false$offset$limit$filter){
  8.         $em $this->getEntityManager();
  9.         $q          = (!empty($filter) && !empty($filter['q']) ? $filter['q'] : null);
  10.         $sort       = (!empty($filter['sort']) && $filter['sort'] != '' $filter['sort'] : 'p.id');
  11.         $order      = (!empty($filter['order']) && $filter['order'] == 'asc' 'asc' 'desc');
  12.         $category      = (!empty($filter['category']) ? $filter['category'] : null);
  13.         $concept null;
  14.         if($filter['concept'] != "")
  15.         {
  16.             if ($filter['concept'] == '1')
  17.             {
  18.                 $concept "AND p.concept = 1";
  19.             }else {
  20.                 $concept "AND p.concept = 0";
  21.             }
  22.         }
  23.         // Force $q to array
  24.         if(!is_array($q)){
  25.             $q = [$q];
  26.         }
  27.         $queries = [];
  28.         $joins = [];
  29.         foreach($q as $part){
  30.             if(empty($part)) continue;
  31.             $queries[] = "
  32.             (
  33.                 p.id LIKE '%" $part "%' OR
  34.                 p.label LIKE '%" $part "%'
  35.             )
  36.             ";
  37.         }
  38.         if($category){
  39.             $joins[] = "
  40.             JOIN p.category c
  41.             ";
  42.             $queries[] = "
  43.             c.id = " $category "
  44.             ";
  45.         }
  46.         $sql "
  47.         SELECT " . ($doCount "count(p)" "p") . "
  48.         FROM TrinityBlogBundle:Entry p
  49.         " . (!empty($joins) ? implode("\n"$joins) : "") . "
  50.         WHERE 1 = 1
  51.         AND p.blog = " $blogid "
  52.        " $concept "
  53.         " . (!empty($queries) ? " AND " implode(" AND "$queries) : "") . "
  54.         ORDER BY {$sort} {$order},p.id DESC
  55.         ";
  56.         // dump($sql);die();
  57.         $query $em->createQuery($sql);
  58.         if($doCount){
  59.             return $query->getSingleScalarResult();
  60.         }else{
  61.             // dump($query->getResult());
  62.             // die();
  63.         }
  64.         return $query->setFirstResult($offset)->setMaxResults($limit)->getResult();
  65.     }
  66.     public function findByNot(array $criteria2, array $criteria, array $orderBy null$limit null$offset null)
  67.     {
  68.         $qb $this->getEntityManager()->createQueryBuilder();
  69.         $expr $this->getEntityManager()->getExpressionBuilder();
  70.         $qb->select('Entry')
  71.             ->from('TrinityBlogBundle:Entry''Entry');
  72.         foreach ($criteria as $field => $value) {
  73.             if (is_null($value)) {
  74.                 $qb->andWhere('Entry.' $field ' IS NOT NULL');
  75.             } else {
  76.                 $qb->andWhere($expr->neq('Entry.' $field$value));
  77.             }
  78.         }
  79.         foreach ($criteria2 as $field => $value) {
  80.             $qb->andWhere($expr->eq('Entry.' $field$value));
  81.         }
  82.         $qb->andWhere('datePublish <= :date');
  83.         $qb->setParameter('date', new \DateTime('now'));
  84.         if ($orderBy) {
  85.             foreach ($orderBy as $field => $order) {
  86.                 $qb->addOrderBy('Entry.' $field$order);
  87.             }
  88.         }
  89.         if ($limit)
  90.             $qb->setMaxResults($limit);
  91.         if ($offset)
  92.             $qb->setFirstResult($offset);
  93.         $q $qb->getQuery();
  94.         return $q->getResult();
  95.     }
  96. //    public function getMostViewedByCategory()
  97. //    {
  98. //        $sql = "
  99. //            SELECT        C
  100. //            FROM        TrinityBlogBundle:Category AS C
  101. //        ";
  102. //
  103. //        $result = $this->getEntityManager()->createQuery($sql)->getResult();
  104. //        foreach($result as $cat){
  105. //
  106. //            $sql = "
  107. //                SELECT        E
  108. //                FROM        TrinityBlogBundle:Entry AS E
  109. //                WHERE         E.category IN (" . $cat->getId() . ")
  110. //                GROUP BY     E.id
  111. //                ORDER BY     E.readcount DESC
  112. //            ";
  113. ////
  114. //
  115. //            $entry = $this->getEntityManager()->createQuery($sql)->getResult();
  116. //            dump($entry);die;
  117. //
  118. ////            die();
  119. //        }
  120. ////
  121. ////        die();
  122. //    }
  123.     /**
  124.      * Find a number of random posts which are not displayed yet
  125.      *
  126.      * @param integer $limit Number of entries to return
  127.      * @param array $neq Array of disallowed blog Entry id's
  128.      * @return ArrayCollection
  129.      */
  130.     public function findByRandom($Blog$limit 8$neq = []) {
  131.         $qb $this->createQueryBuilder('ran');
  132.         $qb->andWhere('ran.blog = ' $Blog->getId());
  133.         $qb->andWhere('ran.datePublish <= :date');
  134.         $qb->setParameter('date', new \DateTime('now'));
  135.         foreach ($neq as $key => $id) {
  136.             $qb->andWhere('ran.id != :id' $key);
  137.             $qb->setParameter('id' $key$id);
  138.         }
  139.         $query $qb->getQuery();
  140.         $entries $query->execute();
  141.         $max = (count($entries) < $limit) ? count($entries) : $limit;
  142.         if (!empty($entries))
  143.         {
  144.             $entity_ids array_rand($entries$max);
  145.         }else{
  146.             $entity_ids = [];
  147.         }
  148.         $random_entities = new ArrayCollection();
  149.         foreach ((array)$entity_ids as $eid) {
  150.             $random_entities[] = $entries[$eid];
  151.         }
  152.         return $random_entities;
  153.     }
  154.     public function findEntriesByCategoryName($categoryName ''$limit null$offset 0){
  155.         $em $this->getEntityManager();
  156.         if(!empty($categoryName)){
  157.             $sql "SELECT p
  158.             FROM TrinityBlogBundle:Entry p
  159.             JOIN p.category c
  160.             WHERE c.category = '" $categoryName "'
  161.             AND p.concept = 0
  162.             AND p.datePublish <= '" date('Y-m-d H:i:s') . "'
  163.             AND (
  164.                 p.datePublishEnd >= '" date('Y-m-d H:i:s') . "'
  165.             OR
  166.                 p.datePublishEnd IS NULL
  167.             )
  168.             ORDER BY p.datePublish DESC";
  169.         }else{
  170.             $sql "SELECT p
  171.             FROM TrinityBlogBundle:Entry p
  172.             WHERE p.concept = 0
  173.             AND p.datePublish <= '" date('Y-m-d H:i:s') . "'
  174.             AND (
  175.                 p.datePublishEnd >= '" date('Y-m-d H:i:s') . "'
  176.             OR
  177.                 p.datePublishEnd IS NULL
  178.             )
  179.             ORDER BY p.datePublish DESC";
  180.         }
  181.         $query $em->createQuery($sql);
  182.         if ($limit) {
  183.             $query->setMaxResults($limit);
  184.         }
  185.         $query->setFirstResult($offset);
  186.         return $query->getResult();
  187.     }
  188.     public function findEntriesByCategory($blog$categories$concept false$limit null$offset 0){
  189.         $em $this->getEntityManager();
  190.         // Force $categories to array
  191.         if(!is_array($categories) && !is_null($categories)){
  192.             $categories = [$categories];
  193.         }
  194.         $sql "
  195.             SELECT p
  196.             FROM TrinityBlogBundle:Entry p
  197.         ";
  198.         if(!empty($categories) && implode(','$categories) != '') {
  199.             $sql .= "
  200.                 JOIN p.category c
  201.                ";
  202.         }
  203.         $sql .= "
  204.             WHERE p.blog = " $blog->getId() . "
  205.             AND p.concept = " . ($concept 0) . "
  206.             AND p.datePublish <= '" date('Y-m-d H:i:s') . "'
  207.             AND (
  208.                 p.datePublishEnd >= '" date('Y-m-d H:i:s') . "'
  209.             OR
  210.                 p.datePublishEnd IS NULL
  211.             )
  212.             ";
  213.         if (!empty($categories)) {
  214.             if(is_array($categories)) {
  215.                 $counter 0;
  216.                 foreach ($categories as $cat) {
  217.                     if (!empty($cat)) {
  218.                         if ($counter == 0) {
  219.                             $sql .= "AND (c.id = " $cat " ";
  220.                         } else {
  221.                             $sql .= "OR c.id = " $cat " ";
  222.                         }
  223.                         $counter += 1;
  224.                     }
  225.                 }
  226.                 if ($counter >= 1) {
  227.                     $sql .= ") ";
  228.                 }
  229.             }
  230.         }
  231.         $sql .=  "
  232.         ORDER BY p.datePublish DESC
  233.             ";
  234.         $query $em->createQuery($sql);
  235.         if ($limit) {
  236.             $query->setMaxResults($limit);
  237.         }
  238.         $query->setFirstResult($offset);
  239.         return $query->getResult();
  240.     }
  241.     public function findEntriesPublishedNow($blog$concept false$limit null$offset 0)
  242.     {
  243.         $em $this->getEntityManager();
  244.         $query $em->createQuery(
  245.             "
  246.             SELECT p
  247.             FROM TrinityBlogBundle:Entry p
  248.             WHERE p.blog = " . (!empty($blog) ? $blog->getId() : 0) . "
  249.             AND (p.concept = " . ($concept " OR p.concept IS NULL") . ")
  250.             AND p.datePublish <= '" date('Y-m-d H:i:s') . "'
  251.             AND (
  252.                 p.datePublishEnd >= '" date('Y-m-d H:i:s') . "'
  253.             OR
  254.                 p.datePublishEnd IS NULL
  255.             )
  256.             ORDER BY p.datePublish DESC
  257.             "
  258.         );
  259.         if ($limit) {
  260.             $query->setMaxResults($limit);
  261.         }
  262.         $query->setFirstResult($offset);
  263.         return $query->getResult();
  264.     }
  265.     public function findPopularEntriesPublishedNow($blog$limit 10)
  266.     {
  267.         $em $this->getEntityManager();
  268.         $query $em->createQuery(
  269.             "
  270.             SELECT p
  271.             FROM TrinityBlogBundle:Entry p
  272.             WHERE p.blog = " . (!empty($blog) ? $blog->getId() : 0) . "
  273.             AND p.concept = 0
  274.             AND p.datePublish <= '" date('Y-m-d H:i:s') . "'
  275.             AND (
  276.                 p.datePublishEnd >= '" date('Y-m-d H:i:s') . "'
  277.             OR
  278.                 p.datePublishEnd IS NULL
  279.             )
  280.             ORDER BY p.readcount DESC
  281.             "
  282.         );
  283.         if ($limit) {
  284.             $query->setMaxResults($limit);
  285.         }
  286.         $query->setFirstResult(0);
  287.         return $query->getResult();
  288.     }
  289.     public function findRecentEntriesPublishedNow($blog$limit 10$ignoreIds = [])
  290.     {
  291.         $em $this->getEntityManager();
  292.         if(!is_array($ignoreIds)){
  293.             $ignoreIds = [$ignoreIds];
  294.         }
  295.         $query $em->createQuery(
  296.             "
  297.             SELECT p
  298.             FROM TrinityBlogBundle:Entry p
  299.             WHERE p.blog = " $blog->getId() . "
  300.             AND p.concept = 0
  301.             AND p.body != ''
  302.             AND p.id NOT IN(" implode(','$ignoreIds) . ")
  303.             AND p.datePublish <= '" date('Y-m-d H:i:s') . "'
  304.             AND (
  305.                 p.datePublishEnd >= '" date('Y-m-d H:i:s') . "'
  306.             OR
  307.                 p.datePublishEnd IS NULL
  308.             )
  309.             ORDER BY p.datePublish DESC
  310.             "
  311.         );
  312.         if ($limit) {
  313.             $query->setMaxResults($limit);
  314.         }
  315.         $query->setFirstResult(0);
  316.         return $query->getResult();
  317.     }
  318.     public function findPopularEntriesPublishedByCategoryNow($language$categories$limit 10$ignoreIds = [])
  319.     {
  320.         $em $this->getEntityManager();
  321.         // Force $categories to array
  322.         if(!is_array($categories) && !is_null($categories)){
  323.             $categories = [$categories];
  324.         }
  325.         if(!is_array($ignoreIds)){
  326.             $ignoreIds = [$ignoreIds];
  327.         }
  328.         $sql "
  329.             SELECT e
  330.             FROM TrinityBlogBundle:Entry e
  331.             JOIN e.blog b
  332.         ";
  333.         if (!empty($categories)) {
  334.             $sql .= "JOIN e.category c ";
  335.         }
  336.         $sql .= "
  337.             WHERE b.language = " $language->getId() . "
  338.             AND e.concept = 0
  339.             AND e.body != ''
  340.             ";
  341.         if (!empty($ignoreIds)) {
  342.             $sql .= "
  343.                 AND e.id NOT IN(" implode(','$ignoreIds) . ")
  344.             ";
  345.         }
  346.         $sql .= "AND e.datePublish <= '" date('Y-m-d H:i:s') . "'
  347.             ";
  348.         if (!empty($categories)) {
  349.             if(is_array($categories)) {
  350.                 $counter 0;
  351.                 foreach ($categories as $cat) {
  352.                     if (!empty($cat)) {
  353.                         if ($counter == 0) {
  354.                             $sql .= "AND (c.id = " $cat " ";
  355.                         } else {
  356.                             $sql .= "OR c.id = " $cat " ";
  357.                         }
  358.                         $counter += 1;
  359.                     }
  360.                 }
  361.                 if ($counter >= 1) {
  362.                     $sql .= ") ";
  363.                 }
  364.             }
  365.         }
  366.         $sql .= "
  367.             ORDER BY e.datePublish DESC
  368.             ";
  369.         $query $em->createQuery($sql);
  370.         return $query->getResult();
  371.     }
  372.     public function findEntriesByLanguage($language$categories null$limit null$offset 0)
  373.     {
  374.         $em $this->getEntityManager();
  375.         // Force $categories to array
  376.         if(!is_array($categories) && !is_null($categories)){
  377.             $categories = [$categories];
  378.         }
  379.         $sql "
  380.             SELECT e
  381.             FROM TrinityBlogBundle:Entry e
  382.             JOIN e.blog b
  383.             ";
  384.         if (!empty($categories)) {
  385.             $sql .= "JOIN e.category c ";
  386.         }
  387.         $sql .= "
  388.             WHERE b.language = '" $language->getId() . "'
  389.             AND e.concept = 0
  390.             AND e.body != ''
  391.             AND e.datePublish <= '" date('Y-m-d H:i:s') . "'
  392.             AND (
  393.                 e.datePublishEnd >= '" date('Y-m-d H:i:s') . "'
  394.             OR
  395.                 e.datePublishEnd IS NULL
  396.             )
  397.             ";
  398.         if (!empty($categories)) {
  399.             if(is_array($categories)) {
  400.                 $counter 0;
  401.                 foreach ($categories as $cat) {
  402.                     if (!empty($cat)) {
  403.                         if ($counter == 0) {
  404.                             $sql .= "AND (c.id = " $cat " ";
  405.                         } else {
  406.                             $sql .= "OR c.id = " $cat " ";
  407.                         }
  408.                         $counter += 1;
  409.                     }
  410.                 }
  411.                 if ($counter >= 1) {
  412.                     $sql .= ") ";
  413.                 }
  414.             }
  415.         }
  416.         $sql .= "
  417.             ORDER BY e.datePublish DESC
  418.             ";
  419.         $query $em->createQuery($sql);
  420.         if ($limit) {
  421.             $query->setMaxResults($limit);
  422.         }
  423.         $query->setFirstResult($offset);
  424.         return $query->getResult();
  425.     }
  426. }