/** * Query field groups from a single domain. * * @param string $domain One of the valid field domains. Legacy "meta type" values will be also accepted. * @param array $query Query arguments for Types_Field_Group_Factory::query_groups(). * * @return null|Types_Field_Group[] Array of field groups or null on error. * @since m2m */ private function query_specific_domain($domain, $query) { // Make sure we have a valid domain string. $valid_domains = Types_Field_Utils::get_domains(); if (!in_array($domain, $valid_domains)) { $domain = Types_Field_Utils::legacy_meta_type_to_domain($domain); } // Pass the group query to the proper factory class. try { $group_factory = Types_Field_Group_Factory::get_factory_by_domain($domain); $groups = $group_factory->query_groups($query); } catch (Exception $e) { // We don't care, it's a failure. return null; } return $groups; }
/** * 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; } }