/**
* 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']));
}
