/** * Sanitize single checkboxes option definition. * * @param array $option * @return array Sanitized option. * @since 2.1 */ private function sanitize_single_option($option) { $option = $this->sanitize_element_isset(wpcf_ensarr($option), 'value'); $option = $this->sanitize_element_isset($option, 'title', $option['value']); $option = $this->sanitize_element_isset($option, 'display_value', $option['value']); return $option; }
/** * Sanitize single checkboxes option definition. * * @param array $option * @return array Sanitized option. * @since 2.1 */ private function sanitize_single_option($option) { $option = $this->sanitize_element_isset(wpcf_ensarr($option), 'set_value'); $option = $this->sanitize_element_isset($option, 'title', $option['set_value']); $option = $this->sanitize_element_isset($option, 'display', 'db', array('db', 'value')); $option = $this->sanitize_element_isset($option, 'display_value_selected'); $option = $this->sanitize_element_isset($option, 'display_value_not_selected'); return $option; }
/** * Get taxonomies that are associated with this field group. * * @return string[] Taxonomy slugs. Empty array means that this group should be displayed with all taxonomies. */ public function get_associated_taxonomies() { $postmeta = get_post_meta($this->get_id(), self::POSTMETA_ASSOCIATED_TAXONOMY, false); $postmeta = array_filter($postmeta, function ($value) { $value = trim($value); return !empty($value); }); return wpcf_ensarr($postmeta); }
/** * Add the 'number' validation if it was not already there, and activate it. * * @param array $definition_array * @return array * @since 2.0 */ protected function sanitize_numeric_validation($definition_array) { // Get the original setting or a default one. $validation_setting = wpcf_ensarr(wpcf_getnest($definition_array, array('data', 'validate', 'number')), array('active' => true, 'message' => __('Please enter numeric data', 'wpcf'))); // Force the activation of this validation. $validation_setting['active'] = true; // Store the setting. $definition_array['data']['validate']['number'] = $validation_setting; return $definition_array; }
/** * @param Types_Field_Type_Definition $type * @return Types_Field_Type_Definition[] */ public function get_possible_conversions($type) { if (!$type instanceof Types_Field_Type_Definition) { throw new InvalidArgumentException('Not a field type definition'); } $matrix = $this->get_conversion_matrix(); $allowed_slugs = wpcf_ensarr(wpcf_getarr($matrix, $type->get_slug())); $allowed_types = Types_Field_Type_Definition_Factory::get_instance()->load_multiple_definitions($allowed_slugs); return $allowed_types; }
/** * Get taxonomies that are associated with this field group. * * @return string[] Taxonomy slugs. Empty array means that this group should be displayed with all taxonomies. */ public function get_associated_taxonomies() { $postmeta = get_post_meta($this->get_id(), self::POSTMETA_ASSOCIATED_TAXONOMY, false); // Survive empty or whitespace taxonomy slugs (skip them). They are invalid values but // if we have only them, we need to return an empty array to keep the group displayed everywhere. foreach ($postmeta as $index => $taxonomy_slug) { $taxonomy_slug = trim($taxonomy_slug); if (empty($taxonomy_slug)) { unset($postmeta[$index]); } } return wpcf_ensarr($postmeta); }
/** * Read the field values from $_POST. * * @return array Values in the "intermediate" format (see WPCF_Field_DataMapper_Abstract). For non-repetitive values, * it will be an array with a single item. */ private function read_field_values() { if (null == $this->field_values) { $definition = $this->field->get_definition(); $form_data = wpcf_ensarr(wpcf_getpost('wpcf')); $values = wpcf_getarr($form_data, $definition->get_slug()); // Handle single fields. if (!$definition->get_is_repetitive()) { $values = array($values); } // Map POST values to intermediate format. $this->field_values = array(); $data_mapper = $definition->get_data_mapper(); foreach ($values as $value) { $this->field_values[] = $data_mapper->post_to_intermediate($value, $form_data); } } return wpcf_ensarr($this->field_values); }
/** * Retrieve an array of option definitions. * * Allowed only for the checkboxes, radio and select field types. * * @throws RuntimeException when the field type is invalid * @throws InvalidArgumentException when option definitions are corrupted * @return WPCF_Field_Option_Checkboxes[] An option_id => option_data array. * @since 1.9 */ public function get_field_options() { $this->check_allowed_types(array(Types_Field_Type_Definition_Factory::CHECKBOXES, Types_Field_Type_Definition_Factory::RADIO, Types_Field_Type_Definition_Factory::SELECT)); $options_definition = wpcf_ensarr(wpcf_getnest($this->definition_array, array('data', 'options'))); $results = array(); // The 'default' key can be present, we have to remove it so it's not handled as another option. $has_default = array_key_exists('default', $options_definition); $default = wpcf_getarr($options_definition, 'default', 'no-default'); if ($has_default) { unset($options_definition['default']); } foreach ($options_definition as $option_id => $option_config) { try { switch ($this->get_type()->get_slug()) { case Types_Field_Type_Definition_Factory::RADIO: $option = new WPCF_Field_Option_Radio($option_id, $option_config, $default, $this); break; case Types_Field_Type_Definition_Factory::SELECT: $option = new WPCF_Field_Option_Select($option_id, $option_config, $default, $this); break; case Types_Field_Type_Definition_Factory::CHECKBOXES: $option = new WPCF_Field_Option_Checkboxes($option_id, $option_config, $default); break; default: throw new InvalidArgumentException('Invalid field type'); } $results[$option_id] = $option; } catch (Exception $e) { // Corrupted data, can't do anything but skip the option. } } return $results; }
/** * Filter the data to be exported for custom taxonomies. * * Ensure the settings of post types associated with the taxonomy is exported correctly, even with support of legacy * settings. * * @param array $taxonomy_data * @return array Modified taxonomy data. * @since unknown */ function wpcf_fix_exported_taxonomy_assignment_to_cpt($taxonomy_data = array()) { $setting_name_prefix = '__types_cpt_supports_'; $post_type_support_settings = array(); // Associated CPTs slugs are stored as XML keys, so they can not start with a number. // We force a prefix on all of them on export, and restore them on import. $supported_post_types = wpcf_ensarr(wpcf_getarr($taxonomy_data, 'supports')); foreach ($supported_post_types as $post_type_slug => $is_supported) { $setting_name = $setting_name_prefix . $post_type_slug; $post_type_support_settings[$setting_name] = $is_supported ? 1 : 0; } // Here, we will also process the legacy "object_type" setting, containing supported post type slugs as array items, // in the samve way. $legacy_supported_post_type_array = wpcf_ensarr(wpcf_getarr($taxonomy_data, 'object_type')); foreach ($legacy_supported_post_type_array as $post_type_slug) { $setting_name = $setting_name_prefix . $post_type_slug; $post_type_support_settings[$setting_name] = 1; } // Now we need to remove this legacy setting to prevent producing invalid XML. unset($taxonomy_data['object_type']); $taxonomy_data['supports'] = $post_type_support_settings; return $taxonomy_data; }
/** * Change which groups is a field definition associated with. * * AJAX callback helper only, do not use elsewhere. * * @param string $field_slug Field definition slug. * @param string $domain Field domain * @param string[][] $groups Action-specific data passed through AJAX. Array containing a single key 'group_slugs', * containing an array of field group slugs. * * @return WP_Error|WPCF_Field_Definition The updated field definition on success or an error object. * @since 2.0 */ public static function change_assignment_to_groups($field_slug, $domain, $groups) { $factory = Types_Field_Utils::get_definition_factory_by_domain($domain); $definition = $factory->load_field_definition($field_slug); if (null == $definition) { return new WP_Error(42, sprintf(__('Field definition for field "%s" not found in options.', 'wpcf'), sanitize_text_field($field_slug))); } $new_groups = wpcf_ensarr(wpcf_getarr($groups, 'group_slugs')); $associated_groups = $definition->get_associated_groups(); $is_success = true; foreach ($associated_groups as $group) { if (!in_array($group->get_slug(), $new_groups)) { $is_success = $is_success && $group->remove_field_definition($definition); } } $group_factory = $factory->get_group_factory(); foreach ($new_groups as $new_group_slug) { $new_group = $group_factory->load_field_group($new_group_slug); if (null != $new_group) { $is_success = $is_success && $new_group->add_field_definition($definition); } else { $is_success = false; } } if ($is_success) { return $definition; } else { return new WP_Error(); } }
/** * Get field type definitions from an array of slugs. * * If a definition cannot be loaded for a given slug, the slug is skipped without reporting an error in any other way. * * @param string[] $field_type_slugs * @return Types_Field_Type_Definition[] * @since 2.0 */ public function load_multiple_definitions($field_type_slugs) { $results = array(); $field_type_slugs = wpcf_ensarr($field_type_slugs); foreach ($field_type_slugs as $field_type_slug) { $type_definition = $this->load_field_type_definition($field_type_slug); if (null != $type_definition) { $results[$field_type_slug] = $type_definition; } } return $results; }
/** * Get taxonomies that are associated with this field group. * * @return string[] Taxonomy slugs. Empty array means that this group should be displayed with all taxonomies. */ public function get_associated_taxonomies() { $postmeta = get_post_meta($this->get_id(), self::POSTMETA_ASSOCIATED_TAXONOMY, false); return wpcf_ensarr($postmeta); }
/** * Make sure that the field definition array contains all necessary information. * * Note: This is a WIP, currently it sanitizes only very specific cases. It should be extended in the future. * * @link https://git.onthegosystems.com/toolset/types/wikis/database-layer/field-definition-arrays * @param array $definition_array Field definition array * @return array Field definition array that is safe to be used even with legacy code. * @since 2.0 */ public final function sanitize_field_definition_array($definition_array) { /** * types_pre_sanitize_field_definition_array * * Allow for additional field definition array sanitization before the standard one runs. * * @param mixed $definition_array * @return array * @since 2.1 */ $definition_array = wpcf_ensarr(apply_filters('types_pre_sanitize_field_definition_array', $definition_array)); $definition_array = $this->sanitize_field_definition_array_generic($definition_array); $definition_array = $this->sanitize_numeric_validation($definition_array); $definition_array = $this->sanitize_field_definition_array_type_specific($definition_array); /** * types_post_sanitize_field_definition_array * * Allow for additional field definition array sanitization after the standard one runs. * * @param array $definition_array * @return array * @since 2.1 */ $definition_array = wpcf_ensarr(apply_filters('types_post_sanitize_field_definition_array', $definition_array)); return $definition_array; }
/** * Make sure that the field definition array contains all necessary information. * * Note: This is a WIP, currently it sanitizes only very specific cases. It should be extended in the future. * * Expected definition array structure common to all fields: * * - slug: string * - data: array * - validate: array * * @param array $definition_array Field definition array * @return array Field definition array that is safe to be used even with legacy code. * @since 2.0 */ public function sanitize_field_definition_array($definition_array) { $definition_array['data'] = wpcf_ensarr(wpcf_getarr($definition_array, 'data')); $definition_array['data']['validate'] = wpcf_ensarr(wpcf_getarr($definition_array['data'], 'validate')); $definition_array = $this->sanitize_numeric_validation($definition_array); return $definition_array; }
/** * @return array An option_id => option_data array. */ public function get_field_options() { return wpcf_ensarr(wpcf_getnest($this->definition_array, array('data', 'options'))); }
private function ajax_filter_default_value($value, $currently_supported = array(), $type = false) { if ($type && isset($_REQUEST['all_fields']) && is_array($_REQUEST['all_fields'])) { switch ($type) { case 'taxonomies-for-termmeta': $selected_taxonomies = wpcf_ensarr(wpcf_getnest($_REQUEST, array('all_fields', 'wpcf', 'group', 'taxonomies'))); if (in_array($value, array_keys($selected_taxonomies)) && true == $selected_taxonomies[$value]) { return true; } break; } // not selected return false; } if (isset($_REQUEST['current'])) { if (is_array($_REQUEST['current']) && in_array($value, $_REQUEST['current'])) { return true; } } else { if ($currently_supported && !empty($currently_supported) && in_array($value, $currently_supported)) { return true; } } return false; }
/** * Imports data from XML. * * @param string $data * @param bool $redirect * @param string $context * @param array $args * * @return array */ function wpcf_admin_import_data($data = '', $redirect = true, $context = 'types', $args = array()) { global $wpdb; $data_installer = false; $return = array(); libxml_use_internal_errors(true); $data = simplexml_load_string($data); if (!$data) { $return[] = array('type' => 'error', 'content' => __('Error parsing XML: ', 'wpcf') . $error->message); libxml_clear_errors(); return $return; } $overwrite_settings = isset($_POST['overwrite-settings']); $overwrite_groups = isset($_POST['overwrite-groups']); $overwrite_fields = isset($_POST['overwrite-fields']); $overwrite_types = isset($_POST['overwrite-types']); $overwrite_tax = isset($_POST['overwrite-tax']); $delete_groups = isset($_POST['delete-groups']); $delete_fields = isset($_POST['delete-fields']); $delete_types = isset($_POST['delete-types']); $delete_tax = isset($_POST['delete-tax']); if ('wpvdemo' == $context && !empty($args)) { /** * allow overwrite */ $overwrite_groups = true; $overwrite_fields = true; $overwrite_types = true; $overwrite_tax = true; include_once dirname(__FILE__) . '/classes/class.types.data.installer.php'; $data_installer = new Types_Data_Installer($data, $args); $data = $data_installer->wpvdemo(); } /** * process settings */ if ($overwrite_settings && isset($data->settings)) { $wpcf_settings = wpcf_get_settings(); foreach (wpcf_admin_import_export_simplexml2array($data->settings) as $key => $value) { $wpcf_settings[$key] = $value; } wpcf_save_settings($wpcf_settings); $return[] = array('type' => 'success', 'content' => __('Settings are updated.', 'wpcf')); } // Process groups $groups_check = array(); if (!empty($data->groups)) { $groups = array(); // Set insert data from XML foreach ($data->groups->group as $group) { $group = wpcf_admin_import_export_simplexml2array($group); $groups[$group['ID']] = $group; } // Set insert data from POST if (!empty($_POST['groups'])) { foreach ($_POST['groups'] as $group_id => $group) { if (empty($groups[$group_id])) { continue; } $groups[$group_id]['add'] = !empty($group['add']); $groups[$group_id]['update'] = isset($group['update']) && $group['update'] == 'update' ? true : false; } } else { foreach ($groups as $group_id => $group) { $groups[$group_id]['add'] = true; $groups[$group_id]['update'] = false; } } // Insert groups $show_import_fail_version_message = true; foreach ($groups as $group_id => $group) { $post = array('post_status' => $group['post_status'], 'post_type' => TYPES_CUSTOM_FIELD_GROUP_CPT_NAME, 'post_title' => $group['post_title'], 'post_content' => !empty($group['post_content']) ? $group['post_content'] : ''); /** * preserve slug */ if (array_key_exists('__types_id', $group)) { $post['post_name'] = $group['__types_id']; } if (isset($group['add']) && $group['add']) { $post_to_update = $wpdb->get_var($wpdb->prepare("SELECT ID FROM {$wpdb->posts} WHERE post_title = %s AND post_type = %s", $group['post_title'], TYPES_CUSTOM_FIELD_GROUP_CPT_NAME)); // Update (may be forced by bulk action) if ($group['update'] || $overwrite_groups && !empty($post_to_update)) { if (!empty($post_to_update)) { $post['ID'] = $post_to_update; $group_wp_id = wp_update_post($post); if (!$group_wp_id) { $return[] = array('type' => 'error', 'content' => sprintf(__('Group "%s" update failed', 'wpcf'), $group['post_title'])); } else { $return[] = array('type' => 'success', 'content' => sprintf(__('Group "%s" updated', 'wpcf'), $group['post_title'])); } } else { $return[] = array('type' => 'error', 'content' => sprintf(__('Group "%s" update failed', 'wpcf'), $group['post_title'])); } } else { // Insert $group_wp_id = wp_insert_post($post, true); if (is_wp_error($group_wp_id)) { $return[] = array('type' => 'error', 'content' => sprintf(__('Group "%s" insert failed', 'wpcf'), $group['post_title'])); } else { $return[] = array('type' => 'success', 'content' => sprintf(__('Group "%s" added', 'wpcf'), $group['post_title'])); } } // Update meta if (!empty($group['meta'])) { foreach ($group['meta'] as $meta_key => $meta_value) { if ('_wpcf_conditional_display' == $meta_key) { if (!empty($meta_value)) { $meta_value = wpcf_admin_import_export_simplexml2array($meta_value); if (!is_array($meta_value)) { $meta_value = array(); if ($show_import_fail_version_message) { $show_import_fail_version_message = false; $return[] = array('type' => 'error', 'content' => __('The Types settings were not fully imported because it contained unsecured data. You should re-export your Types settings using the latest version of Types', 'wpcf')); } } } } update_post_meta($group_wp_id, $meta_key, $meta_value); } } $groups_check[] = $group_wp_id; if (!empty($post_to_update)) { $groups_check[] = $post_to_update; } } } // Delete groups (forced, set in bulk actions) } if ($delete_groups) { $groups_to_delete = get_posts(array('post_type' => TYPES_CUSTOM_FIELD_GROUP_CPT_NAME, 'post_status' => 'any', 'posts_per_page' => -1)); if (!empty($groups_to_delete)) { foreach ($groups_to_delete as $group_to_delete) { if (!in_array($group_to_delete->ID, $groups_check)) { $deleted = wp_delete_post($group_to_delete->ID, true); if (!$deleted) { $return[] = array('type' => 'error', 'content' => sprintf(__('Group "%s" delete failed', 'wpcf'), $group_to_delete->post_title)); } else { $return[] = array('type' => 'success', 'content' => sprintf(__('Group "%s" deleted', 'wpcf'), $group_to_delete->post_title)); } } } } } else { // If not forced, look in POST if (!empty($_POST['groups-to-be-deleted'])) { foreach ($_POST['groups-to-be-deleted'] as $group_to_delete) { $group_to_delete_post = get_post($group_to_delete); if (!empty($group_to_delete_post) && $group_to_delete_post->post_type == TYPES_CUSTOM_FIELD_GROUP_CPT_NAME) { $deleted = wp_delete_post($group_to_delete, true); if (!$deleted) { $return[] = array('type' => 'error', 'content' => sprintf(__('Group "%s" delete failed', 'wpcf'), $group_to_delete_post->post_title)); } else { $return[] = array('type' => 'success', 'content' => sprintf(__('Group "%s" deleted', 'wpcf'), $group_to_delete_post->post_title)); } } else { $return[] = array('type' => 'error', 'content' => sprintf(__('Group "%s" delete failed', 'wpcf'), $group_to_delete)); } } } } // Process fields $fields_check = array(); $fields_existing = wpcf_admin_fields_get_fields(); if (!empty($data->fields)) { $fields = array(); // Set insert data from XML foreach ($data->fields->field as $field) { $field = wpcf_admin_import_export_simplexml2array($field); // Set if submitted in 'types' context if ($context == 'types') { // Process only if marked if (isset($_POST['fields'][$field['id']])) { $fields[$field['id']] = $field; } } else { $fields[$field['id']] = $field; } } // Set insert data from POST if (!empty($_POST['fields'])) { foreach ($_POST['fields'] as $field_id => $field) { if (empty($fields[$field_id])) { continue; } $fields[$field_id]['add'] = !empty($field['add']); $fields[$field_id]['update'] = isset($field['update']) && $field['update'] == 'update' ? true : false; } } // Insert fields foreach ($fields as $field_id => $field) { if (isset($field['add']) && !$field['add'] && !$overwrite_fields) { continue; } if (empty($field['id']) || empty($field['name']) || empty($field['slug'])) { continue; } $field_data = array(); $field_data['description'] = isset($field['description']) ? $field['description'] : ''; $field_data['data'] = isset($field['data']) && is_array($field['data']) ? $field['data'] : array(); foreach (array('id', 'name', 'type', 'slug', 'meta_key', 'meta_type') as $key) { if (array_key_exists($key, $field)) { $field_data[$key] = $field[$key]; } } $fields_existing[$field_id] = $field_data; $fields_check[] = $field_id; // WPML global $iclTranslationManagement; if (!empty($iclTranslationManagement) && isset($field['wpml_action'])) { $iclTranslationManagement->settings['custom_fields_translation'][wpcf_types_get_meta_prefix($field) . $field_id] = $field['wpml_action']; $iclTranslationManagement->save_settings(); } $return[] = array('type' => 'success', 'content' => sprintf(__('Field "%s" added/updated', 'wpcf'), $field['name'])); } } // Delete fields if ($delete_fields) { foreach ($fields_existing as $k => $v) { if (!empty($v['data']['controlled'])) { continue; } if (!in_array($k, $fields_check)) { $return[] = array('type' => 'success', 'content' => sprintf(__('Field "%s" deleted', 'wpcf'), $fields_existing[$k]['name'])); unset($fields_existing[$k]); } } } else { if (!empty($_POST['fields-to-be-deleted'])) { foreach ($_POST['fields-to-be-deleted'] as $field_to_delete) { $return[] = array('type' => 'success', 'content' => sprintf(__('Field "%s" deleted', 'wpcf'), $fields_existing[$field_to_delete]['name'])); unset($fields_existing[$field_to_delete]); } } } update_option('wpcf-fields', $fields_existing); // Process user groups //print_r($data->user_groups);exit; $groups_check = array(); if (!empty($data->user_groups) && isset($data->user_groups->group)) { $groups = array(); // Set insert data from XML foreach ($data->user_groups->group as $group) { $group = wpcf_admin_import_export_simplexml2array($group); $groups[$group['ID']] = $group; } // Set insert data from POST if (!empty($_POST['user_groups'])) { foreach ($_POST['user_groups'] as $group_id => $group) { if (empty($groups[$group_id])) { continue; } $groups[$group_id]['add'] = !empty($group['add']); $groups[$group_id]['update'] = isset($group['update']) && $group['update'] == 'update' ? true : false; } } else { foreach ($groups as $group_id => $group) { $groups[$group_id]['add'] = true; $groups[$group_id]['update'] = false; } } // Insert groups foreach ($groups as $group_id => $group) { $post = array('post_status' => $group['post_status'], 'post_type' => TYPES_USER_META_FIELD_GROUP_CPT_NAME, 'post_title' => $group['post_title'], 'post_content' => !empty($group['post_content']) ? $group['post_content'] : ''); if (isset($group['add']) && $group['add']) { $post_to_update = $wpdb->get_var($wpdb->prepare("SELECT ID FROM {$wpdb->posts} WHERE post_title = %s AND post_type = %s", $group['post_title'], TYPES_USER_META_FIELD_GROUP_CPT_NAME)); // Update (may be forced by bulk action) if ($group['update'] || $overwrite_groups && !empty($post_to_update)) { if (!empty($post_to_update)) { $post['ID'] = $post_to_update; $group_wp_id = wp_update_post($post); if (!$group_wp_id) { $return[] = array('type' => 'error', 'content' => sprintf(__('User group "%s" update failed', 'wpcf'), $group['post_title'])); } else { /* wpcf_admin_message_store( sprintf( __( 'User group "%s" updated', 'wpcf' ), $group['post_title'] ) ); */ $return[] = array('type' => 'success', 'content' => sprintf(__('User group "%s" updated', 'wpcf'), $group['post_title'])); } } else { $return[] = array('type' => 'error', 'content' => sprintf(__('User group "%s" update failed', 'wpcf'), $group['post_title'])); } } else { // Insert $group_wp_id = wp_insert_post($post, true); if (is_wp_error($group_wp_id)) { $return[] = array('type' => 'error', 'content' => sprintf(__('User group "%s" insert failed', 'wpcf'), $group['post_title'])); } else { $return[] = array('type' => 'success', 'content' => sprintf(__('User group "%s" added', 'wpcf'), $group['post_title'])); } } // Update meta if (!empty($group['meta'])) { foreach ($group['meta'] as $meta_key => $meta_value) { update_post_meta($group_wp_id, $meta_key, wpcf_admin_import_export_simplexml2array($meta_value)); } } $groups_check[] = $group_wp_id; if (!empty($post_to_update)) { $groups_check[] = $post_to_update; } } } } // Delete groups (forced, set in bulk actions) if ($delete_groups) { $groups_to_delete = get_posts(array('post_type' => TYPES_USER_META_FIELD_GROUP_CPT_NAME, 'post_status' => 'any', 'posts_per_page' => -1)); if (!empty($groups_to_delete)) { foreach ($groups_to_delete as $group_to_delete) { if (!in_array($group_to_delete->ID, $groups_check)) { $deleted = wp_delete_post($group_to_delete->ID, true); if (!$deleted) { $return[] = array('type' => 'error', 'content' => sprintf(__('User group "%s" delete failed', 'wpcf'), $group_to_delete->post_title)); } else { $return[] = array('type' => 'success', 'content' => sprintf(__('User group "%s" deleted', 'wpcf'), $group_to_delete->post_title)); } } } } } else { // If not forced, look in POST if (!empty($_POST['user-groups-to-be-deleted'])) { foreach ($_POST['user-groups-to-be-deleted'] as $group_to_delete) { $group_to_delete_post = get_post($group_to_delete); if (!empty($group_to_delete_post) && $group_to_delete_post->post_type == TYPES_USER_META_FIELD_GROUP_CPT_NAME) { $deleted = wp_delete_post($group_to_delete, true); if (!$deleted) { $return[] = array('type' => 'error', 'content' => sprintf(__('User group "%s" delete failed', 'wpcf'), $group_to_delete_post->post_title)); } else { $return[] = array('type' => 'success', 'content' => sprintf(__('User group "%s" deleted', 'wpcf'), $group_to_delete_post->post_title)); } } else { $return[] = array('type' => 'error', 'content' => sprintf(__('User group "%s" delete failed', 'wpcf'), $group_to_delete)); } } } } // Process fields $fields_existing = wpcf_admin_fields_get_fields(false, false, false, 'wpcf-usermeta'); $fields_check = array(); if (!empty($data->user_fields)) { $fields = array(); // Set insert data from XML foreach ($data->user_fields->field as $field) { $field = wpcf_admin_import_export_simplexml2array($field); // Set if submitted in 'types' context if ($context == 'types') { // Process only if marked if (isset($_POST['user_fields'][$field['id']])) { $fields[$field['id']] = $field; } } else { $fields[$field['id']] = $field; } } // Set insert data from POST if (!empty($_POST['user_fields'])) { foreach ($_POST['user_fields'] as $field_id => $field) { if (empty($fields[$field_id])) { continue; } $fields[$field_id]['add'] = !empty($field['add']); $fields[$field_id]['update'] = isset($field['update']) && $field['update'] == 'update' ? true : false; } } // Insert fields foreach ($fields as $field_id => $field) { if (isset($field['add']) && !$field['add'] && !$overwrite_fields) { continue; } if (empty($field['id']) || empty($field['name']) || empty($field['slug'])) { continue; } $field_data = array(); $field_data['id'] = $field['id']; $field_data['name'] = $field['name']; $field_data['description'] = isset($field['description']) ? $field['description'] : ''; $field_data['type'] = $field['type']; $field_data['slug'] = $field['slug']; if (isset($field['meta_key'])) { $field_data['meta_key'] = $field['meta_key']; } $field_data['data'] = isset($field['data']) && is_array($field['data']) ? $field['data'] : array(); $fields_existing[$field_id] = $field_data; $fields_check[] = $field_id; // WPML global $iclTranslationManagement; if (!empty($iclTranslationManagement) && isset($field['wpml_action'])) { $iclTranslationManagement->settings['custom_fields_translation'][wpcf_types_get_meta_prefix($field) . $field_id] = $field['wpml_action']; $iclTranslationManagement->save_settings(); } $return[] = array('type' => 'success', 'content' => sprintf(__('User field "%s" added/updated', 'wpcf'), $field['name'])); } } // Delete fields if ($delete_fields) { foreach ($fields_existing as $k => $v) { if (!empty($v['data']['controlled'])) { continue; } if (!in_array($k, $fields_check)) { $return[] = array('type' => 'success', 'content' => sprintf(__('User field "%s" deleted', 'wpcf'), $fields_existing[$k]['name'])); unset($fields_existing[$k]); } } } else { if (!empty($_POST['user-fields-to-be-deleted'])) { foreach ($_POST['user-fields-to-be-deleted'] as $field_to_delete) { $return[] = array('type' => 'success', 'content' => sprintf(__('User field "%s" deleted', 'wpcf'), $fields_existing[$field_to_delete]['name'])); unset($fields_existing[$field_to_delete]); } } } update_option('wpcf-usermeta', $fields_existing); // Handle term field groups and field definitions outside of this mess. $ie_controller = Types_Import_Export::get_instance(); $term_group_results = $ie_controller->process_field_group_import_per_domain(Types_Field_Utils::DOMAIN_TERMS, $data, 'term_groups', $overwrite_groups, $delete_groups, wpcf_ensarr(wpcf_getpost('term_groups'))); $term_field_results = $ie_controller->process_field_definition_import_per_domain(Types_Field_Utils::DOMAIN_TERMS, $data, 'term_fields', $delete_fields, wpcf_ensarr(wpcf_getpost('term_fields'))); $return = array_merge($return, $term_group_results, $term_field_results); // Process types $types_existing = get_option(WPCF_OPTION_NAME_CUSTOM_TYPES, array()); $types_check = array(); if (!empty($data->types) && isset($data->types->type)) { $types = array(); // Set insert data from XML foreach ($data->types->type as $type) { $type = wpcf_admin_import_export_simplexml2array($type); // Set if submitted in 'types' context if ($context == 'types') { if (isset($_POST['types'][$type['id']])) { $types[$type['id']] = $type; } } else { $types[$type['id']] = $type; } } // Set insert data from POST if (!empty($_POST['types'])) { foreach ($_POST['types'] as $type_id => $type) { if (empty($types[$type_id])) { continue; } $types[$type_id]['add'] = !empty($type['add']); $types[$type_id]['update'] = isset($type['update']) && $type['update'] == 'update' ? true : false; } } // Insert types foreach ($types as $type_id => $type) { if (isset($type['add']) && !$type['add'] && !$overwrite_types) { continue; } unset($type['add'], $type['update']); $types_existing[$type_id] = $type; $types_check[] = $type_id; $return[] = array('type' => 'success', 'content' => sprintf(__('Post Type "%s" added/updated', 'wpcf'), $type_id)); } } // Delete types if ($delete_types) { foreach ($types_existing as $k => $v) { if (!in_array($k, $types_check)) { unset($types_existing[$k]); $return[] = array('type' => 'success', 'content' => sprintf(__('Post Type "%s" deleted', 'wpcf'), esc_html($k))); } } } else { if (!empty($_POST['types-to-be-deleted'])) { foreach ($_POST['types-to-be-deleted'] as $type_to_delete) { $return[] = array('type' => 'success', 'content' => sprintf(__('Post Type "%s" deleted', 'wpcf'), $types_existing[$type_to_delete]['labels']['name'])); unset($types_existing[$type_to_delete]); } } } update_option(WPCF_OPTION_NAME_CUSTOM_TYPES, $types_existing); // Process taxonomies $taxonomies_existing = get_option(WPCF_OPTION_NAME_CUSTOM_TAXONOMIES, array()); $taxonomies_check = array(); if (!empty($data->taxonomies) && isset($data->taxonomies->taxonomy)) { $taxonomies = array(); // Set insert data from XML foreach ($data->taxonomies->taxonomy as $taxonomy) { $taxonomy = wpcf_admin_import_export_simplexml2array($taxonomy); $taxonomy = apply_filters('wpcf_filter_import_custom_taxonomy', $taxonomy); // Set if submitted in 'types' context if ($context == 'types') { if (isset($_POST['taxonomies'][$taxonomy['id']])) { $taxonomies[$taxonomy['id']] = $taxonomy; } } else { $taxonomies[$taxonomy['id']] = $taxonomy; } } // Set insert data from POST if (!empty($_POST['taxonomies'])) { foreach ($_POST['taxonomies'] as $taxonomy_id => $taxonomy) { if (empty($taxonomies[$taxonomy_id])) { continue; } $taxonomies[$taxonomy_id]['add'] = !empty($taxonomy['add']); $taxonomies[$taxonomy_id]['update'] = isset($taxonomy['update']) && $taxonomy['update'] == 'update' ? true : false; } } // Insert taxonomies foreach ($taxonomies as $taxonomy_id => $taxonomy) { if (isset($taxonomy['add']) && !$taxonomy['add'] && !$overwrite_tax) { continue; } unset($taxonomy['add'], $taxonomy['update']); $taxonomies_existing[$taxonomy_id] = $taxonomy; $taxonomies_check[] = $taxonomy_id; $return[] = array('type' => 'success', 'content' => sprintf(__('Taxonomy "%s" added/updated', 'wpcf'), $taxonomy_id)); } } /** * reset TOOLSET_EDIT_LAST */ if ($data_installer) { $data_installer->reset_toolset_edit_last(); } // Delete taxonomies if ($delete_tax) { foreach ($taxonomies_existing as $k => $v) { if (!in_array($k, $taxonomies_check)) { unset($taxonomies_existing[$k]); $return[] = array('type' => 'success', 'content' => sprintf(__('Taxonomy "%s" deleted', 'wpcf'), $k)); } } } else { if (!empty($_POST['taxonomies-to-be-deleted'])) { foreach ($_POST['taxonomies-to-be-deleted'] as $taxonomy_to_delete) { $return[] = array('type' => 'success', 'content' => sprintf(__('Taxonomy "%s" deleted', 'wpcf'), $taxonomies_existing[$taxonomy_to_delete]['labels']['name'])); unset($taxonomies_existing[$taxonomy_to_delete]); } } } update_option(WPCF_OPTION_NAME_CUSTOM_TAXONOMIES, $taxonomies_existing); // Add relationships if (!empty($data->post_relationships) && !empty($_POST['post_relationship'])) { $relationship_existing = get_option('wpcf_post_relationship', array()); /** * be sure, $relationship_existing is a array! */ if (!is_array($relationship_existing)) { $relationship_existing = array(); } $relationship = json_decode($data->post_relationships->data, true); if (is_array($relationship)) { $relationship = array_merge($relationship_existing, $relationship); update_option('wpcf_post_relationship', $relationship); $return[] = array('type' => 'success', 'content' => __('Post relationships created', 'wpcf')); } else { $return[] = array('type' => 'error', 'content' => __('Post relationships settings were not imported because it contained unsecured data. You should re-export your Types settings using the latest version of Types', 'wpcf')); } } // WPML bulk registration if (wpcf_get_settings('register_translations_on_import')) { wpcf_admin_bulk_string_translation(); } // Flush rewrite rules wpcf_init_custom_types_taxonomies(); flush_rewrite_rules(); if ($redirect) { echo '<script type="text/javascript"> <!-- window.location = "' . admin_url('admin.php?page=toolset-export-import&tab=types') . '" //--> </script>'; die; } else { return $return; } }
/** * Get array of groups that are associated with given taxonomy. * * @param string $taxonomy_slug Slug of the taxonomy * @return WPCF_Field_Group_Term[] Associated term field groups. */ public function get_groups_by_taxonomy($taxonomy_slug) { $groups_by_taxonomies = $this->get_groups_by_taxonomies(); return wpcf_ensarr(wpcf_getarr($groups_by_taxonomies, $taxonomy_slug)); }
/** * For repetitive field, get the order of individual values. * * @return array Meta IDs in the order defining the field value order. */ protected function get_sort_order() { $accessor = $this->get_order_accessor(); return wpcf_ensarr($accessor->get_raw_value()); }
/** * WPCF_Field_Renderer_Preview_Base constructor. * * @param WPCF_Field_Instance_Abstract $field * @param array $args Preview renderer settings: * - maximum_item_count => Maximum count of field values that should be displayed. * - maximum_item_length => Maximum length of single item. * - maximum_total_length => Maximum length of output. * - value_separator => Separator to be used between multiple field values. * - ellipsis => Ellipsis to be added when some field values are omitted. * * Specialized renderers may interpret the settings in a different way or add their own. * * @since 1.9.1 */ public function __construct($field, $args = array()) { parent::__construct($field); $this->args = wpcf_ensarr($args); }
/** * Modify field validation rules. * * Hooked into toolset_filter_field_definition_array. Not to be used elsewhere. * * Add mandatory validation rules that have not been stored in the database but are needed by Types and toolset-forms * to work properly. Namely it's the URL validation for file fields. On the contrary CRED needs these validation rules * removed. * * @param array $field_definition A field definition array. * @return array * @since 2.2.4 */ function wpcf_update_mandatory_validation_rules($field_definition, $ignored) { // Add URL validation to file fields (containing URLs). // // This doesn't include embed files because they are more variable and the URL validation can be // configured on the Edit Field Group page. $file_fields = array('file', 'image', 'audio', 'video'); $field_type = toolset_getarr($field_definition, 'type'); $is_file_field = in_array($field_type, $file_fields); $validation_rules = wpcf_ensarr(wpcf_getnest($field_definition, array('data', 'validate'))); $has_url2_validation = array_key_exists('url2', $validation_rules); if ($is_file_field) { unset($validation_rules['url']); if (!$has_url2_validation) { $default_validation_error_message = __('Please enter a valid URL address pointing to the file.', 'wpcf'); $validation_error_messages = array('file' => $default_validation_error_message, 'audio' => __('Please enter a valid URL address pointing to the audio file.', 'wpcf'), 'image' => __('Please enter a valid URL address pointing to the image file.', 'wpcf'), 'video' => __('Please enter a valid URL address pointing to the video file.', 'wpcf')); // The url2 validation doesn't require the TLD part of the URL. $validation_rules['url2'] = array('active' => '1', 'message' => toolset_getarr($validation_error_messages, $field_type, $default_validation_error_message), 'suppress_for_cred' => true); } $field_definition['data']['validate'] = $validation_rules; } // On the contrary, CRED file fileds MUST NOT use this validation otherwise it won't be possible to // submit not changed fields on the edit form. Thus we're making sure that no such rule goes through. // // These field types come via WPToolset_Types::filterValidation(). $cred_file_fields = array('credfile', 'credimage', 'credaudio', 'credvideo'); $is_cred_field = in_array($field_type, $cred_file_fields); if ($is_cred_field) { unset($validation_rules['url']); unset($validation_rules['url2']); $field_definition['data']['validate'] = $validation_rules; } return $field_definition; }