Beispiel #1
0
  /**
   * Generate for the first line the headers of the columns
   *
   * @return the headers columns
   */
  public String generateHeader() {

    Map<Integer, DataField> dataFieldsSorted = new TreeMap<Integer, DataField>(dataFields);
    Iterator<Integer> it = dataFieldsSorted.keySet().iterator();

    StringBuilder builderHeader = new StringBuilder();

    while (it.hasNext()) {

      DataField dataField = dataFieldsSorted.get(it.next());

      // Retrieve the field
      Field field = annotatedFields.get(dataField.pos());
      // Change accessibility to allow to read protected/private fields
      field.setAccessible(true);

      // Get dataField
      if (!dataField.columnName().equals("")) {
        builderHeader.append(dataField.columnName());
      } else {
        builderHeader.append(field.getName());
      }

      if (it.hasNext()) {
        builderHeader.append(separator);
      }
    }

    return builderHeader.toString();
  }
Beispiel #2
0
 /**
  * Set the default values for the non defined fields.
  *
  * @param model the model which has its default fields set.
  * @throws IllegalAccessException if the underlying fields are inaccessible
  * @throws Exception In case the field cannot be parsed
  */
 private void setDefaultValuesForFields(final Map<String, Object> model)
     throws IllegalAccessException, Exception {
   // Set the default values, if defined
   for (int i = 1; i <= dataFields.size(); i++) {
     Field field = annotatedFields.get(i);
     field.setAccessible(true);
     DataField dataField = dataFields.get(i);
     Object modelField = model.get(field.getDeclaringClass().getName());
     if (field.get(modelField) == null && !dataField.defaultValue().isEmpty()) {
       Format<?> format = FormatFactory.getFormat(field.getType(), getLocale(), dataField);
       Object value = format.parse(dataField.defaultValue());
       field.set(modelField, value);
     }
   }
 }
Beispiel #3
0
  @Override
  public void initAnnotatedFields() {

    maxpos = 0;
    for (Class<?> cl : models) {
      List<Field> linkFields = new ArrayList<Field>();

      if (LOG.isDebugEnabled()) {
        LOG.debug("Class retrieved: {}", cl.getName());
      }

      for (Field field : cl.getDeclaredFields()) {
        DataField dataField = field.getAnnotation(DataField.class);
        if (dataField != null) {
          if (LOG.isDebugEnabled()) {
            LOG.debug(
                "Position defined in the class: {}, position: {}, Field: {}",
                new Object[] {cl.getName(), dataField.pos(), dataField});
          }

          if (dataField.required()) {
            ++numberMandatoryFields;
          } else {
            ++numberOptionalFields;
          }

          int pos = dataField.pos();
          if (annotatedFields.containsKey(pos)) {
            Field f = annotatedFields.get(pos);
            LOG.warn(
                "Potentially invalid model: existing @DataField '{}' replaced by '{}'",
                f.getName(),
                field.getName());
          }
          dataFields.put(pos, dataField);
          annotatedFields.put(pos, field);
          maxpos = Math.max(maxpos, pos);
        }

        Link linkField = field.getAnnotation(Link.class);

        if (linkField != null) {
          if (LOG.isDebugEnabled()) {
            LOG.debug("Class linked: {}, Field: {}", cl.getName(), field);
          }
          linkFields.add(field);
        }
      }

      if (!linkFields.isEmpty()) {
        annotatedLinkFields.put(cl.getName(), linkFields);
      }

      totalFields = numberMandatoryFields + numberOptionalFields;

      if (LOG.isDebugEnabled()) {
        LOG.debug("Number of optional fields: {}", numberOptionalFields);
        LOG.debug("Number of mandatory fields: {}", numberMandatoryFields);
        LOG.debug("Total: {}", totalFields);
      }
    }

    if (annotatedFields.size() < maxpos) {
      LOG.info(
          "Potentially incomplete model: some csv fields may not be mapped to @DataField members");
    }
  }
