privilegedemarque/classes/stock/StockAvailable.php

<?php
/*
* 2007-2014 PrestaShop
*
* NOTICE OF LICENSE
*
* This source file is subject to the Open Software License (OSL 3.0)
* that is bundled with this package in the file LICENSE.txt.
* It is also available through the world-wide-web at this URL:
* http://opensource.org/licenses/osl-3.0.php
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to license@prestashop.com so we can send you a copy immediately.
*
* DISCLAIMER
*
* Do not edit or add to this file if you wish to upgrade PrestaShop to newer
* versions in the future. If you wish to customize PrestaShop for your
* needs please refer to http://www.prestashop.com for more information.
*
*  @author PrestaShop SA <contact@prestashop.com>
*  @copyright  2007-2014 PrestaShop SA
*  @license    http://opensource.org/licenses/osl-3.0.php  Open Software License (OSL 3.0)
*  International Registered Trademark & Property of PrestaShop SA
*/

/**
 * Represents quantities available
 * It is either synchronized with Stock or manualy set by the seller
 *
 * @since 1.5.0
 */
class StockAvailableCore extends ObjectModel
{
	/** @var int identifier of the current product */
	public $id_product;

	/** @var int identifier of product attribute if necessary */
	public $id_product_attribute;

	/** @var int the shop associated to the current product and corresponding quantity */
	public $id_shop;

	/** @var int the group shop associated to the current product and corresponding quantity */
	public $id_shop_group;

	/** @var int the quantity available for sale */
	public $quantity = 0;

	/** @var bool determine if the available stock value depends on physical stock */
	public $depends_on_stock = false;

	/** @var bool determine if a product is out of stock - it was previously in Product class */
	public $out_of_stock = false;

	/**
	 * @see ObjectModel::$definition
	 */
	public static $definition = array(
		'table' => 'stock_available',
		'primary' => 'id_stock_available',
		'fields' => array(
			'id_product' => 			array('type' => self::TYPE_INT, 'validate' => 'isUnsignedId', 'required' => true),
			'id_product_attribute' => 	array('type' => self::TYPE_INT, 'validate' => 'isUnsignedId', 'required' => true),
			'id_shop' => 				array('type' => self::TYPE_INT, 'validate' => 'isUnsignedId'),
			'id_shop_group' => 			array('type' => self::TYPE_INT, 'validate' => 'isUnsignedId'),
			'quantity' => 				array('type' => self::TYPE_INT, 'validate' => 'isInt', 'required' => true),
			'depends_on_stock' => 		array('type' => self::TYPE_BOOL, 'validate' => 'isBool', 'required' => true),
			'out_of_stock' => 			array('type' => self::TYPE_INT, 'validate' => 'isInt', 'required' => true),
		),
	);

	/**
	 * @see ObjectModel::$webserviceParameters
	 */
 	protected $webserviceParameters = array(
 		'fields' => array(
 			'id_product' => array('xlink_resource' => 'products'),
 			'id_product_attribute' => array('xlink_resource' => 'combinations'),
 			'id_shop' => array('xlink_resource' => 'shops'),
 			'id_shop_group' => array('xlink_resource' => 'shop_groups'),
 		),
 		'hidden_fields' => array(
 		),
		'objectMethods' => array(
			'add' => 'addWs',
			'update' => 'updateWs',
		),
 	);

	/**
	 * For a given {id_product, id_product_attribute and id_shop}, gets the stock available id associated
	 *
	 * @param int $id_product
	 * @param int $id_product_attribute Optional
	 * @param int $id_shop Optional
	 * @return int
	 */
	
	public function updateWs()
	{
		if ($this->depends_on_stock)
			return WebserviceRequest::getInstance()->setError(500, Tools::displayError('You cannot update the available stock when it depends on stock.'), 133);
		return $this->update();
	}
	
