started to separated logic of oauth flow endpoints

constants/constants.go

@@ -0,0 +1,14 @@
+package constants
+
+const (
+	// HandlerLogTag is a tag we are using to identify log messages from the handler
+	HandlerLogTag = "AUTH HANDLERS"
+)
+
+//providers
+const (
+    SocialProvider = "SocialProvider"
+    ADProvider = "ADProvider"
+    ProxyProvider = "ProxyProvider"
+)
+

http_handlers.go

@@ -4,12 +4,11 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/TykTechnologies/tyk-identity-broker/constants"
 	"net/http"
 
 	"github.com/Sirupsen/logrus"
-	"github.com/TykTechnologies/tyk-identity-broker/providers"
 	"github.com/TykTechnologies/tyk-identity-broker/tap"
-	"github.com/TykTechnologies/tyk-identity-broker/tap/identity-handlers"
 	"github.com/gorilla/mux"
 )
 
@@ -19,69 +18,19 @@ type APIErrorMessage struct {
 	Error  string
 }
 
-// HandlerLogTag is a tag we are uing to identify log messages from the handler
-var HandlerLogTag = "AUTH HANDLERS"
-
 // Returns a profile ID
 func getId(req *http.Request) (string, error) {
 	id := mux.Vars(req)["id"]
 	if id == "" {
 		id = mux.Vars(req)[":id"]
 	}
 	if id == "" {
-		return id, errors.New("No profile id detected")
+		return id, errors.New("no profile id detected")
 	}
 	return id, nil
-}
-
-// Maps an identity handler from an Action type, register new Identity Handlers and methods here
-func getIdentityHandler(name tap.Action) tap.IdentityHandler {
-	var thisIdentityHandler tap.IdentityHandler
-
-	switch name {
-	case tap.GenerateOrLoginDeveloperProfile, tap.GenerateOrLoginUserProfile, tap.GenerateOAuthTokenForClient, tap.GenerateTemporaryAuthToken:
-		thisIdentityHandler = &identityHandlers.TykIdentityHandler{
-			API:   &TykAPIHandler,
-			Store: IdentityKeyStore}
-	}
 
-	return thisIdentityHandler
-}
-
-// A hack to marshal a provider conf from map[string]interface{} intoa type without type checking, ugly, but effective
-func hackProviderConf(conf interface{}) []byte {
-	thisConf, err := json.Marshal(conf)
-	if err != nil {
-		log.WithFields(logrus.Fields{
-			"prefix": HandlerLogTag,
-			"error":  err,
-		}).Warning("Failure in JSON conversion")
-		return []byte{}
-	}
-	return thisConf
 }
 