Beispiel #4
0
  /**
   * Generate a table containing the data formatted and sorted with their position/offset If the
   * model is Ordered than a key is created combining the annotation @Section and Position of the
   * field If a relation @OneToMany is defined, than we iterate recursively through this function
   * The result is placed in the Map<Integer, List> results
   */
  private void generateCsvPositionMap(
      Class<?> clazz, Object obj, Map<Integer, List<String>> results) throws Exception {

    String result = "";

    for (Field field : clazz.getDeclaredFields()) {

      field.setAccessible(true);

      DataField datafield = field.getAnnotation(DataField.class);

      if (datafield != null) {

        if (obj != null) {

          // Retrieve the format, pattern and precision associated to the type
          Class<?> type = field.getType();

          // Create format
          Format<?> format = FormatFactory.getFormat(type, getLocale(), datafield);

          // Get field value
          Object value = field.get(obj);

          result = formatString(format, value);

          if (datafield.trim()) {
            result = result.trim();
          }

          if (datafield.clip() && result.length() > datafield.length()) {
            result = result.substring(0, datafield.length());
          }

          if (LOG.isDebugEnabled()) {
            LOG.debug(
                "Value to be formatted: {}, position: {}, and its formatted value: {}",
                new Object[] {value, datafield.pos(), result});
          }

        } else {
          result = "";
        }

        Integer key;

        if (isMessageOrdered() && obj != null) {

          // Generate a key using the number of the section
          // and the position of the field
          Integer key1 = sections.get(obj.getClass().getName());
          Integer key2 = datafield.position();
          Integer keyGenerated = generateKey(key1, key2);

          if (LOG.isDebugEnabled()) {
            LOG.debug("Key generated: {}, for section: {}", String.valueOf(keyGenerated), key1);
          }

          key = keyGenerated;

        } else {
          key = datafield.pos();
        }

        if (!results.containsKey(key)) {
          List<String> list = new LinkedList<String>();
          list.add(result);
          results.put(key, list);
        } else {
          List<String> list = results.get(key);
          list.add(result);
        }
      }

      OneToMany oneToMany = field.getAnnotation(OneToMany.class);
      if (oneToMany != null) {

        // Set global variable
        // Will be used during generation of CSV
        isOneToMany = true;

        List<?> list = (List<?>) field.get(obj);
        if (list != null) {

          Iterator<?> it = list.iterator();
          while (it.hasNext()) {
            Object target = it.next();
            generateCsvPositionMap(target.getClass(), target, results);
          }

        } else {

          // Call this function to add empty value
          // in the table
          generateCsvPositionMap(field.getClass(), null, results);
        }
      }
    }
  }
Beispiel #5
0
  public void bind(List<String> tokens, Map<String, Object> model, int line) throws Exception {

    int pos = 1;
    int counterMandatoryFields = 0;

    for (String data : tokens) {

      // Get DataField from model
      DataField dataField = dataFields.get(pos);
      ObjectHelper.notNull(
          dataField, "No position " + pos + " defined for the field: " + data + ", line: " + line);

      if (dataField.trim()) {
        data = data.trim();
      }

      if (dataField.required()) {
        // Increment counter of mandatory fields
        ++counterMandatoryFields;

        // Check if content of the field is empty
        // This is not possible for mandatory fields
        if (data.equals("")) {
          throw new IllegalArgumentException(
              "The mandatory field defined at the position "
                  + pos
                  + " is empty for the line: "
                  + line);
        }
      }

      // Get Field to be setted
      Field field = annotatedFields.get(pos);
      field.setAccessible(true);

      if (LOG.isDebugEnabled()) {
        LOG.debug("Pos: {}, Data: {}, Field type: {}", new Object[] {pos, data, field.getType()});
      }

      // Create format object to format the field
      Format<?> format = FormatFactory.getFormat(field.getType(), getLocale(), dataField);

      // field object to be set
      Object modelField = model.get(field.getDeclaringClass().getName());

      // format the data received
      Object value = null;

      if (!data.equals("")) {
        try {
          value = format.parse(data);
        } catch (FormatException ie) {
          throw new IllegalArgumentException(
              ie.getMessage() + ", position: " + pos + ", line: " + line, ie);
        } catch (Exception e) {
          throw new IllegalArgumentException(
              "Parsing error detected for field defined at the position: "
                  + pos
                  + ", line: "
                  + line,
              e);
        }
      } else {
        if (!dataField.defaultValue().isEmpty()) {
          value = format.parse(dataField.defaultValue());
        } else {
          value = getDefaultValueForPrimitive(field.getType());
        }
      }

      field.set(modelField, value);

      ++pos;
    }

    LOG.debug("Counter mandatory fields: {}", counterMandatoryFields);

    if (counterMandatoryFields < numberMandatoryFields) {
      throw new IllegalArgumentException("Some mandatory fields are missing, line: " + line);
    }

    if (pos < totalFields) {
      setDefaultValuesForFields(model);
    }
  }