func PerformActions(params *revel.Params, serverInterface models.ServerInterface) {
	var action = strings.ToLower(params.Get("action"))

	switch action {
	case "start":
		serverInterface.Start()
	case "stop":
		serverInterface.Stop()
	case "run":
		serverInterface.Run()
	}
}

func bindCard(params *revel.Params, name string, typ reflect.Type) reflect.Value {
	var card models.Card
	if name == "card" && typ == reflect.TypeOf(card) {
		params.Bind(&card.CardBody, "CardBody")
		params.Bind(&card.CardBlanks, "CardBlanks")
		params.Bind(&card.CardType, "CardType")

		return reflect.ValueOf(card)
	}
	return reflect.ValueOf(nil)
}

func (a *LinkedinAuthProvider) AuthenticateBase(parent *AuthProvider, params *revel.Params) (resp AuthResponse, err error) {
	// assumption: validation has previously been done revel.OnAppStart() and then in in Authenticate()
	errorCode := params.Get("error")
	if errorCode != "" {
		resp = AuthResponse{Type: AuthResponseError, Response: params.Get("error_description")}
		return resp, err
	}

	code := params.Get("code")
	if code == "" {
		// we have no token, so begin authorization
		theUrl, _ := url.ParseRequestURI(parent.AuthConfig.AuthorizeUrl)

		// create a Map of all necessary params to pass to authenticator
		valueMap, _ := parent.MapAuthInitatorValues(parent)
		valueMap.Add("state", "blahblahblah")

		theUrl.RawQuery = valueMap.Encode()
		resp = AuthResponse{Type: AuthResponseRedirect, Response: theUrl.String()}
		return resp, err
	} else {
		// we have a code, so it's exchange time!
		theUrl, _ := url.ParseRequestURI(parent.AuthConfig.AccessTokenUrl)

		// create a map of all necessary params to pass to authenticator
		valueMap, _ := parent.MapExchangeValues(parent)
		valueMap.Add("code", code)
		valueMap.Add("state", "blahblahblah")

		// push the whole valueMap into the URL instance
		theUrl.RawQuery = valueMap.Encode()

		// do the POST, then post
		theJson, err := postRequestForJson(theUrl.Scheme+"://"+theUrl.Host+theUrl.Path, valueMap.Encode())
		if err == nil {
			resp = AuthResponse{Type: AuthResponseString, Response: theJson}
			return resp, err
		} else {
			resp = AuthResponse{Type: AuthResponseError, Response: err.Error()}
			return resp, err
		}
	}
}

func (a *TwitterAuthProvider) AuthenticateBase(parent *AuthProvider, params *revel.Params) (resp AuthResponse, err error) {
	// assumption: validation has previously been done revel.OnAppStart() and then in in Authenticate()
	errorCode := params.Get("error_code")
	if errorCode != "" {
		resp = AuthResponse{Type: AuthResponseError, Response: params.Get("error_message")}
		return resp, err
	}

	token := params.Get("oauth_token")
	verifier := params.Get("oauth_verifier")

	if token == "" && verifier == "" { // Step 1: obtain a request token and redirect user
		theUrl, _ := url.ParseRequestURI(parent.AuthConfig.RequestTokenUrl)
		// create a Map of all necessary params to pass to authenticator
		valueMap, _ := parent.MapAuthInitatorValues(parent)
		theUrl.RawQuery = valueMap.Encode()

		// do the POST to get the oauth_token
		theJson, err := postRequestForJson(theUrl.Scheme+"://"+theUrl.Host+theUrl.Path, valueMap.Encode())
		if err != nil {
			resp = AuthResponse{Type: AuthResponseError, Response: err.Error()}
			return resp, err
		}

		// extract oauth_token out of theJson (which is not JSON, but rather a querystring)
		vals, err := url.ParseQuery(theJson)
		if err != nil {
			resp = AuthResponse{Type: AuthResponseError, Response: err.Error()}
			return resp, err
		}

		token := vals.Get("oauth_token")
		if token == "" {
			resp = AuthResponse{Type: AuthResponseError, Response: "No oauth token found in token request to Twitter."}
			return resp, err
		}

		// redirect user to authenticate
		redirectUrl, _ := url.ParseRequestURI(parent.AuthConfig.AuthorizeUrl)
		v := url.Values{}
		v.Set("oauth_token", token)
		redirectUrl.RawQuery = v.Encode()
		resp = AuthResponse{Type: AuthResponseRedirect, Response: redirectUrl.String()}
		return resp, err

	} else {
		// we have a token and verifier, so it's exchange time!
		theUrl, _ := url.ParseRequestURI(parent.AuthConfig.AccessTokenUrl)

		// create a map of all necessary params to pass to authenticator
		//valueMap, _ := parent.MapExchangeValues(parent)
		valueMap := url.Values{}
		valueMap.Add("oauth_token", token)
		valueMap.Add("oauth_verifier", verifier)

		// push the whole valueMap into the URL instance
		theUrl.RawQuery = valueMap.Encode()

		// do the POST, then post
		theJson, err := postRequestForJson(theUrl.Scheme+"://"+theUrl.Host+theUrl.Path, valueMap.Encode())
		if err == nil {
			resp = AuthResponse{Type: AuthResponseString, Response: theJson}
			return resp, err
		} else {
			resp = AuthResponse{Type: AuthResponseError, Response: err.Error()}
			return resp, err
		}
	}
}

func NewServerFromParams(Params *revel.Params) (server *Server) {
	server = &Server{
		Label:    Params.Get("label"),
		Username: Params.Get("username"),
		Host:     Params.Get("host"),
		Port:     Params.Get("port"),
	}
	queryInterval, err := strconv.Atoi(Params.Get("query_interval"))

	if err != nil {
		server.SetQueryInterval(60)
	} else {
		server.SetQueryInterval(queryInterval)
	}
	server.ParsePrivateKey(Params.Get("private_key"))
	server.SetPassword(Params.Get("password"))

	var cmds [][]string
	Params.Bind(&cmds, "commands")
	server.Commands = make(map[string]string)

	for _, cmd := range cmds {
		if len(cmd) == 2 && cmd[0] != "" && cmd[1] != "" {
			server.Commands[cmd[0]] = cmd[1]
		}
	}
	return
}