Examples with LoanTermCondition com.github.robozonky.strategy.natural.conditions.LoanTermCondition used on opensource projects

Example 1 with LoanTermCondition

use of com.github.robozonky.strategy.natural.conditions.LoanTermCondition in project robozonky by RoboZonky.

the class FilterSupplier method supplyFilters.

private static Collection<MarketplaceFilter> supplyFilters(final Collection<MarketplaceFilter> filters, final long monthsBeforeExit) {
    if (monthsBeforeExit > -1) {
        // ignore marketplace items that go over the exit date
        // fix extreme exit dates
        final long filteredTerms = Math.min(monthsBeforeExit + 1, 84);
        final MarketplaceFilterCondition c = new LoanTermCondition(filteredTerms);
        final MarketplaceFilter f = MarketplaceFilter.of(c);
        final Collection<MarketplaceFilter> result = new ArrayList<>(filters.size());
        result.add(f);
        result.addAll(filters);
        return Collections.unmodifiableCollection(result);
    } else {
        return Collections.unmodifiableCollection(filters);
    }
}

Example 2 with LoanTermCondition

use of com.github.robozonky.strategy.natural.conditions.LoanTermCondition in project robozonky by RoboZonky.

the class SimpleStrategyService method parseOrThrow.

private static InvestmentStrategy parseOrThrow(final String strategy) {
    final ImmutableConfiguration config = ImmutableConfiguration.from(strategy);
    // set default values
    final DefaultValues d = new DefaultValues(DefaultPortfolio.EMPTY);
    d.setMinimumBalance(SimpleStrategyService.getMinimumBalance(config));
    d.setTargetPortfolioSize(SimpleStrategyService.getTargetPortfolioSize(config));
    d.setInvestmentShare(new DefaultInvestmentShare(SimpleStrategyService.getInvestmentShare(config)));
    final LoanRatingEnumeratedCondition c = new LoanRatingEnumeratedCondition();
    Stream.of(Rating.values()).filter(r -> StrategyFileProperty.REQUIRE_CONFIRMATION.getValue(r, config::getBoolean)).forEach(c::add);
    d.setConfirmationCondition(c);
    // assemble strategy
    final Map<Rating, InvestmentSize> investmentSizes = Stream.of(Rating.values()).collect(Collectors.toMap(Function.identity(), r -> {
        final int min = StrategyFileProperty.MINIMUM_LOAN_AMOUNT.getValue(r, config::getInt);
        final int max = StrategyFileProperty.MAXIMUM_LOAN_AMOUNT.getValue(r, config::getInt);
        return new InvestmentSize(min, max);
    }));
    final Collection<PortfolioShare> portfolio = Stream.of(Rating.values()).map(r -> {
        final int min = SimpleStrategyService.getShare(config, StrategyFileProperty.TARGET_SHARE, r);
        final int max = SimpleStrategyService.getShare(config, StrategyFileProperty.MAXIMUM_SHARE, r);
        return new PortfolioShare(r, min, max);
    }).collect(Collectors.toList());
    // filter loans with less than minimum term
    final Stream<Optional<MarketplaceFilter>> s1 = Stream.of(Rating.values()).map(r -> {
        final int min = StrategyFileProperty.MINIMUM_TERM.getValue(r, config::getInt);
        if (min < 2) {
            // there will be no loan with term smaller than 1
            return Optional.empty();
        }
        final MarketplaceFilterCondition f = new LoanTermCondition(0, min - 1);
        return Optional.of(getRatingFilter(r, f));
    });
    // filter loans with more than maximum term
    final Stream<Optional<MarketplaceFilter>> s2 = Stream.of(Rating.values()).map(r -> {
        final int max = StrategyFileProperty.MAXIMUM_TERM.getValue(r, config::getInt);
        if (max < 1) {
            return Optional.empty();
        }
        final MarketplaceFilterCondition f = new LoanTermCondition(max + 1);
        return Optional.of(getRatingFilter(r, f));
    });
    // filter loans with ask for less than minimum
    final Stream<Optional<MarketplaceFilter>> s3 = Stream.of(Rating.values()).map(r -> {
        final int min = StrategyFileProperty.MINIMUM_ASK.getValue(r, config::getInt);
        if (min < 2) {
            // amount smaller than 1 is 0, no need to have that filter
            return Optional.empty();
        }
        final MarketplaceFilterCondition f = new LoanAmountCondition(0, min - 1);
        return Optional.of(getRatingFilter(r, f));
    });
    // filter loans with ask more than maximum
    final Stream<Optional<MarketplaceFilter>> s4 = Stream.of(Rating.values()).map(r -> {
        final int max = StrategyFileProperty.MAXIMUM_ASK.getValue(r, config::getInt);
        if (max < 1) {
            return Optional.empty();
        }
        final MarketplaceFilterCondition f = new LoanAmountCondition(max + 1);
        return Optional.of(getRatingFilter(r, f));
    });
    // put all filters together
    final Collection<MarketplaceFilter> filters = Stream.of(s1, s2, s3, s4).flatMap(Function.identity()).flatMap(s -> s.map(Stream::of).orElse(Stream.empty())).collect(Collectors.toList());
    // and create the strategy
    final ParsedStrategy p = new ParsedStrategy(d, portfolio, investmentSizes, new FilterSupplier(d, filters));
    LOGGER.debug("Converted strategy: {}.", p);
    final InvestmentStrategy result = new NaturalLanguageInvestmentStrategy(p);
    return new SimpleStrategyService.ExclusivelyPrimaryMarketplaceInvestmentStrategy(result);
}