	public static function getStockAvailableIdByProductId($id_product, $id_product_attribute = null, $id_shop = null)
	{
		if (!Validate::isUnsignedId($id_product))
			return false;

		$query = new DbQuery();
		$query->select('id_stock_available');
		$query->from('stock_available');
		$query->where('id_product = '.(int)$id_product);

		if ($id_product_attribute !== null)
			$query->where('id_product_attribute = '.(int)$id_product_attribute);

		$query = StockAvailable::addSqlShopRestriction($query, $id_shop);
		return (int)Db::getInstance(_PS_USE_SQL_SLAVE_)->getValue($query);
	}

	/**
	 * For a given id_product, synchronizes StockAvailable::quantity with Stock::usable_quantity
	 *
	 * @param int $id_product
	 */
	public static function synchronize($id_product, $order_id_shop = null)
	{
		if (!Validate::isUnsignedId($id_product))
			return false;

		// gets warehouse ids grouped by shops
		$ids_warehouse = Warehouse::getWarehousesGroupedByShops();
		if ($order_id_shop !== null)
		{
			$order_warehouses = array();
			$wh = Warehouse::getWarehouses(false, (int)$order_id_shop);
			foreach ($wh as $warehouse)
				$order_warehouses[] = $warehouse['id_warehouse'];
		}
		
		// gets all product attributes ids
		$ids_product_attribute = array();
		foreach (Product::getProductAttributesIds($id_product) as $id_product_attribute)
			$ids_product_attribute[] = $id_product_attribute['id_product_attribute'];
		
		// Allow to order the product when out of stock?
		$out_of_stock = StockAvailable::outOfStock($id_product);

		$manager = StockManagerFactory::getManager();
		// loops on $ids_warehouse to synchronize quantities
		foreach ($ids_warehouse as $id_shop => $warehouses)
		{
			// first, checks if the product depends on stock for the given shop $id_shop
			if (StockAvailable::dependsOnStock($id_product, $id_shop))
			{
				// init quantity
				$product_quantity = 0;

				// if it's a simple product
				if (empty($ids_product_attribute))
				{
					$allowed_warehouse_for_product = WareHouse::getProductWarehouseList((int)$id_product, 0, (int)$id_shop);
					$allowed_warehouse_for_product_clean = array();
					foreach ($allowed_warehouse_for_product as $warehouse)
						$allowed_warehouse_for_product_clean[] = (int)$warehouse['id_warehouse'];
					$allowed_warehouse_for_product_clean = array_intersect($allowed_warehouse_for_product_clean, $warehouses);
					if ($order_id_shop != null && !count(array_intersect($allowed_warehouse_for_product_clean, $order_warehouses)))
						continue;

					$product_quantity = $manager->getProductRealQuantities($id_product, null, $allowed_warehouse_for_product_clean, true);
					
					Hook::exec('actionUpdateQuantity',
									array(
										'id_product' => $id_product,
										'id_product_attribute' => 0,
										'quantity' => $product_quantity
										)
					);
				}
				// else this product has attributes, hence loops on $ids_product_attribute
				else
				{
					foreach ($ids_product_attribute as $id_product_attribute)
					{

						$allowed_warehouse_for_combination = WareHouse::getProductWarehouseList((int)$id_product, (int)$id_product_attribute, (int)$id_shop);
						$allowed_warehouse_for_combination_clean = array();
						foreach ($allowed_warehouse_for_combination as $warehouse)
							$allowed_warehouse_for_combination_clean[] = (int)$warehouse['id_warehouse'];
						$allowed_warehouse_for_combination_clean = array_intersect($allowed_warehouse_for_combination_clean, $warehouses);
						if ($order_id_shop != null && !count(array_intersect($allowed_warehouse_for_combination_clean, $order_warehouses)))
							continue;

						$quantity = $manager->getProductRealQuantities($id_product, $id_product_attribute, $allowed_warehouse_for_combination_clean, true);
					
						$query = new DbQuery();
						$query->select('COUNT(*)');
						$query->from('stock_available');
						$query->where('id_product = '.(int)$id_product.' AND id_product_attribute = '.(int)$id_product_attribute.
							StockAvailable::addSqlShopRestriction(null, $id_shop));
					
						if ((int)Db::getInstance(_PS_USE_SQL_SLAVE_)->getValue($query))
						{
							$query = array(
								'table' => 'stock_available',
								'data' => array('quantity' => $quantity),
								'where' => 'id_product = '.(int)$id_product.' AND id_product_attribute = '.(int)$id_product_attribute.
								StockAvailable::addSqlShopRestriction(null, $id_shop)
							);
							Db::getInstance()->update($query['table'], $query['data'], $query['where']);
						}
						else
						{
							$query = array(
								'table' => 'stock_available',
								'data' => array(
									'quantity' => $quantity,
									'depends_on_stock' => 1,
									'out_of_stock' => $out_of_stock,
									'id_product' => (int)$id_product,
									'id_product_attribute' => (int)$id_product_attribute,
								)
							);
							StockAvailable::addSqlShopParams($query['data']);
							Db::getInstance()->insert($query['table'], $query['data']);
						}

						$product_quantity += $quantity;

						Hook::exec('actionUpdateQuantity',
									array(
										'id_product' => $id_product,
										'id_product_attribute' => $id_product_attribute,
										'quantity' => $quantity
									)
						);
					}
				}
				// updates
				// if $id_product has attributes, it also updates the sum for all attributes
				$query = array(
					'table' => 'stock_available',
					'data' => array('quantity' => $product_quantity),
					'where' => 'id_product = '.(int)$id_product.' AND id_product_attribute = 0'.
					StockAvailable::addSqlShopRestriction(null, $id_shop)
				);
				Db::getInstance()->update($query['table'], $query['data'], $query['where']);
			}
		}
		// In case there are no warehouses, removes product from StockAvailable
		if (count($ids_warehouse) == 0 && StockAvailable::dependsOnStock((int)$id_product))
			Db::getInstance()->update('stock_available', array('quantity' => 0 ), 'id_product = '.(int)$id_product);
			
		Cache::clean('StockAvailable::getQuantityAvailableByProduct_'.(int)$id_product.'*');
	}

