Example usage for java.time.temporal ChronoUnit MINUTES

List of usage examples for java.time.temporal ChronoUnit MINUTES

Introduction

In this page you can find the example usage for java.time.temporal ChronoUnit MINUTES.

Prototype

ChronoUnit MINUTES

To view the source code for java.time.temporal ChronoUnit MINUTES.

Click Source Link

Document

Unit that represents the concept of a minute.

Usage

From source file:com.ikanow.aleph2.data_model.utils.TimeUtils.java

/** The simplest date parsing utility - only handles daily/hourly/monthly type strings (1d, d, daily, day - etc). Note "m" is ambiguous and not supported, use "min" or "month"
 * @param human_readable_period - daily/hourly/monthly type strings (1d, d, daily, day - etc). Note "m" is ambiguous and not supported, use "min" or "month"
 * @return a ChronoUnit if successful, else a generic error string
 *///from ww w. j  av  a 2s. co m
public static Validation<String, ChronoUnit> getTimePeriod(final String human_readable_period) {
    return Patterns
            .match(Optional.ofNullable(human_readable_period).orElse("").toLowerCase().replaceAll("\\s+", ""))
            .<Validation<String, ChronoUnit>>andReturn()
            .when(d -> d.equals("1d"), __ -> Validation.success(ChronoUnit.DAYS))
            .when(d -> d.equals("d"), __ -> Validation.success(ChronoUnit.DAYS))
            .when(d -> d.equals("1day"), __ -> Validation.success(ChronoUnit.DAYS))
            .when(d -> d.equals("day"), __ -> Validation.success(ChronoUnit.DAYS))
            .when(d -> d.equals("daily"), __ -> Validation.success(ChronoUnit.DAYS))

            .when(d -> d.equals("1w"), __ -> Validation.success(ChronoUnit.WEEKS))
            .when(d -> d.equals("w"), __ -> Validation.success(ChronoUnit.WEEKS))
            .when(d -> d.equals("1wk"), __ -> Validation.success(ChronoUnit.WEEKS))
            .when(d -> d.equals("wk"), __ -> Validation.success(ChronoUnit.WEEKS))
            .when(d -> d.equals("1week"), __ -> Validation.success(ChronoUnit.WEEKS))
            .when(d -> d.equals("week"), __ -> Validation.success(ChronoUnit.WEEKS))
            .when(d -> d.equals("weekly"), __ -> Validation.success(ChronoUnit.WEEKS))

            .when(d -> d.equals("1month"), __ -> Validation.success(ChronoUnit.MONTHS))
            .when(d -> d.equals("month"), __ -> Validation.success(ChronoUnit.MONTHS))
            .when(d -> d.equals("monthly"), __ -> Validation.success(ChronoUnit.MONTHS))

            .when(d -> d.equals("1sec"), __ -> Validation.success(ChronoUnit.SECONDS))
            .when(d -> d.equals("sec"), __ -> Validation.success(ChronoUnit.SECONDS))
            .when(d -> d.equals("1s"), __ -> Validation.success(ChronoUnit.SECONDS))
            .when(d -> d.equals("s"), __ -> Validation.success(ChronoUnit.SECONDS))
            .when(d -> d.equals("1second"), __ -> Validation.success(ChronoUnit.SECONDS))
            .when(d -> d.equals("second"), __ -> Validation.success(ChronoUnit.SECONDS))

            .when(d -> d.equals("1min"), __ -> Validation.success(ChronoUnit.MINUTES))
            .when(d -> d.equals("min"), __ -> Validation.success(ChronoUnit.MINUTES))
            .when(d -> d.equals("1minute"), __ -> Validation.success(ChronoUnit.MINUTES))
            .when(d -> d.equals("minute"), __ -> Validation.success(ChronoUnit.MINUTES))

            .when(d -> d.equals("1h"), __ -> Validation.success(ChronoUnit.HOURS))
            .when(d -> d.equals("h"), __ -> Validation.success(ChronoUnit.HOURS))
            .when(d -> d.equals("1hour"), __ -> Validation.success(ChronoUnit.HOURS))
            .when(d -> d.equals("hour"), __ -> Validation.success(ChronoUnit.HOURS))
            .when(d -> d.equals("hourly"), __ -> Validation.success(ChronoUnit.HOURS))

            .when(d -> d.equals("1y"), __ -> Validation.success(ChronoUnit.YEARS))
            .when(d -> d.equals("y"), __ -> Validation.success(ChronoUnit.YEARS))
            .when(d -> d.equals("1year"), __ -> Validation.success(ChronoUnit.YEARS))
            .when(d -> d.equals("year"), __ -> Validation.success(ChronoUnit.YEARS))
            .when(d -> d.equals("1yr"), __ -> Validation.success(ChronoUnit.YEARS))
            .when(d -> d.equals("yr"), __ -> Validation.success(ChronoUnit.YEARS))
            .when(d -> d.equals("yearly"), __ -> Validation.success(ChronoUnit.YEARS))

            .otherwise(__ -> Validation
                    .fail(ErrorUtils.get(ErrorUtils.INVALID_DATETIME_FORMAT, human_readable_period)));
}

