io.mstream.trader.datafeed.handlers.api.stocks.price.GetPriceHandler Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of data-feed Show documentation
The newest version!
package io.mstream.trader.datafeed.handlers.api.stocks.price;


import io.mstream.trader.commons.http.RequestContext;
import io.mstream.trader.commons.ratpack.exception.ValidationErrorHandler;
import io.mstream.trader.commons.utils.cache.Cached;
import io.mstream.trader.commons.utils.exception.NotFoundException;
import io.mstream.trader.commons.utils.repository.SingleRepository;
import io.mstream.trader.datafeed.handlers.api.stocks.price.data
        .StockPriceConverter;
import io.mstream.trader.datafeed.stocks.Stock;
import io.mstream.trader.datafeed.stocks.StockFactory;
import io.mstream.trader.datafeed.stocks.StocksRepository;
import org.joda.money.Money;
import ratpack.handling.Context;
import ratpack.handling.Handler;

import javax.inject.Inject;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

import static ratpack.jackson.Jackson.json;
import static ratpack.rx.RxRatpack.observe;
import static ratpack.rx.RxRatpack.promiseSingle;


class GetPriceHandler
        implements Handler {
    
    private final SingleRepository
            stocksRepository;
    
    private final StockPriceConverter stockValueConverter;
    
    private final ParameterNameProvider parameterNameProvider;
    
    private final StockFactory stockFactory;
    
    private final DateTimeFormatter dateTimeFormatter;
    
    private final ValidationErrorHandler validationErrorHandler;
    
    @Inject
    public GetPriceHandler(
            @Cached
                    SingleRepository stocksRepository,
            StockPriceConverter stockValueConverter,
            ParameterNameProvider parameterNameProvider,
            StockFactory stockFactory,
            DateTimeFormatter dateTimeFormatter,
            @GetPrice
                    ValidationErrorHandler validationErrorHandler
    ) {
        
        this.stocksRepository = stocksRepository;
        this.stockValueConverter = stockValueConverter;
        this.parameterNameProvider = parameterNameProvider;
        this.stockFactory = stockFactory;
        this.dateTimeFormatter = dateTimeFormatter;
        this.validationErrorHandler = validationErrorHandler;
    }
    
    @Override
    public void handle(Context ctx)
            throws Exception {
        
        observe(ctx
                .getRequest()
                .getBody())
                .map(body -> new RequestContext(ctx, body))
                .subscribe(requestContext -> {
                    if (!validationErrorHandler.test(requestContext)) {
                        ctx
                                .getResponse()
                                .status(400)
                                .send();
                        return;
                    }
                    String idParam = ctx
                            .getPathTokens()
                            .get(parameterNameProvider.stockId());
    
                    String fromTimestampParam = ctx
                            .getPathTokens()
                            .get(parameterNameProvider.date());
    
                    Stock stock = stockFactory.create(idParam);
    
                    LocalDate date =
                            LocalDate.parse(
                                    fromTimestampParam,
                                    dateTimeFormatter
                            );
                    
                    promiseSingle(
                            stocksRepository
                                    .get(
                                            new StocksRepository.Key(
                                                    stock,
                                                    date
                                            )
                                    )
                                    .map(stockValueConverter::apply)
                                    .toObservable()
                    )
                            .onError(error -> {
                                        if (error instanceof
                                                NotFoundException) {
                                            ctx.notFound();
                                        } else {
                                            ctx.error(error);
                                        }
                                    }
                            )
                            .then(
                                    stockPrice ->
                                            ctx.render(
                                                    json(
                                                            stockPrice
                                                    )
                                            )
                            );
                });
    }
}