/** * {@inheritdoc} */ public function preprocess($value) { // Text field. Check if field has an input format. $field_info = field_info_field($this->getProperty()); // If there was no bundle that had the field instance, then return NULL. if (!($instance = field_info_instance($this->getEntityType(), $this->getProperty(), $this->getBundle()))) { return NULL; } $return = NULL; if ($field_info['cardinality'] == 1) { // Single value. if (!$instance['settings']['text_processing']) { return $value; } return array('value' => $value, 'format' => 'filtered_html'); } // Multiple values. foreach ($value as $delta => $single_value) { if (!$instance['settings']['text_processing']) { $return[$delta] = $single_value; } else { $return[$delta] = array('value' => $single_value, 'format' => 'filtered_html'); } } return $return; }
/** * Provides a method to update date fields that use a time increment value. * * @param int $time_increment * The new time increment value. */ function hook_studyroom_time_increment_update($time_increment) { foreach (studyroom_reservation_types() as $bundle) { $instance = field_info_instance('studyroom_reservation', 'field_reservation_datetime', $bundle->type); $instance['widget']['settings']['increment'] = $time_increment; field_update_instance($instance); } }
function bunsen_form_alter(&$form, &$form_state, $form_id) { $form_type = !empty($form['type']['#value']) ? $form['type']['#value'] : ''; $form['#attributes']['class'][] = 'form-horizontal'; // Add icons to action buttons $form['actions']['submit']['#value'] .= ' <i class="fa fa-save"></i>'; if (!empty($form['actions']['delete'])) { $form['actions']['delete']['#value'] .= ' <i class="fa fa-ban"></i>'; } // Remove node settings at the bottom of form unset($form['additional_settings']); foreach ($form as $key => $element) { if (is_array($form[$key]) && isset($form[$key]['#group'])) { unset($form[$key]); } // Wrap certain form element types with Bootstrap column classes if (strrpos($key, 'field_', -strlen($key)) !== FALSE || $key == 'title') { $field_info = field_info_instance('node', $key, $form_type); $field_type = !empty($field_info['widget']['type']) ? $field_info['widget']['type'] : ''; $column_prefix = '<span class="col-md-8">'; $column_suffix = '</span>'; $adjust_col = FALSE; if ($key == 'title') { $form_elem =& $form[$key]; $adjust_col = TRUE; } else { switch ($field_type) { case "text_textarea": break; case "file_generic": $form_elem =& $form[$key][LANGUAGE_NONE][0]; $adjust_col = TRUE; break; case "number": $form_elem =& $form[$key][LANGUAGE_NONE][0]['value']; $column_prefix = '<span class="col-md-2 input-type-number">'; $adjust_col = TRUE; break; case "text_textfield": $form_elem =& $form[$key][LANGUAGE_NONE][0]['value']; $adjust_col = TRUE; break; default: $form_elem =& $form[$key][LANGUAGE_NONE]; $adjust_col = TRUE; break; } } if ($adjust_col) { $prefix = !empty($form_elem['#field_prefix']) ? $form_elem['#field_prefix'] : ''; $suffix = !empty($form_elem['#field_suffix']) ? $form_elem['#field_suffix'] : ''; $form_elem['#field_prefix'] = $column_prefix . $prefix; $form_elem['#field_suffix'] = $suffix . $column_suffix; } } } }
/** * Overrides \RestfulEntityBaseNode::publicFieldsInfo(). */ public function publicFieldsInfo() { $public_fields = parent::publicFieldsInfo(); unset($public_fields['self']); $public_fields['created'] = array('property' => 'created'); $public_fields['updated'] = array('property' => 'changed'); if (field_info_instance($this->getEntityType(), OG_AUDIENCE_FIELD, $this->getBundle())) { $public_fields['company'] = array('property' => OG_AUDIENCE_FIELD, 'resource' => array('company' => array('name' => 'companies', 'full_view' => FALSE))); } return $public_fields; }
public function publicFieldsInfo() { $public_fields = parent::publicFieldsInfo(); if ($this->getBundle()) { $public_fields['vsite'] = array('property' => OG_AUDIENCE_FIELD, 'process_callbacks' => array(array($this, 'vsiteFieldDisplay'))); } $public_fields['body'] = array('property' => 'body', 'sub_property' => 'value'); if (field_info_instance($this->getEntityType(), 'field_upload', $this->getBundle())) { $public_fields['files'] = array('property' => 'field_upload', 'process_callbacks' => array(array($this, 'fileFieldDisplay'))); } return $public_fields; }
/** * @todo. */ public function dateForm($field_name, $field_type, $widget_type, $todate = TRUE) { // Tests that date field functions properly. $edit = array(); $edit['title'] = $this->randomName(8); if ($widget_type == 'date_select') { $edit[$field_name . '[und][0][value][year]'] = '2010'; $edit[$field_name . '[und][0][value][month]'] = '10'; $edit[$field_name . '[und][0][value][day]'] = '7'; $edit[$field_name . '[und][0][value][hour]'] = '10'; $edit[$field_name . '[und][0][value][minute]'] = '30'; if ($todate) { $edit[$field_name . '[und][0][show_todate]'] = '1'; $edit[$field_name . '[und][0][value2][year]'] = '2010'; $edit[$field_name . '[und][0][value2][month]'] = '10'; $edit[$field_name . '[und][0][value2][day]'] = '7'; $edit[$field_name . '[und][0][value2][hour]'] = '11'; $edit[$field_name . '[und][0][value2][minute]'] = '30'; } } elseif ($widget_type == 'date_popup') { $edit[$field_name . '[und][0][value][date]'] = '10/07/2010'; $edit[$field_name . '[und][0][value][time]'] = '10:30'; if ($todate) { $edit[$field_name . '[und][0][show_todate]'] = '1'; $edit[$field_name . '[und][0][value2][date]'] = '10/07/2010'; $edit[$field_name . '[und][0][value2][time]'] = '11:30'; } } // Test that the date is displayed correctly using both the 'short' and // 'long' date types. // // For the short type, save an explicit format and assert that is the one // which is displayed. variable_set('date_format_short', 'l, m/d/Y - H:i:s'); $instance = field_info_instance('node', $field_name, 'story'); $instance['display']['default']['settings']['format_type'] = 'short'; field_update_instance($instance); $this->drupalPost('node/add/story', $edit, t('Save')); $this->assertText($edit['title'], "Node has been created"); $should_be = $todate ? 'Thursday, 10/07/2010 - 10:30 to 11:30' : 'Thursday, 10/07/2010 - 10:30'; $this->assertText($should_be, "Found the correct date for a {$field_type} field using the {$widget_type} widget displayed using the short date format."); // For the long format, do not save anything, and assert that the displayed // date uses the expected default value of this format provided by Drupal // core ('l, F j, Y - H:i'). $instance = field_info_instance('node', $field_name, 'story'); $instance['display']['default']['settings']['format_type'] = 'long'; field_update_instance($instance); $this->drupalPost('node/add/story', $edit, t('Save')); $this->assertText($edit['title'], "Node has been created"); $should_be = $todate ? 'Thursday, October 7, 2010 - 10:30 to 11:30' : 'Thursday, October 7, 2010 - 10:30'; $this->assertText($should_be, "Found the correct date for a {$field_type} field using the {$widget_type} widget displayed using the long date format."); }
/** * Notification to modules that a goal is completed. * * @param int $goal_id * Goal being completed. * @param int $uid * UserID of user completing the goal. */ function hook_goals_completed_goal($goal_id, $uid) { if (field_info_instance('goal', 'goal_userpoints', 'goal_bundle') && function_exists('userpoints_userpointsapi')) { $goals = entity_load('goal', array($goal_id)); $goal = $goals[$goal_id]; $point_array = field_get_items('goal', $goal, 'goal_userpoints'); $points = $point_array[0]['value']; if ($points) { $params = array('uid' => $uid, 'points' => $points, 'description' => t('Goal @goal completed.', array('@goal' => $goal->title))); userpoints_userpointsapi($params); } } }
/** * Implements template_preprocess_node, replacing selected static * field values with form elements that allow them to be edited. */ function sand_theme_preprocess_node(&$variables) { // Only applies to specific node type 'request' if ($variables['type'] == 'request') { //We don't need to show comments or links with this form if (isset($variables['content']['comments'])) { unset($variables['content']['comments']); } if (isset($variables['content']['links'])) { unset($variables['content']['links']); } // Call the form builder function for 'request_updater' // with current node->nid as an extra parameter $status_form = drupal_get_form('request_updater', $variables['nid']); $weight_max = -999; // Check whether there is a returned form that can be displayed if ($status_form['#access']) { foreach ($status_form['fields_replaced']['#value'] as $field) { // For each field in the form with a corresponding static field that has // been populated, copy the weight of the static field to the form // element and delete the static element. if (isset($variables['content'][$field])) { $status_form[$field]['#weight'] = $variables['content'][$field]['#weight']; $weight_max = max($weight_max, $status_form[$field]['#weight']); unset($variables['content'][$field]); } else { $inst = field_info_instance('node', $field, 'request'); $status_form[$field]['#weight'] = $inst['display']['default']['weight']; $weight_max = max($weight_max, $status_form[$field]['#weight']); } } // Node fields that have been populated and not matched to a form element just stay // as they are foreach ($variables['content'] as $field => $status) { if (isset($variables['content'][$field]['#weight'])) { $weight_max = max($weight_max, $variables['content'][$field]['#weight']); } } // Merge the elements of the form with the remaining content elements into // the content array. $variables['content'] = array_merge($status_form, $variables['content']); // $weight_max should now equal to the largest weight of any content element // so add 1 to make sure that the 'Save' button appears at the bottom $variables['content']['submit_button']['#weight'] = $weight_max + 1; } else { // If there's no form to be displayed, no change is made to the content array // and we still have the regular static display for the node } } }
/** * Load a field's configuration and instance configuration by an * entity_type.bundle.field_name identifier. */ protected function field_load($identifier) { list($entity_type, $field_name, $bundle) = explode('.', $identifier); $field_info = field_info_field($field_name); $instance_info = field_info_instance($entity_type, $field_name, $bundle); if ($field_info && $instance_info) { unset($field_info['id']); unset($field_info['bundles']); unset($instance_info['id']); unset($instance_info['field_id']); return array('field_config' => $field_info, 'field_instance' => $instance_info); } return FALSE; }
/** * Test instance field creation. * * @dataProvider fieldDataProvider */ public function testFieldInstanceCreation($field_name, $type, $label, $widget, $default_formatter, $teaser_formatter) { $base_handler = new DefaultBaseFieldHandler($field_name, $type); $base_handler->save(); $handler = new DefaultInstanceFieldHandler($field_name, 'node', self::CONTENT_TYPE_WITHOUT_FIELDS); $handler->label($label)->widget($widget)->display('default', $default_formatter, 'inline')->display('teaser', $teaser_formatter); $instance = $handler->getField(); $handler->save(); $saved_instance = field_info_instance('node', $field_name, self::CONTENT_TYPE_WITHOUT_FIELDS); $this->assertEquals($label, $saved_instance['label']); $this->assertEquals($widget, $saved_instance['widget']['type']); $this->assertEquals($default_formatter, $saved_instance['display']['default']['type']); $this->assertEquals($teaser_formatter, $saved_instance['display']['teaser']['type']); field_delete_field($field_name); }
/** * Constructor for the Add to cart form. Provide $nid as the id of the * product display node. Other optional arguments are product reference field * name, view mode of the product display node and language of the product * display node. If optional arguments are not provided, their default values * are assumed, which are "field_product", "default" and "en" respectively. * * @param int $nid * Product display node id. */ public function __construct($nid) { $args = func_get_args(); array_shift($args); $field_name = array_shift($args); $view_mode = array_shift($args); $language = array_shift($args); if (is_null($field_name)) { $field_name = 'field_product'; } if (is_null($view_mode)) { $view_mode = 'default'; } if (is_null($language)) { $language = 'en'; } $node = node_load($nid); $instance = field_info_instance('node', $field_name, $node->type); $display = field_get_display($instance, $view_mode, $node); $settings = array_merge(field_info_formatter_settings($display['type']), $display['settings']); $field_product = field_get_items('node', $node, $field_name); $product_id = $field_product[0]['product_id']; $products = commerce_product_load_multiple(array($product_id)); $type = !empty($settings['line_item_type']) ? $settings['line_item_type'] : 'product'; $line_item = commerce_product_line_item_new(commerce_product_reference_default_product($products), $settings['default_quantity'], 0, array(), $type); $line_item->data['context']['product_ids'] = array_keys($products); $line_item->data['context']['add_to_cart_combine'] = !empty($settings['combine']); $line_item->data['context']['show_single_product_attributes'] = !empty($settings['show_single_product_attributes']); $cart_context = array('entity_type' => 'node', 'entity_id' => $nid, 'display' => 'default', 'language' => $language); $cart_context['class_prefix'] = $cart_context['entity_type'] . '-' . $nid; $cart_context['view_mode'] = $cart_context['entity_type'] . '_' . $view_mode; $entity_uri = entity_uri($cart_context['entity_type'], $node); $arguments = array('form_id' => commerce_cart_add_to_cart_form_id(array($product_id)), 'line_item' => $line_item, 'show_quantity' => $settings['show_quantity']); // Add the display path and referencing entity data to the line item. if (!empty($entity_uri['path'])) { $arguments['line_item']->data['context']['display_path'] = $entity_uri['path']; } $arguments['line_item']->data['context']['entity'] = array('entity_type' => $cart_context['entity_type'], 'entity_id' => $cart_context['entity_id'], 'product_reference_field_name' => $field_name); // Update the product_ids variable to point to the entity data if we're // referencing multiple products. if (count($arguments['line_item']->data['context']['product_ids']) > 1) { $arguments['line_item']->data['context']['product_ids'] = 'entity'; } parent::__construct($arguments['form_id'], $arguments['line_item'], $arguments['show_quantity'], $cart_context); $this->cart_context = $cart_context; $this->arguments = $arguments; }
/** * {@inheritdoc} */ function describe($api, $entity_type, $keys) { if (!empty($this->bundlesByType[$entity_type])) { if ('user' === $entity_type) { $instance = field_info_instance('user', $this->fieldKey, 'user'); foreach ($keys as $key => $title) { $api->addRule($key, $title); } $api->descWithLabel($instance['label'], t('Field')); } foreach ($this->bundlesByType[$entity_type] as $bundle_name) { if (isset($keys[$bundle_name])) { $instance = field_info_instance($entity_type, $this->fieldKey, $bundle_name); $api->addRule($bundle_name, $keys[$bundle_name]); $api->descWithLabel($instance['label'], t('Field'), $bundle_name); } } // $api->addDescription('(' . $this->fieldKey . ')'); } }
/** * Given a relationship, gets the stub entity for the source. * * @param array $relationship The relationship array. * * @return bool|mixed Either the stub entity or false on error. */ protected function getSourceStubEntity(array $relationship) { $field_name = $relationship['field_name']; $source_entity_ids = entity_get_id_by_uuid($relationship['source_type'], array($relationship['source_uuid'])); $source_entity_id = count($source_entity_ids) > 0 ? reset($source_entity_ids) : null; $source_entity_vids = entity_get_id_by_uuid($relationship['source_type'], array($relationship['source_vuuid']), true); $source_entity_vid = count($source_entity_vids) > 0 ? reset($source_entity_vids) : false; if (!$source_entity_id) { return false; } // Get the bundle for the source entity. $source_entity_bundle = Entity::getBundleFromID($relationship['source_type'], $source_entity_id); if (!$source_entity_bundle) { return false; } // Get the stub entity for the source. $source_stub = Entity::getStub($relationship['source_type'], $source_entity_id, $source_entity_bundle, $source_entity_vid); // Load the existing field onto the entity. $field_instance_info = field_info_instance($relationship['source_type'], $field_name, $source_entity_bundle); if ($field_instance_info === false) { return false; } try { // First, load the revisions. field_attach_load_revision($relationship['source_type'], array($source_entity_id => $source_stub), array('field_id' => $field_instance_info['field_id'])); // Second, get the original deltas for the revision. $deltas = db_select('field_revision_' . $field_name, 'fr')->fields('fr', array('language', 'delta'))->condition($source_entity_vid ? 'revision_id' : 'entity_id', $source_entity_vid ? $source_entity_vid : $source_entity_id)->condition('language', field_available_languages($relationship['source_type'], $field_instance_info), 'IN')->orderBy('delta')->execute(); // Assign the deltas to their languages. $deltas_languages = array(); foreach ($deltas as $delta) { if (!array_key_exists($delta->language, $deltas_languages)) { $deltas_languages[$delta->language] = array(); } $deltas_languages[$delta->language][] = $delta->delta; } // Reset the deltas to their correct orders. $field_value =& $source_stub->{$field_name}; foreach ($deltas_languages as $language => $deltas) { $new_value = array(); for ($i = 0; $i < count($field_value[$language]); $i++) { $new_value[$deltas[$i]] = $field_value[$language][$i]; } $field_value[$language] = $new_value; } } catch (\Exception $ex) { // If an exception was thrown, that probably means the field doesn't // exist, so we should return false. return false; } return $source_stub; }
/** * Delete field instance given label, base field name, entity type and bundle. * * @param string $field_name * Machine name of an existing base field. * @param string $entity_type * Entity type machine name. * @param string $bundle * Bundle machine name. */ public function deleteInstanceField($field_name, $entity_type, $bundle) { if ($instance = field_info_instance($entity_type, $field_name, $bundle)) { field_delete_instance($instance); } }
/** * Returns field instance from field name for the given entity. * * @param string $field_name * Field name. * * @return mixed $instance * An instance array if one exists, FALSE otherwise. * * @throws \EntityMalformedException */ public function getFieldInstance($field_name) { list(, , $bundle) = entity_extract_ids($this->entity_type, $this->entity); return field_info_instance($this->entity_type, $field_name, $bundle); }
function BraftonArticleImporter() { $errors = new BraftonErrorReport(variable_get('brafton_api_key'), variable_get('brafton_api_root'), (bool) variable_get('brafton_debug_mode')); //Gathers feed type, Api and Video Keys, and archive file information from the Brafton module settings page. $import_list = array(); $feed_type = variable_get('brafton_feed_type'); $is_api = variable_get('brafton_api_key'); $is_archive = variable_get('brafton_archive_file'); $overwrite = variable_get('brafton_overwrite'); $is_published = variable_get('brafton_published'); $counter = 0; //Define default fields for b_news type_url_form_media if ($is_api || $is_archive) { //Loads the date and overwrite settings. $date = get_date_setting(); //Loads the article objects from the feed into an array. $article_array = load_article_array($is_archive); //Loops through the article array foreach ($article_array as $value) { //Checks to see if the article already exists. If it does not, a new node is created of type b_news. If it does, then depending upon the overwrite settings the existing node is either loaded, or we iterate to the next article in the feed $id = $value->getId(); $check = check_if_article_exists($id); if (!empty($check) && $overwrite == 1) { $nid = key($check['node']); $node = node_load($nid); } elseif (empty($check)) { $node = new stdClass(); } else { continue; } //Gets an array of image information from the feed. $image = get_image_attributes($value); //Gets the article categories as an array of valid and unique term ids. $categories = set_article_categories($value, 'b_news'); //Instantiation of each article component as a field in the node object. $node->status = $is_published == 1 ? 0 : 1; $types = array('body' => 'body', 'image' => 'field_brafton_image', 'tax' => 'field_brafton_term'); if (variable_get('brafton_existing_type') != 'b_news') { $types['body'] = variable_get('brafton_custom_body'); $types['image'] = variable_get('brafton_custom_image'); $types['tax'] = variable_get('brafton_custom_taxonomy'); } $node->type = variable_get('brafton_existing_type'); $node->language = LANGUAGE_NONE; $node->title = $value->getHeadline(); $import_list['title'][] = $node->title; $node->uid = checkAuthor(variable_get('brafton_author'), $value->getByLine()); //$nodestatus = 1; $node->created = strtotime($value->{$date}()); $node->updated = $node->created; $node->promote = 0; $node->sticky = 0; $node->comment = variable_get('brafton_comments'); $node->{$types['body']}[$node->language][0] = array('value' => $value->getText(), 'summary' => $value->getExtract(), 'format' => 'full_html'); if ($image) { $node->{$types['image']}[$node->language][0] = (array) system_retrieve_file($image['url'], NULL, TRUE, FILE_EXISTS_REPLACE); $node->{$types['image']}[$node->language][0]['alt'] = $image['alt']; $node->{$types['image']}[$node->language][0]['title'] = $image['title']; } if (field_info_instance('node', 'field_brafton_id', $node->type) == NULL) { $brafton_id_field = array('field_name' => 'field_brafton_id', 'entity_type' => 'node', 'bundle' => $node->type, 'display' => array('default' => array('label' => 'hidden', 'type' => 'hidden'))); field_create_instance($brafton_id_field); } $node->field_brafton_id[$node->language][0]['value'] = $id; //Setting the article pause cta text //ensure categories don't get added twice $cats = false; $oldcats; if ($overwrite && isset($node->{$types['tax']}[$node->language])) { $oldcats = $node->{$types['tax']}[$node->language]; $cats = true; } foreach ($categories as $category) { if ($cats) { foreach ($oldcats as $oldcat) { if ($oldcat['tid'] != $category) { $node->{$types['tax']}[$node->language][]['tid'] = $category; } } } else { $node->{$types['tax']}[$node->language][]['tid'] = $category; } } //end category code node_save($node); var_dump($node); taxonomy_node_insert($node); $nid = $node->nid; $alias = drupal_get_path_alias("node/" . $nid); $counter++; ++$errors->level; } } $import_list['counter'] = $counter; return $import_list; }
/** * Returns information about field instance. * * @param Entity $entityObject * Entity for which the field instance is to be returned. * @param string $field_name * Field name. * * @return array|null * An array of field instance information if the instance exists. NULL if * the field instance does not exist. */ public static function getFieldInstance(Entity $entityObject, $field_name) { list(, , $bundle) = entity_extract_ids($entityObject->getEntityType(), $entityObject->getEntity()); $instance = field_info_instance($entityObject->getEntityType(), $field_name, $bundle); return $instance; }
/** * Grab the information about a field instance attached to a bundle. * * This is simple a wrapper around field_info_instance. * * @param string $entityType * The entity type the bundle is attached to. * @param string $fieldName * The field name (i.e. field_image) * @param string $bundleName * The bundle name you are looking on. * @return array|null * An array containing the output of field_info_instance or null if the field instance doesn't exist. */ public function grabFieldInstance($entityType, $fieldName, $bundleName) { return field_info_instance($entityType, $fieldName, $bundleName); }
public function build($entityType, $bundleName) { if (!($info = field_info_instance($entityType, $this->field_name, $bundleName))) { field_create_instance(array('entity_type' => $entityType, 'bundle' => $bundleName, 'field_name' => $this->field_name, 'label' => $this->label, 'description' => $this->description, 'required' => $this->required, 'settings' => array(), 'widget' => $this->widget->getDefinition(), 'display' => array())); } }
function _get_field_instance($bundle_name, $field_name) { return field_info_instance('node', $field_name, $bundle_name); }
/** * Populate public info field with Property API information. */ protected function populatePublicInfoField() { $field_definition = $this->getDefinition(); $discovery_info = empty($field_definition['discovery']) ? array() : $field_definition['discovery']; $public_field_info = new PublicFieldInfoEntity($this->getPublicName(), $this->getProperty(), $this->getEntityType(), $this->getBundle(), $discovery_info); $this->setPublicFieldInfo($public_field_info); if ($field_instance = field_info_instance($this->getEntityType(), $this->getProperty(), $this->getBundle())) { $public_field_info->addSectionDefaults('info', array('label' => $field_instance['label'], 'description' => $field_instance['description'])); $field_info = $this::fieldInfoField($this->getProperty()); $section_info = array(); $section_info['label'] = empty($field_info['label']) ? NULL : $field_info['label']; $section_info['description'] = empty($field_info['description']) ? NULL : $field_info['description']; $public_field_info->addSectionDefaults('info', $section_info); $type = $public_field_info instanceof PublicFieldInfoEntityInterface ? $public_field_info->getFormSchemaAllowedType() : NULL; $public_field_info->addSectionDefaults('form_element', array('default_value' => isset($field_instance['default_value']) ? $field_instance['default_value'] : NULL, 'type' => $type)); // Loading allowed values can be a performance issue, load them only if // they are not provided in the field definition. $form_element_info = $public_field_info->getSection('form_element'); if (!isset($form_element_info['allowed_values'])) { $allowed_values = $public_field_info instanceof PublicFieldInfoEntityInterface ? $public_field_info->getFormSchemaAllowedValues() : NULL; $public_field_info->addSectionDefaults('form_element', array('allowed_values' => $allowed_values)); } } else { // Extract the discovery information from the property info. try { $property_info = $this->entityTypeWrapper()->getPropertyInfo($this->getProperty()); } catch (\EntityMetadataWrapperException $e) { return; } if (empty($property_info)) { return; } $public_field_info->addSectionDefaults('data', array('type' => $property_info['type'], 'required' => empty($property_info['required']) ? FALSE : $property_info['required'])); $public_field_info->addSectionDefaults('info', array('label' => $property_info['label'], 'description' => $property_info['description'])); } }
function cubert_attach_form($field_name, $entity_type, $bundle, $entity, &$form, &$form_state, $langcode = NULL) { // Set #parents to 'top-level' if it doesn't exist. $form += array('#parents' => array()); // If no language is provided use the default site language. $options = array('language' => field_valid_language($langcode), 'default' => TRUE); // Append to the form ctools_include('fields'); $field_instance = field_info_instance($entity_type, $field_name, $bundle); $form += (array) ctools_field_invoke_field($field_instance, 'form', $entity_type, $entity, $form, $form_state, $options); }
<?php $field_instances = field_info_instance('node', $settings['fieldName'], $settings['nodeType']); $display = field_get_display($field_instances, 'full', $node); $field_render = field_view_field('node', $node, $settings['fieldName'], $display); print render($field_render);
public function setValue($wrapper, $fieldLabel, $rawValue) { $subField = FALSE; if (strpos($fieldLabel, ':') !== FALSE) { $fieldStrings = explode(':', $fieldLabel); $fieldLabel = $fieldStrings[0]; $subField = $fieldStrings[1]; } foreach ($wrapper->getPropertyInfo() as $key => $wrapper_property) { if ($fieldLabel == $wrapper_property['label']) { $fieldMachineName = $key; $fieldInfo = isset($wrapper_property['field']) && $wrapper_property['field'] ? field_info_field($fieldMachineName) : array(); if (empty($fieldInfo)) { switch ($wrapper_property['type']) { case 'boolean': $value = filter_var($rawValue, FILTER_VALIDATE_BOOLEAN); break; case 'date': if (!is_numeric($rawValue)) { $rawValue = strtotime($rawValue); } default: $value = $rawValue; } } elseif ($fieldInfo = field_info_field($fieldMachineName)) { // @todo add condition for each field type. switch ($fieldInfo['type']) { case 'entityreference': $relatedEntityType = $fieldInfo['settings']['target_type']; $targetBundles = $fieldInfo['settings']['handler_settings']['target_bundles']; $query = new \EntityFieldQuery(); $query->entityCondition('entity_type', $relatedEntityType); // Adding special conditions. if (count($targetBundles) > 1) { $relatedBundles = array_keys($targetBundles); $query->entityCondition('bundle', $relatedBundles, 'IN'); } else { $relatedBundles = reset($targetBundles); $query->entityCondition('bundle', $relatedBundles); } if ($relatedEntityType == 'node') { $query->propertyCondition('title', $rawValue); } if ($relatedEntityType == 'taxonomy_term' || $relatedEntityType == 'user') { $query->propertyCondition('name', $rawValue); } $results = $query->execute(); if (empty($results)) { throw new \Exception("Entity that you want relate doesn't exist."); } $value = array_keys($results[$relatedEntityType]); if (count($value) == 1) { $value = array_pop($value); } break; case 'image': try { $fieldInstance = field_info_instance($wrapper->type(), $fieldMachineName, $wrapper->getBundle()); $fieldDirectory = 'public://' . $fieldInstance['settings']['file_directory']; $image = file_get_contents($rawValue); $pathinfo = pathinfo($rawValue); $filename = $pathinfo['basename']; file_prepare_directory($fieldDirectory, FILE_CREATE_DIRECTORY); $value = (array) file_save_data($image, $fieldDirectory . '/' . $filename, FILE_EXISTS_RENAME); if ($fieldInfo['cardinality'] > 1 || $fieldInfo['cardinality'] == FIELD_CARDINALITY_UNLIMITED) { $value = array($value); } } catch (Exception $e) { throw new \Exception("File {$rawValue} coundn't be saved."); } break; default: $value = $rawValue; break; } } } } if (empty($fieldMachineName)) { throw new \Exception("Entity property {$fieldLabel} doesn't exist."); } if ($subField) { $wrapper->{$fieldMachineName}->{$subField} = $value; } else { $wrapper->{$fieldMachineName} = $value; } $wrapper->save(); }
function _generate_specifics_string($node) { $string = ''; $included_fields = array('field_practice_pit', 'field_pit_dug_in_a_ski_area', 'field_pit_is_representative_of_backcountry', 'field_adjacent_to_avy', 'field_near_avalanche', 'field_collapsing_widespread', 'field_collapsing_localized', 'field_cracking', 'field_recent_activity_on_similar', 'field_recent_activity_on_differe', 'field_instability_rapidly_rising', 'field_ski_tracks_on_slope', 'field_we_skiied_slope', 'field_snowmobile_tracks_on_slope', 'field_we_snowmobiled_slope', 'field_poor_pit_location'); // etc $specifics = array(); // then we loop through the array and add them each to the string. foreach ($included_fields as $key => $field) { if (isset($node->{$field})) { // Anything beyond the specific field here , will require accessing via the $node object $field_item = $node->{$field}; if (isset($field_item['und'][0]) && $field_item['und'][0]['value'] != '0') { $item_full = field_info_instance('node', $field, 'snowpit_profile'); switch ($field) { case 'field_adjacent_to_avy': $specifics[] = $item_full['label'] . ": " . $node->field_near_avalanche['und'][0]['value']; break; case 'field_near_avalanche': break; case 'field_stability_on_similar_slope': $specifics[] = $item_full['label'] . ": " . $node->field_stability_on_similar_slope['und'][0]['value']; break; default: $specifics[] = $item_full['label']; break; } } } } return implode('; ', $specifics); }
/** * Specify token replacement values for combinations. * * Combination-providing modules should implement this hook. * * commerce_bpc handles token management for combinations, to ensure * a minimally consistent set of tokens. In particular, commerce_bpc * will create a FIELD_NAME-value and a FIELD_NAME-label token for * each combination-creating field. The -value token should be fit * for inclusion in SKUs, while the -label token should be a human readable * value. * * @param string $product_type * The product type to provide tokens for. * @param array $combination * An array with field names as keys and their respective * values as values. * @param array $options * Options array passed unmodified from hook_tokens(). Make sure * you honor the 'sanitize' property. * * @return array * An array with two keys 'values' and 'labels', each of which should * have an array keyed by field names with replacements as values. * * @see hook_commerce_bpc_get_combinations() */ function hook_commerce_bpc_tokens($product_type, $combination, $options) { $replacements = array(); $sanitize = !empty($options['sanitize']); foreach ($combination as $field_name => $values) { $field = field_info_field($field_name); $instance = field_info_instance('commerce_product', $field_name, $product_type); if ($field['module'] == 'list' && !_commerce_bpc_get_value($instance, array('commerce_bpc', 'is_static'), FALSE)) { // TODO: Treat languages properly. $items = reset($values); // We only allow a single value per combination, so we can treat // this like a single value field. $value = $items[0]['value']; $replacements['values'][$field_name] = $value; $labels = list_allowed_values($field); $replacements['labels'][$field_name] = $sanitize ? check_plain($labels[$value]) : $labels[$value]; } } return $replacements; }
function snowpilot_user_unit_prefs_check($uid, $redirect_to_user_edit = TRUE) { $account = user_load($uid); $drupal_keys_required = array('field_depth_0_from', 'field_depth_units', 'field_temp_units', 'field_coordinate_type', 'field_elevation_units', 'field_longitude_type', 'field_latitude_type', 'field_density_units', 'field_fracture_category', 'field_hardness_scale', 'field_first_name', 'field_last_name', 'name', 'mail'); $missing_keys = array(); foreach ($drupal_keys_required as $key) { if (count($account->{$key}) == 0) { $field = field_info_field($key); $field_instance = field_info_instance('node', $key, 'snowpit_profile'); $missing_keys[] = $field_instance['label']; } } if (count($missing_keys)) { drupal_set_message("<h3>Missing User Unit Preferences</h3>You need to set your <a href = '/user/" . $uid . "/edit#edit-field-first-name'>User Unit Preferences</a> before you can create a new Snowpit Profile.<br/>\n\t\t\tThe following preferences have not been set yet: <li>" . implode($missing_keys, '<li>'), 'warning'); if ($redirect_to_user_edit == TRUE) { drupal_goto("snowpilot/user/edit", array('query' => array('destination' => drupal_get_destination()))); } return FALSE; } return TRUE; }
/** * Returns field instance information. * * @param string $field_name * Field name. * * @return array * Field instance array. */ protected function getFieldInstance($field_name) { list(, , $bundle) = entity_extract_ids($this->entityObject->getEntityType(), $this->entityObject->getEntity()); $instance = field_info_instance($this->entityObject->getEntityType(), $field_name, $bundle); return $instance; }
public static function changeInstanceField(array $instance, $new_field_name) { $old_field = field_info_field($instance['field_name']); $new_field = field_info_field($new_field_name); if ($old_field['type'] != $new_field['type']) { throw new FieldException("Cannot change field instance because they are not the same field type."); } if ($old_field['storage']['type'] !== 'field_sql_storage') { throw new FieldException("Unable to change field type for field {$old_field['field_name']} using storage {$old_field['storage']['type']}."); } if ($new_field['storage']['type'] !== 'field_sql_storage') { throw new FieldException("Unable to change field type for field {$new_field['field_name']} using storage {$new_field['storage']['type']}."); } if (!field_info_instance($instance['entity_type'], $new_field_name, $instance['bundle'])) { $new_instance = $instance; $new_instance['field_name'] = $new_field_name; field_create_instance($new_instance); watchdog('helper', "Created new field instance: {$instance['entity_type']}.{$instance['bundle']}.{$new_field_name}"); } // Copy data from old field tables to the new field tables. $old_data_table = _field_sql_storage_tablename($old_field); $new_data_table = _field_sql_storage_tablename($new_field); $query = db_select($old_data_table, 'old'); $query->fields('old'); $query->condition('entity_type', $instance['entity_type']); $query->condition('bundle', $instance['bundle']); db_insert($new_data_table)->from($query)->execute(); $old_revision_table = _field_sql_storage_revision_tablename($old_field); if (db_table_exists($old_revision_table)) { $new_revision_table = _field_sql_storage_revision_tablename($new_field); $query = db_select($old_revision_table, 'old'); $query->fields('old'); $query->condition('entity_type', $instance['entity_type']); $query->condition('bundle', $instance['bundle']); db_insert($new_revision_table)->from($query)->execute(); } FieldHelper::deleteInstance($instance); }
field_delete_instance($instance); } // From roles nodes. if ($instance = field_info_instance('node', 'field_diaet', 'roles')) { field_delete_instance($instance); } if ($instance = field_info_instance('node', 'field_invitation', 'roles')) { field_delete_instance($instance); } if ($instance = field_info_instance('node', 'field_reminder', 'roles')) { field_delete_instance($instance); } if ($instance = field_info_instance('node', 'field_rsvp_yes', 'roles')) { field_delete_instance($instance); } if ($instance = field_info_instance('node', 'field_rsvp_no', 'roles')) { field_delete_instance($instance); } if ($instance = field_info_instance('node', 'field_rsvp_never', 'roles')) { field_delete_instance($instance); } // From volutneer nodes. if ($instance = field_info_instance('node', 'field_token', 'volunteers')) { field_delete_instance($instance); } if ($instance = field_info_instance('node', 'field_rsvp', 'volunteers')) { field_delete_instance($instance); } if ($instance = field_info_instance('node', 'field_rsvp_comment', 'volunteers')) { field_delete_instance($instance); }