From source file:com.muk.services.util.GoogleOAuthService.java

private String createClaim(String scope, String privateKeyAlias, String account) {
    final Instant issued = Instant.now();
    final Instant expirePlusHour = issued.plus(50, ChronoUnit.MINUTES);

    final StringBuilder sb = new StringBuilder();

    sb.append("{\"iss\":\"").append(account).append("\",\"scope\":\"").append(scope).append("\",\"aud\":\"")
            .append(JWT_AUD).append("\",\"exp\":").append(expirePlusHour.getEpochSecond()).append(",\"iat\":")
            .append(issued.getEpochSecond()).append(",\"sub\":\"").append(JWT_SUB).append("\"}");

    /*//from  w  w w  .  j av a2s.co m
     * sb.append("{\"iss\":\"").append(account).append("\",\"scope\":\"").append(scope).append("\",\"aud\":\"")
     * .append(JWT_AUD).append("\",\"exp\":").append(expirePlusHour.getEpochSecond()).append(",\"iat\":")
     * .append(issued.getEpochSecond()).append("}");
     */

    String jwt = JWT_HEADER + "." + cryptoService.encodeUrlSafe(sb.toString().getBytes(StandardCharsets.UTF_8));

    try {
        jwt = jwt + "."
                + cryptoService.signature("SHA256withRSA", jwt, keystoreService.getPrivateKey(privateKeyAlias));
    } catch (final IOException ioEx) {
        LOG.error("Failed to access keystore.", ioEx);
    } catch (final GeneralSecurityException secEx) {
        LOG.error("Failed to sign jwt.", secEx);
    }

    return jwt;
}

From source file:com.onyxscheduler.domain.SchedulerIT.java

private Instant buildPastDate() {
    return Instant.now().minus(PAST_DATE_MINUTES, ChronoUnit.MINUTES);
}

From source file:org.openhab.binding.buienradar.internal.BuienradarHandler.java

private void refresh() {
    try {/*from w w  w .  ja  v  a  2s  .c o  m*/
        @SuppressWarnings("null")
        final List<Prediction> predictions = client.getPredictions(location);
        for (final Prediction prediction : predictions) {
            final BigDecimal intensity = prediction.getIntensity();
            final ZonedDateTime nowPlusThree = ZonedDateTime.now().plusMinutes(3);
            final ZonedDateTime lastFiveMinute = nowPlusThree.withMinute((nowPlusThree.getMinute() / 5) * 5)
                    .withSecond(0).withNano(0);
            final long minutesFromNow = lastFiveMinute.until(prediction.getDateTime(), ChronoUnit.MINUTES);
            final long minuteClass = minutesFromNow;
            logger.debug("Forecast for {} at {} is {}", minutesFromNow, prediction.getDateTime(), intensity);
            if (minuteClass >= 0 && minuteClass <= 115) {
                final String label = String.format(Locale.ENGLISH, "forecast_%d", minuteClass);

                /** @TODO: edejong 2019-04-03 Change to SmartHomeUnits.MILLIMETRE_PER_HOUR for OH 2.5 */
                updateState(label, new QuantityType<Speed>(intensity, MILLIMETRE_PER_HOUR));
            }
        }

        updateStatus(ThingStatus.ONLINE);
    } catch (IOException e) {
        logger.warn("Cannot retrieve predictions", e);
        updateStatus(ThingStatus.ONLINE, ThingStatusDetail.COMMUNICATION_ERROR,
                String.format("Could not reach buienradar: %s", e.getMessage()));
    }
}

From source file:com.querydsl.webhooks.GithubReviewWindow.java

@VisibleForTesting
protected static String makeHumanReadable(Duration duration) {
    StringBuilder output = new StringBuilder();
    duration = truncateAndAppend(duration, duration.toDays(), ChronoUnit.DAYS, "day", output);
    duration = truncateAndAppend(duration, duration.toHours(), ChronoUnit.HOURS, "hour", output);
    duration = truncateAndAppend(duration, duration.toMinutes(), ChronoUnit.MINUTES, "minute", output);
    duration = truncateAndAppend(duration, duration.getSeconds(), ChronoUnit.SECONDS, "second", output);
    return output.toString().trim();
}

From source file:org.jimsey.project.turbine.spring.controller.IndicatorControllerTest.java

