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:  * Catalog category helper
 29:  *
 30:  * @author      Magento Core Team <core@magentocommerce.com>
 31:  */
 32: class Mage_Catalog_Helper_Product extends Mage_Core_Helper_Url
 33: {
 34:     const XML_PATH_PRODUCT_URL_SUFFIX           = 'catalog/seo/product_url_suffix';
 35:     const XML_PATH_PRODUCT_URL_USE_CATEGORY     = 'catalog/seo/product_use_categories';
 36:     const XML_PATH_USE_PRODUCT_CANONICAL_TAG    = 'catalog/seo/product_canonical_tag';
 37: 
 38:     /**
 39:      * Flag that shows if Magento has to check product to be saleable (enabled and/or inStock)
 40:      *
 41:      * @var boolean
 42:      */
 43:     protected $_skipSaleableCheck = false;
 44: 
 45:     /**
 46:      * Cache for product rewrite suffix
 47:      *
 48:      * @var array
 49:      */
 50:     protected $_productUrlSuffix = array();
 51: 
 52:     protected $_statuses;
 53: 
 54:     protected $_priceBlock;
 55: 
 56:     /**
 57:      * Retrieve product view page url
 58:      *
 59:      * @param   mixed $product
 60:      * @return  string
 61:      */
 62:     public function getProductUrl($product)
 63:     {
 64:         if ($product instanceof Mage_Catalog_Model_Product) {
 65:             return $product->getProductUrl();
 66:         }
 67:         elseif (is_numeric($product)) {
 68:             return Mage::getModel('catalog/product')->load($product)->getProductUrl();
 69:         }
 70:         return false;
 71:     }
 72: 
 73:     /**
 74:      * Retrieve product price
 75:      *
 76:      * @param   Mage_Catalog_Model_Product $product
 77:      * @return  float
 78:      */
 79:     public function getPrice($product)
 80:     {
 81:         return $product->getPrice();
 82:     }
 83: 
 84:     /**
 85:      * Retrieve product final price
 86:      *
 87:      * @param   Mage_Catalog_Model_Product $product
 88:      * @return  float
 89:      */
 90:     public function getFinalPrice($product)
 91:     {
 92:         return $product->getFinalPrice();
 93:     }
 94: 
 95:     /**
 96:      * Retrieve base image url
 97:      *
 98:      * @return string
 99:      */
100:     public function getImageUrl($product)
101:     {
102:         $url = false;
103:         if (!$product->getImage()) {
104:             $url = Mage::getDesign()->getSkinUrl('images/no_image.jpg');
105:         }
106:         elseif ($attribute = $product->getResource()->getAttribute('image')) {
107:             $url = $attribute->getFrontend()->getUrl($product);
108:         }
109:         return $url;
110:     }
111: 
112:     /**
113:      * Retrieve small image url
114:      *
115:      * @return unknown
116:      */
117:     public function getSmallImageUrl($product)
118:     {
119:         $url = false;
120:         if (!$product->getSmallImage()) {
121:             $url = Mage::getDesign()->getSkinUrl('images/no_image.jpg');
122:         }
123:         elseif ($attribute = $product->getResource()->getAttribute('small_image')) {
124:             $url = $attribute->getFrontend()->getUrl($product);
125:         }
126:         return $url;
127:     }
128: 
129:     /**
130:      * Retrieve thumbnail image url
131:      *
132:      * @return unknown
133:      */
134:     public function getThumbnailUrl($product)
135:     {
136:         return '';
137:     }
138: 
139:     public function getEmailToFriendUrl($product)
140:     {
141:         $categoryId = null;
142:         if ($category = Mage::registry('current_category')) {
143:             $categoryId = $category->getId();
144:         }
145:         return $this->_getUrl('sendfriend/product/send', array(
146:             'id' => $product->getId(),
147:             'cat_id' => $categoryId
148:         ));
149:     }
150: 
151:     public function getStatuses()
152:     {
153:         if(is_null($this->_statuses)) {
154:             $this->_statuses = array();//Mage::getModel('catalog/product_status')->getResourceCollection()->load();
155:         }
156: 
157:         return $this->_statuses;
158:     }
159: 
160:     /**
161:      * Check if a product can be shown
162:      *
163:      * @param  Mage_Catalog_Model_Product|int $product
164:      * @return boolean
165:      */
166:     public function canShow($product, $where = 'catalog')
167:     {
168:         if (is_int($product)) {
169:             $product = Mage::getModel('catalog/product')->load($product);
170:         }
171: 
172:         /* @var $product Mage_Catalog_Model_Product */
173: 
174:         if (!$product->getId()) {
175:             return false;
176:         }
177: 
178:         return $product->isVisibleInCatalog() && $product->isVisibleInSiteVisibility();
179:     }
180: 
181:     /**
182:      * Retrieve product rewrite sufix for store
183:      *
184:      * @param int $storeId
185:      * @return string
186:      */
187:     public function getProductUrlSuffix($storeId = null)
188:     {
189:         if (is_null($storeId)) {
190:             $storeId = Mage::app()->getStore()->getId();
191:         }
192: 
193:         if (!isset($this->_productUrlSuffix[$storeId])) {
194:             $this->_productUrlSuffix[$storeId] = Mage::getStoreConfig(self::XML_PATH_PRODUCT_URL_SUFFIX, $storeId);
195:         }
196:         return $this->_productUrlSuffix[$storeId];
197:     }
198: 
199:     /**
200:      * Check if <link rel="canonical"> can be used for product
201:      *
202:      * @param $store
203:      * @return bool
204:      */
205:     public function canUseCanonicalTag($store = null)
206:     {
207:         return Mage::getStoreConfig(self::XML_PATH_USE_PRODUCT_CANONICAL_TAG, $store);
208:     }
209: 
210:     /**
211:      * Return information array of product attribute input types
212:      * Only a small number of settings returned, so we won't break anything in current dataflow
213:      * As soon as development process goes on we need to add there all possible settings
214:      *
215:      * @param string $inputType
216:      * @return array
217:      */
218:     public function getAttributeInputTypes($inputType = null)
219:     {
220:         /**
221:         * @todo specify there all relations for properties depending on input type
222:         */
223:         $inputTypes = array(
224:             'multiselect'   => array(
225:                 'backend_model'     => 'eav/entity_attribute_backend_array'
226:             ),
227:             'boolean'       => array(
228:                 'source_model'      => 'eav/entity_attribute_source_boolean'
229:             )
230:         );
231: 
232:         if (is_null($inputType)) {
233:             return $inputTypes;
234:         } else if (isset($inputTypes[$inputType])) {
235:             return $inputTypes[$inputType];
236:         }
237:         return array();
238:     }
239: 
240:     /**
241:      * Return default attribute backend model by input type
242:      *
243:      * @param string $inputType
244:      * @return string|null
245:      */
246:     public function getAttributeBackendModelByInputType($inputType)
247:     {
248:         $inputTypes = $this->getAttributeInputTypes();
249:         if (!empty($inputTypes[$inputType]['backend_model'])) {
250:             return $inputTypes[$inputType]['backend_model'];
251:         }
252:         return null;
253:     }
254: 
255:     /**
256:      * Return default attribute source model by input type
257:      *
258:      * @param string $inputType
259:      * @return string|null
260:      */
261:     public function getAttributeSourceModelByInputType($inputType)
262:     {
263:         $inputTypes = $this->getAttributeInputTypes();
264:         if (!empty($inputTypes[$inputType]['source_model'])) {
265:             return $inputTypes[$inputType]['source_model'];
266:         }
267:         return null;
268:     }
269: 
270:     /**
271:      * Inits product to be used for product controller actions and layouts
272:      * $params can have following data:
273:      *   'category_id' - id of category to check and append to product as current.
274:      *     If empty (except FALSE) - will be guessed (e.g. from last visited) to load as current.
275:      *
276:      * @param int $productId
277:      * @param Mage_Core_Controller_Front_Action $controller
278:      * @param Varien_Object $params
279:      *
280:      * @return false|Mage_Catalog_Model_Product
281:      */
282:     public function initProduct($productId, $controller, $params = null)
283:     {
284:         // Prepare data for routine
285:         if (!$params) {
286:             $params = new Varien_Object();
287:         }
288: 
289:         // Init and load product
290:         Mage::dispatchEvent('catalog_controller_product_init_before', array(
291:             'controller_action' => $controller,
292:             'params' => $params,
293:         ));
294: 
295:         if (!$productId) {
296:             return false;
297:         }
298: 
299:         $product = Mage::getModel('catalog/product')
300:             ->setStoreId(Mage::app()->getStore()->getId())
301:             ->load($productId);
302: 
303:         if (!$this->canShow($product)) {
304:             return false;
305:         }
306:         if (!in_array(Mage::app()->getStore()->getWebsiteId(), $product->getWebsiteIds())) {
307:             return false;
308:         }
309: 
310:         // Load product current category
311:         $categoryId = $params->getCategoryId();
312:         if (!$categoryId && ($categoryId !== false)) {
313:             $lastId = Mage::getSingleton('catalog/session')->getLastVisitedCategoryId();
314:             if ($product->canBeShowInCategory($lastId)) {
315:                 $categoryId = $lastId;
316:             }
317:         } elseif (!$product->canBeShowInCategory($categoryId)) {
318:             $categoryId = null;
319:         }
320: 
321:         if ($categoryId) {
322:             $category = Mage::getModel('catalog/category')->load($categoryId);
323:             $product->setCategory($category);
324:             Mage::register('current_category', $category);
325:         }
326: 
327:         // Register current data and dispatch final events
328:         Mage::register('current_product', $product);
329:         Mage::register('product', $product);
330: 
331:         try {
332:             Mage::dispatchEvent('catalog_controller_product_init', array('product' => $product));
333:             Mage::dispatchEvent('catalog_controller_product_init_after',
334:                             array('product' => $product,
335:                                 'controller_action' => $controller
336:                             )
337:             );
338:         } catch (Mage_Core_Exception $e) {
339:             Mage::logException($e);
340:             return false;
341:         }
342: 
343:         return $product;
344:     }
345: 
346:     /**
347:      * Prepares product options by buyRequest: retrieves values and assigns them as default.
348:      * Also parses and adds product management related values - e.g. qty
349:      *
350:      * @param  Mage_Catalog_Model_Product $product
351:      * @param  Varien_Object $buyRequest
352:      * @return Mage_Catalog_Helper_Product
353:      */
354:     public function prepareProductOptions($product, $buyRequest)
355:     {
356:         $optionValues = $product->processBuyRequest($buyRequest);
357:         $optionValues->setQty($buyRequest->getQty());
358:         $product->setPreconfiguredValues($optionValues);
359: 
360:         return $this;
361:     }
362: 
363:     /**
364:      * Process $buyRequest and sets its options before saving configuration to some product item.
365:      * This method is used to attach additional parameters to processed buyRequest.
366:      *
367:      * $params holds parameters of what operation must be performed:
368:      * - 'current_config', Varien_Object or array - current buyRequest that configures product in this item,
369:      *   used to restore currently attached files
370:      * - 'files_prefix': string[a-z0-9_] - prefix that was added at frontend to names of file inputs,
371:      *   so they won't intersect with other submitted options
372:      *
373:      * @param Varien_Object|array $buyRequest
374:      * @param Varien_Object|array $params
375:      * @return Varien_Object
376:      */
377:     public function addParamsToBuyRequest($buyRequest, $params)
378:     {
379:         if (is_array($buyRequest)) {
380:             $buyRequest = new Varien_Object($buyRequest);
381:         }
382:         if (is_array($params)) {
383:             $params = new Varien_Object($params);
384:         }
385: 
386: 
387:         // Ensure that currentConfig goes as Varien_Object - for easier work with it later
388:         $currentConfig = $params->getCurrentConfig();
389:         if ($currentConfig) {
390:             if (is_array($currentConfig)) {
391:                 $params->setCurrentConfig(new Varien_Object($currentConfig));
392:             } else if (!($currentConfig instanceof Varien_Object)) {
393:                 $params->unsCurrentConfig();
394:             }
395:         }
396: 
397:         /*
398:          * Notice that '_processing_params' must always be object to protect processing forged requests
399:          * where '_processing_params' comes in $buyRequest as array from user input
400:          */
401:         $processingParams = $buyRequest->getData('_processing_params');
402:         if (!$processingParams || !($processingParams instanceof Varien_Object)) {
403:             $processingParams = new Varien_Object();
404:             $buyRequest->setData('_processing_params', $processingParams);
405:         }
406:         $processingParams->addData($params->getData());
407: 
408:         return $buyRequest;
409:     }
410: 
411:     /**
412:      * Return loaded product instance
413:      *
414:      * @param  int|string $productId (SKU or ID)
415:      * @param  int $store
416:      * @param  string $identifierType
417:      * @return Mage_Catalog_Model_Product
418:      */
419:     public function getProduct($productId, $store, $identifierType = null)
420:     {
421:         /** @var $product Mage_Catalog_Model_Product */
422:         $product = Mage::getModel('catalog/product')->setStoreId(Mage::app()->getStore($store)->getId());
423: 
424:         $expectedIdType = false;
425:         if ($identifierType === null) {
426:             if (is_string($productId) && !preg_match("/^[+-]?[1-9][0-9]*$|^0$/", $productId)) {
427:                 $expectedIdType = 'sku';
428:             }
429:         }
430: 
431:         if ($identifierType == 'sku' || $expectedIdType == 'sku') {
432:             $idBySku = $product->getIdBySku($productId);
433:             if ($idBySku) {
434:                 $productId = $idBySku;
435:             } else if ($identifierType == 'sku') {
436:                 // Return empty product because it was not found by originally specified SKU identifier
437:                 return $product;
438:             }
439:         }
440: 
441:         if ($productId && is_numeric($productId)) {
442:             $product->load((int) $productId);
443:         }
444: 
445:         return $product;
446:     }
447: 
448:     /**
449:      * Set flag that shows if Magento has to check product to be saleable (enabled and/or inStock)
450:      *
451:      * For instance, during order creation in the backend admin has ability to add any products to order
452:      *
453:      * @param bool $skipSaleableCheck
454:      * @return Mage_Catalog_Helper_Product
455:      */
456:     public function setSkipSaleableCheck($skipSaleableCheck = false)
457:     {
458:         $this->_skipSaleableCheck = $skipSaleableCheck;
459:         return $this;
460:     }
461: 
462:     /**
463:      * Get flag that shows if Magento has to check product to be saleable (enabled and/or inStock)
464:      *
465:      * @return boolean
466:      */
467:     public function getSkipSaleableCheck()
468:     {
469:         return $this->_skipSaleableCheck;
470:     }
471: }
472: