/core/api.php

<?php 
 
/** 
*  get_field_reference() 
* 
*  This function will find the $field_key that is related to the $field_name. 
*  This is know as the field value reference 
* 
*  @type    function 
*  @since    3.6 
*  @date    29/01/13 
* 
*  @param    mixed    $field_name: the name of the field - 'sub_heading' 
*  @param    int        $post_id: the post_id of which the value is saved against 
* 
*  @return    string    $return:  a string containing the field_key 
*/ 
 
function get_field_reference( $field_name, $post_id ) { 
   
  // cache 
  $found = false; 
  $cache = wp_cache_get( 'field_reference/post_id=' .  $post_id . '/name=' .  $field_name, 'acf', false, $found ); 
 
  if( $found ) 
  { 
      return $cache; 
  } 
   
   
  // vars 
  $return = ''; 
 
   
  // get field key 
  if( is_numeric($post_id) ) 
  { 
      $return = get_post_meta($post_id, '_' . $field_name, true);  
  } 
  elseif( strpos($post_id, 'user_') !== false ) 
  { 
      $temp_post_id = str_replace('user_', '', $post_id); 
      $return = get_user_meta($temp_post_id, '_' . $field_name, true);  
  } 
  else 
  { 
      $return = get_option('_' . $post_id . '_' . $field_name);  
  } 
   
   
  // set cache 
  wp_cache_set( 'field_reference/post_id=' .  $post_id . '/name=' .  $field_name, $return, 'acf' ); 
       
   
  // return     
  return $return; 
} 
 
 
/** 
*  get_field_objects() 
* 
*  This function will return an array containing all the custom field objects for a specific post_id. 
*  The function is not very elegant and wastes a lot of PHP memory / SQL queries if you are not using all the fields / values. 
* 
*  @type    function 
*  @since    3.6 
*  @date    29/01/13 
* 
*  @param    mixed    $post_id: the post_id of which the value is saved against 
* 
*  @return    array    $return: an array containin the field groups 
*/ 
 
function get_field_objects( $post_id = false, $options = array() ) { 
   
  // global 
  global $wpdb; 
   
   
  // filter post_id 
  $post_id = apply_filters('acf/get_post_id', $post_id ); 
 
 
  // vars 
  $field_key = ''; 
  $value = array(); 
   
   
  // get field_names 
  if( is_numeric($post_id) ) 
  { 
      $keys = $wpdb->get_col($wpdb->prepare( 
          "SELECT meta_value FROM $wpdb->postmeta WHERE post_id = %d and meta_key LIKE %s AND meta_value LIKE %s",  
          $post_id,  
          '_%',  
          'field_%' 
 )); 
  } 
  elseif( strpos($post_id, 'user_') !== false ) 
  { 
      $user_id = str_replace('user_', '', $post_id); 
       
      $keys = $wpdb->get_col($wpdb->prepare( 
          "SELECT meta_value FROM $wpdb->usermeta WHERE user_id = %d and meta_key LIKE %s AND meta_value LIKE %s",  
          $user_id,  
          '_%',  
          'field_%' 
 )); 
  } 
  else 
  { 
      $keys = $wpdb->get_col($wpdb->prepare( 
          "SELECT option_value FROM $wpdb->options WHERE option_name LIKE %s",  
          '_' . $post_id . '_%'  
 )); 
  } 
 
 
  if( is_array($keys) ) 
  { 
      foreach( $keys as $key ) 
      { 
          $field = get_field_object( $key, $post_id, $options ); 
           
          if( !is_array($field) ) 
          { 
              continue; 
          } 
           
          $value[ $field['name'] ] = $field; 
      } 
   } 
    
    
  // no value 
  if( empty($value) ) 
  { 
      return false; 
  } 
   
   
  // return 
  return $value; 
} 
 
 
/** 
*  get_fields() 
* 
*  This function will return an array containing all the custom field values for a specific post_id. 
*  The function is not very elegant and wastes a lot of PHP memory / SQL queries if you are not using all the values. 
* 
*  @type    function 
*  @since    3.6 
*  @date    29/01/13 
* 
*  @param    mixed    $post_id: the post_id of which the value is saved against 
* 
*  @return    array    $return: an array containin the field values 
*/ 
 
function get_fields( $post_id = false, $format_value = true ) { 
   
  // vars 
  $options = array( 
      'load_value' => true,  
      'format_value' => $format_value 
 ); 
   
   
  $fields = get_field_objects( $post_id, $options ); 
   
  if( is_array($fields) ) 
  { 
      foreach( $fields as $k => $field ) 
      { 
          $fields[ $k ] = $field['value']; 
      } 
  } 
   
  return $fields;     
} 
 
 
/** 
*  get_field() 
* 
*  This function will return a custom field value for a specific field name/key + post_id. 
*  There is a 3rd parameter to turn on/off formating. This means that an Image field will not use  
*  its 'return option' to format the value but return only what was saved in the database 
* 
*  @type    function 
*  @since    3.6 
*  @date    29/01/13 
* 
*  @param    string        $field_key: string containing the name of teh field name / key ('sub_field' / 'field_1') 
*  @param    mixed        $post_id: the post_id of which the value is saved against 
*  @param    boolean        $format_value: whether or not to format the value as described above 
* 
*  @return    mixed        $value: the value found 
*/ 
  
