io.mstream.trader.simulation.handlers.api.simulation.continuation.ContinueRequestValidator Maven / Gradle / Ivy

package io.mstream.trader.simulation.handlers.api.simulation.continuation;


import com.google.common.collect.Sets;
import io.mstream.trader.commons.utils.exception.ValidationException;
import io.mstream.trader.simulation.handlers.api.simulation.continuation.data
        .ContinueRequestPayload;
import io.mstream.trader.simulation.security.SimulationTokenCipher;
import io.mstream.trader.simulation.simulation.SimulationToken;
import rx.Observable;
import rx.functions.Func1;

import javax.inject.Inject;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Optional;
import java.util.Set;

import static java.lang.String.format;


class ContinueRequestValidator
        implements Func1> {
    
    private final SimulationTokenCipher simulationTokenCipher;
    
    private final DateTimeFormatter dateTimeFormatter;
    
    private final Set validActions;
    
    @Inject
    public ContinueRequestValidator(
            SimulationTokenCipher simulationTokenCipher,
            DateTimeFormatter dateTimeFormatter
    ) {
        
        this.simulationTokenCipher = simulationTokenCipher;
        this.dateTimeFormatter = dateTimeFormatter;
        this.validActions = Sets.newHashSet("HOLD", "BUY", "SELL");
    }
    
    @Override
    public Observable call(ContinueRequestPayload payload) {
        
        String encryptedToken = payload.getToken();
        
        Optional simulationTokenOpt =
                simulationTokenCipher
                        .decrypt(encryptedToken);
        
        if (!simulationTokenOpt.isPresent()) {
            return Observable.error(
                    new ValidationException(
                            format(
                                    "can't parse the token: %s",
                                    encryptedToken
                            )
                    )
            );
        }
        
        SimulationToken token = simulationTokenOpt.get();
        
        try {
            LocalDate.from(dateTimeFormatter.parse(token.getStartDate()));
        } catch (Exception e) {
            return Observable.error(
                    new ValidationException(
                            format(
                                    "can't parse the token: %s",
                                    encryptedToken
                            )
                    )
            );
        }
        
        String action = payload.getAction();
        
        if (!validActions.contains(action)) {
            return Observable.error(
                    new ValidationException(
                            format(
                                    "not supported action: %s\n supported " +
                                            "actions: %s",
                                    encryptedToken,
                                    validActions
                            )
                    )
            );
        }
        
        return Observable.just(payload);
    }
}