// start date before end date static LocalDateTime[] parse(String startDateTimeString, String endDateTimeString) { LocalDateTime[] dates = new LocalDateTime[2]; String startDateString = null; String startTimeString = null; String endDateString = null; String endTimeString = null; Pattern pattern = Pattern.compile(DATE_TIME_PATTERN); Matcher matcher = pattern.matcher(startDateTimeString); matcher.find(); startDateString = matcher.group(1); startTimeString = matcher.group(2); matcher = pattern.matcher(endDateTimeString); matcher.find(); endDateString = matcher.group(1); endTimeString = matcher.group(2); if (startDateString == null) { startDateString = processNullStartDate(endDateString); } if (startDateString.equals("now")) { startTimeString = getCurrentTime(); } if (endDateString == null) { endDateString = startDateString; } if (startTimeString == null) { startTimeString = processNullStartTime(startDateString); } if (endTimeString == null) { endTimeString = processNullEndTime(startDateString, endDateString, startTimeString); } LocalDate startDate = DateParser.parse(startDateString); LocalTime startTime = TimeParser.parse(startTimeString); LocalDateTime startDateTime = startDate.atTime(startTime); LocalDate endDate = DateParser.parse(endDateString); LocalTime endTime = TimeParser.parse(endTimeString); LocalDateTime endDateTime = endDate.atTime(endTime); if (endDateTime.isBefore(startDateTime)) { endDateTime.plusDays(1); } dates[0] = startDateTime; dates[1] = endDateTime; return dates; }
public static void main(String[] args) { LocalDate today = LocalDate.now(); // Today’s date System.out.println("TODAY: " + today); /*String strDate = today.plusWeeks(1).toString(); // 2015-09-01 String day; if (strDate.substring(8, 9).matches("0")) { day = strDate.substring(9); System.out.println("DAY IS: " + day); } else { day = strDate.substring(8); System.out.println("DAY IS: " + day); }*/ int dayOfMonth = today.plusDays(4).getDayOfMonth(); System.out.println("DAY OF MONTH: " + dayOfMonth); LocalDate localDate = LocalDate.of(2015, Month.valueOf("OCTOBER"), 25); System.out.println("LOCAL DATE: " + localDate); long toDays = Duration.between(localDate.atTime(0, 0), today.atTime(0, 0)).toDays(); System.out.println("TO DAYS: " + toDays); Duration toDays23 = Duration.between(localDate, today); System.out.println("TO DAYS: " + toDays23); Month month = today.getMonth(); // localDate. System.out.println("Month " + month.toString()); String displayName = month.getDisplayName(TextStyle.FULL, Locale.CANADA); System.out.println("DISPLAY NAME: " + displayName); LocalDate alonzosBirthday = LocalDate.of(1903, 6, 14); alonzosBirthday = LocalDate.of(1903, Month.JUNE, 14); // Uses the Month enumeration System.out.println("alonzosBirthday: " + alonzosBirthday); LocalDate programmersDay = LocalDate.of(2015, 1, 1).plusDays(255); // September 13, but in a leap year it would be September 12 System.out.println("programmersDay: " + programmersDay); LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4); LocalDate christmas = LocalDate.of(2014, Month.DECEMBER, 25); System.out.println("Until christmas: " + independenceDay.until(christmas)); System.out.println( "Until christmas (with crono): " + independenceDay.until(christmas, ChronoUnit.DAYS)); System.out.println(LocalDate.of(2016, 1, 31).plusMonths(1)); System.out.println(LocalDate.of(2016, 3, 31).minusMonths(1)); DayOfWeek startOfLastMillennium = LocalDate.of(1900, 1, 1).getDayOfWeek(); System.out.println("startOfLastMillennium: " + startOfLastMillennium); System.out.println(startOfLastMillennium.getValue()); System.out.println(DayOfWeek.SATURDAY.plus(3)); }
@RequestMapping( method = RequestMethod.GET, params = {"fromDate", "toDate"}) public List<AuditEvent> getByDates( @RequestParam(value = "fromDate") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate fromDate, @RequestParam(value = "toDate") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate toDate) { return auditEventService.findByDates(fromDate.atTime(0, 0), toDate.atTime(23, 59)); }
static LocalDateTime parse(String endDateTimeString) { String endDateString = null; String endTimeString = null; Pattern pattern = Pattern.compile(DATE_TIME_PATTERN); Matcher matcher = pattern.matcher(endDateTimeString); matcher.find(); endDateString = matcher.group(1); endTimeString = matcher.group(2); if (endDateString == null) { endDateString = "today"; } if (endTimeString == null) { endTimeString = END_TIME_DEFAULT; } LocalDate endDate = DateParser.parse(endDateString); LocalTime endTime = TimeParser.parse(endTimeString); LocalDateTime endDateTime = endDate.atTime(endTime); if (endDateTime.isBefore(LocalDateTime.now())) { endDateTime = endDateTime.plusDays(1); } return endDateTime; }
private static void useLocalDate() { LocalDate date = LocalDate.of(2014, 3, 18); int year = date.getYear(); // 2014 Month month = date.getMonth(); // MARCH int day = date.getDayOfMonth(); // 18 DayOfWeek dow = date.getDayOfWeek(); // TUESDAY int len = date.lengthOfMonth(); // 31 (days in March) boolean leap = date.isLeapYear(); // false (not a leap year) System.out.println(date); int y = date.get(ChronoField.YEAR); int m = date.get(ChronoField.MONTH_OF_YEAR); int d = date.get(ChronoField.DAY_OF_MONTH); LocalTime time = LocalTime.of(13, 45, 20); // 13:45:20 int hour = time.getHour(); // 13 int minute = time.getMinute(); // 45 int second = time.getSecond(); // 20 System.out.println(time); LocalDateTime dt1 = LocalDateTime.of(2014, Month.MARCH, 18, 13, 45, 20); // 2014-03-18T13:45 LocalDateTime dt2 = LocalDateTime.of(date, time); LocalDateTime dt3 = date.atTime(13, 45, 20); LocalDateTime dt4 = date.atTime(time); LocalDateTime dt5 = time.atDate(date); System.out.println(dt1); LocalDate date1 = dt1.toLocalDate(); System.out.println(date1); LocalTime time1 = dt1.toLocalTime(); System.out.println(time1); Instant instant = Instant.ofEpochSecond(44 * 365 * 86400); Instant now = Instant.now(); Duration d1 = Duration.between(LocalTime.of(13, 45, 10), time); Duration d2 = Duration.between(instant, now); System.out.println(d1.getSeconds()); System.out.println(d2.getSeconds()); Duration threeMinutes = Duration.of(3, ChronoUnit.MINUTES); System.out.println(threeMinutes); JapaneseDate japaneseDate = JapaneseDate.from(date); System.out.println(japaneseDate); }
/** * Obtains an instance from the implied volatility surface and the date, time and zone for which * it is valid. * * @param surface the implied volatility surface * @param index the Ibor index for which the data is valid * @param valuationDate the valuation date * @param valuationTime the valuation time * @param valuationZone the valuation time zone * @param dayCount the day count applicable to the model * @return the volatilities */ public static NormalIborCapletFloorletExpiryStrikeVolatilities of( NodalSurface surface, IborIndex index, LocalDate valuationDate, LocalTime valuationTime, ZoneId valuationZone, DayCount dayCount) { return of(surface, index, valuationDate.atTime(valuationTime).atZone(valuationZone), dayCount); }
@Test public void shouldPlayWithDates() { LocalDate d1 = LocalDate.now(); LocalDate d2 = LocalDate.of(2014, 2, 15).plusDays(10); print(d1); print(d2); LocalDateTime d3 = d2.atTime(13, 23, 34, 45); assertThat(d3.toString(), is("2014-02-25T13:23:34.000000045")); LocalDateTime d4 = d3.plus(Period.of(1, 2, 3)); assertThat(d4.toString(), is("2015-04-28T13:23:34.000000045")); }
/** Test {@link BlackFxVanillaOptionTradePricer}. */ @Test public class BlackFxVanillaOptionTradePricerTest { private static final LocalDate VAL_DATE = RatesProviderDataSets.VAL_DATE_2014_01_22; private static final LocalTime VAL_TIME = LocalTime.of(13, 45); private static final ZoneId ZONE = ZoneId.of("Z"); private static final ZonedDateTime VAL_DATE_TIME = VAL_DATE.atTime(VAL_TIME).atZone(ZONE); private static final ZonedDateTime EXPIRY = ZonedDateTime.of(2014, 5, 9, 13, 10, 0, 0, ZONE); private static final FxMatrix FX_MATRIX = RatesProviderFxDataSets.fxMatrix(); private static final RatesProvider RATES_PROVIDER = RatesProviderFxDataSets.createProviderEURUSD(VAL_DATE); private static final DoubleArray TIME_TO_EXPIRY = DoubleArray.of(0.01, 0.252, 0.501, 1.0, 2.0, 5.0); private static final DoubleArray ATM = DoubleArray.of(0.175, 0.185, 0.18, 0.17, 0.16, 0.16); private static final DoubleArray DELTA = DoubleArray.of(0.10, 0.25); private static final DoubleMatrix RISK_REVERSAL = DoubleMatrix.ofUnsafe( new double[][] { {-0.010, -0.0050}, {-0.011, -0.0060}, {-0.012, -0.0070}, {-0.013, -0.0080}, {-0.014, -0.0090}, {-0.014, -0.0090} }); private static final DoubleMatrix STRANGLE = DoubleMatrix.ofUnsafe( new double[][] { {0.0300, 0.0100}, {0.0310, 0.0110}, {0.0320, 0.0120}, {0.0330, 0.0130}, {0.0340, 0.0140}, {0.0340, 0.0140} }); private static final InterpolatedStrikeSmileDeltaTermStructure SMILE_TERM = InterpolatedStrikeSmileDeltaTermStructure.of( TIME_TO_EXPIRY, DELTA, ATM, RISK_REVERSAL, STRANGLE, ACT_365F); private static final CurrencyPair CURRENCY_PAIR = CurrencyPair.of(EUR, USD); private static final BlackFxOptionSmileVolatilities VOLS = BlackFxOptionSmileVolatilities.of( FxOptionVolatilitiesName.of("Test"), CURRENCY_PAIR, VAL_DATE_TIME, SMILE_TERM); private static final LocalDate PAYMENT_DATE = LocalDate.of(2014, 5, 13); private static final double NOTIONAL = 1.0e6; private static final CurrencyAmount EUR_AMOUNT = CurrencyAmount.of(EUR, NOTIONAL); private static final CurrencyAmount USD_AMOUNT = CurrencyAmount.of(USD, -NOTIONAL * FX_MATRIX.fxRate(EUR, USD)); private static final ResolvedFxSingle FX_PRODUCT = ResolvedFxSingle.of(EUR_AMOUNT, USD_AMOUNT, PAYMENT_DATE); private static final ResolvedFxVanillaOption OPTION_PRODUCT = ResolvedFxVanillaOption.builder() .longShort(SHORT) .expiry(EXPIRY) .underlying(FX_PRODUCT) .build(); private static final TradeInfo TRADE_INFO = TradeInfo.builder().tradeDate(VAL_DATE).build(); private static final LocalDate CASH_SETTLE_DATE = LocalDate.of(2014, 1, 25); private static final Payment PREMIUM = Payment.of(EUR, NOTIONAL * 0.027, CASH_SETTLE_DATE); private static final ResolvedFxVanillaOptionTrade OPTION_TRADE = ResolvedFxVanillaOptionTrade.builder() .premium(PREMIUM) .product(OPTION_PRODUCT) .info(TRADE_INFO) .build(); private static final BlackFxVanillaOptionProductPricer PRICER_PRODUCT = BlackFxVanillaOptionProductPricer.DEFAULT; private static final BlackFxVanillaOptionTradePricer PRICER_TRADE = BlackFxVanillaOptionTradePricer.DEFAULT; private static final DiscountingPaymentPricer PRICER_PAYMENT = DiscountingPaymentPricer.DEFAULT; private static final double TOL = 1.0e-13; public void test_presentValue() { MultiCurrencyAmount pvSensiTrade = PRICER_TRADE.presentValue(OPTION_TRADE, RATES_PROVIDER, VOLS); CurrencyAmount pvSensiProduct = PRICER_PRODUCT.presentValue(OPTION_PRODUCT, RATES_PROVIDER, VOLS); CurrencyAmount pvSensiPremium = PRICER_PAYMENT.presentValue(PREMIUM, RATES_PROVIDER); assertEquals(pvSensiTrade, MultiCurrencyAmount.of(pvSensiProduct, pvSensiPremium)); } public void test_presentValueSensitivity() { PointSensitivities pvSensiTrade = PRICER_TRADE.presentValueSensitivityRates(OPTION_TRADE, RATES_PROVIDER, VOLS); PointSensitivities pvSensiProduct = PRICER_PRODUCT.presentValueSensitivityRates(OPTION_PRODUCT, RATES_PROVIDER, VOLS); PointSensitivities pvSensiPremium = PRICER_PAYMENT.presentValueSensitivity(PREMIUM, RATES_PROVIDER).build(); assertEquals(pvSensiTrade, pvSensiProduct.combinedWith(pvSensiPremium)); } public void test_presentValueSensitivityBlackVolatility() { PointSensitivities pvSensiTrade = PRICER_TRADE.presentValueSensitivityModelParamsVolatility( OPTION_TRADE, RATES_PROVIDER, VOLS); PointSensitivities pvSensiProduct = PRICER_PRODUCT .presentValueSensitivityModelParamsVolatility(OPTION_PRODUCT, RATES_PROVIDER, VOLS) .build(); assertEquals(pvSensiTrade, pvSensiProduct); } public void test_currencyExposure() { MultiCurrencyAmount ceComputed = PRICER_TRADE.currencyExposure(OPTION_TRADE, RATES_PROVIDER, VOLS); PointSensitivities point = PRICER_TRADE.presentValueSensitivityRates(OPTION_TRADE, RATES_PROVIDER, VOLS); MultiCurrencyAmount pv = PRICER_TRADE.presentValue(OPTION_TRADE, RATES_PROVIDER, VOLS); MultiCurrencyAmount ceExpected = RATES_PROVIDER.currencyExposure(point).plus(pv); assertEquals(ceComputed.size(), 2); assertEquals( ceComputed.getAmount(EUR).getAmount(), ceExpected.getAmount(EUR).getAmount(), TOL * NOTIONAL); assertEquals( ceComputed.getAmount(USD).getAmount(), ceExpected.getAmount(USD).getAmount(), TOL * NOTIONAL); } public void test_currentCash_zero() { assertEquals( PRICER_TRADE.currentCash(OPTION_TRADE, VAL_DATE), CurrencyAmount.zero(PREMIUM.getCurrency())); } public void test_currentCash_onSettle() { assertEquals(PRICER_TRADE.currentCash(OPTION_TRADE, CASH_SETTLE_DATE), PREMIUM.getValue()); } }
/** Test {@link BlackVolatilityExpiryTenorSwaptionProvider}. */ @Test public class BlackVolatilityExpiryTenorSwaptionProviderTest { private static final Interpolator1D LINEAR_FLAT = CombinedInterpolatorExtrapolator.of( CurveInterpolators.LINEAR.getName(), CurveExtrapolators.FLAT.getName(), CurveExtrapolators.FLAT.getName()); private static final GridInterpolator2D INTERPOLATOR_2D = new GridInterpolator2D(LINEAR_FLAT, LINEAR_FLAT); private static final DoubleArray TIME = DoubleArray.of(0.25, 0.5, 1.0, 0.25, 0.5, 1.0, 0.25, 0.5, 1.0, 0.25, 0.5, 1.0); private static final DoubleArray TENOR = DoubleArray.of(3.0, 3.0, 3.0, 5.0, 5.0, 5.0, 7.0, 7.0, 7.0, 10.0, 10.0, 10.0); private static final DoubleArray VOL = DoubleArray.of(0.14, 0.12, 0.1, 0.14, 0.13, 0.12, 0.13, 0.12, 0.11, 0.12, 0.11, 0.1); private static final SurfaceMetadata METADATA_WITH_PARAM; private static final SurfaceMetadata METADATA; static { List<SwaptionSurfaceExpiryTenorNodeMetadata> list = new ArrayList<SwaptionSurfaceExpiryTenorNodeMetadata>(); int nData = TIME.size(); for (int i = 0; i < nData; ++i) { SwaptionSurfaceExpiryTenorNodeMetadata parameterMetadata = SwaptionSurfaceExpiryTenorNodeMetadata.of(TIME.get(i), TENOR.get(i)); list.add(parameterMetadata); } METADATA_WITH_PARAM = DefaultSurfaceMetadata.builder() .dayCount(ACT_365F) .parameterMetadata(list) .surfaceName(SurfaceName.of("GOVT1-SWAPTION-VOL")) .xValueType(ValueType.YEAR_FRACTION) .yValueType(ValueType.YEAR_FRACTION) .build(); METADATA = DefaultSurfaceMetadata.builder() .dayCount(ACT_365F) .surfaceName(SurfaceName.of("GOVT1-SWAPTION-VOL")) .xValueType(ValueType.YEAR_FRACTION) .yValueType(ValueType.YEAR_FRACTION) .build(); } private static final InterpolatedNodalSurface SURFACE_WITH_PARAM = InterpolatedNodalSurface.of(METADATA_WITH_PARAM, TIME, TENOR, VOL, INTERPOLATOR_2D); private static final InterpolatedNodalSurface SURFACE = InterpolatedNodalSurface.of(METADATA, TIME, TENOR, VOL, INTERPOLATOR_2D); private static final FixedIborSwapConvention CONVENTION = FixedIborSwapConventions.GBP_FIXED_1Y_LIBOR_3M; private static final LocalDate VALUATION_DATE = date(2015, 2, 17); private static final LocalTime VALUATION_TIME = LocalTime.of(13, 45); private static final ZoneId LONDON_ZONE = ZoneId.of("Europe/London"); private static final ZonedDateTime VALUATION_DATE_TIME = VALUATION_DATE.atTime(VALUATION_TIME).atZone(LONDON_ZONE); private static final BlackVolatilityExpiryTenorSwaptionProvider PROVIDER_WITH_PARAM = BlackVolatilityExpiryTenorSwaptionProvider.of( SURFACE_WITH_PARAM, CONVENTION, ACT_365F, VALUATION_DATE, VALUATION_TIME, LONDON_ZONE); private static final BlackVolatilityExpiryTenorSwaptionProvider PROVIDER = BlackVolatilityExpiryTenorSwaptionProvider.of( SURFACE, CONVENTION, ACT_365F, VALUATION_DATE, VALUATION_TIME, LONDON_ZONE); private static final ZonedDateTime[] TEST_OPTION_EXPIRY = new ZonedDateTime[] { dateUtc(2015, 2, 17), dateUtc(2015, 5, 17), dateUtc(2015, 6, 17), dateUtc(2017, 2, 17) }; private static final int NB_TEST = TEST_OPTION_EXPIRY.length; private static final double[] TEST_TENOR = new double[] {2.0, 6.0, 7.0, 15.0}; private static final double[] TEST_SENSITIVITY = new double[] {1.0, 1.0, 1.0, 1.0}; private static final double TEST_FORWARD = 0.025; // not used internally private static final double TEST_STRIKE = 0.03; // not used internally private static final double TOLERANCE_VOL = 1.0E-10; // ------------------------------------------------------------------------- public void test_valuationDate() { assertEquals(PROVIDER_WITH_PARAM.getValuationDateTime(), VALUATION_DATE_TIME); } public void test_swapConvention() { assertEquals(PROVIDER_WITH_PARAM.getConvention(), CONVENTION); } public void test_tenor() { double test1 = PROVIDER_WITH_PARAM.tenor(VALUATION_DATE, VALUATION_DATE); assertEquals(test1, 0d); double test2 = PROVIDER_WITH_PARAM.tenor(VALUATION_DATE, date(2018, 2, 28)); assertEquals(test2, 3d); double test3 = PROVIDER_WITH_PARAM.tenor(VALUATION_DATE, date(2018, 2, 10)); assertEquals(test3, 3d); } public void test_relativeTime() { double test1 = PROVIDER_WITH_PARAM.relativeTime(VALUATION_DATE_TIME); assertEquals(test1, 0d); double test2 = PROVIDER_WITH_PARAM.relativeTime(date(2018, 2, 17).atStartOfDay(LONDON_ZONE)); double test3 = PROVIDER_WITH_PARAM.relativeTime(date(2012, 2, 17).atStartOfDay(LONDON_ZONE)); assertEquals(test2, -test3); // consistency checked } public void test_volatility() { for (int i = 0; i < NB_TEST; i++) { double expiryTime = PROVIDER_WITH_PARAM.relativeTime(TEST_OPTION_EXPIRY[i]); double volExpected = SURFACE_WITH_PARAM.zValue(expiryTime, TEST_TENOR[i]); double volComputed = PROVIDER_WITH_PARAM.getVolatility( TEST_OPTION_EXPIRY[i], TEST_TENOR[i], TEST_STRIKE, TEST_FORWARD); assertEquals(volComputed, volExpected, TOLERANCE_VOL); } } public void test_volatility_sensitivity() { double eps = 1.0e-6; int nData = TIME.size(); for (int i = 0; i < NB_TEST; i++) { SwaptionSensitivity point = SwaptionSensitivity.of( CONVENTION, TEST_OPTION_EXPIRY[i], TENOR.get(i), TEST_STRIKE, TEST_FORWARD, GBP, TEST_SENSITIVITY[i]); SurfaceCurrencyParameterSensitivity sensi = PROVIDER_WITH_PARAM.surfaceCurrencyParameterSensitivity(point); Map<DoublesPair, Double> map = new HashMap<DoublesPair, Double>(); for (int j = 0; j < nData; ++j) { DoubleArray volDataUp = VOL.subArray(0, nData).with(j, VOL.get(j) + eps); DoubleArray volDataDw = VOL.subArray(0, nData).with(j, VOL.get(j) - eps); InterpolatedNodalSurface paramUp = InterpolatedNodalSurface.of( METADATA_WITH_PARAM, TIME, TENOR, volDataUp, INTERPOLATOR_2D); InterpolatedNodalSurface paramDw = InterpolatedNodalSurface.of( METADATA_WITH_PARAM, TIME, TENOR, volDataDw, INTERPOLATOR_2D); BlackVolatilityExpiryTenorSwaptionProvider provUp = BlackVolatilityExpiryTenorSwaptionProvider.of( paramUp, CONVENTION, ACT_365F, VALUATION_DATE_TIME); BlackVolatilityExpiryTenorSwaptionProvider provDw = BlackVolatilityExpiryTenorSwaptionProvider.of( paramDw, CONVENTION, ACT_365F, VALUATION_DATE_TIME); double volUp = provUp.getVolatility(TEST_OPTION_EXPIRY[i], TEST_TENOR[i], TEST_STRIKE, TEST_FORWARD); double volDw = provDw.getVolatility(TEST_OPTION_EXPIRY[i], TEST_TENOR[i], TEST_STRIKE, TEST_FORWARD); double fd = 0.5 * (volUp - volDw) / eps; map.put(DoublesPair.of(TIME.get(j), TENOR.get(j)), fd); } SurfaceCurrencyParameterSensitivity sensiFromNoMetadata = PROVIDER.surfaceCurrencyParameterSensitivity(point); List<SurfaceParameterMetadata> list = sensi.getMetadata().getParameterMetadata().get(); DoubleArray computed = sensi.getSensitivity(); assertEquals(computed.size(), nData); for (int j = 0; j < list.size(); ++j) { SwaptionSurfaceExpiryTenorNodeMetadata metadata = (SwaptionSurfaceExpiryTenorNodeMetadata) list.get(i); double expected = map.get(DoublesPair.of(metadata.getYearFraction(), metadata.getTenor())); assertEquals(computed.get(i), expected, eps); assertTrue( sensiFromNoMetadata.getMetadata().getParameterMetadata().get().contains(metadata)); } } } // ------------------------------------------------------------------------- public void coverage() { BlackVolatilityExpiryTenorSwaptionProvider test1 = BlackVolatilityExpiryTenorSwaptionProvider.of( SURFACE_WITH_PARAM, CONVENTION, ACT_365F, VALUATION_DATE_TIME); coverImmutableBean(test1); BlackVolatilityExpiryTenorSwaptionProvider test2 = BlackVolatilityExpiryTenorSwaptionProvider.of(SURFACE, CONVENTION, ACT_360, VALUATION_DATE); coverBeanEquals(test1, test2); } }
/** Test {@link BlackBondFutureOptionMarginedProductPricer}. */ @Test public class BlackBondFutureOptionMarginedProductPricerTest { // product private static final StandardId FUTURE_SECURITY_ID = BondDataSets.FUTURE_SECURITY_ID_EUR; private static final BondFutureOption FUTURE_OPTION_PRODUCT = BondDataSets.FUTURE_OPTION_PRODUCT_EUR_116; // curves private static final LegalEntityDiscountingProvider RATE_PROVIDER = LegalEntityDiscountingProviderDataSets.ISSUER_REPO_ZERO_EUR; // vol surface private static final Interpolator1D LINEAR_FLAT = CombinedInterpolatorExtrapolator.of( CurveInterpolators.LINEAR, CurveExtrapolators.FLAT, CurveExtrapolators.FLAT); private static final GridInterpolator2D INTERPOLATOR_2D = new GridInterpolator2D(LINEAR_FLAT, LINEAR_FLAT); private static final DoubleArray TIME = DoubleArray.of(0.20, 0.20, 0.20, 0.20, 0.20, 0.45, 0.45, 0.45, 0.45, 0.45); private static final DoubleArray MONEYNESS = DoubleArray.of(-0.050, -0.005, 0.000, 0.005, 0.050, -0.050, -0.005, 0.000, 0.005, 0.050); private static final DoubleArray VOL = DoubleArray.of(0.50, 0.49, 0.47, 0.48, 0.51, 0.45, 0.44, 0.42, 0.43, 0.46); private static final SurfaceMetadata METADATA; static { List<GenericVolatilitySurfaceYearFractionMetadata> list = new ArrayList<GenericVolatilitySurfaceYearFractionMetadata>(); int nData = TIME.size(); for (int i = 0; i < nData; ++i) { GenericVolatilitySurfaceYearFractionMetadata parameterMetadata = GenericVolatilitySurfaceYearFractionMetadata.of( TIME.get(i), LogMoneynessStrike.of(MONEYNESS.get(i))); list.add(parameterMetadata); } METADATA = DefaultSurfaceMetadata.builder() .dayCount(ACT_365F) .parameterMetadata(list) .surfaceName(SurfaceName.of("GOVT1-BOND-FUT-VOL")) .xValueType(ValueType.YEAR_FRACTION) .yValueType(ValueType.STRIKE) .build(); } private static final InterpolatedNodalSurface SURFACE = InterpolatedNodalSurface.of(METADATA, TIME, MONEYNESS, VOL, INTERPOLATOR_2D); private static final LocalDate VALUATION_DATE = RATE_PROVIDER.getValuationDate(); private static final LocalTime VALUATION_TIME = LocalTime.of(0, 0); private static final ZoneId ZONE = FUTURE_OPTION_PRODUCT.getExpiryZone(); private static final ZonedDateTime VALUATION_DATE_TIME = VALUATION_DATE.atTime(VALUATION_TIME).atZone(ZONE); private static final BlackVolatilityExpLogMoneynessBondFutureProvider VOL_PROVIDER = BlackVolatilityExpLogMoneynessBondFutureProvider.of( SURFACE, FUTURE_SECURITY_ID, ACT_365F, VALUATION_DATE_TIME); private static final double TOL = 1.0E-13; private static final double EPS = 1.0e-6; // pricer private static final DiscountingBondFutureProductPricer FUTURE_PRICER = DiscountingBondFutureProductPricer.DEFAULT; private static final BlackBondFutureOptionMarginedProductPricer OPTION_PRICER = new BlackBondFutureOptionMarginedProductPricer(FUTURE_PRICER); private static final RatesFiniteDifferenceSensitivityCalculator FD_CAL = new RatesFiniteDifferenceSensitivityCalculator(EPS); public void test_getFuturePricer() { assertSame(OPTION_PRICER.getFuturePricer(), FUTURE_PRICER); } public void test_price() { double computed = OPTION_PRICER.price(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER); double futurePrice = FUTURE_PRICER.price(FUTURE_OPTION_PRODUCT.getUnderlying(), RATE_PROVIDER); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VALUATION_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double vol = SURFACE.zValue(expiryTime, logMoneyness); double expected = BlackFormulaRepository.price(futurePrice, strike, expiryTime, vol, true); assertEquals(computed, expected, TOL); } public void test_price_from_future_price() { double futurePrice = 1.1d; double computed = OPTION_PRICER.price(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER, futurePrice); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VALUATION_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double vol = SURFACE.zValue(expiryTime, logMoneyness); double expected = BlackFormulaRepository.price(futurePrice, strike, expiryTime, vol, true); assertEquals(computed, expected, TOL); } public void test_price_from_generic_provider() { BondFutureProvider volProvider = BlackVolatilityExpLogMoneynessBondFutureProvider.of( SURFACE, FUTURE_SECURITY_ID, ACT_365F, VALUATION_DATE_TIME); double computed = OPTION_PRICER.price(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, volProvider); double expected = OPTION_PRICER.price(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER); assertEquals(computed, expected, TOL); } // ------------------------------------------------------------------------- public void test_delta() { double computed = OPTION_PRICER.deltaStickyStrike(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER); double futurePrice = FUTURE_PRICER.price(FUTURE_OPTION_PRODUCT.getUnderlying(), RATE_PROVIDER); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VALUATION_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double vol = SURFACE.zValue(expiryTime, logMoneyness); double expected = BlackFormulaRepository.delta(futurePrice, strike, expiryTime, vol, true); assertEquals(computed, expected, TOL); } public void test_delta_from_future_price() { double futurePrice = 1.1d; double computed = OPTION_PRICER.deltaStickyStrike( FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER, futurePrice); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VALUATION_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double vol = SURFACE.zValue(expiryTime, logMoneyness); double expected = BlackFormulaRepository.delta(futurePrice, strike, expiryTime, vol, true); assertEquals(computed, expected, TOL); } public void test_gamma() { double computed = OPTION_PRICER.gammaStickyStrike(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER); double futurePrice = FUTURE_PRICER.price(FUTURE_OPTION_PRODUCT.getUnderlying(), RATE_PROVIDER); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VALUATION_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double vol = SURFACE.zValue(expiryTime, logMoneyness); double expected = BlackFormulaRepository.gamma(futurePrice, strike, expiryTime, vol); assertEquals(computed, expected, TOL); } public void test_gamma_from_future_price() { double futurePrice = 1.1d; double computed = OPTION_PRICER.gammaStickyStrike( FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER, futurePrice); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VALUATION_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double vol = SURFACE.zValue(expiryTime, logMoneyness); double expected = BlackFormulaRepository.gamma(futurePrice, strike, expiryTime, vol); assertEquals(computed, expected, TOL); } public void test_theta() { double computed = OPTION_PRICER.theta(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER); double futurePrice = FUTURE_PRICER.price(FUTURE_OPTION_PRODUCT.getUnderlying(), RATE_PROVIDER); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VALUATION_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double vol = SURFACE.zValue(expiryTime, logMoneyness); double expected = BlackFormulaRepository.driftlessTheta(futurePrice, strike, expiryTime, vol); assertEquals(computed, expected, TOL); } public void test_theta_from_future_price() { double futurePrice = 1.1d; double computed = OPTION_PRICER.theta(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER, futurePrice); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VALUATION_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double vol = SURFACE.zValue(expiryTime, logMoneyness); double expected = BlackFormulaRepository.driftlessTheta(futurePrice, strike, expiryTime, vol); assertEquals(computed, expected, TOL); } // ------------------------------------------------------------------------- public void test_priceSensitivity() { PointSensitivities point = OPTION_PRICER.priceSensitivityStickyStrike( FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER); CurveCurrencyParameterSensitivities computed = RATE_PROVIDER.curveParameterSensitivity(point); CurveCurrencyParameterSensitivities expected = FD_CAL.sensitivity( RATE_PROVIDER, (p) -> CurrencyAmount.of( EUR, OPTION_PRICER.price(FUTURE_OPTION_PRODUCT, (p), VOL_PROVIDER))); double futurePrice = FUTURE_PRICER.price(FUTURE_OPTION_PRODUCT.getUnderlying(), RATE_PROVIDER); double strike = FUTURE_OPTION_PRODUCT.getStrikePrice(); double expiryTime = ACT_365F.relativeYearFraction(VALUATION_DATE, FUTURE_OPTION_PRODUCT.getExpiryDate()); double logMoneyness = Math.log(strike / futurePrice); double logMoneynessUp = Math.log(strike / (futurePrice + EPS)); double logMoneynessDw = Math.log(strike / (futurePrice - EPS)); double vol = SURFACE.zValue(expiryTime, logMoneyness); double volUp = SURFACE.zValue(expiryTime, logMoneynessUp); double volDw = SURFACE.zValue(expiryTime, logMoneynessDw); double volSensi = 0.5 * (volUp - volDw) / EPS; double vega = BlackFormulaRepository.vega(futurePrice, strike, expiryTime, vol); CurveCurrencyParameterSensitivities sensiVol = RATE_PROVIDER .curveParameterSensitivity( FUTURE_PRICER.priceSensitivity( FUTURE_OPTION_PRODUCT.getUnderlying(), RATE_PROVIDER)) .multipliedBy(-vega * volSensi); expected = expected.combinedWith(sensiVol); assertTrue(computed.equalWithTolerance(expected, 30d * EPS)); } public void test_priceSensitivity_from_future_price() { double futurePrice = 1.1d; PointSensitivities point = OPTION_PRICER.priceSensitivityStickyStrike( FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER, futurePrice); CurveCurrencyParameterSensitivities computed = RATE_PROVIDER.curveParameterSensitivity(point); double delta = OPTION_PRICER.deltaStickyStrike( FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER, futurePrice); CurveCurrencyParameterSensitivities expected = RATE_PROVIDER .curveParameterSensitivity( FUTURE_PRICER.priceSensitivity( FUTURE_OPTION_PRODUCT.getUnderlying(), RATE_PROVIDER)) .multipliedBy(delta); assertTrue(computed.equalWithTolerance(expected, TOL)); } public void test_priceSensitivity_from_generic_provider() { BondFutureProvider volProvider = BlackVolatilityExpLogMoneynessBondFutureProvider.of( SURFACE, FUTURE_SECURITY_ID, ACT_365F, VALUATION_DATE_TIME); PointSensitivities expected = OPTION_PRICER.priceSensitivityStickyStrike( FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER); PointSensitivities computed = OPTION_PRICER.priceSensitivity(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, volProvider); assertEquals(computed, expected); } // ------------------------------------------------------------------------- public void test_priceSensitivityBlackVolatility() { BondFutureOptionSensitivity sensi = OPTION_PRICER.priceSensitivityBlackVolatility( FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER); testPriceSensitivityBlackVolatility( VOL_PROVIDER.surfaceCurrencyParameterSensitivity(sensi), (p) -> OPTION_PRICER.price(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, (p))); } public void test_priceSensitivityBlackVolatility_from_future_price() { double futurePrice = 1.1d; BondFutureOptionSensitivity sensi = OPTION_PRICER.priceSensitivityBlackVolatility( FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER, futurePrice); testPriceSensitivityBlackVolatility( VOL_PROVIDER.surfaceCurrencyParameterSensitivity(sensi), (p) -> OPTION_PRICER.price(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, (p), futurePrice)); } private void testPriceSensitivityBlackVolatility( SurfaceCurrencyParameterSensitivity computed, Function<BlackVolatilityBondFutureProvider, Double> valueFn) { List<SurfaceParameterMetadata> list = computed.getMetadata().getParameterMetadata().get(); int nVol = VOL.size(); assertEquals(list.size(), nVol); for (int i = 0; i < nVol; ++i) { double[] volUp = Arrays.copyOf(VOL.toArray(), nVol); double[] volDw = Arrays.copyOf(VOL.toArray(), nVol); volUp[i] += EPS; volDw[i] -= EPS; InterpolatedNodalSurface sfUp = InterpolatedNodalSurface.of( METADATA, TIME, MONEYNESS, DoubleArray.copyOf(volUp), INTERPOLATOR_2D); InterpolatedNodalSurface sfDw = InterpolatedNodalSurface.of( METADATA, TIME, MONEYNESS, DoubleArray.copyOf(volDw), INTERPOLATOR_2D); BlackVolatilityExpLogMoneynessBondFutureProvider provUp = BlackVolatilityExpLogMoneynessBondFutureProvider.of( sfUp, FUTURE_SECURITY_ID, ACT_365F, VALUATION_DATE_TIME); BlackVolatilityExpLogMoneynessBondFutureProvider provDw = BlackVolatilityExpLogMoneynessBondFutureProvider.of( sfDw, FUTURE_SECURITY_ID, ACT_365F, VALUATION_DATE_TIME); double expected = 0.5 * (valueFn.apply(provUp) - valueFn.apply(provDw)) / EPS; int index = -1; for (int j = 0; j < nVol; ++j) { GenericVolatilitySurfaceYearFractionMetadata meta = (GenericVolatilitySurfaceYearFractionMetadata) list.get(j); if (meta.getYearFraction() == TIME.get(i) && meta.getStrike().getValue() == MONEYNESS.get(i)) { index = j; continue; } } assertEquals(computed.getSensitivity().get(index), expected, EPS); } } // ------------------------------------------------------------------------- public void test_marginIndex() { double price = 0.12d; double computed = OPTION_PRICER.marginIndex(FUTURE_OPTION_PRODUCT, price); assertEquals(computed, price * FUTURE_OPTION_PRODUCT.getUnderlying().getNotional()); } public void test_marginIndexSensitivity() { PointSensitivities point = OPTION_PRICER.priceSensitivityStickyStrike( FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER); PointSensitivities computed = OPTION_PRICER.marginIndexSensitivity(FUTURE_OPTION_PRODUCT, point); assertEquals(computed, point.multipliedBy(FUTURE_OPTION_PRODUCT.getUnderlying().getNotional())); } // ------------------------------------------------------------------------- public void regression_price() { double price = OPTION_PRICER.price(FUTURE_OPTION_PRODUCT, RATE_PROVIDER, VOL_PROVIDER); assertEquals(price, 0.08916005173932573, TOL); // 2.x } }
/** Test {@link BlackBondFutureExpiryLogMoneynessVolatilities}. */ @Test public class BlackBondFutureExpiryLogMoneynessVolatilitiesTest { private static final SurfaceInterpolator INTERPOLATOR_2D = GridSurfaceInterpolator.of(LINEAR, LINEAR); private static final DoubleArray TIME = DoubleArray.of(0.25, 0.25, 0.25, 0.25, 0.50, 0.50, 0.50, 0.50, 1.00, 1.00, 1.00, 1.00); private static final DoubleArray MONEYNESS = DoubleArray.of(-0.02, -0.01, 0.00, 0.01, -0.02, -0.01, 0.00, 0.01, -0.02, -0.01, 0.00, 0.01); private static final DoubleArray VOL = DoubleArray.of( 0.01, 0.011, 0.012, 0.010, 0.011, 0.012, 0.013, 0.012, 0.012, 0.013, 0.014, 0.014); private static final SurfaceMetadata METADATA; static { List<GenericVolatilitySurfaceYearFractionParameterMetadata> list = new ArrayList<GenericVolatilitySurfaceYearFractionParameterMetadata>(); int nData = TIME.size(); for (int i = 0; i < nData; ++i) { GenericVolatilitySurfaceYearFractionParameterMetadata parameterMetadata = GenericVolatilitySurfaceYearFractionParameterMetadata.of( TIME.get(i), LogMoneynessStrike.of(MONEYNESS.get(i))); list.add(parameterMetadata); } METADATA = DefaultSurfaceMetadata.builder() .surfaceName(SurfaceName.of("GOVT1-BOND-FUT-VOL")) .xValueType(ValueType.YEAR_FRACTION) .yValueType(ValueType.LOG_MONEYNESS) .zValueType(ValueType.BLACK_VOLATILITY) .dayCount(ACT_365F) .parameterMetadata(list) .build(); } private static final InterpolatedNodalSurface SURFACE = InterpolatedNodalSurface.of(METADATA, TIME, MONEYNESS, VOL, INTERPOLATOR_2D); private static final LocalDate VAL_DATE = date(2015, 2, 17); private static final LocalTime VAL_TIME = LocalTime.of(13, 45); private static final ZoneId LONDON_ZONE = ZoneId.of("Europe/London"); private static final ZonedDateTime VAL_DATE_TIME = VAL_DATE.atTime(VAL_TIME).atZone(LONDON_ZONE); private static final BlackBondFutureExpiryLogMoneynessVolatilities VOLS = BlackBondFutureExpiryLogMoneynessVolatilities.of(VAL_DATE_TIME, SURFACE); private static final ZonedDateTime[] TEST_OPTION_EXPIRY = new ZonedDateTime[] { dateUtc(2015, 2, 17), dateUtc(2015, 5, 17), dateUtc(2015, 6, 17), dateUtc(2017, 2, 17) }; private static final int NB_TEST = TEST_OPTION_EXPIRY.length; private static final LocalDate[] TEST_FUTURE_EXPIRY = new LocalDate[] {date(2015, 2, 17), date(2015, 5, 17), date(2015, 5, 17), date(2015, 5, 17)}; private static final double[] TEST_STRIKE_PRICE = new double[] {0.985, 0.985, 0.985, 0.985}; private static final double[] TEST_FUTURE_PRICE = new double[] {0.98, 0.985, 1.00, 1.01}; // private static final double[] TEST_SENSITIVITY = new double[] {9.2, 16.0, 1.8, 5.7 }; private static final double[] TEST_SENSITIVITY = new double[] {1.0, 1.0, 1.0, 1.0}; private static final double TOLERANCE_VOL = 1.0E-10; // ------------------------------------------------------------------------- public void test_valuationDate() { assertEquals(VOLS.getValuationDateTime(), VAL_DATE_TIME); } public void test_volatility() { for (int i = 0; i < NB_TEST; i++) { double expiryTime = VOLS.relativeTime(TEST_OPTION_EXPIRY[i]); double volExpected = SURFACE.zValue(expiryTime, Math.log(TEST_STRIKE_PRICE[i] / TEST_FUTURE_PRICE[i])); double volComputed = VOLS.volatility( TEST_OPTION_EXPIRY[i], TEST_FUTURE_EXPIRY[i], TEST_STRIKE_PRICE[i], TEST_FUTURE_PRICE[i]); assertEquals(volComputed, volExpected, TOLERANCE_VOL); } } public void test_volatility_sensitivity() { double eps = 1.0e-6; int nData = TIME.size(); for (int i = 0; i < NB_TEST; i++) { double expiry = VOLS.relativeTime(TEST_OPTION_EXPIRY[i]); BondFutureOptionSensitivity point = BondFutureOptionSensitivity.of( VOLS.getName(), expiry, TEST_FUTURE_EXPIRY[i], TEST_STRIKE_PRICE[i], TEST_FUTURE_PRICE[i], USD, TEST_SENSITIVITY[i]); CurrencyParameterSensitivity sensActual = VOLS.parameterSensitivity(point).getSensitivities().get(0); double[] computed = sensActual.getSensitivity().toArray(); for (int j = 0; j < nData; j++) { DoubleArray volDataUp = VOL.with(j, VOL.get(j) + eps); DoubleArray volDataDw = VOL.with(j, VOL.get(j) - eps); InterpolatedNodalSurface paramUp = InterpolatedNodalSurface.of(METADATA, TIME, MONEYNESS, volDataUp, INTERPOLATOR_2D); InterpolatedNodalSurface paramDw = InterpolatedNodalSurface.of(METADATA, TIME, MONEYNESS, volDataDw, INTERPOLATOR_2D); BlackBondFutureExpiryLogMoneynessVolatilities provUp = BlackBondFutureExpiryLogMoneynessVolatilities.of(VAL_DATE_TIME, paramUp); BlackBondFutureExpiryLogMoneynessVolatilities provDw = BlackBondFutureExpiryLogMoneynessVolatilities.of(VAL_DATE_TIME, paramDw); double volUp = provUp.volatility( expiry, TEST_FUTURE_EXPIRY[i], TEST_STRIKE_PRICE[i], TEST_FUTURE_PRICE[i]); double volDw = provDw.volatility( expiry, TEST_FUTURE_EXPIRY[i], TEST_STRIKE_PRICE[i], TEST_FUTURE_PRICE[i]); double fd = 0.5 * (volUp - volDw) / eps; assertEquals(computed[j], fd, eps); } } } // ------------------------------------------------------------------------- public void coverage() { BlackBondFutureExpiryLogMoneynessVolatilities test1 = BlackBondFutureExpiryLogMoneynessVolatilities.of(VAL_DATE_TIME, SURFACE); coverImmutableBean(test1); BlackBondFutureExpiryLogMoneynessVolatilities test2 = BlackBondFutureExpiryLogMoneynessVolatilities.of( VAL_DATE_TIME.plusDays(1), SURFACE.withParameter(0, 1d)); coverBeanEquals(test1, test2); } }
@FilterWith(XSRFFilter.class) public Result dryRun( Context context, @Param("startDate") String start, @Param("endDate") String end) { long _start = System.currentTimeMillis(); FlashScope flash = context.getFlashScope(); LocalDate startDate = null; LocalDate endDate = null; try { startDate = LocalDate.parse(start); endDate = LocalDate.parse(end); } catch (Exception ex) { } if (startDate == null || endDate == null || startDate.isAfter(endDate)) { flash.error("error.invalidDate"); return Results.redirect(router.getReverseRoute(DebugController.class, "debug")); } Run lastRun = baseDB.run.findLast(Module.GOOGLE, null, null); if (lastRun != null && lastRun.getDay().isAfter(startDate)) { flash.error("error.invalidDate"); return Results.redirect(router.getReverseRoute(DebugController.class, "debug")); } LocalDate date = LocalDate.from(startDate); GoogleSettings ggOptions = googleDB.options.get(); int minPauseBetweenPageSec = ggOptions.getMinPauseBetweenPageSec(); int maxPauseBetweenPageSec = ggOptions.getMaxPauseBetweenPageSec(); ggOptions.setMinPauseBetweenPageSec(0); ggOptions.setMaxPauseBetweenPageSec(0); googleDB.options.update(ggOptions); try { while (date.isBefore(endDate)) { LOG.debug("dry run {}", date); if (!taskManager.startGoogleTask( new Run(Run.Mode.MANUAL, Module.GOOGLE, date.atTime(13, 37, 00)))) { LOG.error("can't startGoogleTask"); flash.error("can't startGoogleTask"); return Results.redirect(router.getReverseRoute(DebugController.class, "debug")); } taskManager.joinGoogleTask(); date = date.plusDays(1); } } catch (Exception ex) { LOG.error("an error occured", ex); flash.error("an error occured"); return Results.redirect(router.getReverseRoute(DebugController.class, "debug")); } finally { ggOptions.setMinPauseBetweenPageSec(minPauseBetweenPageSec); ggOptions.setMaxPauseBetweenPageSec(maxPauseBetweenPageSec); googleDB.options.update(ggOptions); } LOG.debug( "dry run timing : {}", DurationFormatUtils.formatDurationHMS(System.currentTimeMillis() - _start)); flash.success("ok"); return Results.redirect(router.getReverseRoute(DebugController.class, "debug")); }
// Calculate How many time public List<TestingCenterTimeSlots> generateTimeSlots(Exam exam) { TestingCenterInfo tci = tcr.findByTerm(tcr.getCurrentTerm().getTermId()); int gap = tci.getGap(); int examDuration = exam.getDuration(); int openMinutes = (int) ChronoUnit.MINUTES.between(tci.getOpen(), tci.getClose()); // Ensure time chunk devides 30 int timeChuck = (examDuration + gap) % 30 == 0 ? examDuration : 30 * ((examDuration + gap) / 30 + 1); LocalTime endTime = exam.getEndDateTime().toLocalTime(); LocalTime beginTime = exam.getStartDateTime().toLocalTime(); LocalTime openTime = tci.getOpen(); LocalTime closeTime = tci.getClose(); LocalDate beginDate = exam.getStartDateTime().toLocalDate(); LocalDate endDate = exam.getEndDateTime().toLocalDate(); beginTime = adjustTime(beginTime); // Exam Begin Time endTime = adjustTime(endTime); // Exam End Time // Calculate Duration According to different day. int startDayDuration = (int) ChronoUnit.MINUTES.between(beginTime, closeTime); int dayLast = (int) ChronoUnit.DAYS.between(beginDate, endDate) - 1; int endDayDuration = (int) ChronoUnit.MINUTES.between(openTime, endTime); int startDayChucks = startDayDuration / timeChuck; int endDayChucks = endDayDuration / timeChuck; int regularDayChuncks = dayLast >= 0 ? (dayLast * openMinutes) / timeChuck : 0; int dailyChuncks = openMinutes / timeChuck; LocalDate dateCursor = beginDate; LocalTime timeCursor = beginTime; List<TestingCenterTimeSlots> timeSlotses = new ArrayList<>(); if (startDayChucks > 0) { for (int i = 0; i < startDayChucks; i++) { LocalDateTime slotsBegin = dateCursor.atTime(timeCursor); LocalDateTime slotsEnd = dateCursor.atTime(timeCursor.plusMinutes(examDuration)); TestingCenterTimeSlots t = new TestingCenterTimeSlots( exam.getExamId(), slotsBegin, slotsEnd, tci.getNumSeats(), tci.getNumSetAsideSeats()); timeSlotses.add(t); timeCursor = timeCursor.plusMinutes(timeChuck); } } if (regularDayChuncks > 0) { for (int i = 0; i < dayLast; i++) { dateCursor = dateCursor.plusDays(1); timeCursor = adjustTime(openTime); for (int j = 0; j < dailyChuncks; j++) { LocalDateTime slotsBegin = dateCursor.atTime(timeCursor); LocalDateTime slotsEnd = dateCursor.atTime(timeCursor.plusMinutes(examDuration)); TestingCenterTimeSlots t = new TestingCenterTimeSlots( exam.getExamId(), slotsBegin, slotsEnd, tci.getNumSeats(), tci.getNumSetAsideSeats()); timeSlotses.add(t); timeCursor = timeCursor.plusMinutes(timeChuck); } } } if (endDayChucks > 0) { dateCursor = dateCursor.plusDays(1); timeCursor = adjustTime(openTime); for (int i = 0; i < endDayChucks; i++) { LocalDateTime slotsBegin = dateCursor.atTime(timeCursor); LocalDateTime slotsEnd = dateCursor.atTime(timeCursor.plusMinutes(examDuration)); TestingCenterTimeSlots t = new TestingCenterTimeSlots( exam.getExamId(), slotsBegin, slotsEnd, tci.getNumSeats(), tci.getNumSetAsideSeats()); timeSlotses.add(t); timeCursor = timeCursor.plusMinutes(timeChuck); } } return timeSlotses; }