function get_field( $field_key, $post_id = false, $format_value = true ) { 
   
  // vars 
  $return = false; 
  $options = array( 
      'load_value' => true,  
      'format_value' => $format_value 
 ); 
 
   
  $field = get_field_object( $field_key, $post_id, $options); 
   
   
  if( is_array($field) ) 
  { 
      $return = $field['value']; 
  } 
   
   
  return $return; 
    
} 
 
 
/** 
*  get_field_object() 
* 
*  This function will return an array containing all the field data for a given field_name 
* 
*  @type    function 
*  @since    3.6 
*  @date    3/02/13 
* 
*  @param    string        $field_key: string containing the name of teh field name / key ('sub_field' / 'field_1') 
*  @param    mixed        $post_id: the post_id of which the value is saved against 
*  @param    array        $options: an array containing options 
*            boolean        + load_value: load the field value or not. Defaults to true 
*            boolean        + format_value: format the field value or not. Defaults to true 
* 
*  @return    array        $return: an array containin the field groups 
*/ 
 
function get_field_object( $field_key, $post_id = false, $options = array() ) { 
   
  // make sure add-ons are included 
  acf()->include_3rd_party(); 
       
       
  // filter post_id 
  $post_id = apply_filters('acf/get_post_id', $post_id ); 
  $field = false; 
  $orig_field_key = $field_key; 
   
   
  // defaults for options 
  $defaults = array( 
      'load_value' =>    true,  
      'format_value' =>    true,  
 ); 
   
  $options = array_merge($defaults, $options); 
   
   
  // is $field_name a name? pre 3.4.0 
  if( substr($field_key, 0, 6) !== 'field_' ) 
  { 
      // get field key 
      $field_key = get_field_reference( $field_key, $post_id ); 
  } 
   
   
  // get field 
  if( substr($field_key, 0, 6) === 'field_' ) 
  { 
      $field = apply_filters('acf/load_field', false, $field_key ); 
  } 
   
   
  // validate field 
  if( !$field ) 
  { 
      // treat as text field 
      $field = array( 
          'type' => 'text',  
          'name' => $orig_field_key,  
          'key' => 'field_' . $orig_field_key,  
 ); 
      $field = apply_filters('acf/load_field', $field, $field['key'] ); 
  } 
 
 
  // load value 
  if( $options['load_value'] ) 
  { 
      $field['value'] = apply_filters('acf/load_value', false, $post_id, $field); 
       
       
      // format value 
      if( $options['format_value'] ) 
      { 
          $field['value'] = apply_filters('acf/format_value_for_api', $field['value'], $post_id, $field); 
      } 
  } 
 
 
  return $field; 
 
} 
 
 
/** 
*  the_field() 
* 
*  This function is the same as echo get_field(). 
* 
*  @type    function 
*  @since    1.0.3 
*  @date    29/01/13 
* 
*  @param    string        $field_name: the name of the field - 'sub_heading' 
*  @param    mixed        $post_id: the post_id of which the value is saved against 
* 
*  @return    string        $value 
*/ 
 
function the_field( $field_name, $post_id = false ) { 
   
  $value = get_field($field_name, $post_id); 
   
  if( is_array($value) ) 
  { 
      $value = @implode(', ', $value); 
  } 
   
  echo $value; 
} 
 
 
/** 
*  have_rows 
* 
*  This function will instantiate a global variable containing the rows of a repeater or flexible content field,  
*  afterwhich, it will determine if another row exists to loop through 
* 
*  @type    function 
*  @date    2/09/13 
*  @since    4.3.0 
* 
*  @param    $field_name (string) the name of the field - 'images' 
*  @return    $post_id (mixed) the post_id of which the value is saved against 
*/ 
 
