vendor/contao/calendar-bundle/src/Resources/contao/classes/Calendar.php line 398

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of Contao.
  5.  *
  6.  * (c) Leo Feyer
  7.  *
  8.  * @license LGPL-3.0-or-later
  9.  */
  11. namespace Contao;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Symfony\Component\HttpFoundation\RequestStack;
  15. use Symfony\Component\HttpFoundation\Session\Session;
  16. use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
  18. /**
  19.  * Provide methods regarding calendars.
  20.  */
  21. class Calendar extends Frontend
  22. {
  23.     /**
  24.      * Current events
  25.      * @var array
  26.      */
  27.     protected $arrEvents = array();
  29.     /**
  30.      * Page cache array
  31.      * @var array
  32.      */
  33.     private static $arrPageCache = array();
  35.     /**
  36.      * Update a particular RSS feed
  37.      *
  38.      * @param integer $intId
  39.      */
  40.     public function generateFeed($intId)
  41.     {
  42.         $objCalendar = CalendarFeedModel::findByPk($intId);
  44.         if ($objCalendar === null)
  45.         {
  46.             return;
  47.         }
  49.         $objCalendar->feedName = $objCalendar->alias ?: 'calendar' . $objCalendar->id;
  51.         // Delete XML file
  52.         if (Input::get('act') == 'delete')
  53.         {
  54.             $webDir = StringUtil::stripRootDir(System::getContainer()->getParameter('contao.web_dir'));
  56.             $this->import(Files::class, 'Files');
  57.             $this->Files->delete($webDir . '/share/' . $objCalendar->feedName . '.xml');
  58.         }
  60.         // Update XML file
  61.         else
  62.         {
  63.             $this->generateFiles($objCalendar->row());
  65.             System::getContainer()->get('monolog.logger.contao.cron')->info('Generated calendar feed "' . $objCalendar->feedName . '.xml"');
  66.         }
  67.     }
  69.     /**
  70.      * Delete old files and generate all feeds
  71.      */
  72.     public function generateFeeds()
  73.     {
  74.         $this->import(Automator::class, 'Automator');
  75.         $this->Automator->purgeXmlFiles();
  77.         $objCalendar = CalendarFeedModel::findAll();
  79.         if ($objCalendar !== null)
  80.         {
  81.             while ($objCalendar->next())
  82.             {
  83.                 $objCalendar->feedName = $objCalendar->alias ?: 'calendar' . $objCalendar->id;
  84.                 $this->generateFiles($objCalendar->row());
  86.                 System::getContainer()->get('monolog.logger.contao.cron')->info('Generated calendar feed "' . $objCalendar->feedName . '.xml"');
  87.             }
  88.         }
  89.     }
  91.     /**
  92.      * Generate all feeds including a certain calendar
  93.      *
  94.      * @param integer $intId
  95.      */
  96.     public function generateFeedsByCalendar($intId)
  97.     {
  98.         $objFeed = CalendarFeedModel::findByCalendar($intId);
  100.         if ($objFeed !== null)
  101.         {
  102.             while ($objFeed->next())
  103.             {
  104.                 $objFeed->feedName = $objFeed->alias ?: 'calendar' . $objFeed->id;
  106.                 // Update the XML file
  107.                 $this->generateFiles($objFeed->row());
  109.                 System::getContainer()->get('monolog.logger.contao.cron')->info('Generated calendar feed "' . $objFeed->feedName . '.xml"');
  110.             }
  111.         }
  112.     }
  114.     /**
  115.      * Generate an XML file and save it to the root directory
  116.      *
  117.      * @param array $arrFeed
  118.      */
  119.     protected function generateFiles($arrFeed)
  120.     {
  121.         $arrCalendars = StringUtil::deserialize($arrFeed['calendars']);
  123.         if (empty($arrCalendars) || !\is_array($arrCalendars))
  124.         {
  125.             return;
  126.         }
  128.         $strType = ($arrFeed['format'] == 'atom') ? 'generateAtom' : 'generateRss';
  129.         $strLink = $arrFeed['feedBase'] ?: Environment::get('base');
  130.         $strFile = $arrFeed['feedName'];
  132.         $objFeed = new Feed($strFile);
  133.         $objFeed->link = $strLink;
  134.         $objFeed->title = $arrFeed['title'];
  135.         $objFeed->description = $arrFeed['description'];
  136.         $objFeed->language = $arrFeed['language'];
  137.         $objFeed->published = $arrFeed['tstamp'];
  139.         $arrUrls = array();
  140.         $this->arrEvents = array();
  141.         $time = time();
  143.         // Get the upcoming events
  144.         $objArticle = CalendarEventsModel::findUpcomingByPids($arrCalendars, $arrFeed['maxItems']);
  146.         // Parse the items
  147.         if ($objArticle !== null)
  148.         {
  149.             while ($objArticle->next())
  150.             {
  151.                 // Never add unpublished elements to the RSS feeds
  152.                 if (!$objArticle->published || ($objArticle->start && $objArticle->start > $time) || ($objArticle->stop && $objArticle->stop <= $time))
  153.                 {
  154.                     continue;
  155.                 }
  157.                 $jumpTo = $objArticle->getRelated('pid')->jumpTo;
  159.                 // No jumpTo page set (see #4784)
  160.                 if (!$jumpTo)
  161.                 {
  162.                     continue;
  163.                 }
  165.                 $objParent = $this->getPageWithDetails($jumpTo);
  167.                 // A jumpTo page is set but does no longer exist (see #5781)
  168.                 if ($objParent === null)
  169.                 {
  170.                     continue;
  171.                 }
  173.                 // Get the jumpTo URL
  174.                 if (!isset($arrUrls[$jumpTo]))
  175.                 {
  176.                     $arrUrls[$jumpTo] = $objParent->getAbsoluteUrl(Config::get('useAutoItem') ? '/%s' : '/events/%s');
  177.                 }
  179.                 $strUrl = $arrUrls[$jumpTo];
  180.                 $this->addEvent($objArticle, $objArticle->startTime, $objArticle->endTime, $strUrl);
  182.                 // Recurring events
  183.                 if ($objArticle->recurring)
  184.                 {
  185.                     $arrRepeat = StringUtil::deserialize($objArticle->repeatEach);
  187.                     if (!isset($arrRepeat['unit'], $arrRepeat['value']) || $arrRepeat['value'] < 1)
  188.                     {
  189.                         continue;
  190.                     }
  192.                     $count = 0;
  193.                     $intStartTime = $objArticle->startTime;
  194.                     $intEndTime = $objArticle->endTime;
  195.                     $strtotime = '+ ' . $arrRepeat['value'] . ' ' . $arrRepeat['unit'];
  197.                     // Do not include more than 20 recurrences
  198.                     while ($count++ < 20)
  199.                     {
  200.                         if ($objArticle->recurrences > 0 && $count >= $objArticle->recurrences)
  201.                         {
  202.                             break;
  203.                         }
  205.                         $intStartTime = strtotime($strtotime, $intStartTime);
  206.                         $intEndTime = strtotime($strtotime, $intEndTime);
  208.                         if ($intStartTime >= $time)
  209.                         {
  210.                             $this->addEvent($objArticle, $intStartTime, $intEndTime, $strUrl, '', true);
  211.                         }
  212.                     }
  213.                 }
  214.             }
  215.         }
  217.         $count = 0;
  218.         ksort($this->arrEvents);
  220.         $container = System::getContainer();
  222.         /** @var RequestStack $requestStack */
  223.         $requestStack = System::getContainer()->get('request_stack');
  224.         $currentRequest = $requestStack->getCurrentRequest();
  226.         $origObjPage = $GLOBALS['objPage'] ?? null;
  228.         // Add the feed items
  229.         foreach ($this->arrEvents as $days)
  230.         {
  231.             foreach ($days as $events)
  232.             {
  233.                 foreach ($events as $event)
  234.                 {
  235.                     if ($arrFeed['maxItems'] > 0 && $count++ >= $arrFeed['maxItems'])
  236.                     {
  237.                         break 3;
  238.                     }
  240.                     // Override the global page object (#2946)
  241.                     $GLOBALS['objPage'] = $this->getPageWithDetails(CalendarModel::findByPk($event['pid'])->jumpTo);
  243.                     // Push a new request to the request stack (#3856)
  244.                     $request = $this->createSubRequest($event['link'], $currentRequest);
  245.                     $request->attributes->set('_scope', 'frontend');
  246.                     $requestStack->push($request);
  248.                     $objItem = new FeedItem();
  249.                     $objItem->title = $event['title'];
  250.                     $objItem->link = $event['link'];
  251.                     $objItem->published = $event['tstamp'];
  252.                     $objItem->begin = $event['startTime'];
  253.                     $objItem->end = $event['endTime'];
  255.                     if ($event['isRepeated'] ?? null)
  256.                     {
  257.                         $objItem->guid = $event['link'] . '#' . date('Y-m-d', $event['startTime']);
  258.                     }
  260.                     if (($objAuthor = UserModel::findById($event['author'])) !== null)
  261.                     {
  262.                         $objItem->author = $objAuthor->name;
  263.                     }
  265.                     // Prepare the description
  266.                     if ($arrFeed['source'] == 'source_text')
  267.                     {
  268.                         $strDescription = '';
  269.                         $objElement = ContentModel::findPublishedByPidAndTable($event['id'], 'tl_calendar_events');
  271.                         if ($objElement !== null)
  272.                         {
  273.                             // Overwrite the request (see #7756)
  274.                             $strRequest = Environment::get('request');
  275.                             Environment::set('request', $objItem->link);
  277.                             while ($objElement->next())
  278.                             {
  279.                                 $strDescription .= $this->getContentElement($objElement->current());
  280.                             }
  282.                             Environment::set('request', $strRequest);
  283.                         }
  284.                     }
  285.                     else
  286.                     {
  287.                         $strDescription = $event['teaser'] ?? '';
  288.                     }
  290.                     $strDescription = System::getContainer()->get('contao.insert_tag.parser')->replaceInline($strDescription);
  291.                     $objItem->description = $this->convertRelativeUrls($strDescription, $strLink);
  293.                     if (\is_array($event['media:content']))
  294.                     {
  295.                         foreach ($event['media:content'] as $enclosure)
  296.                         {
  297.                             $objItem->addEnclosure($enclosure, $strLink, 'media:content', $arrFeed['imgSize']);
  298.                         }
  299.                     }
  301.                     if (\is_array($event['enclosure']))
  302.                     {
  303.                         foreach ($event['enclosure'] as $enclosure)
  304.                         {
  305.                             $objItem->addEnclosure($enclosure, $strLink);
  306.                         }
  307.                     }
  309.                     $objFeed->addItem($objItem);
  311.                     $requestStack->pop();
  312.                 }
  313.             }
  314.         }
  316.         $GLOBALS['objPage'] = $origObjPage;
  318.         $webDir = StringUtil::stripRootDir($container->getParameter('contao.web_dir'));
  320.         // Create the file
  321.         File::putContent($webDir . '/share/' . $strFile . '.xml', System::getContainer()->get('contao.insert_tag.parser')->replaceInline($objFeed->$strType()));
  322.     }
  324.     /**
  325.      * Add events to the indexer
  326.      *
  327.      * @param array   $arrPages
  328.      * @param integer $intRoot
  329.      * @param boolean $blnIsSitemap
  330.      *
  331.      * @return array
  332.      */
  333.     public function getSearchablePages($arrPages, $intRoot=0, $blnIsSitemap=false)
  334.     {
  335.         $arrRoot = array();
  337.         if ($intRoot > 0)
  338.         {
  339.             $arrRoot = $this->Database->getChildRecords($intRoot, 'tl_page');
  340.         }
  342.         $arrProcessed = array();
  343.         $time = time();
  345.         // Get all calendars
  346.         $objCalendar = CalendarModel::findByProtected('');
  348.         // Walk through each calendar
  349.         if ($objCalendar !== null)
  350.         {
  351.             while ($objCalendar->next())
  352.             {
  353.                 // Skip calendars without target page
  354.                 if (!$objCalendar->jumpTo)
  355.                 {
  356.                     continue;
  357.                 }
  359.                 // Skip calendars outside the root nodes
  360.                 if (!empty($arrRoot) && !\in_array($objCalendar->jumpTo, $arrRoot))
  361.                 {
  362.                     continue;
  363.                 }
  365.                 // Get the URL of the jumpTo page
  366.                 if (!isset($arrProcessed[$objCalendar->jumpTo]))
  367.                 {
  368.                     $objParent = PageModel::findWithDetails($objCalendar->jumpTo);
  370.                     // The target page does not exist
  371.                     if ($objParent === null)
  372.                     {
  373.                         continue;
  374.                     }
  376.                     // The target page has not been published (see #5520)
  377.                     if (!$objParent->published || ($objParent->start && $objParent->start > $time) || ($objParent->stop && $objParent->stop <= $time))
  378.                     {
  379.                         continue;
  380.                     }
  382.                     if ($blnIsSitemap)
  383.                     {
  384.                         // The target page is protected (see #8416)
  385.                         if ($objParent->protected)
  386.                         {
  387.                             continue;
  388.                         }
  390.                         // The target page is exempt from the sitemap (see #6418)
  391.                         if ($objParent->robots == 'noindex,nofollow')
  392.                         {
  393.                             continue;
  394.                         }
  395.                     }
  397.                     // Generate the URL
  398.                     $arrProcessed[$objCalendar->jumpTo] = $objParent->getAbsoluteUrl(Config::get('useAutoItem') ? '/%s' : '/events/%s');
  399.                 }
  401.                 $strUrl = $arrProcessed[$objCalendar->jumpTo];
  403.                 // Get the items
  404.                 $objEvents = CalendarEventsModel::findPublishedDefaultByPid($objCalendar->id);
  406.                 if ($objEvents !== null)
  407.                 {
  408.                     while ($objEvents->next())
  409.                     {
  410.                         if ($blnIsSitemap && $objEvents->robots === 'noindex,nofollow')
  411.                         {
  412.                             continue;
  413.                         }
  415.                         $arrPages[] = sprintf(preg_replace('/%(?!s)/', '%%', $strUrl), ($objEvents->alias ?: $objEvents->id));
  416.                     }
  417.                 }
  418.             }
  419.         }
  421.         return $arrPages;
  422.     }
  424.     /**
  425.      * Add an event to the array of active events
  426.      *
  427.      * @param CalendarEventsModel $objEvent
  428.      * @param integer             $intStart
  429.      * @param integer             $intEnd
  430.      * @param string              $strUrl
  431.      * @param string              $strBase
  432.      * @param boolean             $isRepeated
  433.      */
  434.     protected function addEvent($objEvent, $intStart, $intEnd, $strUrl, $strBase='', $isRepeated=false)
  435.     {
  436.         if ($intEnd < time())
  437.         {
  438.             return; // see #3917
  439.         }
  441.         $intKey = date('Ymd', $intStart);
  442.         $span = self::calculateSpan($intStart, $intEnd);
  443.         $format = $objEvent->addTime ? 'datimFormat' : 'dateFormat';
  445.         /** @var PageModel $objPage */
  446.         global $objPage;
  448.         if ($objPage instanceof PageModel)
  449.         {
  450.             $date = $objPage->$format;
  451.             $dateFormat = $objPage->dateFormat;
  452.             $timeFormat = $objPage->timeFormat;
  453.         }
  454.         else
  455.         {
  456.             // Called in the back end (see #4026)
  457.             $date = Config::get($format);
  458.             $dateFormat = Config::get('dateFormat');
  459.             $timeFormat = Config::get('timeFormat');
  460.         }
  462.         // Add date
  463.         if ($span > 0)
  464.         {
  465.             $title = Date::parse($date, $intStart) . $GLOBALS['TL_LANG']['MSC']['cal_timeSeparator'] . Date::parse($date, $intEnd);
  466.         }
  467.         else
  468.         {
  469.             $title = Date::parse($dateFormat, $intStart) . ($objEvent->addTime ? ' (' . Date::parse($timeFormat, $intStart) . (($intStart < $intEnd) ? $GLOBALS['TL_LANG']['MSC']['cal_timeSeparator'] . Date::parse($timeFormat, $intEnd) : '') . ')' : '');
  470.         }
  472.         // Add title and link
  473.         $title .= ' ' . $objEvent->title;
  475.         // Backwards compatibility (see #8329)
  476.         if ($strBase && !preg_match('#^https?://#', $strUrl))
  477.         {
  478.             $strUrl = $strBase . $strUrl;
  479.         }
  481.         $link = '';
  483.         switch ($objEvent->source)
  484.         {
  485.             case 'external':
  486.                 $link = $objEvent->url;
  487.                 break;
  489.             case 'internal':
  490.                 if (($objTarget = $objEvent->getRelated('jumpTo')) instanceof PageModel)
  491.                 {
  492.                     /** @var PageModel $objTarget */
  493.                     $link = $objTarget->getAbsoluteUrl();
  494.                 }
  495.                 break;
  497.             case 'article':
  498.                 if (($objArticle = ArticleModel::findByPk($objEvent->articleId)) instanceof ArticleModel && ($objPid = $objArticle->getRelated('pid')) instanceof PageModel)
  499.                 {
  500.                     /** @var PageModel $objPid */
  501.                     $link = StringUtil::ampersand($objPid->getAbsoluteUrl('/articles/' . ($objArticle->alias ?: $objArticle->id)));
  502.                 }
  503.                 break;
  505.             default:
  506.                 $link = sprintf(preg_replace('/%(?!s)/', '%%', $strUrl), ($objEvent->alias ?: $objEvent->id));
  507.                 break;
  508.         }
  510.         // Store the whole row (see #5085)
  511.         $arrEvent = $objEvent->row();
  513.         // Override link and title
  514.         $arrEvent['link'] = $link;
  515.         $arrEvent['title'] = $title;
  517.         // Set the current start and end date
  518.         $arrEvent['startDate'] = $intStart;
  519.         $arrEvent['endDate'] = $intEnd;
  520.         $arrEvent['isRepeated'] = $isRepeated;
  522.         // Reset the enclosures (see #5685)
  523.         $arrEvent['enclosure'] = array();
  524.         $arrEvent['media:content'] = array();
  526.         // Add the article image as enclosure
  527.         if ($objEvent->addImage)
  528.         {
  529.             $objFile = FilesModel::findByUuid($objEvent->singleSRC);
  531.             if ($objFile !== null)
  532.             {
  533.                 $arrEvent['media:content'][] = $objFile->path;
  534.             }
  535.         }
  537.         // Enclosures
  538.         if ($objEvent->addEnclosure)
  539.         {
  540.             $arrEnclosure = StringUtil::deserialize($objEvent->enclosure, true);
  542.             if (\is_array($arrEnclosure))
  543.             {
  544.                 $objFile = FilesModel::findMultipleByUuids($arrEnclosure);
  546.                 if ($objFile !== null)
  547.                 {
  548.                     while ($objFile->next())
  549.                     {
  550.                         $arrEvent['enclosure'][] = $objFile->path;
  551.                     }
  552.                 }
  553.             }
  554.         }
  556.         $this->arrEvents[$intKey][$intStart][] = $arrEvent;
  557.     }
  559.     /**
  560.      * Calculate the span between two timestamps in days
  561.      *
  562.      * @param integer $intStart
  563.      * @param integer $intEnd
  564.      *
  565.      * @return integer
  566.      */
  567.     public static function calculateSpan($intStart, $intEnd)
  568.     {
  569.         return self::unixToJd($intEnd) - self::unixToJd($intStart);
  570.     }
  572.     /**
  573.      * Convert a UNIX timestamp to a Julian day
  574.      *
  575.      * @param integer $tstamp
  576.      *
  577.      * @return integer
  578.      */
  579.     public static function unixToJd($tstamp)
  580.     {
  581.         list($year, $month, $day) = explode(',', date('Y,m,d', $tstamp));
  583.         // Make year a positive number
  584.         $year += ($year < 0 ? 4801 : 4800);
  586.         // Adjust the start of the year
  587.         if ($month > 2)
  588.         {
  589.             $month -= 3;
  590.         }
  591.         else
  592.         {
  593.             $month += 9;
  594.             --$year;
  595.         }
  597.         $sdn  = floor((floor($year / 100) * 146097) / 4);
  598.         $sdn += floor((($year % 100) * 1461) / 4);
  599.         $sdn += floor(($month * 153 + 2) / 5);
  600.         $sdn += $day - 32045;
  602.         return $sdn;
  603.     }
  605.     /**
  606.      * Return the names of the existing feeds so they are not removed
  607.      *
  608.      * @return array
  609.      */
  610.     public function purgeOldFeeds()
  611.     {
  612.         $arrFeeds = array();
  613.         $objFeeds = CalendarFeedModel::findAll();
  615.         if ($objFeeds !== null)
  616.         {
  617.             while ($objFeeds->next())
  618.             {
  619.                 $arrFeeds[] = $objFeeds->alias ?: 'calendar' . $objFeeds->id;
  620.             }
  621.         }
  623.         return $arrFeeds;
  624.     }
  626.     /**
  627.      * Return the page object with loaded details for the given page ID
  628.      *
  629.      * @param  integer        $intPageId
  630.      * @return PageModel|null
  631.      */
  632.     private function getPageWithDetails($intPageId)
  633.     {
  634.         if (!isset(self::$arrPageCache[$intPageId]))
  635.         {
  636.             self::$arrPageCache[$intPageId] = PageModel::findWithDetails($intPageId);
  637.         }
  639.         return self::$arrPageCache[$intPageId];
  640.     }
  642.     /**
  643.      * Creates a sub request for the given URI.
  644.      */
  645.     private function createSubRequest(string $uri, Request $request = null): Request
  646.     {
  647.         $cookies = null !== $request ? $request->cookies->all() : array();
  648.         $server = null !== $request ? $request->server->all() : array();
  650.         unset($server['HTTP_IF_MODIFIED_SINCE'], $server['HTTP_IF_NONE_MATCH']);
  652.         $subRequest = Request::create($uri, 'get', array(), $cookies, array(), $server);
  654.         if (null !== $request)
  655.         {
  656.             if ($request->get('_format'))
  657.             {
  658.                 $subRequest->attributes->set('_format', $request->get('_format'));
  659.             }
  661.             if ($request->getDefaultLocale() !== $request->getLocale())
  662.             {
  663.                 $subRequest->setLocale($request->getLocale());
  664.             }
  665.         }
  667.         // Always set a session (#3856)
  668.         $subRequest->setSession(new Session(new MockArraySessionStorage()));
  670.         return $subRequest;
  671.     }
  672. }
  674. class_alias(Calendar::class, 'Calendar');