system/modules/pct_theme_settings/PCT/ThemeSettings/ContaoCallbacks.php line 398

Open in your IDE?
  1. <?php
  3. /**
  4.  * Contao Open Source CMS
  5.  *
  6.  * Copyright (C) 2005-2013 Leo Feyer
  7.  *
  8.  * @copyright Tim Gatzky 2019
  9.  * @author  Tim Gatzky <info@tim-gatzky.de>
  10.  * @package  pct_theme_settings
  11.  * @link  http://contao.org
  12.  */
  15. /**
  16.  * Namespace
  17.  */
  18. namespace PCT\ThemeSettings;
  20. use Contao\StringUtil;
  22. /**
  23.  * Class file
  24.  * ContaoCallbacks
  25.  *
  26.  * Provide various callbacks to contao hooks
  27.  */
  28. class ContaoCallbacks
  29. {
  30.     /**
  31.      * Run scripts on Contao init
  32.      * @ called from initializeSystem Hook
  33.      */
  34.     public function initializeSystemCallback()
  35.     {
  36.         // append themify-icons.css to Iconpicker
  37.         if( \file_exists(TL_ROOT.'/files/cto_layout/css/themify-icons.css') )
  38.         {
  39.             $arrFiles = \Contao\StringUtil::deserialize( \Contao\Config::get('iconStylesheets') ) ?: array();
  40.             $arrFiles[] = \Contao\StringUtil::binToUuid( \Contao\Dbafs::addResource('files/cto_layout/css/themify-icons.css')->uuid );
  41.             \Contao\Config::set('iconStylesheets',$arrFiles);
  42.             
  43.             $arrClasses = \explode(',', \Contao\Config::get('customIconClasses') ?: '');
  44.             $arrClasses[] = '.ti-';
  45.             $arrClasses[] = '.ti-themify';
  46.             \Contao\Config::set('customIconClasses', \implode(',',array_unique($arrClasses)));
  47.         }
  48.     }
  51.     /**
  52.      * Add the theme setting related information to the article template
  53.      * @param object The article template object
  54.      * @param array  The db row information
  55.      * @param object The class object
  56.      *
  57.      * called from compileArticle Hook
  58.      */
  59.     public function compileArticleCallback($objTemplate,$arrData,$objArticle)
  60.     {
  61.         \PCT\ThemeSettings\Core::addToTemplate($objTemplate,$objArticle);
  62.     }
  63.     
  64.     
  65.     /**
  66.      * Inject theme classes in content elements
  67.      * @param object
  68.      * @param string
  69.      * @param objElement
  70.      * @return string
  71.      */
  72.     public function getContentElementCallback($objRow, $strBuffer, $objElement)
  73.     {
  74.         if(TL_MODE != 'FE')
  75.         {
  76.             return $strBuffer;
  77.         }
  78.         
  79.         // handle include elements
  80.         //if( $objElement->type == 'alias' )
  81.         //{
  82.         //    $objModel = \Contao\ContentModel::findByPk($objElement->cteAlias);
  83.         //    if ($objModel === null)
  84.         //    {
  85.         //        return $strBuffer;
  86.         //    }
  87.         //    
  88.         //    $strClass = \Contao\ContentElement::findClass($objModel->type);
  89.         //    if( class_exists($strClass) === false)
  90.         //    {
  91.         //        return $strBuffer;
  92.         //    }
  93.         //    
  94.         //    $objOrigElement = new $strClass($objModel);
  95.         //    
  96.         //    // run recursive here to get all the autogrid features for the original element
  97.         //    return $this->getContentElementCallback($objModel,$strBuffer,$objOrigElement);
  98.         //}
  99.         
  100.         $blnGenerate = false;
  102.         // set the ce_headline_seo template for headlines when seo is active and no custom template is set
  103.         if($objElement->type == 'headline' && $objRow->seo  && empty($objRow->customTpl))
  104.         {
  105.             $objElement->customTpl = $GLOBALS['PCT_THEME_SETTINGS']['templateByType']['headline_seo'];
  106.             $blnGenerate = true;
  107.         }
  108.         else if($objElement->type == 'text' && $objRow->seo && empty($objRow->customTpl))
  109.         {
  110.             $objElement->customTpl = $GLOBALS['PCT_THEME_SETTINGS']['templateByType']['text_seo'];
  111.             $blnGenerate = true;
  112.         }
  114.         if($blnGenerate === true)
  115.         {
  116.             $strClass = \Contao\ContentElement::findClass($objRow->type);
  117.             if( class_exists($strClass) === false)
  118.             {
  119.                 return $strBuffer;
  120.             }
  121.             // set new template
  122.             $objRow->customTpl = $objElement->customTpl;
  123.             // @var object
  124.             $objElement = new $strClass($objRow);
  125.             // regenerate the element with the new template
  126.             $strBuffer = $objElement->generate();
  127.         }
  128.     
  129.         return $strBuffer;
  130.     }
  133.     /**
  134.     * Handle form fields widgets
  135.     * @param widget
  136.     * @return widget
  137.     */
  138.     public function loadFormFieldCallback($objWidget)
  139.     {
  140.         if( empty($objWidget->visibility_css) === false )
  141.         {
  142.             $objWidget->class = ' '.$objWidget->visibility_css;
  143.         }
  144.         return $objWidget;
  145.     }
  148.     /**
  149.      * Collect include elements for further usage
  150.      * @param object
  151.      * @param boolean
  152.      * @return boolean
  153.      */
  154.     public function isVisibleElementCallback($objRow, $blnReturn)
  155.     {
  156.         if( TL_MODE != 'FE' )
  157.         {
  158.             return $blnReturn;
  159.         }
  161.         $objModel = null;
  163.         // include module
  164.         if( $objRow->type == 'module' )
  165.         {
  166.             $objModel = \Contao\ModuleModel::findByPk($objRow->module);
  167.         }
  168.         // include form
  169.         else if( $objRow->type == 'form' )
  170.         {
  171.             $objModel = \Contao\FormModel::findByPk($objRow->form);
  172.         }
  173.         // include content element
  174.         else if( $objRow->type == 'alias' )
  175.         {
  176.             $objModel = \Contao\FormModel::findByPk($objRow->cteAlias);
  177.         }
  178.         // include article
  179.         else if( $objRow->type == 'article' )
  180.         {
  181.             $objModel = \Contao\ArticleModel::findByPk($objRow->articleAlias);
  182.         }
  184.         // frontend module
  185.         if( $objRow->getTable() == 'tl_module' )
  186.         {
  187.             $arrCssId = \Contao\StringUtil::deserialize($objRow->cssID);
  188.             if( empty($objRow->visibility_css) === false )
  189.             {
  190.                 $arrCssId[1] .= ' '.$objRow->visibility_css;
  191.             }
  192.             $objRow->__set('cssID',$arrCssId);
  193.         }
  195.         if( $objModel !== null )
  196.         {
  197.             $objModel->__set('origID',$objRow->id);
  198.             $objModel->__set('isInclude',true);
  199.         }
  200.         
  201.         return $blnReturn;
  202.     }
  205.     /**
  206.      * Add information to the template object
  207.      * @param object
  208.      */
  209.     public function parseTemplateCallback($objTemplate)
  210.     {
  211.         $objRow = clone($objTemplate);
  212.         if( (int)$objTemplate->origID > 0 )
  213.         {
  214.             $objRow = \Contao\ContentModel::findByPk( $objTemplate->origID );
  215.         }
  216.         
  217.         $arrClasses = explode(' ', $objTemplate->class);
  219.         if( !isset($GLOBALS['PCT_THEME_SETTINGS']['cssByType'][$objRow->type]) )
  220.         {
  221.             $GLOBALS['PCT_THEME_SETTINGS']['cssByType'][$objRow->type] = array();
  222.         }
  224.         // collect css classes depending on the element type
  225.         $arrFields = array_merge($GLOBALS['PCT_THEME_SETTINGS']['cssByType'][$objRow->type] ?: array(),$GLOBALS['PCT_THEME_SETTINGS']['cssByType']['*'] );
  226.         foreach($arrFields as $field)
  227.         {
  228.             $arrClasses[] = $objRow->{$field};
  229.         }
  230.     
  231.         $arrClasses = array_unique( array_filter($arrClasses) );
  232.         
  233.         // add to Contaos $this->class
  234.         if( empty($arrClasses) === false)
  235.         {
  236.             $objTemplate->class = implode(' ', $arrClasses);
  237.         }
  238.     }
  239.     
  241.     // !Inserttags
  244.     /**
  245.      * Replace insert tags
  246.      * @param string
  247.      * @return boolean||mixed
  248.      *
  249.      * called from replaceInsertTags Hook
  250.      */
  251.     public function replaceInsertTagsCallback($strElement)
  252.     {
  253.         $arrElements = explode('::', $strElement);
  254.         
  255.         // label-
  256.         if( strlen(strpos($arrElements[0], 'label-')) > 0 )
  257.         {
  258.             $arr = $arrElements;
  259.             $arrElements[0] = 'label-';
  260.             $arrElements[1] = str_replace('label-','',$arr[0]);
  261.             $arrElements[2] = $arr[1];
  262.             unset($arr);
  263.         }
  264.         
  265.         // color-
  266.         if( strlen(strpos($arrElements[0], 'color-')) > 0 )
  267.         {
  268.             $arr = $arrElements;
  269.             $arrElements[0] = 'color-';
  270.             $arrElements[1] = str_replace('color-','',$arr[0]);
  271.             $arrElements[2] = $arr[1];
  272.             unset($arr);
  273.         }
  274.         
  275.         switch($arrElements[0])
  276.         {
  277.             // color-
  278.             case 'color-':
  279.                 return '<span class="color-'.$arrElements[1].'">'.$arrElements[2].'</span>';
  280.                 break;
  281.             // label-
  282.             case 'label-':
  283.                 return '<span class="label-'.$arrElements[1].'">'.$arrElements[2].'</span>';
  284.                 break;
  285.             default:
  286.                 break;
  287.         }
  289.         return false;
  290.     }
  293.     // !News
  296.     /**
  297.      * Enable manual sorting for tl_news
  298.      * @param string
  299.      * @called from loadDataContainer Hook
  300.      */
  301.     public function enableManualSorting($strTable)
  302.     {
  303.         if($strTable != 'tl_news' || TL_MODE != 'BE')
  304.         {
  305.             return;
  306.         }
  309.         $objArchive = null;
  310.         $intArchive = 0;
  311.         if(!\Contao\Input::get('act'))
  312.         {
  313.             $intArchive = \Contao\Input::get('id');
  314.         }
  315.         else if(in_array(\Contao\Input::get('act'),array('cut','copyAll')) || in_array(\Contao\Input::get('mode'),array('cut','cutAll')) )
  316.             {
  317.                 $objActiveRecord = \Contao\NewsModel::findByPk( \Contao\Input::get('id') );
  318.                 $intArchive = $objActiveRecord->pid;
  319.             }
  321.         #$objArchive = $objArchive = \Contao\NewsArchiveModel::findByPk($intArchive);
  322.         $objArchive = \Contao\Database::getInstance()->prepare("SELECT * FROM tl_news_archive WHERE id=?")->limit(1)->execute($intArchive);
  323.         
  324.         if($objArchive->manualSorting)
  325.         {
  326.             $GLOBALS['TL_DCA']['tl_news']['list']['sorting']['fields'] = array('sorting');
  328.             // add the sorting field as backend sorting option
  329.             $GLOBALS['TL_DCA']['tl_news']['fields']['sorting']['sorting'] = true;
  331.             // bypass the permission check on cut, cutAll to allow manual sorting
  332.             if( \in_array(\Contao\Input::get('act'),array('cut','cutAll')) )
  333.             {
  334.                 if(is_array($GLOBALS['TL_DCA']['tl_news']['config']['onload_callback']))
  335.                 {
  336.                     foreach($GLOBALS['TL_DCA']['tl_news']['config']['onload_callback'] as $i => $callback)
  337.                     {
  338.                         if(!is_array($callback) || empty($callback))
  339.                         {
  340.                             continue;
  341.                         }
  343.                         if($callback[0] == 'tl_news' && $callback[1] == 'checkPermission')
  344.                         {
  345.                             unset($GLOBALS['TL_DCA']['tl_news']['config']['onload_callback'][$i]);
  346.                         }
  347.                     }
  348.                 }
  349.             }
  350.         }
  351.     }
  354.     /**
  355.      * Apply manual sorting for news
  356.      * @param array
  357.      * @param boolean
  358.      * @param integer
  359.      * @param integer
  360.      * @return object||null||false
  361.      * called from $GLOBALS['TL_HOOKS']['newsListFetchItems']
  362.      */
  363.     public function newsListFetchItemsCallback($arrArchives, $blnFeatured, $intLimit, $intOffset, $objModule)
  364.     {
  365.         if( $objModule->news_order != 'sorting' )
  366.         {
  367.             return false;
  368.         }
  369.         
  370.         $strTable = \Contao\NewsModel::getTable();
  371.         $arrOptions = array( 'order' => 'sorting' );
  373.         // news list filtering
  374.         // fetch portfoliofilters related to this list
  375.         $objFilterModules = \Contao\ModuleModel::findBy( array('news_readerModule','news_sysfilter'), array($objModule->id,1) );
  376.         if( $objFilterModules !== null )
  377.         {
  378.             $arrIds = static::filterNews($arrArchives, $blnFeatured, $intLimit, $intOffset, $arrOptions);
  379.             if( !empty($arrIds) )
  380.             {
  381.                 $arrOptions['column'] = array($strTable.'.id IN('.implode(',', $arrIds).')');
  382.             }
  383.         }
  384.         
  385.         return \Contao\NewsModel::findPublishedByPids($arrArchives, $blnFeatured, $intLimit, $intOffset, $arrOptions);
  386.     }
  389.     /**
  390.      * Calculate the number of news items after applying the filter
  391.      * @param array
  392.      * @param boolean
  393.      * @param object
  394.      * @return object||integer||boolean(false)
  395.      *
  396.       * called from $GLOBALS['TL_HOOKS']['newsListCountItems']
  397.      */
  398.     public function newsListCountItemsCallback($arrArchives, $blnFeatured, $objModule)
  399.     {
  400.         // fetch portfoliofilters related to this list
  401.         $objFilterModules = \Contao\ModuleModel::findBy( array('news_readerModule','news_sysfilter'), array($objModule->id,1) );
  402.         
  403.         if( $objFilterModules === null || \Contao\Input::get('filter') == '' )
  404.         {
  405.             return false;
  406.         }
  407.         
  408.         $arrIds = static::filterNews($arrArchives, $blnFeatured, 0, 0, array());
  409.         
  410.         return count($arrIds);
  411.     }
  412.     
  413.     
  414.     /**
  415.      * Filter news entries
  416.      * @param array
  417.      * @param boolean
  418.      * @param integer
  419.      * @param integer
  420.      * @return array
  421.      */
  422.     public static function filterNews($arrArchives, $blnFeatured, $intLimit, $intOffset, $arrOptions)
  423.     {
  424.         if( \Contao\Input::get('filter') == '' )
  425.         {
  426.             return array();
  427.         }
  428.         
  429.         $strTable = \Contao\NewsModel::getTable();
  430.         
  431.         // active url filters
  432.         $arrFilters = array_filter( explode(',', \Contao\Input::get('filter') ) );
  433.         
  434.         $arrOptions['column'] = array($strTable.'.addFilter=1');
  435.         
  436.         // fetch all entries 
  437.         $objEntries = \Contao\NewsModel::findPublishedByPids($arrArchives,$blnFeatured,$intLimit,$intOffset,$arrOptions);
  438.         if($objEntries === null)
  439.         {
  440.             return array();
  441.         }
  442.         
  443.         $arrIds = array();
  444.         foreach($objEntries as $objModel)
  445.         {
  446.             $filter = StringUtil::deserialize($objModel->filters);
  447.             
  448.             if( empty( array_intersect($filter, $arrFilters) ) )
  449.             {
  450.                 continue;
  451.             }
  452.             
  453.             $arrIds[] = $objModel->id;
  454.         }
  455.         
  456.         return $arrIds;
  457.     }
  458. }