vendor/isotope/isotope-core/system/modules/isotope/library/Isotope/Model/Product.php line 253

Open in your IDE?
  1. <?php
  3. /*
  4.  * Isotope eCommerce for Contao Open Source CMS
  5.  *
  6.  * Copyright (C) 2009 - 2019 terminal42 gmbh & Isotope eCommerce Workgroup
  7.  *
  8.  * @link       https://isotopeecommerce.org
  9.  * @license    https://opensource.org/licenses/lgpl-3.0.html
  10.  */
  12. namespace Isotope\Model;
  14. use Contao\Database;
  15. use Contao\Date;
  16. use Contao\DcaExtractor;
  17. use Contao\Model;
  18. use Isotope\Interfaces\IsotopeProduct;
  19. use Isotope\Model\Attribute;
  20. use Isotope\RequestCache\Filter;
  21. use Model\Collection;
  23. /**
  24.  * The basic Isotope product model
  25.  *
  26.  * @property int    $id
  27.  * @property int    $pid
  28.  * @property int    $gid
  29.  * @property int    $tstamp
  30.  * @property string $language
  31.  * @property int    $dateAdded
  32.  * @property int    $type
  33.  * @property array  $pages
  34.  * @property array  $orderPages
  35.  * @property array  $inherit
  36.  * @property bool   $fallback
  37.  * @property string $alias
  38.  * @property string $sku
  39.  * @property string $name
  40.  * @property string $teaser
  41.  * @property string $description
  42.  * @property string $meta_title
  43.  * @property string $meta_description
  44.  * @property string $meta_keywords
  45.  * @property bool   $shipping_exempt
  46.  * @property array  $images
  47.  * @property bool   $protected
  48.  * @property array  $groups
  49.  * @property bool   $guests
  50.  * @property array  $cssID
  51.  * @property bool   $published
  52.  * @property string $start
  53.  * @property string $stop
  54.  */
  55. abstract class Product extends TypeAgent implements IsotopeProduct
  56. {
  58.     /**
  59.      * Table name
  60.      * @var string
  61.      */
  62.     protected static $strTable = 'tl_iso_product';
  64.     /**
  65.      * Interface to validate attribute
  66.      * @var string
  67.      */
  68.     protected static $strInterface = '\Isotope\Interfaces\IsotopeProduct';
  70.     /**
  71.      * List of types (classes) for this model
  72.      * @var array
  73.      */
  74.     protected static $arrModelTypes = array();
  76.     /**
  77.      * Currently active product (LIFO queue)
  78.      * @var array
  79.      */
  80.     protected static $arrActive = array();
  82.     /**
  83.      * Get categories (pages) assigned to this product
  84.      *
  85.      * @param bool $blnPublished Only return published categories (pages)
  86.      *
  87.      * @return array
  88.      */
  89.     abstract public function getCategories($blnPublished = false);
  91.     /**
  92.      * Get product that is currently active (needed e.g. for insert tag replacement)
  93.      *
  94.      * @return IsotopeProduct|null
  95.      */
  96.     public static function getActive()
  97.     {
  98.         return 0 === \count(static::$arrActive) ? null : end(static::$arrActive);
  99.     }
  101.     /**
  102.      * Set product that is currently active (needed e.g. for insert tag replacement)
  103.      *
  104.      * @param IsotopeProduct $objProduct
  105.      */
  106.     public static function setActive(IsotopeProduct $objProduct)
  107.     {
  108.         static::$arrActive[] = $objProduct;
  109.     }
  111.     /**
  112.      * Unset product that is currently active (prevent later use of it)
  113.      */
  114.     public static function unsetActive()
  115.     {
  116.         array_pop(static::$arrActive);
  117.     }
  119.     /**
  120.      * Find all published products
  121.      *
  122.      * @param array $arrOptions
  123.      *
  124.      * @return Collection|Product[]|null
  125.      */
  126.     public static function findPublished(array $arrOptions = array())
  127.     {
  128.         return static::findPublishedBy(array(), array(), $arrOptions);
  129.     }
  131.     /**
  132.      * Find published products by condition
  133.      *
  134.      * @param mixed $arrColumns
  135.      * @param mixed $arrValues
  136.      * @param array $arrOptions
  137.      *
  138.      * @return Collection|Product[]|null
  139.      */
  140.     public static function findPublishedBy($arrColumns, $arrValues, array $arrOptions = array())
  141.     {
  142.         $t = static::$strTable;
  144.         $arrValues = (array) $arrValues;
  146.         if (!\is_array($arrColumns)) {
  147.             $arrColumns = array(static::$strTable . '.' . $arrColumns . '=?');
  148.         }
  150.         // Add publish check to $arrColumns as the first item to enable SQL keys
  151.         if (BE_USER_LOGGED_IN !== true) {
  152.             $time = Date::floorToMinute();
  153.             array_unshift(
  154.                 $arrColumns,
  155.                 "$t.published='1' AND ($t.start='' OR $t.start<'$time') AND ($t.stop='' OR $t.stop>'" . ($time + 60) . "')"
  156.             );
  157.         }
  159.         return static::findBy($arrColumns, $arrValues, $arrOptions);
  160.     }
  162.     /**
  163.      * Find a single product by primary key
  164.      *
  165.      * @param int   $intId
  166.      * @param array $arrOptions
  167.      *
  168.      * @return static|null
  169.      */
  170.     public static function findPublishedByPk($intId, array $arrOptions = array())
  171.     {
  172.         $arrOptions = array_merge(
  173.             array(
  174.                 'return'    => 'Model'
  175.             ),
  176.             $arrOptions
  177.         );
  179.         return static::findPublishedBy(static::$strPk, (int) $intId, $arrOptions);
  180.     }
  182.     /**
  183.      * Find a single product by its ID or alias
  184.      *
  185.      * @param mixed $varId      The ID or alias
  186.      * @param array $arrOptions An optional options array
  187.      *
  188.      * @return static|null      The model or null if the result is empty
  189.      */
  190.     public static function findPublishedByIdOrAlias($varId, array $arrOptions = array())
  191.     {
  192.         $t = static::$strTable;
  194.         $arrColumns = array("($t.id=? OR $t.alias=?)");
  195.         $arrValues  = array(is_numeric($varId) ? $varId : 0, $varId);
  197.         $arrOptions = array_merge(
  198.             array(
  199.                 'limit'     => 1,
  200.                 'return'    => 'Model'
  201.             ),
  202.             $arrOptions
  203.         );
  205.         return static::findPublishedBy($arrColumns, $arrValues, $arrOptions);
  206.     }
  208.     /**
  209.      * Find products by IDs
  210.      *
  211.      * @param array $arrIds
  212.      * @param array $arrOptions
  213.      *
  214.      * @return Product[]|Collection
  215.      */
  216.     public static function findPublishedByIds(array $arrIds, array $arrOptions = array())
  217.     {
  218.         if (0 === \count($arrIds)) {
  219.             return null;
  220.         }
  222.         return static::findPublishedBy(
  223.             array(static::$strTable . '.id IN (' . implode(',', array_map('intval', $arrIds)) . ')'),
  224.             null,
  225.             $arrOptions
  226.         );
  227.     }
  229.     /**
  230.      * Return collection of published product variants by product PID
  231.      *
  232.      * @param int   $intPid
  233.      * @param array $arrOptions
  234.      *
  235.      * @return Collection|Product[]|null
  236.      */
  237.     public static function findPublishedByPid($intPid, array $arrOptions = array())
  238.     {
  239.         return static::findPublishedBy('pid', (int) $intPid, $arrOptions);
  240.     }
  242.     /**
  243.      * Return collection of published products by categories
  244.      *
  245.      * @param array $arrCategories
  246.      * @param array $arrOptions
  247.      *
  248.      * @return Collection|Product[]|null
  249.      */
  250.     public static function findPublishedByCategories(array $arrCategories, array $arrOptions = array())
  251.     {
  252.         return static::findPublishedBy(
  253.             array('c.page_id IN (' . implode(',', array_map('intval', $arrCategories)) . ')'),
  254.             null,
  255.             $arrOptions
  256.         );
  257.     }
  259.     /**
  260.      * Find a single frontend-available product by primary key
  261.      *
  262.      * @param int   $intId
  263.      * @param array $arrOptions
  264.      *
  265.      * @return static|null
  266.      */
  267.     public static function findAvailableByPk($intId, array $arrOptions = array())
  268.     {
  269.         $objProduct = static::findPublishedByPk($intId, $arrOptions);
  271.         if (null === $objProduct || !$objProduct->isAvailableInFrontend()) {
  272.             return null;
  273.         }
  275.         return $objProduct;
  276.     }
  278.     /**
  279.      * Find a single frontend-available product by its ID or alias
  280.      *
  281.      * @param mixed $varId      The ID or alias
  282.      * @param array $arrOptions An optional options array
  283.      *
  284.      * @return Product|null     The model or null if the result is empty
  285.      */
  286.     public static function findAvailableByIdOrAlias($varId, array $arrOptions = array())
  287.     {
  288.         $objProduct = static::findPublishedByIdOrAlias($varId, $arrOptions);
  290.         if (null === $objProduct || !$objProduct->isAvailableInFrontend()) {
  291.             return null;
  292.         }
  294.         return $objProduct;
  295.     }
  297.     /**
  298.      * Find frontend-available products by IDs
  299.      *
  300.      * @param array $arrIds
  301.      * @param array $arrOptions
  302.      *
  303.      * @return Collection|Product[]|null
  304.      */
  305.     public static function findAvailableByIds(array $arrIds, array $arrOptions = array())
  306.     {
  307.         $objProducts = static::findPublishedByIds($arrIds, $arrOptions);
  309.         if (null === $objProducts) {
  310.             return null;
  311.         }
  313.         $arrProducts = [];
  314.         foreach ($objProducts as $objProduct) {
  315.             if ($objProduct->isAvailableInFrontend()) {
  316.                 $arrProducts[] = $objProduct;
  317.             }
  318.         }
  320.         if (0 === \count($arrProducts)) {
  321.             return null;
  322.         }
  324.         return new Collection($arrProducts, static::$strTable);
  325.     }
  327.     /**
  328.      * Find frontend-available products by condition
  329.      *
  330.      * @param mixed $arrColumns
  331.      * @param mixed $arrValues
  332.      * @param array $arrOptions
  333.      *
  334.      * @return Collection
  335.      */
  336.     public static function findAvailableBy($arrColumns, $arrValues, array $arrOptions = array())
  337.     {
  338.         $objProducts = static::findPublishedBy($arrColumns, $arrValues, $arrOptions);
  340.         if (null === $objProducts) {
  341.             return null;
  342.         }
  344.         $arrProducts = [];
  345.         foreach ($objProducts as $objProduct) {
  346.             if ($objProduct->isAvailableInFrontend()) {
  347.                 $arrProducts[] = $objProduct;
  348.             }
  349.         }
  351.         if (0 === \count($arrProducts)) {
  352.             return null;
  353.         }
  355.         return new Collection($arrProducts, static::$strTable);
  356.     }
  358.     /**
  359.      * Find variant of a product
  360.      *
  361.      * @param IsotopeProduct $objProduct
  362.      * @param array          $arrVariant
  363.      * @param array          $arrOptions
  364.      *
  365.      * @return Model|null
  366.      */
  367.     public static function findVariantOfProduct(
  368.         IsotopeProduct $objProduct,
  369.         array $arrVariant,
  370.         array $arrOptions = array()
  371.     ) {
  372.         $t = static::$strTable;
  374.         $arrColumns = array(
  375.             "$t.id IN (" . implode(',', $objProduct->getVariantIds()) . ')',
  376.             "$t." . implode("=? AND $t.", array_keys($arrVariant)) . '=?'
  377.         );
  379.         $arrOptions = array_merge(
  380.             array(
  381.                  'limit'  => 1,
  382.                  'column' => $arrColumns,
  383.                  'value'  => $arrVariant,
  384.                  'return' => 'Model'
  385.             ),
  386.             $arrOptions
  387.         );
  389.         return static::find($arrOptions);
  390.     }
  392.     /**
  393.      * Finds the default variant of a product.
  394.      *
  395.      * @param IsotopeProduct $objProduct
  396.      * @param array          $arrOptions
  397.      *
  398.      * @return static|null
  399.      */
  400.     public static function findDefaultVariantOfProduct(IsotopeProduct $objProduct, array $arrOptions = array())
  401.     {
  402.         static $cache;
  404.         if (null === $cache) {
  405.             $cache = [];
  406.             $data  = Database::getInstance()->execute(
  407.                 "SELECT id, pid FROM tl_iso_product WHERE pid>0 AND language='' AND fallback='1'"
  408.             );
  410.             while ($data->next()) {
  411.                 $cache[$data->pid] = $data->id;
  412.             }
  413.         }
  415.         $defaultId = $cache[$objProduct->getProductId()] ?? null;
  417.         if ($defaultId < 1 || !\in_array($defaultId, $objProduct->getVariantIds())) {
  418.             return null;
  419.         }
  421.         return static::findByPk($defaultId, $arrOptions);
  422.     }
  424.     /**
  425.      * Returns the number of published products.
  426.      *
  427.      * @param array $arrOptions
  428.      *
  429.      * @return int
  430.      */
  431.     public static function countPublished(array $arrOptions = array())
  432.     {
  433.         return static::countPublishedBy(array(), array(), $arrOptions);
  434.     }
  436.     /**
  437.      * Return the number of products matching certain criteria
  438.      *
  439.      * @param mixed $arrColumns
  440.      * @param mixed $arrValues
  441.      * @param array $arrOptions
  442.      *
  443.      * @return int
  444.      */
  445.     public static function countPublishedBy($arrColumns, $arrValues, array $arrOptions = array())
  446.     {
  447.         $t = static::$strTable;
  449.         $arrValues = (array) $arrValues;
  451.         if (!\is_array($arrColumns)) {
  452.             $arrColumns = array(static::$strTable . '.' . $arrColumns . '=?');
  453.         }
  455.         // Add publish check to $arrColumns as the first item to enable SQL keys
  456.         if (BE_USER_LOGGED_IN !== true) {
  457.             $time = Date::floorToMinute();
  458.             array_unshift(
  459.                 $arrColumns,
  460.                 "
  461.                     $t.published='1'
  462.                     AND ($t.start='' OR $t.start<'$time')
  463.                     AND ($t.stop='' OR $t.stop>'" . ($time + 60) . "')
  464.                 "
  465.             );
  466.         }
  468.         return static::countBy($arrColumns, $arrValues, $arrOptions);
  469.     }
  471.     /**
  472.      * Gets the number of translation records in the product table.
  473.      * Mostly useful to see if there are any translations at all to optimize queries.
  474.      *
  475.      * @return int
  476.      */
  477.     public static function countTranslatedProducts()
  478.     {
  479.         static $result;
  481.         if (null === $result) {
  482.             $result = Database::getInstance()->query(
  483.                 "SELECT COUNT(*) AS total FROM tl_iso_product WHERE language!=''"
  484.             )->total;
  485.         }
  487.         return $result;
  488.     }
  490.     /**
  491.      * Return a model or collection based on the database result type
  492.      *
  493.      * @param array $arrOptions
  494.      *
  495.      * @return Product|Product[]|Collection|null
  496.      */
  497.     protected static function find(array $arrOptions)
  498.     {
  499.         $arrOptions['group'] = static::getTable() . '.id' . (null === ($arrOptions['group'] ?? null) ? '' : ', '.$arrOptions['group']);
  501.         $objProducts = parent::find($arrOptions);
  503.         if (null === $objProducts) {
  504.             return null;
  505.         }
  507.         /** @var Filter[] $arrFilters */
  508.         $arrFilters = $arrOptions['filters'] ?? null;
  509.         $arrSorting = $arrOptions['sorting'] ?? null;
  511.         $hasFilters = \is_array($arrFilters) && 0 !== \count($arrFilters);
  512.         $hasSorting = \is_array($arrSorting) && 0 !== \count($arrSorting);
  514.         if ($hasFilters || $hasSorting) {
  516.             /** @var static[] $arrProducts */
  517.             $arrProducts = $objProducts->getModels();
  519.             if ($hasFilters) {
  520.                 $arrProducts = array_filter($arrProducts, function ($objProduct) use ($arrFilters) {
  521.                     $arrGroups = [];
  523.                     foreach ($arrFilters as $objFilter) {
  524.                         $blnMatch = $objFilter->matches($objProduct);
  526.                         if ($objFilter->hasGroup()) {
  527.                             $arrGroups[$objFilter->getGroup()] = $arrGroups[$objFilter->getGroup()] ? : $blnMatch;
  528.                         } elseif (!$blnMatch) {
  529.                             return false;
  530.                         }
  531.                     }
  533.                     return !\in_array(false, $arrGroups, true);
  534.                 });
  535.             }
  537.             // $arrProducts can be empty if the filter removed all records
  538.             if ($hasSorting && 0 !== \count($arrProducts)) {
  539.                 $arrParam = array();
  540.                 $arrData  = array();
  542.                 foreach ($arrSorting as $strField => $arrConfig) {
  543.                     foreach ($arrProducts as $objProduct) {
  545.                         // Both SORT_STRING and SORT_REGULAR are case sensitive, strings starting with a capital letter
  546.                         // will come before strings starting with a lowercase letter. To perform a case insensitive
  547.                         // search, force the sorting order to be determined by a lowercase copy of the original value.
  549.                         // Temporary fix for price attribute (see #945)
  550.                         if ('price' === $strField) {
  551.                             if (null !== $objProduct->getPrice()) {
  552.                                 $arrData[$strField][$objProduct->id] = $objProduct->getPrice()->getAmount();
  553.                             } else {
  554.                                 $arrData[$strField][$objProduct->id] = 0;
  555.                             }
  557.                             continue;
  558.                         }
  560.                         if(
  561.                             $objProduct->hasVariants()
  562.                             && !$objProduct->isVariant()
  563.                             && \in_array($strField, $objProduct->getType()->getVariantAttributes(), true)
  564.                             && ($defaultVariant = Product::findDefaultVariantOfProduct($objProduct))
  565.                         ) {
  566.                             $arrData[$strField][$objProduct->id] = strtolower(
  567.                                 str_replace('"', '', $defaultVariant->$strField)
  568.                             );
  570.                             continue;
  571.                         }
  573.                         $arrData[$strField][$objProduct->id] = strtolower(
  574.                             str_replace('"', '', $objProduct->$strField)
  575.                         );
  576.                     }
  578.                     $arrParam[] = &$arrData[$strField];
  579.                     $arrParam[] = $arrConfig[0];
  580.                     $arrParam[] = $arrConfig[1];
  581.                 }
  583.                 // Add product array as the last item.
  584.                 // This will sort the products array based on the sorting of the passed in arguments.
  585.                 $arrParam[] = &$arrProducts;
  586.                 array_multisort(...$arrParam);
  587.             }
  589.             $objProducts = new Collection($arrProducts, static::$strTable);
  590.         }
  592.         return $objProducts;
  593.     }
  595.     /**
  596.      * Return select statement to load product data including multilingual fields
  597.      *
  598.      * @param array $arrOptions an array of columns
  599.      *
  600.      * @return string
  601.      */
  602.     protected static function buildFindQuery(array $arrOptions)
  603.     {
  604.         $objBase         = DcaExtractor::getInstance($arrOptions['table']);
  605.         $hasTranslations = (static::countTranslatedProducts() > 0);
  606.         $hasVariants     = (ProductType::countByVariants() > 0);
  608.         $arrJoins  = array();
  609.         $arrFields = array(
  610.             $arrOptions['table'] . '.*',
  611.             "'" . str_replace('-', '_', $GLOBALS['TL_LANGUAGE']) . "' AS language",
  612.         );
  614.         if ($hasVariants) {
  615.             $arrFields[] = sprintf(
  616.                 'IF(%s.pid>0, parent.type, %s.type) AS type',
  617.                 $arrOptions['table'],
  618.                 $arrOptions['table']
  619.             );
  620.         }
  622.         if ($hasTranslations) {
  623.             foreach (Attribute::getMultilingualFields() as $attribute) {
  624.                 $arrFields[] = "IFNULL(translation.$attribute, " . $arrOptions['table'] . ".$attribute) AS $attribute";
  625.             }
  626.         }
  628.         foreach (Attribute::getFetchFallbackFields() as $attribute) {
  629.             $arrFields[] = "{$arrOptions['table']}.$attribute AS {$attribute}_fallback";
  630.         }
  632.         if ($hasTranslations) {
  633.             $arrJoins[] = sprintf(
  634.                 " LEFT OUTER JOIN %s translation ON %s.id=translation.pid AND translation.language='%s'",
  635.                 $arrOptions['table'],
  636.                 $arrOptions['table'],
  637.                 str_replace('-', '_', $GLOBALS['TL_LANGUAGE'])
  638.             );
  640.             $arrOptions['group'] = (empty($arrOptions['group']) ? '' : $arrOptions['group'].', ') . 'translation.id';
  641.         }
  643.         if ($hasVariants) {
  644.             $arrJoins[] = sprintf(
  645.                 ' LEFT OUTER JOIN %s parent ON %s.pid=parent.id',
  646.                 $arrOptions['table'],
  647.                 $arrOptions['table']
  648.             );
  649.         }
  651.         $arrFields[] = 'GROUP_CONCAT(c.page_id) AS product_categories';
  652.         $arrJoins[] = sprintf(
  653.             ' LEFT OUTER JOIN %s c ON %s=c.pid',
  654.             ProductCategory::getTable(),
  655.             ($hasVariants ? "IFNULL(parent.id, {$arrOptions['table']}.id)" : "{$arrOptions['table']}.id")
  656.         );
  658.         if ('c.sorting' === ($arrOptions['order'] ?? '')) {
  659.             $arrFields[] = 'c.sorting';
  661.             $arrOptions['group'] = (null === $arrOptions['group'] ? '' : $arrOptions['group'].', ') . 'c.id';
  662.         }
  664.         if ($objBase->hasRelations()) {
  665.             $intCount = 0;
  667.             foreach ($objBase->getRelations() as $strKey => $arrConfig) {
  668.                 // Automatically join the single-relation records
  669.                 if (('eager' === $arrConfig['load'] || ($arrOptions['eager'] ?? false))
  670.                     && ('hasOne' === $arrConfig['type'] || 'belongsTo' === $arrConfig['type'])
  671.                 ) {
  672.                     if (\is_array($arrOptions['joinAliases'] ?? null)
  673.                         && ($key = array_search($arrConfig['table'], $arrOptions['joinAliases'], true)) !== false
  674.                     ) {
  675.                         $strJoinAlias = $key;
  676.                         unset($arrOptions['joinAliases'][$key]);
  677.                     } else {
  678.                         ++$intCount;
  679.                         $strJoinAlias = 'j' . $intCount;
  680.                     }
  682.                     $objRelated = DcaExtractor::getInstance($arrConfig['table']);
  684.                     foreach ($objRelated->getFields() as $strField => $config) {
  685.                         $arrFields[] = $strJoinAlias . '.' . $strField . ' AS ' . $strKey . '__' . $strField;
  686.                     }
  688.                     $arrJoins[] = sprintf(
  689.                         ' LEFT JOIN %s %s ON %s.%s=%s.id',
  690.                         $arrConfig['table'],
  691.                         $strJoinAlias,
  692.                         $arrOptions['table'],
  693.                         $strKey,
  694.                         $strJoinAlias
  695.                     );
  696.                 }
  697.             }
  698.         }
  700.         // Generate the query
  701.         $strQuery = 'SELECT ' . implode(', ', $arrFields) . ' FROM ' . $arrOptions['table'] . implode('', $arrJoins);
  703.         // Where condition
  704.         if (!\is_array($arrOptions['column'] ?? null)) {
  705.             $arrOptions['column'] = array($arrOptions['table'] . '.' . $arrOptions['column'] . '=?');
  706.         }
  708.         // The model must never find a language record
  709.         $strQuery .= " WHERE {$arrOptions['table']}.language='' AND " . implode(' AND ', $arrOptions['column']);
  711.         // Group by
  712.         if (($arrOptions['group'] ?? null) !== null) {
  713.             $strQuery .= ' GROUP BY ' . $arrOptions['group'];
  714.         }
  716.         // Order by
  717.         if (($arrOptions['order'] ?? null) !== null) {
  718.             $strQuery .= ' ORDER BY ' . $arrOptions['order'];
  719.         }
  721.         return $strQuery;
  722.     }
  724.     /**
  725.      * Build a query based on the given options to count the number of products.
  726.      *
  727.      * @param array $arrOptions The options array
  728.      *
  729.      * @return string
  730.      */
  731.     protected static function buildCountQuery(array $arrOptions)
  732.     {
  733.         $hasTranslations = (static::countTranslatedProducts() > 0);
  734.         $hasVariants     = (ProductType::countByVariants() > 0);
  736.         $arrJoins  = array();
  737.         $arrFields = array(
  738.             $arrOptions['table'] . '.id',
  739.             "'" . str_replace('-', '_', $GLOBALS['TL_LANGUAGE']) . "' AS language",
  740.         );
  742.         if ($hasVariants) {
  743.             $arrFields[] = sprintf(
  744.                 'IF(%s.pid>0, parent.type, %s.type) AS type',
  745.                 $arrOptions['table'],
  746.                 $arrOptions['table']
  747.             );
  748.         }
  750.         if ($hasTranslations) {
  751.             foreach (Attribute::getMultilingualFields() as $attribute) {
  752.                 $arrFields[] = "IFNULL(translation.$attribute, " . $arrOptions['table'] . ".$attribute) AS $attribute";
  753.             }
  754.         }
  756.         if ($hasTranslations) {
  757.             $arrJoins[] = sprintf(
  758.                 " LEFT OUTER JOIN %s translation ON %s.id=translation.pid AND translation.language='%s'",
  759.                 $arrOptions['table'],
  760.                 $arrOptions['table'],
  761.                 str_replace('-', '_', $GLOBALS['TL_LANGUAGE'])
  762.             );
  764.             $arrOptions['group'] = (!empty($arrOptions['group']) ? $arrOptions['group'].', ' : '') . 'translation.id, tl_iso_product.id';
  765.         }
  767.         if ($hasVariants) {
  768.             $arrJoins[] = sprintf(
  769.                 ' LEFT OUTER JOIN %s parent ON %s.pid=parent.id',
  770.                 $arrOptions['table'],
  771.                 $arrOptions['table']
  772.             );
  773.         }
  775.         $arrJoins[] = sprintf(
  776.             ' LEFT OUTER JOIN %s c ON %s=c.pid',
  777.             ProductCategory::getTable(),
  778.             ($hasVariants ? "IFNULL(parent.id, {$arrOptions['table']}.id)" : "{$arrOptions['table']}.id")
  779.         );
  781.         // Generate the query
  782.         $strWhere = '';
  783.         $strQuery = '
  784.             SELECT
  785.                 ' . implode(', ', $arrFields) . '
  786.             FROM ' . $arrOptions['table'] . implode('', $arrJoins);
  788.         // Where condition
  789.         if (!empty($arrOptions['column'])) {
  790.             if (!\is_array($arrOptions['column'])) {
  791.                 $arrOptions['column'] = array($arrOptions['table'] . '.' . $arrOptions['column'] . '=?');
  792.             }
  794.             $strWhere = ' AND ' . implode(' AND ', $arrOptions['column']);
  795.         }
  797.         // The model must never find a language record
  798.         $strQuery .= " WHERE {$arrOptions['table']}.language=''" . $strWhere;
  800.         // Group by
  801.         if ($arrOptions['group'] !== null) {
  802.             $strQuery .= ' GROUP BY ' . $arrOptions['group'];
  803.         }
  805.         return 'SELECT COUNT(*) AS count FROM ('.$strQuery.') c1';
  806.     }
  808.     /**
  809.      * Return select statement to load product data including multilingual fields
  810.      *
  811.      * @param array $arrOptions     an array of columns
  812.      * @param array $arrJoinAliases an array of table join aliases
  813.      *
  814.      * @return string
  815.      *
  816.      * @deprecated  use buildFindQuery introduced in Contao 3.3
  817.      */
  818.     protected static function buildQueryString($arrOptions, $arrJoinAliases = array('t' => 'tl_iso_producttype'))
  819.     {
  820.         $arrOptions['joinAliases'] = $arrJoinAliases;
  822.         return static::buildFindQuery((array) $arrOptions);
  823.     }
  824. }