private $_payment_version = '1.2';

/**

protected $_requires_credit_card = false;

/**

protected $_supports_callbacks = false;

protected $authorization = array();

protected $redirect_url = '';

protected $current_feed = false;

protected $current_submission_data = false;

protected $is_payment_gateway = false;

//--------- Initialization ----------

public function pre_init() {

parent::pre_init();

// Intercepting callback requests

add_action( 'parse_request', array( $this, 'maybe_process_callback' ) );

if ( $this->payment_method_is_overridden( 'check_status' ) ) {

$this->setup_cron();

}

}

public function init() {

parent::init();

add_filter( 'gform_confirmation', array( $this, 'confirmation' ), 20, 4 );

add_filter( 'gform_validation', array( $this, 'validation' ), 20 );

add_filter( 'gform_entry_post_save', array( $this, 'entry_post_save' ), 10, 2 );

}

public function init_admin() {

parent::init_admin();

//enables credit card field

add_filter( 'gform_enable_credit_card_field', '__return_true' );

add_filter( 'gform_currencies', array( $this, 'supported_currencies' ) );

add_filter( 'gform_delete_lead', array( $this, 'entry_deleted' ) );

if ( rgget( 'page' ) == 'gf_entries' ) {

add_action( 'gform_payment_details', array( $this, 'entry_info' ), 10, 2 );

add_action( 'gform_enable_entry_info_payment_details', array( $this, 'disable_entry_info_payment' ), 10, 2 );

add_filter( 'gform_notes_avatar', array( $this, 'notes_avatar' ), 10, 2 );

}

}

public function init_ajax() {

parent::init_ajax();

add_action( 'wp_ajax_gaddon_cancel_subscription', array( $this, 'ajax_cancel_subscription' ) );

add_action( 'gform_before_delete_field', array( $this, 'before_delete_field' ), 10, 2 );

}

protected function setup() {

parent::setup();

$installed_version = get_option( 'gravityformsaddon_payment_version' );

$installed_addons = get_option( 'gravityformsaddon_payment_addons' );

if ( ! is_array( $installed_addons ) ) {

$installed_addons = array();

}

if ( $installed_version != $this->_payment_version ) {

$this->upgrade_payment( $installed_version );

$installed_addons = array( $this->_slug );

update_option( 'gravityformsaddon_payment_addons', $installed_addons );

} elseif ( ! in_array( $this->_slug, $installed_addons ) ) {

$this->upgrade_payment( $installed_version );

$installed_addons[] = $this->_slug;

update_option( 'gravityformsaddon_payment_addons', $installed_addons );

}

update_option( 'gravityformsaddon_payment_version', $this->_payment_version );

}

private function upgrade_payment( $previous_versions ) {

global $wpdb;

$charset_collate = GFFormsModel::get_db_charset();

$sql = "CREATE TABLE {$wpdb->prefix}gf_addon_payment_transaction (

) $charset_collate;";

GFFormsModel::dbDelta( $sql );

if ( $this->_supports_callbacks ) {

$sql = "CREATE TABLE {$wpdb->prefix}gf_addon_payment_callback (

) $charset_collate;";

GFFormsModel::dbDelta( $sql );

//droping legacy index

GFForms::drop_index( "{$wpdb->prefix}gf_addon_payment_callback", 'slug_callback_id' );

}

}

//--------- Submission Process ------

public function confirmation( $confirmation, $form, $entry, $ajax ) {

if ( empty( $this->redirect_url ) ) {

return $confirmation;

}

$confirmation = array( 'redirect' => $this->redirect_url );

return $confirmation;

}

/**

protected function redirect_url( $feed, $submission_data, $form, $entry ) {

}

public function validation( $validation_result ) {

if ( ! $validation_result['is_valid'] || ! GFFormDisplay::is_last_page( $validation_result['form'] ) ) {

return $validation_result;

}

$form = $validation_result['form'];

$entry = GFFormsModel::create_lead( $form );

$feed = $this->get_payment_feed( $entry, $form );

if ( ! $feed ) {

return $validation_result;

}

$submission_data = $this->get_submission_data( $feed, $form, $entry );

//Do not process payment if payment amount is 0

if ( floatval( $submission_data['payment_amount'] ) <= 0 ) {

$this->log_debug( __METHOD__ . '(): Payment amount is $0.00 or less. Not sending to payment gateway.' );

return $validation_result;

}

$this->is_payment_gateway = true;

$this->current_feed = $feed;

$this->current_submission_data = $submission_data;

$performed_authorization = false;

$is_subscription = $feed['meta']['transactionType'] == 'subscription';

if ( $this->payment_method_is_overridden( 'authorize' ) && ! $is_subscription ) {

//Running an authorization only transaction if function is implemented and this is a single payment

$this->authorization = $this->authorize( $feed, $submission_data, $form, $entry );

$performed_authorization = true;

} elseif ( $this->payment_method_is_overridden( 'subscribe' ) && $is_subscription ) {

$subscription = $this->subscribe( $feed, $submission_data, $form, $entry );

$this->authorization['is_authorized'] = $subscription['is_success'];

$this->authorization['error_message'] = rgar( $subscription, 'error_message' );

$this->authorization['subscription'] = $subscription;

$performed_authorization = true;

}

if ( $performed_authorization ) {

$this->log_debug( __METHOD__ . "(): Authorization result for form #{$form['id']} submission => " . print_r( $this->authorization, 1 ) );

}

if ( $performed_authorization && ! $this->authorization['is_authorized'] ) {

$validation_result = $this->get_validation_result( $validation_result, $this->authorization );

//Setting up current page to point to the credit card page since that will be the highlighted field

GFFormDisplay::set_current_page( $validation_result['form']['id'], $validation_result['credit_card_page'] );

}

return $validation_result;

}

/**

protected function authorize( $feed, $submission_data, $form, $entry ) {

}

/**

protected function capture( $authorization, $feed, $submission_data, $form, $entry ) {

}

/**

protected function subscribe( $feed, $submission_data, $form, $entry ) {

}

/**

protected function cancel( $entry, $feed ) {

return false;

}

protected function get_validation_result( $validation_result, $authorization_result ) {

$credit_card_page = 0;

foreach ( $validation_result['form']['fields'] as &$field ) {

if ( $field['type'] == 'creditcard' ) {

$field['failed_validation'] = true;

$field['validation_message'] = $authorization_result['error_message'];

$credit_card_page = $field['pageNumber'];

break;

}

}

$validation_result['credit_card_page'] = $credit_card_page;

$validation_result['is_valid'] = false;

return $validation_result;

}

public function entry_post_save( $entry, $form ) {

if ( ! $this->is_payment_gateway ) {

return $entry;

}

$feed = $this->current_feed;

if ( ! empty( $this->authorization ) ) {

//If an authorization was done, capture it

if ( $feed['meta']['transactionType'] == 'subscription' ) {

$entry = $this->process_subscription( $this->authorization, $feed, $this->current_submission_data, $form, $entry );

} else {

if ( $this->payment_method_is_overridden( 'capture' ) && rgempty( 'captured_payment', $this->authorization ) ) {

$this->authorization['captured_payment'] = $this->capture( $this->authorization, $feed, $this->current_submission_data, $form, $entry );

}

$entry = $this->process_capture( $this->authorization, $feed, $this->current_submission_data, $form, $entry );

}

} elseif ( $this->payment_method_is_overridden( 'redirect_url' ) ) {

//If the url_redirect() function is overridden, call it.

//Getting URL to redirect to ( saved to be used by the confirmation() function )

$this->redirect_url = $this->redirect_url( $feed, $this->current_submission_data, $form, $entry );

//Setting transaction_type to subscription or one time payment

$entry['transaction_type'] = rgars( $feed, 'meta/transactionType' ) == 'subscription' ? 2 : 1;

$entry['payment_status'] = 'Processing';

}

//Saving which gateway was used to process this entry

gform_update_meta( $entry['id'], 'payment_gateway', $this->_slug );

return $entry;

}

protected function process_capture( $authorization, $feed, $submission_data, $form, $entry ) {

$payment = rgar( $authorization, 'captured_payment' );

if ( empty( $payment ) ) {

return $entry;

}

$this->log_debug( __METHOD__ . "(): Updating entry #{$entry['id']} with result => " . print_r( $payment, 1 ) );

if ( $payment['is_success'] ) {

$entry['is_fulfilled'] = '1';

$payment['payment_status'] = 'Paid';

$payment['payment_date'] = gmdate( 'Y-m-d H:i:s' );

$this->complete_payment( $entry, $payment );

} else {

$entry['payment_status'] = 'Failed';

$this->add_note( $entry['id'], sprintf( esc_html__( 'Payment failed to be captured. Reason: %s', 'gravityforms' ), $payment['error_message'] ), 'error' );

GFAPI::update_entry( $entry );

}

return $entry;

}

protected function process_subscription( $authorization, $feed, $submission_data, $form, $entry ) {

$subscription = rgar( $authorization, 'subscription' );

if ( empty( $subscription ) ) {

return $entry;

}

$this->log_debug( __METHOD__ . "(): Updating entry #{$entry['id']} with result => " . print_r( $subscription, 1 ) );

// if setup fee / trial is captured as part of a separate transaction

$payment = rgar( $subscription, 'captured_payment' );

$payment_name = rgempty( 'name', $payment ) ? esc_html__( 'Initial payment', 'gravityforms' ) : $payment['name'];

if ( $payment && $payment['is_success'] ) {

$this->insert_transaction( $entry['id'], 'payment', $payment['transaction_id'], $payment['amount'], false );

$amount_formatted = GFCommon::to_money( $payment['amount'], $entry['currency'] );

$note = sprintf( esc_html__( '%s has been captured successfully. Amount: %s. Transaction Id: %s', 'gravityforms' ), $payment_name, $amount_formatted, $payment['transaction_id'] );

$this->add_note( $entry['id'], $note, 'success' );

} elseif ( $payment && ! $payment['is_success'] ) {

$this->add_note( $entry['id'], sprintf( esc_html__( 'Failed to capture %s. Reason: %s.', 'gravityforms' ), $payment['error_message'], $payment_name ), 'error' );

}

// updating subscription information

if ( $subscription['is_success'] ) {

$entry = $this->start_subscription( $entry, $subscription );

} else {

$entry['payment_status'] = 'Failed';

GFAPI::update_entry( $entry );

$this->add_note( $entry['id'], sprintf( esc_html__( 'Subscription failed to be created. Reason: %s', 'gravityforms' ), $subscription['error_message'] ), 'error' );

}

return $entry;

}

protected function insert_transaction( $entry_id, $transaction_type, $transaction_id, $amount, $is_recurring = null ) {

global $wpdb;

// @todo: make sure stats does not show setup fee as a recurring payment

$payment_count = $wpdb->get_var( $wpdb->prepare( "SELECT count(id) FROM {$wpdb->prefix}gf_addon_payment_transaction WHERE lead_id=%d", $entry_id ) );

$is_recurring = $payment_count > 0 && $transaction_type == 'payment' ? 1 : 0;

$sql = $wpdb->prepare(

" INSERT INTO {$wpdb->prefix}gf_addon_payment_transaction (lead_id, transaction_type, transaction_id, amount, is_recurring, date_created)

values(%d, %s, %s, %f, %d, utc_timestamp())", $entry_id, $transaction_type, $transaction_id, $amount, $is_recurring

);

$wpdb->query( $sql );

$txn_id = $wpdb->insert_id;

do_action( 'gform_post_payment_transaction', $txn_id, $entry_id, $transaction_type, $transaction_id, $amount, $is_recurring );

if ( has_filter( 'gform_post_payment_transaction' ) ) {

$this->log_debug( __METHOD__ . '(): Executing functions hooked to gform_post_payment_transaction.' );

}

return $txn_id;

}

public function get_payment_feed( $entry, $form = false ) {

$submission_feed = false;

if ( $entry['id'] ) {

$feeds = $this->get_feeds_by_entry( $entry['id'] );

$submission_feed = empty( $feeds ) ? false : $this->get_feed( $feeds[0] );

} elseif ( $form ) {

// getting all feeds

$feeds = $this->get_feeds( $form['id'] );

foreach ( $feeds as $feed ) {

if ( $feed['is_active'] && $this->is_feed_condition_met( $feed, $form, $entry ) ) {

$submission_feed = $feed;

break;

}

}

}

return $submission_feed;

}

protected function is_payment_gateway( $entry_id ) {

if ( $this->is_payment_gateway ){

return true;

}

$gateway = gform_get_meta( $entry_id, 'payment_gateway' );

return $gateway == $this->_slug;

}

protected function get_submission_data( $feed, $form, $entry ) {

$form_data = array();

$form_data['form_title'] = $form['title'];

//getting mapped field data

$billing_fields = $this->billing_info_fields();

foreach ( $billing_fields as $billing_field ) {

$field_name = $billing_field['name'];

$input_id = rgar( $feed['meta'], "billingInformation_{$field_name}" );

$form_data[ $field_name ] = rgar( $entry, $input_id );

}

//getting credit card field data

$card_field = $this->get_credit_card_field( $form );

if ( $card_field ) {

$form_data['card_number'] = $this->remove_spaces_from_card_number( rgpost( "input_{$card_field['id']}_1" ) );

$form_data['card_expiration_date'] = rgpost( "input_{$card_field['id']}_2" );

$form_data['card_security_code'] = rgpost( "input_{$card_field['id']}_3" );

$form_data['card_name'] = rgpost( "input_{$card_field['id']}_5" );

}

//getting product field data

$order_info = $this->get_order_data( $feed, $form, $entry );

$form_data = array_merge( $form_data, $order_info );

return $form_data;

}

protected function get_credit_card_field( $form ) {

$fields = GFAPI::get_fields_by_type( $form, array( 'creditcard' ) );

return empty( $fields ) ? false : $fields[0];

}

protected function has_credit_card_field( $form ) {

return $this->get_credit_card_field( $form ) !== false;

}

protected function get_order_data( $feed, $form, $entry ) {

$products = GFCommon::get_product_fields( $form, $entry );

$payment_field = $feed['meta']['transactionType'] == 'product' ? rgars( $feed, 'meta/paymentAmount' ) : rgars( $feed, 'meta/recurringAmount' );

$setup_fee_field = rgar( $feed['meta'], 'setupFee_enabled' ) ? $feed['meta']['setupFee_product'] : false;

$trial_field = rgar( $feed['meta'], 'trial_enabled' ) ? rgars( $feed, 'meta/trial_product' ) : false;

$amount = 0;

$line_items = array();

$discounts = array();

$fee_amount = 0;

$trial_amount = 0;

foreach ( $products['products'] as $field_id => $product ) {

$quantity = $product['quantity'] ? $product['quantity'] : 1;

$product_price = GFCommon::to_number( $product['price'] );

$options = array();

if ( is_array( rgar( $product, 'options' ) ) ) {

foreach ( $product['options'] as $option ) {

$options[] = $option['option_name'];

$product_price += $option['price'];

}

}

$is_trial_or_setup_fee = false;

if ( ! empty( $trial_field ) && $trial_field == $field_id ) {

$trial_amount = $product_price * $quantity;

$is_trial_or_setup_fee = true;

} elseif ( ! empty( $setup_fee_field ) && $setup_fee_field == $field_id ) {

$fee_amount = $product_price * $quantity;

$is_trial_or_setup_fee = true;

}

//Do not add to line items if the payment field selected in the feed is not the current field.

if ( is_numeric( $payment_field ) && $payment_field != $field_id ) {

continue;

}

//Do not add to line items if the payment field is set to "Form Total" and the current field was used for trial or setup fee.

if ( $is_trial_or_setup_fee && ! is_numeric( $payment_field ) ) {

continue;

}

$amount += $product_price * $quantity;

$description = '';

if ( ! empty( $options ) ) {

$description = esc_html__( 'options: ', 'gravityforms' ) . ' ' . implode( ', ', $options );

}

if ( $product_price >= 0 ) {

$line_items[] = array( 'id' => $field_id, 'name' => $product['name'], 'description' => $description, 'quantity' => $quantity, 'unit_price' => GFCommon::to_number( $product_price ), 'options' => rgar( $product, 'options' ) );

} else {

$discounts[] = array( 'id' => $field_id, 'name' => $product['name'], 'description' => $description, 'quantity' => $quantity, 'unit_price' => GFCommon::to_number( $product_price ), 'options' => rgar( $product, 'options' ) );

}

}

if ( $trial_field == 'enter_amount' ) {

$trial_amount = rgar($feed["meta"], "trial_amount") ? GFCommon::to_number(rgar($feed["meta"], "trial_amount")) : 0;

}

if ( ! empty( $products['shipping']['name'] ) && ! is_numeric( $payment_field ) ) {

$line_items[] = array( 'id' => '', 'name' => $products['shipping']['name'], 'description' => '', 'quantity' => 1, 'unit_price' => GFCommon::to_number( $products['shipping']['price'] ), 'is_shipping' => 1 );

$amount += $products['shipping']['price'];

}

return array( 'payment_amount' => $amount, 'setup_fee' => $fee_amount, 'trial' => $trial_amount, 'line_items' => $line_items, 'discounts' => $discounts );

}

protected function is_callback_valid() {

if ( rgget( 'callback' ) != $this->_slug ) {

return false;

}

return true;

}

//--------- Callback (aka Webhook)----------------

public function maybe_process_callback() {

// ignoring requests that are not this addon's callbacks

if ( ! $this->is_callback_valid() ) {

return;

}

// returns either false or an array of data about the callback request which payment add-on will then use

// to generically process the callback data

$this->log_debug( __METHOD__ . '(): Initializing callback processing for: ' . $this->_slug );

$callback_action = $this->callback();

$this->log_debug( __METHOD__ . '(): Result from gateway callback => ' . print_r( $callback_action, true ) );

$result = false;

if ( is_wp_error( $callback_action ) ) {

$this->display_callback_error( $callback_action );

} elseif ( $callback_action && is_array( $callback_action ) && rgar( $callback_action, 'type' ) && ! rgar( $callback_action, 'abort_callback' ) ) {

$result = $this->process_callback_action( $callback_action );

$this->log_debug( __METHOD__ . '(): Result of callback action => ' . print_r( $result, true ) );

if ( is_wp_error( $result ) ) {

$this->display_callback_error( $result );

} elseif ( ! $result ) {

status_header( 200 );

echo 'Callback could not be processed.';

} else {

status_header( 200 );

echo 'Callback processed successfully.';

}

} else {

status_header( 200 );

echo 'Callback bypassed';

}

$this->post_callback( $callback_action, $result );

die();

}

private function display_callback_error( $error ) {

$data = $error->get_error_data();

$status = ! rgempty( 'status_header', $data ) ? $data['status_header'] : 200;

status_header( $status );

echo $error->get_error_message();

}

/**

private function process_callback_action( $action ) {

$this->log_debug( __METHOD__ . '(): Processing callback action.' );

$action = wp_parse_args(

$action, array(

'type' => false,

'amount' => false,

'transaction_type' => false,

'transaction_id' => false,

'subscription_id' => false,

'entry_id' => false,

'payment_status' => false,

'note' => false,

)

);

$result = false;

if ( rgar( $action, 'id' ) && $this->is_duplicate_callback( $action['id'] ) ) {

return new WP_Error( 'duplicate', sprintf( esc_html__( 'This webhook has already been processed (Event Id: %s)', 'gravityforms' ), $action['id'] ) );

}

$entry = GFAPI::get_entry( $action['entry_id'] );

if ( ! $entry || is_wp_error( $entry ) ) {

return $result;

}

//$action = do_action('gform_action_pre_payment_callback', $action, $entry);

do_action( 'gform_action_pre_payment_callback', $action, $entry );

if ( has_filter( 'gform_action_pre_payment_callback' ) ) {

$this->log_debug( __METHOD__ . '(): Executing functions hooked to gform_action_pre_payment_callback.' );

}

switch ( $action['type'] ) {

case 'complete_payment':

$result = $this->complete_payment( $entry, $action );

break;

case 'refund_payment':

$result = $this->refund_payment( $entry, $action );

break;

case 'fail_payment':

$result = $this->fail_payment( $entry, $action );

break;

case 'add_pending_payment':

$result = $this->add_pending_payment( $entry, $action );

break;

case 'void_authorization':

$result = $this->void_authorization( $entry, $action );

break;

case 'create_subscription':

$result = $this->start_subscription( $entry, $action );

$result = rgar( $result, 'payment_status' ) == 'Active' && rgar( $result, 'transaction_id' ) == rgar( $action, 'subscription_id' );

break;

case 'cancel_subscription':

$feed = $this->get_payment_feed( $entry );

$result = $this->cancel_subscription( $entry, $feed, $action['note'] );

break;

case 'expire_subscription':

$result = $this->expire_subscription( $entry, $action );

break;

case 'add_subscription_payment':

$result = $this->add_subscription_payment( $entry, $action );

break;

case 'fail_subscription_payment':

$result = $this->fail_subscription_payment( $entry, $action );

break;

default:

// handle custom events

if ( is_callable( array( $this, rgar( $action, 'callback' ) ) ) ) {

$result = call_user_func_array( array( $this, $action['callback'] ), array( $entry, $action ) );

}

break;

}

if ( rgar( $action, 'id' ) && $result ) {

$this->register_callback( $action['id'], $action['entry_id'] );

}

do_action( 'gform_post_payment_callback', $entry, $action, $result );

if ( has_filter( 'gform_post_payment_callback' ) ) {

$this->log_debug( __METHOD__ . '(): Executing functions hooked to gform_post_payment_callback.' );

}

return $result;

}

protected function register_callback( $callback_id, $entry_id ) {

global $wpdb;

$wpdb->insert( "{$wpdb->prefix}gf_addon_payment_callback", array( 'addon_slug' => $this->_slug, 'callback_id' => $callback_id, 'lead_id' => $entry_id, 'date_created' => gmdate( 'Y-m-d H:i:s' ) ) );

}

protected function is_duplicate_callback( $callback_id ) {

global $wpdb;

$sql = $wpdb->prepare( "SELECT id FROM {$wpdb->prefix}gf_addon_payment_callback WHERE addon_slug=%s AND callback_id=%s", $this->_slug, $callback_id );

if ( $wpdb->get_var( $sql ) ) {

return true;

}

return false;

}

protected function callback() {

}

protected function post_callback( $callback_action, $result ) {

}

// # PAYMENT INTERACTION FUNCTIONS

public function add_pending_payment( $entry, $action ) {

$this->log_debug( __METHOD__ . '(): Processing request.' );

if ( ! $action['payment_status'] ) {

$action['payment_status'] = 'Pending';

}

if ( ! $action['note'] ) {

$amount_formatted = GFCommon::to_money( $action['amount'], $entry['currency'] );

$action['note'] = sprintf( esc_html__( 'Payment is pending. Amount: %s. Transaction Id: %s.', 'gravityforms' ), $amount_formatted, $action['transaction_id'] );

}

GFAPI::update_entry_property( $entry['id'], 'payment_status', $action['payment_status'] );

$this->add_note( $entry['id'], $action['note'] );

return true;

}

public function complete_payment( &$entry, $action ) {

$this->log_debug( __METHOD__ . '(): Processing request.' );

if ( ! rgar( $action, 'payment_status' ) ) {

$action['payment_status'] = 'Paid';

}

if ( ! rgar( $action, 'transaction_type' ) ) {

$action['transaction_type'] = 'payment';

}

if ( ! rgar( $action, 'payment_date' ) ) {

$action['payment_date'] = gmdate( 'y-m-d H:i:s' );

}

$entry['is_fulfilled'] = '1';

$entry['transaction_id'] = rgar( $action, 'transaction_id' );

$entry['transaction_type'] = '1';

$entry['payment_status'] = $action['payment_status'];

$entry['payment_amount'] = rgar( $action, 'amount' );

$entry['payment_date'] = $action['payment_date'];

$entry['payment_method'] = rgar( $action, 'payment_method' );

$entry['currency'] = GFCommon::get_currency();

if ( ! rgar( $action, 'note' ) ) {

$amount_formatted = GFCommon::to_money( $action['amount'], $entry['currency'] );

$action['note'] = sprintf( esc_html__( 'Payment has been completed. Amount: %s. Transaction Id: %s.', 'gravityforms' ), $amount_formatted, $action['transaction_id'] );

}

GFAPI::update_entry( $entry );

$this->insert_transaction( $entry['id'], $action['transaction_type'], $action['transaction_id'], $action['amount'] );

$this->add_note( $entry['id'], $action['note'], 'success' );

do_action( 'gform_post_payment_completed', $entry, $action );

if ( has_filter( 'gform_post_payment_completed' ) ) {

$this->log_debug( __METHOD__ . '(): Executing functions hooked to gform_post_payment_completed.' );

}

return true;

}

public function refund_payment( $entry, $action ) {

$this->log_debug( __METHOD__ . '(): Processing request.' );

if ( ! $action['payment_status'] ) {

$action['payment_status'] = 'Refunded';

}

if ( ! $action['transaction_type'] ) {

$action['transaction_type'] = 'refund';

}

if ( ! $action['note'] ) {

$amount_formatted = GFCommon::to_money( $action['amount'], $entry['currency'] );

$action['note'] = sprintf( esc_html__( 'Payment has been refunded. Amount: %s. Transaction Id: %s.', 'gravityforms' ), $amount_formatted, $action['transaction_id'] );

}

GFAPI::update_entry_property( $entry['id'], 'payment_status', $action['payment_status'] );

$this->insert_transaction( $entry['id'], $action['transaction_type'], $action['transaction_id'], $action['amount'] );

$this->add_note( $entry['id'], $action['note'] );

do_action( 'gform_post_payment_refunded', $entry, $action );

if ( has_filter( 'gform_post_payment_refunded' ) ) {

$this->log_debug( __METHOD__ . '(): Executing functions hooked to gform_post_payment_refunded.' );

}

return true;

}

public function fail_payment( $entry, $action ) {

$this->log_debug( __METHOD__ . '(): Processing request.' );

if ( ! $action['payment_status'] ) {

$action['payment_status'] = 'Failed';

}

if ( ! $action['note'] ) {

$amount_formatted = GFCommon::to_money( $action['amount'], $entry['currency'] );

$action['note'] = sprintf( esc_html__( 'Payment has failed. Amount: %s.', 'gravityforms' ), $amount_formatted );

}

GFAPI::update_entry_property( $entry['id'], 'payment_status', $action['payment_status'] );

$this->add_note( $entry['id'], $action['note'] );

return true;

}

public function void_authorization( $entry, $action ) {

$this->log_debug( __METHOD__ . '(): Processing request.' );

if ( ! $action['payment_status'] ) {

$action['payment_status'] = 'Voided';

}

if ( ! $action['note'] ) {

$action['note'] = sprintf( esc_html__( 'Authorization has been voided. Transaction Id: %s', 'gravityforms' ), $action['transaction_id'] );

}

GFAPI::update_entry_property( $entry['id'], 'payment_status', $action['payment_status'] );

$this->add_note( $entry['id'], $action['note'] );

return true;

}

/**

public function start_subscription( $entry, $subscription ) {

$this->log_debug( __METHOD__ . '(): Processing request.' );

if ( ! $this->has_subscription( $entry ) ) {

$entry['payment_status'] = 'Active';

$entry['payment_amount'] = $subscription['amount'];

$entry['payment_date'] = gmdate( 'y-m-d H:i:s' );

$entry['transaction_id'] = $subscription['subscription_id'];

$entry['transaction_type'] = '2'; // subscription

$entry['is_fulfilled'] = '1';

$result = GFAPI::update_entry( $entry );

$this->add_note( $entry['id'], sprintf( esc_html__( 'Subscription has been created. Subscription Id: %s.', 'gravityforms' ), $subscription['subscription_id'] ), 'success' );

do_action( 'gform_post_subscription_started', $entry, $subscription );

if ( has_filter( 'gform_post_subscription_started' ) ) {

$this->log_debug( __METHOD__ . '(): Executing functions hooked to gform_post_subscription_started.' );

}

}

return $entry;

}

/**

public function add_subscription_payment( $entry, $action ) {

$this->log_debug( __METHOD__ . '(): Processing request.' );

if ( ! $action['transaction_type'] ) {

$action['transaction_type'] = 'payment';

}

if ( ! $action['note'] ) {

$amount_formatted = GFCommon::to_money( $action['amount'], $entry['currency'] );

$action['note'] = sprintf( esc_html__( 'Subscription has been paid. Amount: %s. Subscription Id: %s', 'gravityforms' ), $amount_formatted, $action['subscription_id'] );

}