vendor/memo_development/contao-foundation-bundle/src/Model/FoundationModel.php line 247

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /**
  6.  * @package   Memo\MemoFoundationBundle
  7.  * @author    Media Motion AG
  8.  * @license   LGPL-3.0+
  9.  * @copyright Media Motion AG
  10.  */
  12. namespace Memo\FoundationBundle\Model;
  14. use Contao\PageModel;
  15. use Memo\TeamBundle\Model\TeamModel;
  16. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  17. use Terminal42\ChangeLanguage\PageFinder;
  19. /**
  20.  * Class FoundationModel
  21.  *
  22.  * Enable ease Translation of all fields in DCA
  23.  */
  24. class FoundationModel extends \Haste\Model\Model
  25. {
  27.     /**
  28.      * Returns a item, based on the alias, regardless of the language
  29.      * @param $strAlias
  30.      * @param $bolIgnorePublished (only show published by default)
  31.      * @return $objItem
  32.      */
  33.     public static function getItemByTranslatedAlias($strAlias, $bolIgnorePublished=false, $strCurrentLanguage=false, $strField="alias")
  34.     {
  35.         // Presets
  36.         $strTable = static::$strTable;
  37.         \Controller::loadDataContainer($strTable);
  38.         $strCurrentLanguage = ($strCurrentLanguage) ? $strCurrentLanguage : $GLOBALS['TL_LANGUAGE'];
  41.         // Get Default Language
  42.         $strDefaultLanguage = \System::getContainer()->get('memo.foundation.language')->getDefaultLanguage();
  44.         // Get Items
  45.         if($strCurrentLanguage != $strDefaultLanguage && $GLOBALS['TL_DCA'][$strTable]['fields'][$strField]['translate'] === true)
  46.         {
  47.             $strFieldname = $strField.'_' . $strCurrentLanguage;
  49.             if($bolIgnorePublished){
  51.                 $colItem = static::findBy(
  52.                     array("$strTable.$strFieldname=?"),
  53.                     array($strAlias)
  54.                 );
  56.             } else {
  58.                 $colItem = static::findBy(
  59.                     array("$strTable.$strFieldname=?", "$strTable.published=?", "($strTable.start='' OR $strTable.start<?)", "($strTable.stop='' OR $strTable.stop>?)"),
  60.                     array($strAlias, 1, time(), time())
  61.                 );
  63.             }
  65.             if(!$colItem)
  66.             {
  67.                 if($bolIgnorePublished){
  69.                     $colItem = static::findBy(
  70.                         array("$strTable.$strField=?"),
  71.                         array($strAlias)
  72.                     );
  74.                 } else {
  76.                     $colItem = static::findBy(
  77.                         array("$strTable.$strField=?", "$strTable.published=?", "($strTable.start='' OR $strTable.start<?)", "($strTable.stop='' OR $strTable.stop>?)"),
  78.                         array($strAlias, 1, time(), time())
  79.                     );
  81.                 }
  83.             }
  85.         } else {
  87.             if($bolIgnorePublished){
  89.                 $colItem = static::findBy(
  90.                     array("$strTable.$strField=?"),
  91.                     array($strAlias)
  92.                 );
  94.             } else {
  96.                 $colItem = static::findBy(
  97.                     array("$strTable.$strField=?", "$strTable.published=?", "($strTable.start='' OR $strTable.start<?)", "($strTable.stop='' OR $strTable.stop>?)"),
  98.                     array($strAlias, 1, time(), time())
  99.                 );
  101.             }
  102.         }
  104.         // Reset Data that was modified (for Default-Language)
  105.         if($colItem){
  106.             foreach($colItem as $objItem)
  107.             {
  108.                 if(is_array($objItem->arrModified) && count($objItem->arrModified) > 0)
  109.                 {
  110.                     foreach($objItem->arrModified as $keyField => $strValue){
  111.                         $objItem->$keyField = $strValue;
  112.                     }
  113.                 }
  114.             }
  115.         }
  118.         return $colItem;
  119.     }
  121.     /**
  122.      * Returns an array of all Page-IDs, on which auto_item Elements could be used on
  123.      * @param bool $bolTranslatedPages
  124.      * @return array
  125.      */
  126.     public static function getDetailPages($bolTranslatedPages=false, $bolOnlyActiveLanguages=false)
  127.     {
  128.         // Presets
  129.         $objLanguageService = \System::getContainer()->get('memo.foundation.language');
  130.         $arrLanguages = $objLanguageService->getAllLanguages(true, $bolOnlyActiveLanguages);
  131.         $arrPages = array();
  133.         // Only continue, if the archive-table exists
  134.         $objDatabase = \Database::getInstance();
  135.         if ($objDatabase->tableExists(static::getTable()) === false){
  136.             return $arrPages;
  137.         }
  139.         // Get all archives
  140.         $objArchives = static::findAll();
  142.         // Look for jumpTo Pages in the Archives
  143.         if ($objArchives)
  144.         {
  145.             foreach($objArchives as $objArchive)
  146.             {
  147.                 if($objArchive->jumpTo)
  148.                 {
  149.                     $arrPages[$objArchive->jumpTo] = $objArchive->jumpTo;
  150.                 }
  151.                 if($bolTranslatedPages){
  152.                     foreach($arrLanguages as $strLanguage){
  153.                         $strFieldname = "jumpTo" . $objLanguageService->getLanguagePostfix($strLanguage);
  154.                         if($objArchive->$strFieldname)
  155.                         {
  156.                             $arrPages[$objArchive->$strFieldname] = $objArchive->$strFieldname;
  157.                         }
  158.                     }
  159.                 } else {
  160.                     if($objArchive->jumpTo)
  161.                     {
  162.                         $arrPages[$objArchive->jumpTo] = $objArchive->jumpTo;
  163.                     }
  164.                 }
  165.             }
  166.         }
  168.         $colModules = \ModuleModel::findBy(array('tl_module.jumpTo!=?', 'foundation_item_template!=?'), array('', ''));
  169.         if($colModules)
  170.         {
  171.             foreach($colModules as $objModule){
  172.                 $arrPages[$objModule->jumpTo] = $objModule->jumpTo;
  173.             }
  174.         }
  176.         // Get the pages in all languages
  177.         if($bolTranslatedPages && is_array($arrPages)){
  179.             $arrOrigPages = $arrPages;
  180.             $objPageFinder = new PageFinder();
  181.             foreach($arrLanguages as $strLanguage)
  182.             {
  183.                 foreach($arrOrigPages as $intPage)
  184.                 {
  185.                     try {
  187.                         $objTranslatedPage = $objPageFinder->findAssociatedForLanguage(\PageModel::findByPk($intPage), $strLanguage);
  189.                     } catch (\InvalidArgumentException $e) {
  190.                         // Do nothing - this can happen, if there are multiple domains in the same installation
  191.                     }
  193.                     if($objTranslatedPage)
  194.                     {
  195.                         $arrPages[$objTranslatedPage->id] = $objTranslatedPage->id;
  196.                     }
  199.                 }
  200.             }
  202.         }
  204.         return $arrPages;
  205.     }
  207.     /**
  208.      * Returns the object, with all translated (or default) values
  209.      * @param $strLanguage
  210.      * @return $this
  211.      */
  212.     public function getTranslatedModel($strLanguage)
  213.     {
  214.         // Get Language Postfix
  215.         $strPostfix = \System::getContainer()->get('memo.foundation.language')->getLanguagePostfix($strLanguage);
  217.         // Only run, if there is a Postfix
  218.         if($strPostfix != '')
  219.         {
  220.             // Loop all dca-fields
  221.             foreach($this->arrData as $key => $value)
  222.             {
  223.                 // Define the field-name for the wanted translation
  224.                 $strLanguageField = $key . $strPostfix;
  226.                 // Check if the field exists and if there is a value set (to override the default-value)
  227.                 if (
  228.                     array_key_exists($strLanguageField, $this->arrData) &&
  229.                     $this->$strLanguageField != '' &&
  230.                     $this->$strLanguageField != null)
  231.                 {
  232.                     // Set new value (only for this call)
  233.                     $this->$key = $this->$strLanguageField;
  234.                 }
  235.             }
  236.         }
  238.         // Return the translated object
  239.         return $this;
  240.     }
  242.     /**
  243.      * @param $arrPids
  244.      * @param array $arrOptions
  245.      * @return |null
  246.      */
  247.     public static function findPublishedByPids($arrPids, array $arrOptions=array(), array $arrColumns=array(), $arrValues=array())
  248.     {
  250.         // Return null, if no data found
  251.         if (empty($arrPids) || !\is_array($arrPids))
  252.         {
  253.             return null;
  254.         }
  256.         // Presets
  257.         $strTable = static::$strTable;
  259.         // Set Filter for Archives
  260.         $arrColumns[] = "$strTable.pid IN(" . implode(',', array_map('\intval', $arrPids)) . ")";
  262.         // Set Filter for Published
  263.         $arrColumns[] = "$strTable.published='1'";
  265.         // Set Filter for stop/start
  266.         $arrColumns[] = "($strTable.start='' OR $strTable.start<".time().")";
  267.         $arrColumns[] = "($strTable.stop='' OR $strTable.stop>".time().")";
  269.         // Get the Items
  270.         $colItems = static::findBy($arrColumns, $arrValues, $arrOptions);
  272.         // Return the Items
  273.         return $colItems;
  274.     }
  276.     /**
  277.      * @param $arrIds
  278.      * @param array $arrOptions
  279.      * @param array $arrColumns
  280.      * @return \Contao\Model|\Contao\Model[]|\Contao\Model\Collection|FoundationModel|null
  281.      */
  282.     public static function findPublishedByIds($arrIds, array $arrOptions=array(), array $arrColumns=array())
  283.     {
  284.         // Return null, if no data found
  285.         if (empty($arrIds) || !\is_array($arrIds))
  286.         {
  287.             return null;
  288.         }
  290.         // Presets
  291.         $strTable = static::$strTable;
  293.         // Set Filter for Archives
  294.         $arrColumns[] = "$strTable.id IN(" . implode(',', array_map('\intval', $arrIds)) . ")";
  296.         // Set Filter for Published
  297.         $arrColumns[] = "$strTable.published='1'";
  299.         // Set Filter for stop/start
  300.         $arrColumns[] = "($strTable.start='' OR $strTable.start<".time().")";
  301.         $arrColumns[] = "($strTable.stop='' OR $strTable.stop>".time().")";
  303.         // Get the Items
  304.         $colItems = static::findBy($arrColumns, null, $arrOptions);
  306.         // Return the Items
  307.         return $colItems;
  308.     }
  310.     public static function findAllPublished(array $arrOptions=array())
  311.     {
  313.         if(empty($arrOptions)){
  314.             $arrOptions = array('order' => 'title');
  315.         }
  317.         // Presets
  318.         $strTable = static::$strTable;
  320.         // Set Filter for Published
  321.         $arrColumns[] = "$strTable.published='1'";
  323.         // Set Filter for stop/start
  324.         $arrColumns[] = "($strTable.start='' OR $strTable.start<".time().")";
  325.         $arrColumns[] = "($strTable.stop='' OR $strTable.stop>".time().")";
  327.         // Get the Items
  328.         $colItems = static::findBy($arrColumns, null, $arrOptions);
  330.         // Return the Items
  331.         return $colItems;
  332.     }
  334.     public function getModified()
  335.     {
  336.         return $this->arrModified;
  337.     }
  339.     public function getURL($strLanguage=false, $strType=UrlGeneratorInterface::ABSOLUTE_URL)
  340.     {
  342.         // Get the language
  343.         if(!$strLanguage)
  344.         {
  345.             $strLanguage = $GLOBALS['TL_LANGUAGE'];
  346.         }
  348.         // Get the default language
  349.         $strDefaultLanguage = \System::getContainer()->get('memo.foundation.language')->getDefaultLanguage();
  351.         // Get Tag in correct language
  352.         if ($strLanguage != $strDefaultLanguage) {
  353.             $this->getTranslatedModel($strLanguage);
  354.         }
  356.         // Static URL set?
  357.         if($this->url != ''){
  358.             return $this->url;
  359.         }
  361.         // Get the archive and translate it
  362.         $objArchive = $this->getRelated('pid');
  363.         if ($strLanguage != $strDefaultLanguage) {
  364.             $objArchive->getTranslatedModel($strLanguage);
  365.         }
  367.         if(!$objArchive) {
  368.             return false;
  369.         }
  371.         if(!$objArchive->jumpTo){
  372.             return false;
  373.         }
  375.         // Get the page
  376.         $objDetailPage = $objArchive->getRelated('jumpTo');
  377.         if($strLanguage != $strDefaultLanguage){
  378.             $objPageFinder = new \Terminal42\ChangeLanguage\PageFinder();
  380.             // Check if the page exists
  381.             if($objDetailPage && $objPageFinder){
  383.                 // Get the page in the correct language
  384.                 $objDetailPage = $objPageFinder->findAssociatedForLanguage($objDetailPage, $strLanguage);
  385.             } else {
  387.                 // Write to contao log
  388.                 \System::log('No page found for the detail page of the archive with the id ' . $objArchive->id . ' in ' . $strLanguage, __METHOD__, TL_ERROR);
  390.             }
  391.         }
  393.         if(!$objDetailPage){
  394.             return false;
  395.         }
  397.         if(!$this->alias){
  398.             return false;
  399.         }
  401.         if(method_exists($objDetailPage, 'getAbsoluteUrl')){
  403.             // Generate absolute url
  404.             $strLink = $objDetailPage->getAbsoluteUrl('/'.$this->alias);
  406.         } else {
  408.             // Get the url generator
  409.             $urlGenerator = \System::getContainer()->get('contao.routing.url_generator');
  411.             // Defined the parameters array
  412.             $arrParams = array(
  413.                 '_locale' => $strLanguage,
  414.                 'alias' => $this->alias,
  415.                 'auto_item' => 'alias'
  416.             );
  418.             $strLink =  $urlGenerator->generate($objDetailPage->alias . '/{alias}', $arrParams, $strType);
  420.         }
  422.         return $strLink;
  423.     }
  425.     public static function countByFormData($strLanguage='de', $intOffset=0, $intLimit=0, $arrFormData=array())
  426.     {
  427.         // Get Tables
  428.         $strTable = static::$strTable;
  430.         // Define the default filter values
  431.         $arrColumns = array("$strTable.published=?", "($strTable.start='' OR $strTable.start<?)", "($strTable.stop='' OR $strTable.stop>?)");
  432.         $arrValues = array(1, time(), time());
  434.         // Add defaut count
  435.         $intProducts = 0;
  437.         // Add the form filters
  438.         if(class_exists('\Memo\ProductBundle\Model\ProductAttributeModel')){
  440.             $arrFormFilters = \Memo\ProductBundle\Model\ProductAttributeModel::resolveFilterForm($arrFormData);
  441.             $arrColumns = array_merge($arrColumns, $arrFormFilters[0]);
  442.             $arrValues = array_merge($arrValues, $arrFormFilters[1]);
  444.             // Get the product count
  445.             $intProducts = self::countBy($arrColumns, $arrValues);
  447.         }
  449.         // Return the product count
  450.         return $intProducts;
  451.     }
  453.     public static function findByFormData($strLanguage=false, $intOffset=0, $intLimit=0, $arrFormData=array(), $arrOptions=array())
  454.     {
  456.         // Get the language
  457.         if(!$strLanguage)
  458.         {
  459.             $strLanguage = $GLOBALS['TL_LANGUAGE'];
  460.         }
  462.         // Get the default language
  463.         $strDefaultLanguage = \System::getContainer()->get('memo.foundation.language')->getDefaultLanguage();
  465.         // Get Tables
  466.         $strTable = static::$strTable;
  468.         // Define the default filter values
  469.         $arrColumns = array("$strTable.published=?", "($strTable.start='' OR $strTable.start<?)", "($strTable.stop='' OR $strTable.stop>?)");
  470.         $arrValues = array(1, time(), time());
  472.         // Add the form filters
  473.         if(class_exists('\Memo\ProductBundle\Model\ProductAttributeModel')) {
  474.             $arrFormFilters = \Memo\ProductBundle\Model\ProductAttributeModel::resolveFilterForm($arrFormData);
  475.             $arrColumns = array_merge($arrColumns, $arrFormFilters[0]);
  476.             $arrValues = array_merge($arrValues, $arrFormFilters[1]);
  477.         }
  479.         // Add the offset and limit
  480.         $arrOptions = array_merge(array('offset'=>$intOffset, 'limit'=>$intLimit), $arrOptions);
  482.         // Get the items
  483.         $colItems = self::findBy($arrColumns, $arrValues, $arrOptions);
  485.         $arrItems= array();
  487.         if(!$colItems){
  488.             return $arrItems;
  489.         }
  491.         foreach($colItems as $objItem)
  492.         {
  493.             if($strLanguage != $strDefaultLanguage){
  494.                 $objItem->getTranslatedModel($strLanguage);
  495.             }
  497.             $arrItems[] = $objItem;
  498.         }
  500.         // Return the items
  501.         return $arrItems;
  502.     }
  503. }