26 |
29 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/acf-to-rest-api/shared/includes/admin/views/html-notice-missing-rest-api.php:
--------------------------------------------------------------------------------
1 |
24 |
25 | 27 | 28 |
26 |
29 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/acf-to-rest-api/shared/includes/admin/views/html-settings-field.php:
--------------------------------------------------------------------------------
1 |
8 |
9 |
17 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/acf-to-rest-api/shared/includes/admin/views/html-settings-section.php:
--------------------------------------------------------------------------------
1 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/acf-to-rest-api/shared/lib/class-acf-to-rest-api-settings.php:
--------------------------------------------------------------------------------
1 | sprintf( '%s', admin_url( 'options-permalink.php#acf-to-rest-api-settings' ), esc_html__( 'Settings', 'acf-to-rest-api' ) ),
44 | );
45 |
46 | $new_actions += $actions;
47 |
48 | return $new_actions;
49 | }
50 |
51 | return $actions;
52 | }
53 |
54 | public static function plugin_row_meta( $plugin_meta, $plugin_file, $plugin_data ) {
55 | if ( isset( $plugin_data['slug'] ) && 'acf-to-rest-api' == $plugin_data['slug'] ) {
56 | $plugin_meta['acf-to-rest-api-github'] = sprintf( '%s', self::$github_url, esc_html__( 'Fork me on GitHub' ) );
57 | $plugin_meta['acf_to_rest_api_donation'] = sprintf( '%s', self::$donation_url, esc_html__( 'Make a donation', 'acf-to-rest-api' ) );
58 | }
59 |
60 | return $plugin_meta;
61 | }
62 |
63 | public static function acf_admin_setting() {
64 | add_settings_section(
65 | 'acf_to_rest_api_settings_section',
66 | __( 'ACF to REST API', 'acf-to-rest-api' ),
67 | array( __CLASS__, 'add_settings_section' ),
68 | 'permalink'
69 | );
70 |
71 | add_settings_field(
72 | 'acf_to_rest_api_request_version',
73 | __( 'Request Version', 'acf-to-rest-api' ),
74 | array( __CLASS__, 'add_settings_field' ),
75 | 'permalink',
76 | 'acf_to_rest_api_settings_section'
77 | );
78 | }
79 |
80 | private static function save() {
81 | if ( ! is_admin() ) {
82 | return;
83 | }
84 |
85 | if ( isset( $_POST['acf_to_rest_api_settings'] ) ) {
86 | $settings = $_POST['acf_to_rest_api_settings'];
87 | if ( array_key_exists( 'request_version', $settings ) ) {
88 | update_option( 'acf_to_rest_api_request_version', absint( $settings['request_version'] ) );
89 | }
90 | }
91 | }
92 |
93 | }
94 |
95 | ACF_To_REST_API_Settings::init();
96 |
97 | }
98 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/acf-to-rest-api/v3/class-acf-to-rest-api-v3.php:
--------------------------------------------------------------------------------
1 | true ), 'objects' ) as $post_type ) {
23 | if ( 'attachment' == $post_type->name ) {
24 | $controller = new ACF_To_REST_API_Attachments_Controller( $post_type );
25 | } else {
26 | $controller = new ACF_To_REST_API_Posts_Controller( $post_type );
27 | }
28 | $controller->register();
29 | }
30 |
31 | foreach ( get_taxonomies( array( 'show_in_rest' => true ), 'objects' ) as $taxonomy ) {
32 | $controller = new ACF_To_REST_API_Terms_Controller( $taxonomy );
33 | $controller->register();
34 | }
35 |
36 | $controller = new ACF_To_REST_API_Comments_Controller;
37 | $controller->register();
38 |
39 | $controller = new ACF_To_REST_API_Options_Controller;
40 | $controller->register();
41 |
42 | $controller = new ACF_To_REST_API_Users_Controller;
43 | $controller->register();
44 | }
45 |
46 | public static function missing_notice() {
47 | if ( ! ACF_To_REST_API::is_plugin_active( 'rest-api' ) ) {
48 | include dirname( __FILE__ ) . '/../shared/includes/admin/views/html-notice-missing-rest-api.php';
49 | }
50 |
51 | if ( ! ACF_To_REST_API::is_plugin_active( 'acf' ) ) {
52 | include dirname( __FILE__ ) . '/../shared/includes/admin/views/html-notice-missing-acf.php';
53 | }
54 | }
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/acf-to-rest-api/v3/lib/class-acf-to-rest-api-acf-field-settings.php:
--------------------------------------------------------------------------------
1 | __( 'Edit in REST API?', 'acf-to-rest-api' ),
33 | 'instructions' => '',
34 | 'type' => 'true_false',
35 | 'name' => 'edit_in_rest',
36 | 'ui' => 1,
37 | 'class' => 'field-edit_in_rest',
38 | 'default_value' => 0,
39 | ), true );
40 | } else { ?>
41 | 27 | 28 |
2 |
3 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/admin/views/field-group-locations.php:
--------------------------------------------------------------------------------
1 |
7 | -
4 |
5 |
6 |
7 |
8 |
9 |
12 |
13 |
16 |
17 | $field ):
20 |
21 | acf_get_view('field-group-field', array( 'field' => $field, 'i' => $i ));
22 |
23 | endforeach;
24 |
25 | endif; ?>
26 |
27 |
28 |
29 |
34 |
35 | 'acfcloneindex',
40 | 'key' => 'acfcloneindex',
41 | 'label' => __('New Field','acf'),
42 | 'name' => 'new_field',
43 | 'type' => 'text'
44 | ));
45 |
46 | ?>
47 |
50 |
51 |
52 |
8 |
36 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/admin/views/html-admin-tools.php:
--------------------------------------------------------------------------------
1 |
19 |
9 |
10 |
11 |
12 |
35 |
20 |
21 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/admin/views/html-location-group.php:
--------------------------------------------------------------------------------
1 | Back to all tools
22 | 23 | 26 | 27 |
2 |
3 |
4 |
5 |
6 |
7 | $rule ):
8 |
9 | // append id
10 | $rule['id'] = "rule_{$i}";
11 | $rule['group'] = $group_id;
12 |
13 |
14 | // valid rule
15 | $rule = acf_get_valid_location_rule($rule);
16 |
17 |
18 | // view
19 | acf_get_view('html-location-rule', array(
20 | 'rule' => $rule
21 | ));
22 |
23 | endforeach; ?>
24 |
25 |
26 |
27 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/admin/views/html-location-rule.php:
--------------------------------------------------------------------------------
1 |
17 |
18 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/admin/views/install.php:
--------------------------------------------------------------------------------
1 |
19 |
20 |
23 |
24 |
52 |
53 |
54 |
55 |
56 |
57 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/admin/views/settings-addons.php:
--------------------------------------------------------------------------------
1 | 10 | 11 |
See what\'s new', 'acf' ), admin_url('edit.php?post_type=acf-field-group&page=acf-settings-info') ); ?>
12 | 13 | 22 | 23 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 |
2 |
3 |
4 |
5 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/ajax.php:
--------------------------------------------------------------------------------
1 | '',
58 | 'value' => '',
59 | 'nonce' => '',
60 | ));
61 |
62 |
63 | // validate
64 | if( ! wp_verify_nonce($options['nonce'], 'acf_nonce') || empty($options['name']) ) {
65 |
66 | die('0');
67 |
68 | }
69 |
70 |
71 | // upadte setting
72 | acf_update_user_setting( $options['name'], $options['value'] );
73 |
74 |
75 | // return
76 | die('1');
77 |
78 | }
79 |
80 | }
81 |
82 | new acf_ajax();
83 |
84 | endif;
85 |
86 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/fields/class-acf-field-color_picker.php:
--------------------------------------------------------------------------------
1 | name = 'color_picker';
25 | $this->label = __("Color Picker",'acf');
26 | $this->category = 'jquery';
27 | $this->defaults = array(
28 | 'default_value' => '',
29 | );
30 |
31 | }
32 |
33 |
34 | /*
35 | * input_admin_enqueue_scripts
36 | *
37 | * description
38 | *
39 | * @type function
40 | * @date 16/12/2015
41 | * @since 5.3.2
42 | *
43 | * @param $post_id (int)
44 | * @return $post_id (int)
45 | */
46 |
47 | function input_admin_enqueue_scripts() {
48 |
49 | // globals
50 | global $wp_scripts;
51 |
52 |
53 | // register if not already (on front end)
54 | // http://wordpress.stackexchange.com/questions/82718/how-do-i-implement-the-wordpress-iris-picker-into-my-plugin-on-the-front-end
55 | if( !isset($wp_scripts->registered['iris']) ) {
56 |
57 | // styles
58 | wp_register_style('wp-color-picker', admin_url('css/color-picker.css'), array(), '', true);
59 |
60 |
61 | // scripts
62 | wp_register_script('iris', admin_url('js/iris.min.js'), array('jquery-ui-draggable', 'jquery-ui-slider', 'jquery-touch-punch'), '1.0.7', true);
63 | wp_register_script('wp-color-picker', admin_url('js/color-picker.min.js'), array('iris'), '', true);
64 |
65 |
66 | // localize
67 | wp_localize_script('wp-color-picker', 'wpColorPickerL10n', array(
68 | 'clear' => __('Clear', 'acf' ),
69 | 'defaultString' => __('Default', 'acf' ),
70 | 'pick' => __('Select Color', 'acf' ),
71 | 'current' => __('Current Color', 'acf' )
72 | ));
73 |
74 | }
75 |
76 |
77 | // enqueue
78 | wp_enqueue_style('wp-color-picker');
79 | wp_enqueue_script('wp-color-picker');
80 |
81 |
82 | }
83 |
84 |
85 | /*
86 | * render_field()
87 | *
88 | * Create the HTML interface for your field
89 | *
90 | * @param $field - an array holding all the field's data
91 | *
92 | * @type action
93 | * @since 3.6
94 | * @date 23/01/13
95 | */
96 |
97 | function render_field( $field ) {
98 |
99 | // vars
100 | $text_input = acf_get_sub_array( $field, array('id', 'class', 'name', 'value') );
101 | $hidden_input = acf_get_sub_array( $field, array('name', 'value') );
102 |
103 |
104 | // html
105 | ?>
106 |
6 |
7 |
8 |
9 | "",
13 | "slug" => "",
14 | "description" => "",
15 | "thumbnail" => "",
16 | "url" => "",
17 | "btn" => __("Download & Install",'acf'),
18 | "btn_color" => ""
19 | ));
20 |
21 | ?>
22 |
23 |
53 |
54 |
24 |
25 |
47 |
48 |
49 |
50 |
51 |
52 |
26 |
27 | 
28 |
29 |
30 |
34 |
45 |
46 |
107 |
108 |
109 |
110 | __('Default Value','acf'),
132 | 'instructions' => '',
133 | 'type' => 'text',
134 | 'name' => 'default_value',
135 | 'placeholder' => '#FFFFFF'
136 | ));
137 |
138 | }
139 |
140 | }
141 |
142 |
143 | // initialize
144 | acf_register_field_type( 'acf_field_color_picker' );
145 |
146 | endif; // class_exists check
147 |
148 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/fields/class-acf-field-email.php:
--------------------------------------------------------------------------------
1 | name = 'email';
25 | $this->label = __("Email",'acf');
26 | $this->defaults = array(
27 | 'default_value' => '',
28 | 'placeholder' => '',
29 | 'prepend' => '',
30 | 'append' => ''
31 | );
32 |
33 | }
34 |
35 |
36 | /*
37 | * render_field()
38 | *
39 | * Create the HTML interface for your field
40 | *
41 | * @param $field - an array holding all the field's data
42 | *
43 | * @type action
44 | * @since 3.6
45 | * @date 23/01/13
46 | */
47 |
48 | function render_field( $field ) {
49 |
50 | // vars
51 | $atts = array();
52 | $keys = array( 'type', 'id', 'class', 'name', 'value', 'placeholder', 'pattern' );
53 | $keys2 = array( 'readonly', 'disabled', 'required' );
54 | $html = '';
55 |
56 |
57 | // prepend
58 | if( $field['prepend'] !== '' ) {
59 |
60 | $field['class'] .= ' acf-is-prepended';
61 | $html .= '' . acf_esc_html($field['prepend']) . '
';
62 |
63 | }
64 |
65 |
66 | // append
67 | if( $field['append'] !== '' ) {
68 |
69 | $field['class'] .= ' acf-is-appended';
70 | $html .= '' . acf_esc_html($field['append']) . '
';
71 |
72 | }
73 |
74 |
75 | // atts (value="123")
76 | foreach( $keys as $k ) {
77 | if( isset($field[ $k ]) ) $atts[ $k ] = $field[ $k ];
78 | }
79 |
80 |
81 | // atts2 (disabled="disabled")
82 | foreach( $keys2 as $k ) {
83 | if( !empty($field[ $k ]) ) $atts[ $k ] = $k;
84 | }
85 |
86 |
87 | // remove empty atts
88 | $atts = acf_clean_atts( $atts );
89 |
90 |
91 | // render
92 | $html .= '' . acf_get_text_input( $atts ) . '
';
93 |
94 |
95 | // return
96 | echo $html;
97 |
98 | }
99 |
100 |
101 | /*
102 | * render_field_settings()
103 | *
104 | * Create extra options for your field. This is rendered when editing a field.
105 | * The value of $field['name'] can be used (like bellow) to save extra data to the $field
106 | *
107 | * @type action
108 | * @since 3.6
109 | * @date 23/01/13
110 | *
111 | * @param $field - an array holding all the field's data
112 | */
113 |
114 | function render_field_settings( $field ) {
115 |
116 | // default_value
117 | acf_render_field_setting( $field, array(
118 | 'label' => __('Default Value','acf'),
119 | 'instructions' => __('Appears when creating a new post','acf'),
120 | 'type' => 'text',
121 | 'name' => 'default_value',
122 | ));
123 |
124 |
125 | // placeholder
126 | acf_render_field_setting( $field, array(
127 | 'label' => __('Placeholder Text','acf'),
128 | 'instructions' => __('Appears within the input','acf'),
129 | 'type' => 'text',
130 | 'name' => 'placeholder',
131 | ));
132 |
133 |
134 | // prepend
135 | acf_render_field_setting( $field, array(
136 | 'label' => __('Prepend','acf'),
137 | 'instructions' => __('Appears before the input','acf'),
138 | 'type' => 'text',
139 | 'name' => 'prepend',
140 | ));
141 |
142 |
143 | // append
144 | acf_render_field_setting( $field, array(
145 | 'label' => __('Append','acf'),
146 | 'instructions' => __('Appears after the input','acf'),
147 | 'type' => 'text',
148 | 'name' => 'append',
149 | ));
150 |
151 | }
152 |
153 | }
154 |
155 |
156 | // initialize
157 | acf_register_field_type( 'acf_field_email' );
158 |
159 | endif; // class_exists check
160 |
161 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/fields/class-acf-field-output.php:
--------------------------------------------------------------------------------
1 | name = 'output';
25 | $this->label = 'output';
26 | $this->public = false;
27 | $this->defaults = array(
28 | 'html' => false
29 | );
30 |
31 | }
32 |
33 |
34 | /*
35 | * render_field()
36 | *
37 | * Create the HTML interface for your field
38 | *
39 | * @param $field (array) the $field being rendered
40 | *
41 | * @type action
42 | * @since 3.6
43 | * @date 23/01/13
44 | *
45 | * @param $field (array) the $field being edited
46 | * @return n/a
47 | */
48 |
49 | function render_field( $field ) {
50 |
51 | // bail early if no html
52 | if( !$field['html'] ) return;
53 |
54 |
55 | // html
56 | if( is_string($field['html']) && !function_exists($field['html']) ) {
57 |
58 | echo $field['html'];
59 |
60 | // function
61 | } else {
62 |
63 | call_user_func_array($field['html'], array($field));
64 |
65 | }
66 |
67 | }
68 |
69 | }
70 |
71 |
72 | // initialize
73 | acf_register_field_type( 'acf_field_output' );
74 |
75 | endif; // class_exists check
76 |
77 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/fields/class-acf-field-password.php:
--------------------------------------------------------------------------------
1 | name = 'password';
25 | $this->label = __("Password",'acf');
26 | $this->defaults = array(
27 | 'placeholder' => '',
28 | 'prepend' => '',
29 | 'append' => '',
30 | );
31 |
32 | }
33 |
34 |
35 | /*
36 | * render_field()
37 | *
38 | * Create the HTML interface for your field
39 | *
40 | * @param $field - an array holding all the field's data
41 | *
42 | * @type action
43 | * @since 3.6
44 | * @date 23/01/13
45 | */
46 |
47 | function render_field( $field ) {
48 |
49 | acf_get_field_type('text')->render_field( $field );
50 |
51 | }
52 |
53 |
54 | /*
55 | * render_field_settings()
56 | *
57 | * Create extra options for your field. This is rendered when editing a field.
58 | * The value of $field['name'] can be used (like bellow) to save extra data to the $field
59 | *
60 | * @type action
61 | * @since 3.6
62 | * @date 23/01/13
63 | *
64 | * @param $field - an array holding all the field's data
65 | */
66 |
67 | function render_field_settings( $field ) {
68 |
69 | // placeholder
70 | acf_render_field_setting( $field, array(
71 | 'label' => __('Placeholder Text','acf'),
72 | 'instructions' => __('Appears within the input','acf'),
73 | 'type' => 'text',
74 | 'name' => 'placeholder',
75 | ));
76 |
77 |
78 | // prepend
79 | acf_render_field_setting( $field, array(
80 | 'label' => __('Prepend','acf'),
81 | 'instructions' => __('Appears before the input','acf'),
82 | 'type' => 'text',
83 | 'name' => 'prepend',
84 | ));
85 |
86 |
87 | // append
88 | acf_render_field_setting( $field, array(
89 | 'label' => __('Append','acf'),
90 | 'instructions' => __('Appears after the input','acf'),
91 | 'type' => 'text',
92 | 'name' => 'append',
93 | ));
94 | }
95 |
96 | }
97 |
98 |
99 | // initialize
100 | acf_register_field_type( 'acf_field_password' );
101 |
102 | endif; // class_exists check
103 |
104 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/fields/class-acf-field-separator.php:
--------------------------------------------------------------------------------
1 | name = 'separator';
25 | $this->label = __("Separator",'acf');
26 | $this->category = 'layout';
27 |
28 | }
29 |
30 |
31 | /*
32 | * render_field()
33 | *
34 | * Create the HTML interface for your field
35 | *
36 | * @param $field - an array holding all the field's data
37 | *
38 | * @type action
39 | * @since 3.6
40 | * @date 23/01/13
41 | */
42 |
43 | function render_field( $field ) {
44 |
45 | /* do nothing */
46 |
47 | }
48 |
49 |
50 | /*
51 | * load_field()
52 | *
53 | * This filter is appied to the $field after it is loaded from the database
54 | *
55 | * @type filter
56 | * @since 3.6
57 | * @date 23/01/13
58 | *
59 | * @param $field - the field array holding all the field options
60 | *
61 | * @return $field - the field array holding all the field options
62 | */
63 |
64 | function load_field( $field ) {
65 |
66 | // remove name to avoid caching issue
67 | $field['name'] = '';
68 |
69 |
70 | // remove required to avoid JS issues
71 | $field['required'] = 0;
72 |
73 |
74 | // set value other than 'null' to avoid ACF loading / caching issue
75 | $field['value'] = false;
76 |
77 |
78 | // return
79 | return $field;
80 |
81 | }
82 |
83 | }
84 |
85 |
86 | // initialize
87 | acf_register_field_type( 'acf_field_separator' );
88 |
89 | endif; // class_exists check
90 |
91 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/fields/class-acf-field-tab.php:
--------------------------------------------------------------------------------
1 | name = 'tab';
25 | $this->label = __("Tab",'acf');
26 | $this->category = 'layout';
27 | $this->defaults = array(
28 | 'placement' => 'top',
29 | 'endpoint' => 0 // added in 5.2.8
30 | );
31 |
32 | }
33 |
34 |
35 | /*
36 | * render_field()
37 | *
38 | * Create the HTML interface for your field
39 | *
40 | * @param $field - an array holding all the field's data
41 | *
42 | * @type action
43 | * @since 3.6
44 | * @date 23/01/13
45 | */
46 |
47 | function render_field( $field ) {
48 |
49 | // vars
50 | $atts = array(
51 | 'href' => '',
52 | 'class' => 'acf-tab-button',
53 | 'data-placement' => $field['placement'],
54 | 'data-endpoint' => $field['endpoint'],
55 | 'data-key' => $field['key']
56 | );
57 |
58 | ?>
59 | >
60 | ' . __( 'Use "Tab Fields" to better organize your edit screen by grouping fields together.', 'acf') . '';
86 | $message .= '' . __( 'All fields following this "tab field" (or until another "tab field" is defined) will be grouped together using this field\'s label as the tab heading.','acf') . '
'; 87 | 88 | 89 | // default_value 90 | acf_render_field_setting( $field, array( 91 | 'label' => __('Instructions','acf'), 92 | 'instructions' => '', 93 | 'name' => 'notes', 94 | 'type' => 'message', 95 | 'message' => $message, 96 | )); 97 | */ 98 | 99 | 100 | // preview_size 101 | acf_render_field_setting( $field, array( 102 | 'label' => __('Placement','acf'), 103 | 'type' => 'select', 104 | 'name' => 'placement', 105 | 'choices' => array( 106 | 'top' => __("Top aligned", 'acf'), 107 | 'left' => __("Left aligned", 'acf'), 108 | ) 109 | )); 110 | 111 | 112 | // endpoint 113 | acf_render_field_setting( $field, array( 114 | 'label' => __('Endpoint','acf'), 115 | 'instructions' => __('Define an endpoint for the previous tabs to stop. This will start a new group of tabs.', 'acf'), 116 | 'name' => 'endpoint', 117 | 'type' => 'true_false', 118 | 'ui' => 1, 119 | )); 120 | 121 | } 122 | 123 | 124 | /* 125 | * load_field() 126 | * 127 | * This filter is appied to the $field after it is loaded from the database 128 | * 129 | * @type filter 130 | * @since 3.6 131 | * @date 23/01/13 132 | * 133 | * @param $field - the field array holding all the field options 134 | * 135 | * @return $field - the field array holding all the field options 136 | */ 137 | 138 | function load_field( $field ) { 139 | 140 | // remove name to avoid caching issue 141 | $field['name'] = ''; 142 | 143 | // remove required to avoid JS issues 144 | $field['required'] = 0; 145 | 146 | // set value other than 'null' to avoid ACF loading / caching issue 147 | $field['value'] = false; 148 | 149 | // return 150 | return $field; 151 | 152 | } 153 | 154 | } 155 | 156 | 157 | // initialize 158 | acf_register_field_type( 'acf_field_tab' ); 159 | 160 | endif; // class_exists check 161 | 162 | ?> -------------------------------------------------------------------------------- /api/wp-content/plugins/advanced-custom-fields-pro/includes/fields/class-acf-field-url.php: -------------------------------------------------------------------------------- 1 | name = 'url'; 25 | $this->label = __("Url",'acf'); 26 | $this->defaults = array( 27 | 'default_value' => '', 28 | 'placeholder' => '', 29 | ); 30 | 31 | } 32 | 33 | 34 | /* 35 | * render_field() 36 | * 37 | * Create the HTML interface for your field 38 | * 39 | * @param $field - an array holding all the field's data 40 | * 41 | * @type action 42 | * @since 3.6 43 | * @date 23/01/13 44 | */ 45 | 46 | function render_field( $field ) { 47 | 48 | // vars 49 | $atts = array(); 50 | $keys = array( 'type', 'id', 'class', 'name', 'value', 'placeholder', 'pattern' ); 51 | $keys2 = array( 'readonly', 'disabled', 'required' ); 52 | $html = ''; 53 | 54 | 55 | // atts (value="123") 56 | foreach( $keys as $k ) { 57 | if( isset($field[ $k ]) ) $atts[ $k ] = $field[ $k ]; 58 | } 59 | 60 | 61 | // atts2 (disabled="disabled") 62 | foreach( $keys2 as $k ) { 63 | if( !empty($field[ $k ]) ) $atts[ $k ] = $k; 64 | } 65 | 66 | 67 | // remove empty atts 68 | $atts = acf_clean_atts( $atts ); 69 | 70 | 71 | // render 72 | $html .= '';
73 | $html .= '' . acf_get_text_input( $atts ) ;
74 | $html .= '
';
75 |
76 |
77 | // return
78 | echo $html;
79 |
80 | }
81 |
82 |
83 | /*
84 | * render_field_settings()
85 | *
86 | * Create extra options for your field. This is rendered when editing a field.
87 | * The value of $field['name'] can be used (like bellow) to save extra data to the $field
88 | *
89 | * @type action
90 | * @since 3.6
91 | * @date 23/01/13
92 | *
93 | * @param $field - an array holding all the field's data
94 | */
95 |
96 | function render_field_settings( $field ) {
97 |
98 | // default_value
99 | acf_render_field_setting( $field, array(
100 | 'label' => __('Default Value','acf'),
101 | 'instructions' => __('Appears when creating a new post','acf'),
102 | 'type' => 'text',
103 | 'name' => 'default_value',
104 | ));
105 |
106 |
107 | // placeholder
108 | acf_render_field_setting( $field, array(
109 | 'label' => __('Placeholder Text','acf'),
110 | 'instructions' => __('Appears within the input','acf'),
111 | 'type' => 'text',
112 | 'name' => 'placeholder',
113 | ));
114 |
115 | }
116 |
117 |
118 | /*
119 | * validate_value
120 | *
121 | * description
122 | *
123 | * @type function
124 | * @date 11/02/2014
125 | * @since 5.0.0
126 | *
127 | * @param $post_id (int)
128 | * @return $post_id (int)
129 | */
130 |
131 | function validate_value( $valid, $value, $field, $input ){
132 |
133 | // bail early if empty
134 | if( empty($value) ) {
135 |
136 | return $valid;
137 |
138 | }
139 |
140 |
141 | if( strpos($value, '://') !== false ) {
142 |
143 | // url
144 |
145 | } elseif( strpos($value, '//') === 0 ) {
146 |
147 | // protocol relative url
148 |
149 | } else {
150 |
151 | $valid = __('Value must be a valid URL', 'acf');
152 |
153 | }
154 |
155 |
156 | // return
157 | return $valid;
158 |
159 | }
160 |
161 | }
162 |
163 |
164 | // initialize
165 | acf_register_field_type( 'acf_field_url' );
166 |
167 | endif; // class_exists check
168 |
169 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/forms/form-gutenberg.php:
--------------------------------------------------------------------------------
1 |
70 |
71 | edit_form_after_title(); ?>
72 |
73 |
78 |
81 |
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-attachment.php:
--------------------------------------------------------------------------------
1 | name = 'attachment';
27 | $this->label = __("Attachment",'acf');
28 | $this->category = 'forms';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $attachment = acf_maybe_get( $screen, 'attachment' );
51 |
52 |
53 | // validate
54 | if( !$attachment ) return false;
55 |
56 |
57 | // get attachment mime type
58 | $mime_type = get_post_mime_type( $attachment );
59 |
60 |
61 | // no specific mime
62 | if( !strpos($rule['value'], '/') ) {
63 |
64 | // explode into [0] => type, [1] => mime
65 | $bits = explode('/', $mime_type);
66 |
67 |
68 | // if type matches, fake the $mime_type to match
69 | if( $rule['value'] === $bits[0] ) {
70 |
71 | $mime_type = $rule['value'];
72 |
73 | }
74 | }
75 |
76 |
77 | // match
78 | return $this->compare( $mime_type, $rule );
79 |
80 | }
81 |
82 |
83 | /*
84 | * rule_operators
85 | *
86 | * This function returns the available values for this rule type
87 | *
88 | * @type function
89 | * @date 30/5/17
90 | * @since 5.6.0
91 | *
92 | * @param n/a
93 | * @return (array)
94 | */
95 |
96 | function rule_values( $choices, $rule ) {
97 |
98 | // vars
99 | $mimes = get_allowed_mime_types();
100 | $choices = array(
101 | 'all' => __('All', 'acf')
102 | );
103 |
104 |
105 | // loop
106 | foreach( $mimes as $type => $mime ) {
107 |
108 | $group = current( explode('/', $mime) );
109 | $choices[ $group ][ $group ] = sprintf( __('All %s formats', 'acf'), $group);
110 | $choices[ $group ][ $mime ] = "$type ($mime)";
111 |
112 | }
113 |
114 |
115 | // return
116 | return $choices;
117 |
118 | }
119 |
120 | }
121 |
122 | // initialize
123 | acf_register_location_rule( 'acf_location_attachment' );
124 |
125 | endif; // class_exists check
126 |
127 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-comment.php:
--------------------------------------------------------------------------------
1 | name = 'comment';
27 | $this->label = __("Comment",'acf');
28 | $this->category = 'forms';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $comment = acf_maybe_get( $screen, 'comment' );
51 |
52 |
53 | // bail early if not comment
54 | if( !$comment ) return false;
55 |
56 |
57 | // return
58 | return $this->compare( $comment, $rule );
59 |
60 | }
61 |
62 |
63 | /*
64 | * rule_operators
65 | *
66 | * This function returns the available values for this rule type
67 | *
68 | * @type function
69 | * @date 30/5/17
70 | * @since 5.6.0
71 | *
72 | * @param n/a
73 | * @return (array)
74 | */
75 |
76 | function rule_values( $choices, $rule ) {
77 |
78 | // vars
79 | $choices = array( 'all' => __('All', 'acf') );
80 | $choices = array_merge( $choices, acf_get_pretty_post_types() );
81 | // change this to post types that support comments
82 |
83 | // return
84 | return $choices;
85 |
86 | }
87 |
88 | }
89 |
90 | // initialize
91 | acf_register_location_rule( 'acf_location_comment' );
92 |
93 | endif; // class_exists check
94 |
95 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-current-user-role.php:
--------------------------------------------------------------------------------
1 | name = 'current_user_role';
27 | $this->label = __("Current User Role",'acf');
28 | $this->category = 'user';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // bail early if not logged in
50 | if( !is_user_logged_in() ) return false;
51 |
52 |
53 | // vars
54 | $user = wp_get_current_user();
55 |
56 |
57 | // super_admin
58 | if( $rule['value'] == 'super_admin' ) {
59 |
60 | $result = is_super_admin( $user->ID );
61 |
62 | // role
63 | } else {
64 |
65 | $result = in_array( $rule['value'], $user->roles );
66 |
67 | }
68 |
69 |
70 | // reverse if 'not equal to'
71 | if( $rule['operator'] == '!=' ) {
72 |
73 | $result = !$result;
74 |
75 | }
76 |
77 |
78 | // return
79 | return $result;
80 |
81 | }
82 |
83 |
84 | /*
85 | * rule_operators
86 | *
87 | * This function returns the available values for this rule type
88 | *
89 | * @type function
90 | * @date 30/5/17
91 | * @since 5.6.0
92 | *
93 | * @param n/a
94 | * @return (array)
95 | */
96 |
97 | function rule_values( $choices, $rule ) {
98 |
99 | // global
100 | global $wp_roles;
101 |
102 |
103 | // specific roles
104 | $choices = $wp_roles->get_names();
105 |
106 |
107 | // multi-site
108 | if( is_multisite() ) {
109 |
110 | $prepend = array( 'super_admin' => __('Super Admin', 'acf') );
111 | $choices = array_merge( $prepend, $choices );
112 |
113 | }
114 |
115 |
116 | // return
117 | return $choices;
118 |
119 | }
120 |
121 | }
122 |
123 | // initialize
124 | acf_register_location_rule( 'acf_location_current_user_role' );
125 |
126 | endif; // class_exists check
127 |
128 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-current-user.php:
--------------------------------------------------------------------------------
1 | name = 'current_user';
27 | $this->label = __("Current User",'acf');
28 | $this->category = 'user';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // logged in
50 | if( $rule['value'] == 'logged_in' ) {
51 |
52 | $result = is_user_logged_in();
53 |
54 | // viewing_front
55 | } elseif( $rule['value'] == 'viewing_front' ) {
56 |
57 | $result = !is_admin();
58 |
59 | // viewing_back
60 | } elseif( $rule['value'] == 'viewing_back' ) {
61 |
62 | $result = is_admin();
63 |
64 | }
65 |
66 |
67 | // reverse if 'not equal to'
68 | if( $rule['operator'] == '!=' ) {
69 |
70 | $result = !$result;
71 |
72 | }
73 |
74 |
75 | // return
76 | return $result;
77 |
78 | }
79 |
80 |
81 | /*
82 | * rule_operators
83 | *
84 | * This function returns the available values for this rule type
85 | *
86 | * @type function
87 | * @date 30/5/17
88 | * @since 5.6.0
89 | *
90 | * @param n/a
91 | * @return (array)
92 | */
93 |
94 | function rule_values( $choices, $rule ) {
95 |
96 | return array(
97 | 'logged_in' => __('Logged in', 'acf'),
98 | 'viewing_front' => __('Viewing front end', 'acf'),
99 | 'viewing_back' => __('Viewing back end', 'acf')
100 | );
101 |
102 | }
103 |
104 | }
105 |
106 | // initialize
107 | acf_register_location_rule( 'acf_location_current_user' );
108 |
109 | endif; // class_exists check
110 |
111 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-nav-menu-item.php:
--------------------------------------------------------------------------------
1 | name = 'nav_menu_item';
27 | $this->label = __("Menu Item",'acf');
28 | $this->category = 'forms';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $nav_menu_item = acf_maybe_get( $screen, 'nav_menu_item' );
51 |
52 |
53 | // bail early if not nav_menu_item
54 | if( !$nav_menu_item ) return false;
55 |
56 |
57 | // append nav_menu data
58 | if( !isset($screen['nav_menu']) ) {
59 | $screen['nav_menu'] = acf_get_data('nav_menu_id');
60 | }
61 |
62 |
63 | // return
64 | return acf_get_location_rule('nav_menu')->rule_match( $result, $rule, $screen );
65 |
66 | }
67 |
68 |
69 | /*
70 | * rule_operators
71 | *
72 | * This function returns the available values for this rule type
73 | *
74 | * @type function
75 | * @date 30/5/17
76 | * @since 5.6.0
77 | *
78 | * @param n/a
79 | * @return (array)
80 | */
81 |
82 | function rule_values( $choices, $rule ) {
83 |
84 | // get menu choices
85 | $choices = acf_get_location_rule('nav_menu')->rule_values( $choices, $rule );
86 |
87 |
88 | // append item types?
89 | // dificult to get these details
90 |
91 |
92 | // return
93 | return $choices;
94 |
95 | }
96 |
97 | }
98 |
99 | // initialize
100 | acf_register_location_rule( 'acf_location_nav_menu_item' );
101 |
102 | endif; // class_exists check
103 |
104 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-nav-menu.php:
--------------------------------------------------------------------------------
1 | name = 'nav_menu';
27 | $this->label = __("Menu",'acf');
28 | $this->category = 'forms';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $nav_menu = acf_maybe_get( $screen, 'nav_menu' );
51 |
52 |
53 | // bail early if not nav_menu
54 | if( !$nav_menu ) return false;
55 |
56 |
57 | // location
58 | if( substr($rule['value'], 0, 9) === 'location/' ) {
59 |
60 | // vars
61 | $location = substr($rule['value'], 9);
62 | $menu_locations = get_nav_menu_locations();
63 |
64 |
65 | // bail ealry if no location
66 | if( !isset($menu_locations[$location]) ) return false;
67 |
68 |
69 | // if location matches, update value
70 | if( $menu_locations[$location] == $nav_menu ) {
71 |
72 | $nav_menu = $rule['value'];
73 |
74 | }
75 |
76 | }
77 |
78 |
79 | // return
80 | return $this->compare( $nav_menu, $rule );
81 |
82 | }
83 |
84 |
85 | /*
86 | * rule_operators
87 | *
88 | * This function returns the available values for this rule type
89 | *
90 | * @type function
91 | * @date 30/5/17
92 | * @since 5.6.0
93 | *
94 | * @param n/a
95 | * @return (array)
96 | */
97 |
98 | function rule_values( $choices, $rule ) {
99 |
100 | // all
101 | $choices = array(
102 | 'all' => __('All', 'acf'),
103 | );
104 |
105 |
106 | // locations
107 | $nav_locations = get_registered_nav_menus();
108 | if( !empty($nav_locations) ) {
109 | $cat = __('Menu Locations', 'acf');
110 | foreach( $nav_locations as $slug => $title ) {
111 | $choices[ $cat ][ 'location/'.$slug ] = $title;
112 | }
113 | }
114 |
115 |
116 | // specific menus
117 | $nav_menus = wp_get_nav_menus();
118 | if( !empty($nav_menus) ) {
119 | $cat = __('Menus', 'acf');
120 | foreach( $nav_menus as $nav_menu ) {
121 | $choices[ $cat ][ $nav_menu->term_id ] = $nav_menu->name;
122 | }
123 | }
124 |
125 |
126 | // return
127 | return $choices;
128 |
129 | }
130 |
131 | }
132 |
133 | // initialize
134 | acf_register_location_rule( 'acf_location_nav_menu' );
135 |
136 | endif; // class_exists check
137 |
138 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-page-parent.php:
--------------------------------------------------------------------------------
1 | name = 'page_parent';
27 | $this->label = __("Page Parent",'acf');
28 | $this->category = 'page';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $post_id = acf_maybe_get( $screen, 'post_id' );
51 | $page_parent = acf_maybe_get( $screen, 'page_parent' );
52 |
53 |
54 | // no page parent
55 | if( $page_parent === null ) {
56 |
57 | // bail early if no post id
58 | if( !$post_id ) return false;
59 |
60 |
61 | // get post parent
62 | $post = get_post( $post_id );
63 | $page_parent = $post->post_parent;
64 |
65 | }
66 |
67 |
68 | // compare
69 | return $this->compare( $page_parent, $rule );
70 |
71 | }
72 |
73 |
74 | /*
75 | * rule_operators
76 | *
77 | * This function returns the available values for this rule type
78 | *
79 | * @type function
80 | * @date 30/5/17
81 | * @since 5.6.0
82 | *
83 | * @param n/a
84 | * @return (array)
85 | */
86 |
87 | function rule_values( $choices, $rule ) {
88 |
89 | return acf_get_location_rule('page')->rule_values( $choices, $rule );
90 |
91 | }
92 |
93 | }
94 |
95 | // initialize
96 | acf_register_location_rule( 'acf_location_page_parent' );
97 |
98 | endif; // class_exists check
99 |
100 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-page-template.php:
--------------------------------------------------------------------------------
1 | name = 'page_template';
27 | $this->label = __("Page Template",'acf');
28 | $this->category = 'page';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $post_type = acf_maybe_get( $screen, 'post_type' );
51 |
52 |
53 | // lookup post_type
54 | if( !$post_type ) {
55 |
56 | $post_id = acf_maybe_get( $screen, 'post_id' );
57 |
58 | if( !$post_id ) return false;
59 |
60 | $post_type = get_post_type( $post_id );
61 |
62 | }
63 |
64 |
65 | // page template 'default' rule is only for 'page' post type
66 | // prevents 'Default Template' field groups appearing on all post types that allow for post templates (WP 4.7)
67 | if( $rule['value'] === 'default' ) {
68 |
69 | // bail ealry if not page
70 | if( $post_type !== 'page' ) return false;
71 |
72 | }
73 |
74 |
75 | // return
76 | return acf_get_location_rule('post_template')->rule_match( $result, $rule, $screen );
77 |
78 | }
79 |
80 |
81 | /*
82 | * rule_operators
83 | *
84 | * This function returns the available values for this rule type
85 | *
86 | * @type function
87 | * @date 30/5/17
88 | * @since 5.6.0
89 | *
90 | * @param n/a
91 | * @return (array)
92 | */
93 |
94 | function rule_values( $choices, $rule ) {
95 |
96 | // vars
97 | $choices = array(
98 | 'default' => apply_filters( 'default_page_template_title', __('Default Template', 'acf') )
99 | );
100 |
101 |
102 | // get templates and merge them in
103 | $templates = wp_get_theme()->get_page_templates();
104 | $choices = array_merge($choices, $templates);
105 |
106 |
107 | // return choices
108 | return $choices;
109 |
110 | }
111 |
112 | }
113 |
114 | // initialize
115 | acf_register_location_rule( 'acf_location_page_template' );
116 |
117 | endif; // class_exists check
118 |
119 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-page-type.php:
--------------------------------------------------------------------------------
1 | name = 'page_type';
27 | $this->label = __("Page Type",'acf');
28 | $this->category = 'page';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $post_id = acf_maybe_get( $screen, 'post_id' );
51 |
52 | // bail early if no post id
53 | if( !$post_id ) return false;
54 |
55 | // get post
56 | $post = get_post( $post_id );
57 |
58 | // bail early if no post
59 | if( !$post ) return false;
60 |
61 |
62 | // compare
63 | if( $rule['value'] == 'front_page') {
64 |
65 | // vars
66 | $front_page = (int) get_option('page_on_front');
67 |
68 |
69 | // compare
70 | $result = ( $front_page === $post->ID );
71 |
72 | } elseif( $rule['value'] == 'posts_page') {
73 |
74 | // vars
75 | $posts_page = (int) get_option('page_for_posts');
76 |
77 |
78 | // compare
79 | $result = ( $posts_page === $post->ID );
80 |
81 | } elseif( $rule['value'] == 'top_level') {
82 |
83 | // vars
84 | $page_parent = acf_maybe_get( $screen, 'page_parent', $post->post_parent );
85 |
86 |
87 | // compare
88 | $result = ( $page_parent == 0 );
89 |
90 | } elseif( $rule['value'] == 'parent' ) {
91 |
92 | // get children
93 | $children = get_posts(array(
94 | 'post_type' => $post->post_type,
95 | 'post_parent' => $post->ID,
96 | 'posts_per_page' => 1,
97 | 'fields' => 'ids',
98 | ));
99 |
100 |
101 | // compare
102 | $result = !empty( $children );
103 |
104 | } elseif( $rule['value'] == 'child') {
105 |
106 | // vars
107 | $page_parent = acf_maybe_get( $screen, 'page_parent', $post->post_parent );
108 |
109 |
110 | // compare
111 | $result = ( $page_parent > 0 );
112 |
113 | }
114 |
115 |
116 | // reverse if 'not equal to'
117 | if( $rule['operator'] == '!=' ) {
118 |
119 | $result = !$result;
120 |
121 | }
122 |
123 |
124 | // return
125 | return $result;
126 |
127 | }
128 |
129 |
130 | /*
131 | * rule_operators
132 | *
133 | * This function returns the available values for this rule type
134 | *
135 | * @type function
136 | * @date 30/5/17
137 | * @since 5.6.0
138 | *
139 | * @param n/a
140 | * @return (array)
141 | */
142 |
143 | function rule_values( $choices, $rule ) {
144 |
145 | return array(
146 | 'front_page' => __("Front Page",'acf'),
147 | 'posts_page' => __("Posts Page",'acf'),
148 | 'top_level' => __("Top Level Page (no parent)",'acf'),
149 | 'parent' => __("Parent Page (has children)",'acf'),
150 | 'child' => __("Child Page (has parent)",'acf'),
151 | );
152 |
153 | }
154 |
155 | }
156 |
157 | // initialize
158 | acf_register_location_rule( 'acf_location_page_type' );
159 |
160 | endif; // class_exists check
161 |
162 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-page.php:
--------------------------------------------------------------------------------
1 | name = 'page';
27 | $this->label = __("Page",'acf');
28 | $this->category = 'page';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | return acf_get_location_rule('post')->rule_match( $result, $rule, $screen );
50 |
51 | }
52 |
53 |
54 | /*
55 | * rule_operators
56 | *
57 | * This function returns the available values for this rule type
58 | *
59 | * @type function
60 | * @date 30/5/17
61 | * @since 5.6.0
62 | *
63 | * @param n/a
64 | * @return (array)
65 | */
66 |
67 | function rule_values( $choices, $rule ) {
68 |
69 | // get posts grouped by post type
70 | $groups = acf_get_grouped_posts(array(
71 | 'post_type' => 'page'
72 | ));
73 |
74 |
75 | // pop
76 | $choices = array_pop( $groups );
77 |
78 |
79 | // convert posts to titles
80 | foreach( $choices as &$item ) {
81 |
82 | $item = acf_get_post_title( $item );
83 |
84 | }
85 |
86 |
87 | // return
88 | return $choices;
89 |
90 | }
91 |
92 | }
93 |
94 | // initialize
95 | acf_register_location_rule( 'acf_location_page' );
96 |
97 | endif; // class_exists check
98 |
99 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-post-category.php:
--------------------------------------------------------------------------------
1 | name = 'post_category';
27 | $this->label = __("Post Category",'acf');
28 | $this->category = 'post';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | return acf_get_location_rule('post_taxonomy')->rule_match( $result, $rule, $screen );
50 |
51 | }
52 |
53 |
54 | /*
55 | * rule_operators
56 | *
57 | * This function returns the available values for this rule type
58 | *
59 | * @type function
60 | * @date 30/5/17
61 | * @since 5.6.0
62 | *
63 | * @param n/a
64 | * @return (array)
65 | */
66 |
67 | function rule_values( $choices, $rule ) {
68 |
69 | $terms = acf_get_taxonomy_terms( 'category' );
70 |
71 | if( !empty($terms) ) {
72 |
73 | $choices = array_pop($terms);
74 |
75 | }
76 |
77 | return $choices;
78 |
79 | }
80 |
81 | }
82 |
83 | // initialize
84 | acf_register_location_rule( 'acf_location_post_category' );
85 |
86 | endif; // class_exists check
87 |
88 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-post-format.php:
--------------------------------------------------------------------------------
1 | name = 'post_format';
27 | $this->label = __("Post Format",'acf');
28 | $this->category = 'post';
29 |
30 | }
31 |
32 |
33 | /*
34 | * get_post_type
35 | *
36 | * This function will return the current post_type
37 | *
38 | * @type function
39 | * @date 25/11/16
40 | * @since 5.5.0
41 | *
42 | * @param $options (int)
43 | * @return (mixed)
44 | */
45 |
46 | function get_post_type( $screen ) {
47 |
48 | // vars
49 | $post_id = acf_maybe_get( $screen, 'post_id' );
50 | $post_type = acf_maybe_get( $screen, 'post_type' );
51 |
52 |
53 | // post_type
54 | if( $post_type ) return $post_type;
55 |
56 |
57 | // $post_id
58 | if( $post_id ) return get_post_type( $post_id );
59 |
60 |
61 | // return
62 | return false;
63 |
64 | }
65 |
66 |
67 | /*
68 | * rule_match
69 | *
70 | * This function is used to match this location $rule to the current $screen
71 | *
72 | * @type function
73 | * @date 3/01/13
74 | * @since 3.5.7
75 | *
76 | * @param $match (boolean)
77 | * @param $rule (array)
78 | * @return $options (array)
79 | */
80 |
81 | function rule_match( $result, $rule, $screen ) {
82 |
83 | // vars
84 | $post_format = acf_maybe_get( $screen, 'post_format' );
85 |
86 |
87 | // find post format
88 | if( !$post_format ) {
89 |
90 | // get post id
91 | $post_id = acf_maybe_get( $screen, 'post_id' );
92 | $post_type = $this->get_post_type( $screen );
93 |
94 |
95 | // bail early if not a post
96 | if( !$post_id || !$post_type ) return false;
97 |
98 |
99 | // does post_type support 'post-format'
100 | if( post_type_supports($post_type, 'post-formats') ) {
101 |
102 | // update
103 | $post_format = get_post_format($post_id);
104 | $post_format = $post_format ? $post_format : 'standard';
105 |
106 | }
107 |
108 | }
109 |
110 |
111 | // compare
112 | return $this->compare( $post_format, $rule );
113 |
114 | }
115 |
116 |
117 | /*
118 | * rule_operators
119 | *
120 | * This function returns the available values for this rule type
121 | *
122 | * @type function
123 | * @date 30/5/17
124 | * @since 5.6.0
125 | *
126 | * @param n/a
127 | * @return (array)
128 | */
129 |
130 | function rule_values( $choices, $rule ) {
131 |
132 | return get_post_format_strings();
133 |
134 | }
135 |
136 | }
137 |
138 | // initialize
139 | acf_register_location_rule( 'acf_location_post_format' );
140 |
141 | endif; // class_exists check
142 |
143 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-post-status.php:
--------------------------------------------------------------------------------
1 | name = 'post_status';
27 | $this->label = __("Post Status",'acf');
28 | $this->category = 'post';
29 |
30 | }
31 |
32 |
33 | /*
34 | * get_post_type
35 | *
36 | * This function will return the current post_type
37 | *
38 | * @type function
39 | * @date 25/11/16
40 | * @since 5.5.0
41 | *
42 | * @param $options (int)
43 | * @return (mixed)
44 | */
45 |
46 | function get_post_type( $screen ) {
47 |
48 | // vars
49 | $post_id = acf_maybe_get( $screen, 'post_id' );
50 | $post_type = acf_maybe_get( $screen, 'post_type' );
51 |
52 |
53 | // post_type
54 | if( $post_type ) return $post_type;
55 |
56 |
57 | // $post_id
58 | if( $post_id ) return get_post_type( $post_id );
59 |
60 |
61 | // return
62 | return false;
63 |
64 | }
65 |
66 |
67 | /*
68 | * rule_match
69 | *
70 | * This function is used to match this location $rule to the current $screen
71 | *
72 | * @type function
73 | * @date 3/01/13
74 | * @since 3.5.7
75 | *
76 | * @param $match (boolean)
77 | * @param $rule (array)
78 | * @return $options (array)
79 | */
80 |
81 | function rule_match( $result, $rule, $screen ) {
82 |
83 | // vars
84 | $post_status = acf_maybe_get( $screen, 'post_status' );
85 |
86 |
87 | // find post format
88 | if( !$post_status ) {
89 |
90 | // get post id
91 | $post_id = acf_maybe_get( $screen, 'post_id' );
92 |
93 |
94 | // bail early if not a post
95 | if( !$post_id ) return false;
96 |
97 |
98 | // update
99 | $post_status = get_post_status( $post_id );
100 |
101 | }
102 |
103 |
104 | // auto-draft = draft
105 | if( $post_status == 'auto-draft' ) {
106 |
107 | $post_status = 'draft';
108 |
109 | }
110 |
111 |
112 | // match
113 | return $this->compare( $post_status, $rule );
114 |
115 | }
116 |
117 |
118 | /*
119 | * rule_operators
120 | *
121 | * This function returns the available values for this rule type
122 | *
123 | * @type function
124 | * @date 30/5/17
125 | * @since 5.6.0
126 | *
127 | * @param n/a
128 | * @return (array)
129 | */
130 |
131 | function rule_values( $choices, $rule ) {
132 |
133 | // globals
134 | global $wp_post_statuses;
135 |
136 |
137 | // append
138 | if( !empty($wp_post_statuses) ) {
139 |
140 | foreach( $wp_post_statuses as $status ) {
141 |
142 | $choices[ $status->name ] = $status->label;
143 |
144 | }
145 |
146 | }
147 |
148 |
149 | // return choices
150 | return $choices;
151 |
152 | }
153 |
154 | }
155 |
156 | // initialize
157 | acf_register_location_rule( 'acf_location_post_status' );
158 |
159 | endif; // class_exists check
160 |
161 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-post-taxonomy.php:
--------------------------------------------------------------------------------
1 | name = 'post_taxonomy';
27 | $this->label = __("Post Taxonomy",'acf');
28 | $this->category = 'post';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $post_id = acf_maybe_get( $screen, 'post_id' );
51 | $terms = acf_maybe_get( $screen, 'post_taxonomy' );
52 |
53 |
54 | // bail early if not a post
55 | if( !$post_id ) return false;
56 |
57 |
58 | // get term data
59 | $data = acf_decode_taxonomy_term( $rule['value'] );
60 | $term = get_term_by( 'slug', $data['term'], $data['taxonomy'] );
61 |
62 |
63 | // attempt get term via ID (ACF4 uses ID)
64 | if( !$term && is_numeric($data['term']) ) {
65 |
66 | $term = get_term_by( 'id', $data['term'], $data['taxonomy'] );
67 |
68 | }
69 |
70 |
71 | // bail early if no term
72 | if( !$term ) return false;
73 |
74 |
75 | // not ajax, load real post's terms
76 | if( $terms === null ) {
77 |
78 | $terms = wp_get_post_terms( $post_id, $term->taxonomy, array('fields' => 'ids') );
79 |
80 | }
81 |
82 |
83 | // If no terms, this is a new post and should be treated as if it has the "Uncategorized" (1) category ticked
84 | if( empty($terms) ) {
85 |
86 | // get post type
87 | $post_type = get_post_type( $post_id );
88 |
89 |
90 | // if is category
91 | if( is_object_in_taxonomy($post_type, 'category') ) {
92 |
93 | $terms = array( 1 );
94 |
95 | }
96 |
97 | }
98 |
99 |
100 | // match
101 | if( !empty($terms) ) {
102 |
103 | $result = in_array( $term->term_id, $terms );
104 |
105 | }
106 |
107 |
108 | // reverse if 'not equal to'
109 | if( $rule['operator'] === '!=' ) {
110 |
111 | $result = !$result;
112 |
113 | }
114 |
115 |
116 | // return
117 | return $result;
118 |
119 | }
120 |
121 |
122 | /*
123 | * rule_operators
124 | *
125 | * This function returns the available values for this rule type
126 | *
127 | * @type function
128 | * @date 30/5/17
129 | * @since 5.6.0
130 | *
131 | * @param n/a
132 | * @return (array)
133 | */
134 |
135 | function rule_values( $choices, $rule ) {
136 |
137 | // get
138 | $choices = acf_get_taxonomy_terms();
139 |
140 |
141 | // unset post_format
142 | if( isset($choices['post_format']) ) {
143 |
144 | unset( $choices['post_format']) ;
145 |
146 | }
147 |
148 |
149 | // return
150 | return $choices;
151 |
152 | }
153 |
154 | }
155 |
156 | // initialize
157 | acf_register_location_rule( 'acf_location_post_taxonomy' );
158 |
159 | endif; // class_exists check
160 |
161 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-post-template.php:
--------------------------------------------------------------------------------
1 | name = 'post_template';
27 | $this->label = __("Post Template",'acf');
28 | $this->category = 'post';
29 | $this->public = acf_version_compare('wp', '>=', '4.7');
30 |
31 | }
32 |
33 |
34 | /*
35 | * get_post_type
36 | *
37 | * This function will return the current post_type
38 | *
39 | * @type function
40 | * @date 25/11/16
41 | * @since 5.5.0
42 | *
43 | * @param $options (int)
44 | * @return (mixed)
45 | */
46 |
47 | function get_post_type( $screen ) {
48 |
49 | // vars
50 | $post_id = acf_maybe_get( $screen, 'post_id' );
51 | $post_type = acf_maybe_get( $screen, 'post_type' );
52 |
53 |
54 | // post_type
55 | if( $post_type ) return $post_type;
56 |
57 |
58 | // $post_id
59 | if( $post_id ) return get_post_type( $post_id );
60 |
61 |
62 | // return
63 | return false;
64 |
65 | }
66 |
67 |
68 | /*
69 | * rule_match
70 | *
71 | * This function is used to match this location $rule to the current $screen
72 | *
73 | * @type function
74 | * @date 3/01/13
75 | * @since 3.5.7
76 | *
77 | * @param $match (boolean)
78 | * @param $rule (array)
79 | * @return $options (array)
80 | */
81 |
82 | function rule_match( $result, $rule, $screen ) {
83 |
84 | // vars
85 | $templates = array();
86 | $post_id = acf_maybe_get( $screen, 'post_id' );
87 | $page_template = acf_maybe_get( $screen, 'page_template' );
88 | $post_type = $this->get_post_type( $screen );
89 |
90 |
91 | // bail early if no post_type found (not a post)
92 | if( !$post_type ) return false;
93 |
94 |
95 | // get templates (WP 4.7)
96 | if( acf_version_compare('wp', '>=', '4.7') ) {
97 |
98 | $templates = acf_get_post_templates();
99 |
100 | }
101 |
102 |
103 | // 'page' is always a valid pt even if no templates exist in the theme
104 | // allows scenario where page_template = 'default' and no templates exist
105 | if( !isset($templates['page']) ) {
106 |
107 | $templates['page'] = array();
108 |
109 | }
110 |
111 |
112 | // bail early if this post type does not allow for templates
113 | if( !isset($templates[ $post_type ]) ) return false;
114 |
115 |
116 | // get page template
117 | if( !$page_template ) {
118 |
119 | $page_template = get_post_meta( $post_id, '_wp_page_template', true );
120 |
121 | }
122 |
123 |
124 | // new post - no page template
125 | if( !$page_template ) $page_template = "default";
126 |
127 |
128 | // match
129 | return $this->compare( $page_template, $rule );
130 |
131 | }
132 |
133 |
134 | /*
135 | * rule_operators
136 | *
137 | * This function returns the available values for this rule type
138 | *
139 | * @type function
140 | * @date 30/5/17
141 | * @since 5.6.0
142 | *
143 | * @param n/a
144 | * @return (array)
145 | */
146 |
147 | function rule_values( $choices, $rule ) {
148 |
149 | // vars
150 | $choices = array(
151 | 'default' => apply_filters( 'default_page_template_title', __('Default Template', 'acf') )
152 | );
153 |
154 |
155 | // get templates (WP 4.7)
156 | if( acf_version_compare('wp', '>=', '4.7') ) {
157 |
158 | $templates = acf_get_post_templates();
159 | $choices = array_merge($choices, $templates);
160 |
161 | }
162 |
163 |
164 | // return choices
165 | return $choices;
166 |
167 | }
168 |
169 | }
170 |
171 | // initialize
172 | acf_register_location_rule( 'acf_location_post_template' );
173 |
174 | endif; // class_exists check
175 |
176 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-post-type.php:
--------------------------------------------------------------------------------
1 | name = 'post_type';
27 | $this->label = __("Post Type",'acf');
28 | $this->category = 'post';
29 |
30 | }
31 |
32 |
33 | /*
34 | * get_post_type
35 | *
36 | * This function will return the current post_type
37 | *
38 | * @type function
39 | * @date 25/11/16
40 | * @since 5.5.0
41 | *
42 | * @param $options (int)
43 | * @return (mixed)
44 | */
45 |
46 | function get_post_type( $screen ) {
47 |
48 | // vars
49 | $post_id = acf_maybe_get( $screen, 'post_id' );
50 | $post_type = acf_maybe_get( $screen, 'post_type' );
51 |
52 |
53 | // post_type
54 | if( $post_type ) return $post_type;
55 |
56 |
57 | // $post_id
58 | if( $post_id ) return get_post_type( $post_id );
59 |
60 |
61 | // return
62 | return false;
63 |
64 | }
65 |
66 |
67 | /*
68 | * rule_match
69 | *
70 | * This function is used to match this location $rule to the current $screen
71 | *
72 | * @type function
73 | * @date 3/01/13
74 | * @since 3.5.7
75 | *
76 | * @param $match (boolean)
77 | * @param $rule (array)
78 | * @return $options (array)
79 | */
80 |
81 | function rule_match( $result, $rule, $screen ) {
82 |
83 | // vars
84 | $post_type = $this->get_post_type( $screen );
85 |
86 |
87 | // bail early if no post_type found (not a post)
88 | if( !$post_type ) return false;
89 |
90 |
91 | // match
92 | return $this->compare( $post_type, $rule );
93 |
94 | }
95 |
96 |
97 | /*
98 | * rule_operators
99 | *
100 | * This function returns the available values for this rule type
101 | *
102 | * @type function
103 | * @date 30/5/17
104 | * @since 5.6.0
105 | *
106 | * @param n/a
107 | * @return (array)
108 | */
109 |
110 | function rule_values( $choices, $rule ) {
111 |
112 | // get post types
113 | // - removed show_ui to allow 3rd party code to register a post type using a custom admin edit page
114 | $post_types = acf_get_post_types(array(
115 | 'show_ui' => 1,
116 | 'exclude' => array('attachment')
117 | ));
118 |
119 |
120 | // return choices
121 | return acf_get_pretty_post_types( $post_types );
122 |
123 | }
124 |
125 | }
126 |
127 | // initialize
128 | acf_register_location_rule( 'acf_location_post_type' );
129 |
130 | endif; // class_exists check
131 |
132 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-post.php:
--------------------------------------------------------------------------------
1 | name = 'post';
27 | $this->label = __("Post",'acf');
28 | $this->category = 'post';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $post_id = acf_maybe_get( $screen, 'post_id' );
51 |
52 |
53 | // bail early if not post
54 | if( !$post_id ) return false;
55 |
56 |
57 | // compare
58 | return $this->compare( $post_id, $rule );
59 |
60 | }
61 |
62 |
63 | /*
64 | * rule_operators
65 | *
66 | * This function returns the available values for this rule type
67 | *
68 | * @type function
69 | * @date 30/5/17
70 | * @since 5.6.0
71 | *
72 | * @param n/a
73 | * @return (array)
74 | */
75 |
76 | function rule_values( $choices, $rule ) {
77 |
78 | // get post types
79 | $post_types = acf_get_post_types(array(
80 | 'show_ui' => 1,
81 | 'exclude' => array('page', 'attachment')
82 | ));
83 |
84 |
85 | // get posts grouped by post type
86 | $groups = acf_get_grouped_posts(array(
87 | 'post_type' => $post_types
88 | ));
89 |
90 |
91 | if( !empty($groups) ) {
92 |
93 | foreach( array_keys($groups) as $group_title ) {
94 |
95 | // vars
96 | $posts = acf_extract_var( $groups, $group_title );
97 |
98 |
99 | // override post data
100 | foreach( array_keys($posts) as $post_id ) {
101 |
102 | // update
103 | $posts[ $post_id ] = acf_get_post_title( $posts[ $post_id ] );
104 |
105 | };
106 |
107 |
108 | // append to $choices
109 | $choices[ $group_title ] = $posts;
110 |
111 | }
112 |
113 | }
114 |
115 |
116 | // return
117 | return $choices;
118 |
119 | }
120 |
121 | }
122 |
123 | // initialize
124 | acf_register_location_rule( 'acf_location_post' );
125 |
126 | endif; // class_exists check
127 |
128 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-taxonomy.php:
--------------------------------------------------------------------------------
1 | name = 'taxonomy';
27 | $this->label = __("Taxonomy",'acf');
28 | $this->category = 'forms';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $taxonomy = acf_maybe_get( $screen, 'taxonomy' );
51 |
52 |
53 | // bail early if not taxonomy
54 | if( !$taxonomy ) return false;
55 |
56 |
57 | // return
58 | return $this->compare( $taxonomy, $rule );
59 |
60 | }
61 |
62 |
63 | /*
64 | * rule_operators
65 | *
66 | * This function returns the available values for this rule type
67 | *
68 | * @type function
69 | * @date 30/5/17
70 | * @since 5.6.0
71 | *
72 | * @param n/a
73 | * @return (array)
74 | */
75 |
76 | function rule_values( $choices, $rule ) {
77 |
78 | // vars
79 | $choices = array( 'all' => __('All', 'acf') );
80 | $choices = array_merge( $choices, acf_get_taxonomies() );
81 |
82 |
83 | // return
84 | return $choices;
85 |
86 | }
87 |
88 | }
89 |
90 | // initialize
91 | acf_register_location_rule( 'acf_location_taxonomy' );
92 |
93 | endif; // class_exists check
94 |
95 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-user-form.php:
--------------------------------------------------------------------------------
1 | name = 'user_form';
27 | $this->label = __("User Form",'acf');
28 | $this->category = 'user';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $user_form = acf_maybe_get( $screen, 'user_form' );
51 |
52 |
53 | // bail early if no user form
54 | if( !$user_form ) return false;
55 |
56 |
57 | // add is treated the same as edit
58 | if( $user_form === 'add' ) {
59 |
60 | $user_form = 'edit';
61 |
62 | }
63 |
64 |
65 | // match
66 | return $this->compare( $user_form, $rule );
67 |
68 | }
69 |
70 |
71 | /*
72 | * rule_operators
73 | *
74 | * This function returns the available values for this rule type
75 | *
76 | * @type function
77 | * @date 30/5/17
78 | * @since 5.6.0
79 | *
80 | * @param n/a
81 | * @return (array)
82 | */
83 |
84 | function rule_values( $choices, $rule ) {
85 |
86 | return array(
87 | 'all' => __('All', 'acf'),
88 | 'edit' => __('Add / Edit', 'acf'),
89 | 'register' => __('Register', 'acf')
90 | );
91 |
92 | /*
93 |
94 | // global
95 | global $wp_roles;
96 |
97 |
98 | // vars
99 | $choices = array( 'all' => __('All', 'acf') );
100 | $choices = array_merge( $choices, $wp_roles->get_names() );
101 |
102 |
103 | // return
104 | return $choices;
105 | */
106 |
107 | }
108 |
109 | }
110 |
111 | // initialize
112 | acf_register_location_rule( 'acf_location_user_form' );
113 |
114 | endif; // class_exists check
115 |
116 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-user-role.php:
--------------------------------------------------------------------------------
1 | name = 'user_role';
27 | $this->label = __("User Role",'acf');
28 | $this->category = 'user';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $user_id = acf_maybe_get( $screen, 'user_id' );
51 | $user_role = acf_maybe_get( $screen, 'user_role' );
52 |
53 |
54 | // if user_role is supplied (3rd party compatibility)
55 | if( $user_role ) {
56 |
57 | // do nothing
58 |
59 | // user_id (expected)
60 | } elseif( $user_id ) {
61 |
62 | // new user
63 | if( $user_id == 'new' ) {
64 |
65 | // set to default role
66 | $user_role = get_option('default_role');
67 |
68 | // existing user
69 | } elseif( user_can($user_id, $rule['value']) ) {
70 |
71 | // set to value and allow match
72 | $user_role = $rule['value'];
73 |
74 | }
75 |
76 | // else
77 | } else {
78 |
79 | // not a user
80 | return false;
81 |
82 | }
83 |
84 |
85 | // match
86 | return $this->compare( $user_role, $rule );
87 |
88 | }
89 |
90 |
91 | /*
92 | * rule_operators
93 | *
94 | * This function returns the available values for this rule type
95 | *
96 | * @type function
97 | * @date 30/5/17
98 | * @since 5.6.0
99 | *
100 | * @param n/a
101 | * @return (array)
102 | */
103 |
104 | function rule_values( $choices, $rule ) {
105 |
106 | // global
107 | global $wp_roles;
108 |
109 |
110 | // vars
111 | $choices = array( 'all' => __('All', 'acf') );
112 | $choices = array_merge( $choices, $wp_roles->get_names() );
113 |
114 |
115 | // return
116 | return $choices;
117 |
118 | }
119 |
120 | }
121 |
122 | // initialize
123 | acf_register_location_rule( 'acf_location_user_role' );
124 |
125 | endif; // class_exists check
126 |
127 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/locations/class-acf-location-widget.php:
--------------------------------------------------------------------------------
1 | name = 'widget';
27 | $this->label = __("Widget",'acf');
28 | $this->category = 'forms';
29 |
30 | }
31 |
32 |
33 | /*
34 | * rule_match
35 | *
36 | * This function is used to match this location $rule to the current $screen
37 | *
38 | * @type function
39 | * @date 3/01/13
40 | * @since 3.5.7
41 | *
42 | * @param $match (boolean)
43 | * @param $rule (array)
44 | * @return $options (array)
45 | */
46 |
47 | function rule_match( $result, $rule, $screen ) {
48 |
49 | // vars
50 | $widget = acf_maybe_get( $screen, 'widget' );
51 |
52 |
53 | // bail early if not widget
54 | if( !$widget ) return false;
55 |
56 |
57 | // return
58 | return $this->compare( $widget, $rule );
59 |
60 | }
61 |
62 |
63 | /*
64 | * rule_operators
65 | *
66 | * This function returns the available values for this rule type
67 | *
68 | * @type function
69 | * @date 30/5/17
70 | * @since 5.6.0
71 | *
72 | * @param n/a
73 | * @return (array)
74 | */
75 |
76 | function rule_values( $choices, $rule ) {
77 |
78 | // global
79 | global $wp_widget_factory;
80 |
81 |
82 | // vars
83 | $choices = array( 'all' => __('All', 'acf') );
84 |
85 |
86 | // loop
87 | if( !empty( $wp_widget_factory->widgets ) ) {
88 |
89 | foreach( $wp_widget_factory->widgets as $widget ) {
90 |
91 | $choices[ $widget->id_base ] = $widget->name;
92 |
93 | }
94 |
95 | }
96 |
97 |
98 | // return
99 | return $choices;
100 |
101 | }
102 |
103 | }
104 |
105 | // initialize
106 | acf_register_location_rule( 'acf_location_widget' );
107 |
108 | endif; // class_exists check
109 |
110 | ?>
--------------------------------------------------------------------------------
/api/wp-content/plugins/advanced-custom-fields-pro/includes/walkers/class-acf-walker-nav-menu-edit.php:
--------------------------------------------------------------------------------
1 |
52 | $search = '