/**
  * Extract Field data from XML input
  *
  * @param Tracker_FormElement_Field $field
  * @param SimpleXMLElement $field_change
  *
  * @return mixed
  */
 public function getFieldData(Tracker_FormElement_Field $field, SimpleXMLElement $field_change)
 {
     $values = $field_change->value;
     $files_infos = array();
     if ($this->isFieldChangeEmpty($values)) {
         $this->logger->warn('Skipped attachment field ' . $field->getLabel() . ': field value is empty.');
         return $files_infos;
     }
     foreach ($values as $value) {
         try {
             $attributes = $value->attributes();
             $file_id = (string) $attributes['ref'];
             $file = $this->files_importer->getFileXML($file_id);
             if (!$this->files_importer->fileIsAlreadyImported($file_id)) {
                 $files_infos[] = $this->getFileInfoForAttachment($file);
                 $this->files_importer->markAsImported($file_id);
             }
         } catch (Tracker_Artifact_XMLImport_Exception_FileNotFoundException $exception) {
             $this->logger->warn('Skipped attachment field ' . $field->getLabel() . ': ' . $exception->getMessage());
         }
     }
     if ($this->itCannotImportAnyFiles($values, $files_infos)) {
         throw new Tracker_Artifact_XMLImport_Exception_NoValidAttachementsException();
     }
     return $files_infos;
 }

 private function getFieldChangeId(Tracker_FormElement_Field $field, $value)
 {
     if (isset($value['format']) && (string) $value['format'] === self::FORMAT_ID) {
         return (string) $value;
     }
     return $field->getFieldData((string) $value);
 }

 private function getFieldChangeId(Tracker_FormElement_Field $field, $value)
 {
     if (isset($value['format']) && (string) $value['format'] === self::FORMAT_ID) {
         return $this->xml_fields_mapping->getNewOpenValueId((string) $value);
     }
     return $field->getFieldData((string) $value);
 }

 /**
  * Extract Field data from XML input
  *
  * @param Tracker_FormElement_Field $field
  * @param SimpleXMLElement $field_change
  *
  * @return mixed
  */
 public function getFieldData(Tracker_FormElement_Field $field, SimpleXMLElement $field_change)
 {
     $timestamp = strtotime((string) $field_change->value);
     if ($timestamp > 0) {
         return $field->formatDate(strtotime($field_change->value));
     }
     return '';
 }

 /**
  * Return the value of a field in the current changeset
  *
  * @param Tracker_FormElement_Field $field The field
  *
  * @return Tracker_Artifact_ChangesetValue, or null if not found
  */
 public function getValue(Tracker_FormElement_Field $field)
 {
     $values = $this->getValues();
     if (isset($values[$field->getId()])) {
         return $values[$field->getId()];
     }
     return null;
 }

 public function getFullRESTValue(Tracker_FormElement_Field $field)
 {
     $class_user_representation = '\\Tuleap\\Project\\REST\\UserGroupRepresentation';
     $ugroup_representation = new $class_user_representation();
     $ugroup_manager = new UGroupManager();
     $project = $field->getTracker()->getProject();
     $ugroup_representation->build($project->getID(), $ugroup_manager->getById($this->getUgroupId()));
     return $ugroup_representation;
 }

 private function getStaticListDataValue(Tracker_FormElement_Field $field, $value)
 {
     if (isset($value['format']) && (string) $value['format'] === self::FORMAT_ID) {
         return $this->xml_fields_mapping->getNewValueId((int) $value);
     }
     $result = $this->static_value_dao->searchValueByLabel($field->getId(), (string) $value);
     $row = $result->getRow();
     return (int) $row['id'];
 }

 /**
  * @return array of Cardwall_OnTop_Config_ValueMapping
  */
 public function getMappings(Tracker $tracker, Tracker $mapping_tracker, Tracker_FormElement_Field $mapping_field)
 {
     // Why does we return a collection indexed on value_id in the case of freestyle mappings, and a collection
     // indexed on column_id in the case of status mappings @see getStatusMappings?????????
     // Shouldn't we let TrackerMapping do the indexing so that code in TrackerMapping might exploit that?
     $mappings = $this->getMappingFieldValuesIndexedByTracker($tracker);
     if (isset($mappings[$mapping_tracker->getId()][$mapping_field->getId()])) {
         return $mappings[$mapping_tracker->getId()][$mapping_field->getId()];
     }
     return array();
 }

 /**
  * @return \Tracker_Artifact_Changeset|null
  */
 public function getLastChangesetWithFieldValue(Tracker_Artifact $artifact, Tracker_FormElement_Field $field)
 {
     $dar = $this->dao->searchLastChangesetAndValueForArtifactField($artifact->getId(), $field->getId());
     if ($dar) {
         $row = $dar->getRow();
         $changeset = $this->getChangesetFromRow($artifact, $row);
         $value = $field->getChangesetValue($changeset, $row['value_id'], $row['has_changed']);
         $changeset->setFieldValue($field, $value);
         return $changeset;
     }
     return null;
 }

 /**
  * Extract Field data from XML input
  *
  * @param Tracker_FormElement_Field $field
  * @param SimpleXMLElement $field_change
  *
  * @return mixed
  */
 public function getFieldData(Tracker_FormElement_Field $field, SimpleXMLElement $field_change)
 {
     $data = array('use_artifact_permissions' => (int) $field_change['use_perm'], 'u_groups' => array());
     foreach ($field_change->ugroup as $ugroup_xml) {
         if (isset($ugroup_xml['ugroup_id'])) {
             $data['u_groups'][] = (int) $ugroup_xml['ugroup_id'];
         } elseif (isset($ugroup_xml['ugroup_name'])) {
             $ugroup_manager = new UGroupManager();
             $ugroup = $ugroup_manager->getUGroupByName($field->getTracker()->getProject(), (string) $ugroup_xml['ugroup_name']);
             $data['u_groups'][] = $ugroup->getId();
         }
     }
     return $data;
 }

 /**
  * Build a binder associated to a list field.
  * @param Tracker_FormElement_Field $field
  * @param string $type ('ug', 'submit', 'Static')
  */
 public function getBind($field, $type)
 {
     $default_value = array();
     $dao = new Tracker_FormElement_Field_List_Bind_DefaultvalueDao();
     foreach ($dao->searchByFieldId($field->id) as $row) {
         $default_value[$row['value_id']] = true;
     }
     $decorators = array();
     $dao = new Tracker_FormElement_Field_List_BindDecoratorDao();
     foreach ($dao->searchByFieldId($field->id) as $row) {
         $decorators[$row['value_id']] = new Tracker_FormElement_Field_List_BindDecorator($row['field_id'], $row['value_id'], $row['red'], $row['green'], $row['blue']);
     }
     $bind = new Tracker_FormElement_Field_List_Bind_Null($field);
     switch ($type) {
         case self::STATIK:
             $dao = new Tracker_FormElement_Field_List_Bind_StaticDao();
             if ($row = $dao->searchByFieldId($field->id)->getRow()) {
                 $values = array();
                 $dao = new Tracker_FormElement_Field_List_Bind_Static_ValueDao();
                 foreach ($dao->searchByFieldId($field->id, $row['is_rank_alpha']) as $row_value) {
                     $values[$row_value['id']] = $this->getStaticValueInstance($row_value['id'], $row_value['label'], $row_value['description'], $row_value['rank'], $row_value['is_hidden']);
                 }
                 $bind = new Tracker_FormElement_Field_List_Bind_Static($field, $row['is_rank_alpha'], $values, $default_value, $decorators);
             }
             break;
         case self::USERS:
             $dao = new Tracker_FormElement_Field_List_Bind_UsersDao();
             if ($row = $dao->searchByFieldId($field->id)->getRow()) {
                 $bind = new Tracker_FormElement_Field_List_Bind_Users($field, $row['value_function'], $default_value, $decorators);
             }
             break;
         case self::UGROUPS:
             $values = array();
             foreach ($this->getUgroupsValueDao()->searchByFieldId($field->id) as $row_value) {
                 $values[$row_value['id']] = $this->getUgroupsValueInstance($row_value['id'], $field->getTracker()->getProject(), $row_value['ugroup_id'], $row_value['is_hidden']);
             }
             $bind = new Tracker_FormElement_Field_List_Bind_Ugroups($field, array_filter($values), $default_value, $decorators, $this->ugroup_manager, $this->getUgroupsValueDao());
             break;
         default:
             trigger_error('Unknown bind "' . $type . '"', E_USER_WARNING);
             break;
     }
     return $bind;
 }

 /**
  * @see Transition_PostActionSubFactory::isFieldUsedInPostActions()
  */
 public function isFieldUsedInPostActions(Tracker_FormElement_Field $field)
 {
     foreach (array_keys($this->post_actions_classes) as $shortname) {
         if ($this->getDao($shortname)->countByFieldId($field->getId()) > 0) {
             return true;
         }
     }
     return false;
 }

 private function canFieldBeExportedToCSV(Tracker_FormElement_Field $field)
 {
     return $field->isUsed() && $field->userCanRead() && (!is_a($field, 'Tracker_FormElement_Field_ArtifactId') || is_a($field, 'Tracker_FormElement_Field_PerTrackerArtifactId'));
 }

 public function getFieldHTMLValue(PFUser $user, Tracker_FormElement_Field $field)
 {
     return $field->fetchCardValue($this->artifact, $this->display_preferences);
 }

 /**
  * Get the value of bypass_permissions
  *
  * @param Tracker_FormElement_Field $field
  *
  * @return boolean
  */
 public function bypassPermissions($field)
 {
     return $this->getFieldId() == $field->getId() && $this->bypass_permissions;
 }

 /**
  * Say if a field is used to define a workflow
  *
  * @param Tracker_FormElement_Field $field The field
  *
  * @return bool
  */
 public function isWorkflowField(Tracker_FormElement_Field $field)
 {
     $workflow = $this->getWorkflowByTrackerId($field->getTracker()->getId());
     if ($workflow) {
         return $field->getId() == $workflow->getFieldId();
     }
     return false;
 }

 /**
  * @return bool
  */
 private function isRequiredFieldsValid(Tracker $tracker, Tracker_FormElement_Field $title_field, Tracker_FormElement_Field $description_field)
 {
     $is_required_fields_valid = true;
     $form_elements = $tracker->getFormElementFields();
     reset($form_elements);
     while ($is_required_fields_valid && (list(, $form_element) = each($form_elements))) {
         if ($form_element->isRequired()) {
             $is_required_fields_valid = $form_element->getId() === $title_field->getId() || $form_element->getId() === $description_field->getId();
         }
     }
     return $is_required_fields_valid;
 }

 private function getFieldValue($fields_data, Tracker_Artifact $artifact, Tracker_FormElement_Field $field)
 {
     $field_id = $field->getId();
     if (isset($fields_data[$field_id])) {
         return $fields_data[$field_id];
     }
     return $this->getFieldValueFromLastChangeset($artifact, $field);
 }

 /**
  * Returns the selected values of a field
  *
  * @param Tracker_FormElement_Field $field
  * @param array $value_field_list the selected values to test for the artifact
  *
  * @return array the selected values
  */
 function getSelectedValuesForField($field, $value_field_list)
 {
     if (!is_array($value_field_list)) {
         $value_field_list = array($value_field_list);
     }
     $selected_values = array();
     foreach ($value_field_list as $value_field) {
         $selected_values[] = $field->getBind()->formatArtifactValue($value_field);
     }
     return $selected_values;
 }

 public function setFieldValue(Tracker_FormElement_Field $field, Tracker_Artifact_ChangesetValue $value = null)
 {
     $this->values[$field->getId()] = $value;
 }