|
1
|
|
|
<?php |
|
2
|
|
|
/** |
|
3
|
|
|
* WP eCommerce Cart and Cart Item classes |
|
4
|
|
|
* |
|
5
|
|
|
* This is the class for the WP eCommerce Cart , |
|
6
|
|
|
* The Cart class handles adding, removing and adjusting items in the cart, and totaling up the cost of the items in the cart. |
|
7
|
|
|
* |
|
8
|
|
|
* |
|
9
|
|
|
* @package wp-e-commerce |
|
10
|
|
|
* @since 3.7 |
|
11
|
|
|
* @subpackage wpsc-cart-classes |
|
12
|
|
|
*/ |
|
13
|
|
|
|
|
14
|
|
|
/* |
|
15
|
|
|
* @since 3.8.14 |
|
16
|
|
|
* |
|
17
|
|
|
* We are going to do a check to see if the cart template API include file has not been included. Pre 3.8.14 the |
|
18
|
|
|
* template API functions were in the cart.class.php file before the class definition. In 3.8.14 the functions |
|
19
|
|
|
* are in a separate file that is included immediately before this file. In the future we will want to have the option |
|
20
|
|
|
* of changing the order and classes may be included at a different point in the init sequence. |
|
21
|
|
|
* |
|
22
|
|
|
* If we find that a key function we expect to be present does not exist it tells is that this file has been |
|
23
|
|
|
* improperly included directly in outside code. We will give a doing it wrong message. |
|
24
|
|
|
* |
|
25
|
|
|
* So that backwards compatibility is preserved for 3.8.14 we also require_once the cart template API file. |
|
26
|
|
|
* |
|
27
|
|
|
*/ |
|
28
|
|
|
if ( ! function_exists( 'wpsc_cart_need_to_recompute_shipping_quotes' ) ) { |
|
29
|
|
|
_wpsc_doing_it_wrong( 'cart.class.php', __( 'As of WPeC 3.8.14, a check is made to be sure that wpsc-includes\cart.class.php is not loaded directly by outside code. WPeC internals are likely to be re-organized going forward. When this happens code that directly includes WPeC internal modules may fail.', 'wp-e-commerce' ), '3.8.14' ); |
|
30
|
|
|
} |
|
31
|
|
|
|
|
32
|
|
|
require_once( WPSC_FILE_PATH . '/wpsc-includes/cart-template-api.php' ); |
|
33
|
|
|
|
|
34
|
|
|
/** |
|
35
|
|
|
* The WPSC Cart class |
|
36
|
|
|
*/ |
|
37
|
|
|
class WPSC_Cart { |
|
38
|
|
|
public $delivery_country; |
|
39
|
|
|
public $selected_country; |
|
40
|
|
|
public $delivery_region; |
|
41
|
|
|
public $selected_region; |
|
42
|
|
|
|
|
43
|
|
|
public $selected_shipping_method = null; |
|
44
|
|
|
public $selected_shipping_option = null; |
|
45
|
|
|
public $shipping_option = null; |
|
46
|
|
|
public $selected_shipping_amount = null; |
|
47
|
|
|
|
|
48
|
|
|
public $coupon; |
|
49
|
|
|
public $tax_percentage; |
|
50
|
|
|
public $unique_id; |
|
51
|
|
|
public $errors; |
|
52
|
|
|
|
|
53
|
|
|
// caching of frequently used values, these are wiped when the cart is modified and then remade when needed |
|
54
|
|
|
public $total_tax = null; |
|
55
|
|
|
public $base_shipping = null; |
|
56
|
|
|
public $total_item_shipping = null; |
|
57
|
|
|
public $total_shipping = null; |
|
58
|
|
|
public $subtotal = null; |
|
59
|
|
|
public $total_price = null; |
|
60
|
|
|
public $uses_shipping = null; |
|
61
|
|
|
|
|
62
|
|
|
public $is_incomplete = true; |
|
63
|
|
|
|
|
64
|
|
|
// The cart loop variables |
|
65
|
|
|
public $cart_items = array(); |
|
66
|
|
|
public $cart_item = null; |
|
67
|
|
|
public $cart_item_count = 0; |
|
68
|
|
|
public $current_cart_item = -1; |
|
69
|
|
|
public $in_the_loop = false; |
|
70
|
|
|
|
|
71
|
|
|
// The shipping method loop variables |
|
72
|
|
|
public $shipping_methods = array(); |
|
73
|
|
|
public $shipping_method = null; |
|
74
|
|
|
public $shipping_method_count = 0; |
|
75
|
|
|
public $current_shipping_method = -1; |
|
76
|
|
|
public $in_the_method_loop = false; |
|
77
|
|
|
|
|
78
|
|
|
// The shipping quote loop variables |
|
79
|
|
|
public $shipping_quotes = array(); |
|
80
|
|
|
public $shipping_quote = null; |
|
81
|
|
|
public $shipping_quote_count = 0; |
|
82
|
|
|
public $current_shipping_quote = -1; |
|
83
|
|
|
public $in_the_quote_loop = false; |
|
84
|
|
|
|
|
85
|
|
|
//coupon variable |
|
86
|
|
|
public $coupons_name = ''; |
|
87
|
|
|
public $coupons_amount = 0; |
|
88
|
|
|
|
|
89
|
|
|
// Cart signature, a hash indicating uniqueness of cart |
|
90
|
|
|
public $_signature = ''; |
|
91
|
|
|
|
|
92
|
|
|
|
|
93
|
|
|
public function __construct() { |
|
94
|
|
|
$coupon = 'percentage'; |
|
95
|
|
|
$this->update_location(); |
|
96
|
|
|
$this->wpsc_refresh_cart_items(); |
|
97
|
|
|
$this->unique_id = sha1( uniqid( rand(), true ) ); |
|
98
|
|
|
|
|
99
|
|
|
add_action( 'wpsc_visitor_location_changing', array( &$this, 'shopper_location_changing' ), 10, 2); |
|
100
|
|
|
add_filter( 'wpsc_default_shipping_quote', array ($this, 'set_default_shipping_quote' ), 10, 3 ); |
|
|
|
|
|
|
101
|
|
|
} |
|
102
|
|
|
|
|
103
|
|
|
/* |
|
104
|
|
|
* Action routine to start the processing that has to happen when the customer changes |
|
105
|
|
|
* location. |
|
106
|
|
|
* |
|
107
|
|
|
* @since 3.8.14 |
|
108
|
|
|
* @param array names of checnout items that hav changed since the last time the location for this customer was changed |
|
109
|
|
|
* |
|
110
|
|
|
*/ |
|
111
|
|
|
function shopper_location_changing( $what_changed, $visitor_id ) { |
|
|
|
|
|
|
112
|
|
|
$this->update_location(); |
|
113
|
|
|
} |
|
114
|
|
|
|
|
115
|
|
|
/** |
|
116
|
|
|
* update_location method, updates the location |
|
117
|
|
|
* @access public |
|
118
|
|
|
*/ |
|
119
|
|
|
|
|
120
|
|
|
public function update_location() { |
|
121
|
|
|
|
|
122
|
|
|
$this->clear_cache(); |
|
123
|
|
|
|
|
124
|
|
|
$delivery_country = wpsc_get_customer_meta( 'shippingcountry' ); |
|
125
|
|
|
$billing_country = wpsc_get_customer_meta( 'billingcountry' ); |
|
126
|
|
|
$delivery_region = wpsc_get_customer_meta( 'shippingregion' ); |
|
127
|
|
|
$billing_region = wpsc_get_customer_meta( 'billingregion' ); |
|
128
|
|
|
|
|
129
|
|
|
$this->delivery_country = $delivery_country; |
|
130
|
|
|
$this->selected_country = $billing_country ; |
|
131
|
|
|
$this->delivery_region = $delivery_region ; |
|
132
|
|
|
$this->selected_region = $billing_region; |
|
133
|
|
|
|
|
134
|
|
|
// adding refresh item |
|
135
|
|
|
|
|
136
|
|
|
$this->wpsc_refresh_cart_items(); |
|
137
|
|
|
} |
|
138
|
|
|
|
|
139
|
|
|
/** |
|
140
|
|
|
* @description: refresh all items in the cart |
|
141
|
|
|
* |
|
142
|
|
|
* @param: void |
|
143
|
|
|
* @return: null |
|
144
|
|
|
**/ |
|
145
|
|
|
public function wpsc_refresh_cart_items() { |
|
146
|
|
|
global $wpsc_cart; |
|
147
|
|
|
|
|
148
|
|
|
if ( is_object( $wpsc_cart ) && is_array( $wpsc_cart->cart_items ) ) { |
|
149
|
|
|
foreach ( $wpsc_cart->cart_items as $cart_item ) { |
|
150
|
|
|
$cart_item->refresh_item(); |
|
151
|
|
|
} |
|
152
|
|
|
} |
|
153
|
|
|
} |
|
154
|
|
|
|
|
155
|
|
|
/* |
|
156
|
|
|
* It os time to checkout, or at other points in the workflow and it's time to validate the shopping cart |
|
157
|
|
|
* call this function. |
|
158
|
|
|
* |
|
159
|
|
|
* The function will in turn execute all of the hooks that are built into WPEC, then any hooks added by |
|
160
|
|
|
* themes and plugins. This means that validation rules beyond what WPEC has internally can be added as needed. |
|
161
|
|
|
*/ |
|
162
|
|
|
function validate_cart() { |
|
163
|
|
|
|
|
164
|
|
|
/* |
|
165
|
|
|
* action: wpsc_pre_validate_cart |
|
166
|
|
|
* |
|
167
|
|
|
* Prior to validating the cart we give anyone whoe is interested a chance to do a little setup with this |
|
168
|
|
|
* wpsc_pre_validate_cart. |
|
169
|
|
|
* |
|
170
|
|
|
* This action can be used as a convenient point to change the logic that is esecuted when the 'wpsc_validate_cart' |
|
171
|
|
|
* action is fired. For example, if you want to do different address checks based on which country is being shipped |
|
172
|
|
|
* to you can call add_action with different function paramters. Or if you wnated to some extra validation when shipping |
|
173
|
|
|
* address is differnet than billing, perhaps a quick SOAP call to a fraud check service, you can conditionally do an |
|
174
|
|
|
* add action to your function that does the fraud check. |
|
175
|
|
|
* |
|
176
|
|
|
* @param wpsc_cart the cart object |
|
177
|
|
|
* @param current visitor id (use this to get customer meta for the current user |
|
178
|
|
|
*/ |
|
179
|
|
|
do_action( 'wpsc_pre_validate_cart', $this, wpsc_get_current_customer_id() ); |
|
180
|
|
|
|
|
181
|
|
|
/* |
|
182
|
|
|
* action: wpsc_validate_cart |
|
183
|
|
|
* |
|
184
|
|
|
* Validate that the cart contents is valid. Typically done just prior to checkout. Most often error conditions |
|
185
|
|
|
* will be recorded to special customer meta values, but other processing can be implemented based on specific needs |
|
186
|
|
|
* |
|
187
|
|
|
* These are the customer/visitor meta values that are typically added to when errors are found: |
|
188
|
|
|
* checkout_error_messages |
|
189
|
|
|
* gateway_error_messages |
|
190
|
|
|
* registration_error_messages |
|
191
|
|
|
* |
|
192
|
|
|
* @param wpsc_cart the cart object |
|
193
|
|
|
* @param current visitor id (use this to get customer meta for the current user |
|
194
|
|
|
*/ |
|
195
|
|
|
do_action( 'wpsc_validate_cart', $this, wpsc_get_current_customer_id() ); |
|
196
|
|
|
} |
|
197
|
|
|
|
|
198
|
|
|
/** |
|
199
|
|
|
* Clear all shipping method information for this cart |
|
200
|
|
|
* |
|
201
|
|
|
* @since 3.8.14 |
|
202
|
|
|
* |
|
203
|
|
|
*/ |
|
204
|
|
|
function clear_shipping_info() { |
|
205
|
|
|
$this->selected_shipping_method = null; |
|
206
|
|
|
$this->selected_shipping_option = null; |
|
207
|
|
|
$this->shipping_option = null; |
|
208
|
|
|
$this->shipping_method = null; |
|
209
|
|
|
$this->shipping_methods = array(); |
|
210
|
|
|
$this->shipping_quotes = array(); |
|
211
|
|
|
$this->shipping_quote = null; |
|
212
|
|
|
$this->shipping_method_count = 0; |
|
213
|
|
|
$this->base_shipping = null; |
|
214
|
|
|
$this->total_item_shipping = null; |
|
215
|
|
|
$this->total_shipping = null; |
|
216
|
|
|
} |
|
217
|
|
|
|
|
218
|
|
|
/** |
|
219
|
|
|
* Does the cart have a valid shipping method selected |
|
220
|
|
|
* |
|
221
|
|
|
* @since 3.8.14.1 |
|
222
|
|
|
* |
|
223
|
|
|
* @return boolean true if a valid shipping method is selected, false otherwise |
|
224
|
|
|
*/ |
|
225
|
|
|
function shipping_method_selected() { |
|
226
|
|
|
|
|
227
|
|
|
$selected = true; |
|
228
|
|
|
|
|
229
|
|
|
// so the check could be written as one long expression, but thougth it better to make it more |
|
230
|
|
|
// readily understandable by someone who wants to see what is happening. |
|
231
|
|
|
// TODO: All this logic would be unnecessary but for the lack of protected properties and |
|
232
|
|
|
// the legacy code that may choose to manipulate them directly avoiding class methods |
|
233
|
|
|
|
|
234
|
|
|
// is there a shipping method? |
|
235
|
|
|
if ( empty( $this->selected_shipping_method ) ) { |
|
236
|
|
|
$selected = false; |
|
237
|
|
|
} |
|
238
|
|
|
|
|
239
|
|
|
// first we will check the shipping methods |
|
240
|
|
|
if ( $selected && ( ! is_array( $this->shipping_methods ) || empty( $this->shipping_methods ) ) ) { |
|
241
|
|
|
$selected = false; |
|
242
|
|
|
} |
|
243
|
|
|
|
|
244
|
|
|
// check to be sure the shipping method name is not empty, and is also in the array |
|
245
|
|
|
if ( $selected && ( empty( $this->selected_shipping_method ) || ! in_array( $this->selected_shipping_method, $this->shipping_methods ) ) ) { |
|
246
|
|
|
$selected = false; |
|
247
|
|
|
} |
|
248
|
|
|
|
|
249
|
|
|
return $selected; |
|
250
|
|
|
} |
|
251
|
|
|
|
|
252
|
|
|
/** |
|
253
|
|
|
* Does the cart have a valid shipping quote selected |
|
254
|
|
|
* |
|
255
|
|
|
* @since 3.8.14.1 |
|
256
|
|
|
* |
|
257
|
|
|
* @return boolean true if a valid shipping method is selected, false otherwise |
|
258
|
|
|
*/ |
|
259
|
|
|
function shipping_quote_selected() { |
|
260
|
|
|
|
|
261
|
|
|
$selected = true; |
|
262
|
|
|
|
|
263
|
|
|
// so the check could be written as one long expression, but thought it better to make it more |
|
264
|
|
|
// readily understandable by someone who wants to see what is happening. |
|
265
|
|
|
// TODO: All this logic would be unnecessary but for the lack of protected properties and |
|
266
|
|
|
// the legacy code that may choose to manipulate them directly avoiding class methods |
|
267
|
|
|
|
|
268
|
|
|
// do we have a shipping quotes array |
|
269
|
|
|
if ( $selected && ( ! is_array( $this->shipping_quotes ) || empty( $this->shipping_quotes ) ) ) { |
|
270
|
|
|
$selected = false; |
|
271
|
|
|
} |
|
272
|
|
|
|
|
273
|
|
|
if ( $selected && ! isset( $this->shipping_quotes[$this->selected_shipping_option] ) ) { |
|
274
|
|
|
$selected = false; |
|
275
|
|
|
} |
|
276
|
|
|
|
|
|
|
|
|
|
277
|
|
|
|
|
278
|
|
|
return $selected; |
|
279
|
|
|
} |
|
280
|
|
|
|
|
281
|
|
|
|
|
282
|
|
|
/** |
|
283
|
|
|
* Is all shipping method information for this cart empty |
|
284
|
|
|
* |
|
285
|
|
|
* @since 3.8.14 |
|
286
|
|
|
* @return boolean true if all the shipping fields in the cart are empty |
|
287
|
|
|
*/ |
|
288
|
|
|
function shipping_info_empty() { |
|
289
|
|
|
return empty( $this->selected_shipping_method ) |
|
290
|
|
|
&& empty( $this->selected_shipping_option ) |
|
291
|
|
|
&& empty( $this->shipping_method ) |
|
292
|
|
|
&& empty( $this->shipping_methods ) |
|
293
|
|
|
&& empty( $this->shipping_quotes ) |
|
294
|
|
|
&& empty( $this->shipping_quote ) |
|
295
|
|
|
&& empty( $this->shipping_method_count ) |
|
296
|
|
|
&& empty( $this->base_shipping ) |
|
297
|
|
|
&& empty( $this->total_item_shipping ) |
|
298
|
|
|
&& empty( $this->total_shipping ); |
|
299
|
|
|
} |
|
300
|
|
|
|
|
301
|
|
|
/** |
|
302
|
|
|
* Is shipping information calculated and ready to use |
|
303
|
|
|
* |
|
304
|
|
|
* @since 3.8.14 |
|
305
|
|
|
* @return boolean true if a recalc is necessary |
|
306
|
|
|
*/ |
|
307
|
|
|
function needs_shipping_recalc() { |
|
308
|
|
|
global $wpsc_shipping_modules; |
|
309
|
|
|
|
|
310
|
|
|
if ( ! wpsc_is_shipping_enabled() ) { |
|
311
|
|
|
return false; |
|
312
|
|
|
} |
|
313
|
|
|
|
|
314
|
|
|
if ( $this->shipping_info_empty() && $this->uses_shipping() ) { |
|
315
|
|
|
return true; |
|
316
|
|
|
} |
|
317
|
|
|
|
|
318
|
|
|
$needs_shipping_recalc = false; |
|
319
|
|
|
|
|
320
|
|
|
$what_changed = _wpsc_visitor_location_what_changed(); |
|
321
|
|
|
|
|
322
|
|
|
// TODO: this is where we will check the available shipping methods and see if |
|
323
|
|
|
// the parameters used to create the quotes have changes since the quotes where |
|
324
|
|
|
// created. A function of the future shipping component |
|
325
|
|
|
|
|
326
|
|
|
if ( array_key_exists( 'shippingpostcode', $what_changed ) ) { |
|
327
|
|
|
$custom_shipping = get_option( 'custom_shipping_options' ); |
|
328
|
|
|
foreach ( (array)$custom_shipping as $shipping ) { |
|
329
|
|
|
if ( isset( $wpsc_shipping_modules[$shipping]->needs_zipcode ) && $wpsc_shipping_modules[$shipping]->needs_zipcode == true ) { |
|
330
|
|
|
$needs_shipping_recalc = true; |
|
331
|
|
|
break; |
|
332
|
|
|
} |
|
333
|
|
|
} |
|
334
|
|
|
} |
|
335
|
|
|
|
|
336
|
|
|
// recalculate shipping if country changes |
|
337
|
|
|
if ( array_key_exists( 'shippingcountry', $what_changed ) ) { |
|
338
|
|
|
$needs_shipping_recalc = true; |
|
339
|
|
|
} |
|
340
|
|
|
|
|
341
|
|
|
// recalculate shipping if region changes |
|
342
|
|
|
if ( array_key_exists( 'shippingregion', $what_changed ) ) { |
|
343
|
|
|
$needs_shipping_recalc = true; |
|
344
|
|
|
} |
|
345
|
|
|
|
|
346
|
|
|
// recalculate shipping if state |
|
347
|
|
|
if ( array_key_exists( 'shippingstate', $what_changed ) ) { |
|
348
|
|
|
$needs_shipping_recalc = true; |
|
349
|
|
|
} |
|
350
|
|
|
|
|
351
|
|
|
/* |
|
352
|
|
|
* filter: wpsc_needs_shipping_recalc |
|
353
|
|
|
* |
|
354
|
|
|
* If more processing is needed to determine if shipping really needs to |
|
355
|
|
|
* be recalculated it should be hooked on here. |
|
356
|
|
|
*/ |
|
357
|
|
|
return apply_filters( 'wpsc_needs_shipping_recalc', $needs_shipping_recalc, $this ); |
|
358
|
|
|
} |
|
359
|
|
|
|
|
360
|
|
|
/** |
|
361
|
|
|
* get_shipping_rates method, gets the shipping rates |
|
362
|
|
|
* @access public |
|
363
|
|
|
*/ |
|
364
|
|
|
function get_shipping_method() { |
|
365
|
|
|
global $wpsc_shipping_modules; |
|
366
|
|
|
|
|
367
|
|
|
// set us up with a shipping method. |
|
368
|
|
|
$custom_shipping = get_option( 'custom_shipping_options', array() ); |
|
369
|
|
|
|
|
370
|
|
|
if ( ! is_array( $custom_shipping ) ) { |
|
371
|
|
|
$custom_shipping = (array) $custom_shipping; |
|
372
|
|
|
} |
|
373
|
|
|
|
|
374
|
|
|
$this->shipping_methods = $custom_shipping; |
|
375
|
|
|
$this->shipping_method_count = count( $this->shipping_methods ); |
|
376
|
|
|
|
|
377
|
|
|
$use_shipping = ! get_option( 'do_not_use_shipping', false ); |
|
378
|
|
|
$ready_to_calculate_shipping = apply_filters( 'wpsc_ready_to_calculate_shipping', true, $this ); |
|
379
|
|
|
|
|
380
|
|
|
if ( $use_shipping ) { |
|
381
|
|
|
|
|
382
|
|
|
if ( $this->shipping_method_count > 0 && $ready_to_calculate_shipping ) { |
|
383
|
|
|
do_action( 'wpsc_before_get_shipping_method', $this ); |
|
384
|
|
|
|
|
385
|
|
|
$shipping_quotes = null; |
|
386
|
|
|
|
|
387
|
|
|
foreach ( (array) $custom_shipping as $shipping_module ) { |
|
388
|
|
|
|
|
389
|
|
|
if ( empty( $wpsc_shipping_modules[ $shipping_module ] ) || ! is_callable( array( $wpsc_shipping_modules[ $shipping_module ], 'getQuote' ) ) ) { |
|
390
|
|
|
continue; |
|
391
|
|
|
} |
|
392
|
|
|
|
|
393
|
|
|
$raw_quotes = $wpsc_shipping_modules[ $shipping_module ]->getQuote(); |
|
394
|
|
|
|
|
395
|
|
|
if ( empty( $raw_quotes ) || ! is_array( $raw_quotes ) ) { |
|
396
|
|
|
continue; |
|
397
|
|
|
} |
|
398
|
|
|
|
|
399
|
|
|
if ( is_array( $raw_quotes ) ) { |
|
400
|
|
|
foreach ( $raw_quotes as $key => $value ) { |
|
401
|
|
|
$this->shipping_quotes[$wpsc_shipping_modules[ $shipping_module ]->name. ' ' . $key] = $value; |
|
402
|
|
|
} |
|
403
|
|
|
$this->shipping_quote_count = count( $this->shipping_quotes ); |
|
404
|
|
|
} |
|
405
|
|
|
} |
|
406
|
|
|
|
|
407
|
|
|
if ( 1 == count( $this->shipping_methods ) ) { |
|
408
|
|
|
$this->selected_shipping_method = $this->shipping_methods[0]; |
|
409
|
|
|
|
|
410
|
|
|
if ( 1 == count( $this->shipping_quotes ) ) { |
|
411
|
|
|
reset( $this->shipping_quotes ); |
|
412
|
|
|
$this->selected_shipping_option = key( $this->shipping_quotes ); |
|
413
|
|
|
} |
|
414
|
|
|
} |
|
415
|
|
|
|
|
416
|
|
|
do_action( 'wpsc_after_get_shipping_method', $this ); |
|
417
|
|
|
} |
|
418
|
|
|
} |
|
419
|
|
|
|
|
420
|
|
|
$this->rewind_shipping_methods(); |
|
421
|
|
|
|
|
422
|
|
|
} |
|
423
|
|
|
|
|
424
|
|
|
/** |
|
425
|
|
|
* get_shipping_option method, gets the shipping option from the selected method and associated quotes |
|
426
|
|
|
* |
|
427
|
|
|
* @access public |
|
428
|
|
|
* |
|
429
|
|
|
* @return none |
|
430
|
|
|
*/ |
|
431
|
|
|
function get_shipping_option() { |
|
432
|
|
|
global $wpdb, $wpsc_shipping_modules; |
|
433
|
|
|
|
|
434
|
|
|
if ( ( count( $this->shipping_quotes ) < 1 ) && |
|
435
|
|
|
isset( $wpsc_shipping_modules[$this->selected_shipping_method] ) && |
|
436
|
|
|
is_callable( array( $wpsc_shipping_modules[$this->selected_shipping_method], 'getQuote' ) ) ) { |
|
437
|
|
|
$this->shipping_quotes = $wpsc_shipping_modules[$this->selected_shipping_method]->getQuote(); |
|
438
|
|
|
} |
|
439
|
|
|
|
|
440
|
|
|
if ( ! isset( $wpsc_shipping_modules[$this->selected_shipping_method] ) ) { |
|
441
|
|
|
$this->selected_shipping_option = null; |
|
442
|
|
|
} |
|
443
|
|
|
|
|
444
|
|
|
if ( count( $this->shipping_quotes ) < 1 ) { |
|
445
|
|
|
$this->selected_shipping_option = null; |
|
446
|
|
|
} |
|
447
|
|
|
|
|
448
|
|
|
// if the current shipping option is not valid, go back to no shipping option |
|
449
|
|
|
if ( ! empty( $this->selected_shipping_option ) && ! isset( $this->shipping_quotes[$this->selected_shipping_option] ) ) { |
|
450
|
|
|
$this->selected_shipping_option = null; |
|
451
|
|
|
} |
|
452
|
|
|
|
|
453
|
|
|
// let the world pick a default shipping quote |
|
454
|
|
|
if ( empty( $this->selected_shipping_option ) && is_array( $this->shipping_quotes ) && ! empty( $this->shipping_quotes ) ) { |
|
455
|
|
|
$this->selected_shipping_option = apply_filters( 'wpsc_default_shipping_quote', $this->selected_shipping_option, $this->shipping_quotes, $this ); |
|
456
|
|
|
} |
|
457
|
|
|
|
|
458
|
|
|
$this->rewind_shipping_methods(); |
|
459
|
|
|
|
|
460
|
|
|
} |
|
461
|
|
|
|
|
462
|
|
|
/** |
|
463
|
|
|
* update_shipping method, updates the shipping |
|
464
|
|
|
* @access public |
|
465
|
|
|
*/ |
|
466
|
|
|
function update_shipping( $method, $option ) { |
|
467
|
|
|
global $wpdb, $wpsc_shipping_modules; |
|
468
|
|
|
|
|
|
|
|
|
|
469
|
|
|
|
|
470
|
|
|
if ( ! empty( $method ) ) { |
|
471
|
|
|
$this->selected_shipping_method = $method; |
|
472
|
|
|
} |
|
473
|
|
|
|
|
474
|
|
|
if ( ! empty( $option ) ) { |
|
475
|
|
|
$this->selected_shipping_option = $option; |
|
476
|
|
|
} |
|
477
|
|
|
|
|
478
|
|
|
$this->get_shipping_quotes(); |
|
479
|
|
|
|
|
480
|
|
|
// reapply coupon in case it's free shipping |
|
481
|
|
|
if ( $this->coupons_name ) { |
|
482
|
|
|
$coupon = new wpsc_coupons( $this->coupons_name ); |
|
483
|
|
|
if ( $coupon->is_free_shipping() ) |
|
484
|
|
|
$this->apply_coupons( $coupon->calculate_discount(), $this->coupons_name ); |
|
485
|
|
|
} |
|
486
|
|
|
} |
|
487
|
|
|
|
|
488
|
|
|
/** |
|
489
|
|
|
* get_tax_rate method, gets the tax rate as a percentage, based on the selected country and region |
|
490
|
|
|
* * EDIT: Replaced with WPEC Taxes - this function should probably be deprecated |
|
491
|
|
|
* Note: to refresh cart items use wpsc_refresh_cart_items |
|
492
|
|
|
* |
|
493
|
|
|
* @access public |
|
494
|
|
|
*/ |
|
495
|
|
|
function get_tax_rate() { |
|
496
|
|
|
$country = new WPSC_Country( get_option( 'base_country' ) ); |
|
497
|
|
|
|
|
498
|
|
|
$country_data = WPSC_Countries::get_country( get_option( 'base_country' ), true ); |
|
499
|
|
|
$add_tax = false; |
|
500
|
|
|
|
|
501
|
|
|
if ( $this->selected_country == get_option( 'base_country' ) ) { |
|
502
|
|
|
// Tax rules for various countries go here, if your countries tax rules |
|
503
|
|
|
// deviate from this, please supply code to add your region |
|
504
|
|
|
switch ( $this->selected_country ) { |
|
505
|
|
|
case 'US' : // USA! |
|
506
|
|
|
$tax_region = get_option( 'base_region' ); |
|
507
|
|
|
if ( $this->selected_region == get_option( 'base_region' ) && ( get_option( 'lock_tax_to_shipping' ) != '1' ) ) { |
|
508
|
|
|
// if they in the state, they pay tax |
|
509
|
|
|
$add_tax = true; |
|
510
|
|
|
} else if ( $this->delivery_region == get_option( 'base_region' ) ) { |
|
511
|
|
|
|
|
512
|
|
|
// if they live outside the state, but are delivering to within the state, they pay tax also |
|
513
|
|
|
$add_tax = true; |
|
514
|
|
|
} |
|
515
|
|
|
break; |
|
516
|
|
|
|
|
517
|
|
|
case 'CA' : // Canada! apparently in canada, the region that you are in is used for tax purposes |
|
518
|
|
|
if ( $this->selected_region != null ) { |
|
519
|
|
|
$tax_region = $this->selected_region; |
|
520
|
|
|
} else { |
|
521
|
|
|
$tax_region = get_option( 'base_region' ); |
|
522
|
|
|
} |
|
523
|
|
|
|
|
524
|
|
|
$add_tax = true; |
|
525
|
|
|
break; |
|
526
|
|
|
|
|
527
|
|
|
default : // Everywhere else! |
|
528
|
|
|
$tax_region = get_option( 'base_region' ); |
|
529
|
|
|
if ( $country->has_regions() ) { |
|
530
|
|
|
if ( get_option( 'base_region' ) == $tax_region ) { |
|
531
|
|
|
$add_tax = true; |
|
532
|
|
|
} |
|
533
|
|
|
} else { |
|
534
|
|
|
$add_tax = true; |
|
535
|
|
|
} |
|
536
|
|
|
break; |
|
537
|
|
|
} |
|
538
|
|
|
} |
|
539
|
|
|
|
|
540
|
|
|
if ( $add_tax == true ) { |
|
|
|
|
|
|
541
|
|
|
if ( $country->has_regions() ) { |
|
542
|
|
|
$region = $country->get_region( $tax_region ); |
|
|
|
|
|
|
543
|
|
|
$tax_percentage = $region->get_tax(); |
|
|
|
|
|
|
544
|
|
|
} else { |
|
545
|
|
|
$tax_percentage = $country->get_tax(); |
|
546
|
|
|
} |
|
547
|
|
|
} else { |
|
548
|
|
|
// no tax charged = tax equal to 0% |
|
549
|
|
|
$tax_percentage = 0; |
|
550
|
|
|
} |
|
551
|
|
|
|
|
552
|
|
|
if ( $this->tax_percentage != $tax_percentage ) { |
|
553
|
|
|
$this->clear_cache(); |
|
554
|
|
|
$this->tax_percentage = $tax_percentage; |
|
555
|
|
|
$this->wpsc_refresh_cart_items(); |
|
556
|
|
|
} |
|
557
|
|
|
} |
|
558
|
|
|
|
|
559
|
|
|
/** |
|
560
|
|
|
* Set Item method, requires a product ID and the parameters for the product |
|
561
|
|
|
* |
|
562
|
|
|
* @access public |
|
563
|
|
|
* |
|
564
|
|
|
* @param integer the product ID |
|
565
|
|
|
* @param array parameters |
|
566
|
|
|
* @return boolean true on sucess, false on failure |
|
567
|
|
|
*/ |
|
568
|
|
|
function set_item( $product_id, $parameters, $updater = false ) { |
|
569
|
|
|
|
|
570
|
|
|
// default action is adding |
|
571
|
|
|
$add_item = false; |
|
572
|
|
|
$edit_item = false; |
|
573
|
|
|
$variation_check = true; |
|
574
|
|
|
|
|
575
|
|
|
$parameters = wp_parse_args( $parameters, array( |
|
576
|
|
|
'quantity' => 0, |
|
577
|
|
|
'variation_values' => null |
|
578
|
|
|
) ); |
|
579
|
|
|
|
|
580
|
|
|
if ( wpsc_product_has_variations( $product_id ) && is_null( $parameters['variation_values'] ) ) { |
|
581
|
|
|
$variation_check = false; |
|
582
|
|
|
} |
|
583
|
|
|
|
|
584
|
|
|
if ( $variation_check && $parameters['quantity'] > 0 && $this->check_remaining_quantity( $product_id, $parameters['variation_values'], $parameters['quantity'] ) ) { |
|
585
|
|
|
|
|
586
|
|
|
$new_cart_item = new wpsc_cart_item( $product_id, $parameters, $this ); |
|
587
|
|
|
|
|
588
|
|
|
do_action( 'wpsc_set_cart_item', $product_id, $parameters, $this, $new_cart_item ); |
|
589
|
|
|
|
|
590
|
|
|
$add_item = true; |
|
591
|
|
|
$edit_item = false; |
|
592
|
|
|
|
|
593
|
|
|
if ( count( $this->cart_items ) > 0 && $new_cart_item->is_donation != 1 ) { |
|
594
|
|
|
|
|
595
|
|
|
// loop through each cart item |
|
596
|
|
|
foreach ( $this->cart_items as $key => $cart_item ) { |
|
597
|
|
|
|
|
598
|
|
|
// compare product ids and variations. |
|
599
|
|
|
if ( $cart_item->product_id == $new_cart_item->product_id && $cart_item->product_variations == $new_cart_item->product_variations && $cart_item->custom_message == $new_cart_item->custom_message && $cart_item->custom_file == $new_cart_item->custom_file && $cart_item->item_meta_equal( $new_cart_item ) ) { |
|
600
|
|
|
|
|
601
|
|
|
// if they are the same, increment the count, and break out; |
|
602
|
|
|
if ( ! $updater ) { |
|
603
|
|
|
$this->cart_items[$key]->quantity += $new_cart_item->quantity; |
|
604
|
|
|
} else { |
|
605
|
|
|
$this->cart_items[$key]->quantity = $new_cart_item->quantity; |
|
606
|
|
|
} |
|
607
|
|
|
|
|
608
|
|
|
$this->cart_items[$key]->refresh_item(); |
|
609
|
|
|
|
|
610
|
|
|
$add_item = false; |
|
611
|
|
|
$edit_item = true; |
|
612
|
|
|
|
|
613
|
|
|
do_action( 'wpsc_edit_item', $product_id, $parameters, $this ); |
|
614
|
|
|
} |
|
615
|
|
|
} |
|
616
|
|
|
} |
|
617
|
|
|
|
|
618
|
|
|
// if we are still adding the item, add it |
|
619
|
|
|
if ( $add_item ) { |
|
620
|
|
|
$this->cart_items[] = $new_cart_item; |
|
621
|
|
|
do_action( 'wpsc_add_item', $product_id, $parameters, $this ); |
|
622
|
|
|
} |
|
623
|
|
|
} |
|
624
|
|
|
|
|
625
|
|
|
// if some action was performed, return true, otherwise, return false; |
|
626
|
|
|
$status = false; |
|
627
|
|
|
if ( $add_item || $edit_item ) { |
|
628
|
|
|
$status = $new_cart_item; |
|
|
|
|
|
|
629
|
|
|
} |
|
630
|
|
|
|
|
631
|
|
|
$this->cart_item_count = count( $this->cart_items ); |
|
632
|
|
|
$this->clear_cache(); |
|
633
|
|
|
|
|
634
|
|
|
return $status; |
|
635
|
|
|
} |
|
636
|
|
|
|
|
637
|
|
|
/** |
|
638
|
|
|
* Edit Item method |
|
639
|
|
|
* |
|
640
|
|
|
* @access public |
|
641
|
|
|
* |
|
642
|
|
|
* @param integer a cart_items key |
|
643
|
|
|
* @param array an array of parameters to change |
|
644
|
|
|
* @return boolean true on sucess, false on failure |
|
645
|
|
|
*/ |
|
646
|
|
|
function edit_item( $key, $parameters ) { |
|
647
|
|
|
if ( isset( $this->cart_items[$key] ) ) { |
|
648
|
|
|
$product_id = $this->cart_items[$key]->product_id; |
|
649
|
|
|
$quantity = $parameters ['quantity'] - $this->cart_items[$key]->quantity; |
|
650
|
|
|
if ( $this->check_remaining_quantity( $product_id, $this->cart_items[$key]->variation_values, $quantity ) == true ) { |
|
|
|
|
|
|
651
|
|
|
foreach ( $parameters as $name => $value ) { |
|
652
|
|
|
$this->cart_items[$key]->$name = $value; |
|
653
|
|
|
} |
|
654
|
|
|
$this->cart_items[$key]->refresh_item(); |
|
655
|
|
|
do_action( 'wpsc_edit_item', $product_id, $parameters, $this, $key ); |
|
656
|
|
|
$this->clear_cache(); |
|
657
|
|
|
} |
|
658
|
|
|
|
|
659
|
|
|
return true; |
|
660
|
|
|
} else { |
|
661
|
|
|
return false; |
|
662
|
|
|
} |
|
663
|
|
|
} |
|
664
|
|
|
|
|
665
|
|
|
/** |
|
666
|
|
|
* check remaining quantity method |
|
667
|
|
|
* currently only checks remaining stock, in future will do claimed stock and quantity limits |
|
668
|
|
|
* will need to return errors, then, rather than true/false, maybe use the wp_error object? |
|
669
|
|
|
* |
|
670
|
|
|
* @access public |
|
671
|
|
|
* |
|
672
|
|
|
* @param integer a product ID key |
|
673
|
|
|
* @param array variations on the product |
|
674
|
|
|
* @return boolean true on sucess, false on failure |
|
675
|
|
|
*/ |
|
676
|
|
|
function check_remaining_quantity( $product_id, $variations = array(), $quantity = 1 ) { |
|
677
|
|
|
|
|
678
|
|
|
$stock = get_post_meta( $product_id, '_wpsc_stock', true ); |
|
679
|
|
|
$stock = apply_filters( 'wpsc_product_stock', $stock, $product_id, $this ); |
|
680
|
|
|
|
|
681
|
|
|
$result = true; |
|
682
|
|
|
|
|
683
|
|
|
if ( is_numeric( $stock ) ) { |
|
684
|
|
|
$remaining_quantity = wpsc_get_remaining_quantity( $product_id, $variations, $quantity ); |
|
685
|
|
|
if ( $remaining_quantity < $quantity ) { |
|
686
|
|
|
$result = false; |
|
687
|
|
|
} |
|
688
|
|
|
} |
|
689
|
|
|
return $result; |
|
690
|
|
|
} |
|
691
|
|
|
|
|
692
|
|
|
/** |
|
693
|
|
|
* get remaining quantity method |
|
694
|
|
|
* currently only checks remaining stock, in future will do claimed stock and quantity limits |
|
695
|
|
|
* will need to return errors, then, rather than true/false, maybe use the wp_error object? |
|
696
|
|
|
* @access public |
|
697
|
|
|
* |
|
698
|
|
|
* @param integer a product ID key |
|
699
|
|
|
* @param array variations on the product |
|
700
|
|
|
* |
|
701
|
|
|
* @return int Number of product remaining. |
|
702
|
|
|
*/ |
|
703
|
|
|
function get_remaining_quantity( $product_id, $variations = array(), $quantity = 1 ) { |
|
704
|
|
|
return wpsc_get_remaining_quantity( $product_id, $variations, $quantity ); |
|
705
|
|
|
} |
|
706
|
|
|
|
|
707
|
|
|
/** |
|
708
|
|
|
* Remove Item method |
|
709
|
|
|
* |
|
710
|
|
|
* @access public |
|
711
|
|
|
* |
|
712
|
|
|
* @param integer a cart_items key |
|
713
|
|
|
* @return boolean true on sucess, false on failure |
|
714
|
|
|
*/ |
|
715
|
|
|
function remove_item( $key ) { |
|
716
|
|
|
if ( isset( $this->cart_items[$key] ) ) { |
|
717
|
|
|
$cart_item = & $this->cart_items[$key]; |
|
718
|
|
|
$cart_item->update_item( 0 ); |
|
719
|
|
|
unset( $this->cart_items[$key] ); |
|
720
|
|
|
$this->cart_items = array_values( $this->cart_items ); |
|
721
|
|
|
$this->cart_item_count = count( $this->cart_items ); |
|
722
|
|
|
$this->current_cart_item = - 1; |
|
723
|
|
|
do_action( 'wpsc_remove_item', $key, $this, $cart_item ); |
|
724
|
|
|
|
|
725
|
|
|
$this->clear_cache(); |
|
726
|
|
|
return true; |
|
727
|
|
|
} else { |
|
728
|
|
|
$this->clear_cache(); |
|
729
|
|
|
return false; |
|
730
|
|
|
} |
|
731
|
|
|
} |
|
732
|
|
|
|
|
733
|
|
|
/** |
|
734
|
|
|
* Empty Cart method |
|
735
|
|
|
* |
|
736
|
|
|
* @access public |
|
737
|
|
|
* |
|
738
|
|
|
* No parameters, nothing returned |
|
739
|
|
|
*/ |
|
740
|
|
|
function empty_cart( $fromwidget = true ) { |
|
|
|
|
|
|
741
|
|
|
$claimed_query = new WPSC_Claimed_Stock( array( 'cart_id' => $this->unique_id ) ); |
|
742
|
|
|
$claimed_query->clear_claimed_stock( 0 ); |
|
743
|
|
|
|
|
744
|
|
|
$this->cart_items = array(); |
|
745
|
|
|
$this->cart_item = null; |
|
746
|
|
|
$this->cart_item_count = 0; |
|
747
|
|
|
$this->current_cart_item = - 1; |
|
748
|
|
|
$this->coupons_amount = 0; |
|
749
|
|
|
$this->coupons_name = ''; |
|
750
|
|
|
|
|
751
|
|
|
$this->clear_cache(); |
|
752
|
|
|
$this->cleanup(); |
|
753
|
|
|
do_action( 'wpsc_clear_cart', $this ); |
|
754
|
|
|
} |
|
755
|
|
|
|
|
756
|
|
|
/** |
|
757
|
|
|
* Clear Cache method, used to clear the cached totals |
|
758
|
|
|
* |
|
759
|
|
|
* @access public |
|
760
|
|
|
* |
|
761
|
|
|
* No parameters, nothing returned |
|
762
|
|
|
*/ |
|
763
|
|
|
function clear_cache() { |
|
764
|
|
|
$this->total_tax = null; |
|
765
|
|
|
$this->base_shipping = null; |
|
766
|
|
|
$this->total_item_shipping = null; |
|
767
|
|
|
$this->total_shipping = null; |
|
768
|
|
|
$this->subtotal = null; |
|
769
|
|
|
$this->total_price = null; |
|
770
|
|
|
$this->uses_shipping = null; |
|
771
|
|
|
$this->shipping_quotes = null; |
|
|
|
|
|
|
772
|
|
|
$this->get_shipping_option(); |
|
773
|
|
|
do_action( 'wpsc_after_cart_clear_cache', $this ); |
|
774
|
|
|
} |
|
775
|
|
|
|
|
776
|
|
|
/** |
|
777
|
|
|
* submit_stock_claims method, changes the association of the stock claims from the cart unique to the purchase log |
|
778
|
|
|
* ID |
|
779
|
|
|
* |
|
780
|
|
|
* @access public |
|
781
|
|
|
* |
|
782
|
|
|
* No parameters, nothing returned |
|
783
|
|
|
*/ |
|
784
|
|
|
function submit_stock_claims( $purchase_log_id ) { |
|
785
|
|
|
$claimed_query = new WPSC_Claimed_Stock( array( 'cart_id' => $this->unique_id ) ); |
|
786
|
|
|
$claimed_query->submit_claimed_stock( $purchase_log_id ); |
|
787
|
|
|
} |
|
788
|
|
|
|
|
789
|
|
|
/** |
|
790
|
|
|
* cleanup method, cleans up the cart just before final destruction |
|
791
|
|
|
* |
|
792
|
|
|
* @access public |
|
793
|
|
|
* |
|
794
|
|
|
* No parameters, nothing returned |
|
795
|
|
|
*/ |
|
796
|
|
|
function cleanup() { |
|
797
|
|
|
wpsc_delete_customer_meta( 'coupon' ); |
|
798
|
|
|
$claimed_query = new WPSC_Claimed_Stock( array( 'cart_id' => $this->unique_id ) ); |
|
799
|
|
|
$claimed_query->clear_claimed_stock( 0 ); |
|
800
|
|
|
} |
|
801
|
|
|
|
|
802
|
|
|
/** |
|
803
|
|
|
* Calculate total price method |
|
804
|
|
|
* |
|
805
|
|
|
* @access public |
|
806
|
|
|
* |
|
807
|
|
|
* @return float returns the price as a floating point value |
|
808
|
|
|
*/ |
|
809
|
|
|
function calculate_total_price() { |
|
810
|
|
|
|
|
811
|
|
|
// Calculate individual component that comprise the cart total |
|
812
|
|
|
$subtotal = $this->calculate_subtotal(); |
|
813
|
|
|
$shipping = $this->calculate_total_shipping(); |
|
814
|
|
|
|
|
815
|
|
|
// Get tax only if it is included |
|
816
|
|
|
$tax = ( ! wpsc_tax_isincluded() ) ? $this->calculate_total_tax() : 0.00; |
|
817
|
|
|
|
|
818
|
|
|
// Get coupon amount, note that no matter what float precision this |
|
819
|
|
|
// coupon amount is, it's always saved to the database with rounded |
|
820
|
|
|
// value anyways |
|
821
|
|
|
$coupons_amount = round( $this->coupons_amount, 2 ); |
|
822
|
|
|
|
|
823
|
|
|
// Calculate the total |
|
824
|
|
|
$total = ( $subtotal > $coupons_amount ) ? ( ( $subtotal - $coupons_amount ) + $shipping + $tax ) : ( $tax + $shipping ); |
|
825
|
|
|
|
|
826
|
|
|
// Filter total |
|
827
|
|
|
$total = apply_filters( 'wpsc_calculate_total_price', $total, $subtotal, $shipping, $tax, $coupons_amount, $this ); |
|
828
|
|
|
|
|
829
|
|
|
// Set variable and return |
|
830
|
|
|
$this->total_price = $total; |
|
831
|
|
|
|
|
832
|
|
|
return $total; |
|
833
|
|
|
} |
|
834
|
|
|
|
|
835
|
|
|
/** |
|
836
|
|
|
* calculate_subtotal method |
|
837
|
|
|
* |
|
838
|
|
|
* @access public |
|
839
|
|
|
* |
|
840
|
|
|
* @param boolean for_shipping = exclude items with no shipping, |
|
841
|
|
|
* @return float returns the price as a floating point value |
|
842
|
|
|
*/ |
|
843
|
|
|
function calculate_subtotal( $for_shipping = false ) { |
|
844
|
|
|
global $wpdb; |
|
845
|
|
|
if ( $for_shipping == true ) { |
|
|
|
|
|
|
846
|
|
|
$total = 0; |
|
847
|
|
|
foreach ( $this->cart_items as $key => $cart_item ) { |
|
848
|
|
|
if ( $cart_item->uses_shipping == 1 ) { |
|
849
|
|
|
$total += $cart_item->total_price; |
|
850
|
|
|
} |
|
851
|
|
|
} |
|
852
|
|
|
} else { |
|
853
|
|
|
$total = 0; |
|
854
|
|
|
if ( $this->subtotal == null ) { |
|
855
|
|
|
foreach ( $this->cart_items as $key => $cart_item ) { |
|
856
|
|
|
$total += $cart_item->total_price; |
|
857
|
|
|
} |
|
858
|
|
|
$this->subtotal = $total; |
|
859
|
|
|
} else { |
|
860
|
|
|
$total = $this->subtotal; |
|
861
|
|
|
} |
|
862
|
|
|
} |
|
863
|
|
|
|
|
864
|
|
|
return $total; |
|
865
|
|
|
} |
|
866
|
|
|
|
|
867
|
|
|
/** |
|
868
|
|
|
* Return the cart items. |
|
869
|
|
|
* |
|
870
|
|
|
* Accept an array of arguments: |
|
871
|
|
|
* |
|
872
|
|
|
* - 'fields': Defaults to 'all', which returns all the fields. Otherwise, specify a field such |
|
873
|
|
|
* as 'quantity' or 'pnp' to get an array of that field only. |
|
874
|
|
|
* - 'orderby': Specify a field to sort the cart items. Default to '', which means "unsorted". |
|
875
|
|
|
* - 'order' : Specify the direction of the sort, 'ASC' for ascending, 'DESC' for descending. |
|
876
|
|
|
* Defaults to 'DESC' |
|
877
|
|
|
* @since 3.8.9 |
|
878
|
|
|
* @access public |
|
879
|
|
|
* @param array $args Array of arguments |
|
880
|
|
|
* @return array Cart items |
|
881
|
|
|
*/ |
|
882
|
|
|
public function get_items( $args = array() ) { |
|
883
|
|
|
$defaults = array( |
|
884
|
|
|
'fields' => 'all', |
|
885
|
|
|
'orderby' => '', |
|
886
|
|
|
'order' => 'ASC', |
|
887
|
|
|
); |
|
888
|
|
|
|
|
889
|
|
|
$r = wp_parse_args( $args, $defaults ); |
|
890
|
|
|
extract( $r, EXTR_SKIP ); |
|
|
|
|
|
|
891
|
|
|
|
|
892
|
|
|
$results = $this->cart_items; |
|
893
|
|
|
|
|
894
|
|
|
if ( ! empty( $orderby ) ) { |
|
895
|
|
|
$comparison = new _WPSC_Comparison( $orderby, $order ); |
|
896
|
|
|
usort( $results, array( $comparison, 'compare' ) ); |
|
897
|
|
|
} |
|
898
|
|
|
|
|
899
|
|
|
if ( $fields != 'all' ) |
|
900
|
|
|
$results = wp_list_pluck( $results, $fields ); |
|
901
|
|
|
|
|
902
|
|
|
return $results; |
|
903
|
|
|
} |
|
904
|
|
|
|
|
905
|
|
|
/** |
|
906
|
|
|
* calculate total tax method |
|
907
|
|
|
* |
|
908
|
|
|
* @access public |
|
909
|
|
|
* @return float returns the price as a floating point value |
|
910
|
|
|
*/ |
|
911
|
|
|
function calculate_total_tax() { |
|
912
|
|
|
$wpec_taxes_controller = new wpec_taxes_controller(); |
|
913
|
|
|
$taxes_total = $wpec_taxes_controller->wpec_taxes_calculate_total(); |
|
914
|
|
|
$this->total_tax = $taxes_total ['total']; |
|
915
|
|
|
|
|
916
|
|
|
if ( isset( $taxes_total['rate'] ) ) |
|
917
|
|
|
$this->tax_percentage = $taxes_total['rate']; |
|
918
|
|
|
|
|
919
|
|
|
return apply_filters( 'wpsc_calculate_total_tax', $this->total_tax, $this ); |
|
920
|
|
|
} |
|
921
|
|
|
|
|
922
|
|
|
/** |
|
923
|
|
|
* calculate_total_weight method |
|
924
|
|
|
* |
|
925
|
|
|
* @access public |
|
926
|
|
|
* |
|
927
|
|
|
* @param boolean for_shipping = exclude items with no shipping, |
|
928
|
|
|
* @return float returns the price as a floating point value |
|
929
|
|
|
*/ |
|
930
|
|
|
function calculate_total_weight( $for_shipping = false ) { |
|
931
|
|
|
global $wpdb; |
|
932
|
|
|
$total = ''; |
|
933
|
|
|
if ( $for_shipping == true ) { |
|
|
|
|
|
|
934
|
|
|
foreach ( $this->cart_items as $key => $cart_item ) { |
|
935
|
|
|
if ( $cart_item->uses_shipping == 1 ) { |
|
936
|
|
|
$total += $cart_item->weight * $cart_item->quantity; |
|
937
|
|
|
} |
|
938
|
|
|
} |
|
939
|
|
|
} else { |
|
940
|
|
|
foreach ( $this->cart_items as $key => $cart_item ) { |
|
941
|
|
|
$total += $cart_item->weight * $cart_item->quantity; |
|
942
|
|
|
} |
|
943
|
|
|
} |
|
944
|
|
|
return $total; |
|
945
|
|
|
} |
|
946
|
|
|
|
|
947
|
|
|
public function get_total_shipping_quantity() { |
|
948
|
|
|
$total = 0; |
|
949
|
|
|
|
|
950
|
|
|
foreach ( $this->cart_items as $key => $cart_item ) { |
|
951
|
|
|
if ( $cart_item->uses_shipping ) |
|
952
|
|
|
$total += $cart_item->quantity; |
|
953
|
|
|
} |
|
954
|
|
|
|
|
955
|
|
|
return $total; |
|
956
|
|
|
} |
|
957
|
|
|
|
|
958
|
|
|
/** |
|
959
|
|
|
* get category url name method |
|
960
|
|
|
* |
|
961
|
|
|
* @access public |
|
962
|
|
|
* |
|
963
|
|
|
* @return float returns the price as a floating point value |
|
|
|
|
|
|
964
|
|
|
*/ |
|
965
|
|
|
function get_item_categories() { |
|
966
|
|
|
$category_list = array(); |
|
967
|
|
|
foreach ( $this->cart_items as $key => $cart_item ) { |
|
968
|
|
|
$category_list = array_merge( ( array ) $cart_item->category_list, $category_list ); |
|
|
|
|
|
|
969
|
|
|
} |
|
970
|
|
|
return $category_list; |
|
971
|
|
|
} |
|
972
|
|
|
|
|
973
|
|
|
/** |
|
974
|
|
|
* get category IDs total price method |
|
975
|
|
|
* |
|
976
|
|
|
* @access public |
|
977
|
|
|
* |
|
978
|
|
|
* @return float returns the price as a floating point value |
|
|
|
|
|
|
979
|
|
|
*/ |
|
980
|
|
|
function get_item_category_ids() { |
|
981
|
|
|
$category_list = array(); |
|
982
|
|
|
foreach ( $this->cart_items as $key => $cart_item ) { |
|
983
|
|
|
$category_list = array_merge( ( array ) $cart_item->category_id_list, $category_list ); |
|
|
|
|
|
|
984
|
|
|
} |
|
985
|
|
|
return $category_list; |
|
986
|
|
|
} |
|
987
|
|
|
|
|
988
|
|
|
/** |
|
989
|
|
|
* calculate_total_shipping method, gets the shipping option from the selected method and associated quotes |
|
990
|
|
|
* |
|
991
|
|
|
* @access public |
|
992
|
|
|
* @return float returns the shipping as a floating point value |
|
993
|
|
|
*/ |
|
994
|
|
|
function calculate_total_shipping() { |
|
995
|
|
|
$shipping_discount_value = get_option( 'shipping_discount_value' ); |
|
996
|
|
|
$is_free_shipping_enabled = get_option( 'shipping_discount' ); |
|
997
|
|
|
$subtotal = $this->calculate_subtotal(); |
|
998
|
|
|
|
|
999
|
|
|
$has_free_shipping = $is_free_shipping_enabled && $shipping_discount_value > 0 && $shipping_discount_value <= $subtotal; |
|
1000
|
|
|
|
|
1001
|
|
|
if ( ! wpsc_uses_shipping() || $has_free_shipping ) { |
|
1002
|
|
|
$total = 0; |
|
1003
|
|
|
} else { |
|
1004
|
|
|
$total = $this->calculate_base_shipping(); |
|
1005
|
|
|
$total += $this->calculate_per_item_shipping(); |
|
1006
|
|
|
} |
|
1007
|
|
|
|
|
1008
|
|
|
return apply_filters( 'wpsc_convert_total_shipping', $total, $this ); |
|
1009
|
|
|
} |
|
1010
|
|
|
|
|
1011
|
|
|
/** |
|
1012
|
|
|
* has_total_shipping_discount method, checks whether the carts subtotal is larger or equal to the shipping discount |
|
1013
|
|
|
* * value |
|
1014
|
|
|
* |
|
1015
|
|
|
* @access public |
|
1016
|
|
|
* @return float returns true or false depending on whether the cart subtotal is larger or equal to the shipping * |
|
1017
|
|
|
* discount value. |
|
1018
|
|
|
*/ |
|
1019
|
|
|
function has_total_shipping_discount() { |
|
1020
|
|
|
$shipping_discount_value = get_option( 'shipping_discount_value' ); |
|
1021
|
|
|
return get_option( 'shipping_discount' ) && $shipping_discount_value > 0 && $shipping_discount_value <= $this->calculate_subtotal(); |
|
1022
|
|
|
} |
|
1023
|
|
|
|
|
1024
|
|
|
/** |
|
1025
|
|
|
* calculate_base_shipping method, gets the shipping option from the selected method and associated quotes |
|
1026
|
|
|
* |
|
1027
|
|
|
* @access public |
|
1028
|
|
|
* @return float returns the shipping as a floating point value |
|
1029
|
|
|
*/ |
|
1030
|
|
|
function calculate_base_shipping() { |
|
1031
|
|
|
global $wpdb, $wpsc_shipping_modules; |
|
1032
|
|
|
|
|
1033
|
|
|
if ( $this->uses_shipping() ) { |
|
1034
|
|
|
if ( isset( $wpsc_shipping_modules[ $this->selected_shipping_method ] ) |
|
1035
|
|
|
&& is_callable( array( $wpsc_shipping_modules[ $this->selected_shipping_method ], 'getQuote' ) ) |
|
1036
|
|
|
) { |
|
1037
|
|
|
$this->shipping_quotes = $wpsc_shipping_modules[ $this->selected_shipping_method ]->getQuote(); |
|
1038
|
|
|
} |
|
1039
|
|
|
|
|
1040
|
|
|
if ( $this->selected_shipping_option == null ) { |
|
1041
|
|
|
$this->get_shipping_option(); |
|
1042
|
|
|
} |
|
1043
|
|
|
|
|
1044
|
|
|
$total = isset( $this->shipping_quotes[ $this->selected_shipping_option ] ) ? ( float ) $this->shipping_quotes[ $this->selected_shipping_option ] : 0; |
|
|
|
|
|
|
1045
|
|
|
$this->base_shipping = $total; |
|
1046
|
|
|
} else { |
|
1047
|
|
|
$total = 0; |
|
1048
|
|
|
} |
|
1049
|
|
|
|
|
1050
|
|
|
return $total; |
|
1051
|
|
|
} |
|
1052
|
|
|
|
|
1053
|
|
|
/** |
|
1054
|
|
|
* calculate_per_item_shipping method, gets the shipping option from the selected method and associated quotesing |
|
1055
|
|
|
* |
|
1056
|
|
|
* @access public |
|
1057
|
|
|
* @return float returns the shipping as a floating point value |
|
1058
|
|
|
*/ |
|
1059
|
|
|
function calculate_per_item_shipping( $method = null ) { |
|
1060
|
|
|
global $wpdb, $wpsc_shipping_modules; |
|
1061
|
|
|
$total = ''; |
|
1062
|
|
|
if ( $method == null ) { |
|
1063
|
|
|
$method = $this->selected_shipping_method; |
|
1064
|
|
|
} |
|
1065
|
|
|
foreach ( ( array ) $this->cart_items as $cart_item ) { |
|
|
|
|
|
|
1066
|
|
|
$total += $cart_item->calculate_shipping( $method ); |
|
1067
|
|
|
} |
|
1068
|
|
|
if ( $method == $this->selected_shipping_method ) { |
|
1069
|
|
|
$this->total_item_shipping = $total; |
|
1070
|
|
|
} |
|
1071
|
|
|
return $total; |
|
1072
|
|
|
} |
|
1073
|
|
|
|
|
1074
|
|
|
/** |
|
1075
|
|
|
* uses shipping method, to determine if shipping is used. |
|
1076
|
|
|
* |
|
1077
|
|
|
* @access public |
|
1078
|
|
|
* (!(get_option('shipping_discount')== 1) && (get_option('shipping_discount_value') <= |
|
1079
|
|
|
* $wpsc_cart->calculate_subtotal())) |
|
1080
|
|
|
* @return float returns the price as a floating point value |
|
1081
|
|
|
*/ |
|
1082
|
|
|
function uses_shipping() { |
|
1083
|
|
|
global $wpdb; |
|
1084
|
|
|
|
|
1085
|
|
|
if ( get_option( 'do_not_use_shipping' ) ) { |
|
1086
|
|
|
return false; |
|
1087
|
|
|
} |
|
1088
|
|
|
|
|
1089
|
|
|
$uses_shipping = 0; |
|
1090
|
|
|
if ( ( $this->uses_shipping == null ) ) { |
|
1091
|
|
|
foreach ( $this->cart_items as $key => $cart_item ) { |
|
1092
|
|
|
$uses_shipping += ( int ) $cart_item->uses_shipping; |
|
|
|
|
|
|
1093
|
|
|
} |
|
1094
|
|
|
} else { |
|
1095
|
|
|
$uses_shipping = $this->uses_shipping; |
|
1096
|
|
|
} |
|
1097
|
|
|
|
|
1098
|
|
|
$this->uses_shipping = $uses_shipping; |
|
1099
|
|
|
|
|
1100
|
|
|
return $uses_shipping; |
|
1101
|
|
|
} |
|
1102
|
|
|
|
|
1103
|
|
|
/** |
|
1104
|
|
|
* process_as_currency method |
|
1105
|
|
|
* |
|
1106
|
|
|
* @access public |
|
1107
|
|
|
* |
|
1108
|
|
|
* @param float a price |
|
1109
|
|
|
* @return string a price with a currency sign |
|
1110
|
|
|
*/ |
|
1111
|
|
|
function process_as_currency( $price ) { |
|
1112
|
|
|
_wpsc_deprecated_function( __FUNCTION__, '3.8', 'wpsc_currency_display' ); |
|
1113
|
|
|
return wpsc_currency_display( $price ); |
|
1114
|
|
|
} |
|
1115
|
|
|
|
|
1116
|
|
|
/** |
|
1117
|
|
|
* save_to_db method, saves the cart to the database |
|
1118
|
|
|
* |
|
1119
|
|
|
* @access public |
|
1120
|
|
|
* |
|
1121
|
|
|
*/ |
|
1122
|
|
|
function save_to_db( $purchase_log_id ) { |
|
1123
|
|
|
global $wpdb; |
|
1124
|
|
|
|
|
1125
|
|
|
foreach ( $this->cart_items as $key => $cart_item ) { |
|
1126
|
|
|
$cart_item->save_to_db( $purchase_log_id ); |
|
1127
|
|
|
} |
|
1128
|
|
|
} |
|
1129
|
|
|
|
|
1130
|
|
|
public function empty_db( $purchase_log_id ) { |
|
1131
|
|
|
global $wpdb; |
|
1132
|
|
|
$sql = $wpdb->prepare( 'DELETE FROM ' . WPSC_TABLE_CART_CONTENTS . ' WHERE purchaseid = %d', $purchase_log_id ); |
|
1133
|
|
|
$wpdb->query( $sql ); |
|
1134
|
|
|
} |
|
1135
|
|
|
|
|
1136
|
|
|
/** |
|
1137
|
|
|
* cart loop methods |
|
1138
|
|
|
*/ |
|
1139
|
|
|
function next_cart_item() { |
|
1140
|
|
|
$this->current_cart_item ++; |
|
1141
|
|
|
$this->cart_item = $this->cart_items[$this->current_cart_item]; |
|
1142
|
|
|
return $this->cart_item; |
|
1143
|
|
|
} |
|
1144
|
|
|
|
|
1145
|
|
|
function the_cart_item() { |
|
1146
|
|
|
$this->in_the_loop = true; |
|
1147
|
|
|
$this->cart_item = $this->next_cart_item(); |
|
1148
|
|
|
if ( $this->current_cart_item == 0 ) // loop has just started |
|
1149
|
|
|
do_action( 'wpsc_cart_loop_start' ); |
|
1150
|
|
|
} |
|
1151
|
|
|
|
|
1152
|
|
|
function have_cart_items() { |
|
1153
|
|
|
if ( $this->current_cart_item + 1 < $this->cart_item_count ) { |
|
1154
|
|
|
return true; |
|
1155
|
|
|
} else if ( $this->current_cart_item + 1 == $this->cart_item_count && $this->cart_item_count > 0 ) { |
|
1156
|
|
|
do_action( 'wpsc_cart_loop_end' ); |
|
1157
|
|
|
// Do some cleaning up after the loop, |
|
1158
|
|
|
$this->rewind_cart_items(); |
|
1159
|
|
|
} |
|
1160
|
|
|
|
|
1161
|
|
|
$this->in_the_loop = false; |
|
1162
|
|
|
return false; |
|
1163
|
|
|
} |
|
1164
|
|
|
|
|
1165
|
|
|
function rewind_cart_items() { |
|
1166
|
|
|
$this->current_cart_item = - 1; |
|
1167
|
|
|
if ( $this->cart_item_count > 0 ) { |
|
1168
|
|
|
$this->cart_item = $this->cart_items[0]; |
|
1169
|
|
|
} |
|
1170
|
|
|
} |
|
1171
|
|
|
|
|
1172
|
|
|
/** |
|
1173
|
|
|
* shipping_methods methods |
|
1174
|
|
|
*/ |
|
1175
|
|
|
function next_shipping_method() { |
|
1176
|
|
|
$this->current_shipping_method ++; |
|
1177
|
|
|
$this->shipping_method = $this->shipping_methods [$this->current_shipping_method]; |
|
1178
|
|
|
return $this->shipping_method; |
|
1179
|
|
|
} |
|
1180
|
|
|
|
|
1181
|
|
|
function the_shipping_method() { |
|
1182
|
|
|
$this->shipping_method = $this->next_shipping_method(); |
|
1183
|
|
|
$this->get_shipping_quotes(); |
|
1184
|
|
|
} |
|
1185
|
|
|
|
|
1186
|
|
|
function have_shipping_methods() { |
|
1187
|
|
|
if ( $this->current_shipping_method + 1 < $this->shipping_method_count ) { |
|
1188
|
|
|
return true; |
|
1189
|
|
|
} else if ( $this->current_shipping_method + 1 == $this->shipping_method_count && $this->shipping_method_count > 0 ) { |
|
1190
|
|
|
// Do some cleaning up after the loop, |
|
1191
|
|
|
$this->rewind_shipping_methods(); |
|
1192
|
|
|
} |
|
1193
|
|
|
return false; |
|
1194
|
|
|
} |
|
1195
|
|
|
|
|
1196
|
|
|
function rewind_shipping_methods() { |
|
1197
|
|
|
|
|
1198
|
|
|
$this->current_shipping_method = - 1; |
|
1199
|
|
|
|
|
1200
|
|
|
$this->shipping_method_count = count( $this->shipping_methods ); |
|
1201
|
|
|
|
|
1202
|
|
|
if ( $this->shipping_method_count > 0 ) { |
|
1203
|
|
|
$this->shipping_method = $this->shipping_methods[0]; |
|
1204
|
|
|
} |
|
1205
|
|
|
} |
|
1206
|
|
|
|
|
1207
|
|
|
/** |
|
1208
|
|
|
* shipping_quotes methods |
|
1209
|
|
|
*/ |
|
1210
|
|
|
function get_shipping_quotes() { |
|
1211
|
|
|
|
|
1212
|
|
|
global $wpdb, $wpsc_shipping_modules; |
|
1213
|
|
|
$this->shipping_quotes = array(); |
|
1214
|
|
|
if ( $this->shipping_method == null ) { |
|
1215
|
|
|
$this->get_shipping_method(); |
|
1216
|
|
|
} |
|
1217
|
|
|
if ( isset( $wpsc_shipping_modules[$this->shipping_method] ) && is_callable( array( $wpsc_shipping_modules [$this->shipping_method], 'getQuote' ) ) ) { |
|
1218
|
|
|
$unprocessed_shipping_quotes = $wpsc_shipping_modules[$this->shipping_method]->getQuote(); |
|
1219
|
|
|
} |
|
1220
|
|
|
$num = 0; |
|
1221
|
|
|
if ( ! empty( $unprocessed_shipping_quotes ) ) { |
|
1222
|
|
|
foreach ( ( array ) $unprocessed_shipping_quotes as $shipping_key => $shipping_value ) { |
|
|
|
|
|
|
1223
|
|
|
$per_item_shipping = $this->calculate_per_item_shipping( $this->shipping_method ); |
|
1224
|
|
|
$this->shipping_quotes [$num] ['name'] = $shipping_key; |
|
1225
|
|
|
$this->shipping_quotes [$num] ['value'] = ( float ) $shipping_value + ( float ) $per_item_shipping; |
|
|
|
|
|
|
1226
|
|
|
$num ++; |
|
1227
|
|
|
} |
|
1228
|
|
|
} |
|
1229
|
|
|
|
|
1230
|
|
|
$this->shipping_quote_count = count( $this->shipping_quotes ); |
|
1231
|
|
|
} |
|
1232
|
|
|
|
|
1233
|
|
|
/** |
|
1234
|
|
|
* If there is only one quote, set it as the default. |
|
1235
|
|
|
* |
|
1236
|
|
|
* @param string $selected_option The currently selected rate. |
|
1237
|
|
|
* @param array $shipping_quotes Array of all available shipping quotes. |
|
1238
|
|
|
* @param WPSC_Cart $wpsc_cart The WPSC_Cart object. |
|
1239
|
|
|
*/ |
|
1240
|
|
|
function set_default_shipping_quote( $selected_option, $shipping_quotes, $wpsc_cart ) { |
|
|
|
|
|
|
1241
|
|
|
if ( count( $shipping_quotes ) == 1 ) { |
|
1242
|
|
|
reset( $shipping_quotes ); |
|
1243
|
|
|
$selected_option = key( $shipping_quotes ); |
|
1244
|
|
|
} |
|
1245
|
|
|
return $selected_option; |
|
1246
|
|
|
} |
|
1247
|
|
|
|
|
1248
|
|
|
function google_shipping_quotes() { |
|
1249
|
|
|
if ( defined( 'WPEC_LOAD_DEPRECATED' ) && WPEC_LOAD_DEPRECATED ) { |
|
1250
|
|
|
/* |
|
1251
|
|
|
* Couldn't find an easy way to deprecate this function without creating a new class, so it is being |
|
1252
|
|
|
* deprecated in place. Google checkout is gone, so this function should not have any purpose going forward |
|
1253
|
|
|
* @since 3.8.14 |
|
1254
|
|
|
*/ |
|
1255
|
|
|
|
|
1256
|
|
|
global $wpsc_shipping_modules; |
|
1257
|
|
|
$shipping_quote_count = 0; |
|
1258
|
|
|
$custom_shipping = get_option( 'custom_shipping_options' ); |
|
1259
|
|
|
$shipping_quotes = null; |
|
1260
|
|
|
if ( $this->selected_shipping_method != null ) { |
|
1261
|
|
|
$this->shipping_quotes = $wpsc_shipping_modules [$this->selected_shipping_method]->getQuote(); |
|
1262
|
|
|
// use the selected shipping module |
|
1263
|
|
|
if ( is_callable( array( $wpsc_shipping_modules [$this->selected_shipping_method], 'getQuote' ) ) ) { |
|
1264
|
|
|
$this->shipping_quotes = $wpsc_shipping_modules [$this->selected_shipping_method]->getQuote(); |
|
1265
|
|
|
} |
|
1266
|
|
|
} else { |
|
1267
|
|
|
// otherwise select the first one with any quotes |
|
1268
|
|
|
foreach ( ( array ) $custom_shipping as $shipping_module ) { |
|
|
|
|
|
|
1269
|
|
|
|
|
1270
|
|
|
// if the shipping module does not require a weight, or requires one and the weight is larger than |
|
1271
|
|
|
// zero |
|
1272
|
|
|
$this->selected_shipping_method = $shipping_module; |
|
1273
|
|
|
if ( is_callable( array( $wpsc_shipping_modules [$this->selected_shipping_method], 'getQuote' ) ) ) { |
|
1274
|
|
|
|
|
1275
|
|
|
$this->shipping_quotes = $wpsc_shipping_modules [$this->selected_shipping_method]->getQuote(); |
|
1276
|
|
|
} |
|
1277
|
|
|
|
|
1278
|
|
|
// if we have any shipping quotes, break the loop. |
|
1279
|
|
|
if ( count( $this->shipping_quotes ) > $shipping_quote_count ) { |
|
1280
|
|
|
break; |
|
1281
|
|
|
} |
|
1282
|
|
|
} |
|
1283
|
|
|
} |
|
1284
|
|
|
} // end load deprecated |
|
1285
|
|
|
} |
|
1286
|
|
|
|
|
1287
|
|
|
function next_shipping_quote() { |
|
1288
|
|
|
$this->current_shipping_quote ++; |
|
1289
|
|
|
$this->shipping_quote = $this->shipping_quotes [$this->current_shipping_quote]; |
|
1290
|
|
|
return $this->shipping_quote; |
|
1291
|
|
|
} |
|
1292
|
|
|
|
|
1293
|
|
|
function the_shipping_quote() { |
|
1294
|
|
|
$this->shipping_quote = $this->next_shipping_quote(); |
|
1295
|
|
|
} |
|
1296
|
|
|
|
|
1297
|
|
|
function have_shipping_quotes() { |
|
1298
|
|
|
if ( $this->current_shipping_quote + 1 < $this->shipping_quote_count ) { |
|
1299
|
|
|
return true; |
|
1300
|
|
|
} else if ( $this->current_shipping_quote + 1 == $this->shipping_quote_count && $this->shipping_quote_count > 0 ) { |
|
1301
|
|
|
// Do some cleaning up after the loop, |
|
1302
|
|
|
$this->rewind_shipping_quotes(); |
|
1303
|
|
|
} |
|
1304
|
|
|
return false; |
|
1305
|
|
|
} |
|
1306
|
|
|
|
|
1307
|
|
|
function rewind_shipping_quotes() { |
|
1308
|
|
|
$this->current_shipping_quote = - 1; |
|
1309
|
|
|
|
|
1310
|
|
|
if ( $this->shipping_quote_count > 0 ) { |
|
1311
|
|
|
$this->shipping_quote = $this->shipping_quotes[0]; |
|
1312
|
|
|
} |
|
1313
|
|
|
} |
|
1314
|
|
|
|
|
1315
|
|
|
/** |
|
1316
|
|
|
* Applying Coupons |
|
1317
|
|
|
*/ |
|
1318
|
|
|
function apply_coupons( $coupons_amount = '', $coupon_name = '' ) { |
|
1319
|
|
|
$this->clear_cache(); |
|
1320
|
|
|
$this->coupons_name = $coupon_name; |
|
1321
|
|
|
$this->coupons_amount = apply_filters( 'wpsc_coupons_amount', $coupons_amount, $coupon_name, $this ); |
|
1322
|
|
|
|
|
1323
|
|
|
$this->calculate_total_price(); |
|
1324
|
|
|
|
|
1325
|
|
|
if ( $this->total_price < 0 ) { |
|
1326
|
|
|
|
|
1327
|
|
|
$this->coupons_amount += $this->total_price; |
|
1328
|
|
|
$this->total_price = null; |
|
1329
|
|
|
|
|
1330
|
|
|
$this->calculate_total_price(); |
|
1331
|
|
|
} |
|
1332
|
|
|
} |
|
1333
|
|
|
} |
|
1334
|
|
|
|
|
1335
|
|
|
/** |
|
1336
|
|
|
* A final calculation of shipping method on shipping page, prior to quote display. |
|
1337
|
|
|
* A regrettable hack, but necessary for 1.0 versions of our shipping interface and theme engine. |
|
1338
|
|
|
* |
|
1339
|
|
|
* @link https://github.com/wp-e-commerce/WP-e-Commerce/issues/1552 |
|
1340
|
|
|
* |
|
1341
|
|
|
* @since 3.9.0 |
|
1342
|
|
|
* @access private |
|
1343
|
|
|
* |
|
1344
|
|
|
* @return void |
|
1345
|
|
|
*/ |
|
1346
|
|
|
function _wpsc_calculate_shipping_quotes_before_product_page() { |
|
1347
|
|
|
global $wpsc_cart; |
|
1348
|
|
|
|
|
1349
|
|
|
if ( $wpsc_cart->uses_shipping() ) { |
|
1350
|
|
|
$wpsc_cart->get_shipping_method(); |
|
1351
|
|
|
$wpsc_cart->rewind_shipping_methods(); |
|
1352
|
|
|
} |
|
1353
|
|
|
} |
|
1354
|
|
|
|
|
1355
|
|
|
add_action( 'wpsc_before_shipping_of_shopping_cart', '_wpsc_calculate_shipping_quotes_before_product_page' , 1 ); |
|
1356
|
|
|
|
wp-e-commerce /
WP-e-Commerce
Loading history...
