public void test_convertToInstant_furtherAfterLeap() {
   OffsetDateTime odt = OffsetDateTime.of(1980, 1, 1, 0, 0, 1, 0, ZoneOffset.UTC);
   Instant instant = odt.toInstant();
   UtcInstant utc = UtcInstant.ofModifiedJulianDay(MJD_1980, NANOS_PER_SEC);
   assertEquals(rules.convertToInstant(utc), instant);
   assertEquals(rules.convertToUtc(instant), utc);
 }
Example #2
0
  @Test
  public void testTimestampQueryingAndOrder() throws IOException {
    ServiceLocator locator = container;
    SearchByTimestampAndOrderByTimestampRepository analysisGridRepository =
        locator.resolve(SearchByTimestampAndOrderByTimestampRepository.class);

    String marker = UUID.randomUUID().toString();
    OffsetDateTime dt1 = OffsetDateTime.now();
    OffsetDateTime dt2 = dt1.plusDays(1);
    OffsetDateTime dt3 = dt1.plusDays(2);
    OffsetDateTime dt4 = dt1.plusDays(3);

    SearchByTimestampAndOrderByTimestamp[] arr =
        new SearchByTimestampAndOrderByTimestamp[] {
          new SearchByTimestampAndOrderByTimestamp().setOndate(dt1).setMarker(marker),
          new SearchByTimestampAndOrderByTimestamp().setOndate(dt2).setMarker(marker),
          new SearchByTimestampAndOrderByTimestamp().setOndate(dt3).setMarker(marker),
          new SearchByTimestampAndOrderByTimestamp().setOndate(dt4).setMarker(marker)
        };
    analysisGridRepository.insert(arr);

    List<SearchByTimestampAndOrderByTimestamp> queryResults =
        analysisGridRepository
            .query(it -> it.getMarker().equals(marker) && it.getOndate().isAfter(dt2))
            .sortedDescendingBy(SearchByTimestampAndOrderByTimestamp::getOndate)
            .list();
    Assert.assertEquals(queryResults.size(), arr.length - 2);
    Assert.assertTrue(queryResults.get(0).getOndate().isEqual(dt4));
  }
 // -----------------------------------------------------------------------
 // convertToUtc(Instant)/convertToInstant(UtcInstant)
 // -----------------------------------------------------------------------
 public void test_convertToInstant_justBeforeLeap() {
   OffsetDateTime odt = OffsetDateTime.of(1979, 12, 31, 23, 43, 21, 0, ZoneOffset.UTC);
   Instant instant = odt.toInstant();
   UtcInstant utc =
       UtcInstant.ofModifiedJulianDay(MJD_1980 - 1, (SECS_PER_DAY + 1 - 1000) * NANOS_PER_SEC);
   assertEquals(rules.convertToInstant(utc), instant);
   assertEquals(rules.convertToUtc(instant), utc);
 }
