1: <?php
  2: /**
  3:  * Magento
  4:  *
  5:  * NOTICE OF LICENSE
  6:  *
  7:  * This source file is subject to the Open Software License (OSL 3.0)
  8:  * that is bundled with this package in the file LICENSE.txt.
  9:  * It is also available through the world-wide-web at this URL:
 10:  * http://opensource.org/licenses/osl-3.0.php
 11:  * If you did not receive a copy of the license and are unable to
 12:  * obtain it through the world-wide-web, please send an email
 13:  * to license@magentocommerce.com so we can send you a copy immediately.
 14:  *
 15:  * DISCLAIMER
 16:  *
 17:  * Do not edit or add to this file if you wish to upgrade Magento to newer
 18:  * versions in the future. If you wish to customize Magento for your
 19:  * needs please refer to http://www.magentocommerce.com for more information.
 20:  *
 21:  * @category    Mage
 22:  * @package     Mage_Catalog
 23:  * @copyright   Copyright (c) 2012 Magento Inc. (http://www.magentocommerce.com)
 24:  * @license     http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)
 25:  */
 26: 
 27: /**
 28:  * Layer price filter
 29:  *
 30:  * @category    Mage
 31:  * @package     Mage_Catalog
 32:  * @author      Magento Core Team <core@magentocommerce.com>
 33:  */
 34: 
 35: /**
 36:  * @method Mage_Catalog_Model_Layer_Filter_Price setInterval(array)
 37:  * @method array getInterval()
 38:  */
 39: class Mage_Catalog_Model_Layer_Filter_Price extends Mage_Catalog_Model_Layer_Filter_Abstract
 40: {
 41:     /**
 42:      * XML configuration paths for Price Layered Navigation
 43:      */
 44:     const XML_PATH_RANGE_CALCULATION       = 'catalog/layered_navigation/price_range_calculation';
 45:     const XML_PATH_RANGE_STEP              = 'catalog/layered_navigation/price_range_step';
 46:     const XML_PATH_RANGE_MAX_INTERVALS     = 'catalog/layered_navigation/price_range_max_intervals';
 47:     const XML_PATH_ONE_PRICE_INTERVAL      = 'catalog/layered_navigation/one_price_interval';
 48:     const XML_PATH_INTERVAL_DIVISION_LIMIT = 'catalog/layered_navigation/interval_division_limit';
 49: 
 50:     /**
 51:      * Price layered navigation modes: Automatic (equalize price ranges), Automatic (equalize product counts), Manual
 52:      */
 53:     const RANGE_CALCULATION_AUTO     = 'auto'; // equalize price ranges
 54:     const RANGE_CALCULATION_IMPROVED = 'improved'; // equalize product counts
 55:     const RANGE_CALCULATION_MANUAL   = 'manual';
 56: 
 57:     /**
 58:      * Minimal size of the range
 59:      */
 60:     const MIN_RANGE_POWER = 10;
 61: 
 62:     /**
 63:      * Resource instance
 64:      *
 65:      * @var Mage_Catalog_Model_Resource_Eav_Mysql4_Layer_Filter_Price
 66:      */
 67:     protected $_resource;
 68: 
 69:     /**
 70:      * Class constructor
 71:      *
 72:      */
 73:     public function __construct()
 74:     {
 75:         parent::__construct();
 76:         $this->_requestVar = 'price';
 77:     }
 78: 
 79:     /**
 80:      * Retrieve resource instance
 81:      *
 82:      * @return Mage_Catalog_Model_Resource_Eav_Mysql4_Layer_Filter_Price
 83:      */
 84:     protected function _getResource()
 85:     {
 86:         if (is_null($this->_resource)) {
 87:             $this->_resource = Mage::getResourceModel('catalog/layer_filter_price');
 88:         }
 89:         return $this->_resource;
 90:     }
 91: 
 92:     /**
 93:      * Get price range for building filter steps
 94:      *
 95:      * @return int
 96:      */
 97:     public function getPriceRange()
 98:     {
 99:         $range = $this->getData('price_range');
100:         if (!$range) {
101:             $currentCategory = Mage::registry('current_category_filter');
102:             if ($currentCategory) {
103:                 $range = $currentCategory->getFilterPriceRange();
104:             } else {
105:                 $range = $this->getLayer()->getCurrentCategory()->getFilterPriceRange();
106:             }
107: 
108:             $maxPrice = $this->getMaxPriceInt();
109:             if (!$range) {
110:                 $calculation = Mage::app()->getStore()->getConfig(self::XML_PATH_RANGE_CALCULATION);
111:                 if ($calculation == self::RANGE_CALCULATION_AUTO) {
112:                     $index = 1;
113:                     do {
114:                         $range = pow(10, (strlen(floor($maxPrice)) - $index));
115:                         $items = $this->getRangeItemCounts($range);
116:                         $index++;
117:                     }
118:                     while($range > self::MIN_RANGE_POWER && count($items) < 2);
119:                 } else {
120:                     $range = (float)Mage::app()->getStore()->getConfig(self::XML_PATH_RANGE_STEP);
121:                 }
122:             }
123: 
124:             $this->setData('price_range', $range);
125:         }
126: 
127:         return $range;
128:     }
129: 
130:     /**
131:      * Get maximum price from layer products set
132:      *
133:      * @return float
134:      */
135:     public function getMaxPriceInt()
136:     {
137:         $maxPrice = $this->getData('max_price_int');
138:         if (is_null($maxPrice)) {
139:             $maxPrice = $this->getLayer()->getProductCollection()->getMaxPrice();
140:             $maxPrice = floor($maxPrice);
141:             $this->setData('max_price_int', $maxPrice);
142:         }
143: 
144:         return $maxPrice;
145:     }
146: 
147:     /**
148:      * Get information about products count in range
149:      *
150:      * @param   int $range
151:      * @return  int
152:      */
153:     public function getRangeItemCounts($range)
154:     {
155:         $rangeKey = 'range_item_counts_' . $range;
156:         $items = $this->getData($rangeKey);
157:         if (is_null($items)) {
158:             $items = $this->_getResource()->getCount($this, $range);
159:             // checking max number of intervals
160:             $i = 0;
161:             $lastIndex = null;
162:             $maxIntervalsNumber = $this->getMaxIntervalsNumber();
163:             $calculation = Mage::app()->getStore()->getConfig(self::XML_PATH_RANGE_CALCULATION);
164:             foreach ($items as $k => $v) {
165:                 ++$i;
166:                 if ($calculation == self::RANGE_CALCULATION_MANUAL && $i > 1 && $i > $maxIntervalsNumber) {
167:                     $items[$lastIndex] += $v;
168:                     unset($items[$k]);
169:                 } else {
170:                     $lastIndex = $k;
171:                 }
172:             }
173:             $this->setData($rangeKey, $items);
174:         }
175: 
176:         return $items;
177:     }
178: 
179:     /**
180:      * Prepare text of item label
181:      *
182:      * @deprecated since 1.7.0.0
183:      * @param   int $range
184:      * @param   float $value
185:      * @return  string
186:      */
187:     protected function _renderItemLabel($range, $value)
188:     {
189:         $store      = Mage::app()->getStore();
190:         $fromPrice  = $store->formatPrice(($value - 1) * $range);
191:         $toPrice    = $store->formatPrice($value*$range);
192: 
193:         return Mage::helper('catalog')->__('%s - %s', $fromPrice, $toPrice);
194:     }
195: 
196:     /**
197:      * Prepare text of range label
198:      *
199:      * @param float|string $fromPrice
200:      * @param float|string $toPrice
201:      * @return string
202:      */
203:     protected function _renderRangeLabel($fromPrice, $toPrice)
204:     {
205:         $store      = Mage::app()->getStore();
206:         $formattedFromPrice  = $store->formatPrice($fromPrice);
207:         if ($toPrice === '') {
208:             return Mage::helper('catalog')->__('%s and above', $formattedFromPrice);
209:         } elseif ($fromPrice == $toPrice && Mage::app()->getStore()->getConfig(self::XML_PATH_ONE_PRICE_INTERVAL)) {
210:             return $formattedFromPrice;
211:         } else {
212:             if ($fromPrice != $toPrice) {
213:                 $toPrice -= .01;
214:             }
215:             return Mage::helper('catalog')->__('%s - %s', $formattedFromPrice, $store->formatPrice($toPrice));
216:         }
217:     }
218: 
219:     /**
220:      * Get price aggreagation data cache key
221:      * @deprecated after 1.4
222:      * @return string
223:      */
224:     protected function _getCacheKey()
225:     {
226:         $key = $this->getLayer()->getStateKey()
227:             . '_PRICES_GRP_' . Mage::getSingleton('customer/session')->getCustomerGroupId()
228:             . '_CURR_' . Mage::app()->getStore()->getCurrentCurrencyCode()
229:             . '_ATTR_' . $this->getAttributeModel()->getAttributeCode()
230:             . '_LOC_'
231:             ;
232:         $taxReq = Mage::getSingleton('tax/calculation')->getRateRequest(false, false, false);
233:         $key.= implode('_', $taxReq->getData());
234: 
235:         return $key;
236:     }
237: 
238:     /**
239:      * Get additional request param data
240:      *
241:      * @return string
242:      */
243:     protected function _getAdditionalRequestData()
244:     {
245:         $result = '';
246:         $appliedInterval = $this->getInterval();
247:         if ($appliedInterval) {
248:             $result = ',' . $appliedInterval[0] . '-' . $appliedInterval[1];
249:             $priorIntervals = $this->getResetValue();
250:             if ($priorIntervals) {
251:                 $result .= ',' . $priorIntervals;
252:             }
253:         }
254: 
255:         return $result;
256:     }
257: 
258:     /**
259:      * Get data generated by algorithm for build price filter items
260:      *
261:      * @return array
262:      */
263:     protected function _getCalculatedItemsData()
264:     {
265:         /** @var $algorithmModel Mage_Catalog_Model_Layer_Filter_Price_Algorithm */
266:         $algorithmModel = Mage::getSingleton('catalog/layer_filter_price_algorithm');
267:         $collection = $this->getLayer()->getProductCollection();
268:         $appliedInterval = $this->getInterval();
269:         if ($appliedInterval
270:             && $collection->getPricesCount() <= $this->getIntervalDivisionLimit()
271:         ) {
272:             return array();
273:         }
274:         $algorithmModel->setPricesModel($this)->setStatistics(
275:             $collection->getMinPrice(),
276:             $collection->getMaxPrice(),
277:             $collection->getPriceStandardDeviation(),
278:             $collection->getPricesCount()
279:         );
280: 
281:         if ($appliedInterval) {
282:             if ($appliedInterval[0] == $appliedInterval[1] || $appliedInterval[1] === '0') {
283:                 return array();
284:             }
285:             $algorithmModel->setLimits($appliedInterval[0], $appliedInterval[1]);
286:         }
287: 
288:         $items = array();
289:         foreach ($algorithmModel->calculateSeparators() as $separator) {
290:             $items[] = array(
291:                 'label' => $this->_renderRangeLabel($separator['from'], $separator['to']),
292:                 'value' => (($separator['from'] == 0) ? '' : $separator['from'])
293:                     . '-' . $separator['to'] . $this->_getAdditionalRequestData(),
294:                 'count' => $separator['count'],
295:             );
296:         }
297: 
298:         return $items;
299:     }
300: 
301:     /**
302:      * Get data for build price filter items
303:      *
304:      * @return array
305:      */
306:     protected function _getItemsData()
307:     {
308:         if (Mage::app()->getStore()->getConfig(self::XML_PATH_RANGE_CALCULATION) == self::RANGE_CALCULATION_IMPROVED) {
309:             return $this->_getCalculatedItemsData();
310:         } elseif ($this->getInterval()) {
311:             return array();
312:         }
313: 
314:         $range      = $this->getPriceRange();
315:         $dbRanges   = $this->getRangeItemCounts($range);
316:         $data       = array();
317: 
318:         if (!empty($dbRanges)) {
319:             $lastIndex = array_keys($dbRanges);
320:             $lastIndex = $lastIndex[count($lastIndex) - 1];
321: 
322:             foreach ($dbRanges as $index => $count) {
323:                 $fromPrice = ($index == 1) ? '' : (($index - 1) * $range);
324:                 $toPrice = ($index == $lastIndex) ? '' : ($index * $range);
325: 
326:                 $data[] = array(
327:                     'label' => $this->_renderRangeLabel($fromPrice, $toPrice),
328:                     'value' => $fromPrice . '-' . $toPrice,
329:                     'count' => $count,
330:                 );
331:             }
332:         }
333: 
334:         return $data;
335:     }
336: 
337:     /**
338:      * Apply price range filter to collection
339:      *
340:      * @return Mage_Catalog_Model_Layer_Filter_Price
341:      */
342:     protected function _applyPriceRange()
343:     {
344:         $this->_getResource()->applyPriceRange($this);
345:         return $this;
346:     }
347: 
348:     /**
349:      * Validate and parse filter request param
350:      *
351:      * @param string $filter
352:      * @return array|bool
353:      */
354:     protected function _validateFilter($filter)
355:     {
356:         $filter = explode('-', $filter);
357:         if (count($filter) != 2) {
358:             return false;
359:         }
360:         foreach ($filter as $v) {
361:             if (($v !== '' && $v !== '0' && (float)$v <= 0) || is_infinite((float)$v)) {
362:                 return false;
363:             }
364:         }
365: 
366:         return $filter;
367:     }
368: 
369:     /**
370:      * Apply price range filter
371:      *
372:      * @param Zend_Controller_Request_Abstract $request
373:      * @param $filterBlock
374:      *
375:      * @return Mage_Catalog_Model_Layer_Filter_Price
376:      */
377:     public function apply(Zend_Controller_Request_Abstract $request, $filterBlock)
378:     {
379:         /**
380:          * Filter must be string: $fromPrice-$toPrice
381:          */
382:         $filter = $request->getParam($this->getRequestVar());
383:         if (!$filter) {
384:             return $this;
385:         }
386: 
387:         //validate filter
388:         $filterParams = explode(',', $filter);
389:         $filter = $this->_validateFilter($filterParams[0]);
390:         if (!$filter) {
391:             return $this;
392:         }
393: 
394:         list($from, $to) = $filter;
395: 
396:         $this->setInterval(array($from, $to));
397: 
398:         $priorFilters = array();
399:         for ($i = 1; $i < count($filterParams); ++$i) {
400:             $priorFilter = $this->_validateFilter($filterParams[$i]);
401:             if ($priorFilter) {
402:                 $priorFilters[] = $priorFilter;
403:             } else {
404:                 //not valid data
405:                 $priorFilters = array();
406:                 break;
407:             }
408:         }
409:         if ($priorFilters) {
410:             $this->setPriorIntervals($priorFilters);
411:         }
412: 
413:         $this->_applyPriceRange();
414:         $this->getLayer()->getState()->addFilter($this->_createItem(
415:             $this->_renderRangeLabel(empty($from) ? 0 : $from, $to),
416:             $filter
417:         ));
418: 
419:         return $this;
420:     }
421: 
422:     /**
423:      * Apply filter value to product collection based on filter range and selected value
424:      *
425:      * @deprecated since 1.7.0.0
426:      * @param int $range
427:      * @param int $index
428:      * @return Mage_Catalog_Model_Layer_Filter_Price
429:      */
430:     protected function _applyToCollection($range, $index)
431:     {
432:         $this->_getResource()->applyFilterToCollection($this, $range, $index);
433:         return $this;
434:     }
435: 
436:     /**
437:      * Retrieve active customer group id
438:      *
439:      * @return int
440:      */
441:     public function getCustomerGroupId()
442:     {
443:         $customerGroupId = $this->_getData('customer_group_id');
444:         if (is_null($customerGroupId)) {
445:             $customerGroupId = Mage::getSingleton('customer/session')->getCustomerGroupId();
446:         }
447:         return $customerGroupId;
448:     }
449: 
450:     /**
451:      * Set active customer group id for filter
452:      *
453:      * @param int $customerGroupId
454:      * @return Mage_Catalog_Model_Layer_Filter_Price
455:      */
456:     public function setCustomerGroupId($customerGroupId)
457:     {
458:         return $this->setData('customer_group_id', $customerGroupId);
459:     }
460: 
461:     /**
462:      * Retrieve active currency rate for filter
463:      *
464:      * @return float
465:      */
466:     public function getCurrencyRate()
467:     {
468:         $rate = $this->_getData('currency_rate');
469:         if (is_null($rate)) {
470:             $rate = Mage::app()->getStore($this->getStoreId())->getCurrentCurrencyRate();
471:         }
472:         if (!$rate) {
473:             $rate = 1;
474:         }
475:         return $rate;
476:     }
477: 
478:     /**
479:      * Set active currency rate for filter
480:      *
481:      * @param float $rate
482:      * @return Mage_Catalog_Model_Layer_Filter_Price
483:      */
484:     public function setCurrencyRate($rate)
485:     {
486:         return $this->setData('currency_rate', $rate);
487:     }
488: 
489:     /**
490:      * Get maximum number of intervals
491:      *
492:      * @return int
493:      */
494:     public function getMaxIntervalsNumber()
495:     {
496:         return (int)Mage::app()->getStore()->getConfig(self::XML_PATH_RANGE_MAX_INTERVALS);
497:     }
498: 
499:     /**
500:      * Get interval division limit
501:      *
502:      * @return int
503:      */
504:     public function getIntervalDivisionLimit()
505:     {
506:         return (int)Mage::app()->getStore()->getConfig(self::XML_PATH_INTERVAL_DIVISION_LIMIT);
507:     }
508: 
509:     /**
510:      * Get filter value for reset current filter state
511:      *
512:      * @return null|string
513:      */
514:     public function getResetValue()
515:     {
516:         $priorIntervals = $this->getPriorIntervals();
517:         $value = array();
518:         if ($priorIntervals) {
519:             foreach ($priorIntervals as $priorInterval) {
520:                 $value[] = implode('-', $priorInterval);
521:             }
522:             return implode(',', $value);
523:         }
524:         return parent::getResetValue();
525:     }
526: 
527:     /**
528:      * Get 'clear price' link text
529:      *
530:      * @return false|string
531:      */
532:     public function getClearLinkText()
533:     {
534:         if (Mage::app()->getStore()->getConfig(self::XML_PATH_RANGE_CALCULATION) == self::RANGE_CALCULATION_IMPROVED
535:             && $this->getPriorIntervals()
536:         ) {
537:             return Mage::helper('catalog')->__('Clear Price');
538:         }
539: 
540:         return parent::getClearLinkText();
541:     }
542: 
543:     /**
544:      * Load range of product prices
545:      *
546:      * @param int $limit
547:      * @param null|int $offset
548:      * @param null|int $lowerPrice
549:      * @param null|int $upperPrice
550:      * @return array|false
551:      */
552:     public function loadPrices($limit, $offset = null, $lowerPrice = null, $upperPrice = null)
553:     {
554:         $prices = $this->_getResource()->loadPrices($this, $limit, $offset, $lowerPrice, $upperPrice);
555:         if ($prices) {
556:             $prices = array_map('floatval', $prices);
557:         }
558: 
559:         return $prices;
560:     }
561: 
562:     /**
563:      * Load range of product prices, preceding the price
564:      *
565:      * @param float $price
566:      * @param int $index
567:      * @param null|int $lowerPrice
568:      * @return array|false
569:      */
570:     public function loadPreviousPrices($price, $index, $lowerPrice = null)
571:     {
572:         $prices = $this->_getResource()->loadPreviousPrices($this, $price, $index, $lowerPrice);
573:         if ($prices) {
574:             $prices = array_map('floatval', $prices);
575:         }
576: 
577:         return $prices;
578:     }
579: 
580:     /**
581:      * Load range of product prices, next to the price
582:      *
583:      * @param float $price
584:      * @param int $rightIndex
585:      * @param null|int $upperPrice
586:      * @return array|false
587:      */
588:     public function loadNextPrices($price, $rightIndex, $upperPrice = null)
589:     {
590:         $prices = $this->_getResource()->loadNextPrices($this, $price, $rightIndex, $upperPrice);
591:         if ($prices) {
592:             $prices = array_map('floatval', $prices);
593:         }
594: 
595:         return $prices;
596:     }
597: }
598: