1789 lines
38 KiB
PHP
1789 lines
38 KiB
PHP
<?php
|
|
// phpcs:ignoreFile
|
|
|
|
namespace AutomateWoo;
|
|
|
|
use AutomateWoo\Formatters\Formattable;
|
|
use AutomateWoo\Triggers\ManualInterface;
|
|
use InvalidArgumentException;
|
|
use WC_Subscription;
|
|
|
|
/**
|
|
* @class Workflow
|
|
*/
|
|
class Workflow {
|
|
|
|
const POST_TYPE = 'aw_workflow';
|
|
|
|
/** @var int */
|
|
public $id;
|
|
|
|
/** @var \WP_Post */
|
|
public $post;
|
|
|
|
/** @var string */
|
|
public $title;
|
|
|
|
/** @var Trigger */
|
|
private $trigger;
|
|
|
|
/** @var Actions[] */
|
|
private $actions;
|
|
|
|
/** @var Data_Layer */
|
|
private $data_layer;
|
|
|
|
/** @var Variables_Processor */
|
|
private $variable_processor;
|
|
|
|
/** @var Workflow_Location */
|
|
private $location;
|
|
|
|
/** @var Workflow_Location */
|
|
private $tax_location;
|
|
|
|
/** @var Log */
|
|
public $log;
|
|
|
|
/** @var bool */
|
|
public $exists = false;
|
|
|
|
/** @var bool */
|
|
public $preview_mode = false;
|
|
|
|
/** @var bool */
|
|
public $test_mode = false;
|
|
|
|
/** @var bool */
|
|
public $is_setup = false;
|
|
|
|
|
|
/**
|
|
* @param $post mixed (object or post ID)
|
|
*/
|
|
function __construct( $post ) {
|
|
|
|
if ( ! $post instanceof \WP_Post ) {
|
|
// Get from id
|
|
$post = get_post($post);
|
|
}
|
|
|
|
if ( ! $post || $post->post_type !== self::POST_TYPE ) {
|
|
return;
|
|
}
|
|
|
|
$this->exists = true;
|
|
$this->post = $post;
|
|
$this->id = $post->ID;
|
|
$this->title = $post->post_title;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function get_id() {
|
|
return $this->id ? Clean::id( $this->id ) : 0;
|
|
}
|
|
|
|
/**
|
|
* Set workflow ID.
|
|
*
|
|
* @since 5.1.0
|
|
* @param int $id
|
|
*/
|
|
public function set_id( int $id ) {
|
|
$this->id = $id;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
function get_title() {
|
|
return $this->title;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the GMT created date from the post object.
|
|
* Return a converted date if the GMT date is zero (happens with an auto saved draft).
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_date_created() {
|
|
if ( '0000-00-00 00:00:00' === $this->post->post_date_gmt ) {
|
|
return get_gmt_from_date( $this->post->post_date );
|
|
}
|
|
|
|
return $this->post->post_date_gmt;
|
|
}
|
|
|
|
/**
|
|
* Get the workflow type.
|
|
*
|
|
* @since 5.0.0
|
|
* @return string A valid workflow type.
|
|
*/
|
|
public function get_type() {
|
|
$type = $this->get_meta( 'type' );
|
|
return array_key_exists( $type, Workflows::get_types() ) ? $type : 'automatic';
|
|
}
|
|
|
|
/**
|
|
* Set the workflow type.
|
|
*
|
|
* @since 5.0.0
|
|
* @param string $type
|
|
* @throws InvalidArgumentException If $type param is invalid.
|
|
*/
|
|
public function set_type( $type ) {
|
|
if ( ! array_key_exists( $type, Workflows::get_types() ) ) {
|
|
throw new InvalidArgumentException( 'Invalid workflow type.' );
|
|
}
|
|
|
|
$this->update_meta( 'type', $type );
|
|
}
|
|
|
|
/**
|
|
* @return Variables_Processor
|
|
*/
|
|
function variable_processor() {
|
|
|
|
if ( ! isset( $this->variable_processor ) ) {
|
|
$this->variable_processor = new Variables_Processor( $this );
|
|
}
|
|
|
|
return $this->variable_processor;
|
|
}
|
|
|
|
/**
|
|
* Process a single variable string and return the value.
|
|
*
|
|
* For example: "customer.email" or "order.items | template: 'order-table'"
|
|
* This method should only be used if the workflow has a data layer.
|
|
*
|
|
* @since 4.4.0
|
|
*
|
|
* @param string $variable_string
|
|
*
|
|
* @return string
|
|
*/
|
|
function process_variable( $variable_string ) {
|
|
return $this->variable_processor()->process_field( '{{' . $variable_string . '}}', true );
|
|
}
|
|
|
|
|
|
/**
|
|
* @return Data_Layer
|
|
*/
|
|
function data_layer() {
|
|
if ( ! isset( $this->data_layer ) ) {
|
|
$this->data_layer = new Data_Layer();
|
|
}
|
|
|
|
return $this->data_layer;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return Trigger|ManualInterface|false
|
|
*/
|
|
function get_trigger() {
|
|
if ( ! isset( $this->trigger ) ) {
|
|
|
|
$this->trigger = false;
|
|
$trigger_name = $this->get_trigger_name();
|
|
|
|
if ( $trigger_name && Triggers::get( $trigger_name ) ) {
|
|
// @todo clone triggers just to retrieve options now seems a little confusing and inefficient
|
|
$this->trigger = clone Triggers::get( $trigger_name );
|
|
$this->trigger->set_options( $this->get_trigger_options() );
|
|
}
|
|
}
|
|
|
|
return $this->trigger;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return Action[]
|
|
*/
|
|
function get_actions() {
|
|
if ( ! isset( $this->actions ) ) {
|
|
|
|
$this->actions = [];
|
|
$actions_data = $this->get_actions_data();
|
|
|
|
if ( ! is_array( $actions_data ) ) {
|
|
return $this->actions;
|
|
}
|
|
|
|
$n = 1;
|
|
foreach ( $actions_data as $action ) {
|
|
try {
|
|
$action_obj = clone $this->get_action_from_action_fields( $action );
|
|
$action_obj->set_options( $action );
|
|
$this->actions[ $n ] = $action_obj;
|
|
$n++;
|
|
} catch ( Exception $e ) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this->actions;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the saved actions with their data
|
|
*
|
|
* @param $number
|
|
* @return Action|false
|
|
*/
|
|
function get_action( $number ) {
|
|
|
|
$actions = $this->get_actions();
|
|
|
|
if ( ! isset( $actions[$number] ) ) {
|
|
return false;
|
|
}
|
|
|
|
return $actions[$number];
|
|
}
|
|
|
|
|
|
/**
|
|
* @param Data_Layer|array $data_layer
|
|
* @param bool $skip_validation
|
|
* @param bool $force_immediate
|
|
*/
|
|
function maybe_run( $data_layer, $skip_validation = false, $force_immediate = false ) {
|
|
|
|
// setup language and data before validation occurs
|
|
$this->setup( $data_layer );
|
|
|
|
if ( $this->is_missing_required_data() ) {
|
|
return;
|
|
}
|
|
|
|
if ( $skip_validation || $this->validate_workflow() ) {
|
|
|
|
if ( $this->get_timing_type() === 'immediately' || $force_immediate ) {
|
|
$this->run();
|
|
}
|
|
else {
|
|
$this->queue();
|
|
}
|
|
}
|
|
|
|
$this->cleanup();
|
|
}
|
|
|
|
/**
|
|
* Check if workflow is missing some required data.
|
|
*
|
|
* This must be run after the setup() method.
|
|
*
|
|
* @since 4.6
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function is_missing_required_data(){
|
|
if ( ! $this->exists ) {
|
|
return true;
|
|
}
|
|
|
|
if ( ! $this->get_trigger() ) {
|
|
return true;
|
|
}
|
|
|
|
if ( $this->data_layer()->is_missing_data() ) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
function validate_workflow() {
|
|
|
|
if ( ! $this->is_active() )
|
|
return false;
|
|
|
|
if ( ! $trigger = $this->get_trigger() )
|
|
return false;
|
|
|
|
if ( ! $trigger->validate_workflow_language( $this ) )
|
|
return false;
|
|
|
|
if ( ! $trigger->validate_workflow( $this ) )
|
|
return false;
|
|
|
|
if ( ! $this->validate_rules() )
|
|
return false;
|
|
|
|
if ( ! apply_filters( 'automatewoo_custom_validate_workflow', true, $this ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
function validate_rules() {
|
|
|
|
$rule_options = $this->get_rule_data();
|
|
|
|
// no rules exists
|
|
if ( empty( $rule_options ) )
|
|
return true;
|
|
|
|
foreach ( $rule_options as $rule_group ) {
|
|
|
|
$is_group_valid = true;
|
|
|
|
foreach ( $rule_group as $rule ) {
|
|
|
|
// rules have AND relationship so all must return true
|
|
if ( ! $this->validate_rule( $rule ) ) {
|
|
$is_group_valid = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// groups have an OR relationship so if one is valid we can break the loop and return true
|
|
if ( $is_group_valid )
|
|
return true;
|
|
}
|
|
|
|
// no groups were valid
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns true if rule is missing data so that the rule is skipped
|
|
*
|
|
* @param array $rule
|
|
* @return bool
|
|
*/
|
|
function validate_rule( $rule ) {
|
|
|
|
if ( ! is_array( $rule ) )
|
|
return true;
|
|
|
|
$rule_name = isset( $rule['name'] ) ? $rule['name'] : false;
|
|
$rule_compare = isset( $rule['compare'] ) ? $rule['compare'] : false;
|
|
$rule_value = isset( $rule['value'] ) ? $rule['value'] : false;
|
|
|
|
// its ok for compare to be false for boolean type rules
|
|
if ( ! $rule_name ) {
|
|
return true;
|
|
}
|
|
|
|
$rule_object = Rules::get( $rule_name );
|
|
|
|
// rule doesn't exists
|
|
if ( ! $rule_object )
|
|
return false;
|
|
|
|
// get the data required to validate the rule
|
|
$data_item = $this->data_layer()->get_item( $rule_object->data_item );
|
|
|
|
if ( ! $data_item )
|
|
return false;
|
|
|
|
// some rules need the full workflow object
|
|
$rule_object->set_workflow( $this );
|
|
|
|
// Check the expected rule value is valid.
|
|
try {
|
|
$rule_object->validate_value( $rule_value );
|
|
} catch ( \Exception $e ) {
|
|
// Always return false if the rule value is invalid
|
|
return false;
|
|
}
|
|
|
|
return $rule_object->validate( $data_item, $rule_compare, $rule_value );
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
function run() {
|
|
|
|
if ( AW_PREVENT_WORKFLOWS ) {
|
|
Logger::info( 'prevented-workflows', $this->title );
|
|
return false;
|
|
}
|
|
|
|
do_action( 'automatewoo/workflow/before_run', $this );
|
|
|
|
if ( ! $this->is_test_mode() ) {
|
|
$this->create_run_log();
|
|
}
|
|
|
|
$actions = $this->get_actions();
|
|
|
|
foreach ( $actions as $action ) {
|
|
|
|
$action->workflow = $this;
|
|
|
|
try {
|
|
do_action('automatewoo_before_action_run', $action, $this );
|
|
$action->run();
|
|
do_action('automatewoo_after_action_run', $action, $this );
|
|
}
|
|
catch( \Exception $e ) {
|
|
// Log exceptions as errors
|
|
$this->log_action_error( $action, $e->getMessage() );
|
|
}
|
|
}
|
|
|
|
do_action( 'automatewoo_after_workflow_run', $this );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Reset the workflow object
|
|
* Clears any data that is related to the last run
|
|
* The trigger and actions don't need to be reset because their data flows from the workflow options not the workflow data layer
|
|
*/
|
|
function reset_data() {
|
|
$this->data_layer()->clear();
|
|
$this->log = null;
|
|
$this->location = null;
|
|
$this->tax_location = null;
|
|
}
|
|
|
|
/**
|
|
* Create queued event for the workflow.
|
|
*
|
|
* @return Queued_Event|false
|
|
*/
|
|
function queue() {
|
|
$date = $this->get_queue_date();
|
|
|
|
if ( ! $date ) {
|
|
return false;
|
|
}
|
|
|
|
$queue = new Queued_Event();
|
|
$queue->set_workflow_id( $this->get_id() );
|
|
$queue->set_date_due( $date );
|
|
$queue->store_data_layer( $this->data_layer() );
|
|
$queue->save();
|
|
|
|
return $queue;
|
|
}
|
|
|
|
/**
|
|
* Get the date the workflow should be queued for.
|
|
*
|
|
* @since 5.0.0
|
|
*
|
|
* @return DateTime|bool
|
|
*/
|
|
public function get_queue_date() {
|
|
$date = false;
|
|
|
|
switch( $this->get_timing_type() ) {
|
|
case 'delayed':
|
|
$date = new DateTime();
|
|
$current_timestamp = time();
|
|
$date->setTimestamp( $current_timestamp + $this->get_timing_delay( $current_timestamp ) );
|
|
break;
|
|
case 'scheduled':
|
|
$date = $this->calculate_scheduled_datetime();
|
|
break;
|
|
case 'fixed':
|
|
$date = $this->get_fixed_time();
|
|
break;
|
|
case 'datetime':
|
|
$date = $this->get_variable_time();
|
|
break;
|
|
}
|
|
|
|
return apply_filters( 'automatewoo/workflow/queue_date', $date, $this );
|
|
}
|
|
|
|
/**
|
|
* Setup the state of the workflow before it is validated or checked
|
|
* @param array|Data_Layer|bool $data
|
|
*/
|
|
function setup( $data = false ) {
|
|
|
|
// the only time data is false is in preview mode
|
|
if ( $data ) {
|
|
$this->set_data_layer( $data, true );
|
|
}
|
|
|
|
if ( Language::is_multilingual() ) {
|
|
$lang = $this->get_language();
|
|
Language::set_current( $lang );
|
|
|
|
global $woocommerce_wpml;
|
|
|
|
if ( $woocommerce_wpml ) {
|
|
/** @var $woocommerce_wpml \woocommerce_wpml */
|
|
$woocommerce_wpml->emails->change_email_language( $lang );
|
|
}
|
|
}
|
|
|
|
// Ensure mailer and gateways are loaded in case they need to insert data into the emails
|
|
WC()->mailer();
|
|
WC()->payment_gateways();
|
|
WC()->shipping();
|
|
|
|
add_filter( 'woocommerce_get_tax_location', [ $this, 'filter_tax_location' ], 50, 2 );
|
|
|
|
$this->is_setup = true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Clean up after workflow run
|
|
*/
|
|
function cleanup() {
|
|
|
|
// reset language
|
|
if ( Language::is_multilingual() ) {
|
|
Language::set_original();
|
|
}
|
|
|
|
remove_filter( 'woocommerce_get_tax_location', [ $this, 'filter_tax_location' ], 50 );
|
|
|
|
$this->is_setup = false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Record that the workflow has been run
|
|
*/
|
|
function create_run_log() {
|
|
|
|
$this->log = new Log();
|
|
$this->log->set_workflow_id( $this->get_id() );
|
|
$this->log->set_date( new DateTime() );
|
|
|
|
if ( $this->is_tracking_enabled() ) {
|
|
$this->log->set_tracking_enabled( true );
|
|
|
|
if ( $this->is_conversion_tracking_enabled() ) {
|
|
$this->log->set_conversion_tracking_enabled( true );
|
|
}
|
|
}
|
|
|
|
$this->log->save();
|
|
$this->log->store_data_layer( $this->data_layer() );
|
|
|
|
do_action( 'automatewoo_create_run_log', $this->log, $this );
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
function get_times_run() {
|
|
|
|
$cache_key = 'times_run/workflow=' . $this->get_id();
|
|
$cache = Cache::get_transient( $cache_key );
|
|
|
|
if ( $cache !== false ) {
|
|
return (int) $cache;
|
|
}
|
|
|
|
$query = new Log_Query();
|
|
$query->where_workflow( $this->get_id() );
|
|
$count = $query->get_count();
|
|
|
|
Cache::set_transient( $cache_key, $count, 720 );
|
|
|
|
return $count;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param bool $try_cache
|
|
* @return int|string
|
|
*/
|
|
function get_current_queue_count( $try_cache = true ) {
|
|
|
|
$cache_key = 'current_queue_count/workflow=' . $this->get_id();
|
|
$cache = Cache::get_transient( $cache_key );
|
|
|
|
if ( $try_cache && $cache !== false ) {
|
|
return $cache;
|
|
}
|
|
else {
|
|
|
|
$query = new Queue_Query();
|
|
$query->where_workflow( $this->get_id() );
|
|
$count = $query->get_count();
|
|
|
|
Cache::set_transient( $cache_key, $count, 720 );
|
|
|
|
return $count;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $name
|
|
* @param bool $replace_vars
|
|
* @return mixed
|
|
*/
|
|
function get_option( $name, $replace_vars = false ) {
|
|
|
|
$options = $this->get_meta( 'workflow_options' );
|
|
|
|
if ( ! is_array( $options ) || ! isset( $options[$name] ) )
|
|
return false;
|
|
|
|
if ( $replace_vars ) {
|
|
return $this->variable_processor()->process_field( $options[$name] );
|
|
}
|
|
|
|
return apply_filters( 'automatewoo/workflow/option', $options[$name], $name, $this );
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns options are immediately, delayed, scheduled, datetime
|
|
* @since 2.9
|
|
* @return string
|
|
*/
|
|
function get_timing_type() {
|
|
$when = Clean::string( $this->get_option( 'when_to_run' ) );
|
|
if ( ! $when ) $when = 'immediately';
|
|
return $when;
|
|
}
|
|
|
|
/**
|
|
* Return the delay period in seconds
|
|
*
|
|
* @since 2.9
|
|
* @param integer|null $current_timestamp the current timestamp, used for calculating 'month' delays.
|
|
* @return integer
|
|
*/
|
|
public function get_timing_delay( $current_timestamp = null ) {
|
|
|
|
// Default to execution time.
|
|
if ( is_null( $current_timestamp ) ) {
|
|
$current_timestamp = time();
|
|
}
|
|
|
|
$timing_type = $this->get_timing_type();
|
|
|
|
if ( ! in_array( $timing_type, [ 'delayed', 'scheduled' ] ) ) {
|
|
return 0;
|
|
}
|
|
|
|
$number = $this->get_timing_delay_number();
|
|
$unit = $this->get_timing_delay_unit();
|
|
|
|
$units = [
|
|
'm' => MINUTE_IN_SECONDS,
|
|
'h' => HOUR_IN_SECONDS,
|
|
'd' => DAY_IN_SECONDS,
|
|
'w' => WEEK_IN_SECONDS,
|
|
'month' => MONTH_IN_SECONDS,
|
|
];
|
|
|
|
if ( ! $number || ! isset( $units[ $unit ] ) ) {
|
|
return 0;
|
|
} elseif ( 'month' === $unit ) {
|
|
try {
|
|
$delay_date = new DateTime();
|
|
$delay_date->setTimestamp( $current_timestamp );
|
|
$delay_date->add_natural_months( $number );
|
|
return $delay_date->getTimeStamp() - $current_timestamp;
|
|
} catch ( \Exception $exception ) {
|
|
// Invalid $number of months.
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return $number * $units[ $unit ];
|
|
}
|
|
|
|
|
|
/**
|
|
* @return float
|
|
*/
|
|
function get_timing_delay_number() {
|
|
return (float) $this->get_option('run_delay_value');
|
|
}
|
|
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
function get_timing_delay_unit() {
|
|
return Clean::string( $this->get_option('run_delay_unit') );
|
|
}
|
|
|
|
|
|
/**
|
|
* Calculate the next point in time that matches the workflow scheduling options
|
|
* @param bool|integer $current_timestamp - optional, not GMT
|
|
* @return bool|DateTime
|
|
*/
|
|
function calculate_scheduled_datetime( $current_timestamp = false ) {
|
|
|
|
if ( $this->get_timing_type() !== 'scheduled' ) {
|
|
return false;
|
|
}
|
|
|
|
if ( ! $current_timestamp ) {
|
|
$current_timestamp = current_time( 'timestamp' ); // calculate based on the local timezone
|
|
}
|
|
|
|
// scheduled day and time are in the sites specified timezone
|
|
$scheduled_time = $this->get_scheduled_time();
|
|
$scheduled_days = $this->get_scheduled_days();
|
|
$scheduled_time_seconds_from_day_start = Time_Helper::calculate_seconds_from_day_start( $scheduled_time );
|
|
|
|
// get minimum datetime before scheduling can happen, if no delay is set then this will be now
|
|
$min_wait_datetime = new DateTime;
|
|
$min_wait_datetime->setTimestamp( $current_timestamp + $this->get_timing_delay( $current_timestamp ) );
|
|
$min_wait_time_seconds_from_day_start = Time_Helper::calculate_seconds_from_day_start( $min_wait_datetime );
|
|
|
|
// check to see if the scheduled time of day is later than the min wait time
|
|
$is_scheduled_time_later_than_min_wait_time = $min_wait_time_seconds_from_day_start < $scheduled_time_seconds_from_day_start;
|
|
|
|
// if the scheduled time comes before the current min wait time we can not schedule on the same day as the min wait
|
|
// therefore update the min wait datetime so that is its midnight of the next day
|
|
if ( ! $is_scheduled_time_later_than_min_wait_time ) {
|
|
$min_wait_datetime->modify('+1 day');
|
|
}
|
|
|
|
$min_wait_datetime->set_time_to_day_start(); // set time to midnight, time will be added on later
|
|
|
|
// check if scheduled day matches the min wait day
|
|
if ( $scheduled_days && ! in_array( $min_wait_datetime->format( 'N' ), $scheduled_days ) ) {
|
|
|
|
// advance time until a matching day is found
|
|
while ( ! in_array( $min_wait_datetime->format( 'N' ), $scheduled_days ) ) {
|
|
$min_wait_datetime->modify('+1 day');
|
|
}
|
|
}
|
|
|
|
$scheduled_time = new DateTime;
|
|
$scheduled_time->setTimestamp( $min_wait_datetime->getTimestamp() );
|
|
$scheduled_time->modify( "{$scheduled_time_seconds_from_day_start} seconds" );
|
|
$scheduled_time->convert_to_utc_time();
|
|
|
|
return $scheduled_time;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
function get_scheduled_time() {
|
|
return Clean::string( $this->get_option( 'scheduled_time' ) );
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns empty if set to any day, 1 (for Monday) through 7 (for Sunday)
|
|
* @return array
|
|
*/
|
|
function get_scheduled_days() {
|
|
return Clean::ids( $this->get_option( 'scheduled_day' ) );
|
|
}
|
|
|
|
|
|
/**
|
|
* @return DateTime|bool
|
|
*/
|
|
function get_fixed_time() {
|
|
|
|
$date = Clean::string( $this->get_option('fixed_date') );
|
|
$time = array_map( 'absint', (array) $this->get_option('fixed_time') );
|
|
|
|
if ( ! $date ) {
|
|
return false;
|
|
}
|
|
|
|
$datetime = new DateTime( $date );
|
|
$datetime->setTime( isset($time[0]) ? $time[0] : 0, isset($time[1]) ? $time[1] : 0, 0 );
|
|
$datetime->convert_to_utc_time();
|
|
|
|
return $datetime;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get scheduled date as set by variable timing option
|
|
* @return DateTime|bool
|
|
*/
|
|
function get_variable_time() {
|
|
$datetime = $this->get_option( 'queue_datetime', true );
|
|
|
|
if ( ! $datetime ) {
|
|
return false;
|
|
}
|
|
|
|
$timestamp = strtotime( $datetime, current_time( 'timestamp' ) );
|
|
|
|
$date = new DateTime();
|
|
$date->setTimestamp( $timestamp );
|
|
$date->convert_to_utc_time();
|
|
|
|
return $date;
|
|
}
|
|
|
|
/**
|
|
* Get the name of the workflow's trigger.
|
|
*
|
|
* @since 4.4.0
|
|
*
|
|
* @return string
|
|
*/
|
|
function get_trigger_name() {
|
|
return Clean::string( $this->get_meta( 'trigger_name' ) );
|
|
}
|
|
|
|
/**
|
|
* Set the trigger for the workflow.
|
|
*
|
|
* @since 4.4.0
|
|
*
|
|
* @param $trigger_name
|
|
*/
|
|
function set_trigger_name( $trigger_name ) {
|
|
$this->update_meta( 'trigger_name', Clean::string( $trigger_name ) );
|
|
unset( $this->trigger );
|
|
}
|
|
|
|
/**
|
|
* Get the workflow trigger options.
|
|
* Values will be sanitized as per the fields set on the trigger object.
|
|
*
|
|
* @return array
|
|
*/
|
|
function get_trigger_options() {
|
|
$options = $this->get_meta( 'trigger_options' );
|
|
return is_array( $options ) ? $options : [];
|
|
}
|
|
|
|
/**
|
|
* Set the workflow trigger options.
|
|
*
|
|
* Also saves the trigger name if it's different.
|
|
*
|
|
* @since 4.4.0
|
|
*
|
|
* @param string $trigger_name
|
|
* @param array $trigger_options
|
|
*/
|
|
function set_trigger_data( $trigger_name, $trigger_options ) {
|
|
if ( $trigger_name !== $this->get_trigger_name() ) {
|
|
$this->set_trigger_name( $trigger_name );
|
|
}
|
|
$this->update_meta( 'trigger_options', $this->sanitize_trigger_options( $trigger_name, $trigger_options ) );
|
|
unset( $this->trigger );
|
|
}
|
|
|
|
|
|
/**
|
|
* Get's the sanitized value of workflow trigger option.
|
|
*
|
|
* @param string $name
|
|
* @param bool|string $default used when value is not set, this should only be if the option was added workflow was created
|
|
*
|
|
* @return mixed Will vary depending on the field type specified in the trigger's fields.
|
|
*/
|
|
function get_trigger_option( $name, $default = false ) {
|
|
$options = $this->get_trigger_options();
|
|
|
|
if ( isset( $options[$name] ) ) {
|
|
$value = $options[$name];
|
|
}
|
|
else {
|
|
$value = $default;
|
|
}
|
|
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Sanitizes an array of trigger data based on the fields of the trigger.
|
|
*
|
|
* @since 4.4.0
|
|
*
|
|
* @param string $trigger_name
|
|
* @param array $raw_options
|
|
*
|
|
* @return array
|
|
*/
|
|
function sanitize_trigger_options( $trigger_name, $raw_options ) {
|
|
if ( empty( $trigger_name ) ) {
|
|
return [];
|
|
}
|
|
|
|
$trigger = Triggers::get( Clean::string( $trigger_name ) );
|
|
|
|
if ( ! $trigger ) {
|
|
return [];
|
|
}
|
|
|
|
$return = [];
|
|
|
|
foreach( $raw_options as $name => $value ) {
|
|
$name = Clean::string( $name );
|
|
$field_obj = $trigger->get_field( $name );
|
|
|
|
if ( $field_obj ) {
|
|
$return[ $name ] = $field_obj->sanitize_value( $value );
|
|
}
|
|
}
|
|
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Get actions data for the workflow.
|
|
*
|
|
* Values will be formatted as per the fields set on the action object.
|
|
*
|
|
* @since 4.4.0
|
|
* @since 4.8.0 Added formatting to the fields.
|
|
*
|
|
* @return array
|
|
*/
|
|
function get_actions_data() {
|
|
$actions_data = $this->get_meta( 'actions' );
|
|
return is_array( $actions_data ) ? array_map( [ $this, 'format_action_fields' ], $actions_data ) : [];
|
|
}
|
|
|
|
/**
|
|
* Set the workflow actions data.
|
|
*
|
|
* Values will be sanitized as per the fields set on the action object. Data is
|
|
* only sanitized before write, not before read.
|
|
*
|
|
* todo: Update data structure to use separate name and options keys
|
|
*
|
|
* @since 4.4.0
|
|
*
|
|
* @param array $raw_actions_data
|
|
*/
|
|
function set_actions_data( $raw_actions_data ) {
|
|
$actions_data = array_map( [ $this, 'sanitize_action_fields' ], $raw_actions_data );
|
|
// remove empty values from actions array
|
|
$actions_data = array_filter( $actions_data );
|
|
$this->update_meta( 'actions', $actions_data );
|
|
unset( $this->actions );
|
|
}
|
|
|
|
/**
|
|
* Sanitizes a array of action fields for a single action.
|
|
*
|
|
* @since 4.4.0
|
|
*
|
|
* @param array $action_fields
|
|
*
|
|
* @return array
|
|
*/
|
|
function sanitize_action_fields( $action_fields ) {
|
|
try {
|
|
$action = $this->get_action_from_action_fields( $action_fields );
|
|
} catch ( Exception $e ) {
|
|
return [];
|
|
}
|
|
|
|
$sanitized = [
|
|
'action_name' => $action->get_name(),
|
|
];
|
|
|
|
foreach( $action_fields as $name => $value ) {
|
|
$name = Clean::string( $name );
|
|
$field_obj = $action->get_field( $name );
|
|
|
|
if ( $field_obj ) {
|
|
$field_value = $field_obj->sanitize_value( $value );
|
|
// encode emojis to avoid emoji serialization issues
|
|
$field_value = Clean::encode_emoji( $field_value );
|
|
$sanitized[ $name ] = $field_value;
|
|
}
|
|
}
|
|
|
|
return $sanitized;
|
|
}
|
|
|
|
/**
|
|
* Format action fields according to the field type.
|
|
*
|
|
* @since 4.8.0
|
|
*
|
|
* @param array $action_fields
|
|
*
|
|
* @return array
|
|
*/
|
|
public function format_action_fields( $action_fields ) {
|
|
try {
|
|
$action = $this->get_action_from_action_fields( $action_fields );
|
|
} catch ( Exception $e ) {
|
|
return [];
|
|
}
|
|
|
|
$formatted = [
|
|
'action_name' => $action->get_name(),
|
|
];
|
|
|
|
foreach ( $action_fields as $name => $value ) {
|
|
$name = Clean::string( $name );
|
|
$field_obj = $action->get_field( $name );
|
|
|
|
if ( $field_obj && $field_obj instanceof Formattable ) {
|
|
$value = $field_obj->format_value( $value );
|
|
}
|
|
|
|
$formatted[ $name ] = $value;
|
|
}
|
|
|
|
return $formatted;
|
|
}
|
|
|
|
/**
|
|
* @param array $rule_options
|
|
*/
|
|
function set_rule_data( $rule_options ) {
|
|
$this->update_meta( 'rule_options', $this->sanitize_rule_options( $rule_options ) );
|
|
}
|
|
|
|
|
|
/**
|
|
* @return array
|
|
*/
|
|
function get_rule_data() {
|
|
$data = $this->get_meta( 'rule_options' );
|
|
return is_array( $data ) ? $data : [];
|
|
}
|
|
|
|
/**
|
|
* Get the number of rule groups on the workflow.
|
|
*
|
|
* @since 5.0.0
|
|
*
|
|
* @return int
|
|
*/
|
|
public function get_rule_group_count() {
|
|
return count( $this->get_rule_data() );
|
|
}
|
|
|
|
/**
|
|
* Sanitizes all rule groups for a workflow.
|
|
*
|
|
* @since 4.4.0
|
|
*
|
|
* @param array $options
|
|
*
|
|
* @return array
|
|
*/
|
|
function sanitize_rule_options( $options ) {
|
|
if ( ! is_array( $options ) ) {
|
|
return [];
|
|
}
|
|
|
|
// Remove array key names from rules, as they are not needed.
|
|
$cleaned = [];
|
|
foreach ( $options as $rule_group ) {
|
|
$rule_group = array_map( [ $this, 'sanitize_rule_option' ], $rule_group );
|
|
$cleaned[] = array_values( $rule_group );
|
|
}
|
|
|
|
return $cleaned;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sanitizes a single rule.
|
|
*
|
|
* @param array $rule_fields
|
|
*
|
|
* @return array
|
|
* @since 4.3.0
|
|
*/
|
|
public function sanitize_rule_option( $rule_fields ) {
|
|
$name = Clean::string( $rule_fields['name'] );
|
|
$rule = Rules::get( $name );
|
|
|
|
if ( isset( $rule_fields['value'] ) && $rule ) {
|
|
$value = $rule->sanitize_value( $rule_fields['value'] );
|
|
} else {
|
|
// Rule may have been deleted in which case we don't need a value.
|
|
$value = '';
|
|
}
|
|
|
|
$sanitized = [
|
|
'name' => $name,
|
|
'compare' => isset( $rule_fields['compare'] ) ? Clean::string( $rule_fields['compare'] ) : '',
|
|
'value' => $value,
|
|
];
|
|
|
|
return $sanitized;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the log currently created by this workflow run.
|
|
* If false is returned the log record may not have been created.
|
|
*
|
|
* @return Log|bool
|
|
*/
|
|
function get_current_log() {
|
|
if ( isset( $this->log ) ) {
|
|
return $this->log;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Check if workflow is exempt from unsubscribing and allow filtering of unsubscribed prop.
|
|
*
|
|
* @param Customer $customer
|
|
* @return bool
|
|
*/
|
|
function is_customer_unsubscribed( $customer ) {
|
|
if ( $this->is_preview_mode() || $this->is_test_mode() ) {
|
|
return false;
|
|
}
|
|
|
|
if ( $this->is_exempt_from_unsubscribing() ) {
|
|
return false;
|
|
}
|
|
|
|
if ( ! $customer ) {
|
|
return false;
|
|
}
|
|
|
|
return apply_filters( 'automatewoo/workflow/is_customer_unsubscribed', $customer->is_unsubscribed(), $this, $customer );
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns false if the workflow is exempt from unsubscribing.
|
|
*
|
|
* @param Customer $customer
|
|
* @return bool|string
|
|
*/
|
|
function get_unsubscribe_url( $customer ) {
|
|
if ( ! $customer ) {
|
|
return false;
|
|
}
|
|
|
|
if ( $this->is_exempt_from_unsubscribing() ) {
|
|
return false;
|
|
}
|
|
// SEMGREP WARNING EXPLANATION
|
|
// This is escaped with esc_url_raw after, but semgrep only takes into consideration esc_url.
|
|
// Also, the URL is just the My Account Page. Not reaching any user input.
|
|
$url = add_query_arg(
|
|
[
|
|
'aw-action' => 'unsubscribe',
|
|
'workflow' => $this->get_id(),
|
|
'customer_key' => urlencode( $customer->get_key() ),
|
|
],
|
|
wc_get_page_permalink( 'myaccount' )
|
|
);
|
|
|
|
$url = apply_filters( 'automatewoo_unsubscribe_url', $url, $this->get_id(), $customer );
|
|
|
|
return esc_url_raw( $url );
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
function is_exempt_from_unsubscribing() {
|
|
$is_exempt = false;
|
|
|
|
// this avoids breaking changes for any customers using this gist: https://gist.github.com/danielbitzer/c25209057ba063ed4adcb6764049f1b6
|
|
if ( apply_filters( 'automatewoo_unsubscribe_url', home_url(), $this->get_id(), false ) === false ) {
|
|
$is_exempt = true;
|
|
}
|
|
|
|
if ( $this->get_meta('is_transactional') ) {
|
|
$is_exempt = true;
|
|
}
|
|
|
|
return apply_filters( 'automatewoo/workflow/is_exempt_from_unsubscribing', $is_exempt, $this->get_id(), $this );
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $user \WP_User or guest user
|
|
*
|
|
* @return bool
|
|
*/
|
|
function is_first_run_for_user( $user ) {
|
|
return $this->get_times_run_for_user( $user ) === 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* Counts items in log and in queue for this user and workflow
|
|
*
|
|
* @param $user \WP_User|Order_Guest
|
|
* @return int
|
|
*/
|
|
function get_times_run_for_user( $user ) {
|
|
$query = new Log_Query();
|
|
$query->where_workflow( $this->get_id() );
|
|
|
|
if ( $user->ID === 0 ) { // guest user
|
|
$query->where_guest( $user->user_email );
|
|
}
|
|
else {
|
|
$query->where_user( $user->ID );
|
|
}
|
|
|
|
return count( $query->get_results() );
|
|
}
|
|
|
|
|
|
/**
|
|
* Counts items in log and in queue for this user and workflow
|
|
*
|
|
* @param Customer $customer
|
|
* @return int
|
|
*/
|
|
function get_run_count_for_customer( $customer ) {
|
|
$query = new Log_Query();
|
|
$query->where_workflow( $this->get_id() );
|
|
$query->where_customer_or_legacy_user( $customer, true );
|
|
return $query->get_count();
|
|
}
|
|
|
|
|
|
/**
|
|
* @param \WC_Order $order
|
|
* @return int
|
|
*/
|
|
function get_run_count_for_order( $order ) {
|
|
$query = new Log_Query();
|
|
$query->where_workflow( $this->get_id() );
|
|
$query->where_order( $order->get_id() );
|
|
return $query->get_count();
|
|
}
|
|
|
|
/**
|
|
* @param \WP_Post $course
|
|
* @return int
|
|
*/
|
|
public function get_run_count_for_course( $course ) {
|
|
$query = new Log_Query();
|
|
$query->where_workflow( $this->get_id() );
|
|
$query->where_course( $course->ID );
|
|
return $query->get_count();
|
|
}
|
|
|
|
/**
|
|
* Get times this workflow has run for a given subscription.
|
|
*
|
|
* @since 5.0.0
|
|
*
|
|
* @param WC_Subscription $subscription
|
|
*
|
|
* @return int
|
|
*/
|
|
public function get_run_count_for_subscription( WC_Subscription $subscription ) {
|
|
return ( new Log_Query() )
|
|
->where_workflow( $this->get_id() )
|
|
->where_subscription( $subscription->get_id() )
|
|
->get_count();
|
|
}
|
|
|
|
|
|
/**
|
|
* Counts items in log and in queue for this guest and workflow
|
|
*
|
|
* @param $guest Guest
|
|
* @return int
|
|
*/
|
|
function get_times_run_for_guest( $guest ) {
|
|
$query = new Log_Query();
|
|
$query->where_workflow( $this->get_id() );
|
|
$query->where_guest( $guest->get_email() );
|
|
return $query->get_count();
|
|
}
|
|
|
|
|
|
/**
|
|
* Checks the logs to see if a workflow has already run for set data items.
|
|
* This checks the log and the queue if necessary.
|
|
*
|
|
* The $within_timeframe parameter defines how far back to look for when the workflow has run.
|
|
* If $timeframe is false then the query looks for all time.
|
|
*
|
|
* @since 3.8
|
|
*
|
|
* @param array|string $query_data_items Use the ID of the data item/s. When multiple values are supplied an AND query is used.
|
|
* E.g. Setting a product and customer will check if the workflow has run previously
|
|
* for the same product AND the same customer.
|
|
* @param int|false $within_timeframe in seconds
|
|
* @param bool $skip_queue_query
|
|
*
|
|
* @return bool
|
|
*/
|
|
function has_run_for_data_item( $query_data_items, $within_timeframe = false, $skip_queue_query = false ) {
|
|
if ( ! $this->is_setup ) {
|
|
return false;
|
|
}
|
|
|
|
$query_data_items = (array) $query_data_items;
|
|
|
|
$log_query = new Log_Query();
|
|
$log_query->where_workflow( $this->get_translation_ids() );
|
|
|
|
if ( $within_timeframe ) {
|
|
$timeframe_date = new DateTime();
|
|
$timeframe_date->setTimestamp( time() - $within_timeframe );
|
|
$log_query->where_date( $timeframe_date, '>' );
|
|
}
|
|
|
|
foreach ( $query_data_items as $data_item_id ) {
|
|
$log_query->where_data_layer( $data_item_id, $this->data_layer()->get_item( $data_item_id ) );
|
|
}
|
|
|
|
if ( $log_query->has_results() ) {
|
|
return true;
|
|
}
|
|
|
|
// check if something is in the queue
|
|
if ( $this->get_timing_type() !== 'immediately' && ! $skip_queue_query ) {
|
|
$queue_query = new Queue_Query();
|
|
$queue_query->where_workflow( $this->get_translation_ids() );
|
|
|
|
if ( isset( $timeframe_date ) ) {
|
|
$queue_query->where_date_created( $timeframe_date, '>' );
|
|
}
|
|
|
|
foreach ( $query_data_items as $data_item_id ) {
|
|
$queue_query->where_data_layer( $data_item_id, $this->data_layer()->get_item( $data_item_id ) );
|
|
}
|
|
|
|
if ( $queue_query->has_results() ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $name
|
|
* @param $item
|
|
*/
|
|
function set_data_item( $name, $item ) {
|
|
$this->data_layer()->set_item( $name, $item );
|
|
}
|
|
|
|
|
|
/**
|
|
* @param array|Data_Layer $data_layer
|
|
* @param bool $reset_workflow_data
|
|
*/
|
|
function set_data_layer( $data_layer, $reset_workflow_data ) {
|
|
|
|
if ( ! is_a( $data_layer, 'AutomateWoo\Data_Layer' ) ) {
|
|
$data_layer = new Data_Layer( $data_layer );
|
|
}
|
|
|
|
if ( $reset_workflow_data ) {
|
|
$this->reset_data();
|
|
}
|
|
|
|
$this->data_layer = $data_layer;
|
|
}
|
|
|
|
|
|
/**
|
|
* Retrieve and validate a data item
|
|
*
|
|
* @param $name string
|
|
* @return mixed
|
|
*/
|
|
function get_data_item( $name ) {
|
|
return $this->data_layer()->get_item( $name );
|
|
}
|
|
|
|
|
|
/**
|
|
* Is workflow active.
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function is_active() {
|
|
if ( ! $this->exists ) {
|
|
return false;
|
|
}
|
|
return $this->get_status() === 'active';
|
|
}
|
|
|
|
/**
|
|
* Get workflow status.
|
|
*
|
|
* Possible statuses are active|disabled|trash
|
|
*
|
|
* @since 4.6
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_status() {
|
|
$status = $this->post->post_status;
|
|
|
|
if ( 'publish' === $status || 'manual' === $this->get_type() ) {
|
|
$status = 'active';
|
|
}
|
|
elseif ( $status === 'aw-disabled' ) {
|
|
$status = 'disabled';
|
|
}
|
|
|
|
return $status;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $status active|disabled or publish|aw-disabled
|
|
*/
|
|
function update_status( $status ) {
|
|
|
|
if ( $status === 'active' ) {
|
|
$post_status = 'publish';
|
|
}
|
|
elseif ( $status === 'disabled' ) {
|
|
$post_status = 'aw-disabled';
|
|
}
|
|
else {
|
|
$post_status = $status;
|
|
}
|
|
|
|
wp_update_post([
|
|
'ID' => $this->get_id(),
|
|
'post_status' => $post_status
|
|
]);
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
function is_transactional() {
|
|
return (bool) $this->get_meta( 'is_transactional' );
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
function is_tracking_enabled() {
|
|
return (bool) $this->get_option( 'click_tracking' );
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
function is_conversion_tracking_enabled() {
|
|
return (bool) $this->get_option( 'conversion_tracking' );
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
function is_ga_tracking_enabled() {
|
|
return ( $this->is_tracking_enabled() && $this->get_ga_tracking_params() ) ;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
function get_ga_tracking_params() {
|
|
return trim( $this->get_option( 'ga_link_tracking', true ) );
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $url
|
|
* @return string
|
|
*/
|
|
function append_ga_tracking_to_url( $url ) {
|
|
|
|
if ( empty( $url ) || ! $this->is_ga_tracking_enabled() ) {
|
|
return $url;
|
|
}
|
|
|
|
$params = [];
|
|
parse_str( $this->get_ga_tracking_params(), $params );
|
|
|
|
// SEMGREP WARNING EXPLANATION
|
|
// URL is escaped later by the consumer.
|
|
return add_query_arg( $params, $url );
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
function get_order() {
|
|
return (int) $this->post->menu_order ?: 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return false|string
|
|
*/
|
|
function get_language() {
|
|
if ( Integrations::is_wpml() ) {
|
|
$info = wpml_get_language_information( null, $this->get_id() );
|
|
if ( is_array( $info ) )
|
|
return $info['language_code'];
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Return array with all versions of this workflow including the original
|
|
* @return array
|
|
*/
|
|
function get_translation_ids() {
|
|
|
|
if ( ! Integrations::is_wpml() ) {
|
|
return [ $this->get_id() ];
|
|
}
|
|
|
|
global $sitepress;
|
|
|
|
$ids = [];
|
|
|
|
$translations = $sitepress->get_element_translations( $this->get_id(), 'post_post', false, true );
|
|
|
|
if ( is_array( $translations ) ) {
|
|
foreach ( $translations as $translation ) {
|
|
$ids[] = $translation->element_id;
|
|
}
|
|
}
|
|
|
|
$ids[] = $this->get_id(); // sometimes wpml doesn't return default language id?
|
|
|
|
return Clean::ids( $ids );
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $key
|
|
* @param bool $single
|
|
* @return mixed
|
|
*/
|
|
function get_meta( $key, $single = true ) {
|
|
return get_post_meta( $this->get_id(), $key, $single );
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $key
|
|
* @param $value
|
|
* @return bool|int
|
|
*/
|
|
public function update_meta( $key, $value ) {
|
|
return update_post_meta( $this->get_id(), $key, $value );
|
|
}
|
|
|
|
|
|
/**
|
|
* Enabling preview mode also enables test mode
|
|
*/
|
|
function enable_preview_mode() {
|
|
$this->preview_mode = true;
|
|
$this->enable_test_mode();
|
|
}
|
|
|
|
|
|
/**
|
|
* Enable test mode
|
|
*/
|
|
function enable_test_mode() {
|
|
$this->test_mode = true;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
function is_test_mode() {
|
|
return $this->test_mode;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
function is_preview_mode() {
|
|
return $this->preview_mode;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param Action $action
|
|
* @param $note
|
|
*/
|
|
function log_action_note( $action, $note ) {
|
|
if ( ! $log = $this->get_current_log() ) {
|
|
return;
|
|
}
|
|
|
|
$log->add_note( $action->get_title() . ': ' . $note );
|
|
}
|
|
|
|
|
|
/**
|
|
* @param Action $action
|
|
* @param $error
|
|
*/
|
|
function log_action_error( $action, $error ) {
|
|
if ( ! $log = $this->get_current_log() ) {
|
|
return;
|
|
}
|
|
|
|
$log->add_note( $action->get_title() . ': ' . $error );
|
|
|
|
$log->set_has_errors( true );
|
|
$log->save();
|
|
}
|
|
|
|
|
|
/**
|
|
* Logs the error response from the Mailer class.
|
|
* Separates true mail errors from unsubscribes and blacklist errors and logs them accordingly.
|
|
*
|
|
* @param \WP_Error $error
|
|
* @param Action $action
|
|
*/
|
|
function log_action_email_error( $error, $action ) {
|
|
if ( ! $log = $this->get_current_log() ) {
|
|
return;
|
|
}
|
|
|
|
if ( $error->get_error_code() === 'email_unsubscribed' || $error->get_error_code() === 'email_blacklisted' ) {
|
|
$this->log_action_note( $action, $error->get_error_message() );
|
|
$log->set_has_blocked_emails( true );
|
|
$log->save();
|
|
}
|
|
else {
|
|
$this->log_action_error( $action, $error->get_error_message() );
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the location based on the customer in the workflow data layer.
|
|
*
|
|
* @return Workflow_Location
|
|
*/
|
|
function get_location() {
|
|
|
|
if ( ! isset( $this->location ) ) {
|
|
$this->location = new Workflow_Location( $this );
|
|
$this->location = apply_filters( 'automatewoo/workflow/location', $this->location, $this );
|
|
}
|
|
|
|
return $this->location;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return Workflow_Location
|
|
*/
|
|
function get_tax_location() {
|
|
|
|
if ( ! isset( $this->tax_location ) ) {
|
|
$this->tax_location = new Workflow_Location( $this, get_option( 'woocommerce_tax_based_on' ) );
|
|
$this->tax_location = apply_filters( 'automatewoo/workflow/tax_location', $this->tax_location, $this );
|
|
}
|
|
|
|
return $this->tax_location;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set tax location for the current workflow user
|
|
*
|
|
* @param $location
|
|
* @param $tax_class
|
|
* @return array
|
|
*/
|
|
function filter_tax_location( $location, $tax_class ) {
|
|
if ( 'base' === get_option( 'woocommerce_tax_based_on' ) ) {
|
|
return $location;
|
|
}
|
|
|
|
return $this->get_tax_location()->get_location_array();
|
|
}
|
|
|
|
|
|
/**
|
|
* @param $name
|
|
* @param $item
|
|
* @deprecated
|
|
*/
|
|
function add_data_item( $name, $item ) {
|
|
wc_deprecated_function( __METHOD__, '5.2.0' );
|
|
|
|
$this->set_data_item( $name, $item );
|
|
}
|
|
|
|
/**
|
|
* @deprecated use log_action_note
|
|
* @param Action $action
|
|
* @param $note
|
|
*/
|
|
function add_action_log_note( $action, $note ) {
|
|
wc_deprecated_function( __METHOD__, '5.2.0' );
|
|
|
|
$this->log_action_note( $action, $note );
|
|
}
|
|
|
|
/**
|
|
* Get an action based on field data.
|
|
*
|
|
* @since 4.8.0
|
|
*
|
|
* @param array $field_data
|
|
*
|
|
* @return Action The action object for the data.
|
|
* @throws Exception When the Action could not be resolved to an object.
|
|
*/
|
|
public function get_action_from_action_fields( $field_data ) {
|
|
if ( ! is_array( $field_data ) || ! isset( $field_data['action_name'] ) ) {
|
|
throw new Exception( 'Missing action_name key in array.' );
|
|
}
|
|
|
|
$action_name = Clean::string( $field_data['action_name'] );
|
|
$action = Actions::get( $action_name );
|
|
if ( ! $action ) {
|
|
throw new Exception( 'Could not retrieve the action.' );
|
|
}
|
|
|
|
return $action;
|
|
}
|
|
}
|
