Java Code Examples for org.apache.lucene.document.DateTools#dateToString()

private Query createQuery(String field, DateOperator dop) throws UnsupportedSearchException {
    Date date = dop.getDate();
    DateResolution res = dop.getDateResultion();
    DateTools.Resolution dRes = toResolution(res);
    String value = DateTools.dateToString(date, dRes);
    switch (dop.getType()) {
    case ON:
        return new TermQuery(new Term(field, value));
    case BEFORE: 
        return new TermRangeQuery(field, DateTools.dateToString(MIN_DATE, dRes), value, true, false);
    case AFTER: 
        return new TermRangeQuery(field, value, DateTools.dateToString(MAX_DATE, dRes), false, true);
    default:
        throw new UnsupportedSearchException();
    }
}
 

/**
 * @param checkinIn the checkin to set
 */
public void setCheckin(Date checkinIn) {
    if (checkinIn != null) {
        this.checkin = DateTools.dateToString(checkinIn,
            DateTools.Resolution.MINUTE);
    }
    else {
        this.checkin = null;
    }
}
 

/**
 * @param registeredIn the registered to set
 */
public void setRegistered(Date registeredIn) {
    if (registeredIn != null) {
        this.registered = DateTools.dateToString(registeredIn,
            DateTools.Resolution.MINUTE);
    }
    else {
        this.registered = null;
    }
}
 

private void indexDocument(String aDocumentTitle, long aSourceDocumentId,
        long aAnnotationDocumentId, String aUser, byte[] aBinaryCas)
    throws IOException
{
    // Calculate timestamp that will be indexed
    String timestamp = DateTools.dateToString(new Date(), DateTools.Resolution.MILLISECOND);
    
    log.trace(
            "Indexing document in project [{}]({}). sourceId: {}, annotationId: {}, "
            + "user: {} timestamp: {}",
            project.getName(), project.getId(), aSourceDocumentId, aAnnotationDocumentId,
            aUser, timestamp);
    
    IndexWriter indexWriter = getIndexWriter();
    
    // Prepare bytearray with document content to be indexed
    String encodedCAS = new String(MtasUtils.bytesToChars(aBinaryCas));

    // Create new Lucene document
    Document doc = new Document();
    
    // Add indexed fields
    doc.add(new StringField(FIELD_ID, String.valueOf(aSourceDocumentId) + "/"
            + String.valueOf(aAnnotationDocumentId), Field.Store.YES));
    doc.add(new StringField(FIELD_SOURCE_DOCUMENT_ID, String.valueOf(aSourceDocumentId),
            Field.Store.YES));
    doc.add(new StringField(FIELD_ANNOTATION_DOCUMENT_ID,
            String.valueOf(aAnnotationDocumentId), Field.Store.YES));
    doc.add(new StringField(FIELD_TITLE, aDocumentTitle, Field.Store.YES));
    doc.add(new StringField(FIELD_USER, aUser, Field.Store.YES));
    doc.add(new StringField(FIELD_TIMESTAMP, timestamp, Field.Store.YES));
    doc.add(new TextField(FIELD_CONTENT, encodedCAS, Field.Store.NO));

    // Add document to the Lucene index
    indexWriter.addDocument(doc);

    scheduleCommit();
}
 

/**
 * @param checkinIn the checkin to set
 */
public void setCheckin(Date checkinIn) {
    if (checkinIn != null) {
        this.checkin = DateTools.dateToString(checkinIn,
            DateTools.Resolution.MINUTE);
    }
    else {
        this.checkin = null;
    }
}
 

/**
 * @param registeredIn the registered to set
 */
public void setRegistered(Date registeredIn) {
    if (registeredIn != null) {
        this.registered = DateTools.dateToString(registeredIn,
            DateTools.Resolution.MINUTE);
    }
    else {
        this.registered = null;
    }
}
 

@Override
protected QueryNode postProcessNode(QueryNode node) throws QueryNodeException {
  
  if (node instanceof TermRangeQueryNode) {
    TermRangeQueryNode termRangeNode = (TermRangeQueryNode) node;
    FieldQueryNode upper = termRangeNode.getUpperBound();
    FieldQueryNode lower = termRangeNode.getLowerBound();
    
    DateTools.Resolution dateRes = null;
    boolean inclusive = false;
    Locale locale = getQueryConfigHandler().get(ConfigurationKeys.LOCALE);
    
    if (locale == null) {
      locale = Locale.getDefault();
    }
    
    TimeZone timeZone = getQueryConfigHandler().get(ConfigurationKeys.TIMEZONE);
    
    if (timeZone == null) {
      timeZone = TimeZone.getDefault();
    }
    
    CharSequence field = termRangeNode.getField();
    String fieldStr = null;
    
    if (field != null) {
      fieldStr = field.toString();
    }
    
    FieldConfig fieldConfig = getQueryConfigHandler()
        .getFieldConfig(fieldStr);
    
    if (fieldConfig != null) {
      dateRes = fieldConfig.get(ConfigurationKeys.DATE_RESOLUTION);
    }
    
    if (termRangeNode.isUpperInclusive()) {
      inclusive = true;
    }
    
    String part1 = lower.getTextAsString();
    String part2 = upper.getTextAsString();
    
    try {
      DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT, locale);
      df.setLenient(true);
      
      if (part1.length() > 0) {
        Date d1 = df.parse(part1);
        part1 = DateTools.dateToString(d1, dateRes);
        lower.setText(part1);
      }
      
      if (part2.length() > 0) {
        Date d2 = df.parse(part2);
        if (inclusive) {
          // The user can only specify the date, not the time, so make sure
          // the time is set to the latest possible time of that date to
          // really
          // include all documents:
          Calendar cal = Calendar.getInstance(timeZone, locale);
          cal.setTime(d2);
          cal.set(Calendar.HOUR_OF_DAY, 23);
          cal.set(Calendar.MINUTE, 59);
          cal.set(Calendar.SECOND, 59);
          cal.set(Calendar.MILLISECOND, 999);
          d2 = cal.getTime();
        }
        
        part2 = DateTools.dateToString(d2, dateRes);
        upper.setText(part2);
        
      }
      
    } catch (Exception e) {
      // not a date
      Analyzer analyzer = getQueryConfigHandler().get(ConfigurationKeys.ANALYZER);
      if (analyzer != null) {
        // because we call utf8ToString, this will only work with the default TermToBytesRefAttribute
        part1 = analyzer.normalize(lower.getFieldAsString(), part1).utf8ToString();
        part2 = analyzer.normalize(lower.getFieldAsString(), part2).utf8ToString();
        lower.setText(part1);
        upper.setText(part2);
      }
    }
    
  }
  
  return node;
  
}
 

public String getDate(String s) throws Exception {
  // we use the default Locale since LuceneTestCase randomizes it
  DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT, Locale.getDefault());
  return DateTools.dateToString(df.parse(s), DateTools.Resolution.DAY);
}
 

/** for testing DateTools support */
private String getDate(Date d, DateTools.Resolution resolution) {
  return DateTools.dateToString(d, resolution);
}
 

/** for testing DateTools support */
private String getDate(Date d, DateTools.Resolution resolution) {
  return DateTools.dateToString(d, resolution);
}
 

/** for testing DateTools support */
private String getDate(Date d, DateTools.Resolution resolution) {
   return DateTools.dateToString(d, resolution);
}
 

@Override
public String toString(final Date value) {
    return value != null ? DateTools.dateToString(value, Resolution.MILLISECOND) : null;
}