diff --git a/openbis/source/java/ch/systemsx/cisd/openbis/generic/server/dataaccess/db/search/detailed/DateRangeCalculator.java b/openbis/source/java/ch/systemsx/cisd/openbis/generic/server/dataaccess/db/search/detailed/DateRangeCalculator.java
new file mode 100644
index 0000000000000000000000000000000000000000..b91ad9d53799c958637f06be6e050a8b0d74946c
--- /dev/null
+++ b/openbis/source/java/ch/systemsx/cisd/openbis/generic/server/dataaccess/db/search/detailed/DateRangeCalculator.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2014 ETH Zuerich, Scientific IT Services
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ch.systemsx.cisd.openbis.generic.server.dataaccess.db.search.detailed;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.TimeZone;
+
+import org.apache.commons.lang.time.DateUtils;
+
+import ch.systemsx.cisd.common.exceptions.UserFailureException;
+import ch.systemsx.cisd.openbis.generic.shared.basic.dto.CompareType;
+import ch.systemsx.cisd.openbis.generic.shared.basic.dto.DetailedSearchCriterion;
+
+/**
+ * @author pkupczyk
+ */
+public class DateRangeCalculator
+{
+
+ private static final String FORMAT_WITHOUT_TIME = "y-M-d";
+
+ private static final String FORMAT_WITH_MINUTES = "y-M-d HH:mm";
+
+ private static final String FORMAT_WITH_SECONDS = "y-M-d HH:mm:ss";
+
+ private static final String[] DATE_FORMATS = { FORMAT_WITH_SECONDS, FORMAT_WITH_MINUTES, FORMAT_WITHOUT_TIME };
+
+ private Date upper;
+
+ private Date lower;
+
+ public DateRangeCalculator(String date, String timeZone, CompareType compareType)
+ {
+ lower = parseDate(date);
+
+ if (CompareType.EQUALS.equals(compareType))
+ {
+ if (isDateWithTime(date))
+ {
+ makeDateGMT(lower, timeZone);
+ lower = new Date(lower.getTime() - (lower.getTime() % DateUtils.MILLIS_PER_DAY));
+ }
+ upper = new Date(lower.getTime() + DateUtils.MILLIS_PER_DAY);
+ } else if (CompareType.LESS_THAN_OR_EQUAL.equals(compareType))
+ {
+ if (isDateWithoutTime(date))
+ {
+ upper = new Date(lower.getTime() + DateUtils.MILLIS_PER_DAY);
+ } else
+ {
+ makeDateGMT(lower, timeZone);
+ upper = new Date(lower.getTime());
+ }
+ lower = new Date(0);
+ } else if (CompareType.MORE_THAN_OR_EQUAL.equals(compareType))
+ {
+ if (isDateWithTime(date))
+ {
+ makeDateGMT(lower, timeZone);
+ }
+ upper = new Date(Long.MAX_VALUE);
+ }
+ }
+
+ public Date getLowerDate()
+ {
+ return lower;
+ }
+
+ public Date getUpperDate()
+ {
+ return upper;
+ }
+
+ private Date parseDate(String dateAsString)
+ {
+ for (String format : DATE_FORMATS)
+ {
+ Date date = parseDate(dateAsString, format);
+ if (date != null)
+ {
+ return date;
+ }
+ }
+ throw new UserFailureException("Couldn't parse date '" + dateAsString
+ + "'. It has to match one of the following formats: " + Arrays.asList(DATE_FORMATS));
+ }
+
+ private Date parseDate(String dateAsString, String formatAsString)
+ {
+ SimpleDateFormat format = new SimpleDateFormat(formatAsString);
+ format.setTimeZone(TimeZone.getTimeZone("GMT"));
+
+ try
+ {
+ return format.parse(dateAsString);
+ } catch (ParseException ex)
+ {
+ return null;
+ }
+ }
+
+ private void makeDateGMT(Date date, String timeZone)
+ {
+ int offset = getTimeZoneOffset(timeZone, date);
+ date.setTime(date.getTime() + offset);
+ }
+
+ private int getTimeZoneOffset(String timeZone, Date date)
+ {
+ if (timeZone.equals(DetailedSearchCriterion.SERVER_TIMEZONE))
+ {
+ return -TimeZone.getDefault().getOffset(date.getTime());
+ }
+
+ String offset = timeZone;
+ if (timeZone.startsWith("+"))
+ {
+ offset = timeZone.substring(1);
+ } else if (timeZone.equals("Z"))
+ {
+ offset = "0";
+ }
+
+ try
+ {
+ return (int) (-Double.parseDouble(offset) * DateUtils.MILLIS_PER_HOUR);
+ } catch (NumberFormatException e)
+ {
+ return 0;
+ }
+ }
+
+ private boolean isDateWithTime(String dateAsString)
+ {
+ return parseDate(dateAsString, FORMAT_WITH_MINUTES) != null || parseDate(dateAsString, FORMAT_WITH_SECONDS) != null;
+ }
+
+ private boolean isDateWithoutTime(String dateAsString)
+ {
+ return false == isDateWithTime(dateAsString);
+ }
+
+}
diff --git a/openbis/source/java/ch/systemsx/cisd/openbis/generic/server/dataaccess/db/search/detailed/DetailedQueryBuilder.java b/openbis/source/java/ch/systemsx/cisd/openbis/generic/server/dataaccess/db/search/detailed/DetailedQueryBuilder.java
index 2c0843ec20c2f155450cdef3dcd09e937ba4d678..97030146d995b9cbfaa1fbb9b116a8aa5d55d60f 100644
--- a/openbis/source/java/ch/systemsx/cisd/openbis/generic/server/dataaccess/db/search/detailed/DetailedQueryBuilder.java
+++ b/openbis/source/java/ch/systemsx/cisd/openbis/generic/server/dataaccess/db/search/detailed/DetailedQueryBuilder.java
@@ -16,15 +16,12 @@
package ch.systemsx.cisd.openbis.generic.server.dataaccess.db.search.detailed;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Date;
import java.util.EnumSet;
import java.util.List;
-import java.util.TimeZone;
+import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.search.BooleanClause.Occur;
@@ -59,8 +56,6 @@ import ch.systemsx.cisd.openbis.generic.shared.search.IgnoreCaseAnalyzer;
*/
public class DetailedQueryBuilder
{
- private static final String[] DATE_FORMATS =
- { "y-M-d HH:mm:ss", "y-M-d HH:mm", "y-M-d" };
private final static Logger operationLog = LogFactory.getLogger(LogCategory.OPERATION,
DetailedQueryBuilder.class);
@@ -139,30 +134,16 @@ public class DetailedQueryBuilder
resultQuery.add(luceneQuery, occureCondition);
} else
{
- Date lower = parseDate(criterion.getValue());
- int offset = getTimeZoneOffset(criterion, lower);
-
- lower.setTime(lower.getTime() + offset);
- Date upper = new Date(lower.getTime() + 24 * 3600 * 1000);
-
- switch (criterion.getType())
+ if (false == StringUtils.isEmpty(criterion.getValue()))
{
- case EQUALS:
- break;
- case LESS_THAN_OR_EQUAL:
- lower = new Date(0);
- break;
- case MORE_THAN_OR_EQUAL:
- upper = new Date(Long.MAX_VALUE);
- break;
+ DateRangeCalculator rangeCalculator = new DateRangeCalculator(criterion.getValue(), criterion.getTimeZone(), criterion.getType());
+ String fieldName = fieldNames.get(0);
+ DateBridge bridge = new DateBridge(Resolution.SECOND);
+ TermRangeQuery q =
+ new TermRangeQuery(fieldName, bridge.objectToString(rangeCalculator.getLowerDate()),
+ bridge.objectToString(rangeCalculator.getUpperDate()), true, true);
+ resultQuery.add(q, occureCondition);
}
-
- String fieldName = fieldNames.get(0);
- DateBridge bridge = new DateBridge(Resolution.SECOND);
- TermRangeQuery q =
- new TermRangeQuery(fieldName, bridge.objectToString(lower),
- bridge.objectToString(upper), true, true);
- resultQuery.add(q, occureCondition);
}
}
for (DetailedSearchAssociationCriteria association : associations)
@@ -176,52 +157,6 @@ public class DetailedQueryBuilder
return resultQuery;
}
- private int getTimeZoneOffset(DetailedSearchCriterion criterion, Date lower)
- {
- String tzs = criterion.getTimeZone();
- if (tzs.equals(DetailedSearchCriterion.SERVER_TIMEZONE))
- {
- return -TimeZone.getDefault().getOffset(lower.getTime());
- }
-
- if (tzs.startsWith("+"))
- {
- tzs = tzs.substring(1);
- } else if (tzs.equals("Z"))
- {
- tzs = "0";
- }
-
- int offset;
- try
- {
- offset = (int) (-Double.parseDouble(tzs) * 3600000);
- } catch (NumberFormatException e)
- {
- offset = 0;
- }
- return offset;
- }
-
- private Date parseDate(String dateAsString)
- {
- for (String format : DATE_FORMATS)
- {
- SimpleDateFormat sdf = new SimpleDateFormat(format);
- sdf.setTimeZone(TimeZone.getTimeZone("GMT"));
-
- try
- {
- return sdf.parse(dateAsString);
- } catch (ParseException ex)
- {
- // ignore, try next format
- }
- }
- throw new UserFailureException("Couldn't parse date '" + dateAsString
- + "'. It has to match one of the following formats: " + Arrays.asList(DATE_FORMATS));
- }
-
private List<String> extractAssociationPatterns(DetailedSearchAssociationCriteria association)
{
List<String> result = new ArrayList<String>();
diff --git a/openbis/source/java/ch/systemsx/cisd/openbis/generic/shared/dto/EntityPropertyPE.java b/openbis/source/java/ch/systemsx/cisd/openbis/generic/shared/dto/EntityPropertyPE.java
index d3a117a9bb8519f4953998d8e5c670bba215f367..3e7ddec15659909d668e0616714ddfcd6b7f666b 100644
--- a/openbis/source/java/ch/systemsx/cisd/openbis/generic/shared/dto/EntityPropertyPE.java
+++ b/openbis/source/java/ch/systemsx/cisd/openbis/generic/shared/dto/EntityPropertyPE.java
@@ -16,6 +16,8 @@
package ch.systemsx.cisd.openbis.generic.shared.dto;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
import java.util.Date;
import javax.persistence.Column;
@@ -33,17 +35,21 @@ import org.apache.lucene.document.Field;
import org.hibernate.search.annotations.ClassBridge;
import org.hibernate.search.annotations.Index;
import org.hibernate.search.annotations.IndexedEmbedded;
+import org.hibernate.search.annotations.Resolution;
import org.hibernate.search.annotations.Store;
import org.hibernate.search.bridge.FieldBridge;
import org.hibernate.search.bridge.LuceneOptions;
+import org.hibernate.search.bridge.builtin.DateBridge;
import ch.systemsx.cisd.common.reflection.ClassUtils;
import ch.systemsx.cisd.common.reflection.ModifiedShortPrefixToStringStyle;
import ch.systemsx.cisd.openbis.generic.shared.IServer;
+import ch.systemsx.cisd.openbis.generic.shared.basic.dto.DataTypeCode;
import ch.systemsx.cisd.openbis.generic.shared.basic.dto.MaterialIdentifier;
import ch.systemsx.cisd.openbis.generic.shared.dto.hibernate.SearchFieldConstants;
import ch.systemsx.cisd.openbis.generic.shared.dto.properties.EntityKind;
import ch.systemsx.cisd.openbis.generic.shared.util.EqualsHashUtils;
+import ch.systemsx.cisd.openbis.generic.shared.util.SimplePropertyValidator.SupportedDatePattern;
/**
* Persistence entity representing entity property.
@@ -77,8 +83,8 @@ public abstract class EntityPropertyPE extends HibernateAbstractRegistrationHold
private VocabularyTermPE vocabularyTerm;
/**
- * If the property is of MATERIAL, this field is not <code>null</code> and {@link #value} and
- * {@link #vocabularyTerm} fields are set to <code>null</code>.
+ * If the property is of MATERIAL, this field is not <code>null</code> and {@link #value} and {@link #vocabularyTerm} fields are set to
+ * <code>null</code>.
*/
private MaterialPE material;
@@ -97,20 +103,41 @@ public abstract class EntityPropertyPE extends HibernateAbstractRegistrationHold
private Date modificationDate;
/**
- * This bridge allows to save in the search index not only the value of property, but also the
- * corresponding property code.
+ * This bridge allows to save in the search index not only the value of property, but also the corresponding property code.
*/
public static class EntityPropertySearchBridge implements FieldBridge
{
+ private static SimpleDateFormat dateFormat;
+
+ static
+ {
+ dateFormat = new SimpleDateFormat(SupportedDatePattern.CANONICAL_DATE_PATTERN.getPattern());
+ }
+
@Override
public void set(String name, Object/* EntityPropertyPE */value,
Document/* Lucene document */document, LuceneOptions luceneOptions)
{
EntityPropertyPE entityProperty = (EntityPropertyPE) value;
+
String fieldValue = entityProperty.tryGetUntypedValue();
String fieldPrefix = name;
String fieldFullName = fieldPrefix + getPropertyFieldName(entityProperty);
+
+ if (DataTypeCode.TIMESTAMP.equals(entityProperty.getEntityTypePropertyType().getPropertyType().getType().getCode()))
+ {
+ try
+ {
+ Date date = dateFormat.parse(fieldValue);
+ DateBridge dateBridge = new DateBridge(Resolution.SECOND);
+ fieldValue = dateBridge.objectToString(date);
+ } catch (ParseException e)
+ {
+ // leave the original value
+ }
+ }
+
Field field =
new Field(fieldFullName, fieldValue, luceneOptions.getStore(),
luceneOptions.getIndex());
@@ -228,9 +255,7 @@ public abstract class EntityPropertyPE extends HibernateAbstractRegistrationHold
/**
* Sets the <var>entity</var> of this property.
* <p>
- * <i>Do not use directly, instead, call
- * {@link IEntityPropertiesHolder#addProperty(EntityPropertyPE)} with <code>this</code>
- * object!</i>
+ * <i>Do not use directly, instead, call {@link IEntityPropertiesHolder#addProperty(EntityPropertyPE)} with <code>this</code> object!</i>
*/
void setEntity(final IEntityPropertiesHolder entity)
{
diff --git a/openbis/sourceTest/java/ch/ethz/sis/openbis/systemtest/api/v3/SearchExperimentTest.java b/openbis/sourceTest/java/ch/ethz/sis/openbis/systemtest/api/v3/SearchExperimentTest.java
index f3f31bb77c3def4f39baedf97243321583709a6f..a9e7bec7a625b66243668bf7fb125dbaafe1f00d 100644
--- a/openbis/sourceTest/java/ch/ethz/sis/openbis/systemtest/api/v3/SearchExperimentTest.java
+++ b/openbis/sourceTest/java/ch/ethz/sis/openbis/systemtest/api/v3/SearchExperimentTest.java
@@ -247,6 +247,54 @@ public class SearchExperimentTest extends AbstractExperimentTest
testSearch(TEST_USER, criterion, "/CISD/NEMO/EXP-TEST-1");
}
+ @Test
+ public void testSearchWithDatePropertyThatEquals()
+ {
+ ExperimentSearchCriterion criterion = new ExperimentSearchCriterion();
+ criterion.withDateProperty("PURCHASE_DATE").withTimeZone(0).thatEquals("2009-02-08");
+ testSearch(TEST_USER, criterion, 0);
+
+ criterion = new ExperimentSearchCriterion();
+ criterion.withDateProperty("PURCHASE_DATE").withTimeZone(0).thatEquals("2009-02-09");
+ testSearch(TEST_USER, criterion, "/CISD/NEMO/EXP-TEST-2", "/TEST-SPACE/NOE/EXP-TEST-2");
+
+ criterion = new ExperimentSearchCriterion();
+ criterion.withDateProperty("PURCHASE_DATE").withTimeZone(0).thatEquals("2009-02-10");
+ testSearch(TEST_USER, criterion, 0);
+ }
+
+ @Test
+ public void testSearchWithDatePropertyThatIsEarlierThanOrEqualTo()
+ {
+ ExperimentSearchCriterion criterion = new ExperimentSearchCriterion();
+ criterion.withDateProperty("PURCHASE_DATE").withTimeZone(0).thatIsEarlierThanOrEqualTo("2009-02-09 08:59:59");
+ testSearch(TEST_USER, criterion, 0);
+
+ criterion = new ExperimentSearchCriterion();
+ criterion.withDateProperty("PURCHASE_DATE").withTimeZone(0).thatIsEarlierThanOrEqualTo("2009-02-09 09:00:00");
+ testSearch(TEST_USER, criterion, "/CISD/NEMO/EXP-TEST-2");
+
+ criterion = new ExperimentSearchCriterion();
+ criterion.withDateProperty("PURCHASE_DATE").withTimeZone(0).thatIsEarlierThanOrEqualTo("2009-02-09");
+ testSearch(TEST_USER, criterion, "/CISD/NEMO/EXP-TEST-2", "/TEST-SPACE/NOE/EXP-TEST-2");
+ }
+
+ @Test
+ public void testSearchWithDatePropertyThatIsLasterThanOrEqualTo()
+ {
+ ExperimentSearchCriterion criterion = new ExperimentSearchCriterion();
+ criterion.withDateProperty("PURCHASE_DATE").withTimeZone(0).thatIsLaterThanOrEqualTo("2009-02-09 23:00:01");
+ testSearch(TEST_USER, criterion, 0);
+
+ criterion = new ExperimentSearchCriterion();
+ criterion.withDateProperty("PURCHASE_DATE").withTimeZone(0).thatIsLaterThanOrEqualTo("2009-02-09 23:00:00");
+ testSearch(TEST_USER, criterion, "/TEST-SPACE/NOE/EXP-TEST-2");
+
+ criterion = new ExperimentSearchCriterion();
+ criterion.withDateProperty("PURCHASE_DATE").withTimeZone(0).thatIsLaterThanOrEqualTo("2009-02-09");
+ testSearch(TEST_USER, criterion, "/CISD/NEMO/EXP-TEST-2", "/TEST-SPACE/NOE/EXP-TEST-2");
+ }
+
@Test
public void testSearchWithAnyPropertyThatEquals()
{
diff --git a/openbis/sourceTest/java/ch/systemsx/cisd/openbis/generic/server/dataaccess/db/search/detailed/DateRangeCalculatorTest.java b/openbis/sourceTest/java/ch/systemsx/cisd/openbis/generic/server/dataaccess/db/search/detailed/DateRangeCalculatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6507050595a67f5939dcc09c1036d1dd78e2ff6
--- /dev/null
+++ b/openbis/sourceTest/java/ch/systemsx/cisd/openbis/generic/server/dataaccess/db/search/detailed/DateRangeCalculatorTest.java
@@ -0,0 +1,251 @@
+package ch.systemsx.cisd.openbis.generic.server.dataaccess.db.search.detailed;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.TimeZone;
+
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import ch.systemsx.cisd.common.exceptions.UserFailureException;
+import ch.systemsx.cisd.openbis.generic.shared.basic.dto.CompareType;
+
+/**
+ * @author pkupczyk
+ */
+public class DateRangeCalculatorTest
+{
+
+ @Test(expectedExceptions = UserFailureException.class, expectedExceptionsMessageRegExp = "Couldn't parse date 'this should be a date'.*")
+ public void testIncorrectDateFormat()
+ {
+ new DateRangeCalculator("this should be a date", "0", CompareType.EQUALS);
+ }
+
+ @Test
+ public void testIncorrectTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 00:59", "this should be a time zone", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-14 00:59:00.000");
+ }
+
+ @Test
+ public void testZeroTimeZoneOffsetWithZCharacter()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 00:59", "Z", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-14 00:59:00.000");
+ }
+
+ @Test
+ public void testPositiveTimeZoneOffsetWithPlusSign()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 00:59", "+1", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-13 23:59:00.000");
+ }
+
+ @Test
+ public void testEqualToDateWithoutTimeWithZeroTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "0", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testEqualToDateWithoutTimeWithPositiveTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "+1", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testEqualToDateWithoutTimeWithNegativeTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "-1", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testEqualToDateWithoutTimeWithServerTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "server", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testEqualToDateWithTimeWithZeroTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 23:59", "0", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "2014-11-15 00:00:00.000");
+
+ calculator = new DateRangeCalculator("2014-11-14 00:01", "0", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testEqualToDateWithTimeWithPositiveTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 00:59", "1", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-13 00:00:00.000", "2014-11-14 00:00:00.000");
+
+ calculator = new DateRangeCalculator("2014-11-14 01:01", "1", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testEqualToDateWithTimeWithNegativeTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 22:59", "-1", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "2014-11-15 00:00:00.000");
+
+ calculator = new DateRangeCalculator("2014-11-14 23:01", "-1", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-15 00:00:00.000", "2014-11-16 00:00:00.000");
+ }
+
+ @Test
+ public void testEqualToDateWithTimeWithServerTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 00:59", "server", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-13 00:00:00.000", "2014-11-14 00:00:00.000");
+
+ calculator = new DateRangeCalculator("2014-11-14 01:01", "server", CompareType.EQUALS);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testLessThanOrEqualToDateWithoutTimeWithZeroTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "0", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testLessThanOrEqualToDateWithoutTimeWithPositiveTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "1", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testLessThanOrEqualToDateWithoutTimeWithNegativeTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "-1", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testLessThanOrEqualToDateWithoutTimeWithServerTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "server", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-15 00:00:00.000");
+ }
+
+ @Test
+ public void testLessThanOrEqualToDateWithTimeWithZeroTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 14:37", "0", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-14 14:37:00.000");
+ }
+
+ @Test
+ public void testLessThanOrEqualToDateWithTimeWithPositiveTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 14:37", "1", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-14 13:37:00.000");
+
+ calculator = new DateRangeCalculator("2014-11-14 00:59", "1", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-13 23:59:00.000");
+ }
+
+ @Test
+ public void testLessThanOrEqualToDateWithTimeWithNegativeTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 14:37", "-1", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-14 15:37:00.000");
+
+ calculator = new DateRangeCalculator("2014-11-14 23:59", "-1", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-15 00:59:00.000");
+ }
+
+ @Test
+ public void testLessThanOrEqualToDateWithTimeWithServerTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 14:37", "server", CompareType.LESS_THAN_OR_EQUAL);
+ assertDates(calculator, "1970-01-01 00:00:00.000", "2014-11-14 13:37:00.000");
+ }
+
+ @Test
+ public void testMoreThanOrEqualToDateWithoutTimeWithZeroTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "0", CompareType.MORE_THAN_OR_EQUAL);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "292278994-08-17 07:12:55.807");
+ }
+
+ @Test
+ public void testMoreThanOrEqualToDateWithoutTimeWithPositiveTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "1", CompareType.MORE_THAN_OR_EQUAL);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "292278994-08-17 07:12:55.807");
+ }
+
+ @Test
+ public void testMoreThanOrEqualToDateWithoutTimeWithNegativeTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "-1", CompareType.MORE_THAN_OR_EQUAL);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "292278994-08-17 07:12:55.807");
+ }
+
+ @Test
+ public void testMoreThanOrEqualToDateWithoutTimeWithServerTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14", "server", CompareType.MORE_THAN_OR_EQUAL);
+ assertDates(calculator, "2014-11-14 00:00:00.000", "292278994-08-17 07:12:55.807");
+ }
+
+ @Test
+ public void testMoreThanOrEqualToDateWithTimeWithZeroTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 14:37", "0", CompareType.MORE_THAN_OR_EQUAL);
+ assertDates(calculator, "2014-11-14 14:37:00.000", "292278994-08-17 07:12:55.807");
+ }
+
+ @Test
+ public void testMoreThanOrEqualToDateWithTimeWithPositiveTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 14:37", "1", CompareType.MORE_THAN_OR_EQUAL);
+ assertDates(calculator, "2014-11-14 13:37:00.000", "292278994-08-17 07:12:55.807");
+
+ calculator = new DateRangeCalculator("2014-11-14 00:59", "1", CompareType.MORE_THAN_OR_EQUAL);
+ assertDates(calculator, "2014-11-13 23:59:00.000", "292278994-08-17 07:12:55.807");
+ }
+
+ @Test
+ public void testMoreThanOrEqualToDateWithTimeWithNegativeTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 14:37", "-1", CompareType.MORE_THAN_OR_EQUAL);
+ assertDates(calculator, "2014-11-14 15:37:00.000", "292278994-08-17 07:12:55.807");
+
+ calculator = new DateRangeCalculator("2014-11-14 23:59", "-1", CompareType.MORE_THAN_OR_EQUAL);
+ assertDates(calculator, "2014-11-15 00:59:00.000", "292278994-08-17 07:12:55.807");
+ }
+
+ @Test
+ public void testMoreThanOrEqualToDateWithTimeWithServerTimeZoneOffset()
+ {
+ DateRangeCalculator calculator = new DateRangeCalculator("2014-11-14 14:37", "server", CompareType.MORE_THAN_OR_EQUAL);
+ assertDates(calculator, "2014-11-14 13:37:00.000", "292278994-08-17 07:12:55.807");
+ }
+
+ private void assertDates(DateRangeCalculator calculator, String expectedLowerDate, String expectedUpperDate)
+ {
+ assertDate(calculator.getLowerDate(), expectedLowerDate);
+ assertDate(calculator.getUpperDate(), expectedUpperDate);
+ }
+
+ private void assertDate(Date actualDate, String expectedDate)
+ {
+ SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+ format.setTimeZone(TimeZone.getTimeZone("GMT"));
+ Assert.assertEquals(format.format(actualDate), expectedDate);
+ }
+
+}
diff --git a/openbis/sourceTest/sql/postgresql/143/023=experiment_properties.tsv b/openbis/sourceTest/sql/postgresql/143/023=experiment_properties.tsv
index ed6e39a52fae25d648106a41e03aee04447bb278..58e75e69990e5393c27835fde8250d8732c672ee 100644
--- a/openbis/sourceTest/sql/postgresql/143/023=experiment_properties.tsv
+++ b/openbis/sourceTest/sql/postgresql/143/023=experiment_properties.tsv
@@ -13,4 +13,4 @@
19 20 5 \N 12 2 2009-02-09 12:17:55.058768+01 2009-03-18 10:50:19.475958+01 \N 1
18 20 3 2009-02-09 10:00:00 +0100 \N 2 2009-02-09 12:17:55.058768+01 2009-03-18 10:50:19.475958+01 \N 1
20 22 1 A simple experiment \N 2 2008-11-05 09:22:37.246+01 2009-03-18 10:50:19.475958+01 \N 1
-21 24 3 2009-02-010 11:00:00 +0100 \N 2 2009-02-09 12:17:55.058768+01 2009-03-18 10:50:19.475958+01 \N 1
+21 24 3 2009-02-10 01:00:00 +0200 \N 2 2009-02-09 12:17:55.058768+01 2009-03-18 10:50:19.475958+01 \N 1