diff --git a/sites/all/modules/entity_translation/entity_translation.module b/sites/all/modules/entity_translation/entity_translation.module index fcf7908..617083f 100644 --- a/sites/all/modules/entity_translation/entity_translation.module +++ b/sites/all/modules/entity_translation/entity_translation.module @@ -469,6 +469,269 @@ function entity_translation_form_field_ui_field_settings_form_alter(&$form, $for '#title' => t('Users may translate this field.'), '#default_value' => $field['translatable'], ); + $form['field']['warning'] = array( + '#type' => 'container', + '#states' => array( + 'visible' => array( // action to take. + ':input[name="field[translatable]"]' => array('checked' => ! $field['translatable']), + ), + ), + ); + $form['field']['warning']['warning'] = array( + '#markup' => t('By submitting this form you will trigger a batch operation. THIS OPERATION COULD RESULT IN LOSS OF DATA. Please ensure that all effected nodes are backed up before proceeding.'), + ); + + // our submit handler must run before field_ui_field_settings_form_submit() + if (isset($form['#submit'])) { + array_unshift($form['#submit'], 'entity_translation_translatable_submit'); + } + else { + $form['#submit'] = array('entity_translations_translatable_submit'); + } +} + +/** + * This submit handler maintains consistency between the translatability of a node and the language under which the + * field data is stored. + * + * When a field is marked as translatable, all data under $node->{field_name}['und'] is moved to + * $node->{field_name}[$node->language]. When a field is marked as untranslatable, the opposite transfer occurs. + * + * N.B. When marking a field as untranslatable, all translations of the field (except for $node->language) will be + * lost! This should be a very rare case, but a lot of anger will eventually come from it. + * + * TODO: Make a confirmation page as when anything else is deleted. + * + * For lack of a better place, notes go here: + * + * -Make sure that the confirmation screen/message don't appear when creating a new field. + */ +function entity_translation_translatable_submit($form, &$form_state) { + $checked = $form_state['values']['field']['translatable']; + $prior = $form['field']['translatable']['#default_value']; + + if ($prior == $checked) { + return; + } + + $field_name = $form_state['values']['field']['field_name']; + + $ops = array(); + $entity_type = $form['#entity_type']; + // Number of entities per batch operation + $increment = 10; + + // TODO: Everything following wrt nodes needs to be generalised for all entities which have a language defined. + $count = db_select('field_data_' . $field_name, 'n') + ->distinct() + ->fields('n', array('entity_id')) + ->countQuery() + ->execute() + ->fetchField(); + + do { + $ops[] = array('entity_translation_translatable_batch', array($checked, $entity_type, $field_name, $increment)); + $count -= $increment; + } + while ($count > 0); + + // When making field untranslatable, we need to make sure that the other submit handler + // can't see the changed translatable setting. We change it ourselves after the batch operation. + // + // For some reason, adding the custom submit handler to the batch job doesn't work; it never gets called. + // Why this is is yet to be determined, but a temporary workaround is to pass the data into the batch results + // and then call the submit handler from the finalising callback. + if (! $checked) { + $ops[] = array('entity_translation_translatable_batch_data_store', array($form, $form_state)); + $form_state['values']['field']['translatable'] = $prior; + } + + // Somehow this submit handler doesn't get called unless it comes first. So, we look through the list and + // if we find one, we call it ourselves, and remove it from the list. It is removed and executed at most once. + // + // This is not a good solution, but it works. fixme if you see how. + foreach ($form['#submit'] as $key => &$value) { + if ($value === 'field_ui_field_settings_form_submit') { + unset($value); + field_ui_field_settings_form_submit($form, $form_state); + break; + } + } + + $batch = array( + 'operations' => $ops, + 'finished' => 'entity_translation_translatable_batch_done', + ); + + batch_set($batch); +} + +/** + * Hacky helper function to pass the form data off to entity_translation_translatable_batch_done. + */ +function entity_translation_translatable_batch_data_store($form, $form_state, &$context) { + $context['results'] = array($form, $form_state); +} + +/** + * Function from which to build batch array. + */ +function entity_translation_translatable_batch($make_translatable, $entity_type, $field_name, $inc, &$context) { + // Figure out which nodes we're interested in. + if (isset($context['count'])) { + $count = $context['count']; + $contex['count'] += $inc; + } + else { + $count = 0; + $context['count'] = $inc; + } + + $query = db_select('field_data_' . $field_name, 'data') + ->fields('data', array('entity_id', 'entity_type', 'bundle')) + ->distinct() + ->orderBy('entity_type') + ->range($count, $inc) + ->execute(); + // ->fetchAllAssoc('entity_id'); + + + // We have to load the all entities of each type in a separate operation + $entity_list = array (); + $sublist = array(); + $etype = ''; + foreach ($query as $entity) { + if ($etype === '') { + $etype = $entity->entity_type; + $info = entity_get_info($entity->entity_type); + } + else if ($etype !== $entity->entity_type) { + $entity_list[$etype] = $sublist; + $sublist = array(); + $etype = $entity->entity_type; + $info = entity_get_info($entity->entity_type); + } + // Unfortunately, the query above yields an object whose members are poorly named. + $sublist[$entity->entity_id] = (object) array( + $info['entity keys']['id'] => $entity->entity_id, + $info['entity keys']['bundle'] => $entity->bundle, + ); + } + $entity_list[$etype] = $sublist; + + // Finally we load all entities into a single array. + $entities = array(); + foreach ($entity_list as $etype => $list) { + field_attach_load($etype, $list, FIELD_LOAD_CURRENT, array('field_id' => $field_name)); + // There's got to be a better way to do this... + foreach ($list as $id => $entity) { + $entities[$id] = $entity; + } + } + + // Getting the default language of the entities is still an open problem. + // When turning off translatability, the obvious place to look is the source language + // attribute in the entity_translation table, but that table doesn't exist until after + // the field in question has been made translatable, so when turning translatability + // on... + + if (!$make_translatable) { + // This exploits the fact that in the entity_translation table, if the source is blank then the + // language is the source language. + $language = db_select('entity_translation', 'et') + ->fields('et', array('entity_id', 'language')) + ->condition('source', '', '=') + ->condition('entity_id', array_keys($entities), 'IN') + ->execute() + ->fetchAllAssoc('entity_id'); + } + else { + // Far from ideal interim solution. fixme + global $language; + $lang = $language->language; + } + + foreach ($entities as $id => $entity) { + + if (!$make_translatable) { + $lang = $language[$id]->language; + } + // else set lang properly. + + if ($make_translatable && isset($entity->{$field_name}[LANGUAGE_NONE])) { + // If field is to become translatable and has data in 'und' + + $entity->{$field_name}[$lang] = $entity->{$field_name}[LANGUAGE_NONE]; + //setting this to an empty array() will cause the item to be deleted + $entity->{$field_name}[LANGUAGE_NONE] = array(); + } + else if (!$make_translatable && isset($entity->{$field_name}[$lang])) { + // the field has been marked untranslatable and has data in the (entity's) default language + // mv the default language to und and drop the other translations. + //Store the field data in the default language + $data = $entity->{$field_name}[$lang]; + // Remove all translations of the field data. + foreach ($entity->{$field_name} as $langcode => $item) { + $entity->{$field_name}[$langcode] = array(); + } + // Move the original field data to LANGUAGE_NONE + $entity->{$field_name}[LANGUAGE_NONE] = $data; + } + else { + // Don't save unchanged entities. + continue; + } + // Save field data. Faster than node_save, but still too slow for comfort. + field_attach_update($entity_type, $entity); + } +} + +/** + * Check the exit status of the batch operation, and possibly resubmit the changed translatable status. + */ +function entity_translation_translatable_batch_done($success, $results, $operations) { + if (isset($results) && count($results) === 2) { + // Run our custom submit handler. + entity_translation_custom_submit($results[0], $results[1]); + } + if ($success) { + drupal_set_message(t("Data successfully converted.")); + } + else { + // TODO: Do something about this case. + drupal_set_message(t("Something went wrong when converting the data. Some nodes may appear to have lost fields.")); + } +} + +/** + * This is a shameless cut and paste of field_ui_field_settings_form_submit from field_ui.admin.inc. + * + * The reason is that we need to submit the form, but keep one property (translatabe) aside to be updated + * after we've run our batch operation; if we make a field untranslatable before moving the data we lose it. + * + * TODO: Find the right way to do this. + */ +function entity_translation_custom_submit($form, &$form_state) { + $form_values = $form_state['values']; + $field_values = $form_values['field']; + + // Merge incoming form values into the existing field. + $field = field_info_field($field_values['field_name']); + + $entity_type = $form['#entity_type']; + $bundle = $form['#bundle']; + $instance = field_info_instance($entity_type, $field['field_name'], $bundle); + + // Update the field. + $field = array_merge($field, $field_values); + + try { + field_update_field($field); + drupal_set_message(t('Updated field %label field settings.', array('%label' => $instance['label']))); + } + catch (FieldException $e) { + drupal_set_message(t('Attempt to update field %label failed: %message.', array('%label' => $instance['label'], '%message' => $e->getMessage())), 'error'); + } } /**