	/**
	 * For a given id_product, sets if stock available depends on stock
	 *
	 * @param int $id_product
	 * @param int $depends_on_stock Optional : true by default
	 * @param int $id_shop Optional : gets context by default
	 */
	public static function setProductDependsOnStock($id_product, $depends_on_stock = true, $id_shop = null, $id_product_attribute = 0)
	{
		if (!Validate::isUnsignedId($id_product))
			return false;

		$existing_id = StockAvailable::getStockAvailableIdByProductId((int)$id_product, (int)$id_product_attribute, $id_shop);
		if ($existing_id > 0)
		{
			Db::getInstance()->update('stock_available', array(
				'depends_on_stock' => (int)$depends_on_stock
			), 'id_stock_available = '.(int)$existing_id);
		}
		else
		{
			$params = array(
				'depends_on_stock' => (int)$depends_on_stock,
				'id_product' => (int)$id_product,
				'id_product_attribute' => (int)$id_product_attribute
			);

			StockAvailable::addSqlShopParams($params, $id_shop);

			Db::getInstance()->insert('stock_available', $params);
		}

		// depends on stock.. hence synchronizes
		if ($depends_on_stock)
			StockAvailable::synchronize($id_product);
	}

	/**
	 * For a given id_product, sets if product is available out of stocks
	 *
	 * @param int $id_product
	 * @param int $out_of_stock Optional false by default
	 * @param int $id_shop Optional gets context by default
	 */
	public static function setProductOutOfStock($id_product, $out_of_stock = false, $id_shop = null, $id_product_attribute = 0)
	{
		if (!Validate::isUnsignedId($id_product))
			return false;

		$existing_id = StockAvailable::getStockAvailableIdByProductId((int)$id_product, (int)$id_product_attribute, $id_shop);
		if ($existing_id > 0)
		{
			Db::getInstance()->update(
				'stock_available',
				array('out_of_stock' => (int)$out_of_stock),
				'id_product = '.(int)$id_product.
				(($id_product_attribute) ? ' AND id_product_attribute = '.(int)$id_product_attribute : '').
				StockAvailable::addSqlShopRestriction(null, $id_shop)
			);
		}
		else
		{
			$params = array(
				'out_of_stock' => (int)$out_of_stock,
				'id_product' => (int)$id_product,
				'id_product_attribute' => (int)$id_product_attribute
			);

			StockAvailable::addSqlShopParams($params, $id_shop);
			Db::getInstance()->insert('stock_available', $params);
		}
	}

