Ninja_Forms_Processing

Ninja Forms Processing class.

Defined (1)

The class is defined in the following location(s).

/deprecated/includes/display/processing/class-ninja-forms-processing.php  
  1. class Ninja_Forms_Processing { 
  2.  
  3.     /** 
  4.      * 
  5.      * Stores the data accessed by the other parts of the class. 
  6.      * All response messages will be stored in this value. 
  7.      * 
  8.      * @var array 
  9.      * @access private 
  10.      */ 
  11.     var $data = array(); 
  12.  
  13.     /** 
  14.      * Constructor - Sets up the form ID. 
  15.      * 
  16.      * If the form_ID parameter is empty then nothing will be done. 
  17.      * 
  18.      */ 
  19.     function __construct($form_ID = '') { 
  20.         if(empty($form_ID)) { 
  21.             return false; 
  22.         }else{ 
  23.             $this->data['form_ID'] = $form_ID; 
  24.             $user_ID = get_current_user_id(); 
  25.             if(!$user_ID) { 
  26.                 $user_ID = ''; 
  27.             } 
  28.             $this->data['user_ID'] = $user_ID; 
  29.         } 
  30.     } 
  31.  
  32.     /** 
  33.      * Add the submitted vars to $this->data['fields']. 
  34.      * Also runs any functions registered to the field's pre_process hook. 
  35.      * 
  36.      * 
  37.      */ 
  38.     function setup_submitted_vars() { 
  39.         global $ninja_forms_fields, $wp; 
  40.         $form_ID = $this->data['form_ID']; 
  41.  
  42.         //Get our plugin settings 
  43.         $plugin_settings = nf_get_settings(); 
  44.         $req_field_error = __( $plugin_settings['req_field_error'], 'ninja-forms' ); 
  45.  
  46.         if ( empty ( $this->data ) ) 
  47.             return ''; 
  48.          
  49.         $this->data['action'] = 'submit'; 
  50.         $this->data['form']['form_url'] = $this->get_current_url(); 
  51.         $cache = ( Ninja_Forms()->session->get( 'nf_cache' ) ) ? Ninja_Forms()->session->get( 'nf_cache' ) : null; 
  52.  
  53.         // If we have fields in our $_POST object, then loop through the $_POST'd field values and add them to our global variable. 
  54.         if ( isset ( $_POST['_ninja_forms_display_submit'] ) OR isset ( $_POST['_ninja_forms_edit_sub'] ) ) { 
  55.             $field_results = ninja_forms_get_fields_by_form_id($form_ID); 
  56.             //$field_results = apply_filters('ninja_forms_display_fields_array', $field_results, $form_ID); 
  57.  
  58.             foreach( $field_results as $field ) { 
  59.                 $data = $field['data']; 
  60.                 $field_id = $field['id']; 
  61.                 $field_type = $field['type']; 
  62.  
  63.                 if ( isset ( $_POST['ninja_forms_field_' . $field_id ] ) ) { 
  64.                     $val = ninja_forms_stripslashes_deep( $_POST['ninja_forms_field_' . $field_id ] ); 
  65.                     $this->data['submitted_fields'][] = $field_id; 
  66.                 } else { 
  67.                     $val = false; 
  68.                 } 
  69.  
  70.                 $val = nf_wp_kses_post_deep( $val ); 
  71.  
  72.                 $this->data['fields'][$field_id] = $val; 
  73.                 $field_row = ninja_forms_get_field_by_id( $field_id ); 
  74.                 $field_row['data']['field_class'] = 'ninja-forms-field'; 
  75.                 $this->data['field_data'][$field_id] = $field_row; 
  76.             } 
  77.  
  78.             foreach($_POST as $key => $val) { 
  79.                 if(substr($key, 0, 1) == '_') { 
  80.                     $this->data['extra'][$key] = $val; 
  81.                 } 
  82.             } 
  83.  
  84.             //Grab the form info from the database and store it in our global form variables. 
  85.             $form_row = ninja_forms_get_form_by_id($form_ID); 
  86.             $form_data = $form_row['data']; 
  87.  
  88.             if(isset($_REQUEST['_sub_id']) AND !empty($_REQUEST['_sub_id'])) { 
  89.                 $form_data['sub_id'] = absint ( $_REQUEST['_sub_id'] ); 
  90.             }else{ 
  91.                 $form_data['sub_id'] = ''; 
  92.             } 
  93.  
  94.             //Loop through the form data and set the global $ninja_form_data variable. 
  95.             if(is_array($form_data) AND !empty($form_data)) { 
  96.                 foreach($form_data as $key => $val) { 
  97.                     if(!is_array($val)) { 
  98.                         $value = stripslashes($val); 
  99.                         $value = nf_wp_kses_post_deep( $value ); 
  100.                         //$value = htmlspecialchars($value); 
  101.                     }else{ 
  102.                         $value = nf_wp_kses_post_deep( $val ); 
  103.                     } 
  104.                     $this->data['form'][$key] = $value; 
  105.                 } 
  106.                 $this->data['form']['admin_attachments'] = array(); 
  107.                 $this->data['form']['user_attachments'] = array(); 
  108.             } 
  109.  
  110.         } else if ( $cache !== null ) { // Check to see if we have cached values from a submission. 
  111.             if ( is_array ( $cache['field_values'] ) ) { 
  112.                 // We do have a submission contained in our cache. We'll populate the field values with that data. 
  113.                 foreach ( $cache['field_values'] as $field_id => $val ) { 
  114.                     $field_row = ninja_forms_get_field_by_id($field_id); 
  115.                     if(is_array($field_row) AND !empty($field_row)) { 
  116.                         if(isset($field_row['type'])) { 
  117.                             $field_type = $field_row['type']; 
  118.                         }else{ 
  119.                             $field_type = ''; 
  120.                         } 
  121.                         if(isset($field_row['data']['req'])) { 
  122.                             $req = $field_row['data']['req']; 
  123.                         }else{ 
  124.                             $req = ''; 
  125.                         } 
  126.  
  127.                         $val = ninja_forms_stripslashes_deep( $val ); 
  128.                         $val = nf_wp_kses_post_deep( $val ); 
  129.  
  130.                         $this->data['fields'][$field_id] = $val; 
  131.                         if ( isset ( $cache['field_settings'][$field_id] ) ) { 
  132.                             $field_row = $cache['field_settings'][$field_id]; 
  133.                         } else { 
  134.                             $field_row = ninja_forms_get_field_by_id( $field_id ); 
  135.                         } 
  136.  
  137.                         $field_row['data']['field_class'] = 'ninja-forms-field'; 
  138.                          
  139.                         $this->data['field_data'][$field_id] = $field_row; 
  140.                     } 
  141.                 } 
  142.             } 
  143.             $this->data['form'] = $cache['form_settings']; 
  144.             $this->data['success'] = $cache['success_msgs']; 
  145.             $this->data['errors'] = $cache['error_msgs']; 
  146.             $this->data['extra'] = $cache['extra_values']; 
  147.              
  148.         } 
  149.  
  150.     } // Submitted Vars function 
  151.  
  152.     /** 
  153.      * Submitted Values Methods: 
  154.      * 
  155.     **/ 
  156.  
  157.     /** 
  158.      * Retrieve the form ID of the form currently being processed. 
  159.      * 
  160.      */ 
  161.     function get_form_ID() { 
  162.         if ( empty($this->data) ) { 
  163.             return false; 
  164.         }else{ 
  165.             return $this->data['form_ID']; 
  166.         } 
  167.     } 
  168.  
  169.     /** 
  170.      * Retrieve the User ID of the form currently being processed. 
  171.      * 
  172.      */ 
  173.     function get_user_ID() { 
  174.         if ( empty($this->data) ) { 
  175.             return false; 
  176.         }else{ 
  177.             return $this->data['user_ID']; 
  178.         } 
  179.     } 
  180.  
  181.     /** 
  182.      * Set the User ID of the form currently being processed. 
  183.      * 
  184.      */ 
  185.     function set_user_ID( $user_id ) { 
  186.         if ( empty($this->data) ) { 
  187.             return false; 
  188.         }else{ 
  189.             return $this->data['user_ID'] = $user_id; 
  190.         } 
  191.     } 
  192.  
  193.     /** 
  194.      * Retrieve the action currently being performed. 
  195.      * 
  196.      */ 
  197.     function get_action() { 
  198.         if ( empty($this->data['action']) ) { 
  199.             return false; 
  200.         }else{ 
  201.             return $this->data['action']; 
  202.         } 
  203.     } 
  204.  
  205.     /** 
  206.      * Set the action currently being performed. 
  207.      * 
  208.      */ 
  209.     function set_action( $action ) { 
  210.         if ( empty($this->data) ) { 
  211.             return false; 
  212.         }else{ 
  213.             return $this->data['action'] = $action; 
  214.         } 
  215.     } 
  216.  
  217.     /** 
  218.      * Retrieve all the fields attached to a form. 
  219.      * 
  220.      */ 
  221.     function get_all_fields() { 
  222.         if ( empty($this->data['fields']) ) { 
  223.             return false; 
  224.         }else{ 
  225.             return $this->data['fields']; 
  226.         } 
  227.     } 
  228.  
  229.     /** 
  230.      * Retrieve all the user submitted form data. 
  231.      * 
  232.      */ 
  233.     function get_all_submitted_fields() { 
  234.         if ( empty( $this->data['submitted_fields'] ) ) { 
  235.             return false; 
  236.         } else { 
  237.             $fields = array(); 
  238.             $submitted_fields = $this->data['submitted_fields']; 
  239.             foreach ( $submitted_fields as $field_id ) { 
  240.                 if ( isset ( $this->data['fields'][$field_id] ) ) { 
  241.                     $fields[$field_id] = $this->data['fields'][$field_id]; 
  242.                 } 
  243.             } 
  244.             return $fields; 
  245.         } 
  246.     } 
  247.  
  248.  
  249.     /** 
  250.      * Retrieve user submitted form data by field ID. 
  251.      * 
  252.      */ 
  253.     function get_field_value($field_ID = '') { 
  254.         if(empty($this->data) OR $field_ID == '' OR !isset($this->data['fields'][$field_ID])) { 
  255.             return false; 
  256.         }else{ 
  257.             return $this->data['fields'][$field_ID]; 
  258.         } 
  259.     } 
  260.  
  261.     /** 
  262.      * Change the value of a field. 
  263.      * 
  264.      */ 
  265.     function update_field_value($field_ID = '', $new_value = '') { 
  266.         if(empty($this->data) OR $field_ID == '') { 
  267.             return false; 
  268.         }else{ 
  269.             $this->data['fields'][$field_ID] = $new_value; 
  270.             return true; 
  271.         } 
  272.     } 
  273.  
  274.     /** 
  275.      * Remove a field and its value from the user submissions. 
  276.      * 
  277.      */ 
  278.     function remove_field_value($field_ID = '') { 
  279.         if(empty($this->data) OR $field_ID == '') { 
  280.             return false; 
  281.         }else{ 
  282.             unset($this->data['fields'][$field_ID]); 
  283.             return true; 
  284.         } 
  285.     } 
  286.  
  287.     /** 
  288.      * Retrieve field data by field ID. This data includes all of the information entered in the admin back-end. 
  289.      * 
  290.      */ 
  291.     function get_field_settings($field_ID = '') { 
  292.         if(empty($this->data) OR $field_ID == '' OR !isset($this->data['field_data'][$field_ID])) { 
  293.             return false; 
  294.         }else{ 
  295.             return $this->data['field_data'][$field_ID]; 
  296.         } 
  297.     } 
  298.  
  299.     /** 
  300.      * Retrieve a specific piece of field setting data. 
  301.      * 
  302.      * @since 2.2.45 
  303.      * @return $value or bool(false) 
  304.      */ 
  305.     function get_field_setting( $field_id = '', $setting_id = '' ) { 
  306.         if ( empty ( $this->data ) OR $field_id == '' OR $setting_id == '' ) 
  307.             return false; 
  308.         if ( isset ( $this->data['field_data'][$field_id][$setting_id] ) ) { 
  309.             return $this->data['field_data'][$field_id][$setting_id]; 
  310.         } else if ( isset ( $this->data['field_data'][$field_id]['data'][$setting_id] ) ) { 
  311.             return $this->data['field_data'][$field_id]['data'][$setting_id]; 
  312.         } else { 
  313.             return false; 
  314.         } 
  315.     } 
  316.  
  317.     /** 
  318.      * Update field data by field ID. This data includes all of the informatoin entered into the admin back-end. (Please note that the changes made with these methods only affect the current process and DO NOT permanently change these settings): 
  319.      * 
  320.      */ 
  321.     function update_field_settings($field_ID = '', $new_value = '') { 
  322.         if(empty($this->data) OR $field_ID == '') { 
  323.             return false; 
  324.         }else{ 
  325.             $this->data['field_data'][$field_ID] = $new_value; 
  326.             return true; 
  327.         } 
  328.     } 
  329.  
  330.     /** 
  331.      * 
  332.      * Update a specific piece of field setting data by giving the field id and setting id. 
  333.      * 
  334.      * @since 2.2.45 
  335.      * @return void or bool(false) 
  336.      */ 
  337.     function update_field_setting( $field_id = '', $setting_id = '', $value = '' ) { 
  338.         if( empty( $this->data ) OR $field_id == '' OR $setting_id == '' OR $value == '' ) 
  339.             return false; 
  340.          
  341.         if ( isset ( $this->data['field_data'][$field_id][$setting_id] ) ) { 
  342.             $this->data['field_data'][$field_id][$setting_id] = $value; 
  343.         } else { 
  344.             $this->data['field_data'][$field_id]['data'][$setting_id] = $value; 
  345.         } 
  346.     } 
  347.  
  348.  
  349.     /** 
  350.      * Extra Form Values Methods 
  351.      * 
  352.     **/ 
  353.  
  354.     /** 
  355.      * Retrieve all the extra submitted form data. 
  356.      * 
  357.      */ 
  358.     function get_all_extras() { 
  359.         if ( empty($this->data['extra']) ) { 
  360.             return false; 
  361.         }else{ 
  362.             return $this->data['extra']; 
  363.         } 
  364.     } 
  365.  
  366.  
  367.     /** 
  368.      * Retrieve user submitted form data by field ID. 
  369.      * 
  370.      */ 
  371.     function get_extra_value($name = '') { 
  372.         if(empty($this->data) OR $name == '' OR !isset($this->data['extra'][$name])) { 
  373.             return false; 
  374.         }else{ 
  375.             return $this->data['extra'][$name]; 
  376.         } 
  377.     } 
  378.  
  379.     /** 
  380.      * Change the value of a field. 
  381.      * 
  382.      */ 
  383.     function update_extra_value($name = '', $new_value = '') { 
  384.         if(empty($this->data) OR $name == '') { 
  385.             return false; 
  386.         }else{ 
  387.             $this->data['extra'][$name] = $new_value; 
  388.             return true; 
  389.         } 
  390.     } 
  391.  
  392.     /** 
  393.      * Remove a field and its value from the user submissions. 
  394.      * 
  395.      */ 
  396.     function remove_extra_value($name = '') { 
  397.         if(empty($this->data) OR $name == '') { 
  398.             return false; 
  399.         }else{ 
  400.             unset($this->data['extra'][$name]); 
  401.             return true; 
  402.         } 
  403.     } 
  404.  
  405.  
  406.     /** 
  407.      * Form Settings Methods (Please note that the changes made with these methods only affect the current process and DO NOT permanently change these settings): 
  408.      * 
  409.     **/ 
  410.  
  411.     /** 
  412.      * Retrieve all the settings for the form currently being processed. 
  413.      * 
  414.      */ 
  415.     function get_all_form_settings() { 
  416.         if(empty($this->data['form']) OR !isset($this->data['form'])) { 
  417.             return false; 
  418.         }else{ 
  419.             return $this->data['form']; 
  420.         } 
  421.     } 
  422.  
  423.     /** 
  424.      * Retrieve a form setting value by its unique ID. 
  425.      * 
  426.      */ 
  427.     function get_form_setting($setting_ID) { 
  428.         if(empty($this->data['form']) OR !isset($this->data['form'][$setting_ID])) { 
  429.             return false; 
  430.         }else{ 
  431.             return $this->data['form'][$setting_ID]; 
  432.         } 
  433.     } 
  434.  
  435.     /** 
  436.      * Update a form setting value by its unique ID. 
  437.      * 
  438.      */ 
  439.     function update_form_setting($setting_ID, $new_value = '') { 
  440.         if(empty($this->data['form'])) { 
  441.             return false; 
  442.         }else{ 
  443.             return $this->data['form'][$setting_ID] = $new_value; 
  444.         } 
  445.     } 
  446.  
  447.     /** 
  448.      * Remove a form setting value by its unique ID. 
  449.      * 
  450.      */ 
  451.     function remove_form_setting($setting_ID, $new_value = '') { 
  452.         if(empty($this->data['form']) OR !isset($this->data['form'][$setting_ID])) { 
  453.             return false; 
  454.         }else{ 
  455.             unset($this->data['form'][$setting_ID]); 
  456.             return true; 
  457.         } 
  458.     } 
  459.  
  460.     /** 
  461.      * Error Reporting Methods: 
  462.      * 
  463.     **/ 
  464.  
  465.     /** 
  466.      * Retrieve all error messages. 
  467.      * 
  468.      */ 
  469.     function get_all_errors() { 
  470.         if(empty($this->data['errors']) OR !isset($this->data['errors'])) { 
  471.             return false; 
  472.         }else{ 
  473.             return $this->data['errors']; 
  474.         } 
  475.     } 
  476.  
  477.     /** 
  478.      * Retrieve an error message and location by its unique ID. 
  479.      * 
  480.      */ 
  481.     function get_error($error_ID = '') { 
  482.         if(empty($this->data['errors']) OR !isset($this->data['errors'][$error_ID]) OR $error_ID == '') { 
  483.             return false; 
  484.         }else{ 
  485.             return $this->data['errors'][$error_ID]; 
  486.         } 
  487.     } 
  488.  
  489.  
  490.     /** 
  491.      * Retrieve an array of error_IDs and messages by display location. 
  492.      * 
  493.      */ 
  494.     function get_errors_by_location($error_location = '') { 
  495.         $tmp_array = array(); 
  496.         if(empty($this->data['errors']) OR !isset($this->data['errors']) OR $error_location == '') { 
  497.             return false; 
  498.         }else{ 
  499.             foreach($this->data['errors'] as $ID => $error) { 
  500.                 if($error['location'] == $error_location) { 
  501.                     $tmp_array[$ID] = $error; 
  502.                 } 
  503.             } 
  504.             if(!empty($tmp_array)) { 
  505.                 return $tmp_array; 
  506.             }else{ 
  507.                 return false; 
  508.             } 
  509.         } 
  510.     } 
  511.  
  512.  
  513.     /** 
  514.      * Add an error message. 
  515.      * 
  516.      */ 
  517.     function add_error($error_ID, $error_msg, $error_location = 'general') { 
  518.         $this->data['errors'][$error_ID]['msg'] = $error_msg; 
  519.         $this->data['errors'][$error_ID]['location'] = $error_location; 
  520.         return true; 
  521.     } 
  522.  
  523.     /** 
  524.      * Remove an error message by its unique ID. 
  525.      * 
  526.      */ 
  527.     function remove_error($error_ID = '') { 
  528.         if(empty($this->data['errors']) OR !isset($this->data['errors']) OR $error_ID == '') { 
  529.             return false; 
  530.         }else{ 
  531.             unset($this->data['errors'][$error_ID]); 
  532.             return true; 
  533.         } 
  534.     } 
  535.  
  536.     /** 
  537.      * Remove all set error messages. 
  538.      * 
  539.      */ 
  540.     function remove_all_errors() { 
  541.         if(empty($this->data['errors']) OR !isset($this->data['errors'])) { 
  542.             return true; 
  543.         }else{ 
  544.             $this->data['errors'] = array(); 
  545.             return true; 
  546.         } 
  547.     } 
  548.  
  549.     /** 
  550.      * Success Reporting Methods: 
  551.      * 
  552.     **/ 
  553.  
  554.     /** 
  555.      * Retrieve all success messages. 
  556.      * 
  557.      */ 
  558.     function get_all_success_msgs() { 
  559.         if(empty($this->data['success']) OR !isset($this->data['success'])) { 
  560.             return false; 
  561.         }else{ 
  562.             return $this->data['success']; 
  563.         } 
  564.     } 
  565.  
  566.     /** 
  567.      * Retrieve a success message by unique ID. 
  568.      * 
  569.      */ 
  570.     function get_success_msg($success_ID = '') { 
  571.         if(empty($this->data['success']) OR !isset($this->data['success']) OR $success_ID == '') { 
  572.             return array(); 
  573.         }else{ 
  574.             return $this->data['success'][$success_ID]; 
  575.         } 
  576.     } 
  577.  
  578.     /** 
  579.      * Add a success message. 
  580.      * 
  581.      */ 
  582.     function add_success_msg($success_ID, $success_msg) { 
  583.         $this->data['success'][$success_ID] = $success_msg; 
  584.         return true; 
  585.     } 
  586.  
  587.     /** 
  588.      * Remove a success message by its unique ID. 
  589.      * 
  590.      */ 
  591.     function remove_success_msg($success_ID = '') { 
  592.         if(empty($this->data['success']) OR !isset($this->data['success']) OR $success_ID == '') { 
  593.             return false; 
  594.         }else{ 
  595.             unset($this->data['success'][$success_ID]); 
  596.             return true; 
  597.         } 
  598.     }     
  599.  
  600.     /** 
  601.      * Remove all success messages 
  602.      * 
  603.      */ 
  604.     function remove_all_success_msgs() { 
  605.         if(empty($this->data['success'])  OR !isset($this->data['success'])) { 
  606.             return false; 
  607.         }else{ 
  608.             $this->data['success'] = array(); 
  609.             return true; 
  610.         } 
  611.     } 
  612.  
  613.     /** 
  614.     * Function that returns an array of user information fields. 
  615.     * 
  616.     * @since 2.2.30 
  617.     * @returns array $user_info 
  618.     */ 
  619.     function get_user_info() { 
  620.         if ( !isset ( $this->data['field_data'] ) ) { 
  621.             return false; 
  622.         } 
  623.         $user_info = array(); 
  624.         foreach ( $this->data['field_data'] as $field ) { 
  625.             $data = $field['data']; 
  626.             $field_id = $field['id']; 
  627.             $user_value = $this->get_field_value( $field_id ); 
  628.             if ( isset ( $data['user_info_field_group'] ) AND $data['user_info_field_group'] == 1 ) { 
  629.  
  630.                 if ( isset ( $data['user_info_field_group_name'] ) ) { 
  631.                     $group_name = $data['user_info_field_group_name']; 
  632.                 } else { 
  633.                     $group_name = ''; 
  634.                 } 
  635.  
  636.                 if ( isset ( $data['user_info_field_group_custom'] ) ) { 
  637.                     $custom_group = $data['user_info_field_group_custom']; 
  638.                 } else { 
  639.                     $custom_group = ''; 
  640.                 } 
  641.  
  642.                 if ( $group_name == 'custom' ) { 
  643.                     $group_name = $custom_group; 
  644.                 } 
  645.  
  646.                 if ( $group_name != '' ) { 
  647.                     if ( isset ( $data['first_name'] ) AND $data['first_name'] == 1 ) { 
  648.                         $user_info[$group_name]['first_name'] = $user_value; 
  649.                     } else if ( isset ( $data['last_name'] ) AND $data['last_name'] == 1 ) { 
  650.                         $user_info[$group_name]['last_name'] = $user_value; 
  651.                     } else if ( isset ( $data['user_address_1'] ) AND $data['user_address_1'] == 1 ) { 
  652.                         $user_info[$group_name]['address_1'] = $user_value; 
  653.                     } else if ( isset ( $data['user_address_2'] ) AND $data['user_address_2'] == 1 ) { 
  654.                         $user_info[$group_name]['address_2'] = $user_value; 
  655.                     } else if ( isset ( $data['user_city'] ) AND $data['user_city'] == 1 ) { 
  656.                         $user_info[$group_name]['city'] = $user_value; 
  657.                     } else if ( isset ( $data['user_state'] ) AND $data['user_state'] == 1 ) { 
  658.                         $user_info[$group_name]['state'] = $user_value; 
  659.                     } else if ( isset ( $data['user_zip'] ) AND $data['user_zip'] == 1 ) { 
  660.                         $user_info[$group_name]['zip'] = $user_value; 
  661.                     } else if ( isset ( $data['user_email'] ) AND $data['user_email'] == 1 ) { 
  662.                         $user_info[$group_name]['email'] = $user_value; 
  663.                     } else if ( isset ( $data['user_phone'] ) AND $data['user_phone'] == 1 ) { 
  664.                         $user_info[$group_name]['phone'] = $user_value; 
  665.                     } else if ( $field['type'] == '_country' ) { 
  666.                         $user_info[$group_name]['country'] = $user_value; 
  667.                     }                     
  668.                 } else { 
  669.                     if ( isset ( $data['first_name'] ) AND $data['first_name'] == 1 ) { 
  670.                         $user_info['first_name'] = $user_value; 
  671.                     } else if ( isset ( $data['last_name'] ) AND $data['last_name'] == 1 ) { 
  672.                         $user_info['last_name'] = $user_value; 
  673.                     } else if ( isset ( $data['user_address_1'] ) AND $data['user_address_1'] == 1 ) { 
  674.                         $user_info['address_1'] = $user_value; 
  675.                     } else if ( isset ( $data['user_address_2'] ) AND $data['user_address_2'] == 1 ) { 
  676.                         $user_info['address_2'] = $user_value; 
  677.                     } else if ( isset ( $data['user_city'] ) AND $data['user_city'] == 1 ) { 
  678.                         $user_info['city'] = $user_value; 
  679.                     } else if ( isset ( $data['user_state'] ) AND $data['user_state'] == 1 ) { 
  680.                         $user_info['state'] = $user_value; 
  681.                     } else if ( isset ( $data['user_zip'] ) AND $data['user_zip'] == 1 ) { 
  682.                         $user_info['zip'] = $user_value; 
  683.                     } else if ( isset ( $data['user_email'] ) AND $data['user_email'] == 1 ) { 
  684.                         $user_info['email'] = $user_value; 
  685.                     } else if ( isset ( $data['user_phone'] ) AND $data['user_phone'] == 1 ) { 
  686.                         $user_info['phone'] = $user_value; 
  687.                     } else if ( $field['type'] == '_country' ) { 
  688.                         $user_info['country'] = $user_value; 
  689.                     } 
  690.                 } 
  691.             } 
  692.         } 
  693.         return $user_info; 
  694.     } 
  695.  
  696.     /** 
  697.     * Function that returns the value of a calculation field and optionally the fields that contributed to that value. 
  698.     * 
  699.     * @since 2.2.30 
  700.     * @returns $calc 
  701.     */ 
  702.     function get_calc( $name, $array = true ) { 
  703.         if ( !isset ( $this->data['field_data'] ) ) { 
  704.             return false; 
  705.         } 
  706.  
  707.         if ( $name == '' ) { 
  708.             return false; 
  709.         } 
  710.  
  711.         // Check to see if we have a name or an ID. 
  712.         if ( is_numeric ( $name ) AND isset ( $this->data['field_data'][$name] ) ) { 
  713.             // We have an ID. 
  714.             $calc_id = $name; 
  715.             $calc_row = $this->get_field_settings( $calc_id ); 
  716.             $places = $calc_row['data']['calc_places']; 
  717.         } else { 
  718.             // Search for our field by name. 
  719.             $calc_id = ''; 
  720.             foreach ( $this->data['field_data'] as $field ) { 
  721.                 if ( $field['type'] == '_calc' AND $field['calc_name'] == $name ) { 
  722.                     $calc_id = $field['id']; 
  723.                     $places = $field['data']['calc_places']; 
  724.                     break; 
  725.                 } 
  726.             } 
  727.             if ( $calc_id == '' ) { 
  728.                 return false; 
  729.             } 
  730.         } 
  731.         $fields = $this->get_calc_fields( $calc_id ); 
  732.         $total = number_format( round( $this->get_field_value( $calc_id ), $places ), $places ); 
  733.  
  734.         if ( $array ) { 
  735.             $calc = array( 'total' => $total, 'fields' => $fields ); 
  736.         } else { 
  737.             $calc = $total; 
  738.         } 
  739.  
  740.         return $calc; 
  741.     } 
  742.  
  743.     /** 
  744.     * Function that returns the "total" field value if it exists. 
  745.     * 
  746.     * @since 2.2.30 
  747.     * @returns array $total 
  748.     */ 
  749.     function get_calc_total( $array = true, $add_tax = true ) { 
  750.         if ( !isset ( $this->data['field_data'] ) ) { 
  751.             return false; 
  752.         } 
  753.         $total_field = ''; 
  754.  
  755.         // Get our sub total. 
  756.         $sub_total = $this->get_calc_sub_total( false ); 
  757.  
  758.         // Get our tax rate. 
  759.         $tax_rate = $this->get_calc_tax_rate(); 
  760.  
  761.         foreach ( $this->data['field_data'] as $field ) { 
  762.             $data = $field['data']; 
  763.             $field_id = $field['id']; 
  764.             $user_value = $this->get_field_value( $field_id ); 
  765.  
  766.             if ( isset ( $data['payment_total'] ) AND $data['payment_total'] == 1 ) { 
  767.                 $calc_method = $data['calc_method']; 
  768.                 if ( isset ( $data['calc'] ) ) { 
  769.                     $calc_fields = $data['calc']; 
  770.                 } 
  771.                 $calc_eq = $data['calc_eq']; 
  772.                 $places = $data['calc_places']; 
  773.                 $total_field = $field_id; 
  774.                  
  775.                 $total_value = number_format( round( $user_value, $places ), $places );                     
  776.                  
  777.                 break; 
  778.             } 
  779.         } 
  780.         if ( $total_field == '' ) { 
  781.             return false; 
  782.         } 
  783.         if ( $array ) { 
  784.             // Get the list of fields that affected this value. 
  785.             $fields = $this->get_calc_fields( $total_field ); 
  786.  
  787.             $tmp_array = array(); 
  788.             // Loop through the fields in that list and remove any that don't have a calc_option value of 1 
  789.             foreach ( $fields as $field_id => $value ) { 
  790.                 $field_settings = $this->get_field_settings( $field_id ); 
  791.                 $field_value = $this->get_field_value( $field_id ); 
  792.                 $data = $field_settings['data']; 
  793.                 $tmp_array[$field_id] = $value; 
  794.             } 
  795.             $fields = $tmp_array; 
  796.             $total = array(); 
  797.  
  798.             if ( !$sub_total AND $tax_rate AND $add_tax ) { 
  799.                 if ( is_string( $tax_rate ) AND strpos( $tax_rate, "%" ) !== false ) { 
  800.                     $tax_rate_decimal = str_replace( "%", "", $tax_rate ); 
  801.                     $tax_rate_decimal = $tax_rate_decimal / 100; 
  802.                 } 
  803.                 $total['sub_total'] = $total_value; 
  804.                 $total_value = number_format( round( $user_value + ( $user_value * $tax_rate_decimal ), $places ), $places ); 
  805.              
  806.             } 
  807.  
  808.             $total['total'] = $total_value; 
  809.             $total['fields'] = $fields; 
  810.  
  811.             if ( $sub_total ) { 
  812.                 $total['sub_total'] = $sub_total; 
  813.             } 
  814.  
  815.             if ( $tax_rate ) { 
  816.                 $total['tax_rate'] = $tax_rate; 
  817.             } 
  818.  
  819.             // Get our tax total. 
  820.             $tax_total = $this->get_calc_tax_total(); 
  821.             if ( $tax_total ) { 
  822.                 $total['tax_total'] = $tax_total; 
  823.             } 
  824.  
  825.         } else { 
  826.             $total = $total_value; 
  827.         } 
  828.  
  829.         return $total; 
  830.     }     
  831.  
  832.     /** 
  833.     * Function that returns the "sub total" field value if it exists. 
  834.     * 
  835.     * @since 2.2.30 
  836.     * @returns array $sub_total 
  837.     */ 
  838.     function get_calc_sub_total( $array = true ) { 
  839.         if ( !isset ( $this->data['field_data'] ) ) { 
  840.             return false; 
  841.         } 
  842.         $sub_total_value = ''; 
  843.         $sub_total_field = '';         
  844.         foreach ( $this->data['field_data'] as $field ) { 
  845.             $data = $field['data']; 
  846.             $field_id = $field['id']; 
  847.             $user_value = $this->get_field_value( $field_id ); 
  848.  
  849.             if ( isset ( $data['payment_sub_total'] ) AND $data['payment_sub_total'] == 1 ) { 
  850.                 $calc_method = $data['calc_method']; 
  851.                 if ( isset ( $data['calc'] ) ) { 
  852.                     $calc_fields = $data['calc']; 
  853.                 } 
  854.                 $calc_eq = $data['calc_eq']; 
  855.                 $places = $data['calc_places']; 
  856.                 $sub_total_field = $field_id; 
  857.                 $sub_total_value = number_format( round( $user_value, $places ), $places ); 
  858.                 break; 
  859.             } 
  860.         } 
  861.         if ( $sub_total_field == '' ) { 
  862.             return false; 
  863.         } 
  864.         if ( $array ) { 
  865.             // Get the list of fields that affected this value. 
  866.             $fields = $this->get_calc_fields( $sub_total_field ); 
  867.              
  868.             $tmp_array = array(); 
  869.             // Loop through the fields in that list and remove any that don't have a calc_option value of 1 
  870.             foreach ( $fields as $field_id => $value ) { 
  871.                 $field_settings = $this->get_field_settings( $field_id ); 
  872.                 $field_value = $this->get_field_value( $field_id ); 
  873.                 $data = $field_settings['data']; 
  874.                 $tmp_array[$field_id] = $value; 
  875.             } 
  876.             $fields = $tmp_array; 
  877.              
  878.  
  879.             $sub_total = array( 'sub_total' => $sub_total_value, 'fields' => $fields ); 
  880.         } else { 
  881.             $sub_total = $sub_total_value; 
  882.         } 
  883.  
  884.         return $sub_total; 
  885.     } 
  886.  
  887.     /** 
  888.     * Function that returns the total amount of tax if the tax_rate field exists in the form. 
  889.     * 
  890.     * @since 2.2.30 
  891.     * @returns int $tax_total 
  892.     */ 
  893.     function get_calc_tax_total() { 
  894.         if ( !isset ( $this->data['field_data'] ) ) { 
  895.             return false; 
  896.         } 
  897.         $tax_rate = $this->get_calc_tax_rate(); 
  898.         if ( !$tax_rate ) { 
  899.             return false; 
  900.         } 
  901.         // Get our sub-total if it exists. 
  902.         $sub_total = $this->get_calc_sub_total( false ); 
  903.         $locale_info = localeconv(); 
  904.         $decimal_point = $locale_info['decimal_point']; 
  905.         if ( $decimal_point == '.' ) { 
  906.             $sub_total = str_replace(', ', '', $sub_total ); 
  907.         } else { 
  908.             $sub_total = str_replace('.', '', $sub_total ); 
  909.         } 
  910.  
  911.         $sub_total = intval( $sub_total ); 
  912.  
  913.         // Get our total if it exists. 
  914.         $total = $this->get_calc_total( false, false ); 
  915.  
  916.         if ( strpos( $tax_rate, "%" ) !== false ) { 
  917.             $tax_rate = str_replace( "%", "", $tax_rate ); 
  918.             $tax_rate = $tax_rate / 100; 
  919.         } 
  920.  
  921.         if ( $sub_total ) { 
  922.             $tax_total = $sub_total * $tax_rate; 
  923.         } else if ( $total ) { 
  924.             $tax_total = $total * $tax_rate; 
  925.         } else { 
  926.             return false; 
  927.         } 
  928.  
  929.          
  930.         $tax_total = number_format( round( $tax_total, 2 ), 2 ); 
  931.         return $tax_total;     
  932.     } 
  933.  
  934.     /** 
  935.     * Function that returns tax_rate if the field exists in the form. 
  936.     * 
  937.     * @since 2.2.30 
  938.     * @returns string $tax_rate; 
  939.     */ 
  940.     function get_calc_tax_rate() { 
  941.         if ( !isset ( $this->data['field_data'] ) ) { 
  942.             return false; 
  943.         } 
  944.         $tax_rate = ''; 
  945.         foreach ( $this->data['field_data'] as $field ) { 
  946.             if ( $field['type'] == '_tax' ) { 
  947.                 $tax_rate = $this->get_field_value( $field['id'] ); 
  948.                 break; 
  949.             } 
  950.         } 
  951.         if ( $tax_rate == '' ) { 
  952.             return false; 
  953.         } else { 
  954.             return $tax_rate; 
  955.         } 
  956.     } 
  957.  
  958.     /** 
  959.     * Function that returns an array of field IDs and calc_values that contributed to the given calc id. 
  960.     * 
  961.     * @since 2.2.30 
  962.     * @returns array $calc_array 
  963.     */ 
  964.     function get_calc_fields( $calc_id = '' ) { 
  965.          
  966.         if ( $calc_id == '' OR !isset ( $this->data['field_data'] ) ) { 
  967.             return false; 
  968.         } 
  969.         // Get our calculation settings. 
  970.         $field_settings = $this->get_field_settings( $calc_id ); 
  971.         $calc_method = $field_settings['data']['calc_method']; 
  972.  
  973.         if ( isset ( $field_settings['data']['calc_eq'] ) ) { 
  974.             $calc_eq = $field_settings['data']['calc_eq']; 
  975.         } else { 
  976.             $calc_eq = ''; 
  977.         } 
  978.  
  979.         if ( isset ( $field_settings['data']['calc'] ) ) { 
  980.             $calc_fields = $field_settings['data']['calc']; 
  981.         } else { 
  982.             $calc_fields = ''; 
  983.         } 
  984.  
  985.         $tmp_array = array(); 
  986.         // Loop through the fields 
  987.         foreach ( $this->data['fields'] as $field_id => $user_value ) { 
  988.             $field = $this->data['field_data'][$field_id]; 
  989.             $field_value = $this->get_field_value( $field['id'] ); 
  990.             // We don't want our field to be added if it's a tax field. 
  991.             if ( $field['type'] != '_tax' ) { 
  992.                 switch ( $calc_method ) { 
  993.                     case 'auto': 
  994.                         // If this field's calc_auto_include is set to 1, then add this field's ID to the list. 
  995.                         if ( isset ( $field['data']['calc_auto_include'] ) AND $field['data']['calc_auto_include'] == 1 ) { 
  996.                             if ( $field['type'] != '_calc' ) { 
  997.                                 $calc_value = ninja_forms_field_calc_value( $field['id'], $field_value, $calc_method ); 
  998.                                 if ( $calc_value ) { 
  999.                                     $tmp_array[] = array( $field['id'] => $calc_value ); 
  1000.                                 } 
  1001.                             } else { 
  1002.                                 if ( $this->get_field_value( $field['id'] ) ) { 
  1003.                                     $tmp_array[] = array( $field['id'] => $this->get_field_value( $field['id'] ) ); 
  1004.                                 } 
  1005.                                 // If this is a calc field, then call this same function so that we can get all the fields that contributed to that. 
  1006.                                 $tmp_array[] = $this->get_calc_fields( $field['id'] ); 
  1007.                             } 
  1008.                         } 
  1009.                         break; 
  1010.                     case 'fields': 
  1011.                         // If this field is in our list of field operations, add this field's ID to our list. 
  1012.                         if ( $calc_fields != '' ) { 
  1013.                             foreach ( $calc_fields as $calc ) { 
  1014.                                 if ( $field['id'] == $calc['field'] ) { 
  1015.                                     if ( $field['type'] != '_calc' ) { 
  1016.                                         //echo "FIELD ID: ".$field['id']; 
  1017.                                         $calc_value = ninja_forms_field_calc_value( $field['id'], $field_value, $calc_method ); 
  1018.                                         if ( $calc_value ) { 
  1019.                                             $tmp_array[] = array( $field['id'] => $calc_value ); 
  1020.                                         } 
  1021.                                     } else { 
  1022.                                         if ( $this->get_field_value( $field['id'] ) ) { 
  1023.                                             $tmp_array[] = array( $field['id'] => $this->get_field_value( $field['id'] ) ); 
  1024.                                         } 
  1025.                                         // If this is a calc field, then call this same function so that we can get all the fields that contributed to that. 
  1026.                                         $tmp_array[] = $this->get_calc_fields( $field['id'] ); 
  1027.                                     } 
  1028.                                 } 
  1029.                             } 
  1030.                         } 
  1031.                         break; 
  1032.                     case 'eq': 
  1033.                         // If this field exists in our equation, then add this field's ID to our list. 
  1034.                         if ( $calc_eq != '' ) { 
  1035.                             if ( preg_match("/\bfield_".$field['id']."\b/i", $calc_eq ) ) { 
  1036.                                 if ( $field['type'] != '_calc' ) { 
  1037.                                     $calc_value = ninja_forms_field_calc_value( $field['id'], $field_value, $calc_method ); 
  1038.                                     if ( $calc_value ) { 
  1039.                                         $tmp_array[] = array( $field['id'] => $calc_value ); 
  1040.                                     } 
  1041.                                 } else { 
  1042.                                     if ( $this->get_field_value( $field['id'] ) ) { 
  1043.                                         $tmp_array[] = array( $field['id'] => $this->get_field_value( $field['id'] ) ); 
  1044.                                     } 
  1045.                                     // If this is a calc field, then call this same function so that we can get all the fields that contributed to that. 
  1046.                                     $tmp_array[] = $this->get_calc_fields( $field['id'] ); 
  1047.                                 } 
  1048.                             } 
  1049.                         } 
  1050.                         break; 
  1051.                 } 
  1052.             } 
  1053.              
  1054.         } 
  1055.  
  1056.         // Loop through our array and make sure that it's not multi-dimensional. 
  1057.         $calc_array = array(); 
  1058.         foreach ( $tmp_array as $key => $field ) { 
  1059.             foreach ( $field as $field_id => $value ) { 
  1060.                 if ( count ( $value ) <= 1 ) { 
  1061.                     $calc_array[$field_id] = $value; 
  1062.                 } else { 
  1063.                     foreach ( $value as $f_id => $v ) { 
  1064.                         $calc_array[$f_id] = $v; 
  1065.                     } 
  1066.                 } 
  1067.             } 
  1068.         } 
  1069.  
  1070.         return $calc_array; 
  1071.     } 
  1072.  
  1073.     /** 
  1074.     * Function that returns an array of field IDs and calc_values that contributed to the given calc id. 
  1075.     * 
  1076.     * @since 2.2.37 
  1077.     * @returns array $credit_card 
  1078.     */ 
  1079.     function get_credit_card() { 
  1080.         $credit_card = array(); 
  1081.         if ( empty( $this->data ) OR !isset ( $this->data['extra']['_credit_card_number'] ) ) { 
  1082.             return false; 
  1083.         }else{ 
  1084.             $number = str_replace( ' ', '', $this->data['extra']['_credit_card_number'] ); 
  1085.             $credit_card['number'] = $number; 
  1086.              
  1087.             if(isset( $this->data['extra']['_credit_card_cvc'] )) { 
  1088.              
  1089.                 $credit_card['cvc'] = $this->data['extra']['_credit_card_cvc']; 
  1090.                  
  1091.             } 
  1092.              
  1093.             if(isset( $this->data['extra']['_credit_card_name'] )) { 
  1094.              
  1095.                 $credit_card['name'] = $this->data['extra']['_credit_card_name']; 
  1096.                  
  1097.             } 
  1098.              
  1099.             //$credit_card['expires'] = $this->data['extra']['_credit_card_expires']; 
  1100.  
  1101.             if(isset( $this->data['extra']['_credit_card_expires_month'] )) { 
  1102.              
  1103.                 $credit_card['expires'] = $this->data['extra']['_credit_card_expires_month']  
  1104.                     . '/' . $this->data['extra']['_credit_card_expires_year']; 
  1105.  
  1106.                 $credit_card['expires_month'] = $this->data['extra']['_credit_card_expires_month']; 
  1107.                 $credit_card['expires_year'] = $this->data['extra']['_credit_card_expires_year']; 
  1108.                  
  1109.             } 
  1110.             return $credit_card; 
  1111.         } 
  1112.     } 
  1113.  
  1114.     /** 
  1115.     * Function that gets the current URL of the page, including querystring. 
  1116.     * 
  1117.     * @since 2.2.47 
  1118.     * @return $url string 
  1119.     */ 
  1120.     function get_current_url() { 
  1121.         $protocol = ((!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] != 'off') || $_SERVER['SERVER_PORT'] == 443) ? "https://" : "http://"; 
  1122.         $url = $protocol . $_SERVER["HTTP_HOST"] . $_SERVER["REQUEST_URI"]; 
  1123.         return $url; 
  1124.     } 
  1125.  
  1126. }