-// return a provider based on the name of the provider type, add new providers here
-func getTAProvider(conf tap.Profile) (tap.TAProvider, error) {
-
-	var thisProvider tap.TAProvider
-
-	switch conf.ProviderName {
-	case "SocialProvider":
-		thisProvider = &providers.Social{}
-	case "ADProvider":
-		thisProvider = &providers.ADProvider{}
-	case "ProxyProvider":
-		thisProvider = &providers.ProxyProvider{}
-	}
-
-	thisIdentityHandler := getIdentityHandler(conf.ActionType)
-	fmt.Printf("%+v", thisIdentityHandler)
-	thisIdentityHandler.Init(conf)
-	err := thisProvider.Init(thisIdentityHandler, conf, hackProviderConf(conf.ProviderConfig))
-
-	return thisProvider, err
-}
 
 // HandleError is a generic error handler
 func HandleError(tag string, errorMsg string, rawErr error, code int, w http.ResponseWriter, r *http.Request) {
@@ -104,34 +53,16 @@ func HandleError(tag string, errorMsg string, rawErr error, code int, w http.Res
 	fmt.Fprintf(w, string(responseMsg))
 }
 
-func getTapProfile(w http.ResponseWriter, r *http.Request) (tap.TAProvider, error) {
+// HandleAuth is the main entrypoint handler for any profile (i.e. /auth/:profile-id/:provider)
+func HandleAuth(w http.ResponseWriter, r *http.Request) {
+
 	thisId, idErr := getId(r)
 	if idErr != nil {
-		HandleError(HandlerLogTag, "Could not retrieve ID", idErr, 400, w, r)
-		return nil, idErr
-	}
-
-	thisProfile := tap.Profile{}
-	log.WithField("prefix", HandlerLogTag).Debug("--> Looking up profile ID: ", thisId)
-	foundProfileErr := AuthConfigStore.GetKey(thisId, &thisProfile)
-
-	if foundProfileErr != nil {
-		errorMsg := "Profile " + thisId + " not found"
-		HandleError(HandlerLogTag, errorMsg, foundProfileErr, 404, w, r)
-		return nil, foundProfileErr
-	}
-
-	thisIdentityProvider, providerErr := getTAProvider(thisProfile)
-	if providerErr != nil {
-		HandleError(HandlerLogTag, "Could not initialise provider", providerErr, 400, w, r)
-		return nil, providerErr
+		HandleError(constants.HandlerLogTag, "Could not retrieve ID", idErr, 400, w, r)
+		return
 	}
-	return thisIdentityProvider, nil
-}
 
-// HandleAuth is the main entrypoint handler for any profile (i.e. /auth/:profile-id/:provider)
-func HandleAuth(w http.ResponseWriter, r *http.Request) {
-	thisIdentityProvider, err := getTapProfile(w, r)
+	thisIdentityProvider, err := tap.GetTapProfile(w, r, AuthConfigStore, IdentityKeyStore, thisId, TykAPIHandler)
 	if err != nil {
 		return
 	}
@@ -143,8 +74,15 @@ func HandleAuth(w http.ResponseWriter, r *http.Request) {
 // HandleAuthCallback Is a callback URL passed to OAuth providers such as Social, handles completing an auth request
 func HandleAuthCallback(w http.ResponseWriter, r *http.Request) {
 
-	thisIdentityProvider, err := getTapProfile(w, r)
+	thisId, idErr := getId(r)
+	if idErr != nil {
+		HandleError(constants.HandlerLogTag, "Could not retrieve ID", idErr, 400, w, r)
+		return
+	}
+
+	thisIdentityProvider, err := tap.GetTapProfile(w, r, AuthConfigStore, thisId)
 	if err != nil {
+		HandleError(constants.HandlerLogTag, err.Message, err.Error, err.Code, w, r)
 		return
 	}
 
@@ -155,3 +93,4 @@ func HandleAuthCallback(w http.ResponseWriter, r *http.Request) {
 func HandleHealthCheck(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 }
+

providers/tapProvider.go

@@ -0,0 +1 @@
+package providers

tap/profileActions.go

@@ -1,6 +1,18 @@
 package tap
 
-import "errors"
+import (
+	"encoding/json"
+	"errors"
+	"github.com/Sirupsen/logrus"
+	"github.com/TykTechnologies/tyk-identity-broker/constants"
+	logger "github.com/TykTechnologies/tyk-identity-broker/log"
+	"github.com/TykTechnologies/tyk-identity-broker/providers"
+	identityHandlers "github.com/TykTechnologies/tyk-identity-broker/tap/identity-handlers"
+	"github.com/TykTechnologies/tyk-identity-broker/tyk-api"
+	"net/http"
+)
+
+var log = logger.Get()
 
 type HttpError struct{
 	Message string
@@ -104,3 +116,80 @@ func DeleteProfile(key string,AuthConfigStore AuthRegisterBackend, flush func(ba
 	}
 	return nil
 }
+
+func GetTapProfile(w http.ResponseWriter, r *http.Request, AuthConfigStore, identityKeyStore AuthRegisterBackend, id string,tykHandler tyk.TykAPI) (TAProvider, *HttpError) {
+
+	thisProfile := Profile{}
+	log.WithField("prefix", constants.HandlerLogTag).Debug("--> Looking up profile ID: ", id)
+	foundProfileErr := AuthConfigStore.GetKey(id, &thisProfile)
+
+	if foundProfileErr != nil {
+		errorMsg := "Profile " + id + " not found"
+		return nil, &HttpError{
+			Message: errorMsg,
+			Code:    404,
+			Error:   foundProfileErr,
+		}
+	}
+
+	thisIdentityProvider, providerErr := GetTAProvider(thisProfile,tykHandler,identityKeyStore)
+	if providerErr != nil {
+		return  nil, &HttpError{
+			Message: "Could not initialise provider",
+			Code:    400,
+			Error:   providerErr,
+		}
+	}
+
+	return thisIdentityProvider, nil
+}
+
+// return a provider based on the name of the provider type, add new providers here
+func GetTAProvider(conf Profile,handler tyk.TykAPI, identityKeyStore AuthRegisterBackend) (TAProvider, error) {
+
+	var thisProvider TAProvider
+
+	switch conf.ProviderName {
+	case constants.SocialProvider:
+		thisProvider = &providers.Social{}
+	case constants.ADProvider:
+		thisProvider = &providers.ADProvider{}
+	case constants.ProxyProvider:
+		thisProvider = &providers.ProxyProvider{}
+	default:
+		return nil, errors.New("invalid provider name")
+	}
+
+	thisIdentityHandler := getIdentityHandler(conf.ActionType, handler, identityKeyStore)
+	thisIdentityHandler.Init(conf)
+	err := thisProvider.Init(thisIdentityHandler, conf, hackProviderConf(conf.ProviderConfig))
+
+	return thisProvider, err
+}
+
+// Maps an identity handler from an Action type, register new Identity Handlers and methods here
+func getIdentityHandler(name Action,handler tyk.TykAPI, identityKeyStore AuthRegisterBackend) IdentityHandler {
+	var thisIdentityHandler IdentityHandler
+
+	switch name {
+	case GenerateOrLoginDeveloperProfile, GenerateOrLoginUserProfile, GenerateOAuthTokenForClient, GenerateTemporaryAuthToken:
+		thisIdentityHandler = &identityHandlers.TykIdentityHandler{
+			API:   &handler,
+			Store: identityKeyStore}
+	}
+
+	return thisIdentityHandler
+}
+
+// A hack to marshal a provider conf from map[string]interface{} into a type without type checking, ugly, but effective
+func hackProviderConf(conf interface{}) []byte {
+	thisConf, err := json.Marshal(conf)
+	if err != nil {
+		log.WithFields(logrus.Fields{
+			"prefix": constants.HandlerLogTag,
+			"error":  err,
+		}).Warning("Failure in JSON conversion")
+		return []byte{}
+	}
+	return thisConf
+}

tap/tapProvider/tapProvider.go

@@ -0,0 +1,4 @@
+package tapProvider
+
+
+