	/**
	 * For a given id_product and id_product_attribute, gets its stock available
	 *
	 * @param int $id_product
	 * @param int $id_product_attribute Optional
	 * @param int $id_shop Optional : gets context by default
	 * @return int Quantity
	 */
	public static function getQuantityAvailableByProduct($id_product = null, $id_product_attribute = null, $id_shop = null)
	{
		// if null, it's a product without attributes
		if ($id_product_attribute === null)
			$id_product_attribute = 0;

		$key = 'StockAvailable::getQuantityAvailableByProduct_'.(int)$id_product.'-'.(int)$id_product_attribute.'-'.(int)$id_shop;
		if (!Cache::isStored($key))
		{
			$query = new DbQuery();
			$query->select('SUM(quantity)');
			$query->from('stock_available');
	
			// if null, it's a product without attributes
			if ($id_product !== null)
				$query->where('id_product = '.(int)$id_product);
	
			$query->where('id_product_attribute = '.(int)$id_product_attribute);
			$query = StockAvailable::addSqlShopRestriction($query, $id_shop);
			Cache::store($key, (int)Db::getInstance(_PS_USE_SQL_SLAVE_)->getValue($query));
		}

		return Cache::retrieve($key);
	}

	/**
	 * Upgrades total_quantity_available after having saved
	 * @see ObjectModel::add()
	 */
	public function add($autodate = true, $null_values = false)
	{
		if (!$result = parent::add($autodate, $null_values))
			return false;

		$result &= $this->postSave();		
		return $result;
	}

	/**
	 * Upgrades total_quantity_available after having update
	 * @see ObjectModel::update()
	 */
	public function update($null_values = false)
	{
		if (!$result = parent::update($null_values))
			return false;

		$result &= $this->postSave();
		return $result;
	}

	/**
	 * Upgrades total_quantity_available after having saved
	 * @see StockAvailableCore::update()
	 * @see StockAvailableCore::add()
	 */
	public function postSave()
	{
		if ($this->id_product_attribute == 0)
			return true;

		$id_shop = (Shop::getContext() != Shop::CONTEXT_GROUP ? $this->id_shop : null);

		if (!Configuration::get('PS_DISP_UNAVAILABLE_ATTR'))
		{
			$combination = new Combination((int)$this->id_product_attribute);
			if ($colors = $combination->getColorsAttributes())
			{
				$product = new Product((int)$this->id_product);
				foreach ($colors as $color)
				{
					if ($product->isColorUnavailable((int)$color['id_attribute'], (int)$this->id_shop))
					{
						Tools::clearColorListCache($product->id);
						break;
					}
				}
			}
		}
		
		$total_quantity = (int)Db::getInstance(_PS_USE_SQL_SLAVE_)->getValue('
			SELECT SUM(quantity) as quantity
			FROM '._DB_PREFIX_.'stock_available
			WHERE id_product = '.(int)$this->id_product.'
			AND id_product_attribute <> 0 '.
			StockAvailable::addSqlShopRestriction(null, $id_shop)
		);

		$this->setQuantity($this->id_product, 0, $total_quantity, $id_shop);

		return true;
	}

