@Override public Predicate<ServerWebExchange> apply(Config config) { ZonedDateTime datetime1 = config.datetime1; ZonedDateTime datetime2 = config.datetime2; Assert.isTrue(datetime1.isBefore(datetime2), config.datetime1 + " must be before " + config.datetime2); return exchange -> { final ZonedDateTime now = ZonedDateTime.now(); return now.isAfter(datetime1) && now.isBefore(datetime2); }; }
@Override public Predicate<ServerWebExchange> apply(Config config) { ZonedDateTime datetime = config.getDatetime(); return exchange -> { final ZonedDateTime now = ZonedDateTime.now(); return now.isBefore(datetime); }; }
public boolean isExpired(ZonedDateTime zonedNow, ZoneId zoneId) { if (durationType == ReportDurationType.CUSTOM) { ZonedDateTime zonedEndDate = getZonedFromTs(endTs, zoneId).with(LocalTime.MAX); return zonedEndDate.isBefore(zonedNow); } return false; }
/** * Verifies that the actual {@code ZonedDateTime} is <b>strictly</b> before the given one. * <p> * Comparison is done on {@code ZonedDateTime}'s instant (i.e. {@link ZonedDateTime#toEpochSecond()}) * <p> * Example : * <pre><code class='java'> assertThat(parse("2000-01-01T23:59:59Z")).isBefore(parse("2000-01-02T00:00:00Z"));</code></pre> * * @param other the given {@link ZonedDateTime}. * @return this assertion object. * @throws AssertionError if the actual {@code ZonedDateTime} is {@code null}. * @throws IllegalArgumentException if other {@code ZonedDateTime} is {@code null}. * @throws AssertionError if the actual {@code ZonedDateTime} is not strictly before the given one. */ public SELF isBefore(ZonedDateTime other) { Objects.instance().assertNotNull(info, actual); assertDateTimeParameterIsNotNull(other); if (!actual.isBefore(other)) { throw Failures.instance().failure(info, shouldBeBefore(actual, other)); } return myself; }
/** * Verifies that the actual {@code ZonedDateTime} is after or equals to the given one. * <p> * Comparison is done on {@code ZonedDateTime}'s instant (i.e. {@link ZonedDateTime#toEpochSecond()}) * <p> * Example : * <pre><code class='java'> assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo(parse("2000-01-01T00:00:00Z")) * .isAfterOrEqualTo(parse("1999-12-31T23:59:59Z"));</code></pre> * * @param other the given {@link ZonedDateTime}. * @return this assertion object. * @throws AssertionError if the actual {@code ZonedDateTime} is {@code null}. * @throws IllegalArgumentException if other {@code ZonedDateTime} is {@code null}. * @throws AssertionError if the actual {@code ZonedDateTime} is not after or equals to the given one. */ public SELF isAfterOrEqualTo(ZonedDateTime other) { Objects.instance().assertNotNull(info, actual); assertDateTimeParameterIsNotNull(other); if (actual.isBefore(other)) { throw Failures.instance().failure(info, shouldBeAfterOrEqualsTo(actual, other)); } return myself; }
/** * Verifies that the actual {@code ZonedDateTime} is <b>strictly</b> before the given one. * <p> * Comparison is done on {@code ZonedDateTime}'s instant (i.e. {@link ZonedDateTime#toEpochSecond()}) * <p> * Example : * <pre><code class='java'> assertThat(parse("2000-01-01T23:59:59Z")).isBefore(parse("2000-01-02T00:00:00Z"));</code></pre> * * @param other the given {@link ZonedDateTime}. * @return this assertion object. * @throws AssertionError if the actual {@code ZonedDateTime} is {@code null}. * @throws IllegalArgumentException if other {@code ZonedDateTime} is {@code null}. * @throws AssertionError if the actual {@code ZonedDateTime} is not strictly before the given one. */ public SELF isBefore(ZonedDateTime other) { Objects.instance().assertNotNull(info, actual); assertDateTimeParameterIsNotNull(other); if (!actual.isBefore(other)) { throw Failures.instance().failure(info, shouldBeBefore(actual, other)); } return myself; }
/** * Verifies that the actual {@code ZonedDateTime} is after or equals to the given one. * <p> * Comparison is done on {@code ZonedDateTime}'s instant (i.e. {@link ZonedDateTime#toEpochSecond()}) * <p> * Example : * <pre><code class='java'> assertThat(parse("2000-01-01T00:00:00Z")).isAfterOrEqualTo(parse("2000-01-01T00:00:00Z")) * .isAfterOrEqualTo(parse("1999-12-31T23:59:59Z"));</code></pre> * * @param other the given {@link ZonedDateTime}. * @return this assertion object. * @throws AssertionError if the actual {@code ZonedDateTime} is {@code null}. * @throws IllegalArgumentException if other {@code ZonedDateTime} is {@code null}. * @throws AssertionError if the actual {@code ZonedDateTime} is not after or equals to the given one. */ public SELF isAfterOrEqualTo(ZonedDateTime other) { Objects.instance().assertNotNull(info, actual); assertDateTimeParameterIsNotNull(other); if (actual.isBefore(other)) { throw Failures.instance().failure(info, shouldBeAfterOrEqualsTo(actual, other)); } return myself; }
ZonedDateTime halfDay = ZonedDateTime.from(zonedDateTime).truncatedTo(ChronoUnit.DAYS) .plus(1, ChronoUnit.HALF_DAYS); if ( zonedDateTime.isBefore(halfDay) ) { zonedDateTime = halfDay; }else{
@Override public ConnectorSplitSource getSplits(ConnectorTransactionHandle transactionHandle, ConnectorSession session, ConnectorTableLayoutHandle layoutHandle, SplitSchedulingStrategy splitSchedulingStrategy) { AtopTableLayoutHandle handle = (AtopTableLayoutHandle) layoutHandle; AtopTableHandle table = handle.getTableHandle(); List<ConnectorSplit> splits = new ArrayList<>(); ZonedDateTime end = ZonedDateTime.now(timeZone); for (Node node : nodeManager.getWorkerNodes()) { ZonedDateTime start = end.minusDays(maxHistoryDays - 1).withHour(0).withMinute(0).withSecond(0).withNano(0); while (start.isBefore(end)) { ZonedDateTime splitEnd = start.withHour(23).withMinute(59).withSecond(59).withNano(0); Domain splitDomain = Domain.create(ValueSet.ofRanges(Range.range(TIMESTAMP_WITH_TIME_ZONE, 1000 * start.toEpochSecond(), true, 1000 * splitEnd.toEpochSecond(), true)), false); if (handle.getStartTimeConstraint().overlaps(splitDomain) && handle.getEndTimeConstraint().overlaps(splitDomain)) { splits.add(new AtopSplit(table.getTable(), node.getHostAndPort(), start.toEpochSecond(), start.getZone())); } start = start.plusDays(1).withHour(0).withMinute(0).withSecond(0).withNano(0); } } return new FixedSplitSource(splits); } }
public boolean isBefore(JodaCompatibleZonedDateTime o) { return dt.isBefore(o.getZonedDateTime()); }
@Override public State calculate(Set<Item> items) { if (items != null && items.size() > 0) { ZonedDateTime max = null; for (Item item : items) { DateTimeType itemState = item.getStateAs(DateTimeType.class); if (itemState != null) { if (max == null || max.isBefore(itemState.getZonedDateTime())) { max = itemState.getZonedDateTime(); } } } if (max != null) { return new DateTimeType(max); } } return UnDefType.UNDEF; }
@Override protected boolean relation(final ZonedDateTime d1, final ZonedDateTime d2) { Objects.requireNonNull(d1); Objects.requireNonNull(d2); return d1.isBefore(d2); } }
/** * @param timestamp a timestamp * @return true if the provided timestamp is between the begin time and the end time of the current period, false otherwise */ default boolean inPeriod(ZonedDateTime timestamp) { return timestamp != null && !timestamp.isBefore(getBeginTime()) && timestamp.isBefore(getEndTime()); }
/** * Is refresh token expired ? * * @param ticketState the ticket state * @return the boolean */ @JsonIgnore protected boolean isRefreshTokenExpired(final TicketState ticketState) { val expiringTime = ticketState.getCreationTime().plus(this.timeToKillInSeconds, ChronoUnit.SECONDS); return ticketState == null || expiringTime.isBefore(ZonedDateTime.now(ZoneOffset.UTC)); }
@Override public Completable verifyAndCreateTempTables(ZonedDateTime startTime, ZonedDateTime endTime) { Set<Long> timestamps = new HashSet<>(); while(startTime.isBefore(endTime)) { // Table sizes are not configurable at this point timestamps.add(startTime.toInstant().toEpochMilli()); startTime = startTime.plus(2, ChronoUnit.HOURS); } return Completable.fromObservable(dataAccess.createTempTablesIfNotExists(timestamps)); }
@Override public Completable verifyAndCreateTempTables(ZonedDateTime startTime, ZonedDateTime endTime) { Set<Long> timestamps = new HashSet<>(); while(startTime.isBefore(endTime)) { // Table sizes are not configurable at this point timestamps.add(startTime.toInstant().toEpochMilli()); startTime = startTime.plus(2, ChronoUnit.HOURS); } return Completable.fromObservable(dataAccess.createTempTablesIfNotExists(timestamps)); }
@Override public void set(ZonedDateTime dateTime) { ZonedDateTime lastEventPolling = projectState.getLastEventPolling(); if (lastEventPolling != null && dateTime.isBefore(lastEventPolling)) { // this can happen if the settings changed between the read and write return; } projectState.setLastEventPolling(dateTime); } }
@Override public boolean isExpired(final TicketState ticketState) { val expiringTime = ticketState.getCreationTime().plus(this.timeToKillInSeconds, ChronoUnit.SECONDS); val expired = ticketState == null || expiringTime.isBefore(ZonedDateTime.now(ZoneOffset.UTC)); if (!expired) { return super.isExpired(ticketState); } return expired; }
ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("US/Eastern")); ZonedDateTime target2 = zdt .withHour(15) .withMinute(0) .withSecond(0) .withNano(0); if (target2.isBefore(zdt)) { zdt = zdt.plusDays(1); } System.out.println(zdt.until(target2, ChronoUnit.MILLIS));
@Override public final boolean isValid(final ZonedDateTime pvalue, final ConstraintValidatorContext pcontext) { if (pvalue == null) { return true; } final ZonedDateTime dateLimit = ZonedDateTime.now().minusYears(minYears).withHour(0) .withMinute(0).withSecond(0).withNano(0); return !dateLimit.isBefore(pvalue.withHour(0).withMinute(0).withSecond(0).withNano(0)); } }