18F/cg-dashboard

package helpers

import (
    "crypto/rand"
    "encoding/base64"
    "net/http"
    "time"

    "golang.org/x/oauth2"
)

// TimeoutConstant is a constant which holds how long any incoming request should wait until we timeout.
// This is useful as some calls from the Go backend to the external API may take a long time.
// If the user decides to refresh or if the client is polling, multiple requests might build up. This timecaps them.
var TimeoutConstant = time.Second * 20

// GetValidToken is a helper function that returns a token struct only if it finds a non expired token for the session.
func GetValidToken(req *http.Request, rw http.ResponseWriter, settings *Settings) *oauth2.Token {
    // Get session from session store.
    session, _ := settings.Sessions.Get(req, "session")
    // If for some reason we can't get or create a session, bail out.
    if session == nil {
        return nil
    }

    // Attempt to get the token from this session.
    token, ok := session.Values["token"].(oauth2.Token)
    if !ok {
        return nil
    }

    // Save our original refresh token, we might need it further down
    originalRefreshToken := token.RefreshToken

    // Will ensure not expired
    rv, err := settings.OAuthConfig.TokenSource(settings.CreateContext(), &token).Token()
    if err != nil {
        return nil
    }

    // Did it change? if so save it in our cookie so we don't have to refresh again on every request
    if rv.AccessToken != token.AccessToken || !rv.Expiry.Equal(token.Expiry) {
        // We are using opaque UAA tokens, so make sure we replace any new refresh
        // token received with the smaller opaque one that we saved off earlier, or we
        // may hit session storage limits.
        rv.RefreshToken = originalRefreshToken
        session.Values["token"] = *rv
        session.Save(req, rw)
    }

    return rv
}

// GenerateRandomBytes returns securely generated random bytes.
// Borrowed from https://elithrar.github.io/article/generating-secure-random-numbers-crypto-rand/
func GenerateRandomBytes(n int) ([]byte, error) {
    b := make([]byte, n)
    _, err := rand.Read(b)
    // Note that err == nil only if we read len(b) bytes.
    if err != nil {
        return nil, err
    }

    return b, nil
}

// GenerateRandomString returns a URL-safe, base64 encoded
// securely generated random string.
// Borrowed from https://elithrar.github.io/article/generating-secure-random-numbers-crypto-rand/
func GenerateRandomString(s int) (string, error) {
    b, err := GenerateRandomBytes(s)
    return base64.URLEncoding.EncodeToString(b), err
}