	/**
	 * For a given id_product and id_product_attribute updates the quantity available
	 *
	 * @param int $id_product
	 * @param int $id_product_attribute Optional
	 * @param int $delta_quantity The delta quantity to update
	 * @param int $id_shop Optional
	 */
	public static function updateQuantity($id_product, $id_product_attribute, $delta_quantity, $id_shop = null)
	{
		if (!Validate::isUnsignedId($id_product))
			return false;

		$id_stock_available = StockAvailable::getStockAvailableIdByProductId($id_product, $id_product_attribute, $id_shop);

		if (!$id_stock_available)
			return false;

		// Update quantity of the pack products
		if (Pack::isPack($id_product))
		{
			$products_pack = Pack::getItems($id_product, (int)Configuration::get('PS_LANG_DEFAULT'));
			foreach ($products_pack as $product_pack)
			{
				$pack_id_product_attribute = Product::getDefaultAttribute($product_pack->id, 1);
				StockAvailable::updateQuantity($product_pack->id, $pack_id_product_attribute, $product_pack->pack_quantity * $delta_quantity, $id_shop);
			}
		}

		$stock_available = new StockAvailable($id_stock_available);
		$stock_available->quantity = $stock_available->quantity + $delta_quantity;
		$stock_available->update();

		Hook::exec('actionUpdateQuantity',
				   array(
				   	'id_product' => $id_product,
				   	'id_product_attribute' => $id_product_attribute,
				   	'quantity' => $stock_available->quantity
				   )
				  );

		Cache::clean('StockAvailable::getQuantityAvailableByProduct_'.(int)$id_product.'*');

		return true;
	}


	/**
	 * For a given id_product and id_product_attribute sets the quantity available
	 *
	 * @param int $id_product
	 * @param int $id_product_attribute Optional
	 * @param int $delta_quantity The delta quantity to update
	 * @param int $id_shop Optional
	 */
	public static function setQuantity($id_product, $id_product_attribute, $quantity, $id_shop = null)
	{
		if (!Validate::isUnsignedId($id_product))
			return false;

		$context = Context::getContext();

		// if there is no $id_shop, gets the context one
		if ($id_shop === null && Shop::getContext() != Shop::CONTEXT_GROUP)
			$id_shop = (int)$context->shop->id;

		$depends_on_stock = StockAvailable::dependsOnStock($id_product);

		//Try to set available quantity if product does not depend on physical stock
		if (!$depends_on_stock)
		{
			$id_stock_available = (int)StockAvailable::getStockAvailableIdByProductId($id_product, $id_product_attribute, $id_shop);
			if ($id_stock_available)
			{
				$stock_available = new StockAvailable($id_stock_available);
				$stock_available->quantity = (int)$quantity;
				$stock_available->update();
			}
			else
			{
				$out_of_stock = StockAvailable::outOfStock($id_product, $id_shop);
				$stock_available = new StockAvailable();
				$stock_available->out_of_stock = (int)$out_of_stock;
				$stock_available->id_product = (int)$id_product;
				$stock_available->id_product_attribute = (int)$id_product_attribute;
				$stock_available->quantity = (int)$quantity;

				if ($id_shop === null)
					$shop_group = Shop::getContextShopGroup();
				else
					$shop_group = new ShopGroup((int)Shop::getGroupFromShop((int)$id_shop));
		
				// if quantities are shared between shops of the group
				if ($shop_group->share_stock)
				{
					$stock_available->id_shop = 0;
					$stock_available->id_shop_group = (int)$shop_group->id;
				}
				else
				{
					$stock_available->id_shop = (int)$id_shop;
					$stock_available->id_shop_group = 0;
				}
				$stock_available->add();
			}

			Hook::exec('actionUpdateQuantity',
				   array(
				   	'id_product' => $id_product,
				   	'id_product_attribute' => $id_product_attribute,
				   	'quantity' => $stock_available->quantity
				   )
				  );
		}

		Cache::clean('StockAvailable::getQuantityAvailableByProduct_'.(int)$id_product.'*');

	}