Example #4
0
  @Override
  public boolean isSatisfiedBy(Payment payment) {
    OffsetDateTime offsetPaymentDate;
    offsetPaymentDate = OffsetDateTime.ofInstant(payment.getDate(), ZoneOffset.UTC);

    logger.entry(payment);
    logger.entry(offsetPaymentDate);

    return logger.exit(offsetPaymentDate.toLocalTime().compareTo(value) <= 0);
  }
 public void test_convertToInstant_slsMicros() {
   for (int i = 1; i < 1000; i++) {
     long utcNanos = (SECS_PER_DAY + 1 - 1000) * NANOS_PER_SEC + i * 1000;
     long startSls = (86401 - 1000) * NANOS_PER_SEC;
     long slsNanos = (utcNanos - (utcNanos - startSls) / 1000);
     OffsetDateTime odt =
         OffsetDateTime.of(
             1979, 12, 31, 23, 43, 21, (int) (slsNanos % NANOS_PER_SEC), ZoneOffset.UTC);
     Instant instant = odt.toInstant();
     UtcInstant utc =
         UtcInstant.ofModifiedJulianDay(
             MJD_1980 - 1, (SECS_PER_DAY + 1 - 1000) * NANOS_PER_SEC + i * 1000);
     assertEquals(rules.convertToInstant(utc), instant);
     assertEquals(rules.convertToUtc(instant), utc);
   }
 }
 @Override
 protected void writeDateTime(BsonWriter writer, String name, Object value, EncoderContext ctx) {
   writer.writeDateTime(
       OffsetDateTime.parse(((JsonObject) value).getString(DATE_FIELD))
           .toInstant()
           .toEpochMilli());
 }
 public void test_convertToInstant_slsNanos() {
   for (int i = 1; i < 5005; i++) {
     long utcNanos = (SECS_PER_DAY + 1 - 1000) * NANOS_PER_SEC + i;
     long startSls = (86401 - 1000) * NANOS_PER_SEC;
     long slsNanos = (utcNanos - (utcNanos - startSls) / 1000);
     OffsetDateTime odt =
         OffsetDateTime.of(
             1979, 12, 31, 23, 43, 21, (int) (slsNanos % NANOS_PER_SEC), ZoneOffset.UTC);
     Instant instant = odt.toInstant();
     UtcInstant utc = UtcInstant.ofModifiedJulianDay(MJD_1980 - 1, utcNanos);
     assertEquals(rules.convertToInstant(utc), instant);
     // not all instants can map back to the correct UTC value
     long reverseUtcNanos = startSls + ((slsNanos - startSls) * 1000L) / (1000L - 1);
     assertEquals(
         rules.convertToUtc(instant),
         UtcInstant.ofModifiedJulianDay(MJD_1980 - 1, reverseUtcNanos));
   }
 }
 @Override
 protected Object readDateTime(BsonReader reader, DecoderContext ctx) {
   final JsonObject result = new JsonObject();
   result.put(
       DATE_FIELD,
       OffsetDateTime.ofInstant(Instant.ofEpochMilli(reader.readDateTime()), ZoneOffset.UTC)
           .format(ISO_OFFSET_DATE_TIME));
   return result;
 }
  // TODO clean up
  @Override
  public void testGoogleFitMeasureFromDataPoint(
      BodyHeight testMeasure, Map<String, Object> properties) {

    BodyHeight.Builder bodyHeightBuilder =
        new BodyHeight.Builder(new LengthUnitValue(METER, (double) properties.get("fpValue")));
    if (properties.containsKey("endDateTimeString")) {
      bodyHeightBuilder.setEffectiveTimeFrame(
          TimeInterval.ofStartDateTimeAndEndDateTime(
              OffsetDateTime.parse((String) properties.get("startDateTimeString")),
              OffsetDateTime.parse((String) properties.get("endDateTimeString"))));
    } else {
      bodyHeightBuilder.setEffectiveTimeFrame(
          OffsetDateTime.parse((String) properties.get("startDateTimeString")));
    }
    BodyHeight expectedBodyHeight = bodyHeightBuilder.build();
    assertThat(testMeasure, equalTo(expectedBodyHeight));
  }
 private static Instant getInstant(String str) {
   try {
     Instant i = OffsetDateTime.parse(str).toInstant();
     LOG.debug(str + " resolved to Instant");
     return i;
   } catch (DateTimeException e) {
     LOG.debug(str + " does not match to OffsetDateTime pattern");
   }
   return null;
 }
  @PreUpdate
  public void beforeUpdate(Object entity) {
    if (entity instanceof AbstractAuditableEntity) {
      AbstractAuditableEntity o = (AbstractAuditableEntity) entity;
      o.setUpdatedAt(OffsetDateTime.now());

      if (o.getUpdatedBy() == null) {
        o.setUpdatedBy(currentUser());
      }
    }
  }
  @Test
  public void shouldReturnJobIfJobExists() throws Exception {
    // given
    ZoneId cet = ZoneId.of("CET");
    OffsetDateTime now = OffsetDateTime.now(cet);
    JobInfo expectedJob = newJobInfo("42", "TEST", fixed(now.toInstant(), cet), "localhost");
    when(jobService.findJob("42")).thenReturn(Optional.of(expectedJob));

    String nowAsString = ISO_OFFSET_DATE_TIME.format(now);
    mockMvc
        .perform(
            MockMvcRequestBuilders.get("/some-microservice/internal/jobs/42")
                .servletPath("/internal/jobs/42"))
        .andExpect(MockMvcResultMatchers.status().is(200))
        .andExpect(MockMvcResultMatchers.jsonPath("$.status").value("OK"))
        .andExpect(MockMvcResultMatchers.jsonPath("$.messages").isArray())
        .andExpect(MockMvcResultMatchers.jsonPath("$.jobType").value("TEST"))
        .andExpect(MockMvcResultMatchers.jsonPath("$.hostname").value("localhost"))
        .andExpect(MockMvcResultMatchers.jsonPath("$.started").value(nowAsString))
        .andExpect(MockMvcResultMatchers.jsonPath("$.stopped").value(""))
        .andExpect(MockMvcResultMatchers.jsonPath("$.lastUpdated").value(nowAsString))
        .andExpect(
            MockMvcResultMatchers.jsonPath("$.jobUri")
                .value("http://localhost/some-microservice/internal/jobs/42"))
        .andExpect(MockMvcResultMatchers.jsonPath("$.links").isArray())
        .andExpect(
            MockMvcResultMatchers.jsonPath("$.links[0].href")
                .value("http://localhost/some-microservice/internal/jobs/42"))
        .andExpect(
            MockMvcResultMatchers.jsonPath("$.links[1].href")
                .value("http://localhost/some-microservice/internal/jobdefinitions/TEST"))
        .andExpect(
            MockMvcResultMatchers.jsonPath("$.links[2].href")
                .value("http://localhost/some-microservice/internal/jobs"))
        .andExpect(
            MockMvcResultMatchers.jsonPath("$.links[3].href")
                .value("http://localhost/some-microservice/internal/jobs?type=TEST"))
        .andExpect(MockMvcResultMatchers.jsonPath("$.runtime").value(""))
        .andExpect(MockMvcResultMatchers.jsonPath("$.state").value("Running"));
    verify(jobService).findJob("42");
  }
