• Home
• de.sweetcode
• SteamAPI
• 1.0.2-beta
• source code
• SteamMethodVersion.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

de.SweetCode.SteamAPI.method.SteamMethodVersion Maven / Gradle / Ivy

package de.SweetCode.SteamAPI.method;

import de.SweetCode.SteamAPI.SteamHTTPMethod;
import de.SweetCode.SteamAPI.SteamHost;
import de.SweetCode.SteamAPI.SteamVersion;
import de.SweetCode.SteamAPI.SteamVisibility;
import de.SweetCode.SteamAPI.exceptions.SteamDependencyException;
import de.SweetCode.SteamAPI.exceptions.SteamMissingInputException;
import de.SweetCode.SteamAPI.method.input.Input;
import de.SweetCode.SteamAPI.method.option.Option;

import java.util.*;

/**
 * 

 *    A {@link SteamMethod} can have various versions supporting different {@link Option Options}, {@link SteamVersion Steam Versions}
 *    and/or {@link SteamHost Steam Hosts}.
 * 
 */
public class SteamMethodVersion {

    private final SteamHTTPMethod httpMethod;

    private final List hosts;
    private final SteamVersion version;
    private final SteamVisibility visibility;

    private final Map options = new TreeMap<>();

    /**
     * 

     *    Creates a new SteamMethodVersion instance.
     * 
     *
     * @param method The supported HTTP request method.
     * @param hosts All supported hosts.
     * @param version The version the options belong to.
     * @param visibility The visibility of the method.
     */
    public SteamMethodVersion(SteamHTTPMethod method, List hosts, SteamVersion version, SteamVisibility visibility) {

        //@TODO Verify version
        assert !(method == null);
        assert !(hosts == null);
        assert !(hosts.isEmpty());
        assert !(version == null);
        assert !(visibility == null);

        this.httpMethod = method;
        this.hosts = hosts;
        this.version = version;
        this.visibility = visibility;
    }

    /**
     * 

     *    The supported HTTP request method.
     * 
     *
     * @return the supported HTTP request method, never null.
     */
    public SteamHTTPMethod getMethod() {
        return this.httpMethod;
    }

    /**
     * 

     *     All supported hosts.
     * 
     *
     * @return a list of supported hosts.
     */
    public List getHosts() {
        return this.hosts;
    }

    /**
     * 

     *     The version these options belong to.
     * 
     *
     * @return the version, never null.
     */
    public SteamVersion getVersion() {
        return this.version;
    }

    /**
     * 

     *    Gives the visibility of the method.
     * 
     *
     * @return The visibility of the method, never null.
     */
    public SteamVisibility getVisibility() {
        return this.visibility;
    }

    /**
     * 

     *    Gives the option related to the key.
     * 
     *
     * @param key The key of the option.
     *
     * @return the related option, never null.
     */
    public Option get(String key) {

        //@TODO Verify input
        assert !(key == null);
        assert this.options.containsKey(key);

        return this.options.get(key);

    }

    /**
     * 

     *    Adds a option if the option does not exist yet.
     * 
     *
     * @param option The option to add.
     */
    public void add(Option option) {

        //@TODO Verify input
        assert !(option == null);
        assert !(this.options.containsKey(option.getKey()));

        this.options.put(option.getKey(), option);

    }

    /**
     * 

     *     Verifies if the input fits these SteamMethodVersion.
     * 
     *
     * @param steamMethod The SteamMethod calling the verify function.
     * @param host The host which is supposed to receive the provided input.
     * @param input The provided input.
     *
     * @return True, if the input fits, otherwise it throws exception.
     */
    public boolean verify(SteamMethod steamMethod, SteamHost host, Input input) {

        //@TODO Verify input
        assert !(steamMethod == null);
        assert !(input == null);

        Map data = input.getValues();

        for(Map.Entry e : this.options.entrySet()) {

            String key = e.getKey();
            Option option = e.getValue();

            //--- If the option is required & DOES NOT exist -> onError
            if(
                (option.isRequired() || (host == SteamHost.PARTNER && option.isPartnerRequired())) &&
                !(data.containsKey(key))
            ) {
                throw new SteamMissingInputException(steamMethod, option);
            }

            //--- If the key does exist in the input & the value is of the wrong type -> onError
            if(data.containsKey(key) && !(option.getOptionType().check(data.get(key)))) {
                throw new IllegalArgumentException(String.format(
                    "The method %s expected a %s for the key %s. The value %s doesn't fit the OptionType.",
                    steamMethod.getName(),
                    option.getOptionType().getName(),
                    option.getKey(),
                    String.valueOf(data.get(key))
                ));
            }

            //--- Check for dependencies
            if(data.containsKey(key)) {
                option.getDependencies().forEach(d -> {
                    //--- If the input data doesn't contain the required dependecy
                    if(!(data.containsKey(d))) {
                        throw new SteamDependencyException(steamMethod, option, d);
                    }
                });
            }

        }

        return true;

    }

    /**
     *  

     *     Creates a new instance of {@link Builder}.
     *  
     *
     * @return the builder instance.
     */
    public static Builder create() {
        return new Builder();
    }

    /**
     * 

     *    A builder pattern class to buildRequest easier SteamMethodVersion.
     * 
     */
    public static class Builder {

        private SteamHTTPMethod method = null;

        private List hosts = null;
        private SteamVersion version = null;
        private SteamVisibility visibility = null;

        private List collection = new ArrayList<>();

        public Builder() {}

        /**
         * 

         *    The supported HTTP request method.
         * 
         *
         * @param method The request method.
         *
         * @return the current builder instance.
         */
        public Builder method(SteamHTTPMethod method) {
            this.method = method;
            return this;
        }

        /**
         * 

         *     The host the SteamMethodVersion belong to.
         * 
         *
         * @param hosts An array of supported hosts.
         *
         * @return the current builder instance.
         */
        public Builder hosts(SteamHost... hosts) {
            this.hosts = Arrays.asList(hosts);
            return this;
        }

        /**
         * 

         *     The version the SteamMethodVersion belong to.
         * 
         *
         * @param version The option.
         *
         * @return the current builder instance.
         */
        public Builder version(SteamVersion version) {
            this.version = version;
            return this;
        }

        /**
         * 

         *    The visibility of the method.
         * 
         *
         * @param visibility The visibility.
         *
         * @return the current builder instance.
         */
        public Builder visibility(SteamVisibility visibility) {
            this.visibility = visibility;
            return this;
        }

        /**
         * 

         *    Adds the provided Option.
         * 
         *
         * @param option The option to add.
         *
         * @return the current builder instance.
         */
        public Builder add(Option option) {
            this.collection.add(option);
            return this;
        }

        /**
         * 

         *    Builds a new instance of {@link SteamMethodVersion} with all added {@link Option options}.
         * 
         *
         * @return a new instance of SteamMethodVersion.
         */
        public SteamMethodVersion build() {
            SteamMethodVersion steamMethodVersion = new SteamMethodVersion(this.method, this.hosts, this.version, this.visibility);
            this.collection.forEach(steamMethodVersion::add);
            return steamMethodVersion;
        }

    }

}