| 1 |
<?php |
| 2 |
/* |
| 3 |
Delegate class for talking to Vipps MobilePay, encapsulating all the low-level behaviour and mapping error codes to exceptions |
| 4 |
|
| 5 |
This file is part of the plugin Pay with Vipps and MobilePay for WooCommerce |
| 6 |
Copyright (c) 2019 WP-Hosting AS |
| 7 |
|
| 8 |
MIT License |
| 9 |
|
| 10 |
Copyright (c) 2019 WP-Hosting AS |
| 11 |
|
| 12 |
Permission is hereby granted, free of charge, to any person obtaining a copy |
| 13 |
of this software and associated documentation files (the "Software"), to deal |
| 14 |
in the Software without restriction, including without limitation the rights |
| 15 |
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 16 |
copies of the Software, and to permit persons to whom the Software is |
| 17 |
furnished to do so, subject to the following conditions: |
| 18 |
|
| 19 |
The above copyright notice and this permission notice shall be included in all |
| 20 |
copies or substantial portions of the Software. |
| 21 |
|
| 22 |
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 23 |
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 24 |
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 25 |
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 26 |
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 27 |
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 28 |
SOFTWARE. |
| 29 |
|
| 30 |
*/ |
| 31 |
if ( ! defined('ABSPATH') ) { |
| 32 |
exit; // Exit if accessed directly |
| 33 |
} |
| 34 |
require_once(dirname(__FILE__) . "/VippsApi.class.php"); |
| 35 |
|
| 36 |
class WC_Gateway_Vipps extends WC_Payment_Gateway { |
| 37 |
public $form_fields = null; |
| 38 |
public $dev_form_fields = null; |
| 39 |
public $id = 'vipps'; |
| 40 |
public $icon = ''; |
| 41 |
public $has_fields = true; |
| 42 |
public $method_title = 'Vipps MobilePay'; |
| 43 |
public $title = 'Vipps MobilePay'; |
| 44 |
public $method_description = ""; |
| 45 |
public $apiurl = null; |
| 46 |
public $testapiurl = null; |
| 47 |
public $api = null; |
| 48 |
public $supports = null; |
| 49 |
public $express_checkout_supported_product_types; |
| 50 |
|
| 51 |
public $captured_statuses; |
| 52 |
|
| 53 |
private static $instance = null; // This class uses the singleton pattern to make actions easier to handle |
| 54 |
|
| 55 |
protected $keyset = null; // This will contain all api keys etc for the gateway, keyed on the merchant serial number. |
| 56 |
|
| 57 |
// Just to avoid calculating these alot |
| 58 |
private $page_templates = null; |
| 59 |
private $page_list = null; |
| 60 |
|
| 61 |
|
| 62 |
|
| 63 |
// This returns the singleton instance of this class |
| 64 |
public static function instance() { |
| 65 |
if (null === self::$instance) { |
| 66 |
self::$instance = new self(); |
| 67 |
} |
| 68 |
return self::$instance; |
| 69 |
} |
| 70 |
|
| 71 |
public function add_image_upload_setting_widget () { |
| 72 |
add_action('admin_enqueue_scripts', function ($suff) { |
| 73 |
if ($suff == 'woocommerce_page_wc-settings' && (($_REQUEST['section'] ?? false) == 'vipps')) { |
| 74 |
if (!did_action('wp_enqueue_media')) { |
| 75 |
wp_enqueue_media(); |
| 76 |
} |
| 77 |
} |
| 78 |
}); |
| 79 |
} |
| 80 |
|
| 81 |
|
| 82 |
// Generates html for the woo_vipps_image settings widget type |
| 83 |
public function generate_woo_vipps_image_html ($key, $field) { |
| 84 |
$field_key = $this->get_field_key( $key ); |
| 85 |
$defaults = array( |
| 86 |
'title' => '', |
| 87 |
'disabled' => false, |
| 88 |
'class' => '', |
| 89 |
'css' => '', |
| 90 |
'placeholder' => '', |
| 91 |
'type' => 'woo_vipps_image', |
| 92 |
'desc_tip' => false, |
| 93 |
'description' => '', |
| 94 |
'custom_attributes' => array(), |
| 95 |
); |
| 96 |
$data = wp_parse_args( $field, $defaults ); |
| 97 |
|
| 98 |
$imgid = intval($this->get_option($key)); |
| 99 |
$image = $imgid ? wp_get_attachment_image_src($imgid) : ""; |
| 100 |
|
| 101 |
ob_start(); |
| 102 |
?> |
| 103 |
<tr valign="top"> |
| 104 |
<th scope="row" class="titledesc"> |
| 105 |
<label for="<?php echo esc_attr( $field_key ); ?>"><?php echo wp_kses_post( $data['title'] ); ?> <?php echo $this->get_tooltip_html( $data ); // WPCS: XSS ok. ?></label> |
| 106 |
</th> |
| 107 |
<td class="forminp"> |
| 108 |
<fieldset> |
| 109 |
<legend class="screen-reader-text"><span><?php echo wp_kses_post( $data['title'] ); ?></span></legend> |
| 110 |
<?php if ($image): ?> |
| 111 |
<a href="#" class="woo-vipps-image-upload"><img style="max-width: 360px; max-height: 360px" src="<?php echo $image[0]; ?>" /><span style="display:none" class='uploadtext'><?php _e('Upload image', 'woo-vipps'); ?></span></a> |
| 112 |
<a href="#" class="woo-vipps-image-remove"><?php _e('Remove image', 'woo-vipps');?></a> |
| 113 |
<?php else: ?> |
| 114 |
<a href="#" class="woo-vipps-image-upload"><img style="display:none; max-width:360px; max-height: 360px"/><span class='uploadtext'><?php _e('Upload image', 'woo-vipps'); ?></span></a> |
| 115 |
<a href="#" class="woo-vipps-image-remove" style="display:none;"><?php _e('Remove image', 'woo-vipps');?></a> |
| 116 |
<?php endif; ?> |
| 117 |
<input type="hidden" class="woo-vipps-image-input <?php echo esc_attr( $data['class'] ); ?>" name="<?php echo esc_attr( $field_key ); ?>" id="<?php echo esc_attr( $field_key ); ?>" value="<?php echo esc_attr($imgid); ?>" <?php echo $this->get_custom_attribute_html( $data ); // WPCS: XSS ok. ?> /> |
| 118 |
<?php echo $this->get_description_html( $data ); // WPCS: XSS ok. ?> |
| 119 |
</fieldset> |
| 120 |
</td> |
| 121 |
</tr> |
| 122 |
<?php |
| 123 |
|
| 124 |
return ob_get_clean(); |
| 125 |
} |
| 126 |
|
| 127 |
// Attempts to detect the current country based on the store's currency NT-2024-10-15 |
| 128 |
private function detect_country_from_currency() { |
| 129 |
$currency = get_woocommerce_currency(); |
| 130 |
switch ($currency) { |
| 131 |
case 'DKK': |
| 132 |
return 'DK'; |
| 133 |
case 'NOK': |
| 134 |
return 'NO'; |
| 135 |
case 'SEK': |
| 136 |
return 'SE'; |
| 137 |
case 'EUR': |
| 138 |
return 'FI'; |
| 139 |
default: |
| 140 |
return null; |
| 141 |
} |
| 142 |
} |
| 143 |
// Migrates the keysets to include the country setting if it's missing |
| 144 |
// This is an initial migration step to ensure the country setting is explicitly set. |
| 145 |
// We do this because we no longer want to automatically guess payment method name. NT-2024-10-15 |
| 146 |
private function migrate_keyset_with_country_detection() { |
| 147 |
$settings = get_option('woocommerce_vipps_settings', array()); |
| 148 |
if ($settings['country'] ?? false) return; // Already set, do nothing IOK 2024-10-17 |
| 149 |
|
| 150 |
// Now we are only wanting to do this with people who have already configured the plugin. These will have at least this value set: |
| 151 |
if ($settings['payment_method_name'] ?? false) { |
| 152 |
// This assumes that EUR == FI which will be correct for all users reaching this branch IOK 2024-10-17 |
| 153 |
$detected_country = $this->detect_country_from_currency(); |
| 154 |
// If we can't detect the country, there's nothing to migrate. "this cannot happen" etc. |
| 155 |
if (!$detected_country) return; |
| 156 |
|
| 157 |
$settings['country'] = $detected_country; |
| 158 |
update_option('woocommerce_vipps_settings', $settings); |
| 159 |
delete_transient('_vipps_keyset'); |
| 160 |
return; |
| 161 |
} |
| 162 |
} |
| 163 |
|
| 164 |
public function __construct() { |
| 165 |
$this->testapiurl = 'https://apitest.vipps.no'; |
| 166 |
$this->apiurl = 'https://api.vipps.no'; |
| 167 |
|
| 168 |
$this->method_description = __('Offer Vipps or MobilePay as a payment method', 'woo-vipps'); |
| 169 |
$this->method_title = __('Vipps MobilePay','woo-vipps'); |
| 170 |
$this->title = __('Vipps MobilePay','woo-vipps'); |
| 171 |
|
| 172 |
$this->icon = plugins_url('img/vmp-logo.png',__FILE__); |
| 173 |
$this->migrate_keyset_with_country_detection(); |
| 174 |
$this->init_form_fields(); |
| 175 |
$this->init_settings(); |
| 176 |
|
| 177 |
|
| 178 |
$this->api = new VippsApi($this); |
| 179 |
|
| 180 |
$this->supports = array('products','refunds'); |
| 181 |
|
| 182 |
// we need to disallow certain types of refunds; mostly manual refunds done before capture. IOK 2026-02-24 |
| 183 |
add_action( 'woocommerce_create_refund', array($this, 'woocommerce_create_refund'), 10, 2); |
| 184 |
|
| 185 |
// We can't guarantee any particular product type being supported, so we must enumerate those we are certain about |
| 186 |
// IOK 2020-04-21 Add support for WooCommerce Product Bundles |
| 187 |
$supported_types= array('simple','variable','variation','bundle', 'yith_bundle', 'gift-card'); |
| 188 |
$this->express_checkout_supported_product_types = apply_filters('woo_vipps_express_checkout_supported_product_types', $supported_types); |
| 189 |
|
| 190 |
add_action('woocommerce_update_options_payment_gateways_' . $this->id, array( $this, 'process_admin_options') ); |
| 191 |
add_action('admin_init', array($this, 'add_image_upload_setting_widget')); |
| 192 |
|
| 193 |
// Capturing, refunding and cancelling the order when transitioning states: |
| 194 |
// This are the statuses for which the Vipps MobilePay plugin should try to ensure capture has been made. |
| 195 |
// Normally, this is 'processing' and 'completed', but plugins may define other statuses. IOK 2018-10-05 |
| 196 |
// It is also possible to remove 'processing' from this list. If you do, you may use it as the end-state of the |
| 197 |
// Vipps MobilePay transaction (see below in after_vipps_order_status) IOK 2018-12-05 |
| 198 |
$resultstatus = $this->get_option('result_status'); |
| 199 |
$captured_statuses = apply_filters('woo_vipps_captured_statuses', array('processing', 'completed')); |
| 200 |
$captured_statuses = array_diff($captured_statuses, array($resultstatus)); |
| 201 |
|
| 202 |
$this->captured_statuses = $captured_statuses; |
| 203 |
|
| 204 |
$non_completed_captured_statuses = array_diff($captured_statuses, array('completed')); |
| 205 |
|
| 206 |
// This ensures that funds are captured when transitioning from 'on hold' to a status where the money |
| 207 |
// should be captured, and refunded when moved from this status to cancelled or refunded |
| 208 |
foreach($captured_statuses as $capstatus) { |
| 209 |
add_action('woocommerce_order_status_' . $capstatus, array($this, 'maybe_capture_payment')); |
| 210 |
} |
| 211 |
// We will refund money on cancelled orders, but only if they are *relatively new*. This is to |
| 212 |
// avoid accidents and issues where old orders are *somehow* cancelled even though they are complete. IOK 2024-08-12 |
| 213 |
add_action('woocommerce_order_status_cancelled', array($this, 'maybe_cancel_order')); |
| 214 |
// Add a full refund if neccessary *before* woocommerce does, on priority 10 IOK 2026-01-28 |
| 215 |
add_action('woocommerce_order_status_refunded', array($this, 'maybe_refund_order'), 9, 1); |
| 216 |
|
| 217 |
// Possibly delete orders that never went anywhere |
| 218 |
add_action('woocommerce_order_status_pending_to_cancelled', array($this, 'maybe_delete_order'), 99999, 1); |
| 219 |
// Handle orders when authorized |
| 220 |
add_action('woocommerce_payment_complete', array($this, 'order_payment_complete'), 10, 1); |
| 221 |
|
| 222 |
// when an order is complete, we need to check if there is reserved amount that is not captured |
| 223 |
// if so, we need to cancel this amount PMB 2024-11-21 |
| 224 |
// nb: note very late priority - we must have captured before, please |
| 225 |
// Also for orders that have been partially or completely refunded, or need to be set to cancelled IOK 2026-01-26 |
| 226 |
add_action('woocommerce_order_status_completed', array($this, 'maybe_cancel_reserved_amount'), 99); |
| 227 |
add_action('woocommerce_order_status_refunded', array($this, 'maybe_cancel_reserved_amount'), 99, 1); |
| 228 |
add_action('woocommerce_order_status_cancelled', array($this, 'maybe_cancel_reserved_amount'), 99, 1); |
| 229 |
|
| 230 |
// New handling for callbacks in the action scheduler. LP 2026-03-27 |
| 231 |
add_action('woo_vipps_action_process_callback', [$this, 'action_process_callback'], 10, 4); |
| 232 |
|
| 233 |
// Endpoint for setting shipping data for express checkout orders. LP 2026-03-30 |
| 234 |
add_action('rest_api_init', function() { |
| 235 |
register_rest_route(Vipps::get_rest_namespace('v1'), '/order-set-shipping', [ |
| 236 |
'methods' => 'POST', |
| 237 |
'callback' => [$this, 'rest_order_set_shipping'], |
| 238 |
'permission_callback' => function($request) { |
| 239 |
// Note: permission callbacks run twice, on purpose. LP 2026-04-01 |
| 240 |
// https://github.com/WP-API/WP-API/issues/2400 |
| 241 |
$input_token = $request->get_header('X-WooVipps-Token'); |
| 242 |
|
| 243 |
$order_id = $request->get_param('order_id'); |
| 244 |
|
| 245 |
$order = wc_get_order($order_id); |
| 246 |
if (!is_a($order, 'WC_Order')) { |
| 247 |
return new WP_Error('order_not_found', __('Order not found', 'woo-vipps'), ['status' => 404, 'order_id' => $order_id]); |
| 248 |
} |
| 249 |
|
| 250 |
// a small bit of security |
| 251 |
$auth_token = $order->get_meta('_vipps_authtoken'); |
| 252 |
if (!$input_token || !$auth_token || !hash_equals($input_token, $auth_token)) { |
| 253 |
/* translators: endpoint path, order id */ |
| 254 |
$this->log(sprintf(__('Wrong authtoken for rest endpoint %1$s for order %2$s', 'woo-vipps'), '/order-set-shipping', $order_id), 'warning'); |
| 255 |
return false; |
| 256 |
} |
| 257 |
return true; |
| 258 |
|
| 259 |
}, |
| 260 |
'args' => [ |
| 261 |
'order_id' => [ |
| 262 |
'required' => true, |
| 263 |
'validate_callback' => fn($param, $request, $key) => is_numeric($param), |
| 264 |
'sanitize_callback' => fn($param, $request, $key) => intval($param), |
| 265 |
], |
| 266 |
/* Data from Vipps callback or api poll. LP 2026-03-30 */ |
| 267 |
'vipps_order_data' => [ |
| 268 |
'required' => true, |
| 269 |
'validate_callback' => fn($param, $request, $key) => is_array($param), |
| 270 |
'sanitize_callback' => fn($param, $request, $key) => map_deep($param, 'sanitize_text_field'), |
| 271 |
], |
| 272 |
], |
| 273 |
]); |
| 274 |
}); |
| 275 |
} |
| 276 |
|
| 277 |
// this function is called after an order is changed to complete/refunded/cancelled. It checks if there is reserved money that is not captured |
| 278 |
// if there still is money reserved, then this amount is cancelled PMB 2024-11-21 |
| 279 |
// Ensure we've updated the vipps status before calling this. IOK 2026-01-28 |
| 280 |
public function maybe_cancel_reserved_amount ($orderid) { |
| 281 |
$order = wc_get_order($orderid); |
| 282 |
if (!$order) return; |
| 283 |
if (! Vipps::is_vipps_order($order)) return false; |
| 284 |
|
| 285 |
// Check that the normal maybe_capture_order hook has actually ran *and* done something, |
| 286 |
// it's only after this we know we have captured 'everything' so if there is anything left, |
| 287 |
// it should be cancelled. IOK 2025-05-04 |
| 288 |
// Also set in maybe_cancel and maybe_refund now - in all "final status" hooks. IOK 2026-01-28 |
| 289 |
if (! $order->get_meta('_vipps_capture_complete')) { |
| 290 |
return false; |
| 291 |
} |
| 292 |
|
| 293 |
$order_status = $order->get_status(); |
| 294 |
|
| 295 |
if ('completed' == $order_status) { |
| 296 |
// For safety, on completed orders also only want to do this for orders that have had *something* captured. IOK 2025-02-04 |
| 297 |
$captured = intval($order->get_meta('_vipps_captured')); |
| 298 |
if ($captured < 1) { |
| 299 |
return false; |
| 300 |
} |
| 301 |
} |
| 302 |
if ('cancelled' != $order_status) { |
| 303 |
// If not in the 'cancelled' state, allow merchants that do not reserve large amounts to opt out for safety IOK 2025-02-04 |
| 304 |
if (apply_filters('woo_vipps_never_cancel_uncaptured_money', false, $order)) { |
| 305 |
return false; |
| 306 |
} |
| 307 |
} |
| 308 |
|
| 309 |
$ok = true; |
| 310 |
|
| 311 |
$remaining = intval($order->get_meta('_vipps_capture_remaining')); |
| 312 |
|
| 313 |
if ($remaining > 0) { |
| 314 |
$this->log(sprintf(__("maybe_cancel_reserved_amount we have remaining reserved after capture of total %1\$s ",'woo-vipps'), $remaining),'debug'); |
| 315 |
} else { |
| 316 |
// IOK 2026-06-15 Nothing left to cancel, just return |
| 317 |
return false; |
| 318 |
} |
| 319 |
|
| 320 |
$currency = $order->get_currency(); |
| 321 |
try { |
| 322 |
$ok = $this->cancel_payment($order); |
| 323 |
if ($ok && $remaining && 'completed' == $order_status) { |
| 324 |
$amount = number_format($remaining/100, 2) . " " . $currency; |
| 325 |
$note = sprintf(__('Order %1$s: %2$s is cancelled to free up the reservation in the customers bank account.', 'woo-vipps'), $orderid, $amount); |
| 326 |
$order->add_order_note($note); |
| 327 |
} |
| 328 |
} catch (Exception $e) { |
| 329 |
$ok = false; |
| 330 |
// if this happens, we just log it - we may not have an active admin |
| 331 |
$msg = sprintf(__('Was not able to cancel remaining amount for the order %1$s: %2$s','woo-vipps'), $orderid, $e->getMessage()); |
| 332 |
$order->add_order_note($msg); |
| 333 |
$this->log($msg,'error'); |
| 334 |
} |
| 335 |
|
| 336 |
// We need to update the order details after the fact. We can't fix errors here though. IOK 2024-11-22 |
| 337 |
try { |
| 338 |
$this->update_vipps_payment_details($order); |
| 339 |
} catch (Exception $e) { |
| 340 |
// noop |
| 341 |
} |
| 342 |
|
| 343 |
// we just return true from this function for now PMB 2024-11-21 |
| 344 |
// return false if we couldn't cancel reserved. IOK 2024-11-22 |
| 345 |
return $ok; |
| 346 |
} |
| 347 |
|
| 348 |
|
| 349 |
public function get_icon () { |
| 350 |
$src = $this->icon; |
| 351 |
if ($this->get_payment_method_name() == "Vipps") { |
| 352 |
$src = plugins_url('img/vipps-mark.svg',__FILE__); |
| 353 |
} else { |
| 354 |
$src = plugins_url('img/mobilepay-mark.png',__FILE__); |
| 355 |
} |
| 356 |
return '<img src="' . esc_attr($src) . '" alt="' . $this->get_payment_method_name() . '">'; |
| 357 |
} |
| 358 |
|
| 359 |
|
| 360 |
// True iff this gateway is currently in test mode. IOK 2019-08-30 |
| 361 |
public function is_test_mode() { |
| 362 |
if (VIPPS_TEST_MODE) return true; |
| 363 |
if ($this->get_option('developermode') == 'yes' && $this->get_option('testmode') == 'yes') return true; |
| 364 |
return false; |
| 365 |
} |
| 366 |
// These abstraction gets the correct client id and so forth based on whether or not test mode is on |
| 367 |
// "test mode" is now per MSN, so we accept that as an argument IOK 2023-12-19 |
| 368 |
public function apiurl ($msn="") { |
| 369 |
$msn = $msn ?? $this->get_merchant_serial(); |
| 370 |
$keyset = $this->get_keyset(); |
| 371 |
$entry = $keyset ? ($keyset[$msn] ?? null) : null; |
| 372 |
if (!$entry) { |
| 373 |
$testmode = $this->is_test_mode(); |
| 374 |
} else { |
| 375 |
$testmode = $entry['testmode']; |
| 376 |
} |
| 377 |
if ($testmode) return $this->testapiurl; |
| 378 |
return $this->apiurl; |
| 379 |
} |
| 380 |
|
| 381 |
// This returns the *current* merchant serial number. There may be more than one, for instance if the test mode is on. |
| 382 |
// IOK 2023-12-19 |
| 383 |
public function get_merchant_serial() { |
| 384 |
$merch = $this->get_option('merchantSerialNumber'); |
| 385 |
$testmerch = @$this->get_option('merchantSerialNumber_test'); |
| 386 |
if (!empty($testmerch) && $this->is_test_mode()) return $testmerch; |
| 387 |
return $merch; |
| 388 |
} |
| 389 |
|
| 390 |
// Returns a table of all the keydata of this instance, keyed on MSN. IOK 2023-12-19 |
| 391 |
public function get_keyset() { |
| 392 |
if ($this->keyset) return $this->keyset; |
| 393 |
$stored = get_transient('_vipps_keyset'); |
| 394 |
if ($stored) { |
| 395 |
return $stored; |
| 396 |
} |
| 397 |
|
| 398 |
$keyset = []; |
| 399 |
$main = $this->get_option('merchantSerialNumber'); |
| 400 |
if ($main) { |
| 401 |
$data = ['client_id'=>$clientid=$this->get_option('clientId'), |
| 402 |
'client_secret' => $this->get_option('secret'), |
| 403 |
'sub_key'=>$this->get_option('Ocp_Apim_Key_eCommerce'), |
| 404 |
'country' => $this->get_option('country'), |
| 405 |
'gw' => 'vipps' |
| 406 |
]; |
| 407 |
if (! in_array(false, array_map('boolval', array_values($data)))) { |
| 408 |
$data['testmode'] = 0; // Must add after |
| 409 |
$keyset[$main] = $data; |
| 410 |
} |
| 411 |
} |
| 412 |
|
| 413 |
$test = @$this->get_option('merchantSerialNumber_test'); |
| 414 |
$testmode = @$this->get_option('testmode'); |
| 415 |
if ($testmode === 'yes' && $test) { |
| 416 |
$data = [ |
| 417 |
'client_id'=>$clientid=$this->get_option('clientId_test'), |
| 418 |
'client_secret' => $this->get_option('secret_test'), |
| 419 |
'sub_key'=>$this->get_option('Ocp_Apim_Key_eCommerce_test'), |
| 420 |
'country' => $this->get_option('country'), |
| 421 |
'gw' => 'vipps' |
| 422 |
]; |
| 423 |
|
| 424 |
if (! in_array(false, array_map('boolval', array_values($data)))) { |
| 425 |
$data['testmode'] = 1; |
| 426 |
$keyset[$test] = $data; |
| 427 |
} |
| 428 |
} |
| 429 |
|
| 430 |
$this->keyset = $keyset; |
| 431 |
set_transient('_vipps_keyset', $keyset, DAY_IN_SECONDS); |
| 432 |
return $keyset; |
| 433 |
} |
| 434 |
|
| 435 |
// Get and show any keysets from the Vipps Recurring plugin too IOK 2024-11-29 |
| 436 |
private function get_recurring_keysets () { |
| 437 |
$res = []; |
| 438 |
$settings = get_option( 'woocommerce_vipps_recurring_settings' ); |
| 439 |
if (empty($settings)) return $res; |
| 440 |
|
| 441 |
$country = $this->get_option('country'); |
| 442 |
|
| 443 |
$client_id = $settings["client_id"] ?? ""; |
| 444 |
$client_secret = $settings["secret_key"] ?? ""; |
| 445 |
$subscription_key = $settings["subscription_key"] ?? ""; |
| 446 |
$merchant_serial_number = $settings["merchant_serial_number"] ?? ""; |
| 447 |
if ($merchant_serial_number && $client_id && $client_secret && $subscription_key ) { |
| 448 |
$res[$merchant_serial_number] = ['client_id' => $client_id, 'client_secret' => $client_secret, 'sub_key' => $subscription_key, 'country' => $country, 'testmode' => 0, 'gw'=>'vipps_recurring']; |
| 449 |
} |
| 450 |
|
| 451 |
$client_id = $settings["test_client_id"] ?? ""; |
| 452 |
$client_secret = $settings["test_secret_key"] ?? ""; |
| 453 |
$subscription_key = $settings["test_subscription_key"] ?? ""; |
| 454 |
$merchant_serial_number = $settings["test_merchant_serial_number"] ?? ""; |
| 455 |
if ($merchant_serial_number && $client_id && $client_secret && $subscription_key ) { |
| 456 |
$res[$merchant_serial_number] = ['client_id' => $client_id, 'client_secret' => $client_secret, 'sub_key' => $subscription_key, 'country' => $country, 'testmode' => 1, 'gw'=>'vipps_recurring']; |
| 457 |
} |
| 458 |
return $res; |
| 459 |
} |
| 460 |
|
| 461 |
// Return all webhooks for our MSNs |
| 462 |
public function get_webhooks_from_vipps () { |
| 463 |
$keys = $this->get_keyset(); |
| 464 |
$hooks = []; |
| 465 |
foreach($keys as $msn=>$data) { |
| 466 |
try { |
| 467 |
$hooks[$msn] = $this->api->get_webhooks($msn); |
| 468 |
} catch (Exception $e) { |
| 469 |
$this->log(sprintf(__('Could not get webhooks for Merchant Serial Number %1$s: %2$s', 'woo-vipps'), $msn, $e->getMessage()), 'error'); |
| 470 |
$hooks[$msn]=[]; |
| 471 |
} |
| 472 |
} |
| 473 |
return $hooks; |
| 474 |
} |
| 475 |
|
| 476 |
|
| 477 |
// The rest of the settings gets the correct client id, secret, sub key and order prefix based on the MSN. |
| 478 |
public function get_clientid($msn="") { |
| 479 |
if (!$msn) $msn = $this->get_merchant_serial(); |
| 480 |
$keyset = $this->get_keyset(); |
| 481 |
if (!isset($keyset[$msn])) return false; |
| 482 |
return $keyset[$msn]['client_id']; |
| 483 |
} |
| 484 |
public function get_secret($msn="") { |
| 485 |
if (!$msn) $msn = $this->get_merchant_serial(); |
| 486 |
$keyset = $this->get_keyset(); |
| 487 |
if (!isset($keyset[$msn])) return false; |
| 488 |
return $keyset[$msn]['client_secret']; |
| 489 |
} |
| 490 |
public function get_key($msn="") { |
| 491 |
if (!$msn) $msn = $this->get_merchant_serial(); |
| 492 |
$keyset = $this->get_keyset(); |
| 493 |
if (!isset($keyset[$msn])) return false; |
| 494 |
return $keyset[$msn]['sub_key']; |
| 495 |
} |
| 496 |
public function get_country($msn="") { |
| 497 |
if (!$msn) $msn = $this->get_merchant_serial(); |
| 498 |
$keyset = $this->get_keyset(); |
| 499 |
if (!isset($keyset[$msn])) return false; |
| 500 |
return $keyset[$msn]['country']; |
| 501 |
} |
| 502 |
|
| 503 |
public function get_orderprefix() { |
| 504 |
$prefix = $this->get_option('orderprefix'); |
| 505 |
return $prefix; |
| 506 |
} |
| 507 |
|
| 508 |
// We did shenanigans here earlier, we don't have to do that anymore. IOK 2022-12-09 |
| 509 |
public function get_return_url($order=null) { |
| 510 |
$url = parent::get_return_url($order); |
| 511 |
return $url; |
| 512 |
} |
| 513 |
|
| 514 |
|
| 515 |
// Delete express checkout orders with no customer information - these were abandonend before the app started. |
| 516 |
// IOK 2019-08-26 |
| 517 |
public function maybe_delete_order ($orderid) { |
| 518 |
$order = wc_get_order($orderid); |
| 519 |
if (!$order) return; |
| 520 |
if (! Vipps::is_vipps_order($order)) return false; |
| 521 |
$express = $order->get_meta('_vipps_express_checkout'); |
| 522 |
if (!$express) return false; |
| 523 |
$email = $order->get_billing_email(); |
| 524 |
if ($email) return false; |
| 525 |
|
| 526 |
// Only delete if we have to |
| 527 |
if ($this->get_option('deletefailedexpressorders') != 'yes') return false; |
| 528 |
// Mark this order that an order that wasn't completed with any user info - it can be deleted. IOK 2019-11-13 |
| 529 |
$order->update_meta_data('_vipps_delendum',1); |
| 530 |
$order->save(); |
| 531 |
return true; |
| 532 |
} |
| 533 |
|
| 534 |
|
| 535 |
// Return the status to use after return from Vipps MobilePay for orders that are not both "virtual" and "downloadable". |
| 536 |
// These orders are *not* complete, and payment is *not* captured, which is why the default status is 'on-hold'. |
| 537 |
// If you use custom order statuses, or if you don't capture on 'processing' - see filter 'woo_vipps_captured_statuses' - |
| 538 |
// you can instead use 'processing' here - which is much nicer. |
| 539 |
// If you do so, remember to capture *before* shipping is done on the order - if you send the package and then do 'complete', |
| 540 |
// the capture may fail. IOK 2018-12-05 |
| 541 |
// |
| 542 |
// IOK As of 2023-12-22, the default is now 'processing', since this is more in line with what other gateways are using, |
| 543 |
// what other integrations and plugins expect, the most popular choice by users; and because of the fact that "on-hold" is |
| 544 |
// normally used to indicate "a problem with the order". Not being able to capture a reserved order has to my knowledge at this |
| 545 |
// point only happened once, in 2018, with a completely different api and backend. |
| 546 |
public function after_vipps_order_status($order=null) { |
| 547 |
// Revert to on-hold if the user tries to set a payment status that is a 'captured' status IOK 2024-01-25 |
| 548 |
$defaultstatus = 'on-hold'; |
| 549 |
|
| 550 |
$chosen = $this->get_option('result_status'); |
| 551 |
$newstatus = apply_filters('woo_vipps_after_vipps_order_status', $chosen, $order); |
| 552 |
|
| 553 |
if (in_array($newstatus, $this->captured_statuses)){ |
| 554 |
$this->log(sprintf(__("Cannot use %1\$s as status for non-autocapturable orders: payment is captured on this status. See the woo_vipps_captured_statuses-filter.",'woo-vipps'), $newstatus),'debug'); |
| 555 |
return $defaultstatus; |
| 556 |
} |
| 557 |
return $newstatus; |
| 558 |
} |
| 559 |
|
| 560 |
// Create callback urls' using WC's callback API in a way that works with Vipps MobilePay callbacks and both pretty and not so pretty urls. |
| 561 |
private function make_callback_urls($forwhat,$token='', $reference=0) { |
| 562 |
// Passing the token as GET arguments, as the Authorize header is stripped. IOK 2018-06-13 |
| 563 |
// This applies to Ecom, Checkout and Express Checkout callbacks. For epayment, we instead need to use |
| 564 |
// the webhook api, which is altogether different. IOK 2023-12-19 |
| 565 |
$url = home_url("/", 'https'); |
| 566 |
$queryargs = []; |
| 567 |
if ($token) $queryargs['tk']=$token; |
| 568 |
if ($reference) $queryargs['id']=$reference; |
| 569 |
|
| 570 |
// HTTPS required. IOK 2018-05-18 |
| 571 |
// If the user for some reason hasn't enabled pretty links, fall back to ancient version. IOK 2018-04-24 |
| 572 |
if ( !get_option('permalink_structure')) { |
| 573 |
$queryargs['wc-api'] = $forwhat; |
| 574 |
} else { |
| 575 |
$url = trailingslashit(home_url("wc-api/$forwhat", 'https')); |
| 576 |
} |
| 577 |
// And we need to add an empty "callback" query arg as the very last arg to receive the actual callback. |
| 578 |
// We can't use add_query_arg for that, as an empty argument will remove the equals-sign. |
| 579 |
$callbackurl = add_query_arg($queryargs, $url) . "&callback="; |
| 580 |
return $callbackurl; |
| 581 |
} |
| 582 |
|
| 583 |
// Webhook callbacks do not pass GET arguments at all, but do provide an X-Vipps-Authorization header for verification. IOK 2023-12-19 |
| 584 |
public function webhook_callback_url () { |
| 585 |
$url = home_url("/", 'https'); |
| 586 |
$queryargs = ['callback'=>'webhook']; |
| 587 |
$forwhat = 'wc_gateway_vipps'; // Same callback as for epayment, checkout, express checkout |
| 588 |
// HTTPS required. IOK 2018-05-18 |
| 589 |
// If the user for some reason hasn't enabled pretty links, fall back to ancient version. IOK 2018-04-24 |
| 590 |
if ( !get_option('permalink_structure')) { |
| 591 |
$queryargs['wc-api'] = $forwhat; |
| 592 |
} else { |
| 593 |
$url = trailingslashit(home_url("wc-api/$forwhat", 'https')); |
| 594 |
} |
| 595 |
$callbackurl = add_query_arg($queryargs, $url); |
| 596 |
return $callbackurl; |
| 597 |
} |
| 598 |
|
| 599 |
|
| 600 |
// The main payment callback |
| 601 |
public function payment_callback_url ($token='', $reference=0) { |
| 602 |
return $this->make_callback_urls('wc_gateway_vipps',$token, $reference); |
| 603 |
} |
| 604 |
public function shipping_details_callback_url($token='',$reference=0) { |
| 605 |
return $this->make_callback_urls('vipps_shipping_details',$token,$reference); |
| 606 |
} |
| 607 |
// Callback for the consetn removal callback. Must use template redirect directly, because wc-api doesn't handle DELETE. |
| 608 |
// IOK 2018-05-18 |
| 609 |
public function consent_removal_callback_url () { |
| 610 |
$queryargs = []; |
| 611 |
$url = home_url("/", 'https'); |
| 612 |
if ( !get_option('permalink_structure')) { |
| 613 |
$queryargs['vipps-consent-removal']=1; |
| 614 |
} else { |
| 615 |
$url = trailingslashit(home_url('vipps-consent-removal', 'https')); |
| 616 |
} |
| 617 |
// And we need to add an empty "callback" query arg as the very last arg to receive the actual callback. |
| 618 |
// We can't use add_query_arg for that, as an empty argument will remove the equals-sign. |
| 619 |
return add_query_arg($queryargs, $url) . "&callback="; |
| 620 |
} |
| 621 |
|
| 622 |
// Allow user to select the template to be used for the special Vipps MobilePay pages. IOK 2020-02-17 |
| 623 |
public function get_theme_page_templates() { |
| 624 |
if (!$this->page_templates) { |
| 625 |
$choices = array('' => __('Use default template', 'woo-vipps')); |
| 626 |
foreach(wp_get_theme()->get_page_templates() as $filename=>$name) { |
| 627 |
$choices[$filename]=$name; |
| 628 |
} |
| 629 |
$this->page_templates = $choices; |
| 630 |
} |
| 631 |
return $this->page_templates; |
| 632 |
} |
| 633 |
|
| 634 |
// We can't use get_pages to get a default list of pages for our settings, because it triggers |
| 635 |
// actions that can be used by other plugins. Therefore we must use the database directly and cache the results. IOK 2023-08-22 |
| 636 |
public function get_pagelist () { |
| 637 |
if (!$this->page_list) { |
| 638 |
global $wpdb; |
| 639 |
$page_list = array(''=>__('Use a simulated page (default)', 'woo-vipps')); |
| 640 |
foreach($wpdb->get_results("SELECT ID,post_title FROM {$wpdb->prefix}posts WHERE post_type='page' and post_status='publish'") as $page) { |
| 641 |
$page_list[$page->ID] = $page->post_title; |
| 642 |
} |
| 643 |
$this->page_list = $page_list; |
| 644 |
} |
| 645 |
return $this->page_list; |
| 646 |
} |
| 647 |
|
| 648 |
// Check to see if the product in question can be bought with express checkout IOK 2018-12-04 |
| 649 |
public function product_supports_express_checkout($product) { |
| 650 |
// IOK 2023-12-12 Can only support express checkout for Vipps - not MobilePay (yet!) |
| 651 |
// IOK 2025-09-01 Now supports mobilepay |
| 652 |
return apply_filters('woo_vipps_product_supports_express_checkout', $this->product_supports_checkout($product), $product); |
| 653 |
} |
| 654 |
|
| 655 |
// Checkout and Express Checkout are very similarily restricted because they both replace the standard |
| 656 |
// Woo Checkout page, but express checkout is even more restricted, so we need to separate out the commonalities. IOK 2024-01-11 |
| 657 |
public function product_supports_checkout($product) { |
| 658 |
$type = $product->get_type(); |
| 659 |
$ok = in_array($type, $this->express_checkout_supported_product_types); |
| 660 |
$ok = apply_filters('woo_vipps_product_supports_checkout',$ok,$product); |
| 661 |
return $ok; |
| 662 |
} |
| 663 |
|
| 664 |
// Almost the same as express checkout - unfortunately not *entirely* the same. IOK 2024-01-11 |
| 665 |
public function cart_supports_checkout($cart=null) { |
| 666 |
if (!$cart) $cart = WC()->cart; |
| 667 |
if (!$cart) return false; |
| 668 |
# Not supported by Vipps MobilePay |
| 669 |
if ($cart->cart_contents_total <= 0) return false; |
| 670 |
|
| 671 |
$supports = true; |
| 672 |
foreach($cart->get_cart() as $key=>$val) { |
| 673 |
$prod = $val['data']; |
| 674 |
if (!is_a($prod, 'WC_Product')) continue; |
| 675 |
$product_supported = $this->product_supports_checkout($prod); |
| 676 |
if (!$product_supported) { |
| 677 |
$supports = false; |
| 678 |
break; |
| 679 |
} |
| 680 |
} |
| 681 |
$supports = apply_filters('woo_vipps_cart_supports_checkout', $supports, $cart); |
| 682 |
return $supports; |
| 683 |
} |
| 684 |
|
| 685 |
// Check to see if the cart passed (or the global one) can be bought with express checkout IOK 2018-12-04 |
| 686 |
public function cart_supports_express_checkout($cart=null) { |
| 687 |
if (!$cart) $cart = WC()->cart; |
| 688 |
$supports = true; |
| 689 |
if (!$cart) return $supports; |
| 690 |
# Not supported by Vipps MobilePay |
| 691 |
if ($cart->cart_contents_total <= 0) return false; |
| 692 |
|
| 693 |
foreach($cart->get_cart() as $key=>$val) { |
| 694 |
$prod = $val['data']; |
| 695 |
if (!is_a($prod, 'WC_Product')) continue; |
| 696 |
$product_supported = $this->product_supports_express_checkout($prod); |
| 697 |
if (!$product_supported) { |
| 698 |
$supports = false; |
| 699 |
break; |
| 700 |
} |
| 701 |
} |
| 702 |
$supports = apply_filters('woo_vipps_cart_supports_express_checkout', $supports, $cart); |
| 703 |
return $supports; |
| 704 |
} |
| 705 |
|
| 706 |
// True if "Express checkout" should be displayed IOK 2018-06-18 |
| 707 |
public function show_express_checkout() { |
| 708 |
if (!$this->express_checkout_available()) return false; |
| 709 |
$show = 'yes' == $this->enabled && $this->cart_supports_express_checkout(); |
| 710 |
|
| 711 |
if (is_checkout()) { |
| 712 |
$show = $show && $this->get_option('express_show_in_checkout') == 'yes'; |
| 713 |
} else { // for cart, and all other contexts, since this is how the method functioned before we checked checkout explicitly. LP 2026-07-02 |
| 714 |
$show = $show && $this->get_option('cartexpress') == 'yes'; |
| 715 |
} |
| 716 |
// Earlier, we disabled this if Checkout was active; but we will now respect the setting in all |
| 717 |
// cases. Also, there is a filter. IOK 2026-02-19 |
| 718 |
// Now there is also a separate setting for just checkout, 'express_show_in_checkout'. See above branch. LP 2026-07-01 |
| 719 |
|
| 720 |
return apply_filters('woo_vipps_show_express_checkout', $show); |
| 721 |
} |
| 722 |
|
| 723 |
public function show_login_with_vipps() { |
| 724 |
return false; |
| 725 |
} |
| 726 |
|
| 727 |
// Called when orders reach the 'refunded' status. We'll add a complete refund and note that any rest is to be cancelled. |
| 728 |
public function maybe_refund_order($order_id) { |
| 729 |
$order = wc_get_order($order_id); |
| 730 |
if (! Vipps::is_vipps_order($order)) return false; |
| 731 |
try { |
| 732 |
$order = $this->update_vipps_payment_details($order); |
| 733 |
} catch (Exception $e) { |
| 734 |
//Do nothing with this for now |
| 735 |
$this->log(__("Error getting payment details before doing refund: ", 'woo-vipps') . $e->getMessage(), 'warning'); |
| 736 |
} |
| 737 |
$payment = $this->check_payment_status($order); |
| 738 |
if ($payment == 'initiated' || $payment == 'cancelled') { |
| 739 |
return true; // Can't refund these |
| 740 |
} |
| 741 |
|
| 742 |
// This will create + process a refund for the captured amount (if any). IOK 2026-01-26 |
| 743 |
// We always run this since woo will create a manual refund on this status change: we want the refund to be through our gw instead. LP 2026-06-10 |
| 744 |
$this->wc_order_fully_refunded ($order_id); |
| 745 |
|
| 746 |
// In any case, note that this order is ready for cancellation - we don't actually do this here anymore |
| 747 |
$order->update_meta_data('_vipps_capture_complete',true); |
| 748 |
$order->save(); |
| 749 |
} |
| 750 |
|
| 751 |
// Called when orders reach the 'cancelled'-status. When this happens, orders will be *refunded* |
| 752 |
// when they have been captured, but for added safety, this is only done when the orders are relatively new. |
| 753 |
public function maybe_cancel_order($order_id) { |
| 754 |
$order = wc_get_order($order_id); |
| 755 |
if (! Vipps::is_vipps_order($order)) return false; |
| 756 |
|
| 757 |
try { |
| 758 |
$order = $this->update_vipps_payment_details($order); |
| 759 |
} catch (Exception $e) { |
| 760 |
//Do nothing with this for now |
| 761 |
$this->log(__("Error getting payment details before doing cancel: ", 'woo-vipps') . $e->getMessage(), 'warning'); |
| 762 |
} |
| 763 |
|
| 764 |
$payment = $this->check_payment_status($order); |
| 765 |
if ($payment == 'initiated' || $payment == 'cancelled') { |
| 766 |
return true; // Can't cancel these |
| 767 |
} |
| 768 |
|
| 769 |
$days_threshold = apply_filters('woo_vipps_cancel_refund_days_threshold', 30); |
| 770 |
$order_date = $order->get_date_created(); |
| 771 |
$days_since_order = (time() - $order_date->getTimestamp()) / (60 * 60 * 24); |
| 772 |
|
| 773 |
$captured = intval($order->get_meta('_vipps_captured')); |
| 774 |
$vippsstatus = $order->get_meta('_vipps_status'); |
| 775 |
|
| 776 |
// If we have captured some funds, we must first create a refund for the amount we've captured. |
| 777 |
// However, we will only do this if the order is relatively fresh, to avoid accidentally refunding |
| 778 |
// old orders. |
| 779 |
if ($captured > 0 || $vippsstatus == 'SALE') { |
| 780 |
// If this is true then the order is *too old to refund* which would happen on maybe_cancel_payment. |
| 781 |
// add a note instead. |
| 782 |
if ($days_since_order > $days_threshold) { |
| 783 |
$note = sprintf(__('Order with captured funds older than %d days cancelled - because the order is this old, it will not be automatically refunded at Vipps. Manual refund may be required.', 'woo-vipps'), $days_threshold); |
| 784 |
$order->add_order_note($note); |
| 785 |
// Add an admin notice in case this is interactive |
| 786 |
$msg = sprintf(__("Could not cancel %1\$s payment", 'woo-vipps'), $this->get_payment_method_name()); |
| 787 |
$this->adminerr(__('Order', 'woo-vipps') . " " . $order->get_id() . ": " . $note); |
| 788 |
$order->save(); |
| 789 |
Vipps::instance()->store_admin_notices(); |
| 790 |
return false; |
| 791 |
} |
| 792 |
// This will create + process a refund for the captured amount. IOK 2026-01-26 |
| 793 |
$this->wc_order_fully_refunded ($order_id); |
| 794 |
} |
| 795 |
// In any case, note that this order is ready for cancellation - we don't actually do this here anymore |
| 796 |
$order->update_meta_data('_vipps_capture_complete',true); |
| 797 |
$order->save(); |
| 798 |
} |
| 799 |
|
| 800 |
// IOK 2024-09-01 In general, we can refund most Vipps Mobilepay orders through the api, |
| 801 |
// however, this is not the case for the Bank Transfer method available through Vipps Checkout. |
| 802 |
public function can_refund_order( $order ) { |
| 803 |
$method = $order->get_meta('_vipps_api'); |
| 804 |
switch ($method) { |
| 805 |
case 'banktransfer': |
| 806 |
return false; |
| 807 |
break; |
| 808 |
case 'epayment': |
| 809 |
return true; |
| 810 |
break; |
| 811 |
// Default is true; but the above are exhaustive IOK 2026-08-18 |
| 812 |
default: |
| 813 |
return true; |
| 814 |
break; |
| 815 |
} |
| 816 |
} |
| 817 |
|
| 818 |
// This is ran in woocommerce_order_status_refunded *before* woos own wc_order_fully_refunded (priority 9) |
| 819 |
// so that we can create a through-the-gateway refund for this if neccessary. That way, *our* logic for refunds occur |
| 820 |
// instead of the normal woo logic. IOK 2026-04-16 |
| 821 |
public function wc_order_fully_refunded ($orderid) { |
| 822 |
$order = wc_get_order($orderid); |
| 823 |
if (! Vipps::is_vipps_order($order)) return false; |
| 824 |
|
| 825 |
// First check to see if we actually need to refund anything now IOK 2026-02-16 |
| 826 |
$max_refund = wc_format_decimal( $order->get_total() - $order->get_total_refunded() ); |
| 827 |
if ( ! $max_refund ) { |
| 828 |
return; |
| 829 |
} |
| 830 |
|
| 831 |
// IOK 2019-10-03 it is now possible to do capture via other tools than Woo, so we must now first check to see if |
| 832 |
// the order is capturable by getting full payment details. |
| 833 |
try { |
| 834 |
$order = $this->update_vipps_payment_details($order); |
| 835 |
} catch (Exception $e) { |
| 836 |
//Do nothing with this for now |
| 837 |
$this->log(__("Error getting payment details before doing refund: ", 'woo-vipps') . $e->getMessage(), 'warning'); |
| 838 |
} |
| 839 |
|
| 840 |
$data = []; |
| 841 |
$data['amount'] = $max_refund; |
| 842 |
$data['reason'] = __( 'Order fully refunded.', 'woocommerce' ); |
| 843 |
$data['order_id'] = $orderid; |
| 844 |
$data['refund_payment'] = true; // This should call our "process_refund" instead of adding a manual refund |
| 845 |
|
| 846 |
// IOK 2026-04-17 Should be all remaining un-refunded line items |
| 847 |
$line_items = apply_filters('woo_vipps_order_fully_refunded_line_items', $this->get_remaining_refundable_line_items($order), $order); |
| 848 |
$data['line_items'] = $line_items; |
| 849 |
|
| 850 |
wc_switch_to_site_locale(); |
| 851 |
$the_refund = wc_create_refund($data); |
| 852 |
wc_restore_locale(); |
| 853 |
if (is_wp_error($the_refund)) { |
| 854 |
$msg = $the_refund->get_error_message(); |
| 855 |
$order->add_order_note(sprintf(__("Error when refunding payment through %1\$s:", 'woo-vipps'), $this->get_payment_method_name()) . ' ' . $msg); |
| 856 |
$order->save(); |
| 857 |
$this->adminerr($msg); |
| 858 |
} |
| 859 |
return true; |
| 860 |
} |
| 861 |
|
| 862 |
|
| 863 |
// IOK 2026-04-16 Build wc_create_refund() line_items for all remaining refundable order items - used to provide line-item info for the refund to be processed when |
| 864 |
// "fully refunded" is done. |
| 865 |
// [ $item_id => ['qty' => 1, 'refund_total' => '100.00', 'refund_tax' => [ 1 => '25.00' ], * ], ... ] |
| 866 |
// Includes line items, fees and shipping. For fees/shipping, qty is set to 0. |
| 867 |
private function get_remaining_refundable_line_items( WC_Order $order ) { |
| 868 |
$items = $order->get_items( array( 'line_item', 'fee', 'shipping' )); |
| 869 |
|
| 870 |
$new_refund_line_items = []; |
| 871 |
foreach($items as $item_id => $item) { |
| 872 |
$new_refund_line = []; |
| 873 |
|
| 874 |
// Calculate remaining tax for this line item; by tax id. The shape is [ [total] => [tax_id => value_for_this_tax_id] ]. |
| 875 |
// We want the tax id and the value. |
| 876 |
$tax_data = wc_tax_enabled() ? $item->get_taxes() : false; |
| 877 |
$remaining_tax = []; |
| 878 |
if ($tax_data) { |
| 879 |
foreach($tax_data['total'] as $tax_id => $value) { |
| 880 |
if ('' === $value) continue; // don't add empty string as tax value, fatal crash. LP 2026-06-08 |
| 881 |
$remaining_tax[$tax_id] = $value; |
| 882 |
} |
| 883 |
} |
| 884 |
// We can then subtract the tax already refunded for each of these items. |
| 885 |
foreach($remaining_tax as $tax_id => $current) { |
| 886 |
$refunded = $order->get_tax_refunded_for_item($item_id, $tax_id, $item->get_type()); |
| 887 |
$remaining = wc_format_decimal($current-$refunded); |
| 888 |
if ($remaining > 0) { |
| 889 |
$remaining_tax[$tax_id] = wc_format_decimal($current-$refunded); |
| 890 |
} else { |
| 891 |
unset($remaining_tax[$tax_id]); |
| 892 |
} |
| 893 |
} |
| 894 |
|
| 895 |
// Then the quantity |
| 896 |
$qty = (int) $item->get_quantity(); |
| 897 |
$refunded_quantity = abs((int) $order->get_qty_refunded_for_item($item_id, $item->get_type())); // Documented to be positive since 3.0, seems to be actually negative. |
| 898 |
$remaining_quantity = $qty-$refunded_quantity; |
| 899 |
|
| 900 |
$total = $item->get_total(); |
| 901 |
$refunded_total = $order->get_total_refunded_for_item($item_id, $item->get_type()); // A positive value |
| 902 |
$remaining_total = wc_format_decimal($total-$refunded_total); |
| 903 |
|
| 904 |
|
| 905 |
if ($remaining_quantity>0 || !empty($remaining_tax) || $remaining_total > 0) { |
| 906 |
$new_refund_line['qty'] = max(0,$remaining_quantity); |
| 907 |
$new_refund_line['refund_tax'] = $remaining_tax; |
| 908 |
$new_refund_line['refund_total'] = $remaining_total; |
| 909 |
$new_refund_line_items[$item_id] = $new_refund_line; |
| 910 |
} |
| 911 |
|
| 912 |
} |
| 913 |
|
| 914 |
return $new_refund_line_items; |
| 915 |
|
| 916 |
} |
| 917 |
|
| 918 |
|
| 919 |
// This is for orders that are 'reserved' at Vipps but could actually be captured at once because |
| 920 |
// they don't require payment. So we try to capture. IOK 2020-09-22 |
| 921 |
// do NOT call this unless the order is 'reserved' at Vipps! |
| 922 |
protected function maybe_complete_payment($order) { |
| 923 |
if (! Vipps::is_vipps_order($order)) return false; |
| 924 |
if ($order->needs_processing()) return false; // No auto-capture for orders needing processing |
| 925 |
// IOK 2018-10-03 when implementing partial capture, this must be modified. |
| 926 |
$captured = intval($order->get_meta('_vipps_captured')); |
| 927 |
$vippsstatus = $order->get_meta('_vipps_status'); |
| 928 |
if ($captured || $vippsstatus == 'SALE') { |
| 929 |
return true; |
| 930 |
} |
| 931 |
$ok = 0; |
| 932 |
try { |
| 933 |
$ok = $this->capture_payment($order); |
| 934 |
$order->add_order_note(sprintf(__('Payment automatically captured at %1$s for order not needing processing','woo_vipps'), $this->get_payment_method_name())); |
| 935 |
} catch (Exception $e) { |
| 936 |
$order->add_order_note(sprintf(__('Order does not need processing, but payment could not be captured at %1$s:','woo_vipps'), $this->get_payment_method_name()) . ' ' . $e->getMessage()); |
| 937 |
} |
| 938 |
if (!$ok) return false; |
| 939 |
$order->save(); |
| 940 |
return true; |
| 941 |
} |
| 942 |
|
| 943 |
// This filter runs on *all* refunds, including manual refunds. Its main job here is to |
| 944 |
// disallow creating manual refunds on orders that have not been captured yet, since this makes the capture/cancel logic |
| 945 |
// very confusing |
| 946 |
public function woocommerce_create_refund ($refund, $args) { |
| 947 |
$order_id = intval($args['order_id'] ?? 0); |
| 948 |
$order = $order_id ? wc_get_order( $order_id ) : null; |
| 949 |
if ( ! $order ) return; |
| 950 |
if (! Vipps::is_vipps_order($order)) return; |
| 951 |
// This is for manual refunds only IOK 2026-02-24 |
| 952 |
if (!($args['refund_payment'] ?? false)) { |
| 953 |
try { |
| 954 |
$order = $this->update_vipps_payment_details($order); |
| 955 |
} catch (Exception $e) { |
| 956 |
//Do nothing with this for now |
| 957 |
$this->log(__("Error getting payment details before doing refund: ", 'woo-vipps') . $e->getMessage(), 'warning'); |
| 958 |
} |
| 959 |
// This would be *per order line* in the fulfilment branch. IOK 2026-02-24 FIXME |
| 960 |
$captured = intval($order->get_meta('_vipps_captured')); |
| 961 |
if (!$captured) { |
| 962 |
$msg = sprintf(__("Order %2\$d: It is not possible to create a manual refund for a %1\$s order before it has been captured - doing so makes it impossible to track how much to capture and how much to release. If you create the refund through %1\$s, a note will be made internally so that the amount to be refunded will *not* be captured - please do this instead if possible. Otherwise, capture the order then refund either manually or through %1\$s", 'woo-vipps'), $this->get_payment_method_name(), $order_id); |
| 963 |
throw new Exception($msg); |
| 964 |
} |
| 965 |
} |
| 966 |
} |
| 967 |
|
| 968 |
// This is the Woocommerce refund api called by the "Refund" actions. IOK 2018-05-11 |
| 969 |
public function process_refund($orderid,$amount=null,$reason='') { |
| 970 |
$order = wc_get_order($orderid); |
| 971 |
|
| 972 |
$currency = $order->get_currency(); |
| 973 |
|
| 974 |
try { |
| 975 |
$order = $this->update_vipps_payment_details($order); |
| 976 |
} catch (Exception $e) { |
| 977 |
//Do nothing with this for now |
| 978 |
$this->log(__("Error getting payment details before doing refund: ", 'woo-vipps') . $e->getMessage(), 'warning'); |
| 979 |
} |
| 980 |
|
| 981 |
$captured = intval($order->get_meta('_vipps_captured')); |
| 982 |
$to_refund = intval($order->get_meta('_vipps_refund_remaining')); |
| 983 |
|
| 984 |
// No funds captured, by epayment can do cancel of partial capture, so let's note that we are not to capture this. |
| 985 |
if (!$captured) { |
| 986 |
if ('epayment' != $order->get_meta('_vipps_api')) { |
| 987 |
return new WP_Error('Vipps', sprintf(__("Cannot refund through %1\$s - the payment has not been captured yet.", 'woo-vipps'), $this->get_payment_method_name())); |
| 988 |
} |
| 989 |
if ($amount > $order->get_total()) { |
| 990 |
return new WP_Error('Vipps', sprintf(__("Cannot refund through %1\$s - the refund amount is too large.", 'woo-vipps'), $this->get_payment_method_name())); |
| 991 |
} |
| 992 |
$msg = sprintf(__('The money for order %1$d has not been captured, only reserved. %2$s %3$s of the reserved funds will be released when the order is set to complete.', 'woo-vipps'), $orderid, $amount, $currency); |
| 993 |
$this->log($msg, 'info'); |
| 994 |
$uncapturable = round($amount * 100) + intval($order->get_meta('_vipps_noncapturable')); |
| 995 |
|
| 996 |
$order->update_meta_data('_vipps_noncapturable', $uncapturable); |
| 997 |
$order->add_order_note($msg); |
| 998 |
$order->save(); |
| 999 |
return true; |
| 1000 |
} |
| 1001 |
|
| 1002 |
if ($amount*100 > $to_refund) { |
| 1003 |
return new WP_Error('Vipps', sprintf(__("Cannot refund through %1\$s - the refund amount is too large.", 'woo-vipps'), $this->get_payment_method_name())); |
| 1004 |
} |
| 1005 |
$ok = 0; |
| 1006 |
|
| 1007 |
// Specialcase zero, because Vipps treats this as the entire amount IOK 2021-09-14 |
| 1008 |
if (is_numeric($amount) && $amount == 0) { |
| 1009 |
$order->add_order_note($amount . ' ' . $currency . ' ' . sprintf(__(" refunded through %1\$s:",'woo-vipps'), Vipps::CompanyName()) . ' ' . $reason); |
| 1010 |
return true; |
| 1011 |
} |
| 1012 |
|
| 1013 |
try { |
| 1014 |
$ok = $this->refund_payment($order,$amount); |
| 1015 |
} catch (TemporaryVippsApiException $e) { |
| 1016 |
$this->log(sprintf(__('Could not refund %1$s payment for order id:', 'woo-vipps'), $this->get_payment_method_name()) . ' ' . $orderid . "\n" .$e->getMessage(),'error'); |
| 1017 |
return new WP_Error('Vipps',sprintf(__('%1$s is temporarily unavailable.','woo-vipps'), Vipps::CompanyName()) . ' ' . $e->getMessage()); |
| 1018 |
} catch (Exception $e) { |
| 1019 |
$msg = sprintf(__('Could not refund %1$s payment','woo-vipps'), Vipps::CompanyName()) . ' ' . $e->getMessage(); |
| 1020 |
$order->add_order_note($msg); |
| 1021 |
$this->log($msg,'error'); |
| 1022 |
return new WP_Error('Vipps',$msg); |
| 1023 |
} |
| 1024 |
|
| 1025 |
if ($ok) { |
| 1026 |
$order->add_order_note($amount . ' ' . $currency . ' ' . sprintf(__(" refunded through %1\$s:",'woo-vipps'), Vipps::CompanyName()) . ' ' . $reason); |
| 1027 |
} |
| 1028 |
return $ok; |
| 1029 |
} |
| 1030 |
|
| 1031 |
// Detect default payment method based on country code NT-2024-10-15 |
| 1032 |
public function detect_default_payment_method_from_country($country_code) { |
| 1033 |
// Default to MobilePay |
| 1034 |
$payment_method_name = 'MobilePay'; |
| 1035 |
// Default to Vipps if country is Norway or Sweden |
| 1036 |
if($country_code == 'NO' || $country_code == 'SE') { |
| 1037 |
$payment_method_name = 'Vipps'; |
| 1038 |
} |
| 1039 |
return $payment_method_name; |
| 1040 |
} |
| 1041 |
|
| 1042 |
// Returns true iff this is a store where Vipps will allow external payment methods. |
| 1043 |
// Currently this is only Finland, and only Klarna is supported. We need to call this like so because |
| 1044 |
// most of woocommerce will not be initialized when we need this info. IOK 2024-05-28 |
| 1045 |
public function allow_external_payments_in_checkout() { |
| 1046 |
$store_location= wc_get_base_location(); |
| 1047 |
$store_country = $store_location['country'] ?? ''; |
| 1048 |
$finland = (get_woocommerce_currency() == "EUR" && $store_country == "FI"); |
| 1049 |
$norway = (get_woocommerce_currency() == "NOK" && $store_country == "NO"); |
| 1050 |
$sweden = (get_woocommerce_currency() == "SEK" && $store_country == "SE"); |
| 1051 |
return apply_filters('woo_vipps_allow_external_payment_methods', ($finland || $norway || $sweden)); |
| 1052 |
} |
| 1053 |
|
| 1054 |
public function init_form_fields() { |
| 1055 |
global $Vipps; |
| 1056 |
|
| 1057 |
// Used for defaults in the admin interface; however this functions is called a loot more often than that. |
| 1058 |
$page_templates = $this->get_theme_page_templates(); |
| 1059 |
$page_list = $this->get_pagelist(); |
| 1060 |
|
| 1061 |
$orderprefix = $Vipps->generate_order_prefix(); |
| 1062 |
|
| 1063 |
// Default handling based on other parameters and earlier values. |
| 1064 |
$expresscreateuserdefault = "no"; |
| 1065 |
$vippscreateuserdefault = "no"; |
| 1066 |
|
| 1067 |
// Express checkout uses verified email addresses,so we'll create users if the Login plugin is installed and WooCommerce is set to allow user registration. |
| 1068 |
if (class_exists('VippsWooLogin')) { |
| 1069 |
$woodefault = 'yes' === get_option('woocommerce_enable_signup_and_login_from_checkout'); |
| 1070 |
if ($woodefault) { |
| 1071 |
$expresscreateuserdefault = "yes"; |
| 1072 |
// $vippscreateuserdefault = "yes"; // However, for Vipps Checkout the email address is freetext so we'll treat the default a bit different. |
| 1073 |
} |
| 1074 |
} |
| 1075 |
|
| 1076 |
// We will only show the Vipps Checkout options if the user has activated the feature (thus creating the pages involved etc). IOK 2021-10-01 |
| 1077 |
$vipps_checkout_activated = get_option('woo_vipps_checkout_activated', false); |
| 1078 |
|
| 1079 |
|
| 1080 |
// This is used for new options,to set reasonable defaults based on older settings. We can't use WC_Settings->get_option for this unfortunately. |
| 1081 |
$current = get_option('woocommerce_vipps_settings'); |
| 1082 |
// New defaults based on old defaults |
| 1083 |
$default_static_shipping_for_checkout = 'no'; |
| 1084 |
$default_ask_address_for_express = 'no'; |
| 1085 |
$default_status_on_fail = 'failed'; |
| 1086 |
$default_express_show_in_checkout = 'yes'; |
| 1087 |
if ($current) { |
| 1088 |
$default_static_shipping_for_checkout = (isset($current['enablestaticshipping'])) ? $current['enablestaticshipping'] : 'no'; |
| 1089 |
$default_ask_address_for_express = (isset($current['useExplicitCheckoutFlow']) && $current['useExplicitCheckoutFlow'] == "yes") ? "yes" : "no"; |
| 1090 |
// The old default used the same value as for Express Checkout. IOK 2023-07-27 |
| 1091 |
$vippscreateuserdefault = isset($current['expresscreateuser']) ? $current['expresscreateuser'] : $vippscreateuserdefault; |
| 1092 |
|
| 1093 |
// For existing installs: set failed payments order status to cancelled to keep same default behaviour. |
| 1094 |
// New installs will be set to failed instead of cancelled. LP 2026-03-26 |
| 1095 |
$default_status_on_fail = 'cancelled'; |
| 1096 |
|
| 1097 |
// New setting 'express_show_in_checkout', previously 'cartexpress' affected both cart and checkout. |
| 1098 |
// Therefore, set new one equal to 'cartexpress' IF it isn't set yet, so that the functionality stays the same for users. LP 2026-07-02 |
| 1099 |
$default_express_show_in_checkout = 'yes'; |
| 1100 |
if (!isset($current['express_show_in_checkout']) && isset($current['cartexpress'])) { |
| 1101 |
$default_express_show_in_checkout = $current['cartexpress']; |
| 1102 |
} |
| 1103 |
} |
| 1104 |
|
| 1105 |
// Get the already-set country code. For existing sites, this will guess the country based on the currency; for new sites, use |
| 1106 |
// the woo base country. IOK 2024-10-17 (previously used the currency here too). |
| 1107 |
$countries = new WC_Countries(); // Can't use WC()->countries here - too early IOK 2024-10-17 |
| 1108 |
$country_code = $current['country'] ?? $countries->get_base_country(); |
| 1109 |
|
| 1110 |
// Same issue as above: We need the default payment method name before it is set to be able to provide defaults IOK 2023-12-01 |
| 1111 |
$payment_method_name = $current['payment_method_name'] ?? $this->detect_default_payment_method_from_country($country_code); |
| 1112 |
|
| 1113 |
$checkoutfields = array( |
| 1114 |
'checkout_options' => array( |
| 1115 |
'title' => "Checkout", // Vipps::CheckoutName(), // Don't translate this, but save some space IOK 2024-12-06 |
| 1116 |
'type' => 'title', |
| 1117 |
'class' => 'tab', |
| 1118 |
'description' => sprintf(__("%1\$s is a new service from %2\$s which replaces the usual WooCommerce checkout page entirely, replacing it with a simplified checkout screen providing payment both with %2\$s and credit card. Additionally, your customers will get the option of providing their address information using their %2\$s app directly.", 'woo-vipps'), Vipps::CheckoutName(), Vipps::CompanyName()), |
| 1119 |
), |
| 1120 |
|
| 1121 |
|
| 1122 |
'vipps_checkout_enabled' => array( |
| 1123 |
'title' => sprintf(__('Activate Alternative %1$s', 'woo-vipps'), Vipps::CheckoutName()), |
| 1124 |
'label' => sprintf(__('Enable Alternative %1$s screen, replacing the standard checkout page', 'woo-vipps'), Vipps::CheckoutName()), |
| 1125 |
'type' => 'checkbox', |
| 1126 |
'description' => sprintf(__('If activated, this will <strong>replace</strong> the standard Woo checkout screen with %1$s, providing easy checkout using %1$s or credit card, with no need to type in addresses.', 'woo-vipps'), Vipps::CheckoutName()), |
| 1127 |
'default' => 'no', |
| 1128 |
), |
| 1129 |
|
| 1130 |
'checkoutcreateuser' => array ( |
| 1131 |
'title' => sprintf(__('Create new customers on %1$s', 'woo-vipps'), Vipps::CheckoutName()), |
| 1132 |
'label' => sprintf(__('Create new customers on %1$s', 'woo-vipps'), Vipps::CheckoutName()), |
| 1133 |
'type' => 'checkbox', |
| 1134 |
'description' => sprintf(__('Enable this to create and login customers when using %1$s. Otherwise these will all be guest checkouts. If using, you may want to install Login with Vipps too.', 'woo-vipps'), Vipps::CheckoutName()), |
| 1135 |
'default' => $vippscreateuserdefault, |
| 1136 |
), |
| 1137 |
|
| 1138 |
'enablestaticshipping_checkout' => array( |
| 1139 |
'title' => sprintf(__('Enable static shipping for %1$s', 'woo-vipps'), Vipps::CheckoutName()), |
| 1140 |
'label' => __('Enable static shipping', 'woo-vipps'), |
| 1141 |
'type' => 'checkbox', |
| 1142 |
'description' => sprintf(__('If your shipping options do not depend on the customers address, you can enable \'Static shipping\', which will precompute the shipping options when using %1$s so that this will be much faster. If you do this and the customer isn\'t logged in, the base location of the store will be used to compute the shipping options for the order. You should only use this if your shipping is actually \'static\', that is, does not vary based on the customers address. So fixed price/free shipping will work. If the customer is logged in, their address as registered in the store will be used, so if your customers are always logged in, you may be able to use this too.', 'woo-vipps'), Vipps::CheckoutName()), |
| 1143 |
'default' => $default_static_shipping_for_checkout |
| 1144 |
), |
| 1145 |
|
| 1146 |
|
| 1147 |
'requireUserInfo_checkout' => array( |
| 1148 |
'title' => __('Ask the user to consent to share user information', 'woo-vipps'), |
| 1149 |
'label' => __('Ask the user to consent to share user information', 'woo-vipps'), |
| 1150 |
'type' => 'checkbox', |
| 1151 |
'description' => sprintf(__('If using %1$s, ask for the users consent to share user information with the store. This will allow better integration between Login With %1$s but will add another step to first-time buyers.', 'woo-vipps'), Vipps::CompanyName()), |
| 1152 |
'default' => 'no' |
| 1153 |
), |
| 1154 |
|
| 1155 |
'noAddressFields' => array( |
| 1156 |
'title' => __('Drop the address fields on the Checkout screen', 'woo-vipps'), |
| 1157 |
'label' => __('Don\'t require the address fields', 'woo-vipps'), |
| 1158 |
'type' => 'checkbox', |
| 1159 |
'description' => __('If your products <i>don\'t require shipping</i>, either because they are digital downloads, immaterial products or delivering the products directly on purchase, you can check this box. The user will then not be required to provide an address, which should speed things up a bit. If your products require shipping, this will have no effect. NB: If you have plugins that require shipping information, then this is not going to work very well.','woo-vipps'), |
| 1160 |
'default' => 'no' |
| 1161 |
), |
| 1162 |
|
| 1163 |
'noContactFields' => array( |
| 1164 |
'title' => __('Drop the contact fields on the Checkout screen', 'woo-vipps'), |
| 1165 |
'label' => __('Don\'t require the contact fields', 'woo-vipps'), |
| 1166 |
'type' => 'checkbox', |
| 1167 |
'description' => __('If your products <i>don\'t require shipping</i> as above, and you also don\'t care about the customers name or contact information, you can drop this too! The customer fields will then be filled with a placeholder. NB: If you have plugins that require contact information, then this is not going to work very well. Also, for this to work you have to check the \'no addresses\' box as well.','woo-vipps'), |
| 1168 |
'default' => 'no' |
| 1169 |
), |
| 1170 |
|
| 1171 |
|
| 1172 |
); |
| 1173 |
|
| 1174 |
$vipps_checkout_shipping_fields = array( |
| 1175 |
|
| 1176 |
'checkout_shipping' => array( |
| 1177 |
'title' => sprintf(__('%1$s Shipping Methods', 'woo-vipps'), Vipps::CheckoutName()), |
| 1178 |
'type' => 'title', |
| 1179 |
'description' => sprintf(__("When using %1\$s, you have the option to use %1\$s specific shipping methods with extended features for certain carriers. These will add an apropriate logo as well as extended delivery options for certain methods. For some of these, you need to add integration data from the carriers below. You can then add these shipping methods to your shipping zones the normal way, but they will only appear in the %1\$s screen.", 'woo-vipps'), Vipps::CheckoutName()) |
| 1180 |
), |
| 1181 |
|
| 1182 |
'vcs_posten' => array( |
| 1183 |
'title' => __('Posten Norge', 'woo-vipps'), |
| 1184 |
'class' => 'vcs_posten vcs_main', |
| 1185 |
'custom_attributes' => array('data-vcs-show'=>'.vcs_depend.vcs_posten'), |
| 1186 |
'label' => sprintf(__('Support Posten Norge as a shipping method in %1$s', 'woo-vipps'), Vipps::CheckoutName()), |
| 1187 |
'type' => 'checkbox', |
| 1188 |
'description' => sprintf(__('Activate this for Posten Norge as a %1$s Shipping method.', 'woo-vipps'), Vipps::CheckoutName()), |
| 1189 |
'default' => 'yes' |
| 1190 |
), |
| 1191 |
|
| 1192 |
'vcs_posti' => array( |
| 1193 |
'title' => __('Posti', 'woo-vipps'), |
| 1194 |
'class' => 'vcs_posti vcs_main', |
| 1195 |
'custom_attributes' => array('data-vcs-show'=>'.vcs_depend.vcs_posti'), |
| 1196 |
'label' => sprintf(__('Support Posti as a shipping method in %1$s', 'woo-vipps'), Vipps::CheckoutName()), |
| 1197 |
'type' => 'checkbox', |
| 1198 |
'description' => sprintf(__('Activate this for Posti as a %1$s Shipping method.', 'woo-vipps'), Vipps::CheckoutName()), |
| 1199 |
'default' => 'yes' |
| 1200 |
), |
| 1201 |
|
| 1202 |
'vcs_postnord' => array( |
| 1203 |
'title' => __('PostNord', 'woo-vipps'), |
| 1204 |
'class' => 'vcs_postnord vcs_main', |
| 1205 |
'custom_attributes' => array('data-vcs-show'=>'.vcs_depend.vcs_postnord'), |
| 1206 |
'label' => sprintf(__('Support PostenNord as a shipping method in %1$s', 'woo-vipps'), Vipps::CheckoutName()), |
| 1207 |
'type' => 'checkbox', |
| 1208 |
'description' => sprintf(__('Activate this for PostNord as a %1$s Shipping method.', 'woo-vipps'), Vipps::CheckoutName()), |
| 1209 |
'default' => 'yes' |
| 1210 |
), |
| 1211 |
|
| 1212 |
'vcs_porterbuddy' => array( |
| 1213 |
'title' => __('Porterbuddy', 'woo-vipps'), |
| 1214 |
'class' => 'vcs_porterbuddy vcs_main', |
| 1215 |
'custom_attributes' => array('data-vcs-show'=>'.vcs_depend.vcs_porterbuddy'), |
| 1216 |
'label' => sprintf(__('Support Porterbuddy as a shipping method in %1$s', 'woo-vipps'), Vipps::CheckoutName()), |
| 1217 |
'type' => 'checkbox', |
| 1218 |
'description' => sprintf(__('Activate this for Porterbuddy as a %1$s Shipping method. Your store address will be used as the pick-up point and your admin email will be used for booking information from Porterbuddy.' ,'woo-vipps'), Vipps::CheckoutName()), |
| 1219 |
'default' => 'no' |
| 1220 |
), |
| 1221 |
|
| 1222 |
'vcs_porterbuddy_publicToken' => array( |
| 1223 |
'title' => __('Porterbuddy public token', 'woo-vipps'), |
| 1224 |
'class' => 'vippspw vcs_porterbuddy vcs_depend', |
| 1225 |
'type' => 'password', |
| 1226 |
'description' => __('The public key provided to you by Porterbuddy','woo-vipps'), |
| 1227 |
'default' => '', |
| 1228 |
), |
| 1229 |
'vcs_porterbuddy_apiKey' => array( |
| 1230 |
'title' => __('Porterbuddy API key', 'woo-vipps'), |
| 1231 |
'class' => 'vippspw vcs_porterbuddy vcs_depend', |
| 1232 |
'type' => 'password', |
| 1233 |
'description' => __('The API key provided to you by Porterbuddy','woo-vipps'), |
| 1234 |
'default' => '', |
| 1235 |
), |
| 1236 |
'vcs_porterbuddy_phoneNumber' => array( |
| 1237 |
'title' => __('Porterbuddy Phone Number', 'woo-vipps'), |
| 1238 |
'class' => 'vcs_porterbuddy vcs_depend', |
| 1239 |
'type' => 'text', |
| 1240 |
'description' => __('Your phone number where Porterbuddy may send you important messages. Format must be MSISDN (including country code). Example: "4791234567"','woo-vipps'), |
| 1241 |
'default' => '', |
| 1242 |
), |
| 1243 |
|
| 1244 |
// Vipps checkout *shipping options* - extra shipping options that only work with Vipps Checkout |
| 1245 |
'vcs_helthjem' => array( |
| 1246 |
'title' => __('Helthjem', 'woo-vipps'), |
| 1247 |
'label' => sprintf(__('Support Helthjem as a shipping method in %1$s', 'woo-vipps'), Vipps::CheckoutName()), |
| 1248 |
'type' => 'checkbox', |
| 1249 |
'class' => 'vcs_helthjem vcs_main', |
| 1250 |
'custom_attributes' => array('data-vcs-show'=>'.vcs_depend.vcs_helthjem'), |
| 1251 |
'description' => sprintf(__('Activate this for Helthjem as a %1$s Shipping method.' ,'woo-vipps'), Vipps::CheckoutName()), |
| 1252 |
'default' => 'no' |
| 1253 |
), |
| 1254 |
|
| 1255 |
'vcs_helthjem_shopId' => array( |
| 1256 |
'title' => __('Helthjem Shop Id', 'woo-vipps'), |
| 1257 |
'class' => 'vcs_helthjem vcs_depend', |
| 1258 |
'type' => 'number', |
| 1259 |
'custom_attributes' => array('pattern'=>'[0-9]'), |
| 1260 |
'description' => __('The ShopId provided to you by Helthjem','woo-vipps'), |
| 1261 |
'default' => '', |
| 1262 |
), |
| 1263 |
|
| 1264 |
'vcs_helthjem_username' => array( |
| 1265 |
'title' => __('Helthjem Username', 'woo-vipps'), |
| 1266 |
'class' => 'vcs_helthjem vcs_depend', |
| 1267 |
'type' => 'text', |
| 1268 |
'description' => __('The Username provided to you by Helthjem','woo-vipps'), |
| 1269 |
'default' => '', |
| 1270 |
), |
| 1271 |
'vcs_helthjem_password' => array( |
| 1272 |
'title' => __('Helthjem Password', 'woo-vipps'), |
| 1273 |
'class' => 'vippspw vcs_helthjem vcs_depend', |
| 1274 |
'type' => 'password', |
| 1275 |
'description' => __('Password provided to you by Helthjem','woo-vipps'), |
| 1276 |
'default' => '', |
| 1277 |
), |
| 1278 |
|
| 1279 |
); |
| 1280 |
|
| 1281 |
/* Support for *certain* external payment methods in Vipps Checkout. IOK 2024-05-27 */ |
| 1282 |
$externals = []; |
| 1283 |
$external_payment_fields = []; |
| 1284 |
$allow_external_payments = $this->allow_external_payments_in_checkout(); |
| 1285 |
if ($allow_external_payments) { |
| 1286 |
if (in_array('KCO_Gateway', Vipps::$installed_gateways) || in_array('WC_Gateway_Klarna_Payments', Vipps::$installed_gateways)) { |
| 1287 |
$externals['checkout_external_payments_klarna'] = array( |
| 1288 |
'title' => __('Klarna', 'woo-vipps'), |
| 1289 |
'label' => __('Klarna', 'woo-vipps'), |
| 1290 |
'type' => 'checkbox', |
| 1291 |
'class' => 'external_payments klarna', |
| 1292 |
'description' => sprintf(__("Allow Klarna as an external payment method in %1\$s",'woo-vipps'), Vipps::CheckoutName()), |
| 1293 |
'default' => 'no', |
| 1294 |
); |
| 1295 |
} |
| 1296 |
if (!empty($externals)) { |
| 1297 |
$external_payment_fields = [ |
| 1298 |
'checkout_external_payment_title' => array( |
| 1299 |
'title' => sprintf(__('External Payment Methods', 'woo-vipps'), Vipps::CheckoutName()), |
| 1300 |
'type' => 'title', |
| 1301 |
'description' => sprintf(__("Allow certain external payment methods in %1\$s, returning control to WooCommerce for the order", 'woo-vipps'), Vipps::CheckoutName()) |
| 1302 |
), |
| 1303 |
]; |
| 1304 |
foreach($externals as $k => $def) $external_payment_fields[$k] = $def; |
| 1305 |
} |
| 1306 |
} |
| 1307 |
|
| 1308 |
$vipps_checkout_widgets_fields = [ |
| 1309 |
'checkout_widgets' => [ |
| 1310 |
'title' => sprintf(__('%1$s widgets', 'woo-vipps'), Vipps::CheckoutName()), |
| 1311 |
'type' => 'title', |
| 1312 |
'description' => sprintf(__('Widgets are elements shown above the %1$s frame with extra functionality.', 'woo-vipps'), Vipps::CheckoutName()), |
| 1313 |
], |
| 1314 |
'checkout_widget_ordernotes' => [ |
| 1315 |
'title' => __('Order notes', 'woo-vipps'), |
| 1316 |
'label' => __('Enable the order notes widget', 'woo-vipps'), |
| 1317 |
'type' => 'checkbox', |
| 1318 |
'description' => __('A widget to add customer notes with their order.', 'woo-vipps'), |
| 1319 |
'default' => 'yes' |
| 1320 |
], |
| 1321 |
]; |
| 1322 |
/* This seems to have broken some sites with OOM during plugin activation. 2025-05-27 */ |
| 1323 |
// if (wc_coupons_enabled()) { |
| 1324 |
$vipps_checkout_widgets_fields['checkout_widget_coupon'] = [ |
| 1325 |
'title' => __('Coupon code', 'woo-vipps'), |
| 1326 |
'label' => __('Enable the coupon code widget', 'woo-vipps'), |
| 1327 |
'type' => 'checkbox', |
| 1328 |
'description' => __('A widget to activate coupon codes.', 'woo-vipps'), |
| 1329 |
'default' => 'yes' |
| 1330 |
]; |
| 1331 |
// } |
| 1332 |
|
| 1333 |
$mainfields = array( |
| 1334 |
'main_options' => array( |
| 1335 |
'title' => __('Main options', 'woo-vipps'), |
| 1336 |
'type' => 'title', |
| 1337 |
'class' => 'tab', |
| 1338 |
), |
| 1339 |
'enabled' => array( |
| 1340 |
'title' => __('Enable/Disable', 'woocommerce'), |
| 1341 |
'label' => sprintf(__('Enable %1$s', 'woo-vipps'), Vipps::CompanyName()), |
| 1342 |
'type' => 'checkbox', |
| 1343 |
'description' => '', |
| 1344 |
'default' => 'no', |
| 1345 |
), |
| 1346 |
'country' => array( |
| 1347 |
'title' => __('Country', 'woo-vipps'), |
| 1348 |
'label' => __('Country', 'woo-vipps'), |
| 1349 |
'type' => 'select', |
| 1350 |
'options' => array( |
| 1351 |
'NO' => __('Norway', 'woo-vipps'), |
| 1352 |
'SE' => __('Sweden', 'woo-vipps'), |
| 1353 |
'FI' => __('Finland', 'woo-vipps'), |
| 1354 |
'DK' => __('Denmark', 'woo-vipps'), |
| 1355 |
), |
| 1356 |
'description' => __('Select the country for this merchant serial number. This will determine the appropriate payment method (Vipps or MobilePay).', 'woo-vipps'), |
| 1357 |
'default' => $country_code, |
| 1358 |
), |
| 1359 |
|
| 1360 |
'payment_method_name' => array( |
| 1361 |
'title' => __('Payment method', 'woo-vipps'), |
| 1362 |
'label' => __('Choose which payment method should be displayed to users at checkout', 'woo-vipps'), |
| 1363 |
'type' => 'select', |
| 1364 |
'options' => array( |
| 1365 |
'Vipps' => __('Vipps','woo-vipps'), |
| 1366 |
'MobilePay' => __('MobilePay', 'woo-vipps'), |
| 1367 |
), |
| 1368 |
'description' => __('Choose which payment method should be displayed to users at checkout', 'woo-vipps'), |
| 1369 |
'default' => $payment_method_name, |
| 1370 |
), |
| 1371 |
|
| 1372 |
'orderprefix' => array( |
| 1373 |
'title' => __('Order-id Prefix', 'woo-vipps'), |
| 1374 |
'label' => __('Order-id Prefix', 'woo-vipps'), |
| 1375 |
'type' => 'string', |
| 1376 |
'description' => __('An alphanumeric textstring to use as a prefix on orders from your shop, to avoid duplicate order-ids','woo-vipps'), |
| 1377 |
'default' => $orderprefix |
| 1378 |
), |
| 1379 |
'merchantSerialNumber' => array( |
| 1380 |
'title' => __('Merchant Serial Number', 'woo-vipps'), |
| 1381 |
'label' => __('Merchant Serial Number', 'woo-vipps'), |
| 1382 |
'type' => 'number', |
| 1383 |
'description' => __('Your "Merchant Serial Number" from the Developer tab on https://portal.vippsmobilepay.com','woo-vipps'), |
| 1384 |
'default' => '', |
| 1385 |
), |
| 1386 |
'clientId' => array( |
| 1387 |
'title' => __('Client Id', 'woo-vipps'), |
| 1388 |
'class' => 'vippspw', |
| 1389 |
'label' => __('Client Id', 'woo-vipps'), |
| 1390 |
'type' => 'password', |
| 1391 |
'description' => __('Find your account under the "Developer" tab on https://portal.vippsmobilepay.com/ and choose "Show keys". Copy the value of "client_id"','woo-vipps'), |
| 1392 |
'default' => '', |
| 1393 |
), |
| 1394 |
'secret' => array( |
| 1395 |
'title' => __('Client Secret', 'woo-vipps'), |
| 1396 |
'label' => __('Client Secret', 'woo-vipps'), |
| 1397 |
'class' => 'vippspw', |
| 1398 |
'type' => 'password', |
| 1399 |
'description' => __('Find your account under the "Developer" tab on https://portal.vippsmobilepay.com/ and choose "show keys". Copy the value of "client_secret"','woo-vipps'), |
| 1400 |
'default' => '', |
| 1401 |
), |
| 1402 |
'Ocp_Apim_Key_eCommerce' => array( |
| 1403 |
'title' => __('Subscription Key', 'woo-vipps'), |
| 1404 |
'label' => __('Subscription Key', 'woo-vipps'), |
| 1405 |
'class' => 'vippspw', |
| 1406 |
'type' => 'password', |
| 1407 |
'description' => __('Find your account under the "Developer" tab on https://portal.vippsmobilepay.com/ and choose "show keys". Copy the value of "Vipps-Subscription-Key"','woo-vipps'), |
| 1408 |
'default' => '', |
| 1409 |
), |
| 1410 |
|
| 1411 |
'result_status' => array( |
| 1412 |
'title' => sprintf(__('Order status on return from %1$s', 'woo-vipps'), Vipps::CompanyName()), |
| 1413 |
'label' => __('Choose default order status for reserved (not captured) orders', 'woo-vipps'), |
| 1414 |
'type' => 'select', |
| 1415 |
'options' => array( |
| 1416 |
'processing' => __('Processing', 'woo-vipps'), |
| 1417 |
'on-hold' => __('On hold','woo-vipps'), |
| 1418 |
), |
| 1419 |
'description' => __('By default, orders that are <b>reserved</b> but not <b>yet captured</b> will now have the order status \'Processing\'. You can capture the sum manually, or by changing the status to \'Complete\'. You should ensure that your workflow is such that the order is not shipped until after this capture.<br><br> The status \'On hold\' can be chosen instead for stores using a workflow where orders are shipped when the status is \'Processing\'. In this case, \'On hold\' will mean "order is reserved but not yet captured". This is a slightly safer solution, and ensures that the order status will reflect the payment status. <br><br>However, in many stores \'On hold\' has the additional meaning "there is a problem with the order"; and an email is often sent to the customer about this problem. The default is \'Processing\' because of this, and because many plugins and integrations expect orders to be \'Processing\' when the customer has completed payment.', 'woo-vipps'), |
| 1420 |
'default' => 'processing', |
| 1421 |
), |
| 1422 |
|
| 1423 |
'status_on_fail' => array( |
| 1424 |
'title' => sprintf(__('Order status on failed payment (for restartable orders)', 'woo-vipps'), Vipps::CompanyName()), |
| 1425 |
'label' => __('Choose default order status for failed payments', 'woo-vipps'), |
| 1426 |
'type' => 'select', |
| 1427 |
'options' => array( |
| 1428 |
/* translators: woocommerce status name */ |
| 1429 |
'failed' => __('Failed', 'woo-vipps'), |
| 1430 |
/* translators: woocommerce status name */ |
| 1431 |
'cancelled' => __('Cancelled','woo-vipps'), |
| 1432 |
), |
| 1433 |
/* translators: company name. cancelled and failed are woocommerce status names! */ |
| 1434 |
'description' => sprintf(__('By default, orders where payment is started but not completed at %1$s will be set to failed if they can be restarted. This setting changes this behaviour, but does <strong>not</strong> affect orders that cannot be restarted as these will always be set to cancelled.<br><br>Cancelled orders will keep the customer\'s shopping cart intact.<br>Failed orders can be restarted, possibly with another payment method.', 'woo-vipps'), Vipps::CompanyName()), |
| 1435 |
'default' => $default_status_on_fail, |
| 1436 |
), |
| 1437 |
|
| 1438 |
/* |
| 1439 |
'title' => array( |
| 1440 |
'title' => __('Title', 'woocommerce'), |
| 1441 |
'type' => 'text', |
| 1442 |
'description' => __('This controls the title which the user sees during checkout.', 'woocommerce'), |
| 1443 |
'default' => sprintf(__('%1$s','woo-vipps'), $payment_method_name), |
| 1444 |
), |
| 1445 |
*/ |
| 1446 |
|
| 1447 |
'description' => array( |
| 1448 |
'title' => __('Description', 'woocommerce'), |
| 1449 |
'type' => 'textarea', |
| 1450 |
'description' => __('This controls the description which the user sees during checkout.', 'woocommerce'), |
| 1451 |
'default' => __("Pay safely and easily. No fees, no matter the amount.", 'woo-vipps'), |
| 1452 |
), |
| 1453 |
|
| 1454 |
'vippsdefault' => array( |
| 1455 |
'title' => sprintf(__('Use %1$s as default payment method on checkout page', 'woo-vipps'), $payment_method_name), |
| 1456 |
'label' => sprintf(__('%1$s is default payment method', 'woo-vipps'), $payment_method_name), |
| 1457 |
'type' => 'checkbox', |
| 1458 |
'description' => sprintf(__('Enable this to use %1$s as the default payment method on the checkout page, regardless of order.', 'woo-vipps'), $payment_method_name), |
| 1459 |
'default' => 'yes', |
| 1460 |
), |
| 1461 |
|
| 1462 |
'checkout_phone_transformation' => array( |
| 1463 |
'title' => sprintf(__('Phone number transformation for %1$s and Express Checkout', 'woo-vipps'), 'Checkout'), |
| 1464 |
'label' => sprintf(__('Choose a transformation to apply to phone numbers for %1$s and Express Checkout', 'woo-vipps'), 'Checkout'), |
| 1465 |
'type' => 'select', |
| 1466 |
'options' => array( |
| 1467 |
'none' => __('None', 'woo-vipps'), |
| 1468 |
'ensure_plus' => __('Prepend \'+\'','woo-vipps'), |
| 1469 |
'strip_country_code' => __('Strip country code','woo-vipps'), |
| 1470 |
), |
| 1471 |
'description' => __('Phone numbers from Express or Checkout are in the format 47xxxxxx without plus-sign in front. If you prefer, or if it is neccessary for your integrations, you can transform these numbers either by adding the plus sign or by stripping the country-code (45, 46, 47, 358).<br>NB: stripping country codes is at the moment only supported for Norwegian, Danish, Finnish and Swedish numbers.<br>Remember to explicitly test your use case before committing to any transformation on your live store.', 'woo-vipps'), |
| 1472 |
'default' => 'none', |
| 1473 |
), |
| 1474 |
); |
| 1475 |
|
| 1476 |
$expressfields = array( |
| 1477 |
'express_options' => array( |
| 1478 |
'title' => sprintf(__('Express Checkout', 'woo-vipps')), |
| 1479 |
'type' => 'title', |
| 1480 |
'class' => 'tab', |
| 1481 |
'description' => sprintf(__("%1\$s allows you to buy products by a single click from the cart, checkout, or directly from product or catalog pages. Product will get a 'buy now' button which will start the purchase process immediately.", 'woo-vipps'), Vipps::ExpressCheckoutName()) |
| 1482 |
), |
| 1483 |
|
| 1484 |
'cartexpress' => array( |
| 1485 |
'title' => __('Enable Express Checkout in cart', 'woo-vipps'), |
| 1486 |
'label' => __('Enable Express Checkout in cart', 'woo-vipps'), |
| 1487 |
'type' => 'checkbox', |
| 1488 |
'description' => sprintf(__('Enable this to allow customers to shop using %1$s directly from the cart with no login or address input needed', 'woo-vipps'), Vipps::ExpressCheckoutName()) . '.<br>' . |
| 1489 |
sprintf(__('Please note that for Express Checkout, shipping must be calculated in a callback from the %1$s app, without any knowledge of the customer. This means that Express Checkout may not be compatible with all Shipping plugins or setup. You should test that your setup works if you intend to provide this feature.', 'woo-vipps'), Vipps::CompanyName()), |
| 1490 |
'default' => 'yes', |
| 1491 |
), |
| 1492 |
|
| 1493 |
'express_show_in_checkout' => array( |
| 1494 |
'title' => __('Enable Express Checkout in checkout', 'woo-vipps'), |
| 1495 |
'label' => __('Enable Express Checkout in checkout', 'woo-vipps'), |
| 1496 |
'type' => 'checkbox', |
| 1497 |
'description' => sprintf(__('Enable this to allow customers to shop using %1$s directly from the checkout page with no login or address input needed', 'woo-vipps'), Vipps::ExpressCheckoutName()) . '.<br>' . |
| 1498 |
sprintf(__('Please note that for Express Checkout, shipping must be calculated in a callback from the %1$s app, without any knowledge of the customer. This means that Express Checkout may not be compatible with all Shipping plugins or setup. You should test that your setup works if you intend to provide this feature.', 'woo-vipps'), Vipps::CompanyName()), |
| 1499 |
'default' => $default_express_show_in_checkout, |
| 1500 |
), |
| 1501 |
|
| 1502 |
'singleproductexpress' => array( |
| 1503 |
'title' => __('Enable Express Checkout for single products', 'woo-vipps'), |
| 1504 |
'label' => __('Enable Express Checkout for single products', 'woo-vipps'), |
| 1505 |
'type' => 'select', |
| 1506 |
'options' => array( |
| 1507 |
'none' => __('No products','woo-vipps'), |
| 1508 |
'some' => __('Some products', 'woo-vipps'), |
| 1509 |
'all' => __('All products','woo-vipps') |
| 1510 |
), |
| 1511 |
'description' => sprintf(__('Enable this to allow customers to buy a product using %1$s directly from the product page. If you choose \'some\', you must enable this on the relevant products', 'woo-vipps'), Vipps::ExpressCheckoutName()), |
| 1512 |
'default' => 'none', |
| 1513 |
), |
| 1514 |
'singleproductexpressarchives' => array( |
| 1515 |
'title' => __('Add \'Buy now\' button on catalog pages too', 'woo-vipps'), |
| 1516 |
'label' => __('Add the button for all relevant products on catalog pages', 'woo-vipps'), |
| 1517 |
'type' => 'checkbox', |
| 1518 |
'description' => sprintf(__('If %1$s is enabled for a product, add the \'Buy now\' button to catalog pages too', 'woo-vipps'), Vipps::ExpressCheckoutName()), |
| 1519 |
'default' => 'no', |
| 1520 |
), |
| 1521 |
'expresscheckout_termscheckbox' => array( |
| 1522 |
'title' => sprintf(__('Add terms and conditions checkbox on %1$s', 'woo-vipps'), Vipps::ExpressCheckoutName()), |
| 1523 |
'label' => sprintf(__('Always ask for confirmation on %1$s', 'woo-vipps'), Vipps::ExpressCheckoutName()), |
| 1524 |
'type' => 'checkbox', |
| 1525 |
'description' => sprintf(__('When using %1$s, ask the user to confirm that they have read and accepted the stores terms and conditons before proceeding', 'woo-vipps'), Vipps::ExpressCheckoutName()), |
| 1526 |
'default' => 'no', |
| 1527 |
), |
| 1528 |
|
| 1529 |
'expresscheckout_always_address' => array( |
| 1530 |
'title' => __('Always ask for address, even if products don\'t need shipping', 'woo-vipps'), |
| 1531 |
'label' => __('Always ask the user for their address, even if you don\'t need it for shipping', 'woo-vipps'), |
| 1532 |
'type' => 'checkbox', |
| 1533 |
'description' => __('If the order contains only "virtual" products that do not need shipping, we do not normally ask the user for their address - but check this box to do so anyway.', 'woo-vipps'), |
| 1534 |
'default' => $default_ask_address_for_express, |
| 1535 |
), |
| 1536 |
|
| 1537 |
'enablestaticshipping' => array( |
| 1538 |
'title' => __('Enable static shipping for Express Checkout', 'woo-vipps'), |
| 1539 |
'label' => __('Enable static shipping', 'woo-vipps'), |
| 1540 |
'type' => 'checkbox', |
| 1541 |
'description' => __('If your shipping options do not depend on the customers address, you can enable \'Static shipping\', which will precompute the shipping options when using Express Checkout so that this will be much faster. If you do this and the customer isn\'t logged in, the base location of the store will be used to compute the shipping options for the order. You should only use this if your shipping is actually \'static\', that is, does not vary based on the customers address. So fixed price/free shipping will work. If the customer is logged in, their address as registered in the store will be used, so if your customers are always logged in, you may be able to use this too.', 'woo-vipps'), |
| 1542 |
'default' => 'no', |
| 1543 |
), |
| 1544 |
|
| 1545 |
|
| 1546 |
'expresscreateuser' => array ( |
| 1547 |
'title' => __('Create new customers on Express Checkout', 'woo-vipps'), |
| 1548 |
'label' => __('Create new customers on Express Checkout', 'woo-vipps'), |
| 1549 |
'type' => 'checkbox', |
| 1550 |
'description' => sprintf(__('Enable this to create and login new customers when using express checkout. Otherwise these will all be guest checkouts. If you have "Login with Vipps" installed, this will be the default (unless you have turned off user creation in WooCommerce itself)', 'woo-vipps'), Vipps::CompanyName()), |
| 1551 |
'default' => $expresscreateuserdefault, |
| 1552 |
), |
| 1553 |
'singleproductbuynowcompatmode' => array( |
| 1554 |
'title' => __('"Buy now" compatibility mode', 'woo-vipps'), |
| 1555 |
'label' => __('Activate compatibility mode for all "Buy now" buttons', 'woo-vipps'), |
| 1556 |
'type' => 'checkbox', |
| 1557 |
'description' => __('Choosing this will use a different method of handling the "Buy now" button on a single product, which will work for more product types and more plugins - while being <i>slightly</i> less smooth. Use this if your product needs more configuration than simple or standard variable products', 'woo-vipps'), |
| 1558 |
'default' => 'no', |
| 1559 |
), |
| 1560 |
|
| 1561 |
|
| 1562 |
'deletefailedexpressorders' => array( |
| 1563 |
'title' => __('Delete failed Express Checkout Orders', 'woo-vipps'), |
| 1564 |
'label' => __('Delete failed Express Checkout Orders', 'woo-vipps'), |
| 1565 |
'type' => 'checkbox', |
| 1566 |
'description' => __('As Express Checkout orders are anonymous, failed orders will end up as "cancelled" orders with no information in them. Enable this to delete these automatically when cancelled - but test to make sure no other plugin needs them for anything.', 'woo-vipps'), |
| 1567 |
'default' => 'no', |
| 1568 |
) |
| 1569 |
); |
| 1570 |
// New shipping in express checkout is available, but merchant has overridden the old shipping callback. Ask what to do! IOK 2020-02-12 |
| 1571 |
if (has_action('woo_vipps_shipping_methods')) { |
| 1572 |
$shippingoptions = array( |
| 1573 |
'newshippingcallback' => array( |
| 1574 |
'title' => __('Use old-style shipping callback for express checkout', 'woo-vipps'), |
| 1575 |
'label' => __('Use your current shipping filters', 'woo-vipps'), |
| 1576 |
'type' => 'select', |
| 1577 |
'options' => array( |
| 1578 |
'none' => __('Select one','woo-vipps'), |
| 1579 |
'old' => __('Keep using old shipping callback with my custom filter', 'woo-vipps'), |
| 1580 |
'new' => __('Use new shipping callback','woo-vipps') |
| 1581 |
), |
| 1582 |
'description' => sprintf(__('Since version 1.4 this plugin uses a new method of providing shipping methods to %1$s when using Express Checkout. The new method supports metadata in the shipping options, which is neccessary for integration with Bring, Postnord etc. However, the new method is not compatible with the old <code>\'woo_vipps_shipping_methods\'</code> filter, which your site has overridden in a theme or plugin. If you want to, you can continue using this filter and the old method. If you want to disable your filters and use the new method, you can choose this here. ', 'woo-vipps'), Vipps::CompanyName()), |
| 1583 |
'default' => 'none', |
| 1584 |
) |
| 1585 |
); |
| 1586 |
$expressfields = array_merge(array_slice($expressfields ,0,1), $shippingoptions, array_slice($expressfields,1)); |
| 1587 |
} |
| 1588 |
|
| 1589 |
$advancedfields = array( |
| 1590 |
'advanced_options' => array( |
| 1591 |
'title' => __('Advanced', 'woo-vipps'), |
| 1592 |
'type' => 'title', |
| 1593 |
'class' => 'tab', |
| 1594 |
'description' => __("If you have issues with your theme, you might find a setting here that will help. Normally you do not need to change these.", 'woo-vipps') |
| 1595 |
), |
| 1596 |
|
| 1597 |
'vippsorderattribution' => array( |
| 1598 |
'title' => __( 'Support WooCommerces Order Attribution API for Checkout and Express Checkout', 'woo-vipps' ), |
| 1599 |
'label' => __( 'Add support for Order Attribution', 'woo-vipps' ), |
| 1600 |
'type' => 'checkbox', |
| 1601 |
'default'=> 'no', |
| 1602 |
'description' => __('Turn this on to add support for Woos Order Attribution API for Checkout and Express Checkout. Some stores have reported problems when using this API together with Vipps, so be sure to test this if you turn it on.', 'woo-vipps'), |
| 1603 |
), |
| 1604 |
|
| 1605 |
'vippsspecialpagetemplate' => array( |
| 1606 |
'title' => sprintf(__('Override page template used for the special %1$s pages', 'woo-vipps'), Vipps::CompanyName()), |
| 1607 |
'label' => sprintf(__('Use specific template for %1$s', 'woo-vipps'), Vipps::CompanyName()), |
| 1608 |
'type' => 'select', |
| 1609 |
'options' => $page_templates, |
| 1610 |
'description' => sprintf(__('Use this template from your theme or child-theme to display all the special %1$s pages. You will probably want a full-width template and it should call \'the_content()\' normally.', 'woo-vipps'), Vipps::CompanyName()), |
| 1611 |
'default' => ''), |
| 1612 |
|
| 1613 |
'vippsspecialpageid' => array( |
| 1614 |
'title' => sprintf(__('Use a real page ID for the special %1$s pages - neccessary for some themes', 'woo-vipps'), Vipps::CompanyName()), |
| 1615 |
'label' => __('Use a real page ID', 'woo-vipps'), |
| 1616 |
'type' => 'select', |
| 1617 |
'options' => $page_list, |
| 1618 |
'description' => sprintf(__('Some very few themes do not work with the simulated pages used by this plugin, and needs a real page ID for this. Choose a blank page for this; the content will be replaced, but the template and other metadata will be present. You only need to use this if the plugin seems to break on the special %1$s pages.', 'woo-vipps'), Vipps::CompanyName()), |
| 1619 |
'default'=>''), |
| 1620 |
|
| 1621 |
'sendreceipts' => array( |
| 1622 |
'title' => __("Send receipts and order confirmation info to the customers' app on completed purchases.", 'woo-vipps'), |
| 1623 |
'label' => sprintf(__("Send receipts to the customers %1\$s app", 'woo-vipps'), Vipps::CompanyName()), |
| 1624 |
'type' => 'checkbox', |
| 1625 |
'description' => sprintf(__("If this is checked, a receipt will be sent to %1\$s which will be viewable in the users' app, specifying the order items, shipping et cetera", 'woo-vipps'), Vipps::CompanyName()), |
| 1626 |
'default' => 'yes' |
| 1627 |
), |
| 1628 |
|
| 1629 |
'receiptimage' => array ( |
| 1630 |
'title' => sprintf(__('Use this image for the order confirmation link uploaded to the customers\' %1$s app', 'woo-vipps'), Vipps::CompanyName()), |
| 1631 |
'label' => sprintf(__('Profile image used in the %1$s App', 'woo-vipps'), Vipps::CompanyName()), |
| 1632 |
'type' => 'woo_vipps_image', |
| 1633 |
'description' => sprintf(__('If set, this image will be uploaded to %1$s and used to profile your store in the %1$s app for links to the order confirmation etc', 'woo-vipps'), Vipps::CompanyName()), |
| 1634 |
'default' => 0, |
| 1635 |
), |
| 1636 |
|
| 1637 |
|
| 1638 |
'use_flock' => array ( |
| 1639 |
'title' => __('Use flock() to lock orders for Express Checkout', 'woo-vipps'), |
| 1640 |
'label' => __('Use flock() to lock orders for Express Checkout', 'woo-vipps'), |
| 1641 |
'type' => 'checkbox', |
| 1642 |
'description' => __('Use the flock() system call to ensure orders are only finalized once. You can use this for normal setups, but probably not on Windows with IIS, and possibly not on distributed filesystems like NFS. If you don\t know what it is, probably do not use it. If you get duplicated shipping lines on some express orders, you may try using this', 'woo-vipps'), |
| 1643 |
'default' => 'no', |
| 1644 |
), |
| 1645 |
|
| 1646 |
'delete_settings_on_deactivation' => array ( |
| 1647 |
'title' => __('Delete plugin settings on deactivation', 'woo-vipps'), |
| 1648 |
'label' => __('Delete plugin settings on deactivation', 'woo-vipps'), |
| 1649 |
'type' => 'checkbox', |
| 1650 |
'description' => __('If set, all plugin settings will be deleted upon plugin deactivation. Warning: there is no recovery after deletion.', 'woo-vipps'), |
| 1651 |
'default' => 'no', |
| 1652 |
), |
| 1653 |
|
| 1654 |
'developermode' => array ( // DEVELOPERS! DEVELOPERS! DEVELOPERS! DEVE |
| 1655 |
'title' => __('Enable developer mode', 'woo-vipps'), |
| 1656 |
'label' => __('Enable developer mode', 'woo-vipps'), |
| 1657 |
'type' => 'checkbox', |
| 1658 |
'description' => __('Enable this to enter developer mode. This gives you access to the test-api and sometimes other tools not yet ready for general consumption', 'woo-vipps'), |
| 1659 |
'default' => VIPPS_TEST_MODE ? 'yes' : 'no', |
| 1660 |
) |
| 1661 |
|
| 1662 |
|
| 1663 |
); |
| 1664 |
|
| 1665 |
$developerfields = array( |
| 1666 |
'developertitle' => array( |
| 1667 |
'title' => __('Developer mode', 'woo-vipps'), |
| 1668 |
'type' => 'title', |
| 1669 |
'class' => 'tab', |
| 1670 |
'description' => __('These are settings for developers that contain extra features that are normally not useful for regular users, or are not yet ready for primetime', 'woo-vipps'), |
| 1671 |
), |
| 1672 |
|
| 1673 |
'testmode' => array( |
| 1674 |
'title' => __('Test mode', 'woo-vipps'), |
| 1675 |
'label' => __('Enable test mode', 'woo-vipps'), |
| 1676 |
'type' => 'checkbox', |
| 1677 |
'description' => sprintf(__('If you enable this, transactions will be made towards the %1$s Test API instead of the live one. No real transactions will be performed. You will need to fill out your test |
| 1678 |
accounts keys below, and you will need to install a special test-mode app from Testflight on a device (which cannot run the regular %1$s app). Contact %1$s\'s technical support if you need this. If you turn this mode off, normal operation will resume. If you have the VIPPS_TEST_MODE defined in your wp-config file, this will override this value. ', 'woo-vipps'), Vipps::CompanyName()), |
| 1679 |
'default' => VIPPS_TEST_MODE ? 'yes' : 'no', |
| 1680 |
), |
| 1681 |
'merchantSerialNumber_test' => array( |
| 1682 |
'title' => __('Merchant Serial Number', 'woo-vipps'), |
| 1683 |
'class' => 'vippspw', |
| 1684 |
'label' => __('Merchant Serial Number', 'woo-vipps'), |
| 1685 |
'type' => 'number', |
| 1686 |
'description' => __('Your test account "Merchant Serial Number" from the Developer tab on https://portal.vippsmobilepay.com','woo-vipps'), |
| 1687 |
'default' => '', |
| 1688 |
), |
| 1689 |
'clientId_test' => array( |
| 1690 |
'title' => __('Client Id', 'woo-vipps'), |
| 1691 |
'label' => __('Client Id', 'woo-vipps'), |
| 1692 |
'type' => 'password', |
| 1693 |
'class' => 'vippspw', |
| 1694 |
'description' => __('Find your test account under the "Developer" tab on https://portal.vippsmobilepay.com/ and choose "Show keys". Copy the value of "client_id"','woo-vipps'), |
| 1695 |
'default' => '', |
| 1696 |
), |
| 1697 |
'secret_test' => array( |
| 1698 |
'title' => __('Client Secret', 'woo-vipps'), |
| 1699 |
'label' => __('Client Secret', 'woo-vipps'), |
| 1700 |
'type' => 'password', |
| 1701 |
'class' => 'vippspw', |
| 1702 |
'description' => __('Find your test account under the "Developer" tab on https://portal.vippsmobilepay.com/ and choose "show keys". Copy the value of "client_secret"','woo-vipps'), |
| 1703 |
'default' => '', |
| 1704 |
), |
| 1705 |
'Ocp_Apim_Key_eCommerce_test' => array( |
| 1706 |
'title' => __('Subscription Key', 'woo-vipps'), |
| 1707 |
'label' => __('Subscription Key', 'woo-vipps'), |
| 1708 |
'type' => 'password', |
| 1709 |
'class' => 'vippspw', |
| 1710 |
'description' => __('Find your test account under the "Developer" tab on https://portal.vippsmobilepay.com/ and choose "show keys". Copy the value of "Vipps-Subscription-Key"','woo-vipps'), |
| 1711 |
'default' => '', |
| 1712 |
), |
| 1713 |
); |
| 1714 |
|
| 1715 |
// Add all the standard fields |
| 1716 |
foreach($mainfields as $key=>$field) { |
| 1717 |
$this->form_fields[$key] = $field; |
| 1718 |
} |
| 1719 |
foreach($expressfields as $key=>$field) { |
| 1720 |
$this->form_fields[$key] = $field; |
| 1721 |
} |
| 1722 |
foreach($checkoutfields as $key=>$field) { |
| 1723 |
$this->form_fields[$key] = $field; |
| 1724 |
} |
| 1725 |
|
| 1726 |
|
| 1727 |
foreach($external_payment_fields as $key=>$field) { |
| 1728 |
$this->form_fields[$key] = $field; |
| 1729 |
} |
| 1730 |
|
| 1731 |
foreach($vipps_checkout_widgets_fields as $key=>$field) { |
| 1732 |
$this->form_fields[$key] = $field; |
| 1733 |
} |
| 1734 |
|
| 1735 |
foreach($vipps_checkout_shipping_fields as $key=>$field) { |
| 1736 |
$this->form_fields[$key] = $field; |
| 1737 |
} |
| 1738 |
foreach($advancedfields as $key=>$field) { |
| 1739 |
$this->form_fields[$key] = $field; |
| 1740 |
} |
| 1741 |
|
| 1742 |
// The react UI decides whether or not to show the developer fields, however we always have to send this data to the client |
| 1743 |
// because otherwise the react UI will not be able to show the correct translations, since they would be missing. |
| 1744 |
foreach($developerfields as $key=>$field) { |
| 1745 |
$this->form_fields[$key] = $field; |
| 1746 |
} |
| 1747 |
// Developer mode settings: Only shown when active. IOK 2019-08-30 |
| 1748 |
if ($this->get_option('developermode') == 'yes' || VIPPS_TEST_MODE) { |
| 1749 |
if (VIPPS_TEST_MODE) { |
| 1750 |
$this->form_fields['developermode']['description'] .= '<br><b>' . __('VIPPS_TEST_MODE is set to true in your configuration - dev mode is forced', 'woo-vipps') . "</b>"; |
| 1751 |
$this->form_fields['testmode']['description'] .= '<br><b>' . __('VIPPS_TEST_MODE is set to true in your configuration - test mode is forced', 'woo-vipps') . "</b>"; |
| 1752 |
} |
| 1753 |
} |
| 1754 |
|
| 1755 |
|
| 1756 |
} |
| 1757 |
|
| 1758 |
|
| 1759 |
// IOK 2018-04-18 utilities for the 'admin notices' interface. |
| 1760 |
private function adminwarn($what) { |
| 1761 |
add_action('vipps_admin_notices',function() use ($what) { |
| 1762 |
echo "<div class='notice notice-warning is-dismissible'><p>$what</p></div>"; |
| 1763 |
}); |
| 1764 |
} |
| 1765 |
private function adminerr($what) { |
| 1766 |
add_action('vipps_admin_notices',function() use ($what) { |
| 1767 |
echo "<div class='notice notice-error is-dismissible'><p>$what</p></div>"; |
| 1768 |
}); |
| 1769 |
} |
| 1770 |
private function adminnotify($what) { |
| 1771 |
add_action('vipps_admin_notices',function() use ($what) { |
| 1772 |
echo "<div class='notice notice-info is-dismissible'><p>$what</p></div>"; |
| 1773 |
}); |
| 1774 |
} |
| 1775 |
|
| 1776 |
// Only be available if current currency is NOK IOK 2018-09-19 |
| 1777 |
// Only be available if current currency is supported NT 2023-12-04 |
| 1778 |
public function is_available() { |
| 1779 |
// This is split into two functions to avoid triggering infinite recursion in filters that override this value below. IOK 2021-10-30 |
| 1780 |
$ok = $this->standard_is_available(); |
| 1781 |
$ok = apply_filters('woo_vipps_is_available', $ok, $this); |
| 1782 |
return $ok; |
| 1783 |
} |
| 1784 |
|
| 1785 |
// True if the alternative Vipps Checkout screen is both available and activated. Returns the page id of the checkout |
| 1786 |
// page for convenience. IOK 2021-10-01 |
| 1787 |
public function vipps_checkout_available () { |
| 1788 |
|
| 1789 |
if ($this->get_option('vipps_checkout_enabled') != 'yes') return false; |
| 1790 |
if (!$this->standard_is_available()) return false; |
| 1791 |
|
| 1792 |
$checkoutid = wc_get_page_id('vipps_checkout'); |
| 1793 |
if (!$checkoutid) return false; |
| 1794 |
|
| 1795 |
// Page doesn't exist anymore |
| 1796 |
if (! get_post_status($checkoutid)) { |
| 1797 |
delete_option('woocommerce_vipps_checkout_page_id'); |
| 1798 |
return false; |
| 1799 |
} |
| 1800 |
|
| 1801 |
// Restrictions on cart are similar to express checkout, but not exactly the same. IOK 2024-01-11 |
| 1802 |
if (!$this->cart_supports_checkout()) return false; |
| 1803 |
|
| 1804 |
// Filter to false if you want to use the standard checkout for whatever reason |
| 1805 |
return apply_filters('woo_vipps_checkout_available', $checkoutid, $this); |
| 1806 |
} |
| 1807 |
|
| 1808 |
// Get supported currencies for payment method NT 2023-12-04 |
| 1809 |
public function get_supported_currencies($payment_method) { |
| 1810 |
switch ($payment_method) { |
| 1811 |
case 'Vipps': return array('NOK', 'SEK'); |
| 1812 |
case 'MobilePay': return array('DKK', 'EUR'); |
| 1813 |
default: return array(); |
| 1814 |
} |
| 1815 |
} |
| 1816 |
|
| 1817 |
// Check if payment method supports currency. NT 2023-12-04 |
| 1818 |
public function payment_method_supports_currency($payment_method, $currency) { |
| 1819 |
$ok = in_array($currency, $this->get_supported_currencies($payment_method)); |
| 1820 |
return $ok; |
| 1821 |
} |
| 1822 |
|
| 1823 |
// Basic unfiltered version of "can I use vipps" ? IOK 2021-10-01 |
| 1824 |
protected function standard_is_available () { |
| 1825 |
if (!$this->can_be_activated()) return false; |
| 1826 |
if (!parent::is_available()) return false; |
| 1827 |
if (!$this->payment_method_supports_currency($this->get_payment_method_name(), get_woocommerce_currency())) return false; |
| 1828 |
return true; |
| 1829 |
} |
| 1830 |
|
| 1831 |
// True if the express checkout feature should be available |
| 1832 |
public function express_checkout_available() { |
| 1833 |
if (! $this->is_available()) return false; |
| 1834 |
$ok = true; |
| 1835 |
$ok = apply_filters('woo_vipps_express_checkout_available', $ok, $this); |
| 1836 |
return $ok; |
| 1837 |
} |
| 1838 |
|
| 1839 |
// IOK 2018-04-20 Initiate payment at Vipps and redirect to the Vipps payment terminal. |
| 1840 |
public function process_payment ($order_id) { |
| 1841 |
global $woocommerce, $Vipps; |
| 1842 |
if (!$order_id) return []; |
| 1843 |
|
| 1844 |
do_action('woo_vipps_before_process_payment',$order_id); |
| 1845 |
|
| 1846 |
// Get current merchant serial |
| 1847 |
$msn = $this->get_merchant_serial(); |
| 1848 |
|
| 1849 |
// Do a quick check for correct setup first - this is the most critical point IOK 2018-05-11 |
| 1850 |
try { |
| 1851 |
$at = $this->api->get_access_token($msn); |
| 1852 |
} catch (Exception $e) { |
| 1853 |
$this->log(sprintf(__('Could not get access token when initiating %1$s payment for order id:','woo-vipps'), $this->get_payment_method_name()) . $order_id .":\n" . $e->getMessage(), 'error'); |
| 1854 |
wc_add_notice(sprintf(__('Unfortunately, the %1$s payment method is currently unavailable. Please choose another method.','woo-vipps'), $this->get_payment_method_name()),'error'); |
| 1855 |
return []; |
| 1856 |
} |
| 1857 |
|
| 1858 |
|
| 1859 |
// From the request, get either [billing_phone] => or [vipps phone] |
| 1860 |
$phone = ''; |
| 1861 |
if (isset($_POST['vippsphone'])) { |
| 1862 |
$phone = trim(sanitize_text_field($_POST['vippsphone'])); |
| 1863 |
} |
| 1864 |
if (!$phone && isset($_POST['billing_phone'])) { |
| 1865 |
$phone = trim(sanitize_text_field($_POST['billing_phone'])); |
| 1866 |
} |
| 1867 |
|
| 1868 |
// This is for express checkout if we know the customers' phone. |
| 1869 |
// thanks to sOndre @ github for reporting , https://github.com/vippsas/vipps-woocommerce/issues/22 |
| 1870 |
if (!$phone && WC()->customer) { |
| 1871 |
$phone = WC()->customer->get_billing_phone(); |
| 1872 |
} |
| 1873 |
|
| 1874 |
// No longer the case for V2 of the API |
| 1875 |
if (false && !$phone) { |
| 1876 |
wc_add_notice(sprintf(__('You need to enter your phone number to pay with %1$s','woo-vipps'), $this->get_payment_method_name()) ,'error'); |
| 1877 |
return []; |
| 1878 |
} |
| 1879 |
|
| 1880 |
$order = wc_get_order($order_id); |
| 1881 |
$content = null; |
| 1882 |
|
| 1883 |
// Should be impossible, but there we go IOK 2022-04-21 |
| 1884 |
if (! $order->has_status(['pending', 'failed'])) { |
| 1885 |
$this->log(sprintf(__("Trying to start order %1\$s with status %2\$s - only 'pending' and 'failed' are allowed, so this will fail", 'woo-vipps'), $order_id, $order->get_status())); |
| 1886 |
wc_add_notice(sprintf(__('This order cannot be paid with %1$s - please try another payment method or try again later', 'woo-vipps'), $this->get_payment_method_name()), 'error'); |
| 1887 |
return []; |
| 1888 |
} |
| 1889 |
|
| 1890 |
// If the Vipps order already has an init-timestamp, we should *not* call init_payment again, |
| 1891 |
// in the *normal* case, this is a user who have lost their vipps session, so it suffices to |
| 1892 |
// just return the stored vipps session URL (eg. the user used the Back button.) If abandoned, the |
| 1893 |
// order will eventually be cancelled. Changes in the cart will result in a new order anyway. |
| 1894 |
// Note: we now also support restarting the payment with a new retry session if there is no stored vipps session. LP 2026-03-12 |
| 1895 |
if ($order->get_meta('_vipps_init_timestamp')) { |
| 1896 |
$oldurl = $order->get_meta('_vipps_orderurl'); |
| 1897 |
|
| 1898 |
// Poll status at VMP here to verify session is still open. LP 2026-02-27 |
| 1899 |
$vipps_status = 'unknown'; |
| 1900 |
$vipps_session_open = false; |
| 1901 |
try { |
| 1902 |
$vipps_status = $this->get_payment_details($order)['status'] ?? 'unknown'; |
| 1903 |
if ('unknown' !== $vipps_status) { |
| 1904 |
$vipps_status = $this->interpret_vipps_order_status($vipps_status); |
| 1905 |
$vipps_session_open = 'initiated' === $vipps_status; |
| 1906 |
} |
| 1907 |
} catch (Exception $e) { |
| 1908 |
/* translators: company name, order id */ |
| 1909 |
$this->log(sprintf(__('Retry-branch: error getting payment details from %1$s for order id %2$s:','woo-vipps'), $this->get_payment_method_name(), $order->get_id()) . "\n" . $e->getMessage(), 'error'); |
| 1910 |
} |
| 1911 |
|
| 1912 |
// Do we have an active session we can redirect to? LP 2026-02-27 |
| 1913 |
if ($vipps_session_open && $oldurl) { |
| 1914 |
$order->add_order_note(sprintf(__('%1$s payment restarted','woo-vipps'), $this->get_payment_method_name())); |
| 1915 |
return array('result'=>'success','redirect'=>$oldurl); |
| 1916 |
} |
| 1917 |
|
| 1918 |
// If not, then we need to create a new retry session with incrementing index. LP 2026-03-12 |
| 1919 |
$retry_count = intval($order->get_meta('_vipps_retry_count')) + 1; |
| 1920 |
$enable_payment_retry = 'unknown' !== $vipps_status; // dont retry unknown statuses. LP 2026-03-18 |
| 1921 |
if (apply_filters('woo_vipps_enable_payment_retry', $enable_payment_retry, $order, $vipps_status, $retry_count)) { |
| 1922 |
/* translators: number of attempts, order id. */ |
| 1923 |
$this->log(sprintf(__('Order %2$d session could not be restored, creating a new retry session (retry #%1$d).', 'woo-vipps'), $retry_count, $order_id), 'info'); |
| 1924 |
$order->update_meta_data('_vipps_retry_count', $retry_count); |
| 1925 |
$order->save_meta_data(); |
| 1926 |
} else { |
| 1927 |
// If restarting is disabled, then we have to cancel the order. LP 2026-03-12 |
| 1928 |
/* translators: order id. */ |
| 1929 |
$this->log(sprintf(__('Order %1$d session could not be restored, and payment retry is disabled. Cancelling the order!', 'woo-vipps'), $order_id), 'info'); |
| 1930 |
$order->update_status('cancelled', sprintf(__('Cannot restart order at %1$s', 'woo-vipps'), Vipps::CompanyName())); |
| 1931 |
return []; |
| 1932 |
} |
| 1933 |
} |
| 1934 |
|
| 1935 |
// This is needed to ensure that the callbacks from Vipps have access to the customers' session which is important for some plugins. IOK 2019-11-22 |
| 1936 |
$this->save_session_in_order($order); |
| 1937 |
|
| 1938 |
// Vipps-terminal-page return url to poll/await return |
| 1939 |
$returnurl= $Vipps->payment_return_url(); |
| 1940 |
// If we are using express checkout, use this to handle the address stuff |
| 1941 |
// IOK 2018-11-19 also when *not* using express checkout. This allows us to pass the order-id in the return URL and use this as a password in case the sesson has been lost. |
| 1942 |
$authtoken = $this->generate_authtoken(); |
| 1943 |
|
| 1944 |
// IOK 2019-11-19 We have to do this because even though we actually store the order ID in the session, we can a) be redirected to another browser than the one with |
| 1945 |
// the session, and b) some plugins wipe the session for guest purchases. |
| 1946 |
// So we might need to restore (enough of the) session to get to the than you page, even if the session is gone |
| 1947 |
// or in another castle. |
| 1948 |
// IOK 2023-01-23 store the limited session in the order instead and separeted it from the authtoken |
| 1949 |
$limited_session = $this->generate_authtoken(); |
| 1950 |
$returnurl = add_query_arg('ls',$limited_session,$returnurl); |
| 1951 |
$returnurl = add_query_arg('id', $order_id, $returnurl); |
| 1952 |
|
| 1953 |
|
| 1954 |
try { |
| 1955 |
// If the order was 'failed', it isnt any more! yet! |
| 1956 |
if ($order->get_status() == 'failed') { |
| 1957 |
$order->set_status('pending', __('Setting order status to pending to start payment', 'woo-vipps')); |
| 1958 |
} |
| 1959 |
// The requestid is actually for replaying the request, but I get 402 if I retry with the same Orderid. |
| 1960 |
// Still, if we want to handle transient error conditions, then that needs to be extended here (timeouts, etc) |
| 1961 |
// Update: replaced requestid with new idempotency key, moved this into epayment_initiate_payment. LP 2026-03-13 |
| 1962 |
$content = $this->api->epayment_initiate_payment($phone,$order,$returnurl,$authtoken); |
| 1963 |
} catch (TemporaryVippsApiException $e) { |
| 1964 |
$this->log(sprintf(__('Could not initiate %1$s payment','woo-vipps'), $this->get_payment_method_name()) . ' ' . $e->getMessage(), 'error'); |
| 1965 |
wc_add_notice(sprintf(__('Unfortunately, the %1$s payment method is temporarily unavailable. Please wait or choose another method.','woo-vipps'), $this->get_payment_method_name()),'error'); |
| 1966 |
return []; |
| 1967 |
} catch (Exception $e) { |
| 1968 |
|
| 1969 |
// Special case the "duplicate order id" thing to ensure it doesn't happen again, and if it does, at least |
| 1970 |
// log some more info IOK 2022-11-02 |
| 1971 |
if (preg_match("/Duplicate Order Id/i", $e->getMessage())) { |
| 1972 |
do_action('woo_vipps_duplicate_order_id', $order); |
| 1973 |
$this->log(sprintf(__("Duplicate Order ID! Please report this to support@wp-hosting.no together with as much info about the order as possible. Express: %1\$s Status: %2\$s User agent: %3\$s", 'woo-vipps'), $order->get_meta('_vipps_express_checkout'), $order->get_status(), $order->get_customer_user_agent()), 'error'); |
| 1974 |
$order->update_status('cancelled', __('Cannot restart order with same order ID: Must cancel', 'woo-vipps')); |
| 1975 |
} |
| 1976 |
|
| 1977 |
$this->log(sprintf(__('Could not initiate %1$s payment','woo-vipps'), $this->get_payment_method_name()) . ' ' . $e->getMessage(), 'error'); |
| 1978 |
wc_add_notice(sprintf(__('Unfortunately, the %1$s payment method is currently unavailable. Please choose another method.','woo-vipps'), $this->get_payment_method_name()),'error'); |
| 1979 |
return []; |
| 1980 |
} |
| 1981 |
|
| 1982 |
$url = $content['url']; |
| 1983 |
$vippstamp = time(); |
| 1984 |
|
| 1985 |
// Ensure we only check the status by ajax of our own orders. IOK 2018-05-03 |
| 1986 |
$sessionorders= WC()->session->get('_vipps_session_orders'); |
| 1987 |
$sessionorders[$order_id] = 1; |
| 1988 |
WC()->session->set('_vipps_session_orders',$sessionorders); |
| 1989 |
WC()->session->set('_vipps_pending_order',$order_id); // Send information to the 'please confirm' screen IOK 2018-04-24 |
| 1990 |
|
| 1991 |
$order = wc_get_order($order_id); |
| 1992 |
if ($authtoken) { |
| 1993 |
$order->update_meta_data('_vipps_authtoken',wp_hash_password($authtoken)); |
| 1994 |
} |
| 1995 |
if ($limited_session) { |
| 1996 |
$order->update_meta_data('_vipps_limited_session',wp_hash_password($limited_session)); |
| 1997 |
} |
| 1998 |
// Store the "session URL" for restarts of the order in the same session context. IOK 2022-11-02 |
| 1999 |
$order->update_meta_data('_vipps_init_timestamp',$vippstamp); |
| 2000 |
$order->update_meta_data('_vipps_orderurl', $url); |
| 2001 |
|
| 2002 |
$order->update_meta_data('_vipps_status','INITIATE'); // INITIATE right now |
| 2003 |
$order->add_order_note(sprintf(__('%1$s payment initiated','woo-vipps'), $this->get_payment_method_name())); |
| 2004 |
$order->add_order_note(sprintf(__('Awaiting %1$s payment confirmation','woo-vipps'), $this->get_payment_method_name())); |
| 2005 |
$order->save(); |
| 2006 |
|
| 2007 |
// Create a signal file that we can check without calling wordpress to see if our result is in IOK 2018-05-04 |
| 2008 |
try { |
| 2009 |
$Vipps->createCallbackSignal($order); |
| 2010 |
} catch (Exception $e) { |
| 2011 |
// Could not create a signal file, but that's ok. |
| 2012 |
} |
| 2013 |
|
| 2014 |
do_action('woo_vipps_before_redirect_to_vipps',$order_id); |
| 2015 |
|
| 2016 |
// This will send us to a receipt page where we will do the actual work. IOK 2018-04-20 |
| 2017 |
return array('result'=>'success','redirect'=>$url); |
| 2018 |
} |
| 2019 |
|
| 2020 |
|
| 2021 |
// This tries to capture a Vipps payment, and resets the status to 'on-hold' if it fails. IOK 2018-05-07 |
| 2022 |
public function maybe_capture_payment($orderid) { |
| 2023 |
$order = wc_get_order($orderid); |
| 2024 |
if (! Vipps::is_vipps_order($order)) return false; |
| 2025 |
$ok = 0; |
| 2026 |
|
| 2027 |
# Shortcut orders that have been directly captured |
| 2028 |
$vippsstatus = $order->get_meta('_vipps_status'); |
| 2029 |
if ($vippsstatus == 'SALE') { |
| 2030 |
return true; |
| 2031 |
} |
| 2032 |
|
| 2033 |
$remaining = intval($order->get_meta('_vipps_capture_remaining')); |
| 2034 |
|
| 2035 |
// Somehow the order status in payment_complete has been set to the 'after order status' or 'complete' by a filter. If so, do not capture. |
| 2036 |
// Capture will be done *before* payment_complete if appropriate IOK 2020-09-22 |
| 2037 |
if (did_action('woocommerce_pre_payment_complete')) { |
| 2038 |
if (!$order->needs_processing()) return; // This is fine, we've captured. |
| 2039 |
if ($remaining>0) { |
| 2040 |
// Not everything has been captured, but we have reached a capturable status. Complain, do not capture. IOK 2020-09-22 |
| 2041 |
$this->log(sprintf(__("Filters are setting the payment_complete order status to '%1\$s' - will not capture", 'woo-vipps'), $order->get_status()),'debug'); |
| 2042 |
$order->add_order_note(sprintf(__('Payment complete set status to "%1$s" - will not capture payments automatically','woo-vipps'), $order->get_status())); |
| 2043 |
return false; |
| 2044 |
} |
| 2045 |
} |
| 2046 |
|
| 2047 |
// IOK 2019-10-03 it is now possible to do capture via other tools than Woo, so we must now first check to see if |
| 2048 |
// the order is capturable by getting full payment details. |
| 2049 |
try { |
| 2050 |
$order = $this->update_vipps_payment_details($order); |
| 2051 |
} catch (Exception $e) { |
| 2052 |
//Do nothing with this for now |
| 2053 |
$this->log(__("Error getting payment details before doing capture: ", 'woo-vipps') . $e->getMessage(), 'warning'); |
| 2054 |
} |
| 2055 |
|
| 2056 |
try { |
| 2057 |
$ok = $this->capture_payment($order); |
| 2058 |
} catch (Exception $e) { |
| 2059 |
// This is handled in sub-methods so we shouldn't actually hit this IOK 2018-05-07 |
| 2060 |
} |
| 2061 |
if ($ok) { |
| 2062 |
// Signal other hooked actions that this one actually did something. IOK 2025-02-04 |
| 2063 |
$order->update_meta_data('_vipps_capture_complete',true); |
| 2064 |
$order->save(); |
| 2065 |
} else { |
| 2066 |
$order->update_meta_data('_vipps_capture_complete',false); |
| 2067 |
$msg = sprintf(__("Could not capture %1\$s payment for this order!", 'woo-vipps'), $this->get_payment_method_name()); |
| 2068 |
$order->add_order_note($msg); |
| 2069 |
$order->save(); |
| 2070 |
if (apply_filters('woo_vipps_on_hold_on_failed_capture', true, $order)) { |
| 2071 |
$msg = sprintf(__("Could not capture %1\$s payment - status set to", 'woo-vipps'), $this->get_payment_method_name()) . ' ' . __('on-hold','woocommerce'); |
| 2072 |
$order->set_status('on-hold',$msg); |
| 2073 |
$order->save(); |
| 2074 |
global $Vipps; |
| 2075 |
$this->adminerr($msg); |
| 2076 |
$Vipps->store_admin_notices(); |
| 2077 |
return false; |
| 2078 |
} |
| 2079 |
} |
| 2080 |
} |
| 2081 |
|
| 2082 |
|
| 2083 |
// Capture (possibly partially) the order. Only full capture really supported by plugin at this point. IOK 2018-05-07 |
| 2084 |
// Except that we *do* note that money "refunded" through vipps before capture should be "uncapturable". IOK 2024-11-25 |
| 2085 |
public function capture_payment($order) { |
| 2086 |
$pm = $order->get_payment_method(); |
| 2087 |
if (! Vipps::is_vipps_order($pm)) { |
| 2088 |
$this->log(sprintf(__('Trying to capture payment on order not made by %1$s:','woo-vipps'), $this->get_payment_method_name()). ' ' . $order->get_id(), 'error'); |
| 2089 |
$this->adminerr(sprintf(__('Cannot capture payment on orders not made by %1$s','woo-vipps'), $this->get_payment_method_name())); |
| 2090 |
return false; |
| 2091 |
} |
| 2092 |
|
| 2093 |
// Partial capture can happen if the order is edited IOK 2017-12-19 |
| 2094 |
$captured = intval($order->get_meta('_vipps_captured')); |
| 2095 |
$vippsstatus = $order->get_meta('_vipps_status'); |
| 2096 |
$noncapturable = intval($order->get_meta('_vipps_noncapturable')); // This money has been marked as not-to-be-captured. It will be cancelled on complete. |
| 2097 |
|
| 2098 |
// Ensure 'SALE' direct captured orders work |
| 2099 |
if (!$captured && $vippsstatus == 'SALE') { |
| 2100 |
$order = $this->update_vipps_payment_details($order); |
| 2101 |
$captured = intval($order->get_meta('_vipps_captured')); |
| 2102 |
} |
| 2103 |
|
| 2104 |
$total = round(wc_format_decimal($order->get_total(),'')*100); |
| 2105 |
$amount = $total-$captured-$noncapturable; // IOK subtract any amount not to be captured here |
| 2106 |
|
| 2107 |
if ($amount<=0) { |
| 2108 |
$order->add_order_note(__('Payment already captured','woo-vipps')); |
| 2109 |
return true; |
| 2110 |
} |
| 2111 |
|
| 2112 |
// If we already have captured everything, then we are ok! IOK 2017-05-07 |
| 2113 |
if ($captured) { |
| 2114 |
$remaining = intval($order->get_meta('_vipps_capture_remaining')); |
| 2115 |
if (!$remaining) { |
| 2116 |
$order->add_order_note(__('Payment already captured','woo-vipps')); |
| 2117 |
return true; |
| 2118 |
} |
| 2119 |
} |
| 2120 |
|
| 2121 |
// Each time we succeed, we'll increase the 'capture' transaction id so we don't just capture the same amount again and again. IOK 2018-05-07 |
| 2122 |
// (but on failre, we don't increase it - and also, we don't really support partial capture yet.) IOK 2018-05-07 |
| 2123 |
$requestidnr = intval($order->get_meta('_vipps_capture_transid')); |
| 2124 |
// IOK 2023-03-13 keep track of failed captures; because some stores automate capturing without paying attention to the result. |
| 2125 |
// some reservations are for only 7 days (or 30 days or 180 days) so some orders will be uncapturable. This will be reset by the |
| 2126 |
// 'Show full transaction details' metabox. |
| 2127 |
$failures = intval($order->get_meta('_vipps_capture_failures')); |
| 2128 |
$failurelimit = 10; |
| 2129 |
try { |
| 2130 |
|
| 2131 |
// Assume we cannot capture if we have gotten errors 10 times from the API |
| 2132 |
if ($failures >= $failurelimit) { |
| 2133 |
throw new Exception(sprintf(__("More than %1\$d API exceptions trying to capture order - this order cannot be captured.", 'woo-vipps'), $failures)); |
| 2134 |
} |
| 2135 |
|
| 2136 |
$requestid = $requestidnr . ":" . $order->get_order_key(); |
| 2137 |
$api = $order->get_meta('_vipps_api'); |
| 2138 |
|
| 2139 |
|
| 2140 |
if ($api == 'banktransfer') { |
| 2141 |
// This is an error - we should not ever get to the 'capture' branch if we are a banktransfer payment. |
| 2142 |
// IOK 2024-01-09 |
| 2143 |
$content = []; |
| 2144 |
} else { |
| 2145 |
// Now the only other api is 'epayment' IOK 2026-08-18 |
| 2146 |
$content = $this->api->epayment_capture_payment($order,$amount,$requestid); |
| 2147 |
} |
| 2148 |
} catch (TemporaryVippsApiException $e) { |
| 2149 |
$this->log(sprintf(__('Could not capture %1$s payment for order id:', 'woo-vipps'), $this->get_payment_method_name()) . ' ' . $order->get_id() . "\n" .$e->getMessage(),'error'); |
| 2150 |
$this->adminerr(sprintf(__('%1$s is temporarily unavailable.','woo-vipps'), $this->get_payment_method_name()) . "\n" . $e->getMessage()); |
| 2151 |
return false; |
| 2152 |
} catch (Exception $e) { |
| 2153 |
// Keep track of API failures up to a point. IOK 2024-03-13 |
| 2154 |
if ($failures < $failurelimit) { |
| 2155 |
$order->update_meta_data('_vipps_capture_failures', $failures + 1); |
| 2156 |
$order->save(); |
| 2157 |
} |
| 2158 |
|
| 2159 |
$msg = sprintf(__('Could not capture %1$s payment for order_id:','woo-vipps'), $this->get_payment_method_name()) . ' ' . $order->get_id() . "\n" . $e->getMessage(); |
| 2160 |
$this->log($msg,'error'); |
| 2161 |
$this->adminerr($msg); |
| 2162 |
return false; |
| 2163 |
} |
| 2164 |
|
| 2165 |
$currency = $order->get_currency(); |
| 2166 |
|
| 2167 |
// Previously, we got this from the transactionInfo field of the Vipps data - this is no longer provided. IOK 2025-08-12 |
| 2168 |
// We simply have to keep track: There is no way of knowing what the correct values are here yet, as we only get these values async, after |
| 2169 |
// the fact. |
| 2170 |
$captured = $amount + intval($order->get_meta('_vipps_captured')); |
| 2171 |
$remaining = intval($order->get_meta('_vipps_amount')) - $captured - intval($order->get_meta('_vipps_cancelled')); |
| 2172 |
$refundable = $captured - intval($order->get_meta('_vipps_refunded')); |
| 2173 |
|
| 2174 |
$order->update_meta_data('_vipps_captured', $captured); |
| 2175 |
$order->update_meta_data('_vipps_capture_remaining', $remaining); |
| 2176 |
$order->update_meta_data('_vipps_refund_remaining', $refundable); |
| 2177 |
$order->update_meta_data('_vipps_capture_timestamp', time()); |
| 2178 |
$order->add_order_note(sprintf(__('%1$s Payment captured:','woo-vipps'), $this->get_payment_method_name()) . ' ' . sprintf("%0.2f",$captured/100) . ' ' . $currency); |
| 2179 |
|
| 2180 |
|
| 2181 |
// Since we succeeded, the next time we'll start a new transaction. |
| 2182 |
$order->update_meta_data('_vipps_capture_transid', $requestidnr+1); |
| 2183 |
$order->save(); |
| 2184 |
|
| 2185 |
return true; |
| 2186 |
} |
| 2187 |
|
| 2188 |
|
| 2189 |
// Cancel (only completely) a reserved but not yet captured order IOK 2018-05-07 |
| 2190 |
public function cancel_payment($order) { |
| 2191 |
$pm = $order->get_payment_method(); |
| 2192 |
if (! Vipps::is_vipps_order($pm)) { |
| 2193 |
$this->log(sprintf(__('Trying to cancel payment on order not made by %1$s:','woo-vipps'), $this->get_payment_method_name()). ' ' .$order->get_id(), 'error'); |
| 2194 |
$this->adminerr(sprintf(__('Cannot cancel payment on orders not made by %1$s','woo-vipps'), $this->get_payment_method_name())); |
| 2195 |
return false; |
| 2196 |
} |
| 2197 |
// We'll use the same transaction id for all cancel jobs, as we can only do it completely. IOK 2018-05-07 |
| 2198 |
// For epayment, partial cancellations will be possible. IOK 2022-11-12 |
| 2199 |
// IOK 2026-08-18 actually, epayment does *not* support partial cancellation - all remaining funds are cancelled. |
| 2200 |
$api = $order->get_meta('_vipps_api'); |
| 2201 |
try { |
| 2202 |
$requestid = ""; |
| 2203 |
if ($api == 'banktransfer') { |
| 2204 |
// If we are here, and the order is somehow not captured, just do nothing. IOK 2024-01-09 |
| 2205 |
$content = []; |
| 2206 |
} else { |
| 2207 |
// api is here 'epayment'. IOK 2026-07-18 |
| 2208 |
$requestid = 1; |
| 2209 |
// This will cancel any remaining, not-captured amount IOK 2026-01-28 |
| 2210 |
$content = $this->api->epayment_cancel_payment($order,$requestid); |
| 2211 |
} |
| 2212 |
} catch (TemporaryVippsApiException $e) { |
| 2213 |
$this->log(sprintf(__('Could not cancel %1$s payment for order_id:', 'woo-vipps'), $this->get_payment_method_name()) . ' ' . $order->get_id() . "\n" .$e->getMessage(),'error'); |
| 2214 |
$this->adminerr(sprintf(__('%1$s is temporarily unavailable.','woo-vipps'), $this->get_payment_method_name()) . ' ' . $e->getMessage()); |
| 2215 |
return false; |
| 2216 |
} catch (Exception $e) { |
| 2217 |
$msg = sprintf(__('Could not cancel %1$s payment for order id:','woo-vipps'), $this->get_payment_method_name()) . $order->get_id() . "\n" . $e->getMessage(); |
| 2218 |
$this->log($msg,'error'); |
| 2219 |
$this->adminerr($msg); |
| 2220 |
return false; |
| 2221 |
} |
| 2222 |
|
| 2223 |
// the epay v2 API would return transactionInfo and Summary with the result, the new epayment api returns nothing. |
| 2224 |
// Removed epay branch 2025-08-12 IOK |
| 2225 |
$total = intval($order->get_meta('_vipps_amount')); |
| 2226 |
$captured = intval($order->get_meta('_vipps_captured')); |
| 2227 |
$cancelled = $total; |
| 2228 |
$remaining = $total - $captured - $cancelled; |
| 2229 |
|
| 2230 |
// We need to assume it worked. Also, we can't do partial cancels yet, so just cancel everything. |
| 2231 |
$order->update_meta_data('_vipps_cancel_timestamp',time()); |
| 2232 |
$order->update_meta_data('_vipps_cancelled', $cancelled); |
| 2233 |
$order->update_meta_data('_vipps_cancel_remaining', $remaining); |
| 2234 |
|
| 2235 |
|
| 2236 |
// Set status from Vipps, ignore errors, use statusdata if we have it. |
| 2237 |
try { |
| 2238 |
$status = $this->get_vipps_order_status($order); |
| 2239 |
if ($status) $order->update_meta_data('_vipps_status',$status); |
| 2240 |
$order->add_order_note(sprintf(__('%1$s Payment cancelled:','woo-vipps'), $this->get_payment_method_name())); |
| 2241 |
$order->save(); |
| 2242 |
} catch (Exception $e) { |
| 2243 |
} |
| 2244 |
return true; |
| 2245 |
} |
| 2246 |
|
| 2247 |
// Refund (possibly partially) the captured order. IOK 2018-05-07 |
| 2248 |
// The caller must handle the errors. |
| 2249 |
public function refund_payment($order,$amount=0,$cents=false) { |
| 2250 |
$pm = $order->get_payment_method(); |
| 2251 |
if (! Vipps::is_vipps_order($pm)) { |
| 2252 |
$msg = sprintf(__('Trying to refund payment on order not made by %1$s:','woo-vipps'), $this->get_payment_method_name()) . ' ' . $order->get_id(); |
| 2253 |
$this->log($msg,'error'); |
| 2254 |
throw new VippsAPIException($msg); |
| 2255 |
} |
| 2256 |
|
| 2257 |
|
| 2258 |
// If we haven't captured anything, we can't refund IOK 2017-05-07 |
| 2259 |
$captured = intval($order->get_meta('_vipps_captured')); |
| 2260 |
if (!$captured) { |
| 2261 |
$msg = sprintf(__('Trying to refund payment on %1$s payment not captured:','woo-vipps'), $this->get_payment_method_name()). ' ' .$order->get_id(); |
| 2262 |
$this->log($msg,'error'); |
| 2263 |
throw new VippsAPIException($msg); |
| 2264 |
} |
| 2265 |
|
| 2266 |
// Each time we succeed, we'll increase the 'refund' transaction id so we don't just refund the same amount again and again. IOK 2018-05-07 |
| 2267 |
// (but on failre, we don't increase it.) IOK 2018-05-07 |
| 2268 |
$requestidnr = intval($order->get_meta('_vipps_refund_transid')); |
| 2269 |
$requestid = $requestidnr . ":" . $order->get_order_key(); |
| 2270 |
|
| 2271 |
$api = $order->get_meta('_vipps_api'); |
| 2272 |
if ($api == 'banktransfer') { |
| 2273 |
$msg = sprintf(__("Cannot refund bank transfer order %1\$d", 'woo-vipps'), $order->get_id()); |
| 2274 |
$this->log($msg, 'error'); |
| 2275 |
throw new Exception($msg); |
| 2276 |
} else { |
| 2277 |
// api is now 'epayment' IOK 2026-08-18 |
| 2278 |
$content = $this->api->epayment_refund_payment($order,$requestid,$amount,$cents); |
| 2279 |
} |
| 2280 |
|
| 2281 |
$currency = $order->get_currency(); |
| 2282 |
|
| 2283 |
// Previously, we got updated transaction info in a transactionInfo field. this is no longer provided, |
| 2284 |
// so we have to do dead reckoning. IOK 2025-08-12 |
| 2285 |
// We simply have to keep track: There is no way of knowing what the correct values are here yet, as we only get these values async, after |
| 2286 |
// the fact. |
| 2287 |
$captured = intval($order->get_meta('_vipps_captured')); |
| 2288 |
|
| 2289 |
if (!$amount) { |
| 2290 |
$amount = wc_format_decimal($order->get_total(),''); |
| 2291 |
$cents = false; |
| 2292 |
} |
| 2293 |
if ($amount && !$cents) { |
| 2294 |
$amount = round($amount * 100); |
| 2295 |
} |
| 2296 |
|
| 2297 |
$refunded_now = $amount; |
| 2298 |
$refunded = intval($order->get_meta('_vipps_refunded')) + $amount; |
| 2299 |
$remaining = $captured - $refunded; |
| 2300 |
|
| 2301 |
$order->update_meta_data('_vipps_refunded', $refunded); |
| 2302 |
$order->update_meta_data('_vipps_refund_remaining', $remaining); |
| 2303 |
$order->update_meta_data('_vipps_refund_timestamp', time()); |
| 2304 |
$order->add_order_note(sprintf(__('%1$s Payment Refunded:','woo-vipps'), $this->get_payment_method_name()) . ' ' . sprintf("%0.2f",$refunded/100) . ' ' . $currency ); |
| 2305 |
|
| 2306 |
// Since we succeeded, the next time we'll start a new transaction. |
| 2307 |
$order->update_meta_data('_vipps_refund_transid', $requestidnr+1); |
| 2308 |
$order->save(); |
| 2309 |
return true; |
| 2310 |
} |
| 2311 |
|
| 2312 |
// Generate a one-time password for certain callbacks, with some backwards compatibility for PHP 5.6 |
| 2313 |
public function generate_authtoken($length=32) { |
| 2314 |
$token=""; |
| 2315 |
if (function_exists('random_bytes')) { |
| 2316 |
$token = bin2hex(random_bytes($length)); |
| 2317 |
} elseif (function_exists('openssl_random_pseudo_bytes')) { |
| 2318 |
$token = bin2hex(openssl_random_pseudo_bytes($length)); |
| 2319 |
} elseif (function_exists('mcrypt_create_iv')) { |
| 2320 |
// These aren't "secure" but they are probably ok for this purpose. IOK 2018-05-18 |
| 2321 |
$indirect = 'mcrypt_create_iv'; // grep-based 7.2 compatibility checkers need to be worked around IOK 2018-10-24 |
| 2322 |
$token = bin2hex($indirect($length)); |
| 2323 |
} else { |
| 2324 |
// Final fallback |
| 2325 |
$token = bin2hex(md5(microtime() . ":" . mt_rand())); |
| 2326 |
} |
| 2327 |
|
| 2328 |
return $token; |
| 2329 |
} |
| 2330 |
|
| 2331 |
// Collapse several statuses to a known list IOK 2019-01-23 |
| 2332 |
// Statuses still in use are annotated. IOK 2025-08-12 |
| 2333 |
public function interpret_vipps_order_status($status) { |
| 2334 |
switch ($status) { |
| 2335 |
case 'INITIATE': // legacy, used by us to indicate a fresh order |
| 2336 |
case 'REGISTER': |
| 2337 |
case 'REGISTERED': |
| 2338 |
case 'CREATED': // Checkout, Epayment |
| 2339 |
return 'initiated'; |
| 2340 |
break; |
| 2341 |
case 'RESERVE': |
| 2342 |
case 'RESERVED': |
| 2343 |
case 'AUTHORISED': |
| 2344 |
case 'AUTHORIZED': // Checkout, Epayment |
| 2345 |
case 'CAPTURED': // Epayment |
| 2346 |
case 'REFUNDED': // epayment - this is probably authorized, because it will have had that state *before* it was refuned. IOK 2025-08-12 |
| 2347 |
return 'authorized'; |
| 2348 |
break; |
| 2349 |
case 'SALE': |
| 2350 |
return 'complete'; |
| 2351 |
break; |
| 2352 |
case 'CANCEL': |
| 2353 |
case 'CANCELLED': // Epayment |
| 2354 |
case 'VOID': |
| 2355 |
case 'AUTOREVERSAL': |
| 2356 |
case 'AUTOCANCEL': |
| 2357 |
case 'AUTO_CANCEL': |
| 2358 |
case 'RESERVE_FAILED': |
| 2359 |
case 'FAILED': |
| 2360 |
case 'REJECTED': |
| 2361 |
case 'TERMINATED': // Checkout, Epayment |
| 2362 |
case 'ABORTED': // Epayment |
| 2363 |
case 'EXPIRED': // Epayment |
| 2364 |
return 'cancelled'; |
| 2365 |
break; |
| 2366 |
} |
| 2367 |
// Default should never happen, but just to ensure we are in our enumeration |
| 2368 |
return "initiated"; |
| 2369 |
} |
| 2370 |
|
| 2371 |
// This does not normally call Vipps, so if you need to refresh status, please use callback_check_order_status first. IOK 2019-01-23 |
| 2372 |
public function check_payment_status($order) { |
| 2373 |
if (!$order) return 'cancelled'; |
| 2374 |
$status = $this->interpret_vipps_order_status($order->get_meta('_vipps_status')); |
| 2375 |
// This can happen if the vipps status is set from the back end for instance. IOK 2020-08-14 |
| 2376 |
if ($order->get_status() == 'pending' && $status != 'initiated') { |
| 2377 |
$this->callback_check_order_status($order); |
| 2378 |
$order = wc_get_order($order->get_id()); // refresh to get the new status IOK 2021-01-20 |
| 2379 |
$status = $this->interpret_vipps_order_status($order->get_meta('_vipps_status')); |
| 2380 |
} |
| 2381 |
return $status; |
| 2382 |
} |
| 2383 |
|
| 2384 |
// Called by callback_check_order_status and handle_callback to handle the situation where |
| 2385 |
// the payment method has been set to something else *after* Vipps has gotten the order. |
| 2386 |
// This happens very rarely for people who use Vipps as an external payment method in Klarna, so |
| 2387 |
// we only do it for orders that match this. IOK 2023-02-03 |
| 2388 |
public function reset_erroneous_payment_method($order) { |
| 2389 |
// This is only called by methods that are Vipps-specific, but still lets be careful not to touch other orders |
| 2390 |
|
| 2391 |
// New 2026-01-05: we now check all other payment methods that aren't vipps, and reset it back to vipps. |
| 2392 |
// The issue was using Klarna Payments and pressing 'back' in the browser, then completing the payment in vipps checkout |
| 2393 |
// the order still had the payment method klarna_payments, since we previously only checked 'kco' = klarna/kustom checkout. LP 2026-01-05 |
| 2394 |
if (! Vipps::is_vipps_order($order) && $order->get_meta("_vipps_orderid")) { |
| 2395 |
$order->set_payment_method('vipps'); |
| 2396 |
$express = $order->get_meta('_vipps_express_checkout'); |
| 2397 |
$checkout = $order->get_meta('_vipps_checkout'); |
| 2398 |
$order->set_payment_method_title('Vipps'); |
| 2399 |
if ($express) $order->set_payment_method_title('Vipps Express Checkout'); |
| 2400 |
if ($checkout) $order->set_payment_method_title('Vipps Checkout'); |
| 2401 |
// paypal gw resets payment gateway on order save because it has this meta, so delete it before save. LP 2026-06-23 |
| 2402 |
$order->delete_meta_data('_ppcp_paypal_order_id'); |
| 2403 |
$order->save(); |
| 2404 |
|
| 2405 |
$msg = sprintf(__("Payment method reset to %1\$s - it had been set to another payment method while completing the order for %2\$d", 'woo-vipps'), $this->get_payment_method_name(), $order->get_id()); |
| 2406 |
$this->log($msg, 'debug'); |
| 2407 |
$order->add_order_note($msg); |
| 2408 |
} |
| 2409 |
} |
| 2410 |
|
| 2411 |
// Check status of order at Vipps, in case the callback has been delayed or failed. |
| 2412 |
// Should only be called if in status 'pending'; it will modify the order when status changes. |
| 2413 |
public function callback_check_order_status($order, $allow_retry = true) { |
| 2414 |
global $Vipps; |
| 2415 |
$orderid = $order->get_id(); |
| 2416 |
|
| 2417 |
clean_post_cache($order->get_id()); |
| 2418 |
$order = wc_get_order($orderid); // Ensure a fresh copy is read. |
| 2419 |
|
| 2420 |
$oldstatus = $order->get_status(); |
| 2421 |
$newstatus = $oldstatus; |
| 2422 |
|
| 2423 |
// Only do work when the orders woo status is pending |
| 2424 |
if ($oldstatus != 'pending') return $oldstatus; |
| 2425 |
|
| 2426 |
$oldvippsstatus = $this->interpret_vipps_order_status($order->get_meta('_vipps_status')); |
| 2427 |
$vippsstatus = ""; |
| 2428 |
|
| 2429 |
/* Now read the payment details and update the order with the relevant values, finding the new Vipps status IOK 2021-01-20 */ |
| 2430 |
$paymentdetails = array(); |
| 2431 |
try { |
| 2432 |
$paymentdetails = $this->get_payment_details($order); |
| 2433 |
$newvippsstatus = $paymentdetails['status']; |
| 2434 |
$vippsstatus = $this->interpret_vipps_order_status($newvippsstatus); |
| 2435 |
|
| 2436 |
$ready = false; // True if money is authorized or complete |
| 2437 |
if (in_array($vippsstatus, ['authorized', 'complete'])) { |
| 2438 |
$ready = true; |
| 2439 |
} |
| 2440 |
|
| 2441 |
// No change == nothing to do. Ensure we don't modify the order at this point. IOK 2025-10-24 |
| 2442 |
if ($vippsstatus == $oldvippsstatus) { |
| 2443 |
return $oldstatus; |
| 2444 |
} |
| 2445 |
// Something changed, so we are now going to sideeffect the order. IOK 2025-10-15 |
| 2446 |
$this->log(sprintf(__("%1\$s poll: Handling order: ", 'woo-vipps'), Vipps::CompanyName()) . " " . $orderid, 'debug'); |
| 2447 |
|
| 2448 |
// If we are in the process of getting a callback from vipps, don't update anything. Currently, Woo/WP has no locking mechanism, |
| 2449 |
// and it isn't feasible to implement one portably. So this reduces somewhat the likelihood of races when this method is called |
| 2450 |
// and callbacks happen at the same time. |
| 2451 |
if (!$Vipps->lockOrder($order)) { |
| 2452 |
return $oldstatus; |
| 2453 |
} |
| 2454 |
|
| 2455 |
// Failsafe for rare bug when using Klarna Checkout with Vipps as an external payment method |
| 2456 |
// IOK 2024-01-09 ensure this is called only when order is complete/authorized |
| 2457 |
if ($ready) { |
| 2458 |
$this->reset_erroneous_payment_method($order); |
| 2459 |
} |
| 2460 |
|
| 2461 |
$order->update_meta_data('_vipps_status',$newvippsstatus); |
| 2462 |
|
| 2463 |
// Extract order metadata from either Checkout or Epayment - set below IOK 2025-08-13 |
| 2464 |
if (!empty($paymentdetails)) { |
| 2465 |
// checkout has a string, epayment has an array with upper case "type" and apparently, cardBin IOK 2025-08-12 |
| 2466 |
$paymentMethod = $paymentdetails['paymentMethod'] ?? "epayment"; |
| 2467 |
// After normalization, all APIs will have data here. |
| 2468 |
$details = $paymentdetails['paymentDetails']; |
| 2469 |
if (isset($details['paymentMethod'])) { |
| 2470 |
$paymentMethod = $details['paymentMethod']; |
| 2471 |
} |
| 2472 |
if (!is_string($paymentMethod)) { |
| 2473 |
// should be WALLET |
| 2474 |
$paymentMethod = $paymentMethod['type'] ?? "epayment"; |
| 2475 |
} |
| 2476 |
$transaction = array(); |
| 2477 |
$transaction['timeStamp'] = date('Y-m-d H:i:s', time()); |
| 2478 |
$transaction['amount'] = $details['amount']['value']; |
| 2479 |
$transaction['currency'] = $details['amount']['currency']; |
| 2480 |
$transaction['status'] = $details['state']; |
| 2481 |
$transaction['paymentmethod'] = $paymentMethod; |
| 2482 |
$this->order_set_transaction_metadata($order, $transaction); |
| 2483 |
} |
| 2484 |
|
| 2485 |
} catch (Exception $e) { |
| 2486 |
$this->log(sprintf(__("Error getting payment details from %1\$s for order_id:",'woo-vipps'), $this->get_payment_method_name()) . $orderid . "\n" . $e->getMessage(), 'error'); |
| 2487 |
clean_post_cache($order->get_id()); |
| 2488 |
$Vipps->unlockOrder($order); |
| 2489 |
return $oldstatus; |
| 2490 |
} |
| 2491 |
$order->save(); |
| 2492 |
|
| 2493 |
// We have a completed order, but the callback haven't given us the payment details yet - so handle it. |
| 2494 |
if (($vippsstatus == 'authorized' || $vippsstatus=='complete') && $order->get_meta('_vipps_express_checkout')) { |
| 2495 |
|
| 2496 |
do_action('woo_vipps_express_checkout_get_order_status', $paymentdetails); |
| 2497 |
$address_set = $order->get_meta('_vipps_shipping_set'); |
| 2498 |
|
| 2499 |
if ($address_set) { |
| 2500 |
// Callback has handled the situation, do nothing |
| 2501 |
} elseif ($paymentdetails['shippingDetails'] ?? "") { |
| 2502 |
// We need to set shipping details here |
| 2503 |
$billing = isset($paymentdetails['billingDetails']) ? $paymentdetails['billingDetails'] : false; |
| 2504 |
$this->set_order_shipping_details($order,$paymentdetails['shippingDetails'], $paymentdetails['userDetails'], $billing, $paymentdetails); |
| 2505 |
} else { |
| 2506 |
// IN THIS CASE we actually need to cancel the order as we have no way of determining whose order this is. |
| 2507 |
// But first check to see if it has customer info! |
| 2508 |
// Cancel any orders where the Checkout session is dead and there is no address info available |
| 2509 |
if (!$order->has_shipping_address() && !$order->has_billing_address()) { |
| 2510 |
$this->log(sprintf(__("No shipping details from %1\$s for express checkout for order id:",'woo-vipps'), $this->get_payment_method_name()) . ' ' . $orderid, 'error'); |
| 2511 |
$sessiontimeout = time() - (60*90); |
| 2512 |
$then = intval($order->get_meta('_vipps_init_timestamp')); |
| 2513 |
if ($then < $sessiontimeout) { |
| 2514 |
$this->log(sprintf(__("Order %2\$d has no address info and any %1\$s session is dead - have to cancel.", 'woo-vipps'), Vipps::CheckoutName(), $order->get_id())); |
| 2515 |
$order->update_status('cancelled', sprintf(__('Could not get address info for order from %1$s', 'woo-vipps'), Vipps::CompanyName())); |
| 2516 |
$order->save(); |
| 2517 |
} else { |
| 2518 |
// NOOP - the vipps checkout session can still be active, so we need to let it be |
| 2519 |
$this->log(sprintf(__("No address information for order %2\$d, but there still might be an active %1\$s session for it, so do not cancel it.", 'woo-vipps'), Vipps::CheckoutName(), $order->get_id())); |
| 2520 |
} |
| 2521 |
} |
| 2522 |
clean_post_cache($order->get_id()); |
| 2523 |
$Vipps->unlockOrder($order); |
| 2524 |
return $oldstatus; |
| 2525 |
} |
| 2526 |
} |
| 2527 |
|
| 2528 |
# Since the order is pending, and the vipps status has changed, switch to the correct vipps status in woo too IOK 2025-10-24 |
| 2529 |
switch ($vippsstatus) { |
| 2530 |
case 'authorized': |
| 2531 |
$this->payment_complete($order); |
| 2532 |
break; |
| 2533 |
case 'complete': |
| 2534 |
$msg = sprintf(__('Payment captured directly at %1$s', 'woo-vipps'), $this->get_payment_method_name()); |
| 2535 |
$msg = $msg . __(" - order does not need processing", 'woo-vipps'); |
| 2536 |
$order->add_order_note($msg); |
| 2537 |
$order = $this->update_vipps_payment_details($order, $paymentdetails); |
| 2538 |
$order->payment_complete(); |
| 2539 |
break; |
| 2540 |
case 'cancelled': |
| 2541 |
$order_is_retryable = $allow_retry && Vipps::order_is_vipps_retryable($order->get_id()); |
| 2542 |
$status_on_fail = $this->get_option('status_on_fail'); |
| 2543 |
$cancel_on_fail = apply_filters('woo_vipps_cancel_failed_orders', false, $order, $vippsstatus); |
| 2544 |
if ($cancel_on_fail || !$order_is_retryable) { |
| 2545 |
$status_on_fail = 'cancelled'; |
| 2546 |
} |
| 2547 |
if (!in_array($status_on_fail, ['cancelled', 'failed'])) { |
| 2548 |
/* translators: order status name. Cancelled is woocommerce status name */ |
| 2549 |
$this->log(__('Unsupported status for payment failure of \'%1$s\', falling back to cancelled.', 'woo-vipps'), 'warning'); |
| 2550 |
$status_on_fail = 'cancelled'; |
| 2551 |
} |
| 2552 |
|
| 2553 |
/* translators: company name */ |
| 2554 |
$order->update_status($status_on_fail, sprintf(__('Order failed or rejected at %1$s.', 'woo-vipps'), Vipps::CompanyName())); |
| 2555 |
break; |
| 2556 |
} |
| 2557 |
|
| 2558 |
$order->save(); |
| 2559 |
clean_post_cache($order->get_id()); |
| 2560 |
$newstatus = $order->get_status(); |
| 2561 |
$Vipps->unlockOrder($order); |
| 2562 |
return $newstatus; |
| 2563 |
} |
| 2564 |
|
| 2565 |
// IOK 2020-01-20 Previously was just a debugging tool, then was used to update postmeta values. Now is used as the main source of info |
| 2566 |
// about the order from Vipps; the previous side-effecting is now done by update_vipps_payment_details. |
| 2567 |
// IOK 2021-11-24 Because of this, we need to handle 402 and 404 errors differently here now - these *are* results, meaning there is |
| 2568 |
// no payment details because the order doesn't exist. |
| 2569 |
// IOK 2022-01-19 And now, with the epayment API in use by checkout, we also need to use the poll api because the epayment API does not return user- and shipping data. We do get an order status though. |
| 2570 |
// IOK 2025-08-12 And now, with epayment used for Express Checkout also, there *is* user- and shipping-data when using Express Checkout, so we can simplify. We still need to transform the data |
| 2571 |
// so old hooks and filters can get the input they expect. |
| 2572 |
public function get_payment_details($order) { |
| 2573 |
$result = array(); |
| 2574 |
$checkout_session = $order->get_meta('_vipps_checkout_session'); |
| 2575 |
$express = $order->get_meta('_vipps_express_checkout'); |
| 2576 |
|
| 2577 |
// IOK 2025-08-12: Three cases; either this is Checkout, in which case we need to get user/shipping-data from the checkout session, |
| 2578 |
// or it is Express Checkout or normal payment, in which cases we just retrieve the payment from the epayment API - possibly containing user data |
| 2579 |
if ($checkout_session) { |
| 2580 |
try { |
| 2581 |
$result = $this->api->checkout_get_session_info($order); |
| 2582 |
|
| 2583 |
if ($result == 'EXPIRED') { |
| 2584 |
$result = array('status'=>'CANCEL', 'state'=>'CANCEL'); |
| 2585 |
return $result; |
| 2586 |
} |
| 2587 |
|
| 2588 |
// For checkout, we are really handling *session states* which we map to *order states*, but sometimes |
| 2589 |
// these indicate a failed order. |
| 2590 |
// 'state' can be missing for Checkout, first case is if this is because the session is invalid. |
| 2591 |
// The sesssion states are # "SessionCreated" "PaymentInitiated" "SessionExpired" "PaymentSuccessful" "PaymentTerminated" |
| 2592 |
if (isset($result['sessionState']) && ($result['sessionState'] == 'SessionTerminated' || $result['sessionState'] == 'SessionExpired')) { |
| 2593 |
$result['state'] = 'CANCEL'; |
| 2594 |
$result['status'] = 'CANCEL'; |
| 2595 |
$order->add_order_note(sprintf(__('%1$s Order with no order status, so session was never completed; setting status to cancelled', 'woo-vipps'), Vipps::CheckoutName())); |
| 2596 |
return $result; |
| 2597 |
} |
| 2598 |
|
| 2599 |
// IOK 2023-12-14 at some point, apparently SessionStarted became SessionCreated |
| 2600 |
if (isset($result['sessionState']) && ($result['sessionState'] == 'SessionStarted' || $result['sessionState'] == 'SessionCreated')) { |
| 2601 |
// We have no order info, only the session data (this is a checkout order). Therefore, assume it has been started at least. |
| 2602 |
$result['status'] = "INITIATE"; |
| 2603 |
$result['state'] = "INITIATE"; |
| 2604 |
$created = $order->get_date_created(); |
| 2605 |
$timestamp = 0; |
| 2606 |
$now = time(); |
| 2607 |
try { |
| 2608 |
$timestamp = $created->getTimestamp(); |
| 2609 |
} catch (Exception $e) { |
| 2610 |
// PHP 8 gives ValueError for certain older versions of WooCommerce here. |
| 2611 |
$timestamp = intval($created->format('U')); |
| 2612 |
} |
| 2613 |
$passed = $now - $timestamp; |
| 2614 |
$minutes = ($passed / 60); |
| 2615 |
|
| 2616 |
// Give up after 120 minutes. Actually, 60 minutes is probably enough: We expire live sessions after 50 mins. |
| 2617 |
if ($minutes > 120) { |
| 2618 |
$this->log(sprintf(__('Checkout order older than 120 minutes with no order status - cancelled as abandoned: %1$s', 'woo-vipps'), $order->get_id()), 'debug'); |
| 2619 |
$order->add_order_note(sprintf(__('%1$s Order with no order status, so session was never completed; setting status to cancelled', 'woo-vipps'), Vipps::CheckoutName())); |
| 2620 |
$result['status'] = 'CANCEL'; |
| 2621 |
$result['state'] = 'CANCEL'; |
| 2622 |
} |
| 2623 |
return $result; |
| 2624 |
} |
| 2625 |
|
| 2626 |
|
| 2627 |
} catch (VippsAPIException $e) { |
| 2628 |
$resp = intval($e->responsecode); |
| 2629 |
if ($resp == 402 || $resp == 404) { |
| 2630 |
$result = array('status'=>'CANCEL', 'state'=>'CANCEL'); |
| 2631 |
return $result; |
| 2632 |
} else { |
| 2633 |
throw $e; |
| 2634 |
} |
| 2635 |
} |
| 2636 |
} else { |
| 2637 |
try { |
| 2638 |
$result = $this->api->epayment_get_payment($order); |
| 2639 |
} catch (VippsAPIException $e) { |
| 2640 |
$resp = intval($e->responsecode); |
| 2641 |
if ($resp == 402 || $resp == 404) { |
| 2642 |
$result = array('status'=>'CANCEL', 'state'=>'CANCEL'); |
| 2643 |
return $result; |
| 2644 |
} else { |
| 2645 |
$this->log(sprintf(__("Could not get order status from %1\$s using epayment api: ", 'woo-vipps'), Vipps::CompanyName()) . $e->getMessage(), "error"); |
| 2646 |
throw $e; |
| 2647 |
} |
| 2648 |
} |
| 2649 |
} |
| 2650 |
|
| 2651 |
if (!$result || $result == "ERROR") { |
| 2652 |
$this->log(sprintf(__("Could not get payment results for order %1\$s", 'woo-vipps'), $order->get_id())); |
| 2653 |
wp_die(sprintf(__("Could not get payment results for order %1\$s - you may have the wrong MSN for the order. Please check logs for more information", 'woo-vipps'), $order->get_id())); |
| 2654 |
} |
| 2655 |
|
| 2656 |
// We now have a result which maybe will contain user and shipping data, which we will need to normalize because it is slightly different in the different |
| 2657 |
// APIs, and we have provided filters/hooks that receive this information. IOK 2025-08-12 |
| 2658 |
// If we now have epayment data, we want to translate this to the ecom 'view' for now. Later, we will do the opposite. |
| 2659 |
// We now only need to map Checkout and epayment to the same format, but we will try to keep the normalized result compatible with |
| 2660 |
// ecom, in case consumers have created filters/hooks. IOK 2025-08-12 |
| 2661 |
|
| 2662 |
// if Checkout, the result will have a sessionState, reference etc, userInfo, shippingDetails, billingDetails and the payment details in a paymentDetails member. |
| 2663 |
// if not, the result will *be* a paymentDetails field, but with user*Details* and shippingDetails added. No billingDetails. |
| 2664 |
// The end result should have state/status (not neccessarily present with Checkout), userDetails, paymentDetails, shippingDetails and billingDetails, and a transactionSummary. |
| 2665 |
// Because that's what the code depending on this has been expecting. IOK 2025-08-12 |
| 2666 |
if (!$checkout_session) { |
| 2667 |
// This should be an ecom result, so move all data (for simplicitys sake) into paymentDetails |
| 2668 |
$result['paymentDetails'] = $result; |
| 2669 |
} |
| 2670 |
// Ensure we get payment details with state + aggregate, which we do not if the payment method is bank transfer for checkout. IOK 2024-01-09 |
| 2671 |
// Also add keys and transform for backwards compatibility. |
| 2672 |
$result = $this->normalizePaymentDetails($result); |
| 2673 |
$newstatus = $this->interpret_vipps_order_status($result['status']); |
| 2674 |
$ready = false; |
| 2675 |
if (in_array($newstatus, ['authorized', 'complete'])) { |
| 2676 |
$ready = true; |
| 2677 |
} |
| 2678 |
|
| 2679 |
if ($ready && ($express || $checkout_session)) { |
| 2680 |
// For Vipps Checkout version 3 there are no more userDetails, so we will add it, including defaults for anonymous purchases IOK 2023-01-10 |
| 2681 |
// This will also normalize userDetails, adding 'sub' where possible and fields for backwards compatibility. 2025-08-12 |
| 2682 |
$result = $this->ensure_userDetails($result, $order); |
| 2683 |
|
| 2684 |
// After, we need to normalize shipping details or even add them if e.g. using Checkout without address or contact info IOK 2025-08-13 |
| 2685 |
// Epayment Express Checkout is of course also significantly different from both the old Express and from Checkout in the formatting here. IOK 2025-08-12 |
| 2686 |
$result = $this->normalizeShippingDetails($result, $order); |
| 2687 |
} |
| 2688 |
|
| 2689 |
return $result; |
| 2690 |
} |
| 2691 |
|
| 2692 |
// IOK 2025-08-12 Normalize the shippingDetails field for backwards compatibility, since this is different from old express, new express and checkout. |
| 2693 |
function normalizeShippingDetails($result, $order) { |
| 2694 |
|
| 2695 |
// We may actually get no shipping details eg. for Checkout when not asking for addresses etc. |
| 2696 |
if (!isset($result['shippingDetails'])) { |
| 2697 |
$result['shippingDetails'] = ['address' => [] ]; |
| 2698 |
} |
| 2699 |
$details = $result['shippingDetails']; |
| 2700 |
|
| 2701 |
$user = $result['userDetails']; // Normalized earlier |
| 2702 |
$address = $details['address'] ?? []; |
| 2703 |
|
| 2704 |
// No address, but we have a list of addresses in the userDetails field. This is ecom with the address scope added. |
| 2705 |
// We will use the first one. |
| 2706 |
if (empty($address) && isset($result['userDetails']) && isset($result['userDetails']['addresses']) && !empty($result['userDetails']['addresses'])) { |
| 2707 |
$address = $result['userDetails']['addresses'][0]; |
| 2708 |
} |
| 2709 |
|
| 2710 |
// Checkout has address info inside shippingDetails, whereas Express Checkout now has it in an address field IOK 2025-08-12 |
| 2711 |
if (empty($address)) { |
| 2712 |
$address['firstName'] = $details['firstName'] ?? ""; |
| 2713 |
$address['lastName'] = $details['lastName'] ?? ""; |
| 2714 |
$address['email'] = $details['email'] ?? ""; |
| 2715 |
$address['mobileNumber'] = $details['phoneNumber'] ?? ""; |
| 2716 |
$address['addressLine1'] = $details['streetAddress'] ?? ""; |
| 2717 |
$address['addressLine2'] = ""; |
| 2718 |
$address['city'] = $details['city'] ?? ""; |
| 2719 |
$address['postCode'] = $details['postalCode'] ?? ""; |
| 2720 |
$address['country'] = $details['country'] ?? ""; |
| 2721 |
} |
| 2722 |
|
| 2723 |
// Need at least a country for VAT so add our own. |
| 2724 |
if (!$address['country']) { |
| 2725 |
$countries=new WC_Countries(); |
| 2726 |
$address['country'] = $countries->get_base_country(); |
| 2727 |
} |
| 2728 |
|
| 2729 |
// Normalize from user details when neccessary (mostly for new express) |
| 2730 |
$address['firstName'] = ($address['firstName'] ?? "") ?: $user['firstName']; |
| 2731 |
$address['lastName'] = ($address['lastName'] ?? "") ?: $user['lastName']; |
| 2732 |
$address['email'] = ($address['email'] ?? "") ?: $user['email']; |
| 2733 |
$address['mobileNumber'] = ($address['mobileNumber'] ?? "") ?: $user['mobileNumber']; |
| 2734 |
|
| 2735 |
// phoneNumber is checkout, mobileNumber is epayment |
| 2736 |
$address['phoneNumber'] = $address['mobileNumber']; |
| 2737 |
// addressline1 and 2 are epayment, streetAddress is checkout |
| 2738 |
$address['streetAddress'] = $address['addressLine1']; |
| 2739 |
// postCode is epayment, postalCode is checkout |
| 2740 |
$address['postalCode'] = $address['postCode']; |
| 2741 |
|
| 2742 |
|
| 2743 |
// Ensure we have 'address' as in Express/epayment |
| 2744 |
$details['address'] = $address; |
| 2745 |
|
| 2746 |
// Name change from Checkout/Express to new Express from MethodId to OptionId IOK 2025-08-12 |
| 2747 |
$details['shippingMethodId'] = $details['shippingMethodId'] ?? ($details['shippingOptionId'] ?? ""); |
| 2748 |
$details['shippingOptionId'] = $details['shippingMethodId']; |
| 2749 |
|
| 2750 |
$result['shippingDetails'] = $details; |
| 2751 |
return $result; |
| 2752 |
} |
| 2753 |
|
| 2754 |
|
| 2755 |
// IOK 2024-01-09 If using Vipps Checkout with the BankTransfer method, which is eg. used in Finland, |
| 2756 |
// we are (currently) not receiving any 'state' or 'aggregate', so add this iff the payment is successful. |
| 2757 |
// The reason for this is that this payment type does not actually use the epayment API at all (!) |
| 2758 |
// Also moved some other compatibility code here - |
| 2759 |
// --- reference used to be orderId |
| 2760 |
// --- state used to be status |
| 2761 |
// --- there used to be a transactionSummary field |
| 2762 |
// --- at one point there was a 'transactionAggregate' instead of an 'aggregate' |
| 2763 |
private function normalizePaymentDetails($result) { |
| 2764 |
// the 'reference' used to be an 'orderId', keep for compatibility. |
| 2765 |
$result['orderId'] = $result['reference']; |
| 2766 |
if (isset($result['sessionState']) && $result['sessionState'] == 'PaymentSuccessful' && $result['paymentMethod'] == 'BankTransfer') { |
| 2767 |
$details = $result['paymentDetails']; |
| 2768 |
$details['state'] = 'SALE'; // Payment is actually complete at this point |
| 2769 |
$aggregate=[]; |
| 2770 |
$aggregate['capturedAmount'] = $details['amount']; |
| 2771 |
$aggregate['authorizedAmount'] = $details['amount']; |
| 2772 |
$aggregate['refundedAmount'] = ['value'=>0, 'currency'=>$details['amount']['currency']]; |
| 2773 |
$aggregate['cancelledAmount'] = ['value'=>0, 'currency'=>$details['amount']['currency']]; |
| 2774 |
$details['aggregate'] = $aggregate; |
| 2775 |
$result['paymentDetails'] = $details; |
| 2776 |
} |
| 2777 |
|
| 2778 |
// Sometimes we get the state at top level, sometimes in paymentDetails. |
| 2779 |
$state = $result['state'] ?? false; |
| 2780 |
|
| 2781 |
// Now, if we don't have payment details, we should have a dead session or something like it. If we do, we can cretae |
| 2782 |
// a normalized result. IOK 2023-12-13 |
| 2783 |
if (isset($result['paymentDetails'])) { |
| 2784 |
$details = $result['paymentDetails']; |
| 2785 |
$state = $state ?: $details['state']; |
| 2786 |
$result['state'] = $state; |
| 2787 |
$details['state'] = $state; |
| 2788 |
|
| 2789 |
# IOK 2022-01-19 for this, the docs and experience does not agree, so check both |
| 2790 |
$aggregate = (isset($details['transactionAggregate'])) ? $details['transactionAggregate'] : $details['aggregate']; |
| 2791 |
|
| 2792 |
// if 'AUTHORISED' and directCapture is set and true, set to SALE which will set the order to complete |
| 2793 |
// IOK 2025-08-12: This is never true anymore - directCapture is never set and the SALE state does not seem to exist. |
| 2794 |
// this was an extra feature for merchants with special products however, so keep the logic just in case. |
| 2795 |
if (($result['state'] == 'AUTHORISED' || $result['state'] == "AUTHORIZED") && isset($result['directCapture']) && $result['directCapture']) { |
| 2796 |
$result['state'] = "SALE"; |
| 2797 |
} |
| 2798 |
|
| 2799 |
# the transactionSummary used to contain the information now present in 'aggregate', so map it back for compatibility. |
| 2800 |
$transactionSummary = array(); |
| 2801 |
// Always NOK at this point, but we also don't care because the order has the currency |
| 2802 |
// IOK 2024-03-22 Now supports other currencies, but we still don't care. |
| 2803 |
$transactionSummary['capturedAmount'] = isset($aggregate['capturedAmount']) ? $aggregate['capturedAmount']['value'] : 0; |
| 2804 |
$transactionSummary['refundedAmount'] = isset($aggregate['refundedAmount']) ? $aggregate['refundedAmount']['value'] : 0; |
| 2805 |
$transactionSummary['cancelledAmount'] =isset($aggregate['cancelledAmount']) ? $aggregate['cancelledAmount']['value'] : 0; |
| 2806 |
$transactionSummary['authorizedAmount'] =isset($aggregate['authorizedAmount']) ? $aggregate['authorizedAmount']['value'] : 0; |
| 2807 |
$transactionSummary['remainingAmountToCapture'] = $transactionSummary['authorizedAmount'] - $transactionSummary['cancelledAmount'] - $transactionSummary['capturedAmount']; |
| 2808 |
$transactionSummary['remainingAmountToRefund'] = $transactionSummary['capturedAmount'] - $transactionSummary['refundedAmount']; |
| 2809 |
// now also reducing remainingAmmountToCancel with cancelledAmount PMB 2024-11-21 |
| 2810 |
$transactionSummary['remainingAmountToCancel'] = $transactionSummary['authorizedAmount'] - $transactionSummary['capturedAmount'] - $transactionSummary['cancelledAmount']; |
| 2811 |
|
| 2812 |
$result['transactionSummary'] = $transactionSummary; |
| 2813 |
} |
| 2814 |
// After this, the result will contain a 'state' which used to be a 'status' - map back for compatibility. |
| 2815 |
// The reason for the method is that in ecom v2 we needed to calculate this from the transaction history. IOK 2025-08-12 |
| 2816 |
$result['status'] = $this->get_payment_status_from_payment_details($result); |
| 2817 |
|
| 2818 |
// No longer used; was used in later versions of ecom to deduce order status. Added for typewise compatibility. |
| 2819 |
$result['transactionLogHistory'] = array(); |
| 2820 |
// The corresponding epayment log. Filled on-demand by debugging code. |
| 2821 |
$result['epaymentLog'] = null; |
| 2822 |
|
| 2823 |
return $result; |
| 2824 |
} |
| 2825 |
|
| 2826 |
// Vipps Checkout v3 does *not* provide userDetails. Vipps Checkout v2 and epayment *does*. But Checkout additionally allows |
| 2827 |
// for anonymous purchases, in which case there is *no* user details. In this case we provide an anonymous user so we can actually create an order. |
| 2828 |
// To handle this, we provide this utility that ensures we have userDetails no matter the input. For this we use the anonymous filters and "billingDetails" if present |
| 2829 |
// if not, we use shippingDetails. IOK 2023-01-10 |
| 2830 |
// Also, epayment uses mobileNumber and checkout uses phoneNumber, so normalize. |
| 2831 |
public function ensure_userDetails($vippsdata, $order) { |
| 2832 |
$userDetails = []; |
| 2833 |
|
| 2834 |
// If we have userDetails, use it (ecom API with user data requested - Express Checkout |
| 2835 |
if (isset($vippsdata['userDetails'])) { |
| 2836 |
$userDetails = $vippsdata['userDetails']; |
| 2837 |
// This is the verified user information from the app - this is always the customer for Express Checkout, but not for Checkout IOK 2025-08-12 |
| 2838 |
// Also, it may not always be available - it depends on consent and whether scope was added (probably) in epayment_initate_payment. IOK 2026-08-18 |
| 2839 |
$sub = ""; |
| 2840 |
if (isset($vippsdata['profile']) && isset($vippsdata['profile']['sub'])) { |
| 2841 |
$sub = $vippsdata['profile']['sub']; |
| 2842 |
} |
| 2843 |
$userDetails['sub'] = $sub; |
| 2844 |
|
| 2845 |
} else if (isset($vippsdata['billingDetails'])) { |
| 2846 |
// Otherwise this is now Checkout, and we want to get it from billingDetails preferrably |
| 2847 |
$addr = $vippsdata['billingDetails']; |
| 2848 |
$phone = $addr['phoneNumber']; |
| 2849 |
$userDetails = array( |
| 2850 |
'firstName' => $addr['firstName'], |
| 2851 |
'lastName' => $addr['lastName'], |
| 2852 |
'email' => $addr['email'], |
| 2853 |
'phoneNumber' => $phone, |
| 2854 |
// This is the verified user information from the app - this is always the customer for Express Checkout, but not for Checkout IOK 2025-08-12 |
| 2855 |
'sub' => "" |
| 2856 |
); |
| 2857 |
|
| 2858 |
// Or use shippingDetails - this is still Checkout |
| 2859 |
} else if (isset($vippsdata['shippingDetails'])) { |
| 2860 |
$addr = $vippsdata['shippingDetails']; |
| 2861 |
$phone = $addr['phoneNumber']; |
| 2862 |
$userDetails = array( |
| 2863 |
'firstName' => $addr['firstName'], |
| 2864 |
'lastName' => $addr['lastName'], |
| 2865 |
'email' => $addr['email'], |
| 2866 |
'phoneNumber' => $phone, |
| 2867 |
// This is the verified user information from the app - this is always the customer for Express Checkout, but not for Checkout IOK 2025-08-12 |
| 2868 |
'sub' => "" |
| 2869 |
); |
| 2870 |
|
| 2871 |
// And it is possible to not require user details in Checkout at all (or if not using express) |
| 2872 |
} else { |
| 2873 |
$userDetails = array( |
| 2874 |
|
| 2875 |
'firstName' => apply_filters('woo_vipps_anon_customer_first_name', __('Anonymous customer', 'woo-vipps'), $order), |
| 2876 |
'lastName' => apply_filters('woo_vipps_anon_customer_last_name', "", $order), |
| 2877 |
'email' => apply_filters('woo_vipps_anon_customer_email', '', $order), |
| 2878 |
'phoneNumber' => apply_filters('woo_vipps_anon_customer_phone_number', '', $order), |
| 2879 |
'sub' => "" |
| 2880 |
); |
| 2881 |
} |
| 2882 |
|
| 2883 |
//Normalize the result |
| 2884 |
$phone = $userDetails['phoneNumber'] ?? ($userDetails['mobileNumber'] ?? ""); |
| 2885 |
$userDetails['phoneNumber'] = $phone; |
| 2886 |
$userDetails['mobileNumber'] = $phone; |
| 2887 |
|
| 2888 |
|
| 2889 |
// No longer used, but try to provide it for backwards compatibility |
| 2890 |
$userDetails['userId'] = $userDetails['phoneNumber']; |
| 2891 |
// This is possible to get iff we have the 'sub', unfortunately it is not passed directly in several of the apis. IOK 2025-08-12 |
| 2892 |
$userDetails['email_verified'] = ($userDetails['email_verified'] ?? false); |
| 2893 |
|
| 2894 |
$vippsdata['userDetails'] = $userDetails; |
| 2895 |
|
| 2896 |
return $vippsdata; |
| 2897 |
} |
| 2898 |
|
| 2899 |
// Update the order with Vipps payment details, either passed or called using the API. |
| 2900 |
public function update_vipps_payment_details ($order, $details = null) { |
| 2901 |
if (!$details) { |
| 2902 |
try { |
| 2903 |
$details = $this->get_payment_details($order); |
| 2904 |
} catch (Exception $e) { |
| 2905 |
// We'll try but if we fail, that's too bad. IOK 2026-03-18. No recovery is really possible here. |
| 2906 |
$this->log(sprintf(__("Could not get payment results for order %1\$s", 'woo-vipps'), $order->get_id())); |
| 2907 |
$this->log($e->getMessage()); |
| 2908 |
} |
| 2909 |
} |
| 2910 |
|
| 2911 |
if ($details) { |
| 2912 |
if (isset($details['transactionSummary'])) { |
| 2913 |
$transactionSummary= $details['transactionSummary']; |
| 2914 |
$order->update_meta_data('_vipps_status',$details['status']); |
| 2915 |
$order->update_meta_data('_vipps_captured',$transactionSummary['capturedAmount']); |
| 2916 |
$order->update_meta_data('_vipps_refunded',$transactionSummary['refundedAmount']); |
| 2917 |
$order->update_meta_data('_vipps_capture_remaining',$transactionSummary['remainingAmountToCapture']); |
| 2918 |
$order->update_meta_data('_vipps_refund_remaining',$transactionSummary['remainingAmountToRefund']); |
| 2919 |
if (isset($details['transactionSummary']['cancelledAmount'])) { |
| 2920 |
$order->update_meta_data('_vipps_cancelled',$transactionSummary['cancelledAmount']); |
| 2921 |
$order->update_meta_data('_vipps_cancel_remaining',$transactionSummary['remainingAmountToCancel']); |
| 2922 |
} |
| 2923 |
} |
| 2924 |
// This is the epayment API - IOK 2022-01-20 |
| 2925 |
if (isset($details['paymentDetails'])) { |
| 2926 |
$d = $details['paymentDetails']; |
| 2927 |
if (isset($d['amount'])) { |
| 2928 |
$order->update_meta_data('_vipps_amount', $d['amount']['value']); |
| 2929 |
} |
| 2930 |
$aggregate = (isset($d['transactionAggregate'])) ? $d['transactionAggregate'] : $d['aggregate']; |
| 2931 |
if ($aggregate) { |
| 2932 |
// capturedAmount, refundedAmount, authorizedAmount, cancelledAmount |
| 2933 |
if (isset($aggregate['authorizedAmount'])) { |
| 2934 |
$order->update_meta_data('_vipps_amount', $aggregate['authorizedAmount']['value']); |
| 2935 |
} |
| 2936 |
} |
| 2937 |
} |
| 2938 |
// Modify payment method name if neccessary |
| 2939 |
if (isset($details['paymentMethod']) && $details['paymentMethod'] == 'Card') { |
| 2940 |
if ($order->get_meta('_vipps_checkout')) { |
| 2941 |
$order->set_payment_method_title(sprintf(__('Credit Card / %1$s', 'woo-vipps'), Vipps::CheckoutName())); |
| 2942 |
} |
| 2943 |
} |
| 2944 |
if (isset($details['paymentMethod']) && $details['paymentMethod'] == 'BankTransfer') { |
| 2945 |
if ($order->get_meta('_vipps_checkout')) { |
| 2946 |
$order->set_payment_method_title(sprintf(__('Bank Transfer/ %1$s', 'woo-vipps'), Vipps::CheckoutName())); |
| 2947 |
$order->update_meta_data('_vipps_api', 'banktransfer'); |
| 2948 |
} |
| 2949 |
} |
| 2950 |
$order->save(); |
| 2951 |
} |
| 2952 |
return $order; |
| 2953 |
} |
| 2954 |
|
| 2955 |
// IOK 2021-01-20 from March 2021 the order_status interface is removed; so we now need to interpret the payment history to find |
| 2956 |
// out the order status. |
| 2957 |
// IOK 2022-01-19 With the epayment API on the other hand, the payment status is back as 'state'. |
| 2958 |
// IOK 2025-08-12 Except for certain payment methods in Checkout. So. |
| 2959 |
// IOK 2025-08-12 Removing the ecom support now, so all code will use 'state', as normalized by normalizePaymentDetails |
| 2960 |
public function get_payment_status_from_payment_details($details) { |
| 2961 |
$status = $details['state']; |
| 2962 |
return $status; |
| 2963 |
} |
| 2964 |
|
| 2965 |
// Get the order status as defined by Vipps; if you have the payment details already, pass them. Will modify the order. IOK 2021-01-20 |
| 2966 |
public function get_vipps_order_status($order, $statusdata=null) { |
| 2967 |
$vippsorderid = $order->get_meta('_vipps_orderid'); |
| 2968 |
if (!$vippsorderid) { |
| 2969 |
$msg = sprintf(__('Could not get %1$s order status - it has no %1$s Order Id. Must cancel.','woo-vipps'), $this->get_payment_method_name()); |
| 2970 |
$this->log($msg,'error'); |
| 2971 |
return 'CANCEL'; |
| 2972 |
} |
| 2973 |
if (!$statusdata) { |
| 2974 |
try { |
| 2975 |
$statusdata = $this->get_payment_details($order); |
| 2976 |
} catch (TemporaryVippsApiException $e) { |
| 2977 |
$this->log(sprintf(__('Could not get %1$s order status for order id:', 'woo-vipps'), Vipps::CompanyName()) . ' ' . $order->get_id() . "\n" .$e->getMessage(),'error'); |
| 2978 |
return null; |
| 2979 |
} catch (VippsAPIException $e) { |
| 2980 |
$msg = sprintf(__('Could not get %1$s order status','woo-vipps'), $this->get_payment_method_name()) . ' ' . $e->getMessage(); |
| 2981 |
$this->log($msg,'error'); |
| 2982 |
if (intval($e->responsecode) == 402 || intval($e->responsecode) == 404) { |
| 2983 |
$this->log(sprintf(__('Order does not exist at %1$s - cancelling','woo-vipps'), $this->get_payment_method_name()) . ' ' . $order->get_id(), 'warning'); |
| 2984 |
return 'CANCEL'; |
| 2985 |
} |
| 2986 |
} catch (Exception $e) { |
| 2987 |
$msg = sprintf(__('Could not get %1$s order status for order id:','woo-vipps'), $this->get_payment_method_name()) . ' ' . $order->get_id() . "\n" . $e->getMessage(); |
| 2988 |
$this->log($msg,'error'); |
| 2989 |
return null; |
| 2990 |
} |
| 2991 |
} |
| 2992 |
if (!$statusdata) return null; |
| 2993 |
|
| 2994 |
$vippsstatus = isset($statusdata['status']) ? $statusdata['status'] : ""; |
| 2995 |
|
| 2996 |
if (!$vippsstatus) { |
| 2997 |
$this->log("Unknown Vipps Status: " . print_r($statusdata, true), 'debug'); |
| 2998 |
} |
| 2999 |
return $vippsstatus; |
| 3000 |
} |
| 3001 |
|
| 3002 |
// The various Vipps APIs return address info with various keys and formats, so we need to translate all of them |
| 3003 |
// to a canonical format. |
| 3004 |
public function canonicalize_vipps_address($address, $user) { |
| 3005 |
// eCom has user info only in the user struct |
| 3006 |
$firstname = $user['firstName']; |
| 3007 |
$lastname = $user['lastName']; |
| 3008 |
$email = $user['email']; |
| 3009 |
|
| 3010 |
// Get the passed phone number from checkout or express, which could be in any number of slots IOK 2025- |
| 3011 |
$phone = isset($user['mobileNumber']) ? $user['mobileNumber'] : ""; |
| 3012 |
if (isset($user['phoneNumber'])) $phone = $user['phoneNumber']; |
| 3013 |
if (!$phone && ($address['phoneNumber'] ?? "")) $phone = $address['phoneNumber']; |
| 3014 |
if (!$phone && ($address['mobileNumber'] ?? "")) $phone = $address['mobileNumber']; |
| 3015 |
|
| 3016 |
// Phone number transformations - the format Vipps Mobilepay uses is often not what merchants expect or need |
| 3017 |
// NOTE: as of writing this, the checkout+expresscheckout expected format is '{countrycode}{phonenr}', so we assume this. LP 2025-12-29 |
| 3018 |
$phone_transformation = $this->get_option('checkout_phone_transformation'); |
| 3019 |
switch($phone_transformation) { |
| 3020 |
case 'ensure_plus': |
| 3021 |
$phone = "+$phone"; |
| 3022 |
break; |
| 3023 |
case 'strip_country_code': |
| 3024 |
// We only support norway,denmark,swedish,finnish country codes as of now. LP 2025-12-29 |
| 3025 |
// We can't do these replaces in sequence, because e.g. +47 46 12 34 56 would become 0 12 34 56 instead of the correct 46 12 34 56. LP 2026-02-19 |
| 3026 |
if (preg_match('!^(45|47)!', $phone)) { // NO, DK |
| 3027 |
$phone = preg_replace('!^(45|47)!', '', $phone); |
| 3028 |
} else if (preg_match('!^(46|358)!', $phone)) { // SE, FI: leading zero for area codes is not used with country code, so add it back here. LP 2026-02-09 |
| 3029 |
$phone = preg_replace('!^(46|358)!', '0', $phone); |
| 3030 |
} |
| 3031 |
break; |
| 3032 |
} |
| 3033 |
$phone = apply_filters('woo_vipps_canonicalize_checkout_phone', $phone, $address, $user); |
| 3034 |
|
| 3035 |
if (!isset($address['firstName']) or !$address['firstName']) { |
| 3036 |
$address['firstName'] = $firstname; |
| 3037 |
} |
| 3038 |
if (!isset($address['lastName']) or !$address['lastName']) { |
| 3039 |
$address['lastName'] = $lastname; |
| 3040 |
} |
| 3041 |
// checkout uses phonenumber |
| 3042 |
if (!isset($address['phoneNumber']) or !$address['phoneNumber']) { |
| 3043 |
$address['phoneNumber'] = $phone; |
| 3044 |
} |
| 3045 |
// epayment uses mobileNumber |
| 3046 |
if (!isset($address['mobileNumber']) or !$address['mobileNumber']) { |
| 3047 |
$address['mobileNumber'] = $phone; |
| 3048 |
} |
| 3049 |
if (!isset($address['email']) or !$address['email']) { |
| 3050 |
$address['email'] = $email; |
| 3051 |
} |
| 3052 |
|
| 3053 |
// epayment |
| 3054 |
$addressline1 = isset($address['addressLine1']) ? $address['addressLine1'] : ""; |
| 3055 |
$addressline2 = isset($address['addressLine2']) ? $address['addressLine2'] : ""; |
| 3056 |
// checkout |
| 3057 |
if (isset($address['streetAddress'])) { |
| 3058 |
$addressline1 = $address['streetAddress']; |
| 3059 |
} |
| 3060 |
if (isset($address['street_address'])) { // From the userinfo api |
| 3061 |
$addressline1 = $address['street_address']; |
| 3062 |
} |
| 3063 |
if ($addressline1 == $addressline2) $addressline2 = ''; |
| 3064 |
$address['addressLine1'] = $addressline1; // epayment |
| 3065 |
$address['addressline2'] = $addressline2; |
| 3066 |
$address['streetAddress'] = $addressline1; // Checkout |
| 3067 |
|
| 3068 |
$city = ""; |
| 3069 |
if (isset($address['city'])) { // checkout and epayment |
| 3070 |
$city = $address['city']; |
| 3071 |
} elseif (isset($address['region'])) { // ecom |
| 3072 |
$city = $address['region']; |
| 3073 |
} |
| 3074 |
$address['city'] = $city; |
| 3075 |
$address['region'] = $city; |
| 3076 |
|
| 3077 |
$postcode= ""; |
| 3078 |
if (isset($address['postCode'])) { |
| 3079 |
$postcode= $address['postCode']; // epayment |
| 3080 |
} elseif (isset($address['postalCode'])){ |
| 3081 |
$postcode= $address['postalCode']; // checkout |
| 3082 |
} elseif (isset($address['postal_code'])) { |
| 3083 |
$postcode= $address['postal_code']; // userinfo |
| 3084 |
} |
| 3085 |
$address['postCode'] = $postcode; // epayment |
| 3086 |
$address['zipCode'] = $postcode; // ecom |
| 3087 |
$address['postalCode'] = $postcode; // checkout |
| 3088 |
|
| 3089 |
// Allow users to modify the address to e.g. handle phone numbers differently IOK 2025-01-20 |
| 3090 |
// note: added separate filter for phone number 'woo_vipps_canonicalize_checkout_phone' because of the different uses, keys etc. LP 2025-12-29 |
| 3091 |
return apply_filters('woo_vipps_canonicalize_checkout_address', $address, $user); |
| 3092 |
} |
| 3093 |
|
| 3094 |
public function set_order_shipping_details($order,$shipping, $user, $billing=false, $alldata=null, $assigncustomer=true) { |
| 3095 |
global $Vipps; |
| 3096 |
$done = $order->get_meta('_vipps_shipping_set'); |
| 3097 |
if ($done) return true; |
| 3098 |
$order->update_meta_data('_vipps_shipping_set', true); |
| 3099 |
$order->save(); // Limit the window for double shipping as much as possible. |
| 3100 |
|
| 3101 |
// This is for handling a custom consent checkbox for mailing lists etc. IOK 2023-02-09 |
| 3102 |
if ($alldata && isset($alldata['customConsentProvided'])) { |
| 3103 |
$order->update_meta_data('_vipps_custom_consent_provided', intval($alldata['customConsentProvided'])); |
| 3104 |
} |
| 3105 |
|
| 3106 |
|
| 3107 |
// We get different values from the normal callback and the Checkout callback, so be prepared for several results. IOK 2021-09-02 |
| 3108 |
// IOK VERIFY this should be normalized now or soon at any rate |
| 3109 |
$address = isset($shipping['address']) ? $shipping['address'] : $shipping;; |
| 3110 |
|
| 3111 |
// Sometimes we get an empty shipping address! In this case, fill the details with the billing address. |
| 3112 |
// This only happens with ecommerce though, so we need to check before canonicalizing. IOK 2022-03-21 |
| 3113 |
// billing is only present in Checkout, which uses phoneNumber, streetAddress, postalCode etc. |
| 3114 |
$shipping_empty = true; |
| 3115 |
if ($billing && array_key_exists('streetAddress', $address)) { |
| 3116 |
$keys = ['firstName', 'lastName', 'email', 'phoneNumber', 'streetAddress', 'postalCode', 'city', 'country']; |
| 3117 |
foreach ($keys as $key) { |
| 3118 |
if (isset($address[$key]) && $address[$key]) { |
| 3119 |
$shipping_empty = false; break; |
| 3120 |
} |
| 3121 |
} |
| 3122 |
if ($shipping_empty) { |
| 3123 |
foreach ($keys as $key) $address[$key] = $billing[$key]; |
| 3124 |
} |
| 3125 |
} |
| 3126 |
|
| 3127 |
if (!$billing) $billing = $address; |
| 3128 |
$address = $this->canonicalize_vipps_address($address, $user); |
| 3129 |
$billing = $this->canonicalize_vipps_address($billing, $user); |
| 3130 |
|
| 3131 |
# Billing. |
| 3132 |
$order->set_billing_email($billing['email']); |
| 3133 |
$order->set_billing_phone($billing['mobileNumber']); |
| 3134 |
$order->set_billing_first_name($billing['firstName']); |
| 3135 |
$order->set_billing_last_name($billing['lastName']); |
| 3136 |
$order->set_billing_address_1($billing['addressLine1']); |
| 3137 |
if ($billing['addressLine2'] ?? false) $order->set_billing_address_2($billing['addressLine2']); |
| 3138 |
$order->set_billing_city($billing['city'] ?? ""); |
| 3139 |
$order->set_billing_postcode($billing['postCode'] ?? ""); |
| 3140 |
$order->set_billing_country($billing['country'] ?? ""); |
| 3141 |
|
| 3142 |
# Shipping. |
| 3143 |
$order->set_shipping_first_name($address['firstName']); |
| 3144 |
$order->set_shipping_last_name($address['lastName']); |
| 3145 |
if (version_compare(WC_VERSION, '5.6.0', '>=')) { |
| 3146 |
$order->set_shipping_phone($address['mobileNumber']); |
| 3147 |
} |
| 3148 |
$order->set_shipping_address_1($address['addressLine1']); |
| 3149 |
if ($address['addressLine2'] ?? "") $order->set_shipping_address_2($address['addressLine2']); |
| 3150 |
$order->set_shipping_city($address['city']); |
| 3151 |
$order->set_shipping_postcode($address['postCode']); |
| 3152 |
$order->set_shipping_country($address['country']); |
| 3153 |
|
| 3154 |
$order->save(); |
| 3155 |
|
| 3156 |
// This is *essential* to get VAT calculated correctly. That calculation uses the customer, which uses the session, which we will have restored at this point.IOK 2019-10-25 |
| 3157 |
if (WC()->customer) { |
| 3158 |
WC()->customer->set_billing_email($billing['email']); |
| 3159 |
WC()->customer->set_email($billing['email']); |
| 3160 |
|
| 3161 |
$country = $billing['country'] ?? ($address['country'] ?? ""); |
| 3162 |
WC()->customer->set_billing_location($country,'',$billing['postalCode'],$billing['region']); |
| 3163 |
WC()->customer->set_shipping_location($address['country'],'',$address['postalCode'],$address['region']); |
| 3164 |
} |
| 3165 |
|
| 3166 |
// We may need the order total early on, so start with that |
| 3167 |
$ordertotal = $order->get_total() ?: 0; |
| 3168 |
|
| 3169 |
$vipps_reserved = $alldata['paymentDetails']['amount']['value'] ?? null; |
| 3170 |
// i dont expect order total to ever be greater than vipps reserved total here, so i dont use abs(). LP 2026-01-28 |
| 3171 |
$diff_reserved_ordertotal = is_numeric($vipps_reserved) ? ($vipps_reserved / 100 - $ordertotal) : 0; |
| 3172 |
|
| 3173 |
// Now do shipping, if it exists IOK 2021-09-02 |
| 3174 |
$method = isset($shipping['shippingMethodId']) ? $shipping['shippingMethodId'] : false; |
| 3175 |
|
| 3176 |
// We will add a shipping rate either if there has been passed a shipping method; or if this |
| 3177 |
// is an order that needs shipping and the amount reserved at vipps is greater than the order total |
| 3178 |
// (with a bit of tolerance for rounding errors). If we *don't* have a shipping method but we know |
| 3179 |
// we need a shipping rate; this is an error condition that the merchant needs to resolve. We'll add a fake |
| 3180 |
// 'Unknown' rate to ensure we capture the right amount and add this fact to the order log. Code by LP, comment by IOK 2026-01-28 |
| 3181 |
$needs_shipping = $method || $order->get_meta('_vipps_needs_shipping'); |
| 3182 |
$tol = 0.01; |
| 3183 |
$has_shipping = $method || $diff_reserved_ordertotal > $tol; |
| 3184 |
|
| 3185 |
if ($needs_shipping && $has_shipping) { |
| 3186 |
$shipping_rate=null; |
| 3187 |
$option_table = []; |
| 3188 |
|
| 3189 |
// Try to find the shipping rate. LP 2026-01-28 |
| 3190 |
if ($method) { |
| 3191 |
if (substr($method,0,1) != '$') { |
| 3192 |
// This is the old way of adding shipping. We should probably deprecate this sometime soon. IOK 2026-01-28 |
| 3193 |
$shipping_rate = $this->get_legacy_express_checkout_shipping_rate($shipping); |
| 3194 |
} else { |
| 3195 |
// Strip suffixes if we have several Express rates mapping to the same Woo rate (eg. for Posten). IOK 2025-05-04 |
| 3196 |
$matches = []; |
| 3197 |
preg_match("!^(?P<key>[^:]+):?(?P<option_index>.+)?$!", $method, $matches); |
| 3198 |
$key = $matches['key'] ?? ""; |
| 3199 |
$option_index = intval(trim($matches['option_index'] ?? "")); // 0 is never an index |
| 3200 |
$shipping_table = $order->get_meta('_vipps_express_checkout_shipping_method_table'); |
| 3201 |
$is_base64 = $shipping_table ? ( $shipping_table['_is_base64'] ?? false) : false; |
| 3202 |
|
| 3203 |
if (is_array($shipping_table) && isset($shipping_table[$key])) { |
| 3204 |
$decoded = $is_base64 ? @base64_decode($shipping_table[$key]) : $shipping_table[$key]; |
| 3205 |
$shipping_rate = $decoded ? @unserialize($decoded) : null; |
| 3206 |
if (!$shipping_rate) { |
| 3207 |
$this->log(sprintf(__("%1\$s: Could not deserialize the chosen shipping method %2\$s for order %3\$d", 'woo-vipps'), Vipps::ExpressCheckoutName(), $method, $order->get_id()), 'error'); |
| 3208 |
$this->log(sprintf(__("Serialized data was %1\$s", 'woo-vipps'), $decoded), 'error'); |
| 3209 |
} else { |
| 3210 |
// Special-case the Woo pickup location methods. IOK 2026-01-28 |
| 3211 |
if ($option_index) { |
| 3212 |
$meta = $shipping_rate->get_meta_data(); |
| 3213 |
$option_table = $meta['_vipps_pickupPoints'] ?? []; |
| 3214 |
// force string table IOK 2025-08-15 |
| 3215 |
$point = $option_table["i".$option_index] ?? ""; |
| 3216 |
if ($point) { |
| 3217 |
$shipping['pickupPoint'] = $point; |
| 3218 |
} |
| 3219 |
$shipping_rate->add_meta_data('_vipps_pickupPoints', null); |
| 3220 |
} |
| 3221 |
// Empty this when done, but not if there was an error - let the merchant be able to debug. IOK 2020-02-14 |
| 3222 |
$order->update_meta_data('_vipps_express_checkout_shipping_method_table', null); |
| 3223 |
} |
| 3224 |
} |
| 3225 |
} |
| 3226 |
|
| 3227 |
// Possible extra metadata from Vipps Checkout IOK 2023-01-17 |
| 3228 |
// Store in the order, but also in the shipping rate so it will be visible in the order screen |
| 3229 |
// along with the shipping ragte |
| 3230 |
if (isset($shipping['pickupPoint'])) { |
| 3231 |
$order->update_meta_data('vipps_checkout_pickupPoint', $shipping['pickupPoint']); |
| 3232 |
if ($shipping_rate) { |
| 3233 |
$pp = $shipping['pickupPoint']; |
| 3234 |
$addr = []; |
| 3235 |
foreach(['address', 'postalCode', 'city', 'country'] as $key) { |
| 3236 |
$v = trim($pp[$key]); |
| 3237 |
if (!empty($v)) $addr[] = trim($pp[$key]); |
| 3238 |
} |
| 3239 |
|
| 3240 |
$shipping_rate->add_meta_data('pickup_location', $pp['name']); |
| 3241 |
$shipping_rate->add_meta_data('pickup_address', join(", ", $addr)); |
| 3242 |
$shipping_rate->add_meta_data('pickup_details', ""); // Not supported by the API unfortunately. IOK 2025-06-07 |
| 3243 |
} |
| 3244 |
} |
| 3245 |
if (isset($shipping['timeslot'])) { |
| 3246 |
$order->update_meta_data('vipps_checkout_timeslot', $shipping['timeslot']); |
| 3247 |
if ($shipping_rate) { |
| 3248 |
$pp = $shipping['timeslot']; |
| 3249 |
$slot = ""; |
| 3250 |
$slot .= sprintf(__("Date: %s", 'woo-vipps'), ($pp['date'] ?? "")); |
| 3251 |
$slot .= " " . sprintf(__("Start: %s", 'woo-vipps'), ($pp['start'] ?? "")); |
| 3252 |
$slot .= " " . sprintf(__("End: %s", 'woo-vipps'), ($pp['end'] ?? "")); |
| 3253 |
$shipping_rate->add_meta_data('vipps_delivery_timeslot', $slot); |
| 3254 |
$shipping_rate->add_meta_data('vipps_delivery_timeslot_id', $pp['id']); |
| 3255 |
} |
| 3256 |
} |
| 3257 |
} |
| 3258 |
|
| 3259 |
// We know we need a shipping rate, and what its price has to be, so ensure we have one by making one up if missing. LP 2026-01-28 |
| 3260 |
if (!$shipping_rate) { |
| 3261 |
$shipping_rate = new WC_Shipping_Rate( |
| 3262 |
'UNKNOWN', |
| 3263 |
sprintf(__('Unknown shipping: please check the shipping details at %1$s', 'woo-vipps'), Vipps::CompanyName()), |
| 3264 |
$diff_reserved_ordertotal, |
| 3265 |
[], |
| 3266 |
'UNKNOWN', |
| 3267 |
0, |
| 3268 |
); |
| 3269 |
$shipping_rate = apply_filters('woo_vipps_unknown_shipping_rate_dummy', $shipping_rate, $order); |
| 3270 |
|
| 3271 |
// Add an error log for the merchants to quote to us. |
| 3272 |
$msg = sprintf(__("%1\$s Could not retrieve any shipping rate for this order, with method %2\$s",'woo-vipps'), $this->get_payment_method_name(), $method) . " " . $order->get_id(); |
| 3273 |
$order->add_order_note($msg); |
| 3274 |
$this->log($msg, 'warning'); |
| 3275 |
} |
| 3276 |
|
| 3277 |
$shipping_rate = apply_filters('woo_vipps_express_checkout_final_shipping_rate', $shipping_rate, $order, $shipping); |
| 3278 |
|
| 3279 |
$total_shipping = 0; |
| 3280 |
$total_shipping_tax = 0; |
| 3281 |
$it = null; |
| 3282 |
|
| 3283 |
// Recover the Shipping Method class |
| 3284 |
$methods_classes = WC()->shipping->get_shipping_method_class_names(); |
| 3285 |
$methodclass = $methods_classes[$shipping_rate->get_method_id()] ?? null; |
| 3286 |
$shipping_method = $methodclass ? new $methodclass($shipping_rate->get_instance_id()) : null; |
| 3287 |
$is_vipps_checkout_shipping = $shipping_method && is_a($shipping_method, 'VippsCheckout_Shipping_Method'); |
| 3288 |
|
| 3289 |
// Some Vipps Checkout-specific shipping methods calculate the cost in the Vipps window. |
| 3290 |
if ($is_vipps_checkout_shipping && $shipping_method->dynamic_cost) { |
| 3291 |
$vippsamount = intval($order->get_meta('_vipps_amount')); |
| 3292 |
$shipping_tax_rate = floatval($order->get_meta('_vipps_shipping_tax_rates')); |
| 3293 |
$compareamount = $ordertotal * 100; |
| 3294 |
$amountdiff = $vippsamount-$compareamount; // this is the *actual* shipping cost at this point |
| 3295 |
$diffnotax = ($amountdiff / (100 + $shipping_tax_rate)); // Adjusted to correct values actually |
| 3296 |
$difftax = WC_Tax::round($amountdiff/100 - $diffnotax); |
| 3297 |
$actual = $amountdiff/100 - $difftax; |
| 3298 |
|
| 3299 |
$shipping_rate->set_cost($actual); |
| 3300 |
$shipping_rate->set_taxes( [ 1 => $difftax] ); |
| 3301 |
} |
| 3302 |
|
| 3303 |
$it = new WC_Order_Item_Shipping(); |
| 3304 |
$it->set_shipping_rate($shipping_rate); |
| 3305 |
$it->set_order_id( $order->get_id() ); |
| 3306 |
// This should actually have been done by the "set_shipping_rate" call above, but as of 3.9.2 at least, this does not work. |
| 3307 |
// Therefore, do it manually/forcefully IOK 2020-02-17 |
| 3308 |
foreach($shipping_rate->get_meta_data() as $key => $value) { |
| 3309 |
$it->add_meta_data($key,$value,true); |
| 3310 |
} |
| 3311 |
$it->save(); |
| 3312 |
|
| 3313 |
$order->add_item($it); |
| 3314 |
|
| 3315 |
$total_shipping = $it->get_total() ?: 0; |
| 3316 |
$total_shipping_tax = $it->get_total_tax() ?: 0; |
| 3317 |
|
| 3318 |
// Try to avoid calculate_totals, because this will recalculate shipping _without checking if the rate |
| 3319 |
// in question actually should use tax_. Therefore we will just add the pre-calculated values, so that the |
| 3320 |
// value reserved at Vipps and the order total is the same. IOK 2022-10-03 |
| 3321 |
$order->set_shipping_total($total_shipping); |
| 3322 |
$order->set_shipping_tax($total_shipping_tax); |
| 3323 |
|
| 3324 |
$order->set_total($ordertotal + $total_shipping + $total_shipping_tax); |
| 3325 |
$order->update_taxes(); // Necessary for the admin view only; does not recalculate order. |
| 3326 |
|
| 3327 |
// Add an early hook for Vipps Checkout orders with special shipping methods |
| 3328 |
$metadata = $shipping_rate->get_meta_data(); |
| 3329 |
if (isset($metadata['type'])) { |
| 3330 |
do_action('woo_vipps_checkout_special_shipping_method', $order, $shipping_rate, $metadata['type']); |
| 3331 |
} |
| 3332 |
|
| 3333 |
$order->save(); |
| 3334 |
// NB: WE DO NOT CALL CALCULATE TOTALS! |
| 3335 |
// THIS WILL CALCULATE SHIPPING FOR TAX IF THERE IS A TAX RATE FOR THE GIVEN AREA WITH THE 'shipping' PROPERTY CHECKED - EVEN IF THE SHIPPING RATE IT SELF IS NOT THUS CONFIGURED. |
| 3336 |
// Same thing happens when using the "recalculate" button in the backend |
| 3337 |
// This will *only* affect users that choose "No tax" for the shipping rates themselves, which is mostly just wrong, but we want to ensure consistency here since this is hard |
| 3338 |
// to debug. |
| 3339 |
// $order->calculate_totals(true); |
| 3340 |
} |
| 3341 |
|
| 3342 |
|
| 3343 |
// If we have the 'expresscreateuser' thing set to true, we will create or assign the order here, as it is the first-ish place where we can. |
| 3344 |
// If possible and safe, user will be logged in before being sent to the thankyou screen. IOK 2020-10-09 |
| 3345 |
// Same thing for Vipps Checkout, mutatis mutandis. The function below returns false if no customer exists or gets created. |
| 3346 |
$customer = false; |
| 3347 |
if ($assigncustomer) { |
| 3348 |
$customer = Vipps::instance()->express_checkout_get_vipps_customer($order); |
| 3349 |
} |
| 3350 |
if ($customer) { |
| 3351 |
// This would have been used to ensure that we 'enroll' the users the same way as in the Login plugin. Unfortunately, the userId from express checkout isn't |
| 3352 |
// the same as the 'sub' we get in Login so that must be a future feature. IOK 2020-10-09 |
| 3353 |
// IOK 2025-08-13 we do get the 'sub' now, at least for express checkout. For Checkout, we would have to compare the email of the user with the verified email |
| 3354 |
// after calling get_userinfo, so we'll leave that be. |
| 3355 |
// We *maybe* get the sub - it depends on consent, and *maybe* that a scope has been added in epayment_initate_payment. IOK 2026-08-18 |
| 3356 |
if (class_exists('VippsWooLogin') && $customer && !is_wp_error($customer) && !get_user_meta($customer->get_id(), '_vipps_phone',true)) { |
| 3357 |
update_user_meta($customer->get_id(), '_vipps_phone', $billing['phoneNumber']); |
| 3358 |
if (isset($user['sub'])) { |
| 3359 |
$userid = $customer->get_id(); |
| 3360 |
update_user_meta($userid, '_vipps_id', $user['sub']); |
| 3361 |
update_user_meta($userid, '_vipps_just_connected', 1); |
| 3362 |
} |
| 3363 |
} |
| 3364 |
|
| 3365 |
// Ensure we get any changes made to the order, as it will be re-saved later |
| 3366 |
$order = wc_get_order($order->get_id()); |
| 3367 |
} |
| 3368 |
|
| 3369 |
do_action('woo_vipps_set_order_shipping_details', $order, $shipping, $user); |
| 3370 |
$order->save(); // I'm not sure why this is neccessary - but be sure. |
| 3371 |
|
| 3372 |
} |
| 3373 |
|
| 3374 |
// Previously, shipping rates were added by creating them here with metadata packed into the shippingMethodId. This is from 1.4.0 only |
| 3375 |
// used when the woo_vipps_shipping_methods filter has been overriden by the merchant. IOK 2020-02-14 |
| 3376 |
private function get_legacy_express_checkout_shipping_rate($shipping) { |
| 3377 |
$method = $shipping['shippingMethodId']; |
| 3378 |
list ($rate,$tax) = explode(";",$method); |
| 3379 |
// The method ID is encoded in the rate ID but we apparently must still send it to the WC_Shipping_Rate constructor. IOK 2018-06-01 |
| 3380 |
// Unfortunately, Vipps won't accept long enought 'shipingMethodId' for us to actually stash all the information we need. IOK 2018-06-01 |
| 3381 |
list ($method,$product) = explode(":",$rate); |
| 3382 |
$tax = wc_format_decimal($tax,''); |
| 3383 |
$label = $shipping['shippingMethod']; |
| 3384 |
$cost = wc_format_decimal($shipping['shippingCost'],''); // This is inclusive of tax |
| 3385 |
$costExTax= wc_format_decimal($cost-$tax,''); |
| 3386 |
$shipping_rate = new WC_Shipping_Rate($rate,$label,$costExTax,array(array('total'=>$tax)), $method, $product); |
| 3387 |
$shipping_rate = apply_filters('woo_vipps_express_checkout_shipping_rate',$shipping_rate,$costExTax,$tax,$method,$product); |
| 3388 |
return $shipping_rate; |
| 3389 |
} |
| 3390 |
|
| 3391 |
// Used by both callback_check_order_status and handle_callback - sets the neccessary order metadata after a successful (or not vipps transaction). IOK 2025-08-13 |
| 3392 |
public function order_set_transaction_metadata($order, $transaction) { |
| 3393 |
// Set Vipps metadata as early as possible |
| 3394 |
$vippsstamp = strtotime($transaction['timeStamp']); |
| 3395 |
$vippsamount = $transaction['amount'] ?? ''; |
| 3396 |
$vippscurrency= $transaction['currency'] ?? ''; |
| 3397 |
$vippsstatus = $transaction['status']; |
| 3398 |
|
| 3399 |
$order->update_meta_data('_vipps_callback_timestamp',$vippsstamp); |
| 3400 |
$order->update_meta_data('_vipps_amount',$vippsamount); |
| 3401 |
$order->update_meta_data('_vipps_currency',$vippscurrency); |
| 3402 |
$order->update_meta_data('_vipps_status',$vippsstatus); |
| 3403 |
|
| 3404 |
// Checkout only, modify payment method name if neccessary |
| 3405 |
if ($transaction['paymentmethod'] == 'Card') { |
| 3406 |
if ($order->get_meta('_vipps_checkout')) { |
| 3407 |
$order->set_payment_method_title(sprintf(__('Credit Card / %1$s', 'woo-vipps'), Vipps::CheckoutName())); |
| 3408 |
} |
| 3409 |
} |
| 3410 |
// Checkout only, banktransfers are handled specially so note that |
| 3411 |
if ($transaction['paymentmethod'] == 'BankTransfer') { |
| 3412 |
$order->set_payment_method_title(sprintf(__('Bank Transfer/ %1$s', 'woo-vipps'), Vipps::CheckoutName())); |
| 3413 |
$order->update_meta_data('_vipps_api', 'banktransfer'); |
| 3414 |
} |
| 3415 |
} |
| 3416 |
|
| 3417 |
// Handle the callback from Vipps ePayment |
| 3418 |
public function handle_callback($result, $order, $ischeckout=false, $iswebhook=false) { |
| 3419 |
global $Vipps; |
| 3420 |
|
| 3421 |
$vippsorderid = $result['orderId']; |
| 3422 |
$merchant= $result['merchantSerialNumber']; |
| 3423 |
|
| 3424 |
$keyset = $this->get_keyset(); |
| 3425 |
$me = array_keys($keyset); |
| 3426 |
|
| 3427 |
// Validate the callback first |
| 3428 |
if (!in_array($merchant, $me)) { |
| 3429 |
$this->log(sprintf(__("%1\$s callback with wrong merchantSerialNumber - might be forged",'woo-vipps'), $this->get_payment_method_name()) . " " . $order->get_id(), 'warning'); |
| 3430 |
return false; |
| 3431 |
} |
| 3432 |
if (!$order) { |
| 3433 |
$this->log(sprintf(__("%1\$s callback for unknown order",'woo-vipps'), $this->get_payment_method_name()) . " " . $order->get_id(), 'warning'); |
| 3434 |
return false; |
| 3435 |
} |
| 3436 |
$order_id = $order->get_id(); |
| 3437 |
if ($vippsorderid != $order->get_meta('_vipps_orderid')) { |
| 3438 |
$this->log(sprintf(__('Wrong %1$s Orderid - possibly an attempt to fake a callback ', 'woo-vipps'), Vipps::CompanyName()), 'warning'); |
| 3439 |
clean_post_cache($order_id); |
| 3440 |
exit(); |
| 3441 |
} |
| 3442 |
|
| 3443 |
// Note any errors in the callback early |
| 3444 |
$errorInfo = $result['errorInfo'] ?? ''; |
| 3445 |
if ($errorInfo) { |
| 3446 |
/* translators: payment method name, order id */ |
| 3447 |
$this->log(sprintf(__('Message in callback from %1$s for order %2$s: ','woo-vipps'), $this->get_payment_method_name(), $order_id), $errorInfo['errorMessage'], 'error'); |
| 3448 |
/* translators: payment method name, message */ |
| 3449 |
$order->add_order_note(sprintf(__('Message from %1$s: %2$s','woo-vipps'), $this->get_payment_method_name(), $errorInfo['errorMessage'])); |
| 3450 |
} |
| 3451 |
|
| 3452 |
// Create a signal file (if possible) so the confirm screen knows to check status IOK 2018-05-04 |
| 3453 |
try { |
| 3454 |
$Vipps->createCallbackSignal($order,'ok'); |
| 3455 |
} catch (Exception $e) { |
| 3456 |
// Could not create a signal file, but that's ok. |
| 3457 |
} |
| 3458 |
|
| 3459 |
// New callback handling: schedule an Action Scheduler job to process it. The purpose of processing callback |
| 3460 |
// is to set finalize the order (set order status, set shipping for express) in the case when customer does |
| 3461 |
// not return to the store, because then poll does not run. LP 2026-03-27 |
| 3462 |
|
| 3463 |
// Below is separate from '_vipps_callback_timestamp' which is when callback is sent, |
| 3464 |
// but also that meta won't be stored until callback is actually processed. LP 2026-03-30 |
| 3465 |
$order->update_meta_data('_vipps_callback_received_at', time()); |
| 3466 |
// Store the callback data in the order. We'll do a cleanup of this when the scheduled job runs. IOK 2026-04-21 |
| 3467 |
$order->update_meta_data('_vipps_callback_data', $result); |
| 3468 |
$order->save_meta_data(); |
| 3469 |
|
| 3470 |
// Run callback actions for callback received as soon as it is actually received. |
| 3471 |
$transaction = []; // No longer provided. IOK 2026-05-06 |
| 3472 |
do_action('woo_vipps_callback_received', $order, $result, $transaction); |
| 3473 |
|
| 3474 |
$action_args = [ |
| 3475 |
'order_id' => $order->get_id(), |
| 3476 |
'is_checkout' => $ischeckout, |
| 3477 |
'is_webhook' => $iswebhook, |
| 3478 |
]; |
| 3479 |
// We'll check the status of this order in a minute. At that time, the customer should have been able to return to the store |
| 3480 |
// and have the order finalized the 'normal' way, but if they don't, we'll handle it async. 2026-04-21 |
| 3481 |
$scheduled_at = time() + 60; |
| 3482 |
$action_id = as_schedule_single_action($scheduled_at, 'woo_vipps_action_process_callback', $action_args, 'woo-vipps', false); |
| 3483 |
if ($action_id) { |
| 3484 |
/* translators: order id, scheduled time */ |
| 3485 |
$this->log(sprintf(__('Callback action scheduled at %2$s for order %1$s', 'woo-vipps'), $order->get_id(), $scheduled_at), 'info'); |
| 3486 |
} else { |
| 3487 |
// The action scheduler error is not returned, only sent to error_log (https://github.com/woocommerce/action-scheduler/blob/25c982c3d0f8134389d5b5884082403c4806322f/classes/ActionScheduler_ActionFactory.php#L268). LP 2026-04-23 |
| 3488 |
/* translators: order id */ |
| 3489 |
$this->log(sprintf(__('Failed to schedule callback process action for order %1$s, check the php error log', 'woo-vipps'), $order->get_id()), 'error'); |
| 3490 |
/* We will not delete the callback data here, to facilitate debugging. But return false to indicate that callback handling will fail. */ |
| 3491 |
/* NB: The order will still be processed with the periodic job, at a later stage. IOK 2026-05-06 */ |
| 3492 |
return false; |
| 3493 |
} |
| 3494 |
|
| 3495 |
// Signal that we in fact handled the order. |
| 3496 |
return true; |
| 3497 |
} |
| 3498 |
|
| 3499 |
/** Runs in action scheduler: sync woo status from Vipps callback data. Handle shipping etc. for Express. LP 2026-03-31 */ |
| 3500 |
public function action_process_callback($order_id, $is_checkout, $is_webhook) { |
| 3501 |
$order = wc_get_order($order_id); |
| 3502 |
if (!is_a($order, 'WC_Order')) { |
| 3503 |
/* translators: order id */ |
| 3504 |
$this->log(sprintf(__('Callback process action failed, could not find order %1$s','woo-vipps'), $order_id), 'error'); |
| 3505 |
return false; |
| 3506 |
} |
| 3507 |
|
| 3508 |
$oldstatus = $order->get_status(); |
| 3509 |
if ($oldstatus != 'pending') { |
| 3510 |
// Actually, we are ok with this order, abort the callback handler. IOK 2018-05-30 |
| 3511 |
$order->delete_meta_data('_vipps_callback_data'); |
| 3512 |
clean_post_cache($order->get_id()); |
| 3513 |
return false; |
| 3514 |
} |
| 3515 |
$data = $order->get_meta('_vipps_callback_data'); |
| 3516 |
|
| 3517 |
/* translators: order id */ |
| 3518 |
$this->log(sprintf(__('Callback process action running for order %1$s.', 'woo-vipps'), $order_id)); |
| 3519 |
|
| 3520 |
// The payment details field is passed in Checkout, not in Express, but none of them are complete, so we fill out the values |
| 3521 |
// depending on which one we are IOK 2025-08-13 |
| 3522 |
$details = []; |
| 3523 |
// Checkout has this as a field, containing *some* of the neccessary data |
| 3524 |
if (isset($data['paymentDetails'])) { |
| 3525 |
// Checkout. The sesssion states are # "SessionCreated" "PaymentInitiated" "SessionExpired" "PaymentSuccessful" "PaymentTerminated" |
| 3526 |
// -- we should only get callbacks for successful sessions actually. |
| 3527 |
|
| 3528 |
$details = $data['paymentDetails']; |
| 3529 |
$data['state'] = $data['sessionState'] == 'PaymentSuccessful' ? 'AUTHORIZED' : ($data['sessionState'] == 'PaymentTerminated' ? 'TERMINATED' : 'CREATED'); |
| 3530 |
$details['state'] = $data['state']; |
| 3531 |
$details['paymentMethod'] = $data['paymentMethod']; |
| 3532 |
} else { |
| 3533 |
// This should be an epayment webhook callback; which we need to add a lot of data for to get a valid "paymentDetails". |
| 3534 |
$details = []; |
| 3535 |
$data['state'] = $data['name']; // The name of the callback - which should be AUTHORIZED, TERMINATED etc |
| 3536 |
$details['state'] = $data['name']; |
| 3537 |
$details['amount'] = $data['amount']; // currency, value |
| 3538 |
$details['paymentMethod'] = 'epayment'; |
| 3539 |
} |
| 3540 |
|
| 3541 |
// For both callbacks, set 'aggregate' |
| 3542 |
$currency = $details['amount']['currency']; |
| 3543 |
$nothing = [ 'currency' => $currency, 'value' => 0]; |
| 3544 |
$aggregate = ['authorizedAmount' => $nothing, 'cancelledAmount' => $nothing, 'capturedAmount' => $nothing, 'refundedAmount' => $nothing]; |
| 3545 |
if ($details['state'] == 'AUTHORIZED') { |
| 3546 |
$aggregate['authorizedAmount'] = $details['amount']; |
| 3547 |
} |
| 3548 |
$details['aggregate'] = $aggregate; |
| 3549 |
$data['paymentDetails'] = $details; |
| 3550 |
|
| 3551 |
// Do the actual work with a function shared with the periodic job. |
| 3552 |
$this->set_order_status_by_payment_details($order,$data); |
| 3553 |
|
| 3554 |
/* translators: payment method name */ |
| 3555 |
$order->add_order_note(sprintf(__('%1$s callback processed','woo-vipps'), $this->get_payment_method_name())); |
| 3556 |
|
| 3557 |
// We're done, so delete the callback data. IOK 2026-04-22 |
| 3558 |
$order->delete_meta_data('_vipps_callback_data'); |
| 3559 |
} |
| 3560 |
|
| 3561 |
|
| 3562 |
// Called either by periodic job or by action_process_callback with the callback data *or* with payment details fetched with poll. |
| 3563 |
// sets order status if neccessary, and will finalize the order for Express via HTTP call if necessary. IOK 2026-05-06 |
| 3564 |
public function set_order_status_by_payment_details($order, $data, $allow_retry=true) { |
| 3565 |
$data = $this->normalizePaymentDetails($data); |
| 3566 |
$details = $data['paymentDetails']; |
| 3567 |
$order_id = $order->get_id(); |
| 3568 |
|
| 3569 |
$vippsstatus = $data['status']; // Will exist now, because of the normalization IOK 2025-08-13 |
| 3570 |
$newstatus = $this->interpret_vipps_order_status($vippsstatus); |
| 3571 |
|
| 3572 |
// Extract order metadata from either Checkout or Epayment - set below IOK 2025-08-13 |
| 3573 |
$transaction = array(); |
| 3574 |
$stamp = ($data['timestamp'] ?? false) ? strtotime($data['timestamp']) : time(); |
| 3575 |
$transaction['timeStamp'] = date('Y-m-d H:i:s', $stamp); |
| 3576 |
$transaction['amount'] = $details['amount']['value']; |
| 3577 |
$transaction['currency'] = $details['amount']['currency']; |
| 3578 |
$transaction['status'] = ($data['state'] ?? $details['state']); |
| 3579 |
$transaction['paymentmethod'] = $details['paymentMethod'] ?? ""; |
| 3580 |
$this->order_set_transaction_metadata($order, $transaction); |
| 3581 |
|
| 3582 |
// Dont do anything if order is not finalized. LP 2026-08-31 |
| 3583 |
if (!in_array($newstatus, ['authorized', 'complete', 'cancelled'])) { |
| 3584 |
return; |
| 3585 |
} |
| 3586 |
|
| 3587 |
// This order is ready to set order shipping details etc for IOK 2025-09-19 |
| 3588 |
$ready = in_array($newstatus, ['authorized', 'complete']); |
| 3589 |
|
| 3590 |
if ($ready) { |
| 3591 |
// Failsafe for rare bug when using Klarna Checkout with Vipps as an external payment method |
| 3592 |
// IOK 2024-01-09 ensure this is called only when order is complete/authorized |
| 3593 |
$this->reset_erroneous_payment_method($order); |
| 3594 |
} |
| 3595 |
|
| 3596 |
$is_express_or_checkout = $order->get_meta('_vipps_express_checkout'); |
| 3597 |
|
| 3598 |
// Handle session and shipping through http, because we dont want to mess with session here in wp cron (action scheduler). LP 2026-03-30 |
| 3599 |
// NB: This is and must be a *synchronous call*. When done, the order will have shipping, addresses etc. IOK 2026-05-06. |
| 3600 |
$shipping_set = $order->get_meta('_vipps_shipping_set'); |
| 3601 |
if ($ready && $is_express_or_checkout && !$shipping_set) { |
| 3602 |
$token = $order->get_meta('_vipps_authtoken'); |
| 3603 |
$args = [ |
| 3604 |
'body' => [ |
| 3605 |
'order_id' => $order_id, |
| 3606 |
'vipps_order_data' => $data, |
| 3607 |
], |
| 3608 |
'headers' => [ |
| 3609 |
'X-WooVipps-Token' => $token, |
| 3610 |
], |
| 3611 |
]; |
| 3612 |
$url = Vipps::get_rest_url('v1', '/order-set-shipping'); |
| 3613 |
$response = wp_remote_post($url, $args); |
| 3614 |
if (is_wp_error($response)) { |
| 3615 |
/* translators: order id, error message */ |
| 3616 |
$error_msg = $response->get_error_message(); |
| 3617 |
$this->log(sprintf(__('Process callback action failed to finalize shipping through http rest endpoint for order %1$s: %2$s', 'woo-vipps'), $order->get_id(), $error_msg), 'error'); |
| 3618 |
} else if (200 != ($response['response']['code'] ?? -1)) { |
| 3619 |
/* translators: order id */ |
| 3620 |
$response_msg = print_r($response['body'] ?? ['Missing response body'], true); |
| 3621 |
$this->log(sprintf(__('Process callback action failed to finalize shipping through http rest endpoint for order %1$s: %2$s', 'woo-vipps'), $order->get_id(), $response_msg), 'error'); |
| 3622 |
} |
| 3623 |
} |
| 3624 |
|
| 3625 |
// This must happen *after* finalization for Express, as above. IOK 2026-05-06 |
| 3626 |
// the only status we now care about is AUTHORIZED. Previously we had AUTHORISED and RESERVED and RESERVE as well. And SALE. |
| 3627 |
if ($vippsstatus == 'AUTHORIZED') { |
| 3628 |
$this->payment_complete($order); |
| 3629 |
} else if ($vippsstatus == 'SALE') { |
| 3630 |
// Direct capture needs special handling because most of the meta values we use are missing IOK 2019-02-26 |
| 3631 |
// Actually not supported anymore, but keep logic. IOK 2025-08-13 |
| 3632 |
// Still supported for finnish direct bank transfer. IOK 2026-04-22 |
| 3633 |
$order->add_order_note(sprintf(__('Payment captured directly at %1$s', 'woo-vipps'), $this->get_payment_method_name())); |
| 3634 |
$order->payment_complete(); |
| 3635 |
$this->update_vipps_payment_details($order); |
| 3636 |
} else { |
| 3637 |
// Not ok status; set to failed/cancelled |
| 3638 |
$order_is_retryable = $allow_retry && Vipps::order_is_vipps_retryable($order->get_id()); |
| 3639 |
$status_on_fail = $this->get_option('status_on_fail'); |
| 3640 |
$cancel_on_fail = apply_filters('woo_vipps_cancel_failed_orders', false, $order, $vippsstatus); |
| 3641 |
if ($cancel_on_fail || !$order_is_retryable) { |
| 3642 |
$status_on_fail = 'cancelled'; |
| 3643 |
} |
| 3644 |
if (!in_array($status_on_fail, ['cancelled', 'failed'])) { |
| 3645 |
/* translators: %1 = order status parameter. 'cancelled' is woocommerce order status name */ |
| 3646 |
$this->log(__('Unsupported status for payment failure of \'%1$s\', falling back to cancelled.', 'woo-vipps'), 'warning'); |
| 3647 |
$status_on_fail = 'cancelled'; |
| 3648 |
} |
| 3649 |
|
| 3650 |
/* translators: company name */ |
| 3651 |
$order->update_status($status_on_fail, sprintf(__('Callback: Payment cancelled at %1$s.', 'woo-vipps'), Vipps::CompanyName())); |
| 3652 |
} |
| 3653 |
|
| 3654 |
$order->save(); |
| 3655 |
clean_post_cache($order_id); |
| 3656 |
} |
| 3657 |
|
| 3658 |
/* finalize shipping for express/checkout order. LP 2026-03-30 */ |
| 3659 |
public function rest_order_set_shipping($request) { |
| 3660 |
$order_id = $request->get_param('order_id'); |
| 3661 |
$data = $request->get_param('vipps_order_data'); |
| 3662 |
|
| 3663 |
$order = wc_get_order($order_id); |
| 3664 |
if (!is_a($order, 'WC_Order')) { |
| 3665 |
return new WP_Error('order_not_found', __('Order not found', 'woo-vipps'), ['status' => 404]); |
| 3666 |
} |
| 3667 |
|
| 3668 |
$is_express_or_checkout = $order->get_meta('_vipps_express_checkout'); |
| 3669 |
$shipping_set = $order->get_meta('_vipps_shipping_set'); |
| 3670 |
if (!$is_express_or_checkout || $shipping_set) { |
| 3671 |
return new WP_Error('order_is_finalized', __('Order does not need to set shipping', 'woo-vipps'), ['status' => 409]); |
| 3672 |
} |
| 3673 |
|
| 3674 |
// Ensure we use the same session as for the original order from here on. IOK 2019-10-21 |
| 3675 |
// IOK 2023-07-18 but because of the race condition issue, we cannot guarantee that any changes |
| 3676 |
// made to the session here will be saved. Sorry. |
| 3677 |
// UPDATE: Should be no more race condition since we moved callback into the action scheduler, and this shipping finalization into this rest endpoint. LP 2026-03-30 |
| 3678 |
Vipps::instance()->callback_restore_session($order_id); |
| 3679 |
|
| 3680 |
// For Vipps Checkout version 3 there are no more userDetails, so we will add it, including defaults for anonymous purchases IOK 2023-01-10 |
| 3681 |
// This will also normalize userDetails, adding 'sub' where possible and fields for backwards compatibility. 2025-08-12 |
| 3682 |
$data = $this->ensure_userDetails($data, $order); |
| 3683 |
|
| 3684 |
// Some Express Checkout orders aren't really express checkout orders, but normal orders to which we have |
| 3685 |
// added scope name, email, phoneNumber. The reason is that we don't care about the address. But then |
| 3686 |
// we also get no user data in the callback, so we must replace the callback with a user info call. IOK 2023-03-10 |
| 3687 |
// IOK 2025-09-29: This is probably *no longer true* - we now almost certainly *always* get a userDetails field if |
| 3688 |
// we have added a scope of any kind. This is therefore probably dead code. |
| 3689 |
// This being dead code, we'll not try to handle errors gracefully here. IOK 2026-03-18 |
| 3690 |
if (!isset($data['userDetails'])) { |
| 3691 |
// This also calls ensure_userDetails and normalizeShippingDetails - but NB: it could fail, so call only when neccessary. |
| 3692 |
try { |
| 3693 |
$details = $this->get_payment_details($order); |
| 3694 |
$data = $details; |
| 3695 |
} catch (Exception $e) { |
| 3696 |
$this->log(sprintf(__("Could not get payment results for order %1\$s", 'woo-vipps'), $order->get_id())); |
| 3697 |
$this->log($e->getMessage()); |
| 3698 |
} |
| 3699 |
} |
| 3700 |
|
| 3701 |
// Epayment Express Checkout is of course also significantly different from both the old Express and from Checkout in the formatting here. IOK 2025-08-12 |
| 3702 |
$data = $this->normalizeShippingDetails($data, $order); |
| 3703 |
|
| 3704 |
// We should now always have shipping details. |
| 3705 |
if (isset($data['shippingDetails'])) { |
| 3706 |
$billing = isset($data['billingDetails']) ? $data['billingDetails'] : false; |
| 3707 |
$this->set_order_shipping_details($order,$data['shippingDetails'], $data['userDetails'], $billing, $data); |
| 3708 |
} |
| 3709 |
} |
| 3710 |
|
| 3711 |
// Do the 'payment_complete' logic for non-SALE orders IOK 2020-09-22 |
| 3712 |
public function payment_complete($order,$transactionid='') { |
| 3713 |
// Orders not needing processing can be autocaptured, so try to do so now. |
| 3714 |
$autocapture = $this->maybe_complete_payment($order); |
| 3715 |
if (!$autocapture) { |
| 3716 |
add_filter('woocommerce_payment_complete_order_status', |
| 3717 |
function ($status, $orderid, $order) { |
| 3718 |
return $this->after_vipps_order_status($order); |
| 3719 |
}, 99, 3); |
| 3720 |
$order->add_order_note(sprintf(__('Payment authorized at %1$s', 'woo-vipps'), $this->get_payment_method_name())); |
| 3721 |
} |
| 3722 |
$order->payment_complete(); |
| 3723 |
} |
| 3724 |
|
| 3725 |
// Hook run by Woo after order is complete (authorized or sale). We'll add receipt info etc here. |
| 3726 |
public function order_payment_complete ($orderid) { |
| 3727 |
$order = wc_get_order($orderid); |
| 3728 |
if (!is_a($order, 'WC_Order')) return false; |
| 3729 |
if (! Vipps::is_vipps_order($order)) return false; |
| 3730 |
|
| 3731 |
$do_order_management = apply_filters('woo_vipps_order_management_on_payment_complete', true, $orderid); |
| 3732 |
if (!$do_order_management) return; |
| 3733 |
|
| 3734 |
// We do the actual order management call in a separate request which we call non-blocking to avoid it locking |
| 3735 |
// up the users' session on return from the store. This won't work if your Wordpress doesn't support non-blocking calls, |
| 3736 |
// so in this case, allow the user to set a longer timeout (5 seconds should be plenty.) IOK 2022-07-01 |
| 3737 |
// Yes, it will block until timeout even if non-blocking is set. IOK 2022-07-01 |
| 3738 |
$timeout = apply_filters('woo_vipps_asynch_timeout', 0.5); |
| 3739 |
$data = [ 'action'=> 'woo_vipps_order_management','orderid'=>$orderid, 'orderkey' => $order->get_order_key() ]; |
| 3740 |
$args = array( "method" => "POST", "body"=>$data, "timeout"=>$timeout, "blocking" => false); |
| 3741 |
$url = admin_url('admin-post.php'); |
| 3742 |
$asynch = wp_remote_request($url,$args); |
| 3743 |
if (is_wp_error($asynch)) { |
| 3744 |
$this->log(__("Error calling the Order Management API: %1\$s ", 'woo-vipps'), $asynch->get_error_message()); |
| 3745 |
} |
| 3746 |
} |
| 3747 |
|
| 3748 |
// The below actions *may* be long-running, and we can't be sure |
| 3749 |
// they will happen at callback-time. Some user may be affected, even if using wp-cron. |
| 3750 |
// We therefore set them up to be run at shutdown, as soon as payment complete is done |
| 3751 |
public function payment_complete_at_shutdown ($orderid, $orderkey) { |
| 3752 |
// Ensure consistent environment here |
| 3753 |
global $Vipps; |
| 3754 |
if (!$Vipps) $Vipps = Vipps::instance(); |
| 3755 |
$order = wc_get_order($orderid); |
| 3756 |
if (!is_a($order, 'WC_Order')) { |
| 3757 |
return false; |
| 3758 |
} |
| 3759 |
if (! Vipps::is_vipps_order($order)) return false; |
| 3760 |
if ($order->get_order_key() != wc_clean($orderkey)) { |
| 3761 |
return false; |
| 3762 |
} |
| 3763 |
try { |
| 3764 |
|
| 3765 |
$sendreceipt = apply_filters('woo_vipps_send_receipt', ($this->get_option('sendreceipts') == 'yes'), $order); |
| 3766 |
if ($sendreceipt) { |
| 3767 |
$this->api->add_receipt($order); |
| 3768 |
$this->order_add_vipps_categories($order); |
| 3769 |
} |
| 3770 |
do_action('woo_vipps_payment_complete_at_shutdown', $order, $this); |
| 3771 |
} catch (Exception $e) { |
| 3772 |
// This is/should be non-critical so just log it. |
| 3773 |
$this->log(sprintf(__("Could not do all payment-complete actions on %1\$s order %2\$d: %3\$s ", 'woo-vipps'), Vipps::CompanyName(), $orderid, $e->etMessage()), "error"); |
| 3774 |
} |
| 3775 |
} |
| 3776 |
|
| 3777 |
// This is run on payment complete. Per default will it only add a link to the order confirmation page, but |
| 3778 |
// the hook added should be used if selling tickets, bookings etc to add these to the Vipps app receipt; with images if desired (eg. QR images). |
| 3779 |
public function order_add_vipps_categories ($order) { |
| 3780 |
if (!is_a($order, 'WC_Order')) return; |
| 3781 |
|
| 3782 |
$none = ['link'=>null, 'image'=>null, 'imagesize'=>null]; |
| 3783 |
$orderconfirmation = ['link' => $this->get_return_url($order), 'image' => null, 'imagesize'=>null]; |
| 3784 |
|
| 3785 |
$receipt_image = $this->get_option('receiptimage'); |
| 3786 |
if ($receipt_image) { |
| 3787 |
$orderconfirmation['image'] = intval($receipt_image); |
| 3788 |
$orderconfirmation['imagesize'] = 'full'; |
| 3789 |
} |
| 3790 |
|
| 3791 |
// Do these in this order, in case we get terminated at some point during processing |
| 3792 |
$default = ['TICKET'=>$none,'ORDER_CONFIRMATION' => $orderconfirmation, 'RECEIPT' => $none,"BOOKING" => $none, "DELIVERY" => $none, "GENERAL" => $none]; |
| 3793 |
$categories = apply_filters('woo_vipps_add_order_categories', $default, $order, $this); |
| 3794 |
|
| 3795 |
foreach ($categories as $category=>$data) { |
| 3796 |
if ($data['link']) { |
| 3797 |
$this->order_add_vipps_category($category, $order, $data['link'], $data['image'], $data['imagesize']); |
| 3798 |
} |
| 3799 |
// Let people handle this in other ways if not using filter above IOK 2022-07-01 |
| 3800 |
do_action('woo_vipps_add_order_category', $category, $order, $this); |
| 3801 |
|
| 3802 |
} |
| 3803 |
} |
| 3804 |
|
| 3805 |
// Use the Order Management API to add a link with a category name and an optional image, which is viewable in the order. |
| 3806 |
public function order_add_vipps_category($categoryname, $order, $link, $image=null, $imagesize='medium') { |
| 3807 |
$imageid = $image ? $this->add_vipps_image($image, $imagesize) : null; |
| 3808 |
return $this->api->add_category($order, $link, $imageid, $categoryname); |
| 3809 |
} |
| 3810 |
|
| 3811 |
// Use the Order Management API to upload an image that can be attached to the order. |
| 3812 |
public function add_vipps_image ($imagespec, $size = 'medium') { |
| 3813 |
// Imagespec is an attachmend id (of an image) or a filename (to an image), and a size if using an attachment id. |
| 3814 |
$filename = null; |
| 3815 |
$imageid = 0; |
| 3816 |
$imagefile = ""; |
| 3817 |
$mime = ""; |
| 3818 |
$accepted_types = ["image/jpeg", "image/png", "image/jpg"]; // Only accepted types at Vipps |
| 3819 |
$vippsid = null; |
| 3820 |
$uploads = wp_get_upload_dir(); |
| 3821 |
|
| 3822 |
if (is_numeric($imagespec)) { |
| 3823 |
// Don't send same image twice if we have an id |
| 3824 |
$stored = get_post_meta($imagespec, '_vipps_imageid', true); |
| 3825 |
if ($stored && !$this->is_test_mode()) { |
| 3826 |
return $stored; |
| 3827 |
} |
| 3828 |
$imageid = intval($imagespec); |
| 3829 |
$imagefile = get_attached_file($imageid); |
| 3830 |
$mime = get_post_mime_type($imageid); |
| 3831 |
} |
| 3832 |
|
| 3833 |
if (!is_file($imagefile) || !in_array($mime, $accepted_types)) { |
| 3834 |
$this->log(sprintf(__('%1$s is not an image that can be uploaded to %2$s', 'woo-vipps'), $imagefile, Vipps::CompanyName()), 'error'); |
| 3835 |
$this->log(sprintf(__('File type was %1$s; supported types are %2$s', 'woo-vipps'), $mime, join(", ", $accepted_types)), 'error'); |
| 3836 |
return null; |
| 3837 |
} |
| 3838 |
|
| 3839 |
if ($imageid) { |
| 3840 |
$intermediate = image_get_intermediate_size($imageid, $size); |
| 3841 |
if ($intermediate && isset($intermediate['path'])) { |
| 3842 |
$imagefile = join(DIRECTORY_SEPARATOR, [$uploads['basedir'] , $intermediate['path']]); |
| 3843 |
} |
| 3844 |
} |
| 3845 |
|
| 3846 |
if ($imagefile) { |
| 3847 |
// Check image dimensions before uploading |
| 3848 |
$dimensions = getimagesize($imagefile); |
| 3849 |
if ($dimensions && $dimensions[1] < 167) { // [1] is height |
| 3850 |
$this->log(sprintf(__('Image %1$s is too small - height %2$dpx (minimum 167px required)', 'woo-vipps'), |
| 3851 |
$imagefile, $dimensions[1]), 'error'); |
| 3852 |
return null; |
| 3853 |
} |
| 3854 |
|
| 3855 |
$vippsid = $this->api->add_image($imagefile); |
| 3856 |
if ($vippsid) { |
| 3857 |
update_post_meta($imageid, '_vipps_imageid', $vippsid); |
| 3858 |
} |
| 3859 |
} |
| 3860 |
return $vippsid; |
| 3861 |
} |
| 3862 |
|
| 3863 |
// For the express checkout mechanism, create a partial order without shipping details by simulating checkout->create_order(); |
| 3864 |
// IOK 2018-05-25 |
| 3865 |
public function create_partial_order($ischeckout=false) { |
| 3866 |
// This is neccessary for some plugins, like Yith Dynamic Pricing, that adds filters to get_price depending on whether or not ischeckout is true. |
| 3867 |
// so basically, since we are impersonating WC_Checkout here, we should define this constant too. IOK 2020-07-03 |
| 3868 |
wc_maybe_define_constant('WOOCOMMERCE_CHECKOUT', true ); |
| 3869 |
|
| 3870 |
// In *some* cases you may need to actually load classes and reload the cart, because some plugins do not load when DOING_AJAX. |
| 3871 |
do_action('woo_vipps_express_checkout_before_calculate_totals'); |
| 3872 |
WC()->cart->calculate_fees(); |
| 3873 |
WC()->cart->calculate_totals(); |
| 3874 |
do_action('woo_vipps_before_create_express_checkout_order', WC()->cart); |
| 3875 |
|
| 3876 |
// We store this in the order so we don't have to access the cart when initiating payment. This allows us to restart orders etc. |
| 3877 |
$needs_shipping = WC()->cart->needs_shipping(); |
| 3878 |
|
| 3879 |
$contents = WC()->cart->get_cart_contents(); |
| 3880 |
$contents = apply_filters('woo_vipps_create_express_checkout_cart_contents',$contents); |
| 3881 |
try { |
| 3882 |
$cart_hash = md5(json_encode(wc_clean($contents)) . WC()->cart->total); |
| 3883 |
$order = new WC_Order(); |
| 3884 |
$order->set_status('pending'); |
| 3885 |
$order->set_payment_method($this); |
| 3886 |
if ($ischeckout) { |
| 3887 |
$order->update_meta_data('_vipps_api', 'epayment'); |
| 3888 |
$order->set_payment_method_title('Vipps Checkout'); |
| 3889 |
} else { |
| 3890 |
$order->set_payment_method_title('Vipps Express Checkout'); |
| 3891 |
} |
| 3892 |
// We use 'checkout' as the created_via key as per requests, but allow merchants to use their own. IOK 2022-09-15 |
| 3893 |
$created_via = apply_filters('woo_vipps_express_checkout_created_via', 'checkout', $order, $ischeckout); |
| 3894 |
$order->set_created_via($created_via); |
| 3895 |
|
| 3896 |
$dummy = sprintf(__('Vipps Express Checkout', 'woo-vipps')); // this is so gettext will find this string. |
| 3897 |
$dummy = sprintf(__('Vipps Checkout', 'woo-vipps')); // this is so gettext will find this string. |
| 3898 |
|
| 3899 |
$order->update_meta_data('_vipps_express_checkout',1); |
| 3900 |
|
| 3901 |
# To help with address fields, scope etc in inititate payment |
| 3902 |
$order->update_meta_data('_vipps_needs_shipping', $needs_shipping); |
| 3903 |
|
| 3904 |
$order->set_customer_id( apply_filters('woocommerce_checkout_customer_id', get_current_user_id() ) ); |
| 3905 |
$order->set_currency( get_woocommerce_currency() ); |
| 3906 |
$order->set_prices_include_tax('yes' === get_option('woocommerce_prices_include_tax') ); |
| 3907 |
$order->set_customer_ip_address( WC_Geolocation::get_ip_address() ); |
| 3908 |
$order->set_customer_user_agent( wc_get_user_agent() ); |
| 3909 |
$order->set_discount_total( WC()->cart->get_discount_total()); |
| 3910 |
$order->set_discount_tax( WC()->cart->get_discount_tax() ); |
| 3911 |
$order->set_cart_tax( WC()->cart->get_cart_contents_tax() + WC()->cart->get_fee_tax() ); |
| 3912 |
|
| 3913 |
// Use these methods directly - they should be safe. |
| 3914 |
WC()->checkout->create_order_line_items( $order, WC()->cart); |
| 3915 |
WC()->checkout->create_order_fee_lines( $order, WC()->cart); |
| 3916 |
WC()->checkout->create_order_tax_lines( $order, WC()->cart); |
| 3917 |
WC()->checkout->create_order_coupon_lines( $order, WC()->cart); |
| 3918 |
do_action('woo_vipps_before_calculate_totals_partial_order', $order); |
| 3919 |
$order->calculate_totals(true); |
| 3920 |
|
| 3921 |
// Added to support third-party plugins that wants to do stuff with the order before it is saved. IOK 2020-07-03 |
| 3922 |
do_action('woocommerce_checkout_create_order', $order, array()); |
| 3923 |
|
| 3924 |
$orderid = $order->save(); |
| 3925 |
|
| 3926 |
do_action('woo_vipps_express_checkout_order_created', $orderid); |
| 3927 |
|
| 3928 |
// Normally done by the WC_Checkout::create_order method, so call it here too. IOK 2018-11-19 |
| 3929 |
do_action('woocommerce_checkout_update_order_meta', $orderid, array()); |
| 3930 |
|
| 3931 |
// It isn't possible to remove the javascript or 'after order notice' actions, because these are added as closures |
| 3932 |
// before anything else is run. But we can disable the hook that saves data. IOK 2024-01-18 |
| 3933 |
if (WC_Gateway_Vipps::instance()->get_option('vippsorderattribution') != 'yes') { |
| 3934 |
remove_all_filters( 'woocommerce_order_save_attribution_data'); |
| 3935 |
} |
| 3936 |
|
| 3937 |
// And another one. IOK 2021-11-24 |
| 3938 |
do_action('woocommerce_checkout_order_created', $order ); |
| 3939 |
} catch ( Exception $e ) { |
| 3940 |
if ( $order && $order instanceof WC_Order ) { |
| 3941 |
$order->get_data_store()->release_held_coupons( $order ); |
| 3942 |
do_action('woocommerce_checkout_order_exception', $order ); |
| 3943 |
} |
| 3944 |
// Any errors gets passed upstream IOK 2021-11-24 |
| 3945 |
throw $e; |
| 3946 |
} |
| 3947 |
return $orderid; |
| 3948 |
} |
| 3949 |
|
| 3950 |
// The order attribution subsystem of Woo requires extra work for our partial orders. IOK 2024-01-09 |
| 3951 |
// The attribution data is added to the order forms with prefixes (after 'order note') and we need to strip the prefix. |
| 3952 |
public function get_order_attribution_data($input_data) { |
| 3953 |
$prefix = (string) apply_filters( 'wc_order_attribution_tracking_field_prefix', 'wc_order_attribution_'); |
| 3954 |
$prefix = trim( $prefix, '_' ) . "_"; |
| 3955 |
$len = strlen($prefix); |
| 3956 |
$params = []; |
| 3957 |
foreach($input_data as $key=>$val) { |
| 3958 |
$found = strpos($key, $prefix); |
| 3959 |
if ($found === 0) { |
| 3960 |
$paramkey = substr($key, $len); |
| 3961 |
$params[$paramkey] = $val; |
| 3962 |
} |
| 3963 |
} |
| 3964 |
return $params; |
| 3965 |
} |
| 3966 |
|
| 3967 |
public function save_session_in_order($order) { |
| 3968 |
// The callbacks from Vipps carry no session cookie, so we must store this in the order and use a special session handler when in a callback. |
| 3969 |
// The Vipps class will restore the session from this on callbacks. |
| 3970 |
// IOK 2019-10-21 |
| 3971 |
$sessioncookie = array(); |
| 3972 |
$sessionhandler = WC()->session; |
| 3973 |
if ($sessionhandler && is_a($sessionhandler, 'WC_Session_Handler')) { |
| 3974 |
// If customer is actually logged in, take note IOK 2019-10-25 |
| 3975 |
WC()->session->set('express_customer_id',get_current_user_id()); |
| 3976 |
WC()->session->save_data(); |
| 3977 |
$sessioncookie=$sessionhandler->get_session_cookie(); |
| 3978 |
} else { |
| 3979 |
// This actually can't happen. IOK 2020-04-08. Branch added for debugging only. |
| 3980 |
} |
| 3981 |
|
| 3982 |
if (!empty($sessioncookie)) { |
| 3983 |
// Customer id, session expiration, session-epiring and cookie-hash is the contents. IOK 2019-10-21 |
| 3984 |
$order->update_meta_data('_vipps_sessiondata',json_encode($sessioncookie)); |
| 3985 |
$order->save(); |
| 3986 |
} |
| 3987 |
|
| 3988 |
} |
| 3989 |
|
| 3990 |
// Using this internally to allow the 'enable' button or not. Checks SSL in addition to currency, |
| 3991 |
// is valid_for_use can in principle run on a http version of the page; we only need to have https accessible for callbacks, |
| 3992 |
// but if so, admin should definitely be HTTPS so we just check that. IOK 2018-06-06 |
| 3993 |
public function can_be_activated () { |
| 3994 |
if (!is_ssl() && !preg_match("!^https!i",home_url())) return false; |
| 3995 |
return true; |
| 3996 |
} |
| 3997 |
|
| 3998 |
// Used by the ajax thing that 'sets activated' - checks that it can be activated and that all keys are present. IOK 2018-06-06 |
| 3999 |
function needs_setup() { |
| 4000 |
if (!$this->can_be_activated()) return true; |
| 4001 |
$required = array('merchantSerialNumber','clientId', 'secret', 'Ocp_Apim_Key_eCommerce'); |
| 4002 |
foreach ($required as $key) { |
| 4003 |
if (!$this->get_option($key)) return true; |
| 4004 |
} |
| 4005 |
return false; |
| 4006 |
} |
| 4007 |
|
| 4008 |
// Not present in WooCommerce until 3.4.0. Should be deleted when required versions are incremented. IOK 2018-10-26 |
| 4009 |
public function update_option( $key, $value = '') { |
| 4010 |
if ( empty( $this->settings ) ) { |
| 4011 |
$this->init_settings(); |
| 4012 |
} |
| 4013 |
$this->settings[ $key ] = $value; |
| 4014 |
return update_option( $this->get_option_key(), apply_filters('woocommerce_settings_api_sanitized_fields_' . $this->id, $this->settings ), 'yes'); |
| 4015 |
} |
| 4016 |
|
| 4017 |
|
| 4018 |
public function admin_options() { |
| 4019 |
$currency = get_woocommerce_currency(); |
| 4020 |
$payment_method = $this->get_payment_method_name(); |
| 4021 |
|
| 4022 |
if (!$this->can_be_activated()) { |
| 4023 |
$this->update_option('enabled', 'no'); |
| 4024 |
} |
| 4025 |
|
| 4026 |
if ($payment_method != "Vipps"): ?> |
| 4027 |
<style> |
| 4028 |
#woocommerce_vipps_express_options, #woocommerce_vipps_express_options-table { |
| 4029 |
display: none; |
| 4030 |
} |
| 4031 |
</style> |
| 4032 |
<?php endif; ?> |
| 4033 |
|
| 4034 |
<h2 id='vipps-settings-page'><?php echo __(Vipps::CompanyName(),'woo-vipps'); ?> <img style="float:right;max-height:40px;margin-top:-15px" alt="<?php _e($this->title,'woo-vipps'); ?>" src="<?php echo $this->icon; ?>"></h2> |
| 4035 |
<?php $this->display_errors(); ?> |
| 4036 |
|
| 4037 |
<?php |
| 4038 |
|
| 4039 |
|
| 4040 |
if (!$this->payment_method_supports_currency($payment_method, $currency)): |
| 4041 |
?> |
| 4042 |
<div class="inline error"> |
| 4043 |
<p><strong><?php echo sprintf(__('%1$s does not support your currency.', 'woo-vipps'), $payment_method); ?></strong> |
| 4044 |
<br> |
| 4045 |
<?php echo sprintf(__('%1$s supported currencies: %2$s', 'woo-vipps'), $payment_method, implode(", ", $this->get_supported_currencies($payment_method))); ?> |
| 4046 |
</p> |
| 4047 |
</div> |
| 4048 |
<?php endif; ?> |
| 4049 |
|
| 4050 |
<?php if (!is_ssl() && !preg_match("!^https!i",home_url())): ?> |
| 4051 |
<div class="inline error"> |
| 4052 |
<p><strong><?php _e('Gateway disabled', 'woocommerce'); ?></strong>: |
| 4053 |
<?php echo sprintf(__('%1$s requires that your site uses HTTPS.', 'woo-vipps'), $payment_method); ?> |
| 4054 |
</p> |
| 4055 |
</div> |
| 4056 |
<?php endif; ?> |
| 4057 |
|
| 4058 |
<?php // We will only show the Vipps Checkout options if the user has activated the feature (thus creating the pages involved etc). IOK 2021-10-01 |
| 4059 |
$vipps_checkout_activated = get_option('woo_vipps_checkout_activated', false); |
| 4060 |
?> |
| 4061 |
|
| 4062 |
<?php /* We will *not* allow vipps checkout to be activated at this point, since the product is no longer sold. IOK 2026-04-30 */ ?> |
| 4063 |
<?php if (!$vipps_checkout_activated): ?> |
| 4064 |
|
| 4065 |
<?php endif; ?> |
| 4066 |
<table class="form-table"> |
| 4067 |
<?php $this->generate_settings_html(); ?> |
| 4068 |
</table> <?php |
| 4069 |
} |
| 4070 |
|
| 4071 |
// Validate/mangle input fields |
| 4072 |
function validate_text_field ($key, $value) { |
| 4073 |
if ($key != 'orderprefix') return parent::validate_text_field($key,$value); |
| 4074 |
$value = preg_replace('![^a-zA-Z0-9]!','',$value); |
| 4075 |
return $value; |
| 4076 |
} |
| 4077 |
function validate_checkbox_field($key,$value) { |
| 4078 |
if ($key == 'testmode' && VIPPS_TEST_MODE) { |
| 4079 |
return "yes"; |
| 4080 |
} else if ($key == 'developermode' && VIPPS_TEST_MODE) { |
| 4081 |
return "yes"; |
| 4082 |
} else if ($key == 'enabled') { |
| 4083 |
if ($value && $this->can_be_activated()) return 'yes'; |
| 4084 |
return "no"; |
| 4085 |
} |
| 4086 |
return parent::validate_checkbox_field($key,$value); |
| 4087 |
} |
| 4088 |
|
| 4089 |
function process_admin_options () { |
| 4090 |
// Handle options updates |
| 4091 |
$saved = parent::process_admin_options(); |
| 4092 |
// We may have changed the number of form fields at this point if dev mode was changed |
| 4093 |
// from off to on,so re-initialize the form fields here. IOK 2019-09-03 |
| 4094 |
$this->init_form_fields(); |
| 4095 |
|
| 4096 |
// Reinitialize keysets in case user added/changed these |
| 4097 |
$this->keyset = null; |
| 4098 |
delete_transient('_vipps_keyset'); |
| 4099 |
$keyset = $this->get_keyset(); |
| 4100 |
|
| 4101 |
// IOK FIXME check if we are called using ajax for this; and if so add the notifications to a list of notifications |
| 4102 |
// instead of doing the adminerr/adminnotify thing. IOK 2024-01-03 |
| 4103 |
|
| 4104 |
list($ok,$msg) = $this->check_connection(); |
| 4105 |
if ($ok) { |
| 4106 |
$this->adminnotify(sprintf(__("Connection to %1\$s is OK", 'woo-vipps'), Vipps::CompanyName())); |
| 4107 |
} else { |
| 4108 |
$this->adminerr(sprintf(__("Could not connect to %1\$s", 'woo-vipps'), Vipps::CompanyName()) . ": $msg"); |
| 4109 |
} |
| 4110 |
|
| 4111 |
if ($ok) { |
| 4112 |
$this->check_webhooks(); |
| 4113 |
// Try to ensure we have webhooks defined for the epayment-api IOK 2023-12-19 |
| 4114 |
$hooks = $this->initialize_webhooks(); |
| 4115 |
} |
| 4116 |
|
| 4117 |
// If enabling this, ensure the page in question exists |
| 4118 |
if ($this->get_option('vipps_checkout_enabled') == 'yes') { |
| 4119 |
update_option('woo_vipps_checkout_activated', true, true); // This must be true here, but still, make sure |
| 4120 |
Vipps::instance()->maybe_create_vipps_pages(); |
| 4121 |
} |
| 4122 |
|
| 4123 |
return $saved; |
| 4124 |
} |
| 4125 |
|
| 4126 |
// Check our stored webhooks for consistency, which means the callback URLs should point to *this* site. If they don't, |
| 4127 |
// delete all the ones pointing wrong. If this returns false, you should reinitialize the webhooks. IOK 2023-12-20 |
| 4128 |
public function check_webhooks () { |
| 4129 |
$local_hooks = get_option('_woo_vipps_webhooks'); |
| 4130 |
if (!$local_hooks) return false; |
| 4131 |
|
| 4132 |
$callback = $this->webhook_callback_url(); |
| 4133 |
$callback_compare = strtok($callback, '?'); |
| 4134 |
$problems = false; |
| 4135 |
|
| 4136 |
// We are going to re-initialize our webhooks after this, but just to ensure we're not keeping any 'stale' hooks, |
| 4137 |
// we'll update the local hooks too. IOK 2025-02-13 |
| 4138 |
$change = false; |
| 4139 |
$msns = array_keys($local_hooks); |
| 4140 |
foreach($msns as $msn) { |
| 4141 |
$hooks = $local_hooks[$msn]; |
| 4142 |
$ids = array_keys($hooks); |
| 4143 |
foreach ($ids as $id) { |
| 4144 |
$hook = $hooks[$id]; |
| 4145 |
$noargs = strtok($hook['url'], '?'); |
| 4146 |
if ($noargs == $callback_compare) continue; // This hook is good, probably, unless somebody has deleted it |
| 4147 |
try { |
| 4148 |
$this->log(sprintf(__("For msn %s we have a webhook %s %s which is pointed the wrong way (%s) for this website", 'woo-vipps'), $msn, $hook['id'], $hook['url'], $callback_compare)); |
| 4149 |
$this->api->delete_webhook($msn, $hook['id']); // This isn't - it's pointed the wrong way, which means we have changed name of the site or something |
| 4150 |
} catch (Exception $e) { |
| 4151 |
$this->log(sprintf(__("Could not delete webhook for this site with url '%2\$s' : %1\$s", 'woo-vipps'), $e->getMessage(), $noargs), 'error'); |
| 4152 |
} |
| 4153 |
unset($hooks[$id]); |
| 4154 |
$change = true; |
| 4155 |
$problems = true; |
| 4156 |
} |
| 4157 |
|
| 4158 |
if ($change) { |
| 4159 |
if (empty($hooks)) { |
| 4160 |
unset($local_hooks[$msn]); |
| 4161 |
} else { |
| 4162 |
$local_hooks[$msn] = $hooks; |
| 4163 |
} |
| 4164 |
} |
| 4165 |
} |
| 4166 |
|
| 4167 |
if ($change) { |
| 4168 |
update_option('_woo_vipps_webhooks', $local_hooks, true); |
| 4169 |
} |
| 4170 |
|
| 4171 |
if ($problems) return false; |
| 4172 |
return true; |
| 4173 |
} |
| 4174 |
|
| 4175 |
// Returns the local webhooks for the given msn. If the url has changed, it will return nothing. IOK 2023-12-19 |
| 4176 |
public function get_local_webhook($msn) { |
| 4177 |
$local_hooks = get_option('_woo_vipps_webhooks'); |
| 4178 |
$hooks = $local_hooks[$msn] ?? []; |
| 4179 |
$callback = $this->webhook_callback_url(); |
| 4180 |
$callback_compare = strtok($callback, '?'); |
| 4181 |
|
| 4182 |
foreach ($hooks as $id=>$hook) { |
| 4183 |
$noargs = strtok($hook['url'], '?'); |
| 4184 |
if ($noargs == $callback_compare) { |
| 4185 |
return $hook; |
| 4186 |
} else { |
| 4187 |
// May want to log this somehow |
| 4188 |
} |
| 4189 |
} |
| 4190 |
return null; |
| 4191 |
} |
| 4192 |
|
| 4193 |
|
| 4194 |
// This is to be used in deactivate/uninstall - it deletes all webhooks for all MSNs for this instance |
| 4195 |
// Unfortunatetly, we can't delete other msn's webhooks or webhooks pointing to other URLs. IOK 2023-12-20 |
| 4196 |
public function delete_all_webhooks() { |
| 4197 |
delete_option('_woo_vipps_webhooks'); |
| 4198 |
$callback = $this->webhook_callback_url(); |
| 4199 |
$comparandum = strtok($callback, '?'); |
| 4200 |
$all_hooks = $this->get_webhooks_from_vipps(); |
| 4201 |
foreach($all_hooks as $msn => $data) { |
| 4202 |
$hooks = $data['webhooks'] ?? []; |
| 4203 |
foreach ($hooks as $hook) { |
| 4204 |
$id = $hook['id']; |
| 4205 |
$url = $hook['url']; |
| 4206 |
$noargs = strtok($url, '?'); |
| 4207 |
if ($noargs != $comparandum) continue; // Some other shops hook, we will ignore it |
| 4208 |
$ok = $this->api->delete_webhook($msn,$id); |
| 4209 |
} |
| 4210 |
} |
| 4211 |
} |
| 4212 |
|
| 4213 |
// This will initalize the webhooks for this instance, for all MSNs that are configured. |
| 4214 |
// Hooks that point to us that we *do not* know the secret for, have to be deleted. |
| 4215 |
public function initialize_webhooks() { |
| 4216 |
// IOK 2023-12-20 for the epayment api, we need to re-initialize webhooks at this point. |
| 4217 |
try { |
| 4218 |
return $this->initialize_webhooks_internal(); |
| 4219 |
} catch (Exception $e) { |
| 4220 |
$this->log(sprintf(__("Could not initialize webhooks for this site: %1\$s", 'woo-vipps'), $e->getMessage()), 'error'); |
| 4221 |
return []; |
| 4222 |
} |
| 4223 |
} |
| 4224 |
|
| 4225 |
private function initialize_webhooks_internal () { |
| 4226 |
$local_hooks = get_option('_woo_vipps_webhooks'); |
| 4227 |
$all_hooks = $this->get_webhooks_from_vipps(); |
| 4228 |
$ourselves = $this->webhook_callback_url(); |
| 4229 |
$keysets = $this->get_keyset(); |
| 4230 |
|
| 4231 |
// Ignore any extra arguments |
| 4232 |
$comparandum = strtok($ourselves, '?'); |
| 4233 |
|
| 4234 |
$change = false; |
| 4235 |
|
| 4236 |
// We may need to delete webhooks that have been orphaned. There should be exactly one |
| 4237 |
// for this sites' callback, and we need to know its secret. All others should be deleted. |
| 4238 |
$delenda = []; |
| 4239 |
|
| 4240 |
|
| 4241 |
foreach($all_hooks as $msn => $data) { |
| 4242 |
$hooks = $data['webhooks'] ?? []; |
| 4243 |
$gotit = false; |
| 4244 |
$locals = $local_hooks[$msn] ?? []; |
| 4245 |
|
| 4246 |
foreach ($hooks as $hook) { |
| 4247 |
$id = $hook['id']; |
| 4248 |
$url = $hook['url']; |
| 4249 |
$noargs = strtok($url, '?'); |
| 4250 |
if ($noargs != $comparandum) { |
| 4251 |
continue; // Some other shops hook, we will ignore it |
| 4252 |
} |
| 4253 |
$local = $locals[$id] ?? false; |
| 4254 |
|
| 4255 |
// If we haven't gotten our hook yet, but we have a local hook now that we know a secret for, note it and continue |
| 4256 |
if (!$gotit && $local && isset($local['secret'])) { |
| 4257 |
$gotit = $local; |
| 4258 |
continue; |
| 4259 |
} |
| 4260 |
// Now we have a hook for our own msn and url, but either we don't know the secret or it is a duplicate. It should be deleted. |
| 4261 |
$delenda[] = $id; |
| 4262 |
} |
| 4263 |
|
| 4264 |
// Delete all the webhooks for this msn that we don't want |
| 4265 |
foreach ($delenda as $wrong) { |
| 4266 |
$change = true; |
| 4267 |
$this->api->delete_webhook($msn,$wrong); |
| 4268 |
} |
| 4269 |
|
| 4270 |
if ($gotit) { |
| 4271 |
// Now if we got a hook, then we should *just* remember that for this msn. |
| 4272 |
$local_hooks[$msn] = array($gotit['id'] => $gotit); |
| 4273 |
} else { |
| 4274 |
// If not, we don't have a hook for this msn and site, so we need to (try to) create one |
| 4275 |
// but only if the MSN is registered for the payment gateway "vipps" ! IOK 2024-12-03 |
| 4276 |
$keys = $keysets[$msn] ?? []; |
| 4277 |
$gateway = $keys['gw'] ?? 'vipps'; |
| 4278 |
|
| 4279 |
if ($gateway == 'vipps') { |
| 4280 |
$change = true; |
| 4281 |
$result = $this->api->register_webhook($msn, $ourselves); |
| 4282 |
if ($result) { |
| 4283 |
$local_hooks[$msn] = [$result['id'] => ['id'=>$result['id'], 'url' => $ourselves, 'secret' => $result['secret']]]; |
| 4284 |
} |
| 4285 |
} |
| 4286 |
} |
| 4287 |
} |
| 4288 |
update_option('_woo_vipps_webhooks', $local_hooks, true); |
| 4289 |
|
| 4290 |
|
| 4291 |
if ($change) $all_hooks = $this->get_webhooks_from_vipps(); |
| 4292 |
|
| 4293 |
return $all_hooks; |
| 4294 |
} |
| 4295 |
|
| 4296 |
|
| 4297 |
// Checks connection of the 'main' MSN IOK 2023-12-19 |
| 4298 |
public function check_connection ($msn = null) { |
| 4299 |
if (!$msn) { |
| 4300 |
$msn = $this->get_merchant_serial(); |
| 4301 |
} |
| 4302 |
$at = $this->get_key($msn); |
| 4303 |
$s = $this->get_secret($msn); |
| 4304 |
$c = $this->get_clientid($msn); |
| 4305 |
if ($at && $s && $c) { |
| 4306 |
|
| 4307 |
|
| 4308 |
|
| 4309 |
try { |
| 4310 |
// First, test the client id / client secret which will give us an access token |
| 4311 |
$token = $this->api->get_access_token($msn,'force'); |
| 4312 |
if ($token) { |
| 4313 |
// Then, call the webhooks api to check if the msn/sub key is ok |
| 4314 |
try { |
| 4315 |
$this->api->get_webhooks_raw($msn); |
| 4316 |
update_option('woo-vipps-configured', 1, true); |
| 4317 |
return array(true,''); |
| 4318 |
} catch (Exception $e) { |
| 4319 |
$msg = $e->getMessage(); |
| 4320 |
if ($msg == "403 Forbidden") { |
| 4321 |
$msg= __("MSN or subscription key (or both) seem to be wrong: ", 'woo-vipps') . $msg; |
| 4322 |
} |
| 4323 |
update_option('woo-vipps-configured', 0, true); |
| 4324 |
return array(false, $msg); |
| 4325 |
} |
| 4326 |
} |
| 4327 |
|
| 4328 |
} catch (Exception $e) { |
| 4329 |
$msg = __("Your client key or secret is wrong.", 'woo-vipps'); |
| 4330 |
update_option('woo-vipps-configured', 0, true); |
| 4331 |
return array(false, $msg); |
| 4332 |
} |
| 4333 |
} |
| 4334 |
return array(false, ''); // No configuration |
| 4335 |
} |
| 4336 |
|
| 4337 |
public function log ($what,$type='info') { |
| 4338 |
$logger = function_exists('wc_get_logger') ? wc_get_logger() : false; |
| 4339 |
if ($logger) { |
| 4340 |
$context = array('source'=>'woo-vipps'); |
| 4341 |
$logger->log($type,$what,$context); |
| 4342 |
} else { |
| 4343 |
error_log("woo-vipps ($type): $what"); |
| 4344 |
} |
| 4345 |
} |
| 4346 |
|
| 4347 |
// Ensure chosen name gets used in the checkout page IOK 2018-09-12 |
| 4348 |
public function get_title() { |
| 4349 |
return apply_filters('woo_vipps_payment_method_title', $this->get_payment_method_name()); |
| 4350 |
} |
| 4351 |
|
| 4352 |
public function get_payment_method_name() { |
| 4353 |
return $this->get_option('payment_method_name'); |
| 4354 |
} |
| 4355 |
|
| 4356 |
public function payment_fields() { |
| 4357 |
// Use Billing Phone if it is required, otherwise ask for a phone IOK 2018-04-24 |
| 4358 |
// For v2 of the api, just let Vipps ask for then umber |
| 4359 |
// IOK 2019-09-12 removed dead code only used for v1 of api |
| 4360 |
// This just prints a description of the payment method. |
| 4361 |
print $this->get_option('description'); |
| 4362 |
return; |
| 4363 |
} |
| 4364 |
public function validate_fields() { |
| 4365 |
return true; |
| 4366 |
} |
| 4367 |
|
| 4368 |
|
| 4369 |
} |
| 4370 |
|
| 4371 |
|