Example #13
0
  @Override
  public int compareTo(TextChannel chan) {
    if (this == chan) return 0;

    if (this.getGuild() != chan.getGuild())
      throw new IllegalArgumentException(
          "Cannot compare TextChannels that aren't from the same guild!");

    if (this.getPositionRaw() != chan.getPositionRaw())
      return chan.getPositionRaw() - this.getPositionRaw();

    OffsetDateTime thisTime = MiscUtil.getCreationTime(this);
    OffsetDateTime chanTime = MiscUtil.getCreationTime(chan);

    // We compare the provided channel's time to this's time instead of the reverse as one would
    // expect due to how
    // discord deals with hierarchy. The more recent a channel was created, the lower its hierarchy
    // ranking when
    // it shares the same position as another channel.
    return chanTime.compareTo(thisTime);
  }
Example #14
0
 public void calculateNextScheduledRun(Long immediateFrequency) {
   if (lastScheduledRun == null) {
     lastScheduledRun = OffsetDateTime.now();
   }
   switch (getFrequency().getFrequency()) {
     case IMMEDIATE:
       setNextScheduledRun(lastScheduledRun.plusMinutes(immediateFrequency));
       break;
     case DAILY:
       setNextScheduledRun(lastScheduledRun.plusDays(1));
       break;
     case WEEKLY:
       setNextScheduledRun(lastScheduledRun.plusWeeks(1));
       break;
     case MONTHLY:
       setNextScheduledRun(lastScheduledRun.plusMonths(1));
       break;
     default:
       setNextScheduledRun(null);
   }
 }
 @DataProvider(name = "parseWithOffsetWithoutZone")
 Object[][] data_parse_WithOffset_WithoutZone() {
   return new Object[][] {
     {
       "2015-12-14T00:45:00-11:30",
       OffsetDateTime.of(2015, 12, 14, 0, 45, 0, 0, ZoneOffset.of("-11:30"))
     },
     {
       "2015-12-14T01:45:00-05:00",
       OffsetDateTime.of(2015, 12, 14, 1, 45, 0, 0, ZoneOffset.of("-05:00"))
     },
     {
       "2015-12-14T02:45:00-00:00",
       OffsetDateTime.of(2015, 12, 14, 2, 45, 0, 0, ZoneOffset.of("-00:00"))
     },
     {
       "2015-12-14T03:45:00+00:00",
       OffsetDateTime.of(2015, 12, 14, 3, 45, 0, 0, ZoneOffset.of("+00:00"))
     },
     {
       "2015-12-14T04:45:00+03:30",
       OffsetDateTime.of(2015, 12, 14, 4, 45, 0, 0, ZoneOffset.of("+03:30"))
     },
     {
       "2015-12-14T05:45:00+10:00",
       OffsetDateTime.of(2015, 12, 14, 5, 45, 0, 0, ZoneOffset.of("+10:00"))
     }
   };
 }
 /**
  * Get a single world by it's ID
  *
  * @param id the ID
  * @return the world
  */
 @RequestMapping("/{id}")
 @ResponseBody
 public WorldModel get(@PathVariable("id") final String id) {
   WorldModel worldModel = new WorldModel();
   worldModel.setId(id);
   worldModel.setName("Middle Earth");
   worldModel.setDescription("The world of The Hobbit and The Lord of the Rings");
   worldModel.setCreationDate(OffsetDateTime.now());
   worldModel.setOwner(new UserLink());
   worldModel.getOwner().setId(UUID.randomUUID().toString());
   worldModel.getOwner().setName("Tolkien");
   return worldModel;
 }
  //    @Inject
  //    @AuthenticatedUser
  //    User user;
  //    @PersistenceContext
  //    EntityManager em;
  @PrePersist
  public void beforePersist(Object entity) {
    if (entity instanceof AbstractAuditableEntity) {
      AbstractAuditableEntity o = (AbstractAuditableEntity) entity;
      final OffsetDateTime now = OffsetDateTime.now();
      o.setCreatedAt(now);
      o.setUpdatedAt(now);

      if (o.getCreatedBy() == null) {
        o.setCreatedBy(currentUser());
      }
    }
  }
