public ZonedDateTime plusYears(long amount) { return dt.plusYears(amount); }
public ZonedDateTime plusYears(long amount) { return dt.plusYears(amount); }
public ZonedDateTime plusYears(long amount) { return dt.plusYears(amount); }
/** * Returns a copy of this {@code ZonedDateTime} with the specified period in years subtracted. * <p> * This operates on the local time-line, * {@link LocalDateTime#minusYears(long) subtracting years} to the local date-time. * This is then converted back to a {@code ZonedDateTime}, using the zone ID * to obtain the offset. * <p> * When converting back to {@code ZonedDateTime}, if the local date-time is in an overlap, * then the offset will be retained if possible, otherwise the earlier offset will be used. * If in a gap, the local date-time will be adjusted forward by the length of the gap. * <p> * This instance is immutable and unaffected by this method call. * * @param years the years to subtract, may be negative * @return a {@code ZonedDateTime} based on this date-time with the years subtracted, not null * @throws DateTimeException if the result exceeds the supported date range */ public ZonedDateTime minusYears(long years) { return (years == Long.MIN_VALUE ? plusYears(Long.MAX_VALUE).plusYears(1) : plusYears(-years)); }
/** * This will search for the next time within the next 4 years. If there is no * time matching, an InvalidArgumentException will be thrown (it is very * likely that the cron expression is invalid, like the February 30th). * * @param afterTime A date-time with a time-zone in the ISO-8601 calendar system * @return The next time within next 4 years */ public ZonedDateTime nextTimeAfter(ZonedDateTime afterTime) { return nextTimeAfter(afterTime, afterTime.plusYears(FOUR)); }
public ZonedDateTime nextTimeAfter(ZonedDateTime afterTime, long durationInMillis) { // will search for the next time within the next durationInMillis // millisecond. Be aware that the duration is specified in millis, // but in fact the limit is checked on a day-to-day basis. return nextTimeAfter(afterTime, afterTime.plus(Duration.ofMillis(durationInMillis))); }
private List<String> getPeriods(ZonedDateTime validFrom, ZonedDateTime validTo) { if (periodType != PeriodType.YEAR) { throw new UnsupportedOperationException("Period type: " + periodType + " not supported"); } List<String> periods = new ArrayList<>(); ZonedDateTime current = validFrom; ZonedDateTime nextYear = ZonedDateTime.ofInstant(TimeUtil.now(), ZoneId.of(KLASS_TIME_ZONE)) .plusYears(1).with(DECEMBER).with(lastDayOfMonth()).withHour(23); while (current.isBefore(validTo) && current.isBefore(nextYear)) { periods.add(String.valueOf(current.getYear())); current = current.plusYears(1); } return periods; }
public void test_relativeTime() { SabrParametersIborCapletFloorletVolatilities prov = SabrParametersIborCapletFloorletVolatilities.of(NAME, EUR_EURIBOR_3M, DATE_TIME, PARAM); double test1 = prov.relativeTime(DATE_TIME); assertEquals(test1, 0d); double test2 = prov.relativeTime(DATE_TIME.plusYears(2)); double test3 = prov.relativeTime(DATE_TIME.minusYears(2)); assertEquals(test2, -test3, 1e-2); }
public void test_relativeTime() { SabrParametersSwaptionVolatilities prov = SabrParametersSwaptionVolatilities.of(NAME, CONV, DATE_TIME, PARAM); double test1 = prov.relativeTime(DATE_TIME); assertEquals(test1, 0d); double test2 = prov.relativeTime(DATE_TIME.plusYears(2)); double test3 = prov.relativeTime(DATE_TIME.minusYears(2)); assertEquals(test2, -test3, 1e-2); }
private ExecutionTimeResult getNextPotentialMonth(final ZonedDateTime date, final int lowestHour, final int lowestMinute, final int lowestSecond) { NearestValue nearestValue; nearestValue = months.getNextValue(date.getMonthValue(), 0); final int nextMonths = nearestValue.getValue(); if (nearestValue.getShifts() > 0) { return new ExecutionTimeResult(date.truncatedTo(DAYS).withMonth(1).withDayOfMonth(1).plusYears(nearestValue.getShifts()), false); } final Optional<TimeNode> optionalDays = generateDays(cronDefinition, ZonedDateTime.of(LocalDateTime.of(date.getYear(), nextMonths, 1, 0, 0), date.getZone())); if (optionalDays.isPresent()) { final List<Integer> days = optionalDays.get().getValues(); return new ExecutionTimeResult( date.truncatedTo(SECONDS).withMonth(nextMonths).withDayOfMonth(days.get(0)) .with(LocalTime.of(lowestHour, lowestMinute, lowestSecond)), false); } else { return new ExecutionTimeResult(toBeginOfNextMonth(date), false); } }
@Test public void setValidFromAndUntil() { withPersistentCartDiscount(client(), cartDiscount -> { final ZonedDateTime validFrom = ZonedDateTime.of(2018, 8, 8, 0, 0, 0, 0, ZoneId.systemDefault()); final ZonedDateTime validUntil = ZonedDateTime.now().plusYears(1); final CartDiscount updatedDiscountCode = client().executeBlocking(CartDiscountUpdateCommand.of(cartDiscount, SetValidFromAndUntil.of(validFrom, validUntil))); assertThat(updatedDiscountCode.getValidFrom()).isEqualTo(validFrom); assertThat(updatedDiscountCode.getValidUntil()).isEqualTo(validUntil); }); }
@Test public void setValidFromAndUntil() { withPersistentDiscountCode(client(), discountCode -> { final ZonedDateTime validFrom = ZonedDateTime.of(2018, 8, 8, 0, 0, 0, 0, ZoneId.systemDefault()); final ZonedDateTime validUntil = ZonedDateTime.now().plusYears(1); final DiscountCode updatedDiscountCode = client().executeBlocking(DiscountCodeUpdateCommand.of(discountCode, SetValidFromAndUntil.of(validFrom, validUntil))); assertThat(updatedDiscountCode.getValidFrom()).isEqualTo(validFrom); assertThat(updatedDiscountCode.getValidUntil()).isEqualTo(validUntil); }); }
@Override public ZonedDateTime dateAddDuration(ZonedDateTime date, Duration duration) { if (date == null || duration == null) { return null; } try { int years = duration.getYears(); int months = duration.getMonths(); int days = duration.getDays(); if (duration.getSign() == -1) { return date .minusYears(years) .minusMonths(months) .minusDays(days); } else { return date .plusYears(years) .plusMonths(months) .plusDays(days); } } catch (Throwable e) { String message = String.format("dateAdd(%s, %s)", date, duration); logError(message, e); return null; } }
@Test public void setValidFromAndUntil() throws Exception { withUpdateableProductDiscount(client(), discount -> { final ZonedDateTime start = ZonedDateTime.parse("2015-07-09T07:46:40.230Z"); final ZonedDateTime end = start.plusYears(100); final ProductDiscount updatedDiscount = client().executeBlocking(ProductDiscountUpdateCommand.of(discount, SetValidFromAndUntil.of(start,end ))); assertThat(updatedDiscount.getValidFrom()).isEqualTo(start); assertThat(updatedDiscount.getValidUntil()).isEqualTo(end); return updatedDiscount; }); }
@Test public void changeValidFromUntil() throws Exception { withUpdateableProductDiscount(client(), discount -> { final ZonedDateTime start = ZonedDateTime.parse("2015-07-09T07:46:40.230Z"); final ZonedDateTime end = start.plusYears(100); final ProductDiscount updatedDiscount = client().executeBlocking(ProductDiscountUpdateCommand.of(discount, asList(SetValidFrom.of(start),SetValidUntil.of(end)))); assertThat(updatedDiscount.getValidFrom()).isEqualTo(start); assertThat(updatedDiscount.getValidUntil()).isEqualTo(end); return updatedDiscount; }); }
@Test public void changeValidFromUntil() throws Exception { withPersistentCartDiscount(client(), cartDiscount -> { final ZonedDateTime start = ZonedDateTime.parse("2015-07-09T07:46:40.230Z"); final ZonedDateTime end = start.plusYears(100); final CartDiscount updatedDiscount = client().executeBlocking(CartDiscountUpdateCommand.of(cartDiscount, asList(SetValidFrom.of(start),SetValidUntil.of(end)))); assertThat(updatedDiscount.getValidFrom()).isEqualTo(start); assertThat(updatedDiscount.getValidUntil()).isEqualTo(end); }); }
@Test public void checkContractExpiresAtDistantFutureTime() throws Exception{ Contract futureContract = Contract.fromDslFile(rootPath + "simple_root_contract.yml"); futureContract.addSignerKeyFromFile(rootPath+"_xer0yfe2nn1xthc.private.unikey"); futureContract.getDefinition().setExpiresAt(futureContract.getCreatedAt().plusYears(50)); futureContract.seal(); assertTrue(futureContract.check()); System.out.println("Contract is valid: " + futureContract.isOk()); }
@Test public void checkContractExpiresAtDistantFutureTime() throws Exception{ Contract futureContract = Contract.fromDslFile(ROOT_PATH + "simple_root_contract.yml"); futureContract.addSignerKeyFromFile(ROOT_PATH+"_xer0yfe2nn1xthc.private.unikey"); futureContract.getDefinition().setExpiresAt(futureContract.getCreatedAt().plusYears(50)); futureContract.seal(); assertTrue(futureContract.check()); System.out.println("Contract is valid: " + futureContract.isOk()); registerAndCheckApproved(futureContract); }
private Contract createNetConfigContract(List<NodeInfo> netConfig,PrivateKey issuerKey) throws IOException { Contract contract = new Contract(); contract.setIssuerKeys(issuerKey.getPublicKey()); contract.registerRole(new RoleLink("creator", "issuer")); ListRole listRole = new ListRole("owner"); for(NodeInfo ni: netConfig) { SimpleRole role = new SimpleRole(ni.getName()); contract.registerRole(role); role.addKeyRecord(new KeyRecord(ni.getPublicKey())); listRole.addRole(role); } listRole.setQuorum(netConfig.size()-1); contract.registerRole(listRole); RoleLink ownerLink = new RoleLink("ownerlink","owner"); ChangeOwnerPermission changeOwnerPermission = new ChangeOwnerPermission(ownerLink); HashMap<String,Object> fieldsMap = new HashMap<>(); fieldsMap.put("net_config",null); Binder modifyDataParams = Binder.of("fields",fieldsMap); ModifyDataPermission modifyDataPermission = new ModifyDataPermission(ownerLink,modifyDataParams); contract.addPermission(changeOwnerPermission); contract.addPermission(modifyDataPermission); contract.setExpiresAt(ZonedDateTime.now().plusYears(40)); contract.getStateData().set("net_config",netConfig); contract.addSignerKey(issuerKey); contract.seal(); return contract; }