OAuthStateImpl.h

#ifndef TENDUKE_OAUTH_OAUTHSTATEIMPL_H
#define TENDUKE_OAUTH_OAUTHSTATEIMPL_H
 
#include "./OAuthState.h"
 
#include <map>
 
namespace tenduke { namespace oauth {
 
class OAuthStateImpl : public tenduke::oauth::OAuthState
{
public:
    OAuthStateImpl(
            std::string accessToken,
            std::string refreshToken,
            int64_t expiresAt,
            bool infinite,
            std::map<std::string, std::string> additionalProperties
    ) : accessToken(std::move(accessToken)), refreshToken(std::move(refreshToken)), expiresAt(expiresAt), infinite(infinite),
    additionalProperties(std::move(additionalProperties))
    {}
 
    OAuthStateImpl(
            std::string accessToken,
            std::string refreshToken,
            int64_t expiresAt,
            std::map<std::string, std::string> additionalProperties
    ) : OAuthStateImpl(std::move(accessToken), std::move(refreshToken), expiresAt,
    (expiresAt == tenduke::oauth::TOKEN_DOES_NOT_EXPIRE), std::move(additionalProperties))
    {}
 
    const std::string &getAccessToken() const override
    {
        return accessToken;
    }
 
    const std::string &getRefreshToken() const override
    {
        return refreshToken;
    }
 
    std::int64_t getExpiresAt() const override
    {
        return expiresAt;
    }
 
    const std::map<std::string, std::string> & getAdditionalProperties() const override
    {
        return additionalProperties;
    }
 
    const std::string *getAdditionalProperty(const std::string &name) const override
    {
        auto iterator = additionalProperties.find(name);
 
        if (iterator == additionalProperties.end()) {
            return nullptr;
        }
 
        return &(iterator->second);
    }
 
    bool hasAdditionalProperty(const std::string &name) const override
    {
        auto iterator = additionalProperties.find(name);
 
        return !(iterator == additionalProperties.end());
    }
 
    bool hasAccessToken() const override
    {
        return !accessToken.empty();
    }
 
    bool doesExpire() const override
    {
        return !infinite;
    }
 
    bool isRefreshable() const override
    {
        return !refreshToken.empty();
    }
 
    void setAccessToken(const std::string &newAccessToken) override
    {
        this->accessToken = newAccessToken;
    }
 
    void setExpiresAt(std::int64_t newExpiresAt) override
    {
        this->expiresAt = newExpiresAt;
        this->infinite = (expiresAt == tenduke::oauth::TOKEN_DOES_NOT_EXPIRE);
    }
 
    void setRefreshToken(const std::string &newRefreshToken) override
    {
        this->refreshToken = newRefreshToken;
    }
 
    void refreshFrom(const OAuthState &state) override
    {
        setExpiresAt(state.getExpiresAt());
        setAccessToken(state.getAccessToken());
 
        // Only set refresh token if present in other state
        // This assumes that if new refresh-token was not returned from the backend, the
        // original refresh-token is to be re-used.
        const std::string &newRefreshToken = state.getRefreshToken();
        if (! newRefreshToken.empty()) {
            setRefreshToken(newRefreshToken);
        }
    }
 
    void removeAdditionalProperty(const std::string &propertyName) override
    {
        additionalProperties.erase(propertyName);
    }
 
private:
    std::string accessToken;
    std::string refreshToken;
    std::int64_t expiresAt;
    bool infinite; // If true, the token does not expire.
    std::map<std::string, std::string> additionalProperties;
};
 
}}
 
#endif //TENDUKE_OAUTH_OAUTHSTATEIMPL_H