/** * Hook for types_filter_query_field_definitions. * * @param mixed $ignored * @param array $query Field definition query. See Types_Field_Definition_Factory::query() for supported arguments. * Additionally, you can specify: * - 'domain': A single field domain (see Types_Field_Utils) or 'all'. Legacy domain names are also accepted. * For 'all', the method returns a multidimensional arrays with results for individual domains: * - 'refresh': A boolean to refresh the definitions, useful when getting data after saving fields * array( 'posts' => array( ... ), 'users' => array( ... ), ... ). * * @note The 'refresh' parameter is temporal and might dissapear without prior notice when the groups and fields saving gets integrated in the fields definition factory * * @return null|array Field definition arrays, sanitized as per field type, or null if an error has occurred. * @since 2.1 */ public function query_field_definitions($ignored, $query) { $domain = wpcf_getarr($query, 'domain', 'all'); if ('all' == $domain) { // Call itself for each available domain. $results_by_domain = array(); $domains = Types_Field_Utils::get_domains(); foreach ($domains as $field_domain) { $per_domain_query = $query; $per_domain_query['domain'] = $field_domain; $results_by_domain[$field_domain] = $this->query_field_definitions(null, $per_domain_query); } return $results_by_domain; } else { // Sanitize input if (!is_string($domain) || !is_array($query)) { return null; } // Get the factory by domain, and if it fails, try to convert from legacy meta_type value. try { $definition_factory = Types_Field_Utils::get_definition_factory_by_domain($domain); } catch (InvalidArgumentException $e) { $definition_factory = null; } if (null == $definition_factory) { try { $definition_factory = Types_Field_Utils::get_definition_factory_by_domain(Types_Field_Utils::legacy_meta_type_to_domain($domain)); } catch (InvalidArgumentException $e) { return null; } } // Allways query only Types fields. $query['filter'] = 'types'; if (isset($query['refresh']) && $query['refresh']) { $definition_factory->clear_definition_storage(); } /** @var WPCF_Field_Definition[] $definitions */ $definitions = $definition_factory->query_definitions($query); $definition_arrays = array(); foreach ($definitions as $definition) { $definition_arrays[] = $definition->get_definition_array(); } return $definition_arrays; } }
/** * Change cardinality of given field, if it is permitted by its type. * * @param string $field_slug Field definition slug. * @param string $domain Field domain. * @param string[] $arguments Needs to contain the 'target_cardinality' key with 'single'|'repetitive' value. * @return bool|WP_Error|WPCF_Field_Definition The updated definition on succes, error/false otherwise. * @since 2.0 */ public static function change_field_cardinality($field_slug, $domain, $arguments) { $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))); } else { if (!$definition->is_managed_by_types()) { return new WP_Error(42, sprintf(__('Field "%s" will not be converted because it is not managed by Types.', 'wpcf'), sanitize_text_field($field_slug))); } } $target_cardinality = wpcf_getarr($arguments, 'target_cardinality', null, array('single', 'repetitive')); if (null == $target_cardinality) { return false; } $set_as_repetitive = 'repetitive' == $target_cardinality; $result = $definition->set_is_repetitive($set_as_repetitive); if ($result) { return $definition; } else { return false; } }
/** * @param string $domain * @param array $definition_array_import Field definition array (will contain some additional elements from the import file). * * @return array */ private function import_field_definition($domain, $definition_array_import) { $definition = array('id' => $definition_array_import['id'], 'name' => $definition_array_import['name'], 'description' => isset($definition_array_import['description']) ? $definition_array_import['description'] : '', 'type' => $definition_array_import['type'], 'slug' => $definition_array_import['slug'], 'data' => isset($definition_array_import['data']) && is_array($definition_array_import['data']) ? $definition_array_import['data'] : array()); if (isset($definition_array_import['meta_key'])) { $definition['meta_key'] = $definition_array_import['meta_key']; } // WPML global $iclTranslationManagement; if (!empty($iclTranslationManagement) && isset($definition['wpml_action'])) { $iclTranslationManagement->settings['custom_fields_translation'][wpcf_types_get_meta_prefix($definition) . $definition['slug']] = $definition['wpml_action']; $iclTranslationManagement->save_settings(); } $definition_factory = Types_Field_Utils::get_definition_factory_by_domain($domain); $definition_factory->set_field_definition_workaround($definition['slug'], $definition); return array('is_success' => true, 'display_message' => sprintf(__('Term field "%s" added/updated', 'wpcf'), $definition['name'])); }