@Test
public void testGetAllStocksGreaterThanDate() throws Exception {
    Mockito.when(elasticsearch.findIndicatorsByMarketAndSymbolAndNameAndDateGreaterThan(Mockito.anyString(),
            Mockito.anyString(), Mockito.anyString(), Mockito.any(Long.class))).thenReturn(indicators);

    String expected = json.writeValueAsString(new Object() {
        @JsonProperty("indicators")
        List<IndicatorJson> indicatorz = indicators;
    });/*from  w  w w .  j a  va2s.c  o  m*/

    long date = Instant.now().minus(1, ChronoUnit.MINUTES).toEpochMilli();

    String restUri = String.format("%s/%s/%s/%s/%s", TurbineCondenserConstants.REST_ROOT_INDICATORS, "market",
            "symbol", "testName", date);

    mvc.perform(MockMvcRequestBuilders.get(restUri).accept(MediaType.APPLICATION_JSON))
            .andExpect(status().isOk()).andExpect(content().string(equalTo(expected)));
}

From source file:io.gravitee.management.service.impl.InstanceServiceImpl.java

@Override
public InstanceEntity findById(String eventId) {
    EventEntity event = eventService.findById(eventId);
    Instant nowMinusXMinutes = Instant.now().minus(5, ChronoUnit.MINUTES);

    Map<String, String> props = event.getProperties();
    InstanceEntity instance = new InstanceEntity(props.get("id"));
    instance.setLastHeartbeatAt(new Date(Long.parseLong(props.get("last_heartbeat_at"))));
    instance.setStartedAt(new Date(Long.parseLong(props.get("started_at"))));

    if (event.getPayload() != null) {
        try {//from   ww  w  .jav  a  2  s.c  om
            InstanceInfo info = objectMapper.readValue(event.getPayload(), InstanceInfo.class);
            instance.setHostname(info.getHostname());
            instance.setIp(info.getIp());
            instance.setVersion(info.getVersion());
            instance.setTags(info.getTags());
            instance.setSystemProperties(info.getSystemProperties());
            instance.setPlugins(info.getPlugins());
        } catch (IOException ioe) {
            LOGGER.error("Unexpected error while getting instance informations from event payload", ioe);
        }
    }

    if (event.getType() == EventType.GATEWAY_STARTED) {
        instance.setState(InstanceState.STARTED);
        // If last heartbeat timestamp is < now - 5m, set as unknown state
        Instant lastHeartbeat = Instant.ofEpochMilli(instance.getLastHeartbeatAt().getTime());
        if (lastHeartbeat.isBefore(nowMinusXMinutes)) {
            instance.setState(InstanceState.UNKNOWN);
        }
    } else {
        instance.setState(InstanceState.STOPPED);
        instance.setStoppedAt(new Date(Long.parseLong(props.get("stopped_at"))));
    }

    return instance;
}

From source file:devbury.dewey.plugins.RemindMe.java

private Date notifyAt(long amount, String units) {
    ChronoUnit chronoUnit = ChronoUnit.SECONDS;
    switch (units) {
    case "weeks":
    case "week":
        chronoUnit = ChronoUnit.WEEKS;
        break;/*  w  ww  . ja v a  2  s  .  c  o  m*/
    case "months":
    case "month":
        chronoUnit = ChronoUnit.MONTHS;
        break;
    case "days":
    case "day":
        chronoUnit = ChronoUnit.DAYS;
        break;
    case "hours":
    case "hour":
        chronoUnit = ChronoUnit.HOURS;
        break;
    case "minutes":
    case "minute":
        chronoUnit = ChronoUnit.MINUTES;
        break;
    }
    return Date.from(Instant.now().plus(amount, chronoUnit));
}

From source file:org.thevortex.lighting.jinks.robot.Recurrence.java

/**
 * Get the next occurrence from a time./*  www .  ja v  a2 s  .  c  om*/
 *
 * @param fromWhen when
 * @return the next occurrence or {@code null} if there is no more
 */
public LocalDateTime nextOccurrence(TemporalAccessor fromWhen) {
    LocalDateTime from = LocalDateTime.from(fromWhen);

    // if it's not today, try the next day
    if (frequency == Frequency.WEEKLY && !days.contains(from.getDayOfWeek())) {
        return nextOccurrence(from.plusDays(1).truncatedTo(ChronoUnit.DAYS));
    }

    // if we've already started, it's too late - next day
    if (from.toLocalTime().isAfter(startTime)) {
        return nextOccurrence(from.plusDays(1).truncatedTo(ChronoUnit.DAYS));
    }

    // otherwise, we're on the right day, so just adjust the time
    return from.with(startTime).truncatedTo(ChronoUnit.MINUTES);
}

From source file:ru.jts_dev.gameserver.time.GameTimeService.java

public long minutesPassed() {
    return MIN_DATE_TIME.until(dateTime, ChronoUnit.MINUTES);
}