1:   2:   3:   4:   5:   6:   7:   8:   9:  10:  11:  12:  13:  14:  15:  16:  17:  18:  19:  20:  21:  22:  23:  24:  25:  26:  27:  28:  29:  30:  31:  32:  33:  34:  35:  36:  37:  38:  39:  40:  41:  42:  43:  44:  45:  46:  47:  48:  49:  50:  51:  52:  53:  54:  55:  56:  57:  58:  59:  60:  61:  62:  63:  64:  65:  66:  67:  68:  69:  70:  71:  72:  73:  74:  75:  76:  77:  78:  79:  80:  81:  82:  83:  84:  85:  86:  87:  88:  89:  90:  91:  92:  93:  94:  95:  96:  97:  98:  99: 100: 101: 102: 103: 104: 105: 106: 107: 108: 109: 110: 111: 112: 113: 114: 115: 116: 117: 118: 119: 120: 121: 122: 123: 124: 125: 126: 127: 128: 129: 130: 131: 132: 133: 134: 135: 136: 137: 138: 139: 140: 141: 142: 143: 144: 145: 146: 147: 148: 149: 150: 151: 152: 153: 154: 155: 156: 157: 158: 159: 160: 161: 162: 163: 164: 165: 166: 167: 168: 169: 170: 171: 172: 173: 174: 175: 176: 177: 178: 179: 180: 181: 182: 183: 184: 185: 186: 187: 188: 189: 190: 191: 192: 193: 194: 195: 196: 197: 198: 199: 200: 201: 202: 203: 204: 205: 206: 207: 208: 209: 210: 211: 212: 213: 214: 215: 216: 217: 218: 219: 220: 221: 222: 223: 224: 225: 226: 227: 228: 229: 230: 231: 232: 233: 234: 235: 236: 237: 238: 239: 240: 241: 242: 243: 244: 245: 246: 247: 248: 249: 250: 251: 252: 253: 254: 255: 256: 257: 258: 259: 260: 261: 262: 263: 264: 265: 266: 267: 268: 269: 270: 271: 272: 273: 274: 275: 276: 277: 278: 279: 280: 281: 282: 283: 284: 285: 286: 287: 288: 289: 290: 291: 292: 293: 294: 295: 296: 297: 298: 299: 300: 301: 302: 303: 304: 305: 306: 307: 308: 309: 310: 311: 312: 313: 314: 315: 316: 317: 318: 319: 320: 321: 322: 323: 324: 325: 326: 327: 328: 329: 330: 331: 332: 333: 334: 335: 336: 337: 338: 339: 340: 341: 342: 343: 344: 345: 346: 347: 348: 349: 350: 351: 352: 353: 354: 355: 356: 357: 358: 359: 360: 361: 362: 363: 364: 365: 366: 367: 368: 369: 370: 371: 372: 373: 374: 375: 376: 377: 378: 379: 380: 381: 382: 383: 384: 385: 386: 387: 388: 389: 390: 391: 392: 393: 394: 395: 396: 397: 398: 399: 400: 401: 402: 403: 404: 405: 406: 407: 408: 409: 410: 411: 412: 413: 414: 415: 416: 417: 418: 419: 420: 421: 422: 423: 424: 425: 426: 427: 428: 429: 430: 431: 432: 433: 434: 435: 436: 437: 438: 439: 440: 441: 442: 443: 444: 445: 446: 447: 448: 449: 450: 451: 452: 453: 454: 455: 456: 457: 458: 459: 460: 461: 462: 463: 464: 465: 466: 467: 468: 469: 470: 471: 472: 473: 474: 475: 476: 477: 478: 479: 480: 481: 482: 483: 484: 485: 486: 487: 488: 489: 490: 491: 492: 493: 494: 495: 496: 497: 498: 499: 500: 501: 502: 503: 504: 505: 506: 507: 508: 509: 510: 511: 512: 513: 514: 515: 516: 517: 518: 519: 520: 521: 522: 523: 524: 525: 526: 527: 528: 529: 530: 531: 532: 533: 534: 535: 536: 537: 538: 539: 540: 541: 542: 543: 544: 545: 546: 547: 548: 549: 550: 551: 552: 553: 554: 555: 556: 557: 558: 559: 560: 561: 562: 563: 564: 565: 566: 567: 568: 569: 570: 571: 572: 573: 574: 575: 576: 577: 578: 579: 580: 581: 582: 583: 584: 585: 586: 587: 588: 589: 590: 591: 592: 593: 594: 595: 596: 597: 598: 599: 600: 601: 602: 603: 604: 605: 606: 607: 608: 609: 610: 611: 612: 613: 614: 615: 616: 617: 618: 619: 620: 621: 622: 623: 624: 625: 626: 627: 628: 629: 630: 631: 632: 633: 634: 635: 636: 637: 638: 639: 640: 641: 642: 643: 644: 645: 646: 647: 648: 649: 650: 651: 652: 653: 654: 655: 656: 657: 658: 659: 660: 661: 662: 663: 664: 665: 666: 667: 668: 669: 670: 671: 672: 673: 674: 675: 676: 677: 678: 679: 680: 681: 682: 683: 684: 685: 686: 687: 688: 689: 690: 691: 692: 693: 