function have_rows( $field_name, $post_id = false ) { 
   
  // vars 
  $depth = 0; 
  $row = array(); 
  $new_parent_loop = false; 
  $new_child_loop = false; 
   
   
  // reference 
  $_post_id = $post_id; 
   
   
  // filter post_id 
  $post_id = apply_filters('acf/get_post_id', $post_id ); 
   
   
  // empty? 
  if( empty($GLOBALS['acf_field']) ) 
  { 
      // reset 
      reset_rows( true ); 
       
       
      // create a new loop 
      $new_parent_loop = true; 
  } 
  else 
  { 
      // vars 
      $row = end( $GLOBALS['acf_field'] ); 
      $prev = prev( $GLOBALS['acf_field'] ); 
       
       
      // If post_id has changed, this is most likely an archive loop 
      if( $post_id != $row['post_id'] ) 
      { 
          if( $prev && $prev['post_id'] == $post_id ) 
          { 
              // case: Change in $post_id was due to a nested loop ending 
              // action: move up one level through the loops 
              reset_rows(); 
          } 
          elseif( empty($_post_id) && isset($row['value'][ $row['i'] ][ $field_name ]) ) 
          { 
              // case: Change in $post_id was due to this being a nested loop and not specifying the $post_id 
              // action: move down one level into a new loop 
              $new_child_loop = true; 
          } 
          else 
          { 
              // case: Chang in $post_id is the most obvious, used in an WP_Query loop with multiple $post objects 
              // action: leave this current loop alone and create a new parent loop 
              $new_parent_loop = true; 
          } 
      } 
      elseif( $field_name != $row['name'] ) 
      { 
          if( $prev && $prev['name'] == $field_name && $prev['post_id'] == $post_id ) 
          { 
              // case: Change in $field_name was due to a nested loop ending 
              // action: move up one level through the loops 
              reset_rows(); 
          } 
          elseif( isset($row['value'][ $row['i'] ][ $field_name ]) ) 
          { 
              // case: Change in $field_name was due to this being a nested loop 
              // action: move down one level into a new loop 
              $new_child_loop = true; 
               
          } 
          else 
          { 
              // case: Chang in $field_name is the most obvious, this is a new loop for a different field within the $post 
              // action: leave this current loop alone and create a new parent loop 
              $new_parent_loop = true; 
          } 
           
           
      } 
  } 
   
   
  if( $new_parent_loop ) 
  { 
      // vars 
      $f = get_field_object( $field_name, $post_id ); 
      $v = $f['value']; 
      unset( $f['value'] ); 
       
       
      // add row 
      $GLOBALS['acf_field'][] = array( 
          'name' => $field_name,  
          'value' => $v,  
          'field' => $f,  
          'i' => -1,  
          'post_id' => $post_id,  
 ); 
       
  } 
  elseif( $new_child_loop ) 
  { 
      // vars 
      $f = acf_get_child_field_from_parent_field( $field_name, $row['field'] ); 
      $v = $row['value'][ $row['i'] ][ $field_name ]; 
       
      $GLOBALS['acf_field'][] = array( 
          'name' => $field_name,  
          'value' => $v,  
          'field' => $f,  
          'i' => -1,  
          'post_id' => $post_id,  
 ); 
 
  }     
   
   
  // update vars 
  $row = end( $GLOBALS['acf_field'] ); 
   
   
  if( is_array($row['value']) && array_key_exists( $row['i']+1, $row['value'] ) ) 
  { 
      // next row exists 
      return true; 
  } 
   
   
  // no next row! 
  reset_rows(); 
   
   
  // return 
  return false; 
 
} 
 
 
/** 
*  the_row 
* 
*  This function will progress the global repeater or flexible content value 1 row 
* 
*  @type    function 
*  @date    2/09/13 
*  @since    4.3.0 
* 
*  @param    N/A 
*  @return    N/A 
*/ 
 
function the_row() { 
   
  // vars 
  $depth = count( $GLOBALS['acf_field'] ) - 1; 
 
   
   
  // increase row 
  $GLOBALS['acf_field'][ $depth ]['i']++; 
   
   
  // get row 
  $value = $GLOBALS['acf_field'][ $depth ]['value']; 
  $i = $GLOBALS['acf_field'][ $depth ]['i']; 
 
   
  // return 
  return $value[ $i ]; 
} 
 
 
/** 
*  reset_rows 
* 
*  This function will find the current loop and unset it from the global array. 
*  To bo used when loop finishes or a break is used 
* 
*  @type    function 
*  @date    26/10/13 
*  @since    5.0.0 
* 
*  @param    $post_id (int) 
*  @return    $post_id (int) 
*/ 
 
function reset_rows( $hard_reset = false ) { 
   
  // completely destroy? 
  if( $hard_reset ) 
  { 
      $GLOBALS['acf_field'] = array(); 
  } 
  else 
  { 
      // vars 
      $depth = count( $GLOBALS['acf_field'] ) - 1; 
       
       
      // remove 
      unset( $GLOBALS['acf_field'][$depth] ); 
       
       
      // refresh index 
      $GLOBALS['acf_field'] = array_values($GLOBALS['acf_field']); 
  } 
   
   
  // return 
  return true; 
   
   
} 
 
 
/** 
*  has_sub_field() 
* 
*  This function is used inside a while loop to return either true or false (loop again or stop). 
*  When using a repeater or flexible content field, it will loop through the rows until  
*  there are none left or a break is detected 
* 
*  @type    function 
*  @since    1.0.3 
*  @date    29/01/13 
* 
*  @param    string    $field_name: the name of the field - 'sub_heading' 
*  @param    mixed    $post_id: the post_id of which the value is saved against 
* 
*  @return    bool 
*/ 
 
function has_sub_field( $field_name, $post_id = false ) { 
   
  // vars 
  $r = have_rows( $field_name, $post_id ); 
   
   
  // if has rows, progress through 1 row for the while loop to work 
  if( $r ) 
  { 
      the_row(); 
  } 
   
   
  // return 
  return $r; 
} 
 
 
/** 
*  has_sub_fields() 
* 
*  This function is a replica of 'has_sub_field' 
* 
*  @type    function 
*  @since    4.0.0 
*  @date    29/01/13 
* 
*  @param    string    $field_name: the name of the field - 'sub_heading' 
*  @param    mixed    $post_id: the post_id of which the value is saved against 
* 
*  @return    bool 
*/ 
 