	/**
	 * Removes a given product from the stock available
	 *
	 * @param int $id_product
	 * @param int $id_product_attribute Optional
	 * @param mixed $id_shop shop id or shop object Optional
	 */
	public static function removeProductFromStockAvailable($id_product, $id_product_attribute = null, $shop = null)
	{
		if (!Validate::isUnsignedId($id_product))
			return false;

		if (Shop::getContext() == SHOP::CONTEXT_SHOP)
			if (Shop::getContextShopGroup()->share_stock == 1)
			{
				$pa_sql = '';
				if ($id_product_attribute !== null)
				{
					$pa_sql = '_attribute';
					$id_product_attribute_sql = $id_product_attribute;
				}
				else
					$id_product_attribute_sql = $id_product;
					
				if ((int)Db::getInstance()->getValue('SELECT COUNT(*)
						FROM '._DB_PREFIX_.'product'.$pa_sql.'_shop
						WHERE id_product'.$pa_sql.'='.(int)$id_product_attribute_sql.' 
							AND id_shop IN ('.implode(',', array_map('intval', Shop::getContextListShopID(SHOP::SHARE_STOCK))).')'))
						return true;
			}

		$res =  Db::getInstance()->execute('
		DELETE FROM '._DB_PREFIX_.'stock_available
		WHERE id_product = '.(int)$id_product.
		($id_product_attribute ? ' AND id_product_attribute = '.(int)$id_product_attribute : '').
		StockAvailable::addSqlShopRestriction(null, $shop));
		
		if ($id_product_attribute)
		{
			if ($shop === null || !Validate::isLoadedObject($shop))
			{
				$shop_datas = array();
				StockAvailable::addSqlShopParams($shop_datas);
				$id_shop = (int)$shop_datas['id_shop'];
			}
			else
				$id_shop = (int)$shop->id;

			$stock_available = new StockAvailable();
			$stock_available->id_product = (int)$id_product;
			$stock_available->id_product_attribute = (int)$id_product;
			$stock_available->id_shop = (int)$id_shop;
			$stock_available->postSave();
		}

		Cache::clean('StockAvailable::getQuantityAvailableByProduct_'.(int)$id_product.'*');

		return $res;
	}

	/**
	 * Removes all product quantities from all a group of shops
	 * If stocks are shared, remoe all old available quantities for all shops of the group
	 * Else remove all available quantities for the current group
	 *
	 * @param ShopGroup $shop_group the ShopGroup object
	 */
	public static function resetProductFromStockAvailableByShopGroup(ShopGroup $shop_group)
	{
		if ($shop_group->share_stock)
		{
			$shop_list = Shop::getShops(false, $shop_group->id, true);

			if (count($shop_list) > 0)
			{
				$id_shops_list = implode(', ', $shop_list);

				return Db::getInstance()->execute('
					DELETE FROM '._DB_PREFIX_.'stock_available
					WHERE id_shop IN ('.$id_shops_list.')'
				);
			}
		}
		else
		{
			return Db::getInstance()->execute('
				DELETE FROM '._DB_PREFIX_.'stock_available
				WHERE id_shop_group = '.$shop_group->id
			);
		}
	}

	/**
	 * For a given product, tells if it depends on the physical (usable) stock
	 *
	 * @param int $id_product
	 * @param int $id_shop Optional : gets context if null @see Context::getContext()
	 * @return bool : depends on stock @see $depends_on_stock
	 */
	public static function dependsOnStock($id_product, $id_shop = null)
	{
		if (!Validate::isUnsignedId($id_product))
			return false;

		$query = new DbQuery();
		$query->select('depends_on_stock');
		$query->from('stock_available');
		$query->where('id_product = '.(int)$id_product);
		$query->where('id_product_attribute = 0');

		$query = StockAvailable::addSqlShopRestriction($query, $id_shop);

		return (bool)Db::getInstance(_PS_USE_SQL_SLAVE_)->getValue($query);
	}

	/**
	 * For a given product, get its "out of stock" flag
	 *
	 * @param int $id_product
	 * @param int $id_shop Optional : gets context if null @see Context::getContext()
	 * @return bool : depends on stock @see $depends_on_stock
	 */
	public static function outOfStock($id_product, $id_shop = null)
	{
		if (!Validate::isUnsignedId($id_product))
			return false;

		$query = new DbQuery();
		$query->select('out_of_stock');
		$query->from('stock_available');
		$query->where('id_product = '.(int)$id_product);
		$query->where('id_product_attribute = 0');

		$query = StockAvailable::addSqlShopRestriction($query, $id_shop);

		return (int)Db::getInstance(_PS_USE_SQL_SLAVE_)->getValue($query);
	}

	/**
	 * Add an sql restriction for shops fields - specific to StockAvailable
	 *
	 * @param DbQuery $query Reference to the query object
	 * @param int $id_shop Optional : The shop ID
	 * @param string $alias Optional : The current table alias
	 *
	 * @return mixed the DbQuery object or the sql restriction string
	 */
	public static function addSqlShopRestriction(DbQuery $sql = null, $shop = null, $alias = null)
	{
		$context = Context::getContext();

		if (!empty($alias))
			$alias .= '.';

		// if there is no $id_shop, gets the context one
		// get shop group too
		if ($shop === null || $shop === $context->shop->id)
		{
			if (Shop::getContext() == Shop::CONTEXT_GROUP)
				$shop_group = Shop::getContextShopGroup();
			else
				$shop_group = $context->shop->getGroup();
			$shop = $context->shop;
		}
		elseif (is_object($shop))
			$shop_group = $shop->getGroup();
		else
		{
			$shop = new Shop($shop);
			$shop_group = $shop->getGroup();
		}

		// if quantities are shared between shops of the group
		if ($shop_group->share_stock)
		{
			if (is_object($sql))
			{
				$sql->where(pSQL($alias).'id_shop_group = '.(int)$shop_group->id);
				$sql->where(pSQL($alias).'id_shop = 0');
			}
			else
			{
				$sql = ' AND '.pSQL($alias).'id_shop_group = '.(int)$shop_group->id.' ';
				$sql .= ' AND '.pSQL($alias).'id_shop = 0 ';
			}
		}
		else
		{
			if (is_object($sql))
			{
				$sql->where(pSQL($alias).'id_shop = '.(int)$shop->id);
				$sql->where(pSQL($alias).'id_shop_group = 0');
			}
			else
			{
				$sql = ' AND '.pSQL($alias).'id_shop = '.(int)$shop->id.' ';
				$sql .= ' AND '.pSQL($alias).'id_shop_group = 0 ';
			}
		}

		return $sql;
	}

	/**
	 * Add sql params for shops fields - specific to StockAvailable
	 *
	 * @param array $params Reference to the params array
	 * @param int $id_shop Optional : The shop ID
	 *
	 */
	public static function addSqlShopParams(&$params, $id_shop = null)
	{
		$context = Context::getContext();
		$group_ok = false;

		// if there is no $id_shop, gets the context one
		// get shop group too
		if ($id_shop === null)
		{
			if (Shop::getContext() == Shop::CONTEXT_GROUP)
				$shop_group = Shop::getContextShopGroup();
			else
			{
				$shop_group = $context->shop->getGroup();
				$id_shop = $context->shop->id;
			}
		}
		else
		{
			$shop = new Shop($id_shop);
			$shop_group = $shop->getGroup();
		}

		// if quantities are shared between shops of the group
		if ($shop_group->share_stock)
		{
			$params['id_shop_group'] = (int)$shop_group->id;
			$params['id_shop'] = 0;

			$group_ok = true;
		}
		else
			$params['id_shop_group'] = 0;

		// if no group specific restriction, set simple shop restriction
		if (!$group_ok)
			$params['id_shop'] = (int)$id_shop;
	}

	/**
	 * Copies stock available content table
	 *
	 * @param int $src_shop_id
	 * @param int $dst_shop_id
	 * @return bool
	 */
	public static function copyStockAvailableFromShopToShop($src_shop_id, $dst_shop_id)
	{
		if (!$src_shop_id || !$dst_shop_id)
			return false;

		$query = '
			INSERT INTO '._DB_PREFIX_.'stock_available
			(
				id_product,
				id_product_attribute,
				id_shop,
				id_shop_group,
				quantity,
				depends_on_stock,
				out_of_stock
			)
			(
				SELECT id_product, id_product_attribute, '.(int)$dst_shop_id.', 0, quantity, depends_on_stock, out_of_stock
				FROM '._DB_PREFIX_.'stock_available
				WHERE id_shop = '.(int)$src_shop_id.
			')';

		return Db::getInstance()->execute($query);
	}
}