Example #18
0
  private void updateMetadata(ZdoModel model) throws IOException {
    Response.StatusType statusInfo =
        ClientBuilder.newClient()
            .target(fitTransactionToUrl(model.getUrl()))
            .request()
            .put(Entity.entity(model, RDF_SERIALIZATION))
            .getStatusInfo();

    if (statusInfo.getFamily() != Response.Status.Family.SUCCESSFUL) {
      logError(fitTransactionToUrl(model.getUrl()), statusInfo);
      throw new IOException("Failed to update resource " + fitTransactionToUrl(model.getUrl()));
    }

    model.removeAllValuesOfProperty(ZdoTerms.fedoraLastModified);
    if (ZdoType.isAbovePageCategory(model.get(ZdoTerms.zdoType))) {
      model.add(
          model.getSubject(),
          ZdoTerms.fedoraLastModified,
          OffsetDateTime.now().toString(),
          XSDDatatype.XSDdateTime);
      if (model.get(ZdoTerms.fedoraCreated) == null) {
        model.add(
            model.getSubject(),
            ZdoTerms.fedoraCreated,
            OffsetDateTime.now().toString(),
            XSDDatatype.XSDdateTime);
      }
    } else {
      model.removeAllValuesOfProperty(ZdoTerms.fedoraCreated);
    }

    // Also update triplestore
    model.stripPossibleBadUrlEnding(); // strip fcr:metadata
    if (transactionPath == null) {
      sparqlOnDemandIndexer.update(model);
    } else { // If in transaction, triplestore operations are delayed till its end
      toUpdate.add(model);
    }
  }
  @Test
  public void CanDecodeFromJson() throws Exception {
    String content = "[[2015, 6, 28], [[13, 52, 5, 123456],7260]]";
    ObjectMapper mapper = JacksonObjectMapperFactory.objectMapper(DataFormat.Text);

    Object timeObj = mapper.readValue(content, Object.class);
    SqpTimestamp sqpTimestamp = SqpTimestamp.fromJsonFormatValue(timeObj);

    OffsetDateTime timestamp = sqpTimestamp.asOffsetDateTime();
    assertThat(timestamp.getHour(), is(13));
    assertThat(timestamp.getMinute(), is(52));
    assertThat(timestamp.getSecond(), is(5));
    assertThat(timestamp.getNano(), is(123456));
    assertThat(timestamp.getOffset().getTotalSeconds(), is(7260));

    assertThat(timestamp.getYear(), is(2015));
    assertThat(timestamp.getMonth(), is(Month.JUNE));
    assertThat(timestamp.getDayOfMonth(), is(28));
  }
  public static void main(String[] args) throws ParseException {

    OffsetDateTime start = OffsetDateTime.parse("2014-06-10T10:45:00+03:00");
    // Takes the time stamp and converts to an OffsetDateTime object
    OffsetDateTime end = OffsetDateTime.parse("2015-06-10T10:50:00+03:00");

    Instant startInst = start.toInstant(); // converts it to an Instant Class object
    Instant endInst = end.toInstant();
    Duration dur =
        Duration.between(startInst, endInst); // calculates the duration between the two instances

    System.out.println("The Period between the two instants is:\n");
    System.out.println(dur.toMillis() + " Millisecs"); // prints the milliseconds
  }
  @Override
  public Optional<String> validate(final String dateTime) {
    try {
      OffsetDateTime.parse(dateTime, ISO_OFFSET_DATE_TIME);

      // Unfortunately, ISO_OFFSET_DATE_TIME accepts offsets with seconds, which is not RFC3339
      // compliant. So
      // we need to do some further checks using a regex in order to be sure that it adhere to the
      // given format.
      final Matcher matcher = pattern.matcher(dateTime);
      if (matcher.matches()) {
        return Optional.empty();
      } else {
        return error;
      }

    } catch (final DateTimeParseException e) {
      return error;
    }
  }
 @Override
 public TemporalAccessor parse(String text, Locale locale) throws ParseException {
   DateTimeFormatter formatterToUse = DateTimeContextHolder.getFormatter(this.formatter, locale);
   if (LocalDate.class.equals(this.temporalAccessorType)) {
     return LocalDate.parse(text, formatterToUse);
   } else if (LocalTime.class.equals(this.temporalAccessorType)) {
     return LocalTime.parse(text, formatterToUse);
   } else if (LocalDateTime.class.equals(this.temporalAccessorType)) {
     return LocalDateTime.parse(text, formatterToUse);
   } else if (ZonedDateTime.class.equals(this.temporalAccessorType)) {
     return ZonedDateTime.parse(text, formatterToUse);
   } else if (OffsetDateTime.class.equals(this.temporalAccessorType)) {
     return OffsetDateTime.parse(text, formatterToUse);
   } else if (OffsetTime.class.equals(this.temporalAccessorType)) {
     return OffsetTime.parse(text, formatterToUse);
   } else {
     throw new IllegalStateException(
         "Unsupported TemporalAccessor type: " + this.temporalAccessorType);
   }
 }
  public static void main(String... args) {
    F<String, F<String, Date>> simpleDate =
        df ->
            s -> {
              try {
                return new SimpleDateFormat(df).parse(s);
              } catch (Exception e) {
                throw new RuntimeException(e);
              }
            };

    Either<String, Date> res =
        parseDate(
            Either.left(args[0]),
            s -> Date.from(LocalDateTime.parse(s).toInstant(ZoneOffset.UTC)),
            s -> Date.from(OffsetDateTime.parse(s).toInstant()),
            s -> Date.from(ZonedDateTime.parse(s).toInstant()),
            simpleDate.f("yyyy-MM-dd HH:mm:ss"),
            s -> "now".equals(s) ? new Date() : null);

    System.out.println("------");

    System.out.println(res);
  }