<?php

/**
 * Class for registering and loading automation definitions, filters, and queries
 * @package     Automation
 * @subpackage  Rules
 */

if (!class_exists('Inbound_Automation_Loader')) {


    class Inbound_Automation_Loader {

        public static $instance; /* data object will hold all definitions below */
        public static $triggers; /* dataset containing defined trigger hooks */
        public static $rule; /* dataset containing rule settings */
        public static $rules; /* dataset containing inbound automation rules */
        public static $job_id; /* dataset job task id in inbound_automation_queue */
        public static $compare_options; /* array of acceptable comparision options */
        public static $argument_filters; /* dataset of agrument filters */
        public static $db_lookup_filters;
        public static $actions;
        public static $inbound_arguments; /* dataset that holds information on registered hooks */

        /**
         *  Initialize singleton class
         */
        public static function init() {

            /* return class instance if alredy defined */
            if (isset(self::$instance)) {
                return self::$instance;
            }

            //global $inbound_sid;
            //error_log($inbound_sid);

            /* create object */
            self::$instance = new stdClass();

            /* Load Rules */
            self::load_rules();
            self::load_arguments();
            self::load_compare_options();

            /* Load Automation Setting Definitions */
            self::define_triggers();
            self::define_arguments();
            self::define_actions();
            self::define_db_lookup_filters();

            /* Add Trigger Listeners to Hooks */
            self::add_trigger_listeners();

            return self::$instance;
        }

        /**
         *  Load Rules from CPT and set them into static variatiable
         */
        public static function load_rules() {

            $rules = get_posts(array(
                    'post_type' => 'automation',
                    'post_status' => 'publish',
                    'posts_per_page' => -1
                )
            );


            self::$instance->rules = ($rules) ? $rules : array();

        }

        /**
         *  Loads rule settings
         * @param INT $rule_id
         */
        public static function load_rule($rule_id) {
            self::$rule = get_post_meta($rule_id, 'inbound_rule', true);
            self::$rule['ID'] = $rule_id;
        }

        /**
         *  Loads hook argument data from wp_options
         */
        public static function load_arguments() {
            $inbound_arguments = Inbound_Options_API::get_option('inbound_automation', 'arguments');

            self::$instance->inbound_arguments = ($inbound_arguments) ? $inbound_arguments : array();
        }

        /**
         *  Loads possible compare options for filtering
         */
        public static function load_compare_options() {

            /* Build Compare Options */
            $compare_args = array(
                'greater-than' => __('Greater Than', 'automation'),
                'greater-than-equal-to' => __('Greater Than Or Equal To', 'automation'),
                'less-than' => __('Less Than', 'automation'),
                'less-than-equal-to' => __('Less Than Or Equal To', 'automation'),
                'contains' => __('Contains', 'automation'),
                'equals' => __('Equals', 'automation')
            );

            /* Extend Compare Options */
            self::$instance->compare_options = apply_filters('inbound_automation_compare_args', $compare_args);

        }


        /**
         *  Load Triggers into Static Variable
         */
        public static function define_triggers() {
            self::$instance->triggers = apply_filters('inbound_automation_triggers', array());
        }

        /**
         *    Define Argument Filters
         */
        public static function define_arguments() {

            self::$instance->argument_filters = array();

            /*
            error_log(print_r(self::$instance->triggers,true));
            error_log(print_r(self::$instance->inbound_arguments , true));
            exit;
            */

            /* Loop Through Trigger Arguments & Build Trigger Filter Setting Array */
            foreach (self::$instance->triggers as $hook => $trigger) {

                /* Load Historic Argument Keys Associated With Trigger Hook */
                $args = (isset(self::$instance->inbound_arguments[$hook])) ? self::$instance->inbound_arguments[$hook] : array();

                foreach ($trigger['arguments'] as $id => $argument) {

                    $keys = array();

                    /* cycle through data and prepare keys*/
                    if (isset($args[$id]) && is_array($args[$id])) {


                        $count = count($args[$id]);
                        $c = 0;
                        foreach ($args[$id] as $arg_key => $arg_value) {

                            if (is_array($arg_value) || is_numeric($arg_key)) {
                                $c++;
                                $arg_value = json_encode($arg_value);
                            }

                            $keys[$id . ':' . $arg_key] = $arg_key . ' (' . $arg_value . ')';
                        }

                        if ($c == $count) {
                            $keys[$id] = $argument['label'] . ' (' . json_encode($args[$id]) . ')';
                        }

                    } else if (isset($args[$id])) {
                        $args[$id] = strip_tags($args[$id]);
                        $keys[$id] = $argument['label'] . ' (' . $args[$id] . ')';
                    }

                    /* account for empty arguments */
                    if (!isset($keys[$id]) || !$keys[$id]) {
                        $keys[$id] = $argument['label'];
                    }

                    /* Build Trigger Filter Data */
                    self::$instance->argument_filters[$hook][$argument['id']] = array(
                        'id' => $argument['id'],
                        'label' => $argument['label'],
                        'key_input_type' => 'dropdown',
                        'keys' => $keys,
                        'compare' => self::$instance->compare_options,
                        'value_input_type' => 'text',
                        'values' => false
                    );
                }
            }

            self::$instance->argument_filters = apply_filters('inbound_automation_arguments', self::$instance->argument_filters);
        }


        /* Define DB Lookup Filters */
        public static function define_db_lookup_filters() {

            $db_lookup_filters = array();
            $loaded = array();


            /* Loop Through Trigger Arguments & Build Filter Setting Array */
            foreach (self::$instance->triggers as $hook => $trigger) {

                if (!isset($trigger['db_lookup_filters'])) {
                    continue;
                }

                foreach ($trigger['db_lookup_filters'] as $db_lookup_filter) {

                    /* Make sure a class referrence exists in db lookup options */
                    if (!isset($db_lookup_filter['class_name'])) {
                        continue;
                    }

                    /* Get Class Name */
                    $class = $db_lookup_filter['class_name'];

                    /* make sure class exists */
                    if (!class_exists($class)) {
                        continue;
                    }

                    /* Load Queries Only Once */
                    if (array_key_exists($db_lookup_filter['id'], $db_lookup_filters)) {
                        continue;
                    }

                    /* Load Available Queries DB Lookup Class */
                    $keys = $class::get_key_map();

                    if (!$keys) {
                        $keys = array('-1' => 'No Options Detected');
                    }

                    /* Build Trigger Filter Data */
                    $db_lookup_filters[$db_lookup_filter['id']] = array(
                        'class_name' => $db_lookup_filter['class_name'],
                        'id' => $db_lookup_filter['id'],
                        'label' => $db_lookup_filter['label'],
                        'key_input_type' => 'dropdown',
                        'keys' => $keys,
                        'compare' => self::$instance->compare_options,
                        'value_input_type' => 'text',
                        'values' => false
                    );

                }
            }

            self::$instance->db_lookup_filters = apply_filters('inbound_automation_db_lookup_filters', $db_lookup_filters);

        }

        /**
         *  Source actions from hook
         */
        public static function define_actions() {
            self::$instance->actions = apply_filters('inbound_automation_actions', array());
        }

        /* Adds Listener Hooks for Building Filters and Rule Processings */
        public static function add_trigger_listeners() {
            foreach (self::$instance->triggers as $hook_name => $trigger) {
                if (isset($trigger['action_hook'])) {
                    add_action($trigger['action_hook'], array(__CLASS__, 'process_trigger'), 10, count($trigger['arguments']));
                }
            }
        }

        /**
         *  Checks a fired trigger for a match and schedules job
         */
        public static function process_trigger() {

            $trigger = current_filter();
            $args = func_get_args();

            /* prevent repeat processing  */
            foreach (self::$instance->triggers as $hook_name => $trigger_hook) {
                if (isset($trigger['action_hook']) && $trigger['action_hook'] == $hook_name) {
                    remove_action($trigger['action_hook'], array(__CLASS__, 'process_trigger'), 10, count($trigger_hook['arguments']));
                }
            }

            foreach (self::$instance->rules as $rule) {

                self::load_rule($rule->ID);
                $rule->settings = self::$rule;

                if (isset(self::$rule['status']) && self::$rule['status'] == 'off') {
                    continue;
                }

                if (!isset(self::$rule['trigger'])) {
                    continue;
                }

                if (self::$rule['trigger'] == $trigger) {

                    $evaluate = true;
                    $evals = array();

                    $arguments = self::generate_arguments($trigger, $args);

                    /* Check Trigger Filters */
                    if (isset(self::$rule['trigger_filters']) && self::$rule['trigger_filters']) {

                        foreach (self::$rule['trigger_filters'] as $filter) {
                            if (strstr($filter['trigger_filter_key'], ':')) {
                                $parts = explode(':', $filter['trigger_filter_key']);
                                $target_argument = (isset($arguments[$parts[0]][$parts[1]])) ? $arguments[$parts[0]][$parts[1]] : null;
                            } else {
                                $target_argument = $arguments[$filter['trigger_filter_id']];
                            }

                            $evals[] = self::evaluate_trigger_filter($filter, $target_argument);
                        }

                        /* Check Evaluation Nature for Final Decision */
                        $evaluate = self::evaluate_arguments(self::$rule['trigger_filters_evaluate'], $evals);
                    }

                    /* Log Event */
                    self::record_trigger_event($rule, $arguments, $trigger, $evaluate, $evals, self::$rule['trigger_filters_evaluate']);

                    /* Add Job to Queue if Passes Trigger Filters */
                    if ($evaluate) {

                        self::$job_id = Inbound_Automation_Processing::add_job_to_queue(self::$rule, $arguments);

                        /* Log Evaluation Message */
                        self::record_schedule_event($rule, $arguments, $trigger, $evaluate);

                        /* check if rule is set to run immediately */

                        if (isset(self::$rule['defer']) && self::$rule['defer'] == 'off') {
                            inbound_record_log(__('Process Immediately', 'inbound-pro'), '-', $rule->ID, '-', 'trigger_event');
                            Inbound_Automation_Processing::process_rules();
                        } else {
                            inbound_record_log(__('Processing Deferred', 'inbound-pro'),  print_r(self::$rule,true), $rule->ID, '-', 'trigger_event');

                        }
                    }

                }
            }

        }

        /*
        * Evaluate All Filters Based on Evaluation Condition
        */
        public static function evaluate_arguments($eval_nature, $evals) {

            switch ($eval_nature) {
                case 'match-any' :
                    foreach ($evals as $eval) {
                        if ($eval['eval']) {
                            $evaluate = true;
                            break;
                        } else {
                            $evaluate = false;
                        }
                    }

                    BREAK;

                case 'match-all' :
                    $i_evals = count($evals);
                    $e = 0;
                    $evaluate = false;

                    foreach ( $evals as $eval ) {
                        if ($eval['eval']) {
                            $e++;
                        }
                    }

                    if ($e == $i_evals) {
                        $evaluate = true;
                    }
                    BREAK;

                case 'match-none' :
                    foreach ($evals as $eval) {
                        if ($eval['eval']) {
                            $evaluate = false;
                            break;
                        } else {
                            $evaluate = true;

                        }
                    }

                    BREAK;
            }

            return $evaluate;
        }


        /*
        * Get Argument Key From Trigger
        */
        public static function get_argument_key_from_trigger($argument, $trigger) {

            foreach (self::$instance->triggers[$trigger]['arguments'] as $key => $arg) {

                if ($argument['trigger_filter_id'] == $arg['id']) {
                    return $key;
                }
            }

        }

        /*
        * Evaluate Filter By Comparing Filter with Corresponding Incoming Data
        */
        public static function evaluate_trigger_filter($filter, $target_argument) {

            if (!is_array($target_argument)) {
                $arg = $target_argument;
                $target_argument = array();
                $target_argument[$filter['trigger_filter_key']] = $arg;
            } else {
                $target_argument[$filter['trigger_filter_key']] = Inbound_Automation_Loader::flatten_array($target_argument);
            }

            $compare_value = (isset($target_argument[$filter['trigger_filter_key']])) ? $target_argument[$filter['trigger_filter_key']] : __('notset', 'inbound-pro');
            $eval = false;

            if (isset($target_argument[$filter['trigger_filter_key']])) {
                switch ($filter['trigger_filter_compare']) {

                    case 'greater-than' :
                        if ($filter['trigger_filter_value'] < $compare_value) {
                            $eval = true;
                        }
                        BREAK;
                    case 'greater-than-equal-to' :
                        if ($filter['trigger_filter_value'] <= $compare_value) {
                            $eval = true;
                        }
                        BREAK;
                    case 'less-than' :
                        if ($filter['trigger_filter_value'] > $compare_value) {
                            $eval = true;
                        }
                        BREAK;
                    case 'less-than-equal-to' :
                        if ($filter['trigger_filter_value'] >= $compare_value) {
                            $eval = true;
                        }
                        BREAK;

                    case 'contains' :
                        if (stristr($compare_value, $filter['trigger_filter_value'])) {
                            $eval = true;
                        }
                        BREAK;

                    case 'equals' :

                        if ($filter['trigger_filter_value'] == $compare_value) {
                            $eval = true;
                        }
                        BREAK;
                }
            }

            return array(
                'filter_key' => $filter['trigger_filter_key'],
                'filter_compare' => $filter['trigger_filter_compare'],
                'filter_value' => $filter['trigger_filter_value'],
                'compare_value' => $compare_value,
                'eval' => $eval
            );

        }

        /*
        * Record Trigger Event in Logs
        */
        public static function record_trigger_event($rule, $arguments, $trigger, $evaluate, $evals, $eval_nature) {

            $evaluate = (!$evaluate) ? __('Blocked', 'ma') : __('Passed', 'ma');

            $message = "<h2>" . __('Trigger', 'inbound-pro') . "</h2>";
            $message .= "<br><pre>" . $trigger . '</pre></p>';
            $message .= "<h2>" . __('Trigger Filter Evaluation', 'inbound-pro') . "</h2>";
            $message .= "<p>" . __('Evaluation Result:', 'inbound-pro') . "<br><pre>" . $evaluate . "</pre></p>";
            $message .= "<h2>" . __('Evaluation Condition:', 'inbound-pro') . "</h2><br><pre>" . $eval_nature . "</pre></p>";
            $message .= "<p>" . __('Evaluation Details:', 'inbound-pro') . "<br><pre>" . print_r($evals, true) . "</pre></p>";
            $message .= "<p><h2>" . __('Rule Settings:', 'inbound-pro') . "</h2> <br> <pre>" . print_r($rule, true) . "</pre></p>";
            $message .= "<p><h2>" . __('Trigger Data:', 'inbound-pro') . "</h2> <br> <pre>" . print_r($arguments, true) . '</pre></p>';

            inbound_record_log(__('Trigger Fired', 'inbound-pro'), $message, $rule->ID, '-', 'trigger_event');
        }

        /*
        * Record Schedule Event in Logs
        * @param OBJECT $rule contains information about rule being ran
        * @param ARRAY $arguments contains trigger(hook) argument data
        */
        public static function record_schedule_event($rule, $arguments) {

            $message = "<p><h2>" . __('Rule Settings:', 'inbound-pro') . "</h2> <br> <pre>" . print_r($rule, true) . '</pre></p>';
            $message .= "<p><h2>" . __('Trigger Data:', 'inbound-pro') . "</h2> <br> <pre>" . print_r($arguments, true) . '</pre></p>';


            inbound_record_log(__('Scheduling Job', 'inbound-pro'), $message, $rule->ID, '-', 'schedule_event');
        }

        /**
         * This method creates a key->value data map of data being passed from a trigger hook
         * This data is used to assist in designing filters for triggers
         */
        public static function generate_arguments($hook, $args) {

            /* loop through arguments and update memory with available data with latest submission */
            $argument_definitions = self::$instance->triggers[$hook]['arguments'];

            foreach ($args as $key => $argument) {

                /* Get first argument definition in the definition array */
                $definition = array_shift($argument_definitions);

                /* if there is a call back run it */
                if (isset($definition['callback'])) {
                    if (is_array($definition['callback'])) {
                        $argument = call_user_func(
                            array(
                                $definition['callback'][0],
                                $definition['callback'][1]
                            ),
                            $argument
                        );
                    }
                }

                /* Place argument data into memory */
                $updated_arg_data = self::prepare_mixed_data( $argument);

                if (isset(self::$instance->inbound_arguments[$hook][$definition['id']]) && is_array(self::$instance->inbound_arguments[$hook][$definition['id']])) {
                    self::$instance->inbound_arguments[$hook][$definition['id']] = array_replace(self::$instance->inbound_arguments[$hook][$definition['id']], $updated_arg_data);
                } else {
                   self::$instance->inbound_arguments[$hook][$definition['id']] = $updated_arg_data;
                }

            }


            /* eject historical arguments that are no longer supported */
            foreach (self::$instance->inbound_arguments[$hook] as $arg_key => $arg_definition) {
                if (!array_key_exists($arg_key ,self::$instance->triggers[$hook]['arguments'])) {
                    unset(self::$instance->inbound_arguments[$hook][$arg_key]);
                }
            }

            /* update inbound arguments dataset with new data */
            self::update_arguments();

            /* do not use old data stored in memory when no new data available */
            $i = 0;

            foreach (self::$instance->inbound_arguments[$hook] as $key=> $arg) {

                /* pass argument through callback if callback available */
                if (isset(self::$instance->triggers[$hook]['arguments'][$key]['callback'])) {
                    $corresponding_array = call_user_func(
                        array(
                            self::$instance->triggers[$hook]['arguments'][$key]['callback'][0],
                            self::$instance->triggers[$hook]['arguments'][$key]['callback'][1],
                        ),
                        $args[$i]
                    );
                } else {
                    $corresponding_array = $args[$i];
                }

                /* Skip non array based arguments  */
                if (!is_array($corresponding_array)) {
                    continue;
                }

                /* argument contains an array - clean memory of unavailable data */
                foreach($arg as $k => $value) {
                    if (!isset($corresponding_array[$k])) {
                        unset(self::$instance->inbound_arguments[$hook][$key][$k]);
                    }
                }
                $i++;
            }


            /* return arguments */
            return self::$instance->inbound_arguments[$hook];

        }

        /**
         * Takes a multidimensional argument array and flattens it
         */
        public static function flatten_array($array) {
            $flatten = array();

            foreach ($array as $k => $value) {
                if (is_numeric($k)) {
                    continue;
                }

                if (is_array($value)) {
                    foreach ($value as $k1 => $v1) {
                        if (is_array($v1)) {
                            $v1 = json_encode($v1);
                        }
                        $flatten[$k . ':' . $k1] = $v1;
                    }
                } else {
                    $flatten[$k] = $value;
                }
            }

            if (!$flatten) {
                $flatten = json_encode($array);
            }

            return $flatten;
        }

        /**
         *  Updates the dataset that contains information on our tracked hooks
         */
        public static function update_arguments() {
            if (self::$instance->inbound_arguments) {
                //error_log(print_r( self::$instance->inbound_arguments,true));
                Inbound_Options_API::update_option('inbound_automation', 'arguments', self::$instance->inbound_arguments);
            }
        }

        /**
         * checks if json
         */
        public static function prepare_mixed_data( $mixed) {

            if (is_object($mixed)) {
                $mixed = (array) $mixed;
            }

            if ( is_array($mixed) ) {
                foreach ($mixed as $key => $value) {
                    $mixed[$key] = self::prepare_mixed_data( $value);
                }
                return $mixed;
            }

            /* check if json */
            json_decode(stripslashes($mixed));
            if (json_last_error() == JSON_ERROR_NONE) {
                return json_decode($mixed, true);
            }

            /* check if parse string */
            if (strstr($mixed, '=') && !strstr(trim($mixed), ' ')) {
                parse_str($mixed, $matches);
                if (count($matches) > 1) {
                    return $matches;
                }
            }

            /* return normal string */
            return $mixed;

        }


    }

    /**
     *  Loads inbound automation defintitions into init at priority 20
     */
    function inbound_automation_load_definitions() {
        $GLOBALS['Inbound_Automation_Loader'] = Inbound_Automation_Loader::init();
        return $GLOBALS['Inbound_Automation_Loader'];
    }

    /**
     *  load loader in init when not running ajax
     */
    add_action('init', 'inbound_automation_load_definitions', 1);

    /* for debugging */
    $GLOBALS['inbound_sid'] = rand(100, 200);
}