PageRenderTime 42ms CodeModel.GetById 14ms RepoModel.GetById 0ms app.codeStats 1ms

/administrator/components/com_virtuemart/classes/ps_checkout.php

https://bitbucket.org/dgough/annamaria-daneswood-25102012
PHP | 2545 lines | 1679 code | 381 blank | 485 comment | 361 complexity | f85fbf354a3c8b6a921b904dbf3d7aeb MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1 
    

  1. <?php
    2. 

  2. if( !defined( '_VALID_MOS' ) && !defined( '_JEXEC' ) ) die( 'Direct Access to '.basename(__FILE__).' is not allowed.' );
    3. 

  3. /**
    4. 

  4. *
    5. 

  5. * @version $Id: ps_checkout.php 1451 2008-07-04 19:55:31Z soeren_nb $
    6. 

  6. * @package VirtueMart
    7. 

  7. * @subpackage classes
    8. 

  8. * @copyright Copyright (C) 2004-2008 soeren - All rights reserved.
    9. 

  9. * @license http://www.gnu.org/copyleft/gpl.html GNU/GPL, see LICENSE.php
    10. 

  10. * VirtueMart is free software. This version may have been modified pursuant
    11. 

  11. * to the GNU General Public License, and as distributed it includes or
    12. 

  12. * is derivative of works licensed under the GNU General Public License or
    13. 

  13. * other free or open source software licenses.
    14. 

  14. * See /administrator/components/com_virtuemart/COPYRIGHT.php for copyright notices and details.
    15. 

  15. *
    16. 

  16. * http://virtuemart.net
    17. 

  17. */ 
    18. 

  18. 

  19. define("CHECK_OUT_GET_FINAL_BASKET", 1);
    20. 

  20. define("CHECK_OUT_GET_SHIPPING_ADDR", 2);
    21. 

  21. define("CHECK_OUT_GET_SHIPPING_METHOD", 3);
    22. 

  22. define("CHECK_OUT_GET_PAYMENT_METHOD", 4);
    23. 

  23. define("CHECK_OUT_GET_FINAL_CONFIRMATION", 99);
    24. 

  24. 

  25. /**
    26. 

  26.  * The class contains the shop checkout code.  It is used to checkout
    27. 

  27.  * and order and collect payment information.
    28. 

  28.  *
    29. 

  29.  */
    30. 

  30. class ps_checkout {
    31. 

  31. 	var $_SHIPPING = null;
    32. 

  32. 

  33. 	var $_subtotal = null;
    34. 

  34. 	var $_shipping = null;
    35. 

  35. 	var $_shipping_tax = null;
    36. 

  36. 	var $_payment_discount = null;
    37. 

  37. 	var $_coupon_discount = null;
    38. 

  38. 	var $_order_total = null;
    39. 

  39. 	/** @var string An md5 hash of print_r( $cart, true ) to check wether the checkout values have to be renewed */
    40. 

  40. 	var $_cartHash;
    41. 

  41. 

  42. 	/**
    43. 

  43. 	 * Initiate Shipping Modules
    44. 

  44. 	 */
    45. 

  45. 	function ps_checkout() {
    46. 

  46. 		global $vendor_freeshipping, $vars, $PSHOP_SHIPPING_MODULES;
    47. 

  47. 

  48. 		// Make a snapshot of the current checkout configuration
    49. 

  49. 		$this->generate_cart_hash();
    50. 

  50. 

  51. 		/* Ok, need to decide if we have a free Shipping amount > 0,
    52. 

  52. 		* and IF the cart total is more than that Free Shipping amount,
    53. 

  53. 		* let's set Order Shipping = 0
    54. 

  54. 		*/
    55. 

  55. 

  56. 		$this->_subtotal = $this->get_order_subtotal($vars);
    57. 

  57. 		
    58. 

  58. 		if( $vendor_freeshipping > 0 && $vars['order_subtotal_withtax'] >= $vendor_freeshipping) {
    59. 

  59. 			$PSHOP_SHIPPING_MODULES = Array( "free_shipping" );
    60. 

  60. 			include_once( CLASSPATH. "shipping/free_shipping.php" );
    61. 

  61. 			$this->_SHIPPING = new free_shipping();
    62. 

  62. 		}
    63. 

  63. 		elseif( !empty( $_REQUEST['shipping_rate_id'] )) {
    64. 

  64. 

  65. 			// Create a Shipping Object and assign it to the _SHIPPING attribute
    66. 

  66. 			// We take the first Part of the Shipping Rate Id String
    67. 

  67. 			// which holds the Class Name of the Shipping Module
    68. 

  68. 			$rate_array = explode( "|", urldecode(vmGet($_REQUEST,"shipping_rate_id")) );
    69. 

  69. 			$filename = basename( $rate_array[0] );
    70. 

  70. 			if( $filename != '' && file_exists(CLASSPATH. "shipping/".$filename.".php")) {
    71. 

  71. 				include_once( CLASSPATH. "shipping/".$filename.".php" );
    72. 

  72. 				if( class_exists($filename) ) {
    73. 

  73. 					$this->_SHIPPING =& new $filename();
    74. 

  74. 				}
    75. 

  75. 			}
    76. 

  76. 		}
    77. 

  77. 		//$steps = ps_checkout::get_checkout_steps();
    78. 

  78. 		if(empty($_REQUEST['ship_to_info_id']) && ps_checkout::noShipToNecessary()) {
    79. 

  79. 

  80. 			$db = new ps_DB();
    81. 

  81. 

  82. 			/* Select all the ship to information for this user id and
    83. 

  83. 			* order by modification date; most recently changed to oldest
    84. 

  84. 			*/
    85. 

  85. 			$q  = "SELECT user_info_id from `#__{vm}_user_info` WHERE ";
    86. 

  86. 			$q .= "user_id='" . $_SESSION['auth']["user_id"] . "' ";
    87. 

  87. 			$q .= "AND address_type='BT'";
    88. 

  88. 			$db->query($q);
    89. 

  89. 			$db->next_record();
    90. 

  90. 

  91. 			$_REQUEST['ship_to_info_id'] = $db->f("user_info_id");
    92. 

  92. 		}
    93. 

  93. 	}
    94. 

  94. 	/**
    95. 

  95. 	 * Checks if Ship To can be skipped
    96. 

  96. 	 *
    97. 

  97. 	 * @return boolean
    98. 

  98. 	 */
    99. 

  99. 	function noShipToNecessary() {
    100. 

  100. 		global $cart, $only_downloadable_products;
    101. 

  101. 		if( NO_SHIPTO == '1') {
    102. 

  102. 			return true;
    103. 

  103. 		}
    104. 

  104. 		if( !isset( $cart)) $cart = ps_cart::initCart();
    105. 

  105. 	
    106. 

  106. 		if( ENABLE_DOWNLOADS == '1') {
    107. 

  107. 			$not_downloadable = false;
    108. 

  108. 			require_once( CLASSPATH .'ps_product.php');
    109. 

  109. 			for($i = 0; $i < $cart["idx"]; $i++) {
    110. 

  110. 				
    111. 

  111. 				if( !ps_product::is_downloadable($cart[$i]['product_id']) ) {					
    112. 

  112. 					$not_downloadable = true;
    113. 

  113. 					break;
    114. 

  114. 				}
    115. 

  115. 			}
    116. 

  116. 			return !$not_downloadable;
    117. 

  117. 		}
    118. 

  118. 		return false;
    119. 

  119. 	}
    120. 

  120. 	function noShippingMethodNecessary() {
    121. 

  121. 		global $cart, $only_downloadable_products;
    122. 

  122. 		if( NO_SHIPPING == '1') {
    123. 

  123. 			return true;
    124. 

  124. 		}
    125. 

  125. 		
    126. 

  126. 		if( !isset( $cart)) $cart = ps_cart::initCart();
    127. 

  127. 		
    128. 

  128. 		if( ENABLE_DOWNLOADS == '1') {
    129. 

  129. 			$not_downloadable = false;
    130. 

  130. 			require_once( CLASSPATH .'ps_product.php');
    131. 

  131. 			for($i = 0; $i < $cart["idx"]; $i++) {
    132. 

  132. 				if( !ps_product::is_downloadable($cart[$i]['product_id']) ) {
    133. 

  133. 					$not_downloadable = true;
    134. 

  134. 					break;
    135. 

  135. 				}
    136. 

  136. 			}
    137. 

  137. 			return !$not_downloadable;
    138. 

  138. 		}
    139. 

  139. 		return false;
    140. 

  140. 	}
    141. 

  141. 	function noShippingNecessary() {
    142. 

  142. 		return $this->noShipToNecessary() && $this->noShippingMethodNecessary();
    143. 

  143. 	}
    144. 

  144. 	/**
    145. 

  145. 	 * Retrieve an array with all order steps and their details
    146. 

  146. 	 *
    147. 

  147. 	 * @return array
    148. 

  148. 	 */
    149. 

  149. 	function get_checkout_steps() {
    150. 

  150. 		global $VM_CHECKOUT_MODULES;
    151. 

  151. 		$stepnames = array_keys( $VM_CHECKOUT_MODULES );
    152. 

  152. 		$steps = array();
    153. 

  153. 		$i = 0;
    154. 

  154. 		$last_order = 0;
    155. 

  155. 		foreach( $VM_CHECKOUT_MODULES as $step ) {
    156. 

  156. 			// Get the stepname from the array key
    157. 

  157. 			$stepname = current($stepnames);
    158. 

  158. 			next($stepnames);
    159. 

  159. 			
    160. 

  160. 			switch( $stepname ) {
    161. 

  161. 				case 'CHECK_OUT_GET_SHIPPING_ADDR':
    162. 

  162. 					if( ps_checkout::noShipToNecessary() ) $step['enabled'] = 0;
    163. 

  163. 					break;
    164. 

  164. 				case 'CHECK_OUT_GET_SHIPPING_METHOD':
    165. 

  165. 					if( ps_checkout::noShippingMethodNecessary() ) $step['enabled'] = 0;
    166. 

  166. 					break;
    167. 

  167. 			}
    168. 

  168. 			
    169. 

  169. 			
    170. 

  170. 			if( $step['enabled'] == 1 ) {
    171. 

  171. 				$steps[$step['order']][] = $stepname;
    172. 

  172. 			}
    173. 

  173. 			
    174. 

  174. 		}
    175. 

  175. 		ksort( $steps );
    176. 

  176. 		
    177. 

  177. 		return $steps;
    178. 

  178. 	}
    179. 

  179. 	/**
    180. 

  180. 	 * Retrieve the key name of the current checkout step
    181. 

  181. 	 *
    182. 

  182. 	 * @return string
    183. 

  183. 	 */
    184. 

  184. 	function get_current_stage() {
    185. 

  185. 		$steps = ps_checkout::get_checkout_steps();
    186. 

  186. 		$stage = key( $steps ); // $steps is sorted by key, so the first key is the first stage
    187. 

  187. 		// First check the REQUEST parameters for other steps
    188. 

  188. 		if( !empty( $_REQUEST['checkout_last_step'] ) && empty( $_POST['checkout_this_step'] )) {
    189. 

  189. 			// Make sure we have an integer (max 4)
    190. 

  190. 			$checkout_step = abs( min( $_REQUEST['checkout_last_step'], 4 ) );
    191. 

  191. 			if( isset( $steps[$checkout_step] )) {
    192. 

  192. 				return $checkout_step; // it's a valid step
    193. 

  193. 			}
    194. 

  194. 		}
    195. 

  195. 		$checkout_step = (int)vmGet( $_REQUEST, 'checkout_stage' );
    196. 

  196. 		if( isset( $steps[$checkout_step] )) {
    197. 

  197. 			return $checkout_step; // it's a valid step
    198. 

  198. 		}
    199. 

  199. 		// Else: we have no alternative steps given by REQUEST
    200. 

  200. 		while ($step = current($steps)) {
    201. 

  201. 			if( !empty($_POST['checkout_this_step']) )  {
    202. 

  202. 				foreach( $step as $stepname ) {
    203. 

  203. 					if( in_array( $stepname, $_POST['checkout_this_step'])) {
    204. 

  204. 						next($steps);
    205. 

  205. 						$key = key( $steps );
    206. 

  206. 						if( empty( $key )) {
    207. 

  207. 							// We are beyond the last index of the array and need to go "back" to the last index
    208. 

  208. 							end( $steps );
    209. 

  209. 						}
    210. 

  210. 						//echo "Stage: ".key( $steps );
    211. 

  211. 						return key($steps);
    212. 

  212. 						
    213. 

  213. 					}
    214. 

  214. 				}
    215. 

  215. 			}
    216. 

  216. 			next($steps);
    217. 

  217. 		}
    218. 

  218. 		return $stage;
    219. 

  219. 	}
    220. 

  220. 	/**
    221. 

  221. 	 * Displays the "checkout bar" using the checkout bar template
    222. 

  222. 	 *
    223. 

  223. 	 * @param array $steps_to_do Array holding all steps the customer has to make
    224. 

  224. 	 * @param array $step_msg Array containing the step messages
    225. 

  225. 	 * @param int $step_count Number of steps to make
    226. 

  226. 	 * @param int $highlighted_step The index of the recent step
    227. 

  227. 	 */
    228. 

  228. 	function show_checkout_bar() {
    229. 

  229. 

  230. 		global $sess, $ship_to_info_id, $shipping_rate_id, $VM_LANG;
    231. 

  231. 		
    232. 

  232. 		if (SHOW_CHECKOUT_BAR != '1' || defined('VM_CHECKOUT_BAR_LOADED')) {
    233. 

  233. 			return;
    234. 

  234. 		}
    235. 

  235. 	    // Let's assemble the steps
    236. 

  236. 	    $steps = ps_checkout::get_checkout_steps();
    237. 

  237. 	    $step_count = sizeof( $steps );
    238. 

  238. 	    $steps_tmp = $steps;
    239. 

  239. 	    $i = 0;
    240. 

  240. 	    foreach( $steps as $step ) {	    	
    241. 

  241. 	    	foreach( $step as $step_name ) {
    242. 

  242. 	    		switch ( $step_name ) {
    243. 

  243. 	    			case 'CHECK_OUT_GET_SHIPPING_ADDR':
    244. 

  244. 	    				$step_msg = $VM_LANG->_('PHPSHOP_ADD_SHIPTO_2');
    245. 

  245. 	    				break;
    246. 

  246. 	    			case 'CHECK_OUT_GET_SHIPPING_METHOD':
    247. 

  247. 	    				$step_msg = $VM_LANG->_('PHPSHOP_ISSHIP_LIST_CARRIER_LBL');
    248. 

  248. 	    				break;
    249. 

  249. 	    			case 'CHECK_OUT_GET_PAYMENT_METHOD':
    250. 

  250. 	    				$step_msg = $VM_LANG->_('PHPSHOP_ORDER_PRINT_PAYMENT_LBL');
    251. 

  251. 	    				break;
    252. 

  252. 	    			case 'CHECK_OUT_GET_FINAL_CONFIRMATION':
    253. 

  253. 	    				$step_msg = $VM_LANG->_('PHPSHOP_CHECKOUT_CONF_PAYINFO_COMPORDER');
    254. 

  254. 	    				break;
    255. 

  255. 	    		}
    256. 

  256. 	    		$steps_to_do[$i][] = array('step_name' => $step_name,
    257. 

  257. 	    								'step_msg' => $step_msg,
    258. 

  258. 	    								'step_order' => key($steps_tmp) );
    259. 

  259. 			
    260. 

  260. 	    	}
    261. 

  261.     		next( $steps_tmp );
    262. 

  262. 	    	$i++;
    263. 

  263. 	    }
    264. 

  264. 	      
    265. 

  265.       	$highlighted_step = ps_checkout::get_current_stage(); 
    266. 

  266.     	
    267. 

  267.     	$theme = new $GLOBALS['VM_THEMECLASS']();
    268. 

  268.     	$theme->set_vars( array( 'step_count' => $step_count,
    269. 

  269.     							'steps_to_do' => $steps_to_do,
    270. 

  270.     							'steps' => $steps,
    271. 

  271.     							'highlighted_step' => $highlighted_step,
    272. 

  272.     							'ship_to_info_id' => vmGet($_REQUEST, 'ship_to_info_id'),
    273. 

  273.     							'shipping_rate_id' => vmGet( $_REQUEST, 'shipping_rate_id')
    274. 

  274.     						) );
    275. 

  275.     						
    276. 

  276. 		echo $theme->fetch( 'checkout/checkout_bar.tpl.php');
    277. 

  277. 		define('VM_CHECKOUT_BAR_LOADED', 1 );
    278. 

  278. 	}
    279. 

  279. 

  280. 	/**
    281. 

  281. 	 * Called to validate the form values before the order is stored
    282. 

  282. 	 * 
    283. 

  283. 	 * @author gday
    284. 

  284. 	 * @author soeren
    285. 

  285. 	 * 
    286. 

  286. 	 * @param array $d
    287. 

  287. 	 * @return boolean
    288. 

  288. 	 */
    289. 

  289. 	function validate_form(&$d) {
    290. 

  290. 		global $VM_LANG, $PSHOP_SHIPPING_MODULES, $vmLogger;
    291. 

  291. 

  292. 		$db = new ps_DB;
    293. 

  293. 

  294. 		$auth = $_SESSION['auth'];
    295. 

  295. 		$cart = $_SESSION['cart'];
    296. 

  296. 

  297. 		if (!$cart["idx"]) {
    298. 

  298. 			$q  = "SELECT order_id FROM #__{vm}_orders WHERE user_id='" . $auth["user_id"] . "' ";
    299. 

  299. 			$q .= "ORDER BY cdate DESC";
    300. 

  300. 			$db->query($q);
    301. 

  301. 			$db->next_record();
    302. 

  302. 			$d["order_id"] = $db->f("order_id");
    303. 

  303. 			return False;
    304. 

  304. 		}
    305. 

  305. 		if( PSHOP_AGREE_TO_TOS_ONORDER == '1' ) {
    306. 

  306. 			if( empty( $d["agreed"] )) {
    307. 

  307. 				$vmLogger->warning( $VM_LANG->_('PHPSHOP_AGREE_TO_TOS',false) );
    308. 

  308. 				return false;
    309. 

  309. 			}
    310. 

  310. 		}
    311. 

  311. 

  312. 		if ( !ps_checkout::noShippingMethodNecessary() ) {
    313. 

  313. 			if ( !$this->validate_shipping_method($d) ) {
    314. 

  314. 				return False;
    315. 

  315. 			}
    316. 

  316. 		}
    317. 

  317. 		if ( !$this->validate_payment_method( $d, false )) {
    318. 

  318. 			return false;
    319. 

  319. 		}
    320. 

  320. 		if( CHECK_STOCK == '1' ) {
    321. 

  321. 			for($i = 0; $i < $cart["idx"]; $i++) {
    322. 

  322. 

  323. 				$quantity_in_stock = ps_product::get_field($cart[$i]["product_id"], 'product_in_stock');
    324. 

  324. 				$product_name = ps_product::get_field($cart[$i]["product_id"], 'product_name');
    325. 

  325. 				if( $cart[$i]["quantity"] > $quantity_in_stock ) {
    326. 

  326. 					$vmLogger->err( 'The Quantity for the Product "'.$product_name.'" in your Cart ('.$cart[$i]["quantity"].') exceeds the Quantity in Stock ('.$quantity_in_stock.'). 
    327. 

  327. 												We are very sorry for this Inconvenience, but you you need to lower the Quantity in Cart for this Product.');
    328. 

  328. 					return false;
    329. 

  329. 				}
    330. 

  330. 			}
    331. 

  331. 		}
    332. 

  332. 

  333. 		return True;
    334. 

  334. 	}
    335. 

  335. 

  336. 	/**
    337. 

  337. 	 * Validates the variables prior to adding an order
    338. 

  338. 	 *
    339. 

  339. 	 * @param array $d
    340. 

  340. 	 * @return boolean
    341. 

  341. 	 */
    342. 

  342. 	function validate_add(&$d) {
    343. 

  343. 		global $auth, $VM_LANG, $vmLogger;
    344. 

  344. 

  345. 		require_once(CLASSPATH.'ps_payment_method.php');
    346. 

  346. 		$ps_payment_method = new ps_payment_method;
    347. 

  347. 		
    348. 

  348. 		if( empty( $auth['user_id'] ) ) {
    349. 

  349. 			$vmLogger->err('Sorry, but it is not possible to order without a User ID. 
    350. 

  350. 										Please contact the Store Administrator if this Error occurs again.');
    351. 

  351. 			return false;
    352. 

  352. 		}
    353. 

  353. 		if (!ps_checkout::noShipToNecessary()) {
    354. 

  354. 			if (empty($d["ship_to_info_id"])) {
    355. 

  355. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_SHIPTO',false) );
    356. 

  356. 				return False;
    357. 

  357. 			}
    358. 

  358. 		}
    359. 

  359. 		/*
    360. 

  360. 		if (!$d["payment_method_id"]) {
    361. 

  361. 			$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_MSG_4',false) );
    362. 

  362. 			return False;
    363. 

  363. 		}*/
    364. 

  364. 		if ($ps_payment_method->is_creditcard(@$d["payment_method_id"])) {
    365. 

  365. 

  366. 			if (empty($_SESSION["ccdata"]["order_payment_number"])) {
    367. 

  367. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_CCNR',false) );
    368. 

  368. 				return False;
    369. 

  369. 			}
    370. 

  370. 

  371. 			if(!$ps_payment_method->validate_payment($d["payment_method_id"],
    372. 

  372. 					$_SESSION["ccdata"]["order_payment_number"])) {
    373. 

  373. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_CCNUM_INV',false) );
    374. 

  374. 				return False;
    375. 

  375. 			}
    376. 

  376. 

  377. 			if(empty($_SESSION['ccdata']['order_payment_expire'])) {
    378. 

  378. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_CCDATE_INV',false) );
    379. 

  379. 				return False;
    380. 

  380. 			}
    381. 

  381. 		}
    382. 

  382. 

  383. 		return True;
    384. 

  384. 	}
    385. 

  385. 

  386. 	function validate_shipto(&$d) {
    387. 

  387. 		//TODO to be implemented
    388. 

  388. 	}
    389. 

  389. 	/**
    390. 

  390. 	 * Called to validate the shipping_method
    391. 

  391. 	 *
    392. 

  392. 	 * @param array $d
    393. 

  393. 	 * @return boolean
    394. 

  394. 	 */
    395. 

  395. 	function validate_shipping_method(&$d) {
    396. 

  396. 		global $VM_LANG, $PSHOP_SHIPPING_MODULES, $vmLogger;
    397. 

  397. 		
    398. 

  398. 		if( empty($d['shipping_rate_id']) ) {
    399. 

  399. 			$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_SHIP',false) );
    400. 

  400. 			return false;
    401. 

  401. 		}
    402. 

  402. 		
    403. 

  403. 		if( is_callable( array($this->_SHIPPING, 'validate') )) {
    404. 

  404. 			
    405. 

  405. 			if(!$this->_SHIPPING->validate( $d )) {
    406. 

  406. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_OTHER_SHIP',false) );
    407. 

  407. 				return false;
    408. 

  408. 			}
    409. 

  409. 		}
    410. 

  410. 		return true;
    411. 

  411. 	}
    412. 

  412. 

  413. 	/**
    414. 

  414. 	 * Called to validate the payment_method
    415. 

  415. 	 * If payment with CreditCard is used, than the Data must be in stored in the session
    416. 

  416. 	 * This has be done to prevent sending the CreditCard Number back in hidden fields
    417. 

  417. 	 * If the parameter $is_test is true the Number Visa Creditcard number 4111 1111 1111 1111
    418. 

  418. 	 *
    419. 

  419. 	 * @param array $d
    420. 

  420. 	 * @param boolean $is_test
    421. 

  421. 	 * @return boolean
    422. 

  422. 	 */
    423. 

  423. 	function validate_payment_method(&$d, $is_test) {
    424. 

  424. 		global $VM_LANG, $vmLogger, $order_total;
    425. 

  425. 

  426. 		$auth = $_SESSION['auth'];
    427. 

  427. 		$cart = $_SESSION['cart'];
    428. 

  428. 		
    429. 

  429. 		// We don't need to validate a payment method when
    430. 

  430. 		// the user has no order total he should pay
    431. 

  431. 		if( empty( $_REQUEST['order_total'])) {
    432. 

  432. 			
    433. 

  433. 			if( isset( $d['order_total'])) {
    434. 

  434. 				if( round( $d['order_total'], 2 ) <= 0.00 ) {
    435. 

  435. 					return true;
    436. 

  436. 				}
    437. 

  437. 			}
    438. 

  438. 			if( isset($order_total) && $order_total <= 0.00 ) {
    439. 

  439. 				return true;
    440. 

  440. 			}
    441. 

  441. 		}
    442. 

  442. 		if (!isset($d["payment_method_id"]) || $d["payment_method_id"]==0 ) {
    443. 

  443. 			$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_PAYM',false) );
    444. 

  444. 			return false;
    445. 

  445. 		}
    446. 

  446. 		require_once(CLASSPATH.'ps_payment_method.php');
    447. 

  447. 		$ps_payment_method = new ps_payment_method;
    448. 

  448. 

  449. 		$dbp = new ps_DB; //DB Payment_method
    450. 

  450. 

  451. 		// Now Check if all needed Payment Information are entered
    452. 

  452. 		// Bank Information is found in the User_Info
    453. 

  453. 		$w  = "SELECT `enable_processor` FROM `#__{vm}_payment_method` WHERE ";
    454. 

  454. 		$w .= "payment_method_id=" .  (int)$d["payment_method_id"];
    455. 

  455. 		$dbp->query($w);
    456. 

  456. 		$dbp->next_record();
    457. 

  457. 		
    458. 

  458. 		if (($dbp->f("enable_processor") == "Y") 
    459. 

  459. 			|| ($dbp->f("enable_processor") == "")) {
    460. 

  460. 

  461. 			// Creditcard
    462. 

  462. 			if (empty( $_SESSION['ccdata']['creditcard_code']) ) {
    463. 

  463. 				$vmLogger->err( $VM_LANG->_('VM_CHECKOUT_ERR_CCTYPE') );
    464. 

  464. 				return false;
    465. 

  465. 			}
    466. 

  466. 

  467. 			// $_SESSION['ccdata'] = $ccdata;
    468. 

  468. 			// The Data should be in the session
    469. 

  469. 			if (!isset($_SESSION['ccdata'])) { //Not? Then Error
    470. 

  470. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_CCDATA',false) );
    471. 

  471. 				return False;
    472. 

  472. 			}
    473. 

  473. 

  474. 			if (!$_SESSION['ccdata']['order_payment_number']) {
    475. 

  475. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_CCNR_FOUND',false) );
    476. 

  476. 				return False;
    477. 

  477. 			}
    478. 

  478. 

  479. 			// CREDIT CARD NUMBER CHECK
    480. 

  480. 			// USING THE CREDIT CARD CLASS in ps_payment
    481. 

  481. 			if(!$ps_payment_method->validate_payment( $_SESSION['ccdata']['creditcard_code'], $_SESSION['ccdata']['order_payment_number'])) {
    482. 

  482. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_CCDATE',false) );
    483. 

  483. 				return False;
    484. 

  484. 			}
    485. 

  485. 

  486. 			if (!$is_test) {
    487. 

  487. 				$payment_number = ereg_replace(" |-", "", $_SESSION['ccdata']['order_payment_number']);
    488. 

  488. 				if ($payment_number == "4111111111111111") {
    489. 

  489. 					$vmLogger->warning( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_TEST',false) );
    490. 

  490. 					return False;
    491. 

  491. 				}
    492. 

  492. 			}
    493. 

  493. 			if(!empty($_SESSION['ccdata']['need_card_code']) && empty($_SESSION['ccdata']['credit_card_code'])) {
    494. 

  494. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CUSTOMER_CVV2_ERROR',false) );
    495. 

  495. 				return False;
    496. 

  496. 			}
    497. 

  497. 			if(!$_SESSION['ccdata']['order_payment_expire_month']) {
    498. 

  498. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_CCMON',false) );
    499. 

  499. 				return False;
    500. 

  500. 			}
    501. 

  501. 			if(!$_SESSION['ccdata']['order_payment_expire_year']) {
    502. 

  502. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_CCYEAR',false) );
    503. 

  503. 				return False;
    504. 

  504. 			}
    505. 

  505. 			$date = getdate( time() );
    506. 

  506. 			if ($_SESSION['ccdata']['order_payment_expire_year'] < $date["year"] or
    507. 

  507. 			($_SESSION['ccdata']['order_payment_expire_year'] == $date["year"] and
    508. 

  508. 			$_SESSION['ccdata']['order_payment_expire_month'] < $date["mon"])) {
    509. 

  509. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_CCDATE_INV',false) );
    510. 

  510. 				return False;
    511. 

  511. 			}
    512. 

  512. 			return True;
    513. 

  513. 		}
    514. 

  514. 		elseif ($dbp->f("enable_processor") == "B") {
    515. 

  515. 			$_SESSION['ccdata']['creditcard_code'] = "";
    516. 

  516. 			$_SESSION['ccdata']['order_payment_name']  = "";
    517. 

  517. 			$_SESSION['ccdata']['order_payment_number']  = "";
    518. 

  518. 			$_SESSION['ccdata']['order_payment_expire_month'] = "";
    519. 

  519. 			$_SESSION['ccdata']['order_payment_expire_year'] = "";
    520. 

  520. 			// Bank Account
    521. 

  521. 			require_once( CLASSPATH . 'ps_user.php' );
    522. 

  522. 			$dbu =& ps_user::getUserInfo( $auth["user_id"], array( 'bank_account_holder','bank_iban','bank_account_nr','bank_sort_code','bank_name' ) );
    523. 

  523. 			
    524. 

  524. 			if($_SERVER['REMOTE_ADDR'] == '67.161.25.236'){
    525. 

  525. 				
    526. 

  526. 			} 
    527. 

  527. 

  528. 			//Organic Mod: We want it to replace if fields are filled in
    529. 

  529. 			//if ( $dbu->f("bank_account_holder") == "" || $dbu->f("bank_account_nr") =="" ) {
    530. 

  530. 				if( !empty($d['bank_account_holder']) && !empty($d['bank_account_nr'])) {
    531. 

  531. 					// Insert the given data
    532. 

  532. 					$fields = array( 'bank_account_holder' => $d['bank_account_holder'],
    533. 

  533. 							'bank_account_nr' => $d['bank_account_nr'],
    534. 

  534. 							'bank_sort_code' => $d['bank_sort_code'],
    535. 

  535. 							'bank_name' => $d['bank_name'],
    536. 

  536. 							'bank_iban' => $d['bank_iban']
    537. 

  537. 							);
    538. 

  538. 					ps_user::setUserInfo( $fields, $auth["user_id"] );
    539. 

  539. 

  540. 					$dbu =& ps_user::getUserInfo( $auth["user_id"], array( 'bank_account_holder','bank_iban','bank_account_nr','bank_sort_code','bank_name' ) ); 
    541. 

  541. 				}
    542. 

  542. 				else {
    543. 

  543. 					$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_USER_DATA',false) );
    544. 

  544. 					return False;
    545. 

  545. 				}
    546. 

  546. 			//}
    547. 

  547. 			if ($dbu->f("bank_account_holder") == ""){
    548. 

  548. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_BA_HOLDER_NAME',false) );
    549. 

  549. 				return False;
    550. 

  550. 			}
    551. 

  551. 			if (($dbu->f("bank_iban") == "") and
    552. 

  552. 			($dbu->f("bank_account_nr") =="")) {
    553. 

  553. 				$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_IBAN',false) );
    554. 

  554. 				return False;
    555. 

  555. 			}
    556. 

  556. 			if ($dbu->f("bank_iban") == "") {
    557. 

  557. 				if ($dbu->f("bank_account_nr") == ""){
    558. 

  558. 					$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_BA_NUM',false) );
    559. 

  559. 					return False;
    560. 

  560. 				}
    561. 

  561. 				if ($dbu->f("bank_sort_code") == ""){
    562. 

  562. 					$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_BANK_SORT',false) );
    563. 

  563. 					return False;
    564. 

  564. 				}
    565. 

  565. 				if ($dbu->f("bank_name") == ""){
    566. 

  566. 					$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_BANK_NAME',false) );
    567. 

  567. 					return False;
    568. 

  568. 				}
    569. 

  569. 			}
    570. 

  570. 		}
    571. 

  571. 		else {
    572. 

  572. 			$_SESSION['ccdata']['creditcard_code'] = '';
    573. 

  573. 			$_SESSION['ccdata']['order_payment_name']  = "";
    574. 

  574. 			$_SESSION['ccdata']['order_payment_number']  = "";
    575. 

  575. 			$_SESSION['ccdata']['order_payment_expire_month'] = "";
    576. 

  576. 			$_SESSION['ccdata']['order_payment_expire_year'] = "";
    577. 

  577. 		}
    578. 

  578. 		// Enter additional Payment check procedures here if neccessary
    579. 

  579. 

  580. 		return True;
    581. 

  581. 	}
    582. 

  582. 

  583. 	/**
    584. 

  584. 	 * Update order details
    585. 

  585. 	 * CURRENTLY UNUSED
    586. 

  586. 	 *
    587. 

  587. 	 * @param array $d
    588. 

  588. 	 * @return boolean
    589. 

  589. 	 */
    590. 

  590. 	function update(&$d) {
    591. 

  591. 		global $vmLogger;
    592. 

  592. 		
    593. 

  593. 		$db = new ps_DB;
    594. 

  594. 		$timestamp = time();
    595. 

  595. 

  596. 

  597. 		if ($this->validate_update($d)) {
    598. 

  598. 			return True;
    599. 

  599. 		}
    600. 

  600. 		else {
    601. 

  601. 			$vmLogger->err( $this->error );
    602. 

  602. 			return False;
    603. 

  603. 		}
    604. 

  604. 	}
    605. 

  605. 

  606. 	/**
    607. 

  607. 	 * Control Function for the Checkout Process
    608. 

  608. 	 * @author Ekkhard Domning
    609. 

  609. 	 * @author soeren
    610. 

  610. 	 * @param array $d
    611. 

  611. 	 * @return boolean
    612. 

  612. 	 */
    613. 

  613. 	function process(&$d) {
    614. 

  614. 		global $checkout_this_step, $sess,$VM_LANG, $vmLogger;
    615. 

  615. 		$ccdata = array();
    616. 

  616. 

  617. 		if( empty($d["checkout_this_step"]) || !is_array(@$d["checkout_this_step"])) {
    618. 

  618. 			$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_VALID_STEP',false) );
    619. 

  619. 			return false;
    620. 

  620. 		}
    621. 

  621. 		
    622. 

  622. 		foreach($d["checkout_this_step"] as $checkout_this_step) {
    623. 

  623. 		
    624. 

  624. 			switch($checkout_this_step) {
    625. 

  625. 				
    626. 

  626. 				case 'CHECK_OUT_GET_FINAL_BASKET' :
    627. 

  627. 					break;
    628. 

  628. 	
    629. 

  629. 				case 'CHECK_OUT_GET_SHIPPING_ADDR' :		
    630. 

  630. 					// The User has choosen a Shipping address
    631. 

  631. 					if (empty($d["ship_to_info_id"])) {
    632. 

  632. 						$vmLogger->err( $VM_LANG->_('PHPSHOP_CHECKOUT_ERR_NO_SHIPTO',false) );
    633. 

  633. 						unset( $_POST['checkout_this_step']);
    634. 

  634. 						return False;
    635. 

  635. 					}
    636. 

  636. 					break;
    637. 

  637. 	
    638. 

  638. 				case 'CHECK_OUT_GET_SHIPPING_METHOD':
    639. 

  639. 					// The User has choosen a Shipping method
    640. 

  640. 					if (!$this->validate_shipping_method($d)) {
    641. 

  641. 						unset( $_POST['checkout_this_step']);
    642. 

  642. 						return false;
    643. 

  643. 					}
    644. 

  644. 					break;
    645. 

  645. 	
    646. 

  646. 				case 'CHECK_OUT_GET_PAYMENT_METHOD':
    647. 

  647. 					
    648. 

  648. 					// The User has choosen a payment method
    649. 

  649. 					$_SESSION['ccdata']['order_payment_name'] = @$d['order_payment_name'];
    650. 

  650. 					// VISA, AMEX, DISCOVER....
    651. 

  651. 					$_SESSION['ccdata']['creditcard_code'] = @$d['creditcard_code'];
    652. 

  652. 					$_SESSION['ccdata']['order_payment_number'] = @$d['order_payment_number'];
    653. 

  653. 					$_SESSION['ccdata']['order_payment_expire_month'] = @$d['order_payment_expire_month'];
    654. 

  654. 					$_SESSION['ccdata']['order_payment_expire_year'] = @$d['order_payment_expire_year'];
    655. 

  655. 					// 3-digit Security Code (CVV)
    656. 

  656. 					$_SESSION['ccdata']['credit_card_code'] = @$d['credit_card_code'];
    657. 

  657. 		
    658. 

  658. 					if (!$this->validate_payment_method($d, true)) { //Change false to true to Let the user play with the VISA Testnumber
    659. 

  659. 						unset( $_POST['checkout_this_step']);
    660. 

  660. 						return false;
    661. 

  661. 					}
    662. 

  662. 					
    663. 

  663. 					break;
    664. 

  664. 	
    665. 

  665. 				case 'CHECK_OUT_GET_FINAL_CONFIRMATION':
    666. 

  666. 	
    667. 

  667. 					// The User wants to order now, validate everything, if OK than Add immeditialtly
    668. 

  668. 					return( $this->add( $d ) );
    669. 

  669. 	
    670. 

  670. 				default:
    671. 

  671. 					$vmLogger->crit( "CheckOut step ($checkout_this_step) is undefined!" );
    672. 

  672. 					return false;
    673. 

  673. 	
    674. 

  674. 			} // end switch
    675. 

  675. 		}
    676. 

  676. 		return true;
    677. 

  677. 	} // end function process
    678. 

  678. 

  679. 	/**
    680. 

  680. 	 * Prints the List of all shipping addresses of a user
    681. 

  681. 	 *
    682. 

  682. 	 * @param unknown_type $user_id
    683. 

  683. 	 * @param unknown_type $name
    684. 

  684. 	 * @param unknown_type $value
    685. 

  685. 	 */
    686. 

  686. 	function ship_to_addresses_radio($user_id, $name, $value) {
    687. 

  687. 		echo ps_checkout::list_addresses( $user_id, $name, $value );
    688. 

  688. 	}
    689. 

  689. 	/**
    690. 

  690. 	 * Creates a Radio List of all shipping addresses of a user
    691. 

  691. 	 *
    692. 

  692. 	 * @param int $user_id
    693. 

  693. 	 * @param string $name
    694. 

  694. 	 * @param string $value
    695. 

  695. 	 */
    696. 

  696. 	function list_addresses( $user_id, $name, $value ) {
    697. 

  697. 		global $sess,$VM_LANG;
    698. 

  698. 

  699. 		$db = new ps_DB;
    700. 

  700. 

  701. 		/* Select all the ship to information for this user id and
    702. 

  702. 		* order by modification date; most recently changed to oldest
    703. 

  703. 		*/
    704. 

  704. 		$q  = "SELECT * from #__{vm}_user_info WHERE ";
    705. 

  705. 		$q .= "user_id=" . (int)$user_id . ' ';
    706. 

  706. 		$q .= "AND address_type='BT'";
    707. 

  707. 		$db->query($q);
    708. 

  708. 		$db->next_record();
    709. 

  709. 

  710. 		$bt_user_info_id = $db->f("user_info_id");
    711. 

  711. 

  712. 		$q  = "SELECT * FROM #__{vm}_user_info i ";
    713. 

  713. 		$q .= "INNER JOIN #__{vm}_country c ON (i.country=c.country_3_code) ";
    714. 

  714. 		$q .= "LEFT JOIN #__{vm}_state s ON (i.state=s.state_2_code AND s.country_id=c.country_id) ";
    715. 

  715. 		$q .= "WHERE user_id =" . (int)$user_id . ' ';
    716. 

  716. 		$q .= "AND address_type = 'ST' ";
    717. 

  717. 		$q .= "ORDER by address_type_name, mdate DESC";
    718. 

  718. 

  719. 		$db->query($q);
    720. 

  720. 		
    721. 

  721. 		$theme = vmTemplate::getInstance();
    722. 

  722. 		$theme->set_vars(array('db' => $db,
    723. 

  723. 								'user_id' => $user_id,
    724. 

  724. 								'name' => $name,
    725. 

  725. 								'value' => $value,
    726. 

  726. 								'bt_user_info_id' => $bt_user_info_id,
    727. 

  727. 						 	)
    728. 

  728. 						 );
    729. 

  729. 

  730. 		echo $theme->fetch( 'checkout/list_shipto_addresses.tpl.php');
    731. 

  731. 	}
    732. 

  732. 

  733. 	/**
    734. 

  734. 	 * Fetches the address information for the currently logged in user
    735. 

  735. 	 *
    736. 

  736. 	 * @param string $address_type Can be BT (Bill To) or ST (Shipto address)
    737. 

  737. 	 */
    738. 

  738. 	function display_address($address_type='BT') {
    739. 

  739. 		$auth = $_SESSION['auth'];
    740. 

  740. 		
    741. 

  741. 		$address_type = $address_type == 'BT' ? $address_type : 'ST';
    742. 

  742. 		
    743. 

  743. 		$db = new ps_DB;
    744. 

  744. 		$q  = "SELECT * FROM #__{vm}_user_info i ";
    745. 

  745. 		$q .= "INNER JOIN #__{vm}_country c ON (i.country=c.country_3_code OR i.country=c.country_2_code) ";
    746. 

  746. 		$q .= "LEFT JOIN #__{vm}_state s ON (i.state=s.state_2_code AND s.country_id=c.country_id) ";
    747. 

  747. 		$q .= "WHERE user_id='" . $auth["user_id"] . "' ";
    748. 

  748. 		$q .= "AND address_type='BT'";
    749. 

  749. 		$db->query($q);
    750. 

  750. 		$db->next_record();
    751. 

  751. 		$theme = new $GLOBALS['VM_THEMECLASS']();
    752. 

  752. 		$theme->set('db', $db );
    753. 

  753. 		
    754. 

  754. 		return $theme->fetch('checkout/customer_info.tpl.php');
    755. 

  755. 		
    756. 

  756. 	}
    757. 

  757. 	/**
    758. 

  758. 	 * Lists Shipping Methods of all published Shipping Modules
    759. 

  759. 	 *
    760. 

  760. 	 * @param string $ship_to_info_id
    761. 

  761. 	 * @param string $shipping_method_id
    762. 

  762. 	 */
    763. 

  763. 	function list_shipping_methods( $ship_to_info_id=null, $shipping_method_id=null ) {
    764. 

  764. 		global $PSHOP_SHIPPING_MODULES, $vmLogger, $auth, $weight_total;
    765. 

  765. 		
    766. 

  766. 		if( empty( $ship_to_info_id )) {
    767. 

  767. 		    // Get the Bill to user_info_id
    768. 

  768. 		    $database = new ps_DB();
    769. 

  769. 		    $database->setQuery( "SELECT user_info_id FROM #__{vm}_user_info WHERE user_id=".$auth['user_id']." AND address_type='BT'" );
    770. 

  770. 		    $vars["ship_to_info_id"] = $_REQUEST['ship_to_info_id'] = $database->loadResult();
    771. 

  771. 		} else {
    772. 

  772. 			$vars['ship_to_info_id'] = $ship_to_info_id;
    773. 

  773. 		}
    774. 

  774. 		$vars['shipping_rate_id'] = $shipping_method_id;
    775. 

  775. 		$vars["weight"] = $weight_total;
    776. 

  776. 		$vars['zone_qty'] = vmRequest::getInt( 'zone_qty', 0 );
    777. 

  777. 		$i = 0;
    778. 

  778. 

  779. 		$theme = new $GLOBALS['VM_THEMECLASS']();
    780. 

  780. 		$theme->set_vars(array('vars' => $vars,
    781. 

  781. 								'PSHOP_SHIPPING_MODULES' => $PSHOP_SHIPPING_MODULES
    782. 

  782. 						 	)
    783. 

  783. 						 );
    784. 

  784. 

  785. 		echo $theme->fetch( 'checkout/list_shipping_methods.tpl.php');
    786. 

  786. 		
    787. 

  787. 	}
    788. 

  788. 	/**
    789. 

  789. 	 * Lists the payment methods of all available payment modules
    790. 

  790. 	 * @static 
    791. 

  791. 	 * @param int $payment_method_id
    792. 

  792. 	 */
    793. 

  793. 	function list_payment_methods( $payment_method_id=0 ) {
    794. 

  794. 		global $order_total, $sess, $VM_CHECKOUT_MODULES, $VB_STAGE_PAY_METHODS, $page, $ps_booking;
    795. 

  795. 		$ps_vendor_id = $_SESSION['ps_vendor_id'];
    796. 

  796. 		$auth = $_SESSION['auth'];
    797. 

  797. 		
    798. 

  798. 		$ship_to_info_id = vmGet( $_REQUEST, 'ship_to_info_id' );
    799. 

  799. 		$shipping_rate_id = vmGet( $_REQUEST, 'shipping_rate_id' );
    800. 

  800. 		
    801. 

  801.         require_once(CLASSPATH . 'ps_payment_method.php');
    802. 

  802.         $ps_payment_method = new ps_payment_method;
    803. 

  803. 		require_once( CLASSPATH. 'ps_creditcard.php' );
    804. 

  804. 	    $ps_creditcard = new ps_creditcard();
    805. 

  805. 	    
    806. 

  806. 	    /**
    807. 

  807. 		 * VirtueBook:
    808. 

  808. 		 * Only show the payment stages relating to multi-stage payments
    809. 

  809. 		 * if we are on the order.payment_list page
    810. 

  810. 		 * */
    811. 

  811. 		if(isset($VB_STAGE_PAY_METHODS) && count($VB_STAGE_PAY_METHODS) && $page == 'order.payment_list'){
    812. 

  812. 			$stage_pay_methods = $VB_STAGE_PAY_METHODS;
    813. 

  813. 		}else{
    814. 

  814. 			$stage_pay_methods = array();
    815. 

  815. 		}
    816. 

  816. 	    
    817. 

  817. 		// Do we have Credit Card Payments?
    818. 

  818. 		$db_cc  = new ps_DB;
    819. 

  819. 		$q = "SELECT * from #__{vm}_payment_method,#__{vm}_shopper_group WHERE ";
    820. 

  820. 		$q .= "#__{vm}_payment_method.shopper_group_id=#__{vm}_shopper_group.shopper_group_id ";
    821. 

  821. 		$q .= "AND (#__{vm}_payment_method.shopper_group_id='".$auth['shopper_group_id']."' ";
    822. 

  822. 		$q .= "OR #__{vm}_shopper_group.default='1') ";
    823. 

  823. 		$q .= "AND (enable_processor='' OR enable_processor='Y') ";
    824. 

  824. 		$q .= (count($stage_pay_methods) ? "AND payment_method_id IN (".implode(',',$stage_pay_methods).") " : "AND payment_enabled='Y' ");
    825. 

  825. 		$q .= "AND #__{vm}_payment_method.vendor_id='$ps_vendor_id' ";
    826. 

  826. 		$q .= " ORDER BY list_order";
    827. 

  827. 		$db_cc->query($q);
    828. 

  828. 		
    829. 

  829. 		if ($db_cc->num_rows()) {
    830. 

  830. 		    $cc_payments=true;
    831. 

  831. 		}
    832. 

  832. 		else {
    833. 

  833. 		    $cc_payments=false;
    834. 

  834. 		}
    835. 

  835. 		$count = 0;
    836. 

  836. 		$db_nocc  = new ps_DB;
    837. 

  837. 		$q = "SELECT * from #__{vm}_payment_method,#__{vm}_shopper_group WHERE ";
    838. 

  838. 		$q .= "#__{vm}_payment_method.shopper_group_id=#__{vm}_shopper_group.shopper_group_id ";
    839. 

  839. 		$q .= "AND (#__{vm}_payment_method.shopper_group_id='".$auth['shopper_group_id']."' ";
    840. 

  840. 		$q .= "OR #__{vm}_shopper_group.default='1') ";
    841. 

  841. 		$q .= "AND (enable_processor='B' OR enable_processor='N' OR enable_processor='P') ";
    842. 

  842. 		$q .= (count($stage_pay_methods) ? "AND payment_method_id IN (".implode(',',$stage_pay_methods).") " : "AND payment_enabled='Y' ");
    843. 

  843. 		$q .= "AND #__{vm}_payment_method.vendor_id='$ps_vendor_id' ";
    844. 

  844. 

  845. 		//Only show paypal if owner booking payments if false or there is no payment id
    846. 

  846. 		if(!$ps_booking->payment_id || @VB_OWNER_BOOKING_PAYMENTS == 0){
    847. 

  847. 			$q .= "AND #__{vm}_payment_method.payment_class != 'ps_paypal' ";
    848. 

  848. 		}
    849. 

  849. 		$q .= " ORDER BY list_order";
    850. 

  850. 		$db_nocc->query($q);
    851. 

  851. 		
    852. 

  852. 		if ($db_nocc->next_record()) {
    853. 

  853. 		    $nocc_payments=true;
    854. 

  854. 		    $first_payment_method_id = $db_nocc->f("payment_method_id");
    855. 

  855. 		    $count = $db_nocc->num_rows();
    856. 

  856. 		    $db_nocc->reset();
    857. 

  857. 		}
    858. 

  858. 		else {
    859. 

  859. 		    $nocc_payments=false;
    860. 

  860. 		}
    861. 

  861. 		
    862. 

  862.         // Redirect to the last step when there's only one payment method
    863. 

  863. 		if( $VM_CHECKOUT_MODULES['CHECK_OUT_GET_PAYMENT_METHOD']['order'] != $VM_CHECKOUT_MODULES['CHECK_OUT_GET_FINAL_CONFIRMATION']['order'] ) {
    864. 

  864. 			if ($count <= 1 && $cc_payments==false) {
    865. 

  865. 				vmRedirect($sess->url(SECUREURL.basename($_SERVER['PHP_SELF'])."?page=checkout.index&payment_method_id=$first_payment_method_id&ship_to_info_id=$ship_to_info_id&shipping_rate_id=".urlencode($shipping_rate_id)."&checkout_stage=".$VM_CHECKOUT_MODULES['CHECK_OUT_GET_FINAL_CONFIRMATION']['order'], false, false ),"");
    866. 

  866. 			}
    867. 

  867. 			elseif( isset($order_total) && $order_total <= 0.00 ) {
    868. 

  868. 				// In case the order total is less than or equal zero, we don't need a payment method
    869. 

  869. 				vmRedirect($sess->url(SECUREURL.basename($_SERVER['PHP_SELF'])."?page=checkout.index&ship_to_info_id=$ship_to_info_id&shipping_rate_id=".urlencode($shipping_rate_id)."&checkout_stage=".$VM_CHECKOUT_MODULES['CHECK_OUT_GET_FINAL_CONFIRMATION']['order'], false, false),"");
    870. 

  870. 			}
    871. 

  871. 		}
    872. 

  872. 		$theme = new $GLOBALS['VM_THEMECLASS']();
    873. 

  873. 		$theme->set_vars(array('db_nocc' => $db_nocc,
    874. 

  874. 								'db_cc' => $db_cc,
    875. 

  875. 								'nocc_payments' => $nocc_payments,
    876. 

  876. 								'payment_method_id' => $payment_method_id,
    877. 

  877. 								'first_payment_method_id' => $first_payment_method_id,
    878. 

  878. 								'count' => $count,
    879. 

  879. 								'cc_payments' => $cc_payments,
    880. 

  880. 								'ps_creditcard' => $ps_creditcard,
    881. 

  881. 								'ps_payment_method' => $ps_payment_method
    882. 

  882. 						 	)
    883. 

  883. 						 );
    884. 

  884. 						 
    885. 

  885. 			echo $theme->fetch( 'checkout/list_payment_methods.tpl.php');
    886. 

  886. 		
    887. 

  887. 	}
    888. 

  888. 	/**
    889. 

  889. 	 * This is the main function which stores the order information in the database
    890. 

  890. 	 * 
    891. 

  891. 	 * @author gday, soeren, many others!
    892. 

  892. 	 * @param array $d The REQUEST/$vars array
    893. 

  893. 	 * @return boolean
    894. 

  894. 	 */
    895. 

  895. 	function add( &$d ) {
    896. 

  896. 		global $order_tax_details, $afid, $VM_LANG, $auth, $my, $mosConfig_offset,
    897. 

  897. 		$vmLogger, $vmInputFilter, $discount_factor, $ps_booking;
    898. 

  898. 		
    899. 

  899. 		$ps_vendor_id = $_SESSION["ps_vendor_id"];
    900. 

  900. 		$auth = $_SESSION['auth'];
    901. 

  901. 		$cart = $_SESSION['cart'];
    902. 

  902. 

  903. 		require_once(CLASSPATH. 'ps_payment_method.php' );
    904. 

  904. 		$ps_payment_method = new ps_payment_method;
    905. 

  905. 		require_once(CLASSPATH. 'ps_product.php' );
    906. 

  906. 		$ps_product= new ps_product;
    907. 

  907. 		require_once(CLASSPATH.'ps_cart.php');
    908. 

  908. 		$ps_cart = new ps_cart;
    909. 

  909. 

  910. 		if (AFFILIATE_ENABLE == '1') {
    911. 

  911. 			require_once(CLASSPATH.'ps_affiliate.php');
    912. 

  912. 			$ps_affiliate = new ps_affiliate;
    913. 

  913. 		}
    914. 

  914. 

  915. 		$db = new ps_DB;
    916. 

  916. 		
    917. 

  917. 		//Validate the booking
    918. 

  918. 		if (!$ps_booking->process(1,0)) {
    919. 

  919. 			$_SESSION['last_page'] = "booking.index";
    920. 

  920. 			$_REQUEST["checkout_next_step"] = CHECK_OUT_GET_FINAL_CONFIRMATION;
    921. 

  921. 			return False;
    922. 

  922. 		}
    923. 

  923. 

  924. 		/* Set the order number */
    925. 

  925. 		$order_number = $this->get_order_number();
    926. 

  926. 

  927. 		$totals = $this->calc_order_totals( $d );
    928. 

  928. 		extract( $totals );
    929. 

  929. 		
    930. 

  930. 		
    931. 

  931. 		/**
    932. 

  932. 		 * Virtuebook: Add booking totals to order totals
    933. 

  933. 		 * 
    934. 

  934. 		 */
    935. 

  935. 		$payment_stages = $ps_booking->getStagePayment($order_total);	
    936. 

  936. 		/*** Virtuebook End ***/
    937. 

  937. 		
    938. 

  938. 		$timestamp = time() + ($mosConfig_offset*60*60);
    939. 

  939. 		
    940. 

  940. 		// calculate the unix timestamp for the specified expiration date
    941. 

  941. 		// default the day to the 1st
    942. 

  942. 		$expire_timestamp = @mktime(0,0,0,$_SESSION["ccdata"]["order_payment_expire_month"], 1,$_SESSION["ccdata"]["order_payment_expire_year"]);
    943. 

  943. 		$_SESSION["ccdata"]["order_payment_expire"] = $expire_timestamp;
    944. 

  944. 			
    945. 

  945. 		//Check that the form validates and that the booking status is not set to 1
    946. 

  946. 		//!$this->validate_form($d) ||
    947. 

  947. 		if (!$ps_booking->status) {
    948. 

  948. 			return false;
    949. 

  949. 		}
    950. 

  950. 

  951. 		if (!$this->validate_add($d)) {
    952. 

  952. 			return false;
    953. 

  953. 		}
    954. 

  954. 

  955. 

  956. 		// make sure Total doesn't become negative
    957. 

  957. 		if( $order_total < 0 ) $order_total = 0;
    958. 

  958. 

  959. 		$order_total = round( $order_total, 2);
    960. 

  960. 		
    961. 

  961. 		
    962. 

  962. 		$vmLogger->debug('-- Checkout Debug--
    963. 

  963. 		
    964. 

  964. 						Subtotal: '.$order_subtotal.'
    965. 

  965. 						Taxable: '.$order_taxable.'
    966. 

  966. 						Payment Discount: '.$payment_discount.'
    967. 

  967. 						Coupon Discount: '.$coupon_discount.'
    968. 

  968. 						Shipping: '.$order_shipping.'
    969. 

  969. 						Shipping Tax : '.$order_shipping_tax.'
    970. 

  970. 						Tax : '.$order_tax.'
    971. 

  971. 						------------------------
    972. 

  972. 						Order Total: '.$order_total.'
    973. 

  973. 						----------------------------' 
    974. 

  974. 						);
    975. 

  975. 

  976. 		// Check to see if Payment Class File exists
    977. 

  977. 		$payment_class = $ps_payment_method->get_field($d["payment_method_id"], "payment_class");
    978. 

  978. 		$enable_processor = $ps_payment_method->get_field($d["payment_method_id"], "enable_processor");
    979. 

  979. 		
    980. 

  980. 		//Set a hasPaid variable that will control whether to send a success email later
    981. 

  981. 		$hasPaid = 0;
    982. 

  982. 		if (file_exists(CLASSPATH . "payment/$payment_class.php") ) {
    983. 

  983. 			if( !class_exists( $payment_class )) {
    984. 

  984. 				include( CLASSPATH. "payment/$payment_class.php" );
    985. 

  985. 			}
    986. 

  986. 

  987. 			$_PAYMENT = new $payment_class();							
    988. 

  988. 			if (!$_PAYMENT->process_payment($order_number, $order_total_due, $d, $payment_stages)) {
    989. 

  989. 				//$vmLogger->err( $VM_LANG->_('PHPSHOP_PAYMENT_ERROR',false)." ($payment_class)" );
    990. 

  990. 				$_SESSION['last_page'] = "checkout.index";
    991. 

  991. 				$_REQUEST["checkout_next_step"] = CHECK_OUT_GET_PAYMENT_METHOD;
    992. 

  992. 				return False;
    993. 

  993. 			}
    994. 

  994. 			$hasPaid = 1;
    995. 

  995. 		}
    996. 

  996. 

  997. 		else {
    998. 

  998. 			$d["order_payment_log"] = $VM_LANG->_('PHPSHOP_CHECKOUT_MSG_LOG');
    999. 

  999. 		}
    1000. 

  1000. 

  1001. 		// Remove the Coupon, because it is a Gift Coupon and now is used!!
    1002. 

  1002. 		if( @$_SESSION['coupon_type'] == "gift" ) {
    1003. 

  1003. 			$d['coupon_id'] = $_SESSION['coupon_id'];
    1004. 

  1004. 			include_once( CLASSPATH.'ps_coupon.php' );
    1005. 

  1005. 			ps_coupon::remove_coupon_code( $d );
    1006. 

  1006. 		}
    1007. 

  1007. 		
    1008. 

  1008. 		// Get the IP Address
    1009. 

  1009. 		if (!empty($_SERVER['REMOTE_ADDR'])) {
    1010. 

  1010. 			$ip = $_SERVER['REMOTE_ADDR'];
    1011. 

  1011. 		}
    1012. 

  1012. 		else {
    1013. 

  1013. 			$ip = 'unknown';
    1014. 

  1014. 		}
    1015. 

  1015. 		// Collect all fields and values to store them!
    1016. 

  1016. 		$fields = array(
    1017. 

  1017. 			'user_id' => $auth["user_id"], 
    1018. 

  1018. 			'vendor_id' => $ps_vendor_id, 
    1019. 

  1019. 			'order_number' => $order_number, 
    1020. 

  1020. 			'user_info_id' =>  $d["ship_to_info_id"], 
    1021. 

  1021. 			'ship_method_id' => @urldecode($d["shipping_rate_id"]),
    1022. 

  1022. 			'order_total' => $order_total, 
    1023. 

  1023. 			'order_subtotal' => $order_subtotal, 
    1024. 

  1024. 			'order_tax' => $order_tax, 
    1025. 

  1025. 			'order_tax_details' => serialize($order_tax_details), 
    1026. 

  1026. 			'order_shipping' => $order_shipping,
    1027. 

  1027. 			'order_shipping_tax' => $order_shipping_tax, 
    1028. 

  1028. 			'order_discount' => $payment_discount, 
    1029. 

  1029. 			'coupon_discount' => $coupon_discount,
    1030. 

  1030. 			'coupon_code' => @$_SESSION['coupon_code'],
    1031. 

  1031. 			'order_currency' => $GLOBALS['product_currency'], 
    1032. 

  1032. 			'order_status' => 'P', 
    1033. 

  1033. 			'cdate' => $timestamp,
    1034. 

  1034. 			'mdate' => $timestamp,
    1035. 

  1035. 			'customer_note' => htmlspecialchars(strip_tags($d['customer_note']), ENT_QUOTES ),
    1036. 

  1036. 			'ip_address' => $ip
    1037. 

  1037. 			);
    1038. 

  1038. 

  1039. 		// Insert the main order information
    1040. 

  1040. 		$db->buildQuery( 'INSERT', '#__{vm}_orders', $fields );
    1041. 

  1041. 		$result = $db->query();
    1042. 

  1042. 

  1043. 		$d["order_id"] = $order_id = $db->last_insert_id();
    1044. 

  1044. 		if( $result === false || empty( $order_id )) {
    1045. 

  1045. 			$vmLogger->crit( 'Adding the Order into the Database failed! User ID: '.$auth["user_id"] );
    1046. 

  1046. 			return false;
    1047. 

  1047. 		}
    1048. 

  1048. 

  1049. 	    // Insert the initial Order History.	    
    1050. 

  1050. 		$mysqlDatetime = date("Y-m-d G:i:s", $timestamp);		
    1051. 

  1051. 		
    1052. 

  1052. 		$fields = array(
    1053. 

  1053. 					'order_id' => $order_id,
    1054. 

  1054. 					'order_status_code' => 'P',
    1055. 

  1055. 					'date_added' => $mysqlDatetime,
    1056. 

  1056. 					'customer_notified' => 1,
    1057. 

  1057. 					'comments' => '',
    1058. 

  1058. 					'booking_serialized' => serialize($ps_booking)
    1059. 

  1059. 				  );
    1060. 

  1060. 		$db->buildQuery( 'INSERT', '#__{vm}_order_history', $fields );
    1061. 

  1061. 		$db->query();
    1062. 

  1062. 	
    1063. 

  1063. 		
    1064. 

  1064. 		
    1065. 

  1065. 		/**
    1066. 

  1066. 		 * Virtuebook: Save the booking data
    1067. 

  1067. 		 */
    1068. 

  1068. 		
    1069. 

  1069. 		$fields = array('order_id' => $order_id, 
    1070. 

  1070. 						'property_id' => $ps_booking->property_id,
    1071. 

  1071. 						'people' => $ps_booking->people,
    1072. 

  1072. 						'arrival' => $ps_booking->dateFrom,
    1073. 

  1073. 						'departure' => $ps_booking->dateTo, 
    1074. 

  1074. 						'total' => $ps_booking->total,
    1075. 

  1075. 						'subtotal' => $ps_booking->subtotal,
    1076. 

  1076. 						'original' => $ps_booking->original,
    1077. 

  1077. 						'tax_total' => $ps_booking->tax, 
    1078. 

  1078. 						'tax_state' => $ps_booking->tax_state, 
    1079. 

  1079. 						'tax_resort' => $ps_booking->tax_resort, 
    1080. 

  1080. 						'discounts' => $ps_booking->adv_discount['discount_total'], 
    1081. 

  1081. 						'discount_details' => serialize($ps_booking->adv_discount),
    1082. 

  1082. 						'insurance' => $ps_booking->securityDeposit,
    1083. 

  1083. 						'cleaning' => $ps_booking->cleaning
    1084. 

  1084. 						);
    1085. 

  1085. 			
    1086. 

  1086. 		$db->buildQuery( 'INSERT', '#__{vm}_order_booking', $fields );
    1087. 

  1087. 		
    1088. 

  1088. 		if (!$db->query()) {
    1089. 

  1089. 			$vmLogger->crit( 'There was a problem saving your booking. The booking reference is: '.$order_id.'. The Error Information is: '.$db->getErrorMsg());
    1090. 

  1090. 			return false;
    1091. 

  1091. 		}		
    1092. 

  1092. 		
    1093. 

  1093. 		/* Virtuebook End */
    1094. 

  1094. 		
    1095. 

  1095. 		/**
    1096. 

  1096. 	    * Insert the Order payment info 
    1097. 

  1097. 	    */
    1098. 

  1098. 		$payment_number = ereg_replace(" |-", "", @$_SESSION['ccdata']['order_payment_number']);
    1099. 

  1099. 

  1100. 		$d["order_payment_code"] = @$_SESSION['ccdata']['credit_card_code'];		
    1101. 

  1101. 		
    1102. 

  1102. 		
    1103. 

  1103. 		/**
    1104. 

  1104. 		 * Virtuebook:  Loop through the stage payment info
    1105. 

  1105. 		 */		
    1106. 

  1106. 		foreach($payment_stages->stages as $k => &$payment){
    1107. 

  1107. 			if(is_object($payment)){
    1108. 

  1108. 				
    1109. 

  1109. 				// Payment number is encrypted using mySQL encryption functions.
    1110. 

  1110. 				$fields = array(
    1111. 

  1111. 							'order_id' => $order_id,						
    1112. 

  1112. 							'payment_amount' => $payment->payment_amount,
    1113. 

  1113. 							'payment_due' => $payment->payment_due,							
    1114. 

  1114. 							'payment_stage' => $payment->payment_stage							
    1115. 

  1115. 						  );					
    1116. 

  1116. 				
    1117. 

  1117. 				$specialfield = array();								
    1118. 

  1118. 				
    1119. 

  1119. 				//Check if the payment is due
    1120. 

  1120. 				if($payment->is_due){
    1121. 

  1121. 					
    1122. 

  1122. 					$payment->payment_method_id = $d["payment_method_id"];									
    1123. 

  1123. 					$fields['payment_submitted'] = $payment->payment_submitted;
    1124. 

  1124. 					$fields['payment_cleared'] = $payment->payment_cleared;
    1125. 

  1125. 					$fields['payment_method_id'] = $payment->payment_method_id;
    1126. 

  1126. 					$fields['order_payment_log'] = @$d["order_payment_log"];
    1127. 

  1127. 					$fields['order_payment_trans_id'] = $vmInputFilter->safeSQL( @$d["order_payment_trans_id"] );
    1128. 

  1128. 					if( !empty( $payment_number ) && VM_STORE_CREDITCARD_DATA == '1' ) {
    1129. 

  1129. 						// Store Credit Card Information only if the Store Owner has decided to do so
    1130. 

  1130. 						$fields['order_payment_code'] = $d["order_payment_code"];
    1131. 

  1131. 						$fields['order_payment_expire'] = @$_SESSION["ccdata"]["order_payment_expire"];
    1132. 

  1132. 						$fields['order_payment_name'] = @$_SESSION["ccdata"]["order_payment_name"];
    1133. 

  1133. 						$fields['order_payment_number'] = VM_ENCRYPT_FUNCTION."( '$payment_number','" . ENCODE_KEY . "')";
    1134. 

  1134. 						$specialfield = array('order_payment_number');
    1135. 

  1135. 					} 
    1136. 

  1136. 				}
    1137. 

  1137. 				//Add to DB
    1138. 

  1138. 				$db->buildQuery( 'INSERT', '#__{vm}_order_payment', $fields, '', $specialfield );
    1139. 

  1139. 				if(!$db->query()){
    1140. 

  1140. 					$vmLogger->crit( 'There was a problem saving your bookings payment information. The booking reference is: '.$order_id.'. The Error Information is: '.$db->getErrorMsg());
    1141. 

  1141. 				}
    1142. 

  1142. 			}
    1143. 

  1143. 		}
    1144. 

  1144. 				
    1145. 

  1145. 		//Store in the session for use in the thankyou page payment extra_info processing
    1146. 

  1146. 		$_SESSION['payment_stages'] = $payment_stages;
    1147. 

  1147. 				
    1148. 

  1148. 		/**
    1149. 

  1149. 		* Insert the User Billto & Shipto Info
    1150. 

  1150. 		*/
    1151. 

  1151. 		// First: get all the fields from the user field list to copy them from user_info into the order_user_info
    1152. 

  1152. 		$fields = array();
    1153. 

  1153. 		require_once( CLASSPATH . 'ps_userfield.php' );
    1154. 

  1154. 		$userfields = ps_userfield::getUserFields('', false, '', true, true );
    1155. 

  1155. 		foreach ( $userfields as $field ) {
    1156. 

  1156. 			$fields[] = $field->name;
    1157. 

  1157. 		}
    1158. 

  1158. 		$fieldstr = str_replace( 'email', 'user_email', implode( ',', $fields ));
    1159. 

  1159. 		// Save current Bill To Address
    1160. 

  1160. 		$q = "INSERT INTO `#__{vm}_order_user_info` 
    1161. 

  1161. 			(`order_info_id`,`order_id`,`user_id`,address_type, ".$fieldstr.") ";
    1162. 

  1162. 		$q .= "SELECT NULL, '$order_id', '".$auth['user_id']."', address_type, ".$fieldstr." FROM #__{vm}_user_info WHERE user_id='".$auth['user_id']."' AND address_type='BT'";
    1163. 

  1163. 		$db->query( $q );
    1164. 

  1164. 

  1165. 		// Save current Ship to Address if applicable
    1166. 

  1166. 		$q = "INSERT INTO `#__{vm}_order_user_info` 
    1167. 

  1167. 			(`order_info_id`,`order_id`,`user_id`,address_type, ".$fieldstr.") ";
    1168. 

  1168. 		$q .= "SELECT NULL, '$order_id', '".$auth['user_id']."', address_type, ".$fieldstr." FROM #__{vm}_user_info WHERE user_id='".$auth['user_id']."' AND user_info_id='".$d['ship_to_info_id']."' AND address_type='ST'";
    1169. 

  1169. 		$db->query( $q );
    1170. 

  1170. 

  1171. 		/**
    1172. 

  1172.     	* Insert all Products from the Cart into order line items; 
    1173. 

  1173.     	* one row per product in the cart 
    1174. 

  1174.     	*/
    1175. 

  1175. 		$dboi = new ps_DB;
    1176. 

  1176. 		
    1177. 

  1177. 		for($i = 0; $i < $cart["idx"]; $i++) {
    1178. 

  1178. 

  1179. 			$r = "SELECT product_id,product_in_stock,product_sales,product_parent_id,product_sku,product_name ";
    1180. 

  1180. 			$r .= "FROM #__{vm}_product WHERE product_id='".$cart[$i]["product_id"]."'";
    1181. 

  1181. 			$dboi->query($r);
    1182. 

  1182. 			$dboi->next_record();
    1183. 

  1183. 

  1184. 			$product_price_arr = $ps_product->get_adjusted_attribute_price($cart[$i]["product_id"], $cart[$i]["description"]);
    1185. 

  1185. 			$product_price = $GLOBALS['CURRENCY']->convert( $product_price_arr["product_price"], $product_price_arr["product_currency"] );
    1186. 

  1186. 

  1187. 			if( empty( $_SESSION['product_sess'][$cart[$i]["product_id"]]['tax_rate'] )) {
    1188. 

  1188. 				$my_taxrate = $ps_product->get_product_taxrate($cart[$i]["product_id"] );
    1189. 

  1189. 			}
    1190. 

  1190. 			else {
    1191. 

  1191. 				$my_taxrate = $_SESSION['product_sess'][$cart[$i]["product_id"]]['tax_rate'];
    1192. 

  1192. 			}
    1193. 

  1193. 			// Attribute handling
    1194. 

  1194. 			$product_parent_id = $dboi->f('product_parent_id');
    1195. 

  1195. 			$description = '';
    1196. 

  1196. 			if( $product_parent_id > 0 ) {
    1197. 

  1197. 				
    1198. 

  1198. 				$db_atts = $ps_product->attribute_sql( $dboi->f('product_id'), $product_parent_id );
    1199. 

  1199. 				while( $db_atts->next_record()) {
    1200. 

  1200. 					$description .=	$db_atts->f('attribute_name').': '.$db_atts->f('attribute_value').'; ';
    1201. 

  1201. 				}
    1202. 

  1202. 			}
    1203. 

  1203. 			
    1204. 

  1204. 			$description .= $ps_product->getDescriptionWithTax($_SESSION['cart'][$i]["description"], $dboi->f('product_id'));
    1205. 

  1205. 			
    1206. 

  1206. 			$product_final_price = round( ($product_price *($my_taxrate+1)), 2 );
    1207. 

  1207. 

  1208. 			$vendor_id = $ps_vendor_id;
    1209. 

  1209. 			
    1210. 

  1210. 			$fields = array('order_id' => $order_id, 
    1211. 

  1211. 									'user_info_id' => $d["ship_to_info_id"],
    1212. 

  1212. 									'vendor_id' => $vendor_id, 
    1213. 

  1213. 									'product_id' => $cart[$i]["product_id"], 
    1214. 

  1214. 									'order_item_sku' => $dboi->f("product_sku"), 
    1215. 

  1215. 									'order_item_name' => $dboi->f("product_name"), 
    1216. 

  1216. 									'product_quantity' => $cart[$i]["quantity"], 
    1217. 

  1217. 									'product_item_price' => $product_price, 
    1218. 

  1218. 									'product_final_price' => $product_final_price, 		
    1219. 

  1219. 									'order_item_currency' => $GLOBALS['product_currency'],
    1220. 

  1220. 									'order_status' => 'P', 
    1221. 

  1221. 									'product_attribute' => $description, 
    1222. 

  1222. 									'cdate' => $timestamp, 
    1223. 

  1223. 									'mdate' => $timestamp
    1224. 

  1224. 						);
    1225. 

  1225. 			$db->buildQuery( 'INSERT', '#__{vm}_order_item', $fields );
    1226. 

  1226. 			$db->query();
    1227. 

  1227. 

  1228. 			// Update Stock Level and Product Sales, decrease - no matter if in stock or not!
    1229. 

  1229. 			$q = "UPDATE #__{vm}_product ";
    1230. 

  1230. 			$q .= "SET product_in_stock = product_in_stock - ".(int)$cart[$i]["quantity"];
    1231. 

  1231. 			$q .= " WHERE product_id = '" . $cart[$i]["product_id"]. "'";
    1232. 

  1232. 			$db->query($q);
    1233. 

  1233. 

  1234. 			$q = "UPDATE #__{vm}_product ";
    1235. 

  1235. 			$q .= "SET product_sales= product_sales + ".(int)$cart[$i]["quantity"];
    1236. 

  1236. 			$q .= " WHERE product_id='".$cart[$i]["product_id"]."'";
    1237. 

  1237. 			$db->query($q);
    1238. 

  1238. 

  1239. 		}
    1240. 

  1240. 

  1241. 		######## BEGIN DOWNLOAD MOD ###############
    1242. 

  1242. 		if( ENABLE_DOWNLOADS == "1" ) {
    1243. 

  1243. 			require_once( CLASSPATH.'ps_order.php');
    1244. 

  1244. 			for($i = 0; $i < $cart["idx"]; $i++) {
    1245. 

  1245. 				
    1246. 

  1246. 				$params = array('product_id' => $cart[$i]["product_id"], 'order_id' => $order_id, 'user_id' => $auth["user_id"] );
    1247. 

  1247. 				ps_order::insert_downloads_for_product( $params );
    1248. 

  1248. 				
    1249. 

  1249. 				if( @VM_DOWNLOADABLE_PRODUCTS_KEEP_STOCKLEVEL == '1' ) {
    1250. 

  1250. 					// Update the product stock level back to where it was.
    1251. 

  1251. 					$q = "UPDATE #__{vm}_product ";
    1252. 

  1252. 					$q .= "SET product_in_stock = product_in_stock + ".(int)$cart[$i]["quantity"];
    1253. 

  1253. 					$q .= " WHERE product_id = '" .(int)$cart[$i]["product_id"]. "'";
    1254. 

  1254. 					$db->query($q);
    1255. 

  1255. 				}
    1256. 

  1256. 			}
    1257. 

  1257. 		}
    1258. 

  1258. 		################## END DOWNLOAD MOD ###########
    1259. 

  1259. 

  1260. 		if (AFFILIATE_ENABLE == '1') {
    1261. 

  1261. 			$ps_affiliate->register_sale($order_id);
    1262. 

  1262. 		}
    1263. 

  1263. 		// Export the order_id so the checkout complete page can get it
    1264. 

  1264. 		$d["order_id"] = $order_id;
    1265. 

  1265. 

  1266. 		/*
    1267. 

  1267. 		 * Let the shipping module know which shipping method
    1268. 

  1268. 		 * was selected.  This way it can save any information
    1269. 

  1269. 		 * it might need later to print a shipping label.
    1270. 

  1270. 		 */
    1271. 

  1271. 		if( is_callable( array($this->_SHIPPING, 'save_rate_info') )) {
    1272. 

  1272. 			$this->_SHIPPING->save_rate_info($d);
    1273. 

  1273. 		}
    1274. 

  1274. 

  1275. 		// Now as everything else has been done, we can update
    1276. 

  1276. 		// the Order Status if the Payment Method is
    1277. 

  1277. 		// "Use Payment Processor", because:
    1278. 

  1278. 		// Payment Processors return false on any error
    1279. 

  1279. 		// Only completed payments return true!
    1280. 

  1280. 		
    1281. 

  1281. 		$update_order = false;
    1282. 

  1282. 		if( $enable_processor == "Y" || $enable_processor == 'B' ) {
    1283. 

  1283. 			if( defined($_PAYMENT->payment_code.'_VERIFIED_STATUS')) {
    1284. 

  1284.               	$d['order_status'] = constant($_PAYMENT->payment_code.'_VERIFIED_STATUS');
    1285. 

  1285.               	$update_order = true;
    1286. 

  1286.             }
    1287. 

  1287.         } elseif( $order_total == 0.00 ) {
    1288. 

  1288.     	// If the Order Total is zero, we can confirm the order to automatically enable the download
    1289. 

  1289.     	$d['order_status'] = ENABLE_DOWNLOAD_STATUS;
    1290. 

  1290.     	$update_order = true;
    1291. 

  1291.         }
    1292. 

  1292. 		if ( $update_order ) {
    1293. 

  1293. 			require_once(CLASSPATH."ps_order.php");
    1294. 

  1294. 			$ps_order =& new ps_order();
    1295. 

  1295. 			$ps_order->order_status_update($d);
    1296. 

  1296. 		}
    1297. 

  1297. 		
    1298. 

  1298. 		
    1299. 

  1299. 		//Remove bank account details
    1300. 

  1300. 		require_once( CLASSPATH . 'ps_user.php' );
    1301. 

  1301. 		$fields = array( 'bank_account_holder' => '',
    1302. 

  1302. 				'bank_account_nr' => '',
    1303. 

  1303. 				'bank_sort_code' => '',
    1304. 

  1304. 				'bank_name' => '',
    1305. 

  1305. 				'bank_iban' => ''
    1306. 

  1306. 				);
    1307. 

  1307. 		ps_user::setUserInfo( $fields, $auth["user_id"] );
    1308. 

  1308. 		
    1309. 

  1309. 

  1310. 		// Send the e-mail confirmation messages
    1311. 

  1311. 		$this->email_receipt($order_id, '', $hasPaid);
    1312. 

  1312. 

  1313. 		// Reset the cart (=empty it)
    1314. 

  1314. 		$ps_cart->reset();
    1315. 

  1315.         $_SESSION['savedcart']['idx']=0;
    1316. 

  1316.         $ps_cart->saveCart();
    1317. 

  1317. 		
    1318. 

  1318. 		// Unset the payment_method variables
    1319. 

  1319. 		$d["payment_method_id"] = "";
    1320. 

  1320. 		$d["order_payment_number"] = "";
    1321. 

  1321. 		$d["order_payment_expire"] = "";
    1322. 

  1322. 		$d["order_payment_name"] = "";
    1323. 

  1323. 		$d["credit_card_code"] = "";
    1324. 

  1324. 		// Clear the sensitive Session data
    1325. 

  1325. 		$_SESSION['ccdata']['order_payment_name']  = "";
    1326. 

  1326. 		$_SESSION['ccdata']['order_payment_number']  = "";
    1327. 

  1327. 		$_SESSION['ccdata']['order_payment_expire_month'] = "";
    1328. 

  1328. 		$_SESSION['ccdata']['order_payment_expire_year'] = "";
    1329. 

  1329. 		$_SESSION['ccdata']['credit_card_code'] = "";
    1330. 

  1330. 		$_SESSION['coupon_discount'] = "";
    1331. 

  1331. 		$_SESSION['coupon_id'] = "";
    1332. 

  1332. 		$_SESSION['coupon_redeemed'] = false;
    1333. 

  1333. 		
    1334. 

  1334. 		$_POST["payment_method_id"] = "";
    1335. 

  1335. 		$_POST["order_payment_number"] = "";
    1336. 

  1336. 		$_POST["order_payment_expire"] = "";
    1337. 

  1337. 		$_POST["order_payment_name"] = "";
    1338. 

  1338. 		
    1339. 

  1339. 		//Clear the booking data from the session		
    1340. 

  1340. 		$ps_booking->removeSession();
    1341. 

  1341. 		
    1342. 

  1342. 		if( empty($my->id) && !empty( $auth['user_id'])) {
    1343. 

  1343. 			require_once(CLASSPATH.'ps_user.php');
    1344. 

  1344. 			ps_user::logout();
    1345. 

  1345. 		}
    1346. 

  1346. 		
    1347. 

  1347. 		return True;
    1348. 

  1348. 	}
    1349. 

  1349. 

  1350. 	/**
    1351. 

  1351. 	 * Create an order number using the session id, session
    1352. 

  1352. 	 * name, and the current unix timestamp.
    1353. 

  1353. 	 *
    1354. 

  1354. 	 * @return string
    1355. 

  1355. 	 */
    1356. 

  1356. 	function get_order_number() {
    1357. 

  1357. 		global $auth;
    1358. 

  1358. 

  1359. 		/* Generated a unique order number */
    1360. 

  1360. 

  1361. 		$str = session_id();
    1362. 

  1362. 		$str .= (string)time();
    1363. 

  1363. 

  1364. 		$order_number = $auth['user_id'] .'_'. md5($str);
    1365. 

  1365. 

  1366. 		return substr($order_number, 0, 32);
    1367. 

  1367. 	}
    1368. 

  1368. 	/**
    1369. 

  1369.          * Stores the md5 hash of the recent cart in the var _cartHash
    1370. 

  1370.          *
    1371. 

  1371.          */
    1372. 

  1372. 	function generate_cart_hash() {
    1373. 

  1373. 		$this->_cartHash = $this->get_new_cart_hash();
    1374. 

  1374. 	}
    1375. 

  1375. 	
    1376. 

  1376. 	function get_order_total( &$d ) {
    1377. 

  1377. 		global $discount_factor;
    1378. 

  1378. 		$totals = $this->calc_order_totals($d);
    1379. 

  1379. 		return $totals['order_total'];
    1380. 

  1380. 	}
    1381. 

  1381. 	
    1382. 

  1382. 	/**
    1383. 

  1383. 	 * Calculates the current order totals and fills an array with all the values
    1384. 

  1384. 	 *
    1385. 

  1385. 	 * @param array $d
    1386. 

  1386. 	 * @return array
    1387. 

  1387. 	 */
    1388. 

  1388. 	function calc_order_totals( &$d ) {
    1389. 

  1389. 		global $discount_factor, $mosConfig_offset, $ps_booking;
    1390. 

  1390. 		
    1391. 

  1391. 		$totals = array();
    1392. 

  1392. 		
    1393. 

  1393. 		/* sets _subtotal */
    1394. 

  1394. 		$totals['order_subtotal'] = $tmp_subtotal = $this->calc_order_subtotal($d);
    1395. 

  1395. 		
    1396. 

  1396. 		$totals['order_taxable'] = $this->calc_order_taxable($d);
    1397. 

  1397. 

  1398. 		/* DISCOUNT HANDLING */
    1399. 

  1399. 		if( !empty($_SESSION['coupon_discount']) ) {
    1400. 

  1400. 			$totals['coupon_discount'] = floatval($_SESSION['coupon_discount']);
    1401. 

  1401. 		}
    1402. 

  1402. 		else {
    1403. 

  1403. 			$totals['coupon_discount'] = 0.00;
    1404. 

  1404. 		}
    1405. 

  1405. 

  1406. 		// make sure Total doesn't become negative
    1407. 

  1407. 		if( $tmp_subtotal < 0 ) $totals['order_subtotal'] = $tmp_subtotal = 0;
    1408. 

  1408. 		if( $totals['order_taxable'] < 0 ) $totals['order_taxable'] = 0;
    1409. 

  1409. 

  1410. 		// from now on we have $order_tax_details
    1411. 

  1411. 		$d['order_tax'] = $totals['order_tax'] = round( $this->calc_order_tax($totals['order_taxable'], $d), 2 );
    1412. 

  1412. 		
    1413. 

  1413. 		if( is_object($this->_SHIPPING) ) {
    1414. 

  1414. 			/* sets _shipping */
    1415. 

  1415. 			$d['order_shipping'] = $totals['order_shipping'] = round( $this->calc_order_shipping( $d ), 2 );
    1416. 

  1416. 

  1417. 			/* sets _shipping_tax
    1418. 

  1418. 			* btw: This is WEIRD! To get an exactly rounded value we have to convert
    1419. 

  1419. 			* the amount to a String and call "round" with the string. */
    1420. 

  1420. 			$d['order_shipping_tax'] = $totals['order_shipping_tax'] = round( strval($this->calc_order_shipping_tax($d)), 2 );
    1421. 

  1421. 		}
    1422. 

  1422. 		else {
    1423. 

  1423. 			$d['order_shipping'] = $totals['order_shipping'] = $totals['order_shipping_tax'] = $d['order_shipping_tax'] = 0.00;
    1424. 

  1424. 		}		
    1425. 

  1425. 

  1426. 		if( !empty($d['payment_method_id'])) {
    1427. 

  1427. 			$totals['payment_discount'] = $d['payment_discount'] = $this->get_payment_discount($d['payment_method_id'], $tmp_subtotal);
    1428. 

  1428. 		} else {
    1429. 

  1429. 			$totals['payment_discount'] = $d['payment_discount'] = 0.00;
    1430. 

  1430. 		}
    1431. 

  1431. 

  1432. 		$d['order_total'] = $totals['order_total'] = 	$tmp_subtotal 
    1433. 

  1433. 											+ $totals['order_tax']
    1434. 

  1434. 											+ $totals['order_shipping']
    1435. 

  1435. 											+ $totals['order_shipping_tax'];		
    1436. 

  1436. 		
    1437. 

  1437. 		/**
    1438. 

  1438. 		 * Virtuebook: add on order totals
    1439. 

  1439. 		 */
    1440. 

  1440. 		$totals['order_subtotal'] += $ps_booking->subtotal;
    1441. 

  1441. 		$totals['order_total'] += $ps_booking->total;
    1442. 

  1442. 		$totals['order_tax'] += $ps_booking->tax;
    1443. 

  1443. 		$totals['order_taxable'] = $ps_booking->tax > 0 || $totals['order_taxable'];
    1444. 

  1444. 		
    1445. 

  1445. 		/**
    1446. 

  1446. 		 * Get the payment stages
    1447. 

  1447. 		 */
    1448. 

  1448. 		$payment_stages = $ps_booking->getStagePayment($order_total, $d['payment_method_id']);
    1449. 

  1449. 		if(isset($payment_stages->amount_due)){
    1450. 

  1450. 			$totals['order_total_due'] = $payment_stages->amount_due - $totals['coupon_discount'];			
    1451. 

  1451. 		}else{
    1452. 

  1452. 			$totals['order_total_due'] = $totals['order_total'] = $totals['order_total'] - $this->get_payment_discount($d['payment_method_id'], $totals['order_total']) - $totals['coupon_discount'];
    1453. 

  1453. 		}
    1454. 

  1454. 

  1455. 		return $totals;
    1456. 

  1456. 	}
    1457. 

  1457. 	/**
    1458. 

  1458.          * Generates the md5 hash of the recent cart / checkout constellation
    1459. 

  1459.          *
    1460. 

  1460.          * @return unknown
    1461. 

  1461.          */
    1462. 

  1462. 	function get_new_cart_hash() {
    1463. 

  1463. 

  1464. 		return md5( print_r( $_SESSION['cart'], true)
    1465. 

  1465. 		. vmGet($_REQUEST,'shipping_rate_id')
    1466. 

  1466. 		. vmGet($_REQUEST,'payment_method_id')
    1467. 

  1467. 		);
    1468. 

  1468. 

  1469. 	}
    1470. 

  1470. 

  1471. 	/**
    1472. 

  1472.          * Returns the recent subtotal
    1473. 

  1473.          *
    1474. 

  1474.          * @param array $d
    1475. 

  1475.          * @return float The current order subtotal
    1476. 

  1476.          */
    1477. 

  1477. 	function get_order_subtotal( &$d ) {
    1478. 

  1478. 

  1479. 		if( $this->_subtotal === null ) {
    1480. 

  1480. 			$this->_subtotal = $this->calc_order_subtotal( $d );
    1481. 

  1481. 		}
    1482. 

  1482. 		else {
    1483. 

  1483. 			if( $this->_cartHash != $this->get_new_cart_hash() ) {
    1484. 

  1484. 				// Need to re-calculate the subtotal
    1485. 

  1485. 				$this->_subtotal = $this->calc_order_subtotal( $d );
    1486. 

  1486. 			}
    1487. 

  1487. 		}
    1488. 

  1488. 		return $this->_subtotal;
    1489. 

  1489. 	}
    1490. 

  1490. 

  1491. 	/**************************************************************************
    1492. 

  1492. 	** name: calc_order_subtotal()
    1493. 

  1493. 	** created by: gday
    1494. 

  1494. 	** description:  Calculate the order subtotal for the current order.
    1495. 

  1495. 	**               Does not include tax or shipping charges.
    1496. 

  1496. 	** parameters: $d
    1497. 

  1497. 	** returns: sub total for this order
    1498. 

  1498. 	***************************************************************************/
    1499. 

  1499. 	function calc_order_subtotal( &$d ) {
    1500. 

  1500. 		global $order_tax_details;
    1501. 

  1501. 		
    1502. 

  1502. 		$order_tax_details = array();
    1503. 

  1503. 		$d['order_subtotal_withtax'] = 0;
    1504. 

  1504. 		$d['payment_discount'] = 0;
    1505. 

  1505. 		$auth = $_SESSION['auth'];
    1506. 

  1506. 		$cart = $_SESSION['cart'];
    1507. 

  1507. 		$order_subtotal = 0;
    1508. 

  1508. 

  1509. 		require_once(CLASSPATH.'ps_product.php');
    1510. 

  1510. 		$ps_product= new ps_product;
    1511. 

  1511. 

  1512. 		for($i = 0; $i < $cart["idx"]; $i++) {
    1513. 

  1513. 			$my_taxrate = $ps_product->get_product_taxrate($cart[$i]["product_id"] );
    1514. 

  1514. 			$price = $ps_product->get_adjusted_attribute_price($cart[$i]["product_id"], $cart[$i]["description"]);
    1515. 

  1515. 			$product_price = $product_price_tmp = $GLOBALS['CURRENCY']->convert( $price["product_price"], @$price["product_currency"] );
    1516. 

  1516. 			
    1517. 

  1517. 			if( $auth["show_price_including_tax"] == 1 ) {
    1518. 

  1518. 				$product_price = round( ($product_price *($my_taxrate+1)), 2 );
    1519. 

  1519. 				$product_price *= $cart[$i]["quantity"];
    1520. 

  1520. 				
    1521. 

  1521. 				$d['order_subtotal_withtax'] += $product_price;
    1522. 

  1522. 				$product_price = $product_price /($my_taxrate+1);
    1523. 

  1523. 				$order_subtotal += $product_price;
    1524. 

  1524. 				
    1525. 

  1525. 			}
    1526. 

  1526. 			else {
    1527. 

  1527. 				$order_subtotal += $product_price * $cart[$i]["quantity"];
    1528. 

  1528. 				
    1529. 

  1529. 				$product_price = round( ($product_price *($my_taxrate+1)), 2 );
    1530. 

  1530. 				$product_price *= $cart[$i]["quantity"];
    1531. 

  1531. 				$d['order_subtotal_withtax'] += $product_price;
    1532. 

  1532. 				$product_price = $product_price /($my_taxrate+1);
    1533. 

  1533. 			}
    1534. 

  1534. 			if( MULTIPLE_TAXRATES_ENABLE ) {
    1535. 

  1535. 				// Calculate the amounts for each tax rate
    1536. 

  1536. 				if( !isset( $order_tax_details[$my_taxrate] )) {
    1537. 

  1537. 					$order_tax_details[$my_taxrate] = 0;
    1538. 

  1538. 				}
    1539. 

  1539. 				$order_tax_details[$my_taxrate] += $product_price_tmp*$my_taxrate*$cart[$i]["quantity"];
    1540. 

  1540. 			}
    1541. 

  1541. 		}
    1542. 

  1542. 

  1543. 		return($order_subtotal);
    1544. 

  1544. 	}
    1545. 

  1545. 

  1546. 

  1547. 	/**
    1548. 

  1548. 	 * Calculates the taxable order subtotal for the order.
    1549. 

  1549. 	 * If an item has no weight, it is non taxable.
    1550. 

  1550. 	 * @author Chris Coleman
    1551. 

  1551. 	 * @param array $d
    1552. 

  1552. 	 * @return float Subtotal
    1553. 

  1553. 	 */
    1554. 

  1554. 	function calc_order_taxable($d) {
    1555. 

  1555. 		$auth = $_SESSION['auth'];
    1556. 

  1556. 		$cart = $_SESSION['cart'];
    1557. 

  1557. 

  1558. 		$subtotal = 0.0;
    1559. 

  1559. 		
    1560. 

  1560. 		require_once(CLASSPATH.'ps_product.php');
    1561. 

  1561. 		$ps_product= new ps_product;
    1562. 

  1562. 		require_once(CLASSPATH.'ps_shipping_method.php');
    1563. 

  1563. 

  1564. 		$db = new ps_DB;
    1565. 

  1565. 

  1566. 		for($i = 0; $i < $cart["idx"]; $i++) {
    1567. 

  1567. 			$price = $ps_product->get_adjusted_attribute_price($cart[$i]["product_id"], $cart[$i]["description"]);
    1568. 

  1568. 			$product_price = $GLOBALS['CURRENCY']->convert( $price["product_price"], $price['product_currency'] );
    1569. 

  1569. 			$item_weight = ps_shipping_method::get_weight($cart[$i]["product_id"]) * $cart[$i]['quantity'];
    1570. 

  1570. 

  1571. 			if ($item_weight != 0 or TAX_VIRTUAL=='1') {
    1572. 

  1572. 				$subtotal += $product_price * $cart[$i]["quantity"];
    1573. 

  1573. 			}
    1574. 

  1574. 		}
    1575. 

  1575. 		return($subtotal);
    1576. 

  1576. 	}
    1577. 

  1577. 	
    1578. 

  1578. 	/**
    1579. 

  1579. 	 * Calculate the tax charges for the current order.
    1580. 

  1580. 	 * You can switch the way, taxes are calculated:
    1581. 

  1581. 	 * either based on the VENDOR address,
    1582. 

  1582. 	 * or based on the ship-to address.
    1583. 

  1583. 	 * ! Creates the global $order_tax_details
    1584. 

  1584. 	 *
    1585. 

  1585. 	 * @param float $order_taxable
    1586. 

  1586. 	 * @param array $d
    1587. 

  1587. 	 * @return float
    1588. 

  1588. 	 */
    1589. 

  1589. 	function calc_order_tax($order_taxable, $d) {
    1590. 

  1590. 		global $order_tax_details, $discount_factor;
    1591. 

  1591. 		$auth = $_SESSION['auth'];
    1592. 

  1592. 		$ps_vendor_id = $_SESSION["ps_vendor_id"];
    1593. 

  1593. 		$db = new ps_DB;
    1594. 

  1594. 		$ship_to_info_id = vmGet( $_REQUEST, 'ship_to_info_id');
    1595. 

  1595. 		
    1596. 

  1596. 		
    1597. 

  1597. 		require_once(CLASSPATH.'ps_tax.php');
    1598. 

  1598. 		$ps_tax = new ps_tax;
    1599. 

  1599. 		
    1600. 

  1600. 		$discount_factor = 1;
    1601. 

  1601. 		
    1602. 

  1602. 		// Shipping address based TAX
    1603. 

  1603. 		if ( !ps_checkout::tax_based_on_vendor_address () ) {
    1604. 

  1604. 			$q = "SELECT state, country FROM #__{vm}_user_info ";
    1605. 

  1605. 			$q .= "WHERE user_info_id='".$ship_to_info_id. "'";
    1606. 

  1606. 			$db->query($q);
    1607. 

  1607. 			$db->next_record();
    1608. 

  1608. 			$state = $db->f("state");
    1609. 

  1609. 			$country = $db->f("country");
    1610. 

  1610. 			$q = "SELECT * FROM #__{vm}_tax_rate WHERE tax_country='$country' ";
    1611. 

  1611. 			if( $state ) {
    1612. 

  1612. 				$q .= "AND tax_state='$state'";
    1613. 

  1613. 			}
    1614. 

  1614. 			$db->query($q);
    1615. 

  1615. 			if ($db->next_record()) {
    1616. 

  1616. 				$rate = $order_taxable * floatval( $db->f("tax_rate") );
    1617. 

  1617. 				if (empty($rate)) {
    1618. 

  1618. 					$order_tax = 0.0;
    1619. 

  1619. 				}
    1620. 

  1620. 				else {
    1621. 

  1621. 					$order_tax = $rate;
    1622. 

  1622. 				}
    1623. 

  1623. 			}
    1624. 

  1624. 			else {
    1625. 

  1625. 				$order_tax = 0.0;
    1626. 

  1626. 			}
    1627. 

  1627. 			$order_tax_details[$db->f('tax_rate')] = $order_tax;
    1628. 

  1628. 		}
    1629. 

  1629. 		// Store Owner Address based TAX
    1630. 

  1630. 		else {
    1631. 

  1631. 

  1632. 				// Calculate the Tax with a tax rate for every product
    1633. 

  1633. 				$cart = $_SESSION['cart'];
    1634. 

  1634. 				$order_tax = 0.0;
    1635. 

  1635. 				$total = 0.0;
    1636. 

  1636. 				if( (!empty( $_SESSION['coupon_discount'] ) || !empty( $d['payment_discount'] ))
    1637. 

  1637. 					&& PAYMENT_DISCOUNT_BEFORE == '1' ) {
    1638. 

  1638. 					// We need to recalculate the tax details when the discounts are applied
    1639. 

  1639. 					// BEFORE taxes - because they affect the product subtotals then
    1640. 

  1640. 					$order_tax_details = array();
    1641. 

  1641. 				}
    1642. 

  1642. 				require_once(CLASSPATH.'ps_product.php');
    1643. 

  1643. 				$ps_product= new ps_product;
    1644. 

  1644. 				require_once(CLASSPATH.'ps_shipping_method.php');
    1645. 

  1645. 

  1646. 				for($i = 0; $i < $cart["idx"]; $i++) {
    1647. 

  1647. 					$item_weight = ps_shipping_method::get_weight($cart[$i]["product_id"]) * $cart[$i]['quantity'];
    1648. 

  1648. 

  1649. 					if ($item_weight !=0 or TAX_VIRTUAL) {
    1650. 

  1650. 						$price = $ps_product->get_adjusted_attribute_price($cart[$i]["product_id"], $cart[$i]["description"]);
    1651. 

  1651. 						$price['product_price'] = $GLOBALS['CURRENCY']->convert( $price['product_price'], $price['product_currency']);
    1652. 

  1652. 						$tax_rate = $ps_product->get_product_taxrate($cart[$i]["product_id"]);
    1653. 

  1653. 						
    1654. 

  1654. 						if( (!empty( $_SESSION['coupon_discount'] ) || !empty( $d['payment_discount'] ))
    1655. 

  1655. 							&& PAYMENT_DISCOUNT_BEFORE == '1' ) {
    1656. 

  1656. 							$use_coupon_discount= @$_SESSION['coupon_discount'];
    1657. 

  1657. 							if( !empty( $_SESSION['coupon_discount'] )) {
    1658. 

  1658. 								if( $auth["show_price_including_tax"] == 1 ) {
    1659. 

  1659. 									$use_coupon_discount = $_SESSION['coupon_discount'] / ($tax_rate+1);
    1660. 

  1660. 								}
    1661. 

  1661. 							}
    1662. 

  1662. 							$factor = (100 * ($use_coupon_discount + @$d['payment_discount'])) / $this->_subtotal;
    1663. 

  1663. 							$price["product_price"] = $price["product_price"] - ($factor * $price["product_price"] / 100);
    1664. 

  1664. 							@$order_tax_details[$tax_rate] += $price["product_price"] * $tax_rate * $cart[$i]["quantity"];
    1665. 

  1665. 						}
    1666. 

  1666. 						
    1667. 

  1667. 						$order_tax += $price["product_price"] * $tax_rate * $cart[$i]["quantity"];
    1668. 

  1668. 						$total += $price["product_price"] * $cart[$i]["quantity"];
    1669. 

  1669. 					}
    1670. 

  1670. 				}
    1671. 

  1671. 

  1672. 				if( (!empty( $_SESSION['coupon_discount'] ) || !empty( $d['payment_discount'] ))
    1673. 

  1673. 					&& PAYMENT_DISCOUNT_BEFORE != '1' ) {
    1674. 

  1674. 						
    1675. 

  1675. 					// Here we need to re-calculate the Discount
    1676. 

  1676. 					// because we assume the Discount is "including Tax"
    1677. 

  1677. 					$discounted_total = @$d['order_subtotal_withtax'] - @$_SESSION['coupon_discount'] - @$d['payment_discount'];
    1678. 

  1678. 					
    1679. 

  1679. 					if( $discounted_total != @$d['order_subtotal_withtax'] && @$d['order_subtotal_withtax'] > 0.00) {
    1680. 

  1680. 						$discount_factor = $discounted_total / $d['order_subtotal_withtax'];
    1681. 

  1681. 						
    1682. 

  1682. 						foreach( $order_tax_details as $rate => $value ) {
    1683. 

  1683. 							$order_tax_details[$rate] = $value * $discount_factor;
    1684. 

  1684. 						}
    1685. 

  1685. 					}
    1686. 

  1686. 					
    1687. 

  1687. 				}
    1688. 

  1688. 				if( is_object($this->_SHIPPING) ) {
    1689. 

  1689. 					$taxrate = $this->_SHIPPING->get_tax_rate();
    1690. 

  1690. 					if( $taxrate ) {
    1691. 

  1691. 						$rate = $this->_SHIPPING->get_rate( $d );
    1692. 

  1692. 						if( $auth["show_price_including_tax"] == 1 ) {
    1693. 

  1693. 							@$order_tax_details[$taxrate] += $rate - ($rate / ($taxrate+1));
    1694. 

  1694. 						}
    1695. 

  1695. 						else {
    1696. 

  1696. 							@$order_tax_details[$taxrate] += $rate * $taxrate;
    1697. 

  1697. 						}
    1698. 

  1698. 					}
    1699. 

  1699. 				}
    1700. 

  1700. 

  1701. 

  1702. 		}
    1703. 

  1703. 		return( round( $order_tax, 2 ) );
    1704. 

  1704. 	}
    1705. 

  1705.   
    1706. 

  1706. 	/**************************************************************************
    1707. 

  1707. 	** name: calc_order_shipping()
    1708. 

  1708. 	** created by: soeren
    1709. 

  1709. 	** description:  Get the Shipping costs WITHOUT TAX
    1710. 

  1710. 	** parameters: $d,
    1711. 

  1711. 	** returns: a decimal number, excluding taxes
    1712. 

  1712. 	***************************************************************************/
    1713. 

  1713. 	function calc_order_shipping( &$d ) {
    1714. 

  1714. 

  1715. 		$auth = $_SESSION['auth'];
    1716. 

  1716. 

  1717. 		$shipping_total = $this->_SHIPPING->get_rate( $d );
    1718. 

  1718. 		$shipping_taxrate = $this->_SHIPPING->get_tax_rate();
    1719. 

  1719. 

  1720. 		// When the Shipping rate is shown including Tax
    1721. 

  1721. 		// we have to extract the Tax from the Shipping Total
    1722. 

  1722. 		// before returning the value
    1723. 

  1723. 		if( $auth["show_price_including_tax"] == 1 ) {
    1724. 

  1724. 			$d['shipping_tax'] = $shipping_total - ($shipping_total / ($shipping_taxrate+1));
    1725. 

  1725. 			$d['shipping_total'] = $shipping_total - $d['shipping_tax'];
    1726. 

  1726. 		}
    1727. 

  1727. 		else {
    1728. 

  1728. 			$d['shipping_tax'] = $shipping_total * $shipping_taxrate;
    1729. 

  1729. 			$d['shipping_total'] = $shipping_total;
    1730. 

  1730. 		}
    1731. 

  1731. 		$d['shipping_tax'] = $GLOBALS['CURRENCY']->convert( $d['shipping_tax'] );
    1732. 

  1732. 		$d['shipping_total'] = $GLOBALS['CURRENCY']->convert( $d['shipping_total'] );
    1733. 

  1733. 		
    1734. 

  1734. 		return $d['shipping_total'];
    1735. 

  1735. 	}
    1736. 

  1736. 

  1737. 

  1738. 

  1739. 

  1740. 	/**************************************************************************
    1741. 

  1741. 	** name: calc_order_shipping_tax()
    1742. 

  1742. 	** created by: Soeren
    1743. 

  1743. 	** description:  Calculate the tax for the shipping of the current order
    1744. 

  1744. 	** Assumes that the function calc_order_shipping has been called before
    1745. 

  1745. 	** parameters: $d
    1746. 

  1746. 	** returns: Tax for the shipping of this order
    1747. 

  1747. 	***************************************************************************/
    1748. 

  1748. 	function calc_order_shipping_tax($d) {
    1749. 

  1749. 

  1750. 		return $d['shipping_tax'];
    1751. 

  1751. 

  1752. 	}
    1753. 

  1753. 

  1754. 	/**************************************************************************
    1755. 

  1755. 	** name: get_vendor_currency()
    1756. 

  1756. 	** created by: gday
    1757. 

  1757. 	** description:  Get the currency type used by the $vendor_id
    1758. 

  1758. 	** parameters: $vendor_id - vendor id to return currency type
    1759. 

  1759. 	** returns: Currency type for this vendor
    1760. 

  1760. 	***************************************************************************/
    1761. 

  1761. 	function get_vendor_currency($vendor_id) {
    1762. 

  1762. 		$db = new ps_DB;
    1763. 

  1763. 

  1764. 		$q = "SELECT vendor_currency FROM #__{vm}_vendor WHERE vendor_id='$vendor_id'";
    1765. 

  1765. 

  1766. 		$db->query($q);
    1767. 

  1767. 		$db->next_record();
    1768. 

  1768. 

  1769. 		$currency = $db->f("vendor_currency");
    1770. 

  1770. 

  1771. 		return($currency);
    1772. 

  1772. 	}
    1773. 

  1773. 

  1774. 

  1775. 	/**************************************************************************
    1776. 

  1776. 	** name: get_payment_discount()
    1777. 

  1777. 	** created by: soeren
    1778. 

  1778. 	** description:  Get the discount for the selected payment
    1779. 

  1779. 	** parameters: $payment_method_id
    1780. 

  1780. 	** returns: Discount as a decimal if found
    1781. 

  1781. 	**          0 if nothing is found
    1782. 

  1782. 	***************************************************************************/
    1783. 

  1783. 	function get_payment_discount( $payment_method_id, $subtotal = '' ) {
    1784. 

  1784. 		global $modulename;
    1785. 

  1785. 		
    1786. 

  1786. 		if( empty( $payment_method_id )) {
    1787. 

  1787. 			return 0;
    1788. 

  1788. 		}
    1789. 

  1789. 		$db = new ps_DB();
    1790. 

  1790. 		//MOD ei
    1791. 

  1791. 		// There is a special payment method, which fee is depend on subtotal
    1792. 

  1792. 		// it is a type of cash on delivery
    1793. 

  1793. 		// comment soeren: Payment methods can implement their own method
    1794. 

  1794. 		// how to calculate the discount: the function "get_payment_rate"
    1795. 

  1795. 		// should return a float value from the payment class
    1796. 

  1796. 		require_once(CLASSPATH.'ps_payment_method.php');
    1797. 

  1797. 		$ps_payment_method = new ps_payment_method;
    1798. 

  1798. 

  1799. 		$payment_class = $ps_payment_method->get_field($payment_method_id, "payment_class");
    1800. 

  1800. 

  1801. 		// Check to see if Payment Class File exists
    1802. 

  1802. 		if (file_exists(CLASSPATH . "payment/$payment_class.php") ) {
    1803. 

  1803. 

  1804. 			require_once( CLASSPATH. "payment/$payment_class.php" );
    1805. 

  1805. 			eval( "\$_PAYMENT = new $payment_class();" );
    1806. 

  1806. 

  1807. 			if(is_callable(array($payment_class, 'get_payment_rate'))) {
    1808. 

  1808. 				return $_PAYMENT->get_payment_rate($subtotal);
    1809. 

  1809. 			}
    1810. 

  1810. 		}
    1811. 

  1811. 		//End of MOD ei
    1812. 

  1812. 

  1813. 		// If a payment method has no special way of calculating a discount,
    1814. 

  1814. 		// let's do this on our own from the payment_method_discount settings
    1815. 

  1815. 		$q = 'SELECT * FROM `#__{vm}_payment_method` WHERE payment_method_id='.$payment_method_id;
    1816. 

  1816. 		$db->query($q);$db->next_record();
    1817. 

  1817. 

  1818. 		$discount = $db->f('payment_method_discount');
    1819. 

  1819. 		$is_percent = $db->f('payment_method_discount_is_percent');
    1820. 

  1820. 		
    1821. 

  1821. 		
    1822. 

  1822. 		$page = vmGet($_REQUEST,'page');
    1823. 

  1823. 		$tmp = explode('.', $page);
    1824. 

  1824. 		$modulename = $tmp[0];
    1825. 

  1825. 		
    1826. 

  1826. 		//Check when we should apply the discount
    1827. 

  1827. 		if($modulename == 'checkout' && !$db->f('payment_method_discount_checkout')) return 0;
    1828. 

  1828. 		else if($modulename == 'account' && !$db->f('payment_method_discount_stages')) return 0;
    1829. 

  1829. 

  1830. 		if( !$is_percent ) {
    1831. 

  1831. 			// Standard method: absolute amount
    1832. 

  1832. 			if (!empty($discount)) {
    1833. 

  1833. 				return(floatval( $GLOBALS['CURRENCY']->convert($discount)));
    1834. 

  1834. 			}
    1835. 

  1835. 			else {
    1836. 

  1836. 				return(0);
    1837. 

  1837. 			}
    1838. 

  1838. 		}
    1839. 

  1839. 		else {
    1840. 

  1840. 

  1841. 			if( $subtotal === '') {
    1842. 

  1842. 				$subtotal = $this->get_order_subtotal( $vars );
    1843. 

  1843. 			}
    1844. 

  1844. 

  1845. 			// New: percentage of the subtotal, limited by minimum and maximum
    1846. 

  1846. 			$max = $db->f('payment_method_discount_max_amount');
    1847. 

  1847. 			$min = $db->f('payment_method_discount_min_amount');
    1848. 

  1848. 			$value = (float) ($discount/100) * $subtotal;
    1849. 

  1849. 

  1850. 			if( abs($value) > $max && $max > 0 ) {
    1851. 

  1851. 				$value = -$max;
    1852. 

  1852. 			}
    1853. 

  1853. 			elseif( abs($value) < $min && $min > 0 ) {
    1854. 

  1854. 				$value = -$min;
    1855. 

  1855. 			}
    1856. 

  1856. 			return $value;
    1857. 

  1857. 		}
    1858. 

  1858. 

  1859. 	}
    1860. 

  1860. 

  1861. 	/**
    1862. 

  1862.     * Create a receipt for the current order and email it to
    1863. 

  1863.     * the customer and the vendor.
    1864. 

  1864.     * @author gday
    1865. 

  1865.     * @author soeren
    1866. 

  1866.     * @param int $order_id
    1867. 

  1867.     * @return boolean True on success, false on failure
    1868. 

  1868.     */
    1869. 

  1869. 	function email_receipt($order_id, $subject = '', $hasPaid = 0, $email_customer = 0,	$email_owner = 0, $email_vendor = 0) {
    1870. 

  1870. 		
    1871. 

  1871. 		global $sess, $ps_product, $VM_LANG, $CURRENCY_DISPLAY, $vmLogger,
    1872. 

  1872. 		$mosConfig_fromname, $mosConfig_lang, $database, $ps_booking, $modulename;
    1873. 

  1873. 

  1874. 		$ps_vendor_id = vmGet( $_SESSION, 'ps_vendor_id', 1 );
    1875. 

  1875. 		$auth = $_SESSION["auth"];
    1876. 

  1876. 

  1877. 		require_once( CLASSPATH.'ps_order_status.php');
    1878. 

  1878. 		require_once( CLASSPATH.'ps_userfield.php');
    1879. 

  1879. 		require_once(CLASSPATH.'ps_product.php');
    1880. 

  1880. 		$ps_product = new ps_product;
    1881. 

  1881. 

  1882. 		// Connect to database and gather appropriate order information
    1883. 

  1883. 		$db = new ps_DB;
    1884. 

  1884. 		$q  = "SELECT * FROM #__{vm}_orders WHERE order_id='$order_id'";
    1885. 

  1885. 		$db->query($q);
    1886. 

  1886. 		$db->next_record();
    1887. 

  1887. 		$user_id = $db->f("user_id");
    1888. 

  1888. 		$customer_note = $db->f("customer_note");
    1889. 

  1889. 		$order_status = ps_order_status::getOrderStatusName($db->f("order_status") );
    1890. 

  1890. 		
    1891. 

  1891. 		$dbbt = new ps_DB;
    1892. 

  1892. 		$dbst = new ps_DB;
    1893. 

  1893. 

  1894. 		$qt = "SELECT * FROM #__{vm}_user_info WHERE user_id='".$user_id."' AND address_type='BT'";
    1895. 

  1895. 		$dbbt->query($qt);
    1896. 

  1896. 		$dbbt->next_record();
    1897. 

  1897. 

  1898. 		$qt = "SELECT * FROM #__{vm}_user_info WHERE user_info_id='". $db->f("user_info_id") . "'";
    1899. 

  1899. 		$dbst->query($qt);
    1900. 

  1900. 		$dbst->next_record();
    1901. 

  1901. 

  1902. 		$dbv = new ps_DB;
    1903. 

  1903. 		$qt = "SELECT * from #__{vm}_vendor ";
    1904. 

  1904. 		/* Need to decide on vendor_id <=> order relationship */
    1905. 

  1905. 		$qt .= "WHERE vendor_id = '".$ps_vendor_id."'";
    1906. 

  1906. 		$dbv->query($qt);
    1907. 

  1907. 		$dbv->next_record();
    1908. 

  1908. 

  1909. 		$dboi = new ps_DB;
    1910. 

  1910. 		$q_oi = "SELECT * FROM #__{vm}_product, #__{vm}_order_item, #__{vm}_orders ";
    1911. 

  1911. 		$q_oi .= "WHERE #__{vm}_product.product_id=#__{vm}_order_item.product_id ";
    1912. 

  1912. 		$q_oi .= "AND #__{vm}_order_item.order_id='$order_id' ";
    1913. 

  1913. 		$q_oi .= "AND #__{vm}_orders.order_id=#__{vm}_order_item.order_id";
    1914. 

  1914. 		$dboi->query($q_oi);
    1915. 

  1915. 

  1916. 		$db_payment = new ps_DB;
    1917. 

  1917. 		$q  = "SELECT op.payment_method_id, pm.payment_method_name FROM #__{vm}_order_payment as op, #__{vm}_payment_method as pm
    1918. 

  1918.               WHERE order_id='$order_id' AND op.payment_method_id=pm.payment_method_id";
    1919. 

  1919. 		$db_payment->query($q);
    1920. 

  1920. 		$db_payment->next_record();
    1921. 

  1921. 

  1922. 		if ($auth["show_price_including_tax"] == 1) {
    1923. 

  1923. 

  1924. 			$order_shipping = $db->f("order_shipping");
    1925. 

  1925. 			$order_shipping += $db->f("order_shipping_tax");
    1926. 

  1926. 			$order_shipping_tax = 0;
    1927. 

  1927. 			$order_tax = $db->f("order_tax") + $db->f("order_shipping_tax");
    1928. 

  1928. 		}
    1929. 

  1929. 		else {
    1930. 

  1930. 

  1931. 			$order_shipping = $db->f("order_shipping");
    1932. 

  1932. 			$order_shipping_tax = $db->f("order_shipping_tax");
    1933. 

  1933. 			$order_tax = $db->f("order_tax");
    1934. 

  1934. 		}
    1935. 

  1935. 		$order_total = $db->f("order_total");
    1936. 

  1936. 		$order_discount = $db->f("order_discount");
    1937. 

  1937. 		$coupon_discount = $db->f("coupon_discount");
    1938. 

  1938. 

  1939. 		// Email Addresses for shopper and vendor
    1940. 

  1940. 		// **************************************
    1941. 

  1941. 		$shopper_email = $dbbt->f("user_email");
    1942. 

  1942. 		$shopper_name = $dbbt->f("first_name")." ".$dbbt->f("last_name");
    1943. 

  1943. 

  1944. 		$from_email = $dbv->f("contact_email");
    1945. 

  1945. 

  1946. 		$shopper_subject = $dbv->f("vendor_name") . " ".($subject ? $subject : $VM_LANG->_('PHPSHOP_ORDER_PRINT_PO_LBL',false))." - " . $db->f("order_id");
    1947. 

  1947. 		$vendor_subject = $dbv->f("vendor_name") . " ".($subject ? $subject : $VM_LANG->_('PHPSHOP_ORDER_PRINT_PO_LBL',false))." - " . $db->f("order_id");
    1948. 

  1948. 

  1949. 		$shopper_order_link = str_replace('/administrator/','/',$sess->url( SECUREURL ."index.php?page=account.order_details&order_id=$order_id", true, false ));
    1950. 

  1950. 		$vendor_order_link = $sess->url( SECUREURL ."index2.php?page=order.order_print&order_id=$order_id&pshop_mode=admin", true, false );
    1951. 

  1951. 

  1952. 		/**
    1953. 

  1953. 		 * Prepare the payment information, including Credit Card information when not empty
    1954. 

  1954. 		 */
    1955. 

  1955. 		$payment_info_details = $db_payment->f("payment_method_name");
    1956. 

  1956. 		if( !empty( $_SESSION['ccdata']['order_payment_name'] )
    1957. 

  1957. 			&& !empty($_SESSION['ccdata']['order_payment_number'])) {
    1958. 

  1958. 	  		$payment_info_details .= '<br />'.$VM_LANG->_('PHPSHOP_CHECKOUT_CONF_PAYINFO_NAMECARD',false).': '.$_SESSION['ccdata']['order_payment_name'].'<br />';
    1959. 

  1959. 	  		$payment_info_details .= $VM_LANG->_('PHPSHOP_CHECKOUT_CONF_PAYINFO_CCNUM',false).': '.$this->asterisk_pad($_SESSION['ccdata']['order_payment_number'], 4 ).'<br />';
    1960. 

  1960. 	  		$payment_info_details .= $VM_LANG->_('PHPSHOP_CHECKOUT_CONF_PAYINFO_EXDATE',false).': '.$_SESSION['ccdata']['order_payment_expire_month'].' / '.$_SESSION['ccdata']['order_payment_expire_year'].'<br />';
    1961. 

  1961. 	  		if( !empty($_SESSION['ccdata']['credit_card_code'])) {
    1962. 

  1962. 	  			$payment_info_details .= 'CVV code: '.$_SESSION['ccdata']['credit_card_code'].'<br />';
    1963. 

  1963. 	  		}
    1964. 

  1964. 		}
    1965. 

  1965. 		// Convert HTML into Text
    1966. 

  1966. 		$payment_info_details_text = str_replace( '<br />', "\n", $payment_info_details );
    1967. 

  1967. 		
    1968. 

  1968. 		// Get the Shipping Details
    1969. 

  1969. 		$shipping_arr = explode("|", urldecode(vmGet($_REQUEST,"shipping_rate_id")) );
    1970. 

  1970. 		
    1971. 

  1971. 		// Headers and Footers
    1972. 

  1972. 		// ******************************
    1973. 

  1973. 		// Shopper Header
    1974. 

  1974. 		$shopper_header = $VM_LANG->_('PHPSHOP_CHECKOUT_EMAIL_SHOPPER_HEADER1',false)."\n";
    1975. 

  1975. 		
    1976. 

  1976. 		$legal_info_title = '';
    1977. 

  1977. 		$legal_info_html = '';
    1978. 

  1978. 		// Get the legal information about the returns/order cancellation policy		
    1979. 

  1979. 		if( @VM_ONCHECKOUT_SHOW_LEGALINFO == '1' ) {
    1980. 

  1980. 			$article = intval(@VM_ONCHECKOUT_LEGALINFO_LINK);
    1981. 

  1981. 			if( $article > 0 ) {
    1982. 

  1982. 				$db_legal = new ps_DB();
    1983. 

  1983. 				// Get the content article, which contains the Legal Info
    1984. 

  1984. 				$db_legal->query( 'SELECT id, title, introtext FROM #__content WHERE id='.$article );
    1985. 

  1985. 				$db_legal->next_record();
    1986. 

  1986. 				if( $db_legal->f('introtext') ) {
    1987. 

  1987. 					$legal_info_title = $db_legal->f('title');
    1988. 

  1988. 					$legal_info_text = strip_tags( str_replace( '<br />', "\n", $db_legal->f('introtext') ));
    1989. 

  1989. 					$legal_info_html = $db_legal->f('introtext');
    1990. 

  1990. 				}
    1991. 

  1991. 			}
    1992. 

  1992. 		}
    1993. 

  1993. 		//Shopper Footer
    1994. 

  1994. 		$shopper_footer = "\n\n".$VM_LANG->_('PHPSHOP_CHECKOUT_EMAIL_SHOPPER_HEADER2',false)."\n";
    1995. 

  1995. 		if( VM_REGISTRATION_TYPE != 'NO_REGISTRATION' ) {
    1996. 

  1996. 		$shopper_footer .= "\n\n".$VM_LANG->_('PHPSHOP_CHECKOUT_EMAIL_SHOPPER_HEADER5',false)."\n";
    1997. 

  1997. 		$shopper_footer .= $shopper_order_link;
    1998. 

  1998. 		}
    1999. 

  1999. 		$shopper_footer .= "\n\n".$VM_LANG->_('PHPSHOP_CHECKOUT_EMAIL_SHOPPER_HEADER3',false)."\n";
    2000. 

  2000. 		$shopper_footer .= "Email: " . $from_email;
    2001. 

  2001. 		// New in version 1.0.5
    2002. 

  2002. 		if( @VM_ONCHECKOUT_SHOW_LEGALINFO == '1' && !empty( $legal_info_title )) {
    2003. 

  2003. 			$shopper_footer .= "\n\n____________________________________________\n";
    2004. 

  2004. 			$shopper_footer .= $legal_info_title."\n";
    2005. 

  2005. 			$shopper_footer .= $legal_info_text."\n";
    2006. 

  2006. 		}
    2007. 

  2007. 		
    2008. 

  2008. 		// Vendor Header
    2009. 

  2009. 		switch( $db->f("order_status") ) {
    2010. 

  2010. 			
    2011. 

  2011. 			case 'X' :
    2012. 

  2012. 				$vendor_header = $VM_LANG->_('PHPSHOP_CHECKOUT_EMAIL_SHOPPER_HEADER4a',false)."\n";
    2013. 

  2013. 				break;
    2014. 

  2014. 			
    2015. 

  2015. 			default :
    2016. 

  2016. 				$vendor_header = $VM_LANG->_('PHPSHOP_CHECKOUT_EMAIL_SHOPPER_HEADER4',false)."\n";
    2017. 

  2017. 				break;
    2018. 

  2018. 			
    2019. 

  2019. 		}
    2020. 

  2020. 

  2021. 		// Vendor Footer
    2022. 

  2022. 		$vendor_footer = "\n\n".$VM_LANG->_('PHPSHOP_CHECKOUT_EMAIL_SHOPPER_HEADER5',false)."\n";
    2023. 

  2023. 		$vendor_footer .= $vendor_order_link;
    2024. 

  2024. 

  2025. 		$vendor_email = $from_email;
    2026. 

  2026. 

  2027. 		/////////////////////////////////////
    2028. 

  2028. 		// set up text mail
    2029. 

  2029. 		//
    2030. 

  2030. 

  2031. 		// Main Email Message Purchase Order
    2032. 

  2032. 		// *********************************
    2033. 

  2033. 		$shopper_message  = "\n".$VM_LANG->_('PHPSHOP_ORDER_PRINT_PO_LBL',false)."\n";
    2034. 

  2034. 		$shopper_message .= "------------------------------------------------------------------------\n";
    2035. 

  2035. 		$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_PO_NUMBER',false).": " . $db->f("order_id") . "\n";
    2036. 

  2036. 		$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_PO_DATE',false).":   ";
    2037. 

  2037. 		$shopper_message .= strftime( $VM_LANG->_('DATE_FORMAT_LC'), $db->f("cdate") ) . "\n";
    2038. 

  2038. 		$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_PO_STATUS',false).": ";
    2039. 

  2039. 				
    2040. 

  2040. 		$shopper_message .= $order_status."\n\n";
    2041. 

  2041. 				
    2042. 

  2042. 		// BillTo Fields		
    2043. 

  2043. 		$registrationfields = ps_userfield::getUserFields('registration', false, '', false, true );
    2044. 

  2044. 		foreach( $registrationfields as $field ) {
    2045. 

  2045. 			if( $field->name == 'email') $field->name = 'user_email';
    2046. 

  2046. 			if( $field->name == 'delimiter_sendregistration' || $field->type == 'captcha') continue;
    2047. 

  2047. 			
    2048. 

  2048. 			if( $field->type == 'delimiter') {
    2049. 

  2049. 				$shopper_message .= ($VM_LANG->_($field->title) != '' ? $VM_LANG->_($field->title) : $field->title)."\n";
    2050. 

  2050. 				$shopper_message .= "--------------------\n\n";
    2051. 

  2051. 			} else {
    2052. 

  2052. 				$shopper_message .= ($VM_LANG->_($field->title) != '' ? $VM_LANG->_($field->title) : $field->title).':    ';
    2053. 

  2053. 				$shopper_message .= $dbst->f($field->name) . "\n";
    2054. 

  2054. 			}
    2055. 

  2055. 		}
    2056. 

  2056. 		
    2057. 

  2057. 		// Shipping Fields
    2058. 

  2058. 		$shopper_message .= "\n\n";
    2059. 

  2059. 		$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_SHIP_TO_LBL')."\n";
    2060. 

  2060. 		$shopper_message .= "-------\n\n";
    2061. 

  2061. 		
    2062. 

  2062. 		$shippingfields = ps_userfield::getUserFields('shipping', false, '', false, true );
    2063. 

  2063. 		foreach( $shippingfields as $field ) {			
    2064. 

  2064. 			
    2065. 

  2065. 			if( $field->type == 'delimiter') {
    2066. 

  2066. 				$shopper_message .= ($VM_LANG->_($field->title) != '' ? $VM_LANG->_($field->title) : $field->title)."\n";
    2067. 

  2067. 				$shopper_message .= "--------------------\n\n";
    2068. 

  2068. 			} else {
    2069. 

  2069. 				$shopper_message .= ($VM_LANG->_($field->title) != '' ? $VM_LANG->_($field->title) : $field->title).':    ';
    2070. 

  2070. 				$shopper_message .= $dbst->f($field->name) . "\n";
    2071. 

  2071. 			}
    2072. 

  2072. 		}
    2073. 

  2073. 		
    2074. 

  2074. 		$shopper_message .= "\n\n";
    2075. 

  2075. 

  2076. 		$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_ITEMS_LBL',false)."\n";
    2077. 

  2077. 		$shopper_message .= "-----------";
    2078. 

  2078. 		$sub_total = 0.00;
    2079. 

  2079. 		
    2080. 

  2080. 		/** Organic Mod */
    2081. 

  2081. 		/** Gather the booking details for txt email */
    2082. 

  2082. 		$ps_booking->loadBookingData($order_id);
    2083. 

  2083. 		if($ps_booking->status) {
    2084. 

  2084. 			  	
    2085. 

  2085. 		  	$oldmodulename = $modulename;
    2086. 

  2086. 		  	$modulename = 'booking';
    2087. 

  2087. 		  	
    2088. 

  2088. 			$shopper_message .= "\n\n";
    2089. 

  2089. 			$shopper_message .= $VM_LANG->_('VM_BK_EMAIL_YOUR_BOOKING',false)."  = ";
    2090. 

  2090. 			$shopper_message .= $ps_booking->property_data->name ."\n";
    2091. 

  2091. 			$shopper_message .= $VM_LANG->_('VM_BK_EMAIL_ARRIVE',false)." = ";
    2092. 

  2092. 			$shopper_message .= $ps_booking->dateFrom . "\n";
    2093. 

  2093. 			$shopper_message .= $VM_LANG->_('VM_BK_EMAIL_DEPART',false)."      = ";
    2094. 

  2094. 			$shopper_message .= $ps_booking->dateTo  . "\n";
    2095. 

  2095. 

  2096. 			$shopper_message .= $VM_LANG->_('VM_BK_EMAIL_NIGHTS',false)."    = ";
    2097. 

  2097. 			$shopper_message .= $ps_booking->nights ."\n";
    2098. 

  2098. 			$shopper_message .= $VM_LANG->_('VM_BK_EMAIL_TOTAL',false)."    = ";
    2099. 

  2099. 			if ($auth["show_price_including_tax"] == 1) {
    2100. 

  2100. 				$sub_total += $ps_booking->subtotal;
    2101. 

  2101. 				$shopper_message .= $CURRENCY_DISPLAY->getFullValue($ps_booking->subtotal, '', $db->f('order_currency'));
    2102. 

  2102. 			} else {
    2103. 

  2103. 				$sub_total += $ps_booking->subtotal;
    2104. 

  2104. 				$shopper_message .= $CURRENCY_DISPLAY->getFullValue($ps_booking->subtotal, '', $db->f('order_currency'));
    2105. 

  2105. 			}
    2106. 

  2106. 			$modulename = $oldmodulename;
    2107. 

  2107. 		}
    2108. 

  2108. 		
    2109. 

  2109. 		while($dboi->next_record()) {
    2110. 

  2110. 			$shopper_message .= "\n\n";
    2111. 

  2111. 			$shopper_message .= $VM_LANG->_('PHPSHOP_PRODUCT',false)."  = ";
    2112. 

  2112. 			if ($dboi->f("product_parent_id")) {
    2113. 

  2113. 				$shopper_message .= $dboi->f("order_item_name") . "\n";
    2114. 

  2114. 				$shopper_message .= "SERVICE  = ";
    2115. 

  2115. 			}
    2116. 

  2116. 			$shopper_message .= $dboi->f("product_name") . "; ".$dboi->f("product_attribute") ."\n";
    2117. 

  2117. 			$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_QUANTITY',false)." = ";
    2118. 

  2118. 			$shopper_message .= $dboi->f("product_quantity") . "\n";
    2119. 

  2119. 			$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_SKU',false)."      = ";
    2120. 

  2120. 			$shopper_message .= $dboi->f("order_item_sku") . "\n";
    2121. 

  2121. 

  2122. 			$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_PRICE',false)."    = ";
    2123. 

  2123. 			if ($auth["show_price_including_tax"] == 1) {
    2124. 

  2124. 				$sub_total += ($dboi->f("product_quantity") * $dboi->f("product_final_price"));
    2125. 

  2125. 				$shopper_message .= $CURRENCY_DISPLAY->getFullValue($dboi->f("product_final_price"), '', $db->f('order_currency'));
    2126. 

  2126. 			} else {
    2127. 

  2127. 				$sub_total += ($dboi->f("product_quantity") * $dboi->f("product_final_price"));
    2128. 

  2128. 				$shopper_message .= $CURRENCY_DISPLAY->getFullValue($dboi->f("product_item_price"), '', $db->f('order_currency'));
    2129. 

  2129. 			}
    2130. 

  2130. 		}
    2131. 

  2131. 

  2132. 		$shopper_message .= "\n\n";
    2133. 

  2133. 

  2134. 		$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_SUBTOTAL',false)." = ";
    2135. 

  2135. 		$shopper_message .= $CURRENCY_DISPLAY->getFullValue($sub_total, '', $db->f('order_currency'))."\n";
    2136. 

  2136. 

  2137. 		if ( PAYMENT_DISCOUNT_BEFORE == '1') {
    2138. 

  2138. 			if( !empty($order_discount)) {
    2139. 

  2139. 				if ($order_discount > 0) {
    2140. 

  2140. 					$shopper_message .= $VM_LANG->_('PHPSHOP_PAYMENT_METHOD_LIST_DISCOUNT',false)." = ";
    2141. 

  2141. 					$shopper_message .= "- ".$CURRENCY_DISPLAY->getFullValue(abs($order_discount), '', $db->f('order_currency')) . "\n";
    2142. 

  2142. 				} else {
    2143. 

  2143. 					$shopper_message .= $VM_LANG->_('PHPSHOP_FEE',false)." = ";
    2144. 

  2144. 					$shopper_message .= "+ ".$CURRENCY_DISPLAY->getFullValue(abs($order_discount), '', $db->f('order_currency')) . "\n";
    2145. 

  2145. 				}
    2146. 

  2146. 			}
    2147. 

  2147. 			if( !empty($coupon_discount)) {
    2148. 

  2148. 				/* following 2 lines added by Erich for coupon hack */
    2149. 

  2149. 				$shopper_message .= $VM_LANG->_('PHPSHOP_COUPON_DISCOUNT',false) . ": ";
    2150. 

  2150. 				$shopper_message .= $CURRENCY_DISPLAY->getFullValue($coupon_discount, '', $db->f('order_currency')) . "\n";
    2151. 

  2151. 			}
    2152. 

  2152. 		}
    2153. 

  2153. 

  2154. 		if ($auth["show_price_including_tax"] != 1) {
    2155. 

  2155. 			$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_TOTAL_TAX',false)."      = ";
    2156. 

  2156. 			$shopper_message .= $CURRENCY_DISPLAY->getFullValue($order_tax, '', $db->f('order_currency')) . "\n";
    2157. 

  2157. 		}
    2158. 

  2158. 		$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_SHIPPING',false)." = ";
    2159. 

  2159. 		$shopper_message .= $CURRENCY_DISPLAY->getFullValue($order_shipping, '', $db->f('order_currency')) . "\n";
    2160. 

  2160. 		if( !empty($order_shipping_tax)) {
    2161. 

  2161. 			$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_SHIPPING_TAX',false)."   = ";
    2162. 

  2162. 			$shopper_message .= $CURRENCY_DISPLAY->getFullValue($order_shipping_tax, '', $db->f('order_currency'));
    2163. 

  2163. 		}
    2164. 

  2164. 		$shopper_message .= "\n\n";
    2165. 

  2165. 		if ( PAYMENT_DISCOUNT_BEFORE != '1') {
    2166. 

  2166. 			if( !empty($order_discount)) {
    2167. 

  2167. 				if ($order_discount > 0) {
    2168. 

  2168. 					$shopper_message .= $VM_LANG->_('PHPSHOP_PAYMENT_METHOD_LIST_DISCOUNT',false)." = ";
    2169. 

  2169. 					$shopper_message .= "- ".$CURRENCY_DISPLAY->getFullValue(abs($order_discount), '', $db->f('order_currency')) . "\n";
    2170. 

  2170. 				} else {
    2171. 

  2171. 					$shopper_message .= $VM_LANG->_('PHPSHOP_FEE',false)." = ";
    2172. 

  2172. 					$shopper_message .= "+ ".$CURRENCY_DISPLAY->getFullValue(abs($order_discount), '', $db->f('order_currency')) . "\n";
    2173. 

  2173. 				}
    2174. 

  2174. 			}
    2175. 

  2175. 			if( !empty($coupon_discount)) {
    2176. 

  2176. 				/* following 2 lines added by Erich for coupon hack */
    2177. 

  2177. 				$shopper_message .= $VM_LANG->_('PHPSHOP_COUPON_DISCOUNT',false) . ": ";
    2178. 

  2178. 				$shopper_message .= $CURRENCY_DISPLAY->getFullValue($coupon_discount, '', $db->f('order_currency')) . "\n";
    2179. 

  2179. 			}
    2180. 

  2180. 		}
    2181. 

  2181. 		$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_TOTAL',false)."    = ";
    2182. 

  2182. 		$shopper_message .= $CURRENCY_DISPLAY->getFullValue($order_total, '', $db->f('order_currency'));
    2183. 

  2183. 

  2184. 		if ($auth["show_price_including_tax"] == 1) {
    2185. 

  2185. 			$shopper_message .= "\n---------------";
    2186. 

  2186. 			$shopper_message .= "\n";
    2187. 

  2187. 			$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_TOTAL_TAX',false)."      = ";
    2188. 

  2188. 			$shopper_message .= $CURRENCY_DISPLAY->getFullValue($order_tax, '', $db->f('order_currency')) . "\n";
    2189. 

  2189. 		}
    2190. 

  2190. 		if( $db->f('order_tax_details') ) {
    2191. 

  2191. 			$shopper_message .= str_replace( '<br />', "\n", ps_checkout::show_tax_details( $db->f('order_tax_details'), $db->f('order_currency') ));
    2192. 

  2192. 		}
    2193. 

  2193. 		// Payment Details
    2194. 

  2194. 		$shopper_message .= "\n\n------------------------------------------------------------------------\n";
    2195. 

  2195. 		$shopper_message .= $payment_info_details_text;
    2196. 

  2196. 		
    2197. 

  2197. 		// Shipping Details
    2198. 

  2198. 		if( is_object($this->_SHIPPING) ) {
    2199. 

  2199. 			$shopper_message .= "\n\n------------------------------------------------------------------------\n";
    2200. 

  2200. 			$shopper_message .= $VM_LANG->_('PHPSHOP_ORDER_PRINT_SHIPPING_LBL',false).":\n";
    2201. 

  2201. 			$shopper_message .= $shipping_arr[1]." (".$shipping_arr[2].")";
    2202. 

  2202. 		}
    2203. 

  2203. 		// Customer Note
    2204. 

  2204. 		$shopper_message .= "\n\n------------------------------------------------------------------------\n";
    2205. 

  2205. 		$shopper_message .= "\n".$VM_LANG->_('PHPSHOP_ORDER_PRINT_CUSTOMER_NOTE',false)."\n";
    2206. 

  2206. 		$shopper_message .= "---------------";
    2207. 

  2207. 		$shopper_message .= "\n";
    2208. 

  2208. 		if( !empty( $customer_note )) {
    2209. 

  2209. 			$shopper_message .= $customer_note."\n";
    2210. 

  2210. 		}
    2211. 

  2211. 		else {
    2212. 

  2212. 			$shopper_message .= " ./. \n";
    2213. 

  2213. 		}
    2214. 

  2214. 		$shopper_message .= "------------------------------------------------------------------------\n";
    2215. 

  2215. 		
    2216. 

  2216. 		// Decode things like &euro; => €
    2217. 

  2217. 		$shopper_message = vmHtmlEntityDecode( $shopper_message );
    2218. 

  2218. 		
    2219. 

  2219. 		// End of Purchase Order
    2220. 

  2220. 		// *********************
    2221. 

  2221. 

  2222. 		
    2223. 

  2223. 		/**
    2224. 

  2224. 		 * Setup the notification settings
    2225. 

  2225. 		 */
    2226. 

  2226. 		if((@VB_NOTIFY_ADD_CUST && $modulename == 'checkout')){
    2227. 

  2227. 			$email_customer = 1;
    2228. 

  2228. 		}			
    2229. 

  2229. 		if((@VB_NOTIFY_ADD_OWNER && $modulename == 'checkout')){
    2230. 

  2230. 			$email_owner = 1;
    2231. 

  2231. 		}		
    2232. 

  2232. 		if((@VB_NOTIFY_ADD_ADMIN && $modulename == 'checkout')){
    2233. 

  2233. 			$email_vendor = 1;
    2234. 

  2234. 		}		
    2235. 

  2235. 		
    2236. 

  2236. 		//
    2237. 

  2237. 		//END: set up text mail
    2238. 

  2238. 		/////////////////////////////////////
    2239. 

  2239. 		// Send text email
    2240. 

  2240. 		//
    2241. 

  2241. 		if (ORDER_MAIL_HTML == '0') {
    2242. 

  2242. 

  2243. 			$msg = $shopper_header . $shopper_message . $shopper_footer;
    2244. 

  2244. 

  2245. 			if($email_customer || $hasPaid){
    2246. 

  2246. 				// Mail receipt to the shopper
    2247. 

  2247. 				vmMail( $from_email, $mosConfig_fromname, $shopper_email, $shopper_subject, $msg, "" );
    2248. 

  2248. 			}			
    2249. 

  2249. 			
    2250. 

  2250. 			$msg = $vendor_header . $shopper_message . $vendor_footer;
    2251. 

  2251. 

  2252. 			$owner = $ps_booking->getOwner();
    2253. 

  2253. 			if(($email_owner || $hasPaid) && $owner->f('email')){
    2254. 

  2254. 				// Mail receipt for owner
    2255. 

  2255. 				vmMail($from_email, $mosConfig_fromname, $owner->f('email'), $vendor_subject,	$msg, "" );
    2256. 

  2256. 			}
    2257. 

  2257. 			
    2258. 

  2258. 			if($email_vendor || $hasPaid){
    2259. 

  2259. 				// Mail receipt to the vendor
    2260. 

  2260. 				vmMail($from_email, $mosConfig_fromname, $vendor_email, $vendor_subject,	$msg, "" );
    2261. 

  2261. 			}			
    2262. 

  2262. 		}
    2263. 

  2263. 

  2264. 		////////////////////////////
    2265. 

  2265. 		// set up the HTML email
    2266. 

  2266. 		//
    2267. 

  2267. 		elseif (ORDER_MAIL_HTML == '1') {
    2268. 

  2268. 

  2269. 			$dboi->query($q_oi);
    2270. 

  2270. 

  2271. 			// Create Template Object 
    2272. 

  2272. 			$template = vmTemplate::getInstance();
    2273. 

  2273. 			
    2274. 

  2274. 			if ($order_discount > 0) {
    2275. 

  2275. 				$order_discount_lbl = $VM_LANG->_('PHPSHOP_PAYMENT_METHOD_LIST_DISCOUNT');
    2276. 

  2276. 				$order_discount_plusminus = '-';
    2277. 

  2277. 			} else {
    2278. 

  2278. 				$order_discount_lbl = $VM_LANG->_('PHPSHOP_FEE');
    2279. 

  2279. 				$order_discount_plusminus = '+';
    2280. 

  2280. 			}
    2281. 

  2281. 			if ($coupon_discount > 0) {
    2282. 

  2282. 				$coupon_discount_lbl = $VM_LANG->_('PHPSHOP_PAYMENT_METHOD_LIST_DISCOUNT');
    2283. 

  2283. 				$coupon_discount_plusminus = '-';
    2284. 

  2284. 			} else {
    2285. 

  2285. 				$coupon_discount_lbl = $VM_LANG->_('PHPSHOP_FEE');
    2286. 

  2286. 				$coupon_discount_plusminus = '+';
    2287. 

  2287. 			}
    2288. 

  2288. 

  2289. 			if( is_object($this->_SHIPPING) ) {
    2290. 

  2290. 				$shipping_info_details = stripslashes($shipping_arr[1])." (".stripslashes($shipping_arr[2]).")";
    2291. 

  2291. 			}
    2292. 

  2292. 			else {
    2293. 

  2293. 				$shipping_info_details = ' ./. ';
    2294. 

  2294. 			}
    2295. 

  2295. 			
    2296. 

  2296. 			//Load the booking language file
    2297. 

  2297. 			$GLOBALS['VM_LANG']->load('booking');
    2298. 

  2298. 			
    2299. 

  2299. 			// These are a lot of vars to import for the email confirmation
    2300. 

  2300. 			$template->set_vars(array(
    2301. 

  2301. 										'is_email_to_shopper' => true,
    2302. 

  2302. 										'db' => $db,
    2303. 

  2303. 										'dboi' => $dboi,
    2304. 

  2304. 										'dbbt' => $dbbt,
    2305. 

  2305. 										'dbst' => $dbst,
    2306. 

  2306. 										'ps_booking' => $ps_booking,	# Pass booking details
    2307. 

  2307. 										'ps_product' => $ps_product,
    2308. 

  2308. 										'shippingfields' => $shippingfields,
    2309. 

  2309. 										'registrationfields' => $registrationfields,
    2310. 

  2310. 										'order_id' => $order_id,
    2311. 

  2311. 										'order_discount' => $order_discount,
    2312. 

  2312. 										'order_discount_lbl' => $order_discount_lbl,
    2313. 

  2313. 										'order_discount_plusminus' => $order_discount_plusminus,			
    2314. 

  2314. 										'coupon_discount' => $coupon_discount,
    2315. 

  2315. 										'coupon_discount_lbl' => $coupon_discount_lbl,
    2316. 

  2316. 										'coupon_discount_plusminus' => $coupon_discount_plusminus,
    2317. 

  2317. 										'order_date' => $VM_LANG->convert( vmFormatDate($db->f("cdate"), $VM_LANG->_('DATE_FORMAT_LC') )),
    2318. 

  2318. 										'order_status' => $order_status,
    2319. 

  2319. 										'legal_info_title' => $legal_info_title,
    2320. 

  2320. 										'legal_info_html' => $legal_info_html,
    2321. 

  2321. 										'order_link' => $shopper_order_link,
    2322. 

  2322. 

  2323. 										'payment_info_lbl' => $VM_LANG->_('PHPSHOP_ORDER_PRINT_PAYINFO_LBL'),
    2324. 

  2324. 										'payment_info_details' => $payment_info_details,
    2325. 

  2325. 										'shipping_info_lbl' => $VM_LANG->_('PHPSHOP_ORDER_PRINT_SHIPPING_LBL'),
    2326. 

  2326. 										'shipping_info_details' => $shipping_info_details,
    2327. 

  2327. 

  2328. 										'from_email' => $from_email,
    2329. 

  2329. 										'customer_note' => nl2br($customer_note),
    2330. 

  2330. 										'order_header_msg' => $shopper_header,
    2331. 

  2331. 

  2332. 										'order_subtotal' => $CURRENCY_DISPLAY->getFullValue($sub_total, '', $db->f('order_currency')),
    2333. 

  2333. 										'order_shipping' => $CURRENCY_DISPLAY->getFullValue($order_shipping, '', $db->f('order_currency')),
    2334. 

  2334. 										'order_tax' => $CURRENCY_DISPLAY->getFullValue($order_tax, '', $db->f('order_currency')). ps_checkout::show_tax_details( $db->f('order_tax_details'), $db->f('order_currency') ),
    2335. 

  2335. 										'order_total' => $CURRENCY_DISPLAY->getFullValue($order_total, '', $db->f('order_currency')),
    2336. 

  2336. 			
    2337. 

  2337. 										));
    2338. 

  2338. 			$shopper_html = $template->fetch('order_emails/confirmation_email.tpl.php');
    2339. 

  2339. 			
    2340. 

  2340. 			// Reset the list of order items for use in the vendor email
    2341. 

  2341. 			$dboi->reset();
    2342. 

  2342. 			
    2343. 

  2343. 			// Override some vars for the vendor email, so we can use the same template
    2344. 

  2344. 			$template->set_vars(array(
    2345. 

  2345. 														'order_header_msg' => $vendor_header,
    2346. 

  2346. 														'order_link' => $vendor_order_link,
    2347. 

  2347. 														'is_email_to_shopper' => false
    2348. 

  2348. 											));
    2349. 

  2349. 											
    2350. 

  2350. 			$vendor_html = $template->fetch('order_emails/confirmation_email.tpl.php');
    2351. 

  2351. 

  2352. 			/*
    2353. 

  2353. 			* Add the text, html and embedded images.
    2354. 

  2354. 			* The name of the image should match exactly
    2355. 

  2355. 			* (case-sensitive) to the name in the html.
    2356. 

  2356. 			*/
    2357. 

  2357. 			$shopper_mail_Body = $shopper_html;
    2358. 

  2358. 			$shopper_mail_AltBody = $shopper_header . $shopper_message . $shopper_footer;
    2359. 

  2359. 

  2360. 			$vendor_mail_Body = $vendor_html;
    2361. 

  2361. 			$vendor_mail_AltBody = $vendor_header . $shopper_message . $vendor_footer;
    2362. 

  2362. 

  2363. 			$imagefile = pathinfo($dbv->f("vendor_full_image"));
    2364. 

  2364. 			$extension = $imagefile['extension'] == "jpg" ? "jpeg" : "jpeg";
    2365. 

  2365. 

  2366. 			$EmbeddedImages[] = array(	'path' => IMAGEPATH."vendor/".$dbv->f("vendor_full_image"),
    2367. 

  2367. 								'name' => "vendor_image", 
    2368. 

  2368. 								'filename' => $dbv->f("vendor_full_image"),
    2369. 

  2369. 								'encoding' => "base64",
    2370. 

  2370. 								'mimetype' => "image/".$extension );
    2371. 

  2371. 

  2372. 		/*	if($order_id == 12945){
    2373. 

  2373. 				$shopper_email = 'phil.c@organic-development.com';
    2374. 

  2374. 				
    2375. 

  2375. 				echo $shopper_html;
    2376. 

  2376. 				exit();
    2377. 

  2377. 			}
    2378. 

  2378. 		*/			
    2379. 

  2379. 			# Mail customer
    2380. 

  2380. 			if($email_customer || $hasPaid){
    2381. 

  2381. 				$shopper_mail = vmMail( $from_email, $mosConfig_fromname, $shopper_email, $shopper_subject, $shopper_mail_Body, $shopper_mail_AltBody, true, null, null, $EmbeddedImages);
    2382. 

  2382. 			}else{
    2383. 

  2383. 				$shopper_mail = 1;
    2384. 

  2384. 			}
    2385. 

  2385. 			
    2386. 

  2386. 	
    2387. 

  2387. 			# Mail vendor
    2388. 

  2388. 			if($email_vendor || $hasPaid){
    2389. 

  2389. 				$vendor_mail = vmMail( $shopper_email, $shopper_name, $vendor_email, $vendor_subject, $vendor_mail_Body, $vendor_mail_AltBody, true, null, null, $EmbeddedImages);
    2390. 

  2390. 			}else{
    2391. 

  2391. 				$vendor_mail = 1;
    2392. 

  2392. 			}
    2393. 

  2393. 

  2394. 			# Mail vendor
    2395. 

  2395. 			$owner = $ps_booking->getOwner();
    2396. 

  2396. 			if(($email_owner || $hasPaid) && $owner->f('email')){				
    2397. 

  2397. 				vmMail( $from_email, $shopper_name, $owner->f('email'), $vendor_subject, $vendor_mail_Body, $vendor_mail_AltBody, true, null, null, $EmbeddedImages);
    2398. 

  2398. 			}
    2399. 

  2399. 			
    2400. 

  2400. 			if ( !$shopper_mail || !$vendor_mail ) {				
    2401. 

  2401. 				$vmLogger->debug( 'Something went wrong while sending the order confirmation email to '.$from_email.' and '.$shopper_email );
    2402. 

  2402. 				return false;
    2403. 

  2403. 			}			
    2404. 

  2404. 			//
    2405. 

  2405. 			// END: set up and send the HTML email
    2406. 

  2406. 			////////////////////////////////////////
    2407. 

  2407. 		}
    2408. 

  2408. 

  2409. 		return true;
    2410. 

  2410. 

  2411. 	} // end of function email_receipt()
    2412. 

  2412. 

  2413. 

  2414. 

  2415. 	/**
    2416. 

  2416. 	 * Return $str with all but $display_length at the end as asterisks.
    2417. 

  2417. 	 * @author gday
    2418. 

  2418. 	 *
    2419. 

  2419. 	 * @param string $str The string to mask
    2420. 

  2420. 	 * @param int $display_length The length at the end of the string that is NOT masked
    2421. 

  2421. 	 * @param boolean $reversed When true, masks the end. Masks from the beginning at default
    2422. 

  2422. 	 * @return string The string masked by asteriks
    2423. 

  2423. 	 */
    2424. 

  2424. 	function asterisk_pad($str, $display_length, $reversed = false) {
    2425. 

  2425. 

  2426. 		$total_length = strlen($str);
    2427. 

  2427. 

  2428. 		if($total_length > $display_length) {
    2429. 

  2429. 			if( !$reversed) {
    2430. 

  2430. 				for($i = 0; $i < $total_length - $display_length; $i++) {
    2431. 

  2431. 					$str[$i] = "*";
    2432. 

  2432. 				}
    2433. 

  2433. 			}
    2434. 

  2434. 			else {
    2435. 

  2435. 				for($i = $total_length-1; $i >= $total_length - $display_length; $i--) {
    2436. 

  2436. 					$str[$i] = "*";
    2437. 

  2437. 				}
    2438. 

  2438. 			}
    2439. 

  2439. 		}
    2440. 

  2440. 

  2441. 		return($str);
    2442. 

  2442. 	}
    2443. 

  2443. 

  2444. 	/**
    2445. 

  2445. 	 * Displays the order_tax_details array when it contains
    2446. 

  2446. 	 * more than one 
    2447. 

  2447. 	 * @param mixed $details
    2448. 

  2448. 	 * @return string
    2449. 

  2449. 	 */
    2450. 

  2450. 	function show_tax_details( $details, $currency = ''  ) {
    2451. 

  2451. 		global $discount_factor, $CURRENCY_DISPLAY, $VM_LANG;
    2452. 

  2452. 		
    2453. 

  2453. 		if( !isset( $discount_factor) || !empty($_REQUEST['discount_factor'])) {
    2454. 

  2454. 			$discount_factor = 1;
    2455. 

  2455. 		}
    2456. 

  2456. 		$auth = $_SESSION['auth'];
    2457. 

  2457. 		if( !is_array( $details )) {
    2458. 

  2458. 			$details = @unserialize( $details );
    2459. 

  2459. 			if( !is_array($details)) {
    2460. 

  2460. 				return false;
    2461. 

  2461. 			}
    2462. 

  2462. 		}
    2463. 

  2463. 		$html = '';
    2464. 

  2464. 		if( sizeof( $details) > 1 ) {
    2465. 

  2465. 			$html .= '<br />'.$VM_LANG->_('VM_TAXDETAILS_LABEL').':<br />';
    2466. 

  2466. 			
    2467. 

  2467. 			foreach ($details as $rate => $value ) {
    2468. 

  2468. 				if( !$auth['show_price_including_tax']) {
    2469. 

  2469. 					$value /= $discount_factor;
    2470. 

  2470. 				}
    2471. 

  2471. 				$rate = str_replace( '-', $CURRENCY_DISPLAY->decimal, $rate )*100;
    2472. 

  2472. 				$html .= $CURRENCY_DISPLAY->getFullValue( $value, 5, $currency ).' ('.$rate.'% '.$VM_LANG->_('PHPSHOP_CART_TAX').')<br />';
    2473. 

  2473. 			}
    2474. 

  2474. 		}
    2475. 

  2475. 		return $html;
    2476. 

  2476. 	}
    2477. 

  2477. 	
    2478. 

  2478. 	/*
    2479. 

  2479. 	* @abstract This function is very useful to round totals with definite decimals.
    2480. 

  2480. 	*
    2481. 

  2481. 	* @param float   $value
    2482. 

  2482. 	* @param integer $dec
    2483. 

  2483. 	* @return float
    2484. 

  2484. 	*/
    2485. 

  2485. 	function approx( $value, $dec = 2 ) {
    2486. 

  2486. 		$value += 0.0;
    2487. 

  2487. 		$unit  = floor( $value * pow( 10, $dec + 1 ) ) / 10;
    2488. 

  2488. 		$round = round( $unit );
    2489. 

  2489. 		return $round / pow( 10, $dec );
    2490. 

  2490. 	}
    2491. 

  2491. 

  2492. 

  2493. 

  2494. 	/**
    2495. 

  2495. 	 * If the customer is in the EU then tax should be charged according to the
    2496. 

  2496. 	 *  vendor's address, and this function will return true.
    2497. 

  2497. 	 */
    2498. 

  2498. 	function tax_based_on_vendor_address () {
    2499. 

  2499. 		global $__tax_based_on_vendor_address;
    2500. 

  2500. 		global $vmLogger;
    2501. 

  2501. 	
    2502. 

  2502. 		if (!isset ($__tax_based_on_vendor_address)) {
    2503. 

  2503. 			$__tax_based_on_vendor_address = ps_checkout::_tax_based_on_vendor_address ();
    2504. 

  2504. 			if ($__tax_based_on_vendor_address)
    2505. 

  2505. 				$vmLogger->debug ('calculating tax based on vendor address');
    2506. 

  2506. 			else
    2507. 

  2507. 				$vmLogger->debug ('calculating tax based on shipping address');
    2508. 

  2508. 		}
    2509. 

  2509. 		return $__tax_based_on_vendor_address;
    2510. 

  2510. 	}
    2511. 

  2511. 	
    2512. 

  2512. 	function _tax_based_on_vendor_address () {
    2513. 

  2513. 		global $auth;
    2514. 

  2514. 		global $vmLogger;
    2515. 

  2515. 	
    2516. 

  2516. 		switch (TAX_MODE) {
    2517. 

  2517. 		case '0':
    2518. 

  2518. 			return false;
    2519. 

  2519. 	
    2520. 

  2520. 		case '1':
    2521. 

  2521. 			return true;
    2522. 

  2522. 	
    2523. 

  2523. 		case '17749':
    2524. 

  2524. 			if (! array_key_exists ('country', $auth)) {
    2525. 

  2525. 				$vmLogger->debug ('shopper\'s country is not known; defaulting to vendor-based tax');
    2526. 

  2526. 				return true;
    2527. 

  2527. 			}
    2528. 

  2528. 	
    2529. 

  2529. 			$vmLogger->debug ('shopper is in ' . $auth['country']);
    2530. 

  2530. 			return ps_checkout::country_in_eu_common_vat_zone ($auth['country']);
    2531. 

  2531. 	
    2532. 

  2532. 		default:
    2533. 

  2533. 			$vmLogger->warning ('unknown TAX_MODE "' . TAX_MODE . '"');
    2534. 

  2534. 			return true;
    2535. 

  2535. 		}
    2536. 

  2536. 	}
    2537. 

  2537. 	
    2538. 

  2538. 	function country_in_eu_common_vat_zone ($country) {
    2539. 

  2539. 		$eu_countries = array ('AUT', 'BGR', 'BEL', 'CYP', 'CZE', 'DEU', 'DNK', 'ESP', 'EST', 
    2540. 

  2540. 								'FIN', 'FRA', 'FXX', 'GBR', 'GRC', 'HUN', 'IRL', 'ITA', 'LVA', 'LTU', 
    2541. 

  2541. 								'LUX', 'MLT', 'NLD', 'POL', 'PRT', 'ROM', 'SVK', 'SVN', 'SWE');
    2542. 

  2542. 		return in_array ($country, $eu_countries);
    2543. 

  2543. 	}
    2544. 

  2544. }
    2545. 

  2545. ?>
    2546.