Example #24
0
  protected ResponseEntity<ShimDataResponse> getData(
      OAuth2RestOperations restTemplate, ShimDataRequest shimDataRequest) throws ShimException {

    final JawboneDataTypes jawboneDataType;
    try {
      jawboneDataType =
          JawboneDataTypes.valueOf(shimDataRequest.getDataTypeKey().trim().toUpperCase());
    } catch (NullPointerException | IllegalArgumentException e) {
      throw new ShimException(
          "Null or Invalid data type parameter: "
              + shimDataRequest.getDataTypeKey()
              + " in shimDataRequest, cannot retrieve data.");
    }

    // FIXME this needs to get changed or documented
    long numToReturn = 100;
    if (shimDataRequest.getNumToReturn() != null) {
      numToReturn = shimDataRequest.getNumToReturn();
    }

    OffsetDateTime today = OffsetDateTime.now();

    OffsetDateTime startDateTime =
        shimDataRequest.getStartDateTime() == null
            ? today.minusDays(1)
            : shimDataRequest.getStartDateTime();
    long startTimeInEpochSecond = startDateTime.toEpochSecond();

    OffsetDateTime endDateTime =
        shimDataRequest.getEndDateTime() == null
            ? today.plusDays(1)
            : shimDataRequest.getEndDateTime();
    long endTimeInEpochSecond = endDateTime.toEpochSecond();

    UriComponentsBuilder uriComponentsBuilder =
        UriComponentsBuilder.fromUriString(DATA_URL)
            .path(jawboneDataType.getEndPoint())
            .queryParam("start_time", startTimeInEpochSecond)
            .queryParam("end_time", endTimeInEpochSecond)
            .queryParam("limit", numToReturn);

    ResponseEntity<JsonNode> responseEntity;
    try {
      responseEntity =
          restTemplate.getForEntity(uriComponentsBuilder.build().encode().toUri(), JsonNode.class);
    } catch (HttpClientErrorException | HttpServerErrorException e) {
      // FIXME figure out how to handle this
      logger.error("A request for Jawbone data failed.", e);
      throw e;
    }

    if (shimDataRequest.getNormalize()) {

      JawboneDataPointMapper mapper;
      switch (jawboneDataType) {
        case WEIGHT:
          mapper = new JawboneBodyWeightDataPointMapper();
          break;
        case STEPS:
          mapper = new JawboneStepCountDataPointMapper();
          break;
        case BODY_MASS_INDEX:
          mapper = new JawboneBodyMassIndexDataPointMapper();
          break;
        case ACTIVITY:
          mapper = new JawbonePhysicalActivityDataPointMapper();
          break;
        case SLEEP:
          mapper = new JawboneSleepDurationDataPointMapper();
          break;
        case HEART_RATE:
          mapper = new JawboneHeartRateDataPointMapper();
          break;
        default:
          throw new UnsupportedOperationException();
      }

      return ResponseEntity.ok()
          .body(
              ShimDataResponse.result(
                  JawboneShim.SHIM_KEY,
                  mapper.asDataPoints(singletonList(responseEntity.getBody()))));

    } else {

      return ResponseEntity.ok()
          .body(ShimDataResponse.result(JawboneShim.SHIM_KEY, responseEntity.getBody()));
    }
  }
 @Test(dataProvider = "parseWithOffsetWithoutZone")
 public void testWithOffsetWithoutZone(String odtString, OffsetDateTime expectedOTD) {
   dtFormatter = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
   odt1 = OffsetDateTime.parse(odtString, dtFormatter);
   assertEquals(expectedOTD, odt1);
 }
 @Before
 public void before() {
   actual = OffsetDateTime.now();
 }