function has_sub_fields( $field_name, $post_id = false ) 
{ 
  return has_sub_field( $field_name, $post_id ); 
} 
 
 
/** 
*  get_sub_field() 
* 
*  This function is used inside a 'has_sub_field' while loop to return a sub field value 
* 
*  @type    function 
*  @since    1.0.3 
*  @date    29/01/13 
* 
*  @param    string    $field_name: the name of the field - 'sub_heading' 
* 
*  @return    mixed    $value 
*/ 
 
function get_sub_field( $field_name ) { 
   
  // no field? 
  if( empty($GLOBALS['acf_field']) ) 
  { 
      return false; 
  } 
   
   
  // vars 
  $row = end( $GLOBALS['acf_field'] ); 
   
   
  // return value 
  if( isset($row['value'][ $row['i'] ][ $field_name ]) ) 
  { 
      return $row['value'][ $row['i'] ][ $field_name ]; 
  } 
   
   
  // return false 
  return false; 
} 
 
 
/** 
*  get_sub_field() 
* 
*  This function is the same as echo get_sub_field 
* 
*  @type    function 
*  @since    1.0.3 
*  @date    29/01/13 
* 
*  @param    string    $field_name: the name of the field - 'sub_heading' 
* 
*  @return    string    $value 
*/ 
 
function the_sub_field($field_name) 
{ 
  $value = get_sub_field($field_name); 
   
  if(is_array($value)) 
  { 
      $value = implode(', ', $value); 
  } 
   
  echo $value; 
} 
 
 
/** 
*  get_sub_field_object() 
* 
*  This function is used inside a 'has_sub_field' while loop to return a sub field object 
* 
*  @type    function 
*  @since    3.5.8.1 
*  @date    29/01/13 
* 
*  @param    string    $field_name: the name of the field - 'sub_heading' 
* 
*  @return    array    $sub_field     
*/ 
 
function get_sub_field_object( $child_name ) 
{ 
  // no field? 
  if( empty($GLOBALS['acf_field']) ) 
  { 
      return false; 
  } 
 
 
  // vars 
  $depth = count( $GLOBALS['acf_field'] ) - 1; 
  $parent = $GLOBALS['acf_field'][$depth]['field']; 
 
 
  // return 
  return acf_get_child_field_from_parent_field( $child_name, $parent ); 
   
} 
 
 
/** 
*  acf_get_sub_field_from_parent_field() 
* 
*  This function is used by the get_sub_field_object to find a sub field within a parent field 
* 
*  @type    function 
*  @since    3.5.8.1 
*  @date    29/01/13 
* 
*  @param    string    $child_name: the name of the field - 'sub_heading' 
*  @param    array    $parent: the parent field object 
* 
*  @return    array    $sub_field     
*/ 
 
function acf_get_child_field_from_parent_field( $child_name, $parent ) 
{ 
  // vars 
  $return = false; 
   
   
  // find child 
  if( isset($parent['sub_fields']) && is_array($parent['sub_fields']) ) 
  { 
      foreach( $parent['sub_fields'] as $child ) 
      { 
          if( $child['name'] == $child_name || $child['key'] == $child_name ) 
          { 
              $return = $child; 
              break; 
          } 
           
          // perhaps child has grand children? 
          $grand_child = acf_get_child_field_from_parent_field( $child_name, $child ); 
          if( $grand_child ) 
          { 
              $return = $grand_child; 
              break; 
          } 
      } 
  } 
  elseif( isset($parent['layouts']) && is_array($parent['layouts']) ) 
  { 
      foreach( $parent['layouts'] as $layout ) 
      { 
          $child = acf_get_child_field_from_parent_field( $child_name, $layout ); 
          if( $child ) 
          { 
              $return = $child; 
              break; 
          } 
      } 
  } 
   
 
  // return 
  return $return; 
   
} 
 
 
/** 
*  register_field_group() 
* 
*  This function is used to register a field group via code. It acceps 1 array containing 
*  all the field group data. This data can be obtained by using teh export tool within ACF 
* 
*  @type    function 
*  @since    3.0.6 
*  @date    29/01/13 
* 
*  @param    array    $array: an array holding all the field group data 
* 
*  @return 
*/ 
 
$GLOBALS['acf_register_field_group'] = array(); 
 
