org.opengis.filter.temporal.After Java Examples

@Override
public Object visit(final After after, final Object data) {
  final TemporalConstraints leftResult = btime(after.getExpression1().accept(this, data));
  final TemporalConstraints rightResult = btime(after.getExpression2().accept(this, data));

  if (leftResult.isEmpty() || rightResult.isEmpty()) {
    return new TemporalConstraints();
  }

  // property after value
  if (leftResult instanceof ParameterTimeConstraint) {
    return new ParameterTimeConstraint(
        new TemporalRange(
            rightResult.getMaxOr(TemporalRange.START_TIME, 1),
            TemporalRange.END_TIME),
        leftResult.getName());
  } else if (rightResult instanceof ParameterTimeConstraint) {
    return new ParameterTimeConstraint(
        new TemporalRange(
            TemporalRange.START_TIME,
            leftResult.getMinOr(TemporalRange.END_TIME, -1)),
        rightResult.getName());
  }
  // property after property
  return new TemporalConstraints();
}
 

public ElasticCapabilities() {
    super(new ElasticFilterCapabilities());

    addAll(LOGICAL_OPENGIS);
    addAll(SIMPLE_COMPARISONS_OPENGIS);
    addType(PropertyIsNull.class);
    addType(PropertyIsBetween.class);
    addType(Id.class);
    addType(IncludeFilter.class);
    addType(ExcludeFilter.class);
    addType(PropertyIsLike.class);

    // spatial filters
    addType(BBOX.class);
    addType(Contains.class);
    //addType(Crosses.class);
    addType(Disjoint.class);
    //addType(Equals.class);
    addType(Intersects.class);
    //addType(Overlaps.class);
    //addType(Touches.class);
    addType(Within.class);
    addType(DWithin.class);
    addType(Beyond.class);

    //temporal filters
    addType(After.class);
    addType(Before.class);
    addType(Begins.class);
    addType(BegunBy.class);
    addType(During.class);
    addType(Ends.class);
    addType(EndedBy.class);
    addType(TContains.class);
    addType(TEquals.class);
}
 

@Test
public void testTemporalStringLiteral() {
    After filter = ff.after(ff.property("dateAttr"), ff.literal("1970-01-01T00:00:00.000Z"));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttr", ImmutableMap.of("gt", "1970-01-01T00:00:00.000Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testNestedTemporalStringLiteral() {
    After filter = ff.after(ff.property("nested.datehej"), ff.literal("1970-01-01T00:00:00.000Z"));
    Map<String,Object> expectedFilter = ImmutableMap.of("range",
            ImmutableMap.of("nested.datehej", ImmutableMap.of("gt", "1970-01-01T00:00:00.000Z")));
    Map<String,Object> expected = ImmutableMap.of("nested",
            ImmutableMap.of("path", "nested", "query", expectedFilter));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testTemporalInstantLiteralDefaultFormat() throws ParseException {
    dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date date1 = dateFormat.parse("1970-07-19");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    After filter = ff.after(ff.property("dateAttr"), ff.literal(temporalInstant));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttr", ImmutableMap.of("gt", "1970-07-19T00:00:00.000Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testTemporalInstanceLiteralExplicitFormat() throws ParseException {
    addDateWithFormatToFeatureType("yyyy-MM-dd");
    dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456-0100");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    After filter = ff.after(ff.property("dateAttrWithFormat"), ff.literal(temporalInstant));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttrWithFormat", ImmutableMap.of("gt", "1970-07-19")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testTemporalInstanceLiteralBasicDateTimeFormat() throws ParseException {
    addDateWithFormatToFeatureType("basic_date_time");
    dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456-0100");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    After filter = ff.after(ff.property("dateAttrWithFormat"), ff.literal(temporalInstant));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttrWithFormat", ImmutableMap.of("gt", "19700719T020203.456Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testAfterFilter() throws ParseException {
    dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456-0100");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    After filter = ff.after(ff.property("dateAttr"), ff.literal(temporalInstant));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttr", ImmutableMap.of("gt", "1970-07-19T02:02:03.456Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testAfterFilterSwapped() throws ParseException {
    dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456-0100");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    After filter = ff.after(ff.literal(temporalInstant), ff.property("dateAttr"));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttr", ImmutableMap.of("lt", "1970-07-19T02:02:03.456Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testAfterFilterPeriod() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);
    After filter = ff.after(ff.property("dateAttr"), ff.literal(period));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttr", ImmutableMap.of("gt", "1970-07-19T07:08:09.101Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Test
public void testAfterFilterPeriodSwapped() throws ParseException {
    Date date1 = dateFormat.parse("1970-07-19T01:02:03.456Z");
    Instant temporalInstant = new DefaultInstant(new DefaultPosition(date1));
    Date date2 = dateFormat.parse("1970-07-19T07:08:09.101Z");
    Instant temporalInstant2 = new DefaultInstant(new DefaultPosition(date2));
    Period period = new DefaultPeriod(temporalInstant, temporalInstant2);
    After filter = ff.after(ff.literal(period), ff.property("dateAttr"));
    Map<String,Object> expected = ImmutableMap.of("range",
            ImmutableMap.of("dateAttr", ImmutableMap.of("lt", "1970-07-19T01:02:03.456Z")));

    builder.visit(filter, null);
    assertTrue(builder.createCapabilities().fullySupports(filter));
    assertEquals(expected, builder.getQueryBuilder());
}
 

@Override
public Object visit(final After after, final Object extraData) {
  if (!usesProperty(after)) {
    return Filter.INCLUDE;
  }
  return super.visit(after, extraData);
}
 

@Override
public Object visit(final After after, final Object extraData) {
  if (!usesProperty(after)) {
    return Filter.INCLUDE;
  }
  return super.visit(after, extraData);
}
 

/** {@inheritDoc} */
@Override
public Object visit(After after, Object extraData) {
	String propertyName = getPropertyName(after.getExpression1());
	String finalName = parsePropertyName(propertyName, after);
	Object literal = getLiteralValue(after.getExpression2());
	if (literal instanceof Date) {
		return Restrictions.gt(finalName, literal);
	} else {
		throw new UnsupportedOperationException("visit(Object userData)");
	}
}
 

@Test
public void testVisitAfter() throws GeomajasException {
	Filter f = filterService.parseFilter("myDate AFTER 2006-11-30T01:30:00Z");
	Criterion c = (Criterion) (new CriteriaVisitor((HibernateFeatureModel) layer.getFeatureModel(),
			DateFormat.getDateTimeInstance()).visit((After) f, null));
	Date date = ISODateTimeFormat.dateTimeNoMillis().parseDateTime("2006-11-30T01:30:00Z").toDate();
	Assert.assertEquals("myDate>" + date, c.toString());
}
 

public Object visit(After after, Object extraData) {
    return visitBinaryTemporalOperator(after, extraData);
}