src/Repository/PostPublishesRepository.php line 46

Open in your IDE?
  1. <?php
  3. namespace App\Repository;
  5. use App\Entity\Categories;
  6. use App\Entity\GroupBoxItems;
  7. use App\Entity\PostDatas;
  8. use App\Entity\PostPublishes;
  9. use App\Entity\PostsCates;
  10. use App\Entity\PostsTags;
  11. use App\Entity\PostViews;
  12. use App\Entity\Tags;
  13. use App\Utils\Constants;
  14. use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
  15. use Symfony\Bridge\Doctrine\RegistryInterface;
  17. /**
  18.  * @method PostPublishes|null find($id, $lockMode = null, $lockVersion = null)
  19.  * @method PostPublishes|null findOneBy(array $criteria, array $orderBy = null)
  20.  * @method PostPublishes[]    findAll()
  21.  * @method PostPublishes[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
  22.  */
  23. class PostPublishesRepository extends ServiceEntityRepository
  24. {
  25.     public function __construct(RegistryInterface $registry)
  26.     {
  27.         parent::__construct($registry, PostPublishes::class);
  28.     }
  29.     
  30.     /**
  31.      * @param $groupBoxKey
  32.      * @param $limit
  33.      * @return mixed
  34.      */
  35.     public function getTopPostsInGroupBox($groupBoxKey, $limit)
  36.     {
  37.         $posts = $this->createQueryBuilder('p')
  38.             ->select('p.postId, p.title, p.slug, p.sapo, p.cateId, p.publishedDate, p.publishedTimestamp, p.avatar, p.focusAvatar, p.authorName, c.name cateName, c.slug cateSlug')
  39.             ->innerJoin(GroupBoxItems::class, 'gi', 'WITH', 'gi.dataId = p.postId')
  40.             ->innerJoin(Categories::class, 'c', 'WITH', 'c.cateId = p.cateId')
  41.             ->where('gi.key = :key AND p.publishedTimestamp <= :currentDate')
  42.             ->setParameters([':key' => $groupBoxKey, ':currentDate' => time()])
  43.             ->orderBy('gi.order')
  44.             ->setMaxResults($limit)
  45.             ->getQuery()
  46.             ->getResult();
  47.         
  48.         return $posts;
  49.     }
  50.     
  51.     /**
  52.      * Get Rss article in cate paging
  53.      * author: ThanhDT
  54.      * date:   2020-01-10 02:45 PM
  55.      * @param $cateId
  56.      * @param $pageSize
  57.      * @return array
  58.      */
  59.     public function getRssArticleInCatePaging($cateId, $pageSize)
  60.     {
  61.         $data = $this->createQueryBuilder('p')
  62.             ->select('p.postId, p.cateId, p.title, p.slug, p.sapo, p.publishedDate, p.publishedTimestamp, p.avatar, p.publishedTimestamp, p.authorName, pd.contentMobile AS content')
  63.             ->innerJoin(PostDatas::class, 'pd', 'WITH', 'p.postId = pd.postId')
  64.             ->innerJoin(PostsCates::class, 'c', 'WITH', 'c.postId = p.postId')
  65.             ->where('c.cateId IN (:cateId)')
  66.             ->setParameters([':cateId' => $cateId])
  67.             ->orderBy('p.publishedDate', 'DESC')
  68.             ->setMaxResults($pageSize)
  69.             ->getQuery()->getArrayResult();
  70.         
  71.         return $data;
  72.     }
  73.     
  74.     /**
  75.      * Get lastest Rss articles
  76.      * author: ThanhDT
  77.      * date:   2020-01-10 03:09 PM
  78.      * @param int $pageSize
  79.      * @return array
  80.      * @throws \Exception
  81.      */
  82.     public function getRssArticleLatest($pageSize = 9)
  83.     {
  84.         $data = $this->createQueryBuilder('p')
  85.             ->select('p.postId, p.cateId, p.title, p.slug, p.sapo, p.publishedDate, p.avatar, p.publishedTimestamp, p.authorName, pd.contentMobile AS content')
  86.             ->innerJoin(PostDatas::class, 'pd', 'WITH', 'p.postId = pd.postId')
  87.             ->where('p.publishedDate <= :currentDate')
  88.             ->setParameters([':currentDate' => new \DateTime()])
  89.             ->orderBy('p.publishedDate', 'DESC')
  90.             ->setMaxResults($pageSize)
  91.             ->getQuery()->getArrayResult();
  92.         
  93.         return $data;
  94.     }
  95.     
  96.     /**
  97.      * Get post in today
  98.      * author: ThanhDT
  99.      * date:   2020-01-09 12:31 AM
  100.      * @param int $cateId
  101.      * @return mixed
  102.      * @throws \Exception
  103.      */
  104.     public function getPostByCurrentTime($cateId = '')
  105.     {
  106.         $qp = $this->createQueryBuilder('a')
  107.             ->select('a.postId')
  108.             ->where('a.publishedDate BETWEEN :currentMonth AND :currentDate')
  109.             ->setParameters([':currentMonth' => date('Y-m'), ':currentDate' => new \DateTime()])
  110.             ->setMaxResults(1);
  111.             if ($cateId) {
  112.                 $qp->andWhere('a.cateId = :cateId ')
  113.                     ->setParameter(':cateId', $cateId);
  114.             }
  115.         return $qp->getQuery()->getResult();
  116.     }//end getPostByCurrentTime()
  118.     /**
  119.      * @param $start
  120.      * @param $end
  121.      * @param $cateId
  122.      * @return array
  123.      */
  124.     public function getPostsBetweenDates($start, $end, $cateId='')
  125.     {
  126.         $queryBuilder = $this->createQueryBuilder('p');
  127.         $selectFields = [
  128.             'p.postId',
  129.             'p.cateId',
  130.             'p.avatar',
  131.             'p.slug',
  132.             'p.sapo',
  133.             'p.title',
  134.             'c.slug as slugCate',
  135.             'p.publishedDate'
  136.         ];
  137.         $condition = $queryBuilder
  138.             ->select($selectFields)
  139.             ->innerJoin(Categories::class, 'c', 'WITH', 'c.cateId = p.cateId')
  140.             ->orderBy('p.publishedTimestamp', 'DESC')
  141.             ->where('p.publishedTimestamp BETWEEN :startDate AND :endDate')
  142.             ->setParameter('startDate', $start)
  143.             //->andWhere('p.publishedDate <= :endDate')
  144.             ->setParameter('endDate', $end);
  146.         if ($cateId) {
  147.             $condition->andWhere('p.cateId = :cateId ')
  148.                 ->setParameter(':cateId', $cateId);
  149.         }
  150.         
  151.         $postsQuery = $condition->getQuery();
  152.         $posts = $postsQuery->getArrayResult();
  153.         
  154.         return $posts;
  155.     }
  156.     
  157.     /**
  158.      * @param $cateId
  159.      * @param int $limit
  160.      * @param array $exceptIds
  161.      * @return array
  162.      */
  163.     public function getLatestPostsByCate($arrayCateId = [], $limit = 12, $exceptIds = [])
  164.     {
  165.         $query = $this->createQueryBuilder('p')
  166.             ->select('p.postId, p.cateId, p.title, p.slug, p.sapo, p.publishedDate, p.publishedTimestamp, p.avatar, p.authorName')
  167.             ->where('p.publishedTimestamp <= :now ')
  168.             ->setParameter('now', time());
  169.         
  170.         if ($arrayCateId) {
  171.             $query->innerJoin(PostsCates::class, 'c', 'WITH', 'c.postId = p.postId')
  172.                 ->andWhere('c.cateId IN (:cateId) ')
  173.                 ->setParameter(':cateId', $arrayCateId);
  174.         }
  175.         
  176.         if (!empty($exceptIds)) {
  177.             $query->andWhere('p.postId not in (:exceptIds)')
  178.                 ->setParameter(':exceptIds', $exceptIds);
  179.         }
  180.         
  181.         $data = $query->orderBy('p.publishedDate', 'DESC')
  182.             ->setMaxResults($limit)
  183.             ->getQuery()
  184.             ->getArrayResult();
  185.         
  186.         return $data;
  187.     }
  188.     
  189.     /**
  190.      * @param int $limit
  191.      * @param int $fromModify
  192.      * @param array $exceptIds
  193.      * @param array $arrayCateId
  194.      * @return array
  195.      */
  196.     public function getMostViewPosts($limit = 5, $fromModify = 172800, $exceptIds = [], $arrayCateId = [])
  197.     {
  198.         $now = time();
  199.         $from = ($now - $fromModify);
  200.         $queryBuilder = $this->createQueryBuilder('p');
  201.         $selectFields = [
  202.             'SUM(v.viewCount) AS totalView',
  203.             'p.postId',
  204.             'p.avatar',
  205.             'p.slug',
  206.             'p.sapo',
  207.             'p.title',
  208.             'p.cateId',
  209.             'p.viewCount',
  210.             'p.publishedDate',
  211.             'p.publishedTimestamp'
  212.         ];
  213.         
  214.         $condition = $queryBuilder
  215.             ->select($selectFields)
  216.             ->innerJoin(PostViews::class, 'v', 'WITH', 'p.postId = v.postId')
  217.             ->where('p.publishedTimestamp <= :now and v.timestamp >= :from and v.timestamp <= :now')
  218.             ->setParameter('now', $now)
  219.             ->setParameter('from', $from)
  220.             ->setParameter('now', $now)
  221.             ->groupBy('v.postId')
  222.             ->addOrderBy('totalView', 'DESC')
  223.             ->addOrderBy('p.publishedDate', 'DESC')
  224.             ->setMaxResults($limit);
  225.         
  226.         if ($arrayCateId) { // Anhpt4 : add list cate id
  227.             $condition->andWhere('p.cateId IN (:cateId)')->setParameter(':cateId', $arrayCateId);
  228.         }
  229.         
  230.         if ($exceptIds) {
  231.             $condition->andWhere(
  232.                 $queryBuilder->expr()->notIn('p.postId', $exceptIds)
  233.             );
  234.         }
  235.         
  236.         return $condition
  237.             ->getQuery()
  238.             ->getArrayResult();
  239.     }
  240.     
  241.     /**
  242.      * @param $tagId
  243.      * @param $limit
  244.      * @param int $timeStamp
  245.      * @param int $lastId
  246.      * @param array $ignoreIds
  247.      * @return array
  248.      */
  249.     public function getPostsByTagId($tagId, $limit, $timeStamp = 0, $lastId = 0, $ignoreIds = [])
  250.     {
  251.         if ($timeStamp) {
  252.             $date = new \DateTime();
  253.             $date->setTimestamp($timeStamp);
  254.         } else {
  255.             $date = date('Y-m-d H:i:s');
  256.         }
  257.         
  258.         $queryBuilder = $this->createQueryBuilder('p');
  259.         $condition = $queryBuilder
  260.             ->select('p.postId, p.title, p.slug, p.sapo, p.cateId, p.publishedDate, p.publishedTimestamp, p.avatar, p.authorName')
  261.             ->leftJoin(PostsTags::class, 'p_tag', 'WITH', 'p.postId = p_tag.postId')
  262.             ->where('p_tag.tagId = :tagId AND p.publishedDate <= :currentDate')
  263.             ->setParameters(
  264.                 [
  265.                     ':tagId' => $tagId,
  266.                     ':currentDate' => $date,
  267.                 ]
  268.             )
  269.             ->orderBy('p.publishedDate', 'DESC')
  270.             ->addOrderBy('p.postId', 'DESC');
  271.         if ($lastId) {
  272.             $condition
  273.                 ->andWhere('p.postId <> :lastId')
  274.                 ->setParameter('lastId', $lastId);
  275.         }
  276.         if ($ignoreIds) {
  277.             $condition->andWhere(
  278.                 $condition->expr()->notIn('p.postId', $ignoreIds)
  279.             );
  280.         }
  281.         
  282.         return $condition
  283.             ->setMaxResults($limit)
  284.             ->getQuery()
  285.             ->getArrayResult();
  286.     }//end getPostsByTagId()
  287.     
  288.     /**
  289.      * @param int $cateId
  290.      * @param array $excludePostIds
  291.      * @param int $limit
  292.      * @return array
  293.      */
  294.     public function getPostNewInCate($arrayCateId = [], $excludePostIds = [], $limit = Constants::LIMIT_FEATURED, $focusStatus = 0)
  295.     {
  296.         $query = $this->createQueryBuilder('p')
  297.             ->select('p.postId, p.title, p.slug, p.cateId, p.publishedDate, p.publishedTimestamp, p.focusStatus, p.avatar, p.sapo,p.authorName, c.name cateName, c.slug cateSlug')
  298.             ->innerJoin(Categories::class, 'c', 'WITH', 'p.cateId = c.cateId');
  299.         
  300.         if ($excludePostIds) {
  301.             $query->where('p.postId NOT IN (:postIds)')->setParameter(':postIds', $excludePostIds);
  302.         }
  303.         
  304.         if ($arrayCateId) {
  305.             $query->andWhere('p.cateId IN (:cateId)')->setParameter(':cateId', $arrayCateId);
  306.         }
  307.         
  308.         if (isset($focusStatus)) {
  309.             $query->andWhere('p.focusStatus = :focusStatus')->setParameter(':focusStatus', $focusStatus);
  310.         }
  311.         
  312.         $posts = $query->andWhere('p.publishedTimestamp <= :currentDate ')
  313.             ->setParameter(':currentDate', time())
  314.             ->addOrderBy('p.publishedTimestamp', 'DESC')
  315.             ->setMaxResults($limit)
  316.             ->getQuery()
  317.             ->getArrayResult();
  318.         
  319.         return $posts;
  320.     }//end getPostNewCate()
  321.     
  322.     /**
  323.      * Get paging posts in category
  324.      * @param $cateIds
  325.      * @param $limit
  326.      * @param $lastPublishedStamp
  327.      * @param null $excludePostIds
  328.      * @return array
  329.      */
  330.     public function getCatePosts($cateIds, $limit, $lastPublishedStamp, $excludePostIds = null)
  331.     {
  332.         $query = $this->createQueryBuilder('p')
  333.             ->select('p.postId, p.title, p.slug, p.sapo,p.reviewPoints, p.cateId, p.publishedDate, p.publishedTimestamp, p.avatar,p.authorName, c.name cateName, c.slug cateSlug')
  334.             ->innerJoin(PostsCates::class, 'pc', 'WITH', 'pc.postId = p.postId')
  335.             ->innerJoin(Categories::class, 'c', 'WITH', 'c.cateId = p.cateId');
  336.         $parameters = [];
  337.         if ($excludePostIds) {
  338.             $query->where('p.postId NOT IN (:postIds)');//->setParameter(':postIds', $excludePostIds);
  339.             $parameters[':postIds'] = $excludePostIds;
  340.         }
  341.         $query->andWhere('pc.cateId IN (:cateIds) AND p.publishedTimestamp <= :currentDate');
  342.         $parameters[':currentDate'] = $lastPublishedStamp;
  343.         $parameters[':cateIds'] = $cateIds;
  344.         $posts = $query->setParameters($parameters)
  345.             ->orderBy('p.publishedDate', 'DESC')
  346.             ->groupBy('p.postId')
  347.             ->setMaxResults($limit)
  348.             ->getQuery()
  349.             ->getArrayResult();
  350.         
  351.         return $posts;
  352.     }
  353.     
  354.     /**
  355.      * get detail post
  356.      * @param int $postId
  357.      * @param string $slug
  358.      * @return array
  359.      * author : ThangPD
  360.      * date : 2018-25-21 14:25 PM
  361.      */
  362.     public function getDetailPost($postId = 0)
  363.     {
  364.         $query = $this->createQueryBuilder('p')
  365.             ->select('p.postId, p.title, p.slug, p.avatar, p.sapo, p.cateId, p.authorId, p.authorName, p.publishedDate,
  366.             p.reviewId, p.otherTags, p.reviewPoints, p.seoMetadesc , p.seoTitle, p.seoFocusKeyword,
  367.             pd.content, pd.contentAmp, pd.cates, pd.tags, pd.relatedPosts,
  368.             pd.sourceTags, c.name cateName, c.slug cateSlug')
  369.             ->leftJoin(PostDatas::class, 'pd', 'WITH', 'p.postId = pd.postId')
  370.             ->leftJoin(Categories::class, 'c', 'WITH', 'p.cateId = c.cateId')
  371.             ->where('p.postId = ' . $postId)
  372.             ->andWhere('p.publishedDate <= :currentDate')
  373.             ->setParameter(':currentDate', new \DateTime());
  374.         $result = $query->getQuery()->getOneOrNullResult();
  375.         
  376.         return $result;
  377.     }
  378.     
  379.     /**
  380.      * modifier: AnhPT4
  381.      * modifier date: 2019-47-2 16:47 PM
  382.      * get related post by id
  383.      * @param string $ids
  384.      * @return array
  385.      * author : ThangPD
  386.      * date : 2018-20-22 10:20 AM
  387.      */
  388.     public function getRelatedPosts($ids = "", $limit = Constants::LIMIT_RELATED_POST)
  389.     {
  390.         $ids = trim($ids);
  391.         if (empty($ids))
  392.             return [];
  393.         
  394.         $ids = explode(',', $ids);
  395.         $result = $this->createQueryBuilder('p')
  396.             ->select('p.postId, p.cateId, p.title, p.slug, p.avatar, p.publishedDate, p.sapo, c.name cateName, c.slug cateSlug')
  397.             ->leftJoin(Categories::class, 'c', 'WITH', 'p.cateId = c.cateId')
  398.             ->where('p.postId IN (:ids) AND p.publishedDate <= :currentDate')
  399.             ->setParameters([':ids' => $ids, ':currentDate' => new \DateTime()])
  400.             ->setMaxResults(Constants::LIMIT_RELATED)
  401.             ->orderBy('p.publishedDate', 'DESC')
  402.             ->setMaxResults($limit)
  403.             ->getQuery()
  404.             ->getArrayResult();
  405.         
  406.         return $result;
  407.     }
  408.     
  409.     /**
  410.      * get Post In Tag
  411.      * @param array $tagsId
  412.      * @param int $limit
  413.      * @return array
  414.      */
  415.     public function getPostInTag($postId, $tagsId = [], $limit = Constants::LIMIT_RELATED_POST)
  416.     {
  417.         if (empty($tagsId))
  418.             return null;
  419.         
  420.         $result = $this->createQueryBuilder('p')
  421.             ->select('p.postId, p.title,p.slug, c.slug cateSlug')
  422.             ->innerJoin(Categories::class, 'c', 'WITH', 'p.cateId = c.cateId')
  423.             ->innerJoin(PostsTags::class, 'pc', 'WITH', 'p.postId = pc.postId')
  424.             ->innerJoin(Tags::class, 't', 'WITH', 'pc.tagId = t.tagId')
  425.             ->where('p.postId NOT IN(:postId) AND t.tagId IN (:tagId) AND p.publishedTimestamp <= :currentDate')
  426.             ->setParameters([':postId' => $postId, ':tagId' => $tagsId, ':currentDate' => time()])
  427.             ->setMaxResults(Constants::LIMIT_RELATED)
  428.             ->orderBy('p.publishedTimestamp', 'DESC')
  429.             ->setMaxResults($limit)
  430.             ->groupBy('p.postId')
  431.             ->getQuery()
  432.             ->getArrayResult();
  433.         
  434.         return $result;
  435.     }
  436.     
  437.     /**
  438.      * Get paging posts in category
  439.      * @param $cateIds
  440.      * @param $limit
  441.      * @param $lastPublishedStamp
  442.      * @param null $excludePostIds
  443.      * @return array
  444.      */
  445.     public function getPostsInCates($cateIds, $limit, $lastPublishedStamp, $fromModify, $excludePostIds = null)
  446.     {
  447.         $parameters = [];
  448.         $time = $lastPublishedStamp - $fromModify;
  449.         $parameters[':currentDate'] = $lastPublishedStamp;
  450.         $parameters[':cateIds'] = $cateIds;
  451.         $parameters[':fromDate'] = $time;
  452.         
  453.         $query = $this->createQueryBuilder('p')
  454.             ->select('p.postId, p.title, p.slug, p.sapo,p.reviewPoints, p.cateId, p.publishedDate, p.publishedTimestamp,
  455.             p.avatar,p.authorName, c.name cateName, c.slug cateSlug')
  456.             ->innerJoin(PostsCates::class, 'pc', 'WITH', 'pc.postId = p.postId')
  457.             ->innerJoin(Categories::class, 'c', 'WITH', 'c.cateId = p.cateId')
  458.             ->where('pc.cateId IN (:cateIds) AND p.publishedTimestamp <= :currentDate AND p.publishedTimestamp >= :fromDate ')
  459.             ->setParameters($parameters);
  460.         
  461.         if ($excludePostIds) {
  462.             $query->andWhere('p.postId NOT IN (:postIds)')->setParameter(':postIds', $excludePostIds);
  463.         }
  464.         
  465.         $posts = $query->orderBy('p.publishedDate', 'DESC')
  466.             ->setMaxResults($limit)
  467.             ->getQuery()
  468.             ->getArrayResult();
  469.         
  470.         return $posts;
  471.     }
  473.     /**
  474.      * Get top post for instant articles
  475.      * author: ThanhDT
  476.      * date:   2020-04-01 04:55 PM
  477.      * @param $limit
  478.      * @return array
  479.      */
  480.     public function getPostsForInstantArticle($limit)
  481.     {
  482.         $date = date('Y-m-d H:i:s');
  483.         $queryBuilder = $this->createQueryBuilder('p');
  484.         $condition = $queryBuilder
  485.             //->select('p.postId, p.title, p.slug, p.sapo, p.cateId, p.publishedDate, p.avatar')
  486.             ->select('p.postId, p.title, p.slug, p.sapo, pd.contentMobile AS content, p.cateId, p.publishedDate, p.modifiedDate, p.avatar, p.authorName')
  487.             ->innerJoin(PostDatas::class, 'pd', 'WITH', 'p.postId = pd.postId')
  488.             ->where('p.publishedDate <= :currentDate AND p.fbInstantArticle = :fbInstantArticle')
  489.             ->setParameters([':currentDate' => $date, ':fbInstantArticle' => 1])
  490.             ->orderBy('p.publishedDate', 'DESC')
  491.             ->setMaxResults($limit);
  493.         $data = $condition
  494.             ->getQuery()
  495.             ->getArrayResult();
  497.         return $data;
  498.     }//end getPostsForRss()
  499. }