function register_field_group( $array ) 
{ 
  // add id 
  if( !isset($array['id']) ) 
  { 
      $array['id'] = uniqid(); 
  } 
   
 
  // 3.2.5 - changed show_on_page option 
  if( !isset($array['options']['hide_on_screen']) && isset($array['options']['show_on_page']) ) 
  { 
      $show_all = array('the_content', 'discussion', 'custom_fields', 'comments', 'slug', 'author'); 
      $array['options']['hide_on_screen'] = array_diff($show_all, $array['options']['show_on_page']); 
      unset( $array['options']['show_on_page'] ); 
  } 
 
   
  // 4.0.4 - changed location rules architecture 
  if( isset($array['location']['rules']) ) 
  { 
      // vars 
      $groups = array(); 
      $group_no = 0; 
       
       
      if( is_array($array['location']['rules']) ) 
       { 
           foreach( $array['location']['rules'] as $rule ) 
           { 
               $rule['group_no'] = $group_no; 
                
               // sperate groups? 
               if( $array['location']['allorany'] == 'any' ) 
               { 
                   $group_no++; 
               } 
                
                
               // add to group 
               $groups[ $rule['group_no'] ][ $rule['order_no'] ] = $rule; 
                
                
               // sort rules 
               ksort( $groups[ $rule['group_no'] ] ); 
        
           } 
            
           // sort groups 
          ksort( $groups ); 
       } 
        
       $array['location'] = $groups; 
  } 
   
   
  $GLOBALS['acf_register_field_group'][] = $array; 
} 
 
 
add_filter('acf/get_field_groups', 'api_acf_get_field_groups', 2, 1); 
function api_acf_get_field_groups( $return ) 
{ 
  // validate 
  if( empty($GLOBALS['acf_register_field_group']) ) 
  { 
      return $return; 
  } 
   
   
  foreach( $GLOBALS['acf_register_field_group'] as $acf ) 
  { 
      $return[] = array( 
          'id' => $acf['id'],  
          'title' => $acf['title'],  
          'menu_order' => $acf['menu_order'],  
 ); 
  } 
 
   
  // order field groups based on menu_order, title 
  // Obtain a list of columns 
  foreach( $return as $key => $row ) 
  { 
      $menu_order[ $key ] = $row['menu_order']; 
      $title[ $key ] = $row['title']; 
  } 
   
  // Sort the array with menu_order ascending 
  // Add $array as the last parameter, to sort by the common key 
  if(isset($menu_order)) 
  { 
      array_multisort($menu_order, SORT_ASC, $title, SORT_ASC, $return); 
  } 
   
  return $return; 
} 
 
 
add_filter('acf/field_group/get_fields', 'api_acf_field_group_get_fields', 1, 2); 
function api_acf_field_group_get_fields( $fields, $post_id ) 
{ 
  // validate 
  if( !empty($GLOBALS['acf_register_field_group']) ) 
  { 
      foreach( $GLOBALS['acf_register_field_group'] as $acf ) 
      { 
          if( $acf['id'] == $post_id ) 
          { 
              foreach( $acf['fields'] as $f ) 
              { 
                  $fields[] = apply_filters('acf/load_field', $f, $f['key']); 
              } 
               
              break; 
          } 
      } 
  } 
 
  return $fields; 
 
} 
 
 
add_filter('acf/load_field', 'api_acf_load_field', 1, 2); 
function api_acf_load_field( $field, $field_key ) 
{ 
  // validate 
  if( !empty($GLOBALS['acf_register_field_group']) ) 
  { 
      foreach( $GLOBALS['acf_register_field_group'] as $acf ) 
      { 
          if( !empty($acf['fields']) ) 
          { 
              foreach( $acf['fields'] as $f ) 
              { 
                  if( $f['key'] == $field_key ) 
                  { 
                      $field = $f; 
                      break; 
                  } 
              } 
          } 
      } 
  } 
 
  return $field; 
} 
 
 
add_filter('acf/field_group/get_location', 'api_acf_field_group_get_location', 1, 2); 
function api_acf_field_group_get_location( $location, $post_id ) 
{ 
  // validate 
  if( !empty($GLOBALS['acf_register_field_group']) ) 
  { 
      foreach( $GLOBALS['acf_register_field_group'] as $acf ) 
      { 
          if( $acf['id'] == $post_id ) 
          { 
              $location = $acf['location']; 
              break; 
          } 
      } 
  } 
 
  return $location; 
} 
 
 
 
add_filter('acf/field_group/get_options', 'api_acf_field_group_get_options', 1, 2); 
function api_acf_field_group_get_options( $options, $post_id ) 
{ 
  // validate 
  if( !empty($GLOBALS['acf_register_field_group']) ) 
  { 
      foreach( $GLOBALS['acf_register_field_group'] as $acf ) 
      { 
          if( $acf['id'] == $post_id ) 
          { 
              $options = $acf['options']; 
              break; 
          } 
      } 
  } 
 
  return $options; 
} 
 
 
/** 
*  get_row_layout() 
* 
*  This function will return a string representation of the current row layout within a 'has_sub_field' loop 
* 
*  @type    function 
*  @since    3.0.6 
*  @date    29/01/13 
* 
*  @return    $value - string containing the layout 
*/ 
 
function get_row_layout() 
{ 
  // vars 
  $value = get_sub_field('acf_fc_layout'); 
   
   
  return $value; 
} 
 
 
/** 
*  acf_shortcode() 
* 
*  This function is used to add basic shortcode support for the ACF plugin 
* 
*  @type    function 
*  @since    1.1.1 
*  @date    29/01/13 
* 
*  @param    array    $atts: an array holding the shortcode options 
*            string    + field: the field name 
*            mixed    + post_id: the post_id to load from 
* 
*  @return    string    $value: the value found by get_field 
*/ 
 
function acf_shortcode( $atts ) 
{ 
  // extract attributs 
  extract( shortcode_atts( array( 
      'field' => "",  
      'post_id' => false,  
 ), $atts ) ); 
   
   
  // $field is requird 
  if( !$field || $field == "" ) 
  { 
      return ""; 
  } 
   
   
  // get value and return it 
  $value = get_field( $field, $post_id ); 
   
   
  if( is_array($value) ) 
  { 
      $value = @implode( ', ', $value ); 
  } 
   
  return $value; 
} 
add_shortcode( 'acf', 'acf_shortcode' ); 
 
 
/** 
*  acf_form_head() 
* 
*  This function is placed at the very top of a template (before any HTML is rendered) and saves the $_POST data sent by acf_form. 
* 
*  @type    function 
*  @since    1.1.4 
*  @date    29/01/13 
* 
*  @param    N/A 
* 
*  @return    N/A 
*/ 
 
function acf_form_head() 
{ 
  // global vars 
  global $post_id; 
   
   
  // verify nonce 
  if( isset($_POST['acf_nonce']) && wp_verify_nonce($_POST['acf_nonce'], 'input') ) 
  { 
      // $post_id to save against 
      $post_id = $_POST['post_id']; 
       
       
      // allow for custom save 
      $post_id = apply_filters('acf/pre_save_post', $post_id); 
       
       
      // save the data 
      do_action('acf/save_post', $post_id);     
 
 
      // redirect 
      if(isset($_POST['return'])) 
      { 
          wp_redirect($_POST['return']); 
          exit; 
      } 
  } 
   
   
  // need wp styling 
  wp_enqueue_style(array( 
      'colors-fresh' 
 )); 
   
       
  // actions 
  do_action('acf/input/admin_enqueue_scripts'); 
 
  add_action('wp_head', 'acf_form_wp_head'); 
   
} 
 
function acf_form_wp_head() 
{ 
  do_action('acf/input/admin_head'); 
} 
 
 
/** 
*  acf_form() 
* 
*  This function is used to create an ACF form. 
* 
*  @type    function 
*  @since    1.1.4 
*  @date    29/01/13 
* 
*  @param    array        $options: an array containing many options to customize the form 
*            string        + post_id: post id to get field groups from and save data to. Default is false 
*            array        + field_groups: an array containing field group ID's. If this option is set,  
*                          the post_id will not be used to dynamically find the field groups 
*            boolean        + form: display the form tag or not. Defaults to true 
*            array        + form_attributes: an array containg attributes which will be added into the form tag 
*            string        + return: the return URL 
*            string        + html_before_fields: html inside form before fields 
*            string        + html_after_fields: html inside form after fields 
*            string        + submit_value: value of submit button 
*            string        + updated_message: default updated message. Can be false                      
* 
*  @return    N/A 
*/ 
 
function acf_form( $options = array() ) 
{ 
  global $post; 
   
   
  // defaults 
  $defaults = array( 
      'post_id' => false,  
      'field_groups' => array(),  
      'form' => true,  
      'form_attributes' => array( 
          'id' => 'post',  
          'class' => '',  
          'action' => '',  
          'method' => 'post',  
 ),  
      'return' => add_query_arg( 'updated', 'true', get_permalink() ),  
      'html_before_fields' => '',  
      'html_after_fields' => '',  
      'submit_value' => __("Update", 'acf'),  
      'updated_message' => __("Post updated", 'acf'),  
 ); 
   
   
  // merge defaults with options 
  $options = array_merge($defaults, $options); 
   
   
  // merge sub arrays 
  foreach( $options as $k => $v ) 
  { 
      if( is_array($v) ) 
      { 
          $options[ $k ] = array_merge($defaults[ $k ], $options[ $k ]); 
      } 
  } 
   
   
  // filter post_id 
  $options['post_id'] = apply_filters('acf/get_post_id', $options['post_id'] ); 
   
   
  // attributes 
  $options['form_attributes']['class'] .= 'acf-form'; 
   
   
   
  // register post box 
  if( empty($options['field_groups']) ) 
  { 
      // get field groups 
      $filter = array( 
          'post_id' => $options['post_id'] 
 ); 
       
       
      if( strpos($options['post_id'], 'user_') !== false ) 
      { 
          $user_id = str_replace('user_', '', $options['post_id']); 
          $filter = array( 
              'ef_user' => $user_id 
 ); 
      } 
      elseif( strpos($options['post_id'], 'taxonomy_') !== false ) 
      { 
          $taxonomy_id = str_replace('taxonomy_', '', $options['post_id']); 
          $filter = array( 
              'ef_taxonomy' => $taxonomy_id 
 ); 
      } 
       
       
      $options['field_groups'] = array(); 
      $options['field_groups'] = apply_filters( 'acf/location/match_field_groups', $options['field_groups'], $filter ); 
  } 
 
 
  // updated message 
  if(isset($_GET['updated']) && $_GET['updated'] == 'true' && $options['updated_message']) 
  { 
      echo '<div id="message" class="updated"><p>' . $options['updated_message'] . '</p></div>'; 
  } 
   
   
  // display form 
  if( $options['form'] ): ?> 
  <form <?php if($options['form_attributes']) {foreach($options['form_attributes'] as $k => $v) {echo $k . '="' . $v .'" '; }} ?>> 
  <?php endif; ?> 
   
  <div style="display:none"> 
      <script type="text/javascript"> 
          acf.o.post_id = <?php echo is_numeric($options['post_id']) ? $options['post_id'] : '"' . $options['post_id'] . '"'; ?>; 
      </script> 
      <input type="hidden" name="acf_nonce" value="<?php echo wp_create_nonce( 'input' ); ?>" /> 
      <input type="hidden" name="post_id" value="<?php echo $options['post_id']; ?>" /> 
      <input type="hidden" name="return" value="<?php echo $options['return']; ?>" /> 
      <?php wp_editor('', 'acf_settings'); ?> 
  </div> 
   
  <div id="poststuff"> 
  <?php 
   
  // html before fields 
  echo $options['html_before_fields']; 
   
   
  $acfs = apply_filters('acf/get_field_groups', array()); 
   
  if( is_array($acfs) ) { foreach( $acfs as $acf ) { 
       
      // only add the chosen field groups 
      if( !in_array( $acf['id'], $options['field_groups'] ) ) 
      { 
          continue; 
      } 
       
       
      // load options 
      $acf['options'] = apply_filters('acf/field_group/get_options', array(), $acf['id']); 
       
       
      // load fields 
      $fields = apply_filters('acf/field_group/get_fields', array(), $acf['id']); 
       
       
      echo '<div id="acf_' . $acf['id'] . '" class="postbox acf_postbox ' . $acf['options']['layout'] . '">'; 
      echo '<h3 class="hndle"><span>' . $acf['title'] . '</span></h3>'; 
      echo '<div class="inside">'; 
                           
      do_action('acf/create_fields', $fields, $options['post_id']); 
       
      echo '</div></div>'; 
       
  }} 
   
   
  // html after fields 
  echo $options['html_after_fields']; 
   
  ?> 
   
  <?php if( $options['form'] ): ?> 
  <!-- Submit --> 
  <div class="field"> 
      <input type="submit" value="<?php echo $options['submit_value']; ?>" /> 
  </div> 
  <!-- / Submit --> 
  <?php endif; ?> 
   
  </div><!-- <div id="poststuff"> --> 
   
  <?php if( $options['form'] ): ?> 
  </form> 
  <?php endif; 
} 
 
 
/** 
*  update_field() 
* 
*  This function will update a value in the database 
* 
*  @type    function 
*  @since    3.1.9 
*  @date    29/01/13 
* 
*  @param    mixed    $field_name: the name of the field - 'sub_heading' 
*  @param    mixed    $value: the value to save in the database. The variable type is dependant on the field type 
*  @param    mixed    $post_id: the post_id of which the value is saved against 
* 
*  @return    N/A 
*/ 
 
function update_field( $field_key, $value, $post_id = false ) 
{ 
  // filter post_id 
  $post_id = apply_filters('acf/get_post_id', $post_id ); 
   
   
  // vars 
  $options = array( 
      'load_value' => false,  
      'format_value' => false 
 ); 
   
  $field = get_field_object( $field_key, $post_id, $options); 
 
   
  // sub fields? They need formatted data 
  if( $field['type'] == 'repeater' ) 
  { 
      $value = acf_convert_field_names_to_keys( $value, $field ); 
  } 
  elseif( $field['type'] == 'flexible_content' ) 
  { 
      if( $field['layouts'] ) 
      { 
          foreach( $field['layouts'] as $layout ) 
          { 
              $value = acf_convert_field_names_to_keys( $value, $layout ); 
          } 
      } 
  } 
   
   
  // save 
  do_action('acf/update_value', $value, $post_id, $field ); 
   
   
  return true; 
   
} 
 
 
/** 
*  delete_field() 
* 
*  This function will remove a value from the database 
* 
*  @type    function 
*  @since    3.1.9 
*  @date    29/01/13 
* 
*  @param    mixed    $field_name: the name of the field - 'sub_heading' 
*  @param    mixed    $post_id: the post_id of which the value is saved against 
* 
*  @return    N/A 
*/ 
 
function delete_field( $field_name, $post_id ) 
{ 
  do_action('acf/delete_value', $post_id, $field_name ); 
} 
 
 
/** 
*  create_field() 
* 
*  This function will creat the HTML for a field 
* 
*  @type    function 
*  @since    4.0.0 
*  @date    17/03/13 
* 
*  @param    array    $field - an array containing all the field attributes 
* 
*  @return    N/A 
*/ 
 
function create_field( $field ) 
{ 
  do_action('acf/create_field', $field ); 
} 
 
 
/** 
*  acf_convert_field_names_to_keys() 
* 
*  Helper for the update_field function 
* 
*  @type    function 
*  @since    4.0.0 
*  @date    17/03/13 
* 
*  @param    array    $value: the value returned via get_field 
*  @param    array    $field: the field or layout to find sub fields from 
* 
*  @return    N/A 
*/ 
 
function acf_convert_field_names_to_keys( $value, $field ) 
{ 
  // only if $field has sub fields 
  if( !isset($field['sub_fields']) ) 
  { 
      return $value; 
  } 
   
 
  // define sub field keys 
  $sub_fields = array(); 
  if( $field['sub_fields'] ) 
  { 
      foreach( $field['sub_fields'] as $sub_field ) 
      { 
          $sub_fields[ $sub_field['name'] ] = $sub_field; 
      } 
  } 
   
   
  // loop through the values and format the array to use sub field keys 
  if( is_array($value) ) 
  { 
      foreach( $value as $row_i => $row) 
      { 
          if( $row ) 
          { 
              foreach( $row as $sub_field_name => $sub_field_value ) 
              { 
                  // sub field must exist! 
                  if( !isset($sub_fields[ $sub_field_name ]) ) 
                  { 
                      continue; 
                  } 
                   
                   
                  // vars 
                  $sub_field = $sub_fields[ $sub_field_name ]; 
                  $sub_field_value = acf_convert_field_names_to_keys( $sub_field_value, $sub_field ); 
                   
                   
                  // set new value 
                  $value[$row_i][ $sub_field['key'] ] = $sub_field_value; 
                   
                   
                  // unset old value 
                  unset( $value[$row_i][$sub_field_name] ); 
                       
                   
              } 
              // foreach( $row as $sub_field_name => $sub_field_value ) 
          } 
          // if( $row ) 
      } 
      // foreach( $value as $row_i => $row) 
  } 
  // if( $value ) 
   
   
  return $value; 
 
} 
 
 
/** 
*  acf_force_type_array 
* 
*  This function will force a variable to become an array 
* 
*  @type    function 
*  @date    4/02/2014 
*  @since    5.0.0 
* 
*  @param    $var (mixed) 
*  @return    (array) 
*/ 
 
function acf_force_type_array( $var ) { 
   
  // is array? 
  if( is_array($var) ) { 
   
      return $var; 
   
  } 
   
   
  // bail early if empty 
  if( empty($var) && !is_numeric($var) ) { 
       
      return array(); 
       
  } 
   
   
  // string  
  if( is_string($var) ) { 
       
      return explode(', ', $var); 
       
  } 
   
   
  // place in array 
  return array( $var ); 
}  
 
 
/** 
*  acf_get_valid_terms 
* 
*  This function will replace old terms with new split term ids 
* 
*  @type    function 
*  @date    27/02/2015 
*  @since    5.1.5 
* 
*  @param    $terms (int|array) 
*  @param    $taxonomy (string) 
*  @return    $terms 
*/ 
 
function acf_get_valid_terms( $terms = false, $taxonomy = 'category' ) { 
   
  // bail early if function does not yet exist or 
  if( !function_exists('wp_get_split_term') || empty($terms) ) { 
       
      return $terms; 
       
  } 
   
   
  // vars 
  $is_array = is_array($terms); 
   
   
  // force into array 
  $terms = acf_force_type_array( $terms ); 
   
   
  // force ints 
  $terms = array_map('intval', $terms); 
   
   
  // attempt to find new terms 
  foreach( $terms as $i => $term_id ) { 
       
      $new_term_id = wp_get_split_term($term_id, $taxonomy); 
       
      if( $new_term_id ) { 
           
          $terms[ $i ] = $new_term_id; 
           
      } 
       
  } 
   
   
  // revert array if needed 
  if( !$is_array ) { 
       
      $terms = $terms[0]; 
       
  } 
   
   
  // return 
  return $terms; 
   
} 
 
 
/** 
*  Depreceated Functions 
* 
*  @description:  
*  @created: 23/07/12 
*/ 
 
 
/**-------------------------------------------------------------------------------------- 
* 
*    reset_the_repeater_field 
* 
*    @author Elliot Condon 
*    @depreciated: 3.3.4 - now use has_sub_field 
*    @since 1.0.3 
*  
*-------------------------------------------------------------------------------------*/ 
 
function reset_the_repeater_field() 
{ 
  // do nothing 
} 
 
 
/**-------------------------------------------------------------------------------------- 
* 
*    the_repeater_field 
* 
*    @author Elliot Condon 
*    @depreciated: 3.3.4 - now use has_sub_field 
*    @since 1.0.3 
*  
*-------------------------------------------------------------------------------------*/ 
 
function the_repeater_field($field_name, $post_id = false) 
{ 
  return has_sub_field($field_name, $post_id); 
} 
 
 
/**-------------------------------------------------------------------------------------- 
* 
*    the_flexible_field 
* 
*    @author Elliot Condon 
*    @depreciated: 3.3.4 - now use has_sub_field 
*    @since 3.?.? 
*  
*-------------------------------------------------------------------------------------*/ 
 
function the_flexible_field($field_name, $post_id = false) 
{ 
  return has_sub_field($field_name, $post_id); 
} 
 
/** 
*  acf_filter_post_id() 
* 
*  This is a deprecated function which is now run through a filter 
* 
*  @type    function 
*  @since    3.6 
*  @date    29/01/13 
* 
*  @param    mixed    $post_id 
* 
*  @return    mixed    $post_id 
*/ 
 
function acf_filter_post_id( $post_id ) 
{ 
  return apply_filters('acf/get_post_id', $post_id ); 
} 
 
?>