Bootstrap

config.go

 /* SERVER CONFIGURATION */
 const SERVER_PORT = 8081
 
-/* DATABASE CONFIGURATION */
-const DATABASE_HOST = "208.97.141.22"
+const DATABASE_HOST = "homolog.sprinta.com.br"
 const DATABASE_PORT = "3306"
 const DATABASE_USER = "hml"
 const DATABASE_PASS = "spr777hml"
 const DATABASE_SCHEMA = "hml_sprinta"
-
-/* SERVICES ENDPOINTS */
-const AUTHENTICATION_SERVICE = "http://208.97.141.22/api/sign/user_data"

core/request/request.go

 package request
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"net/http"
 )
 
-var request *http.Request
-
-//Method : retorna o metodo
-func Method() string {
-	return request.Method
-}
-
 //Post : retorna um parametro post
-func Post(parameter string) string {
-	var r = request
-
+func Post(r *http.Request, parameter string) string {
 	if err := r.ParseForm(); err != nil {
 		fmt.Printf("ParseForm() err: %v", err)
 		return ""
 }
 
 //Get : retorna um parametro get
-func Get(parameter string) string {
-	var r = request
-
-	keys, ok := r.URL.Query()["key"]
+func Get(r *http.Request, parameter string) string {
+	keys, ok := r.URL.Query()[parameter]
 
 	if !ok || len(keys[0]) < 1 {
 		log.Println("Url Param 'key' is missing")
 	return string(key)
 }
 
-//Parameter : retorna um parametro post ou get
-func Parameter(parameter string) string {
-	var post = Post(parameter)
-	if post != "" {
-		return post
-	}
-
-	var get = Get(parameter)
-	if get != "" {
-		return get
-	}
-
-	return ""
+func SetContextValue(r *http.Request, k string, v interface{}) *http.Request {
+	ctx := context.WithValue(r.Context(), k, v)
+	return r.WithContext(ctx)
 }
 
-func SetRequest(r *http.Request) {
-	request = r
+func GetContextValue(r *http.Request, parameter string) interface{} {
+	return r.Context().Value(parameter)
 }

core/response/response.go

 
 var responseCode = 200
 
-var responseWriter *http.ResponseWriter
-
 //JSON :response json
-func JSON(data interface{}) {
-	w := *responseWriter
+func JSON(w http.ResponseWriter, data interface{}) {
 	js, err := json.Marshal(data)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 func SetCode(code int) {
 	responseCode = code
 }
-
-func SetResponseWriter(w http.ResponseWriter) {
-	responseWriter = &w
-}

core/router/router.go

 )
 
 type closure func(http.ResponseWriter, *http.Request)
-type Middleware func(http.ResponseWriter, *http.Request) bool
+type Middleware func(http.ResponseWriter, *http.Request) (bool, *http.Request)
 
 //Route struct de uma rota
 type Route struct {
+	Method		string
 	Pattern     string
 	Handler     closure
 	Middlewares []Middleware
 
 		items := regexSubmatch(pattern, url)
 
-		ctx := context.WithValue(r.Context(), "parameters", items)
+		ctx := context.WithValue(r.Context(), "urlParameters", items)
 		r = r.WithContext(ctx)
 
 		if items[0] == url {
+			if element.Method != r.Method {
+				//method not allowed
+				w.WriteHeader(405)
+				w.Write(nil)
+				return false
+			}
+
 			if element.Middlewares != nil && len(element.Middlewares) > 0 {
 				for _, mid := range element.Middlewares {
-					if !mid(w, r) {
+					var validator bool
+					validator, r = mid(w, r)
+					if !validator {
+						w.WriteHeader(500)
+						w.Write(nil)
 						return false
 					}
 				}
 			return true
 		}
 	}
-
+	w.WriteHeader(404)
+	w.Write(nil)
 	return false
 }
 

exec.sh

-go build -o build
-./build

main.go

 	"log"
 	"net/http"
 	"strconv"
-
-	"./core/database"
-	"./core/errorHandler"
-	"./core/request"
-	"./core/response"
-	"./src/lib/auth"
 )
 
 func main() {
-
-	initDatabase()
-	initAuthService()
+	// initDatabase()
 
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
-		var Errors errorHandler.Errors
-
-		response.SetResponseWriter(w)
-		request.SetRequest(r)
+		// var Errors errorHandler.Errors
 
-		if !database.IsConnected {
-			Errors.InternalError("Conexão com a base de dados falhou!")
-			response.JSON(Errors)
-			return
-		}
+		// if !database.IsConnected {
+		// 	Errors.InternalError("Conexão com a base de dados falhou!")
+		// 	response.JSON(w, Errors)
+		// 	return
+		// }
 
 		Routes.Match(w, r)
 	})
 
 	log.Fatal(http.ListenAndServe(":"+strconv.Itoa(SERVER_PORT), nil))
 }
-
-func initDatabase() {
-
-	database.Init(
-		database.Config{
-			DATABASE_HOST,
-			DATABASE_PORT,
-			DATABASE_USER,
-			DATABASE_PASS,
-			DATABASE_SCHEMA,
-		})
-}
-
-func initAuthService() {
-
-	auth.Config(
-		auth.ServiceConfig{
-			AUTHENTICATION_SERVICE,
-		})
-}

routes.go

 //Routes rotas de acesso
 var Routes = router.Routes{
 	router.Route{
-		Pattern: `\/(.*)`,
+		Method: "GET",
+		Pattern: `/test1`,
 		Handler: test.Inicial,
 		Middlewares: []router.Middleware{
 			login.Mandatory,
 		},
 	},
+	router.Route{
+		Method: "POST",
+		Pattern:     `/test2`,
+		Handler:     test.AddError,
+		Middlewares: nil,
+	},
+	router.Route{
+		Method: "GET",
+		Pattern:     `/test3`,
+		Handler:     test.Erro,
+		Middlewares: []router.Middleware{
+			login.Test,
+		},
+	},
 }

src/controller/Test/Test.go

 	"../../../core/errorHandler"
 	"../../../core/request"
 	"../../../core/response"
-
-	auth "../../lib/auth"
 )
 
-type Profile struct {
-	Name    string
-	Hobbies []string
-}
-
-/**
- * @api {get} /user/:id Request User information
- * @apiName GetUser
- * @apiGroup User
- *
- * @apiParam {Number} id Users unique ID.
- *
- * @apiSuccess {String} firstname Firstname of the User.
- * @apiSuccess {String} lastname  Lastname of the User.
- */
 func Inicial(w http.ResponseWriter, r *http.Request) {
-	fmt.Println(r.Context().Value("parameters"))
-
-	var Errors errorHandler.Errors
-
-	user, err := auth.GetUser(r)
-
-	fmt.Printf("%+v\n", user)
-	fmt.Printf("%+v\n", err)
-
-	//var errors errors.Errors
-	// fmt.Println(vars[0])
-	// fmt.Fprintf(w, "Hello Route, %q", html.EscapeString(r.URL.Path))
-	// profile := Profile{"Alex", []string{"snowboarding", "programming"}}
-
-	if err := r.ParseForm(); err != nil {
-		fmt.Printf("ParseForm() err: %v", err)
-		return
-	}
-
-	Errors.InvalidParameter("username", "Usuário não disponível")
-	Errors.InternalError("Ocorreu um erro interno")
-	Errors.ActionForbidden("Ocorreu um erro interno2")
+	fmt.Println(request.Get(r, "test"))
+	fmt.Println(request.GetContextValue(r, "user"))
+}
 
-	if Errors.Has() {
-		response.JSON(Errors)
-		return
-	}
+func AddError(w http.ResponseWriter, r *http.Request) {
+	fmt.Println(request.GetContextValue(r, "user"))
+	var err errorHandler.Errors
+	err.ActionForbidden("test")
 
-	fmt.Println(request.Method())
+	response.JSON(w, err)
+}
 
-	// res.SetCode(404)
-	// res.JSON(profile)
 
-}
+func Erro(w http.ResponseWriter, r *http.Request) {
+	
+}

src/middleware/login/login.go

 package login
 
 import (
-	"context"
 	"net/http"
 
-	"../../../core/errorHandler"
-	"../../../core/response"
-	"../../lib/auth"
+	"../../../core/request"
 )
 
-func Mandatory(w http.ResponseWriter, r *http.Request) (logged bool) {
-
-	user, logged := auth.GetUser(r)
-
-	if logged {
-
-		ctx := context.WithValue(r.Context(), "user", user)
-		r = r.WithContext(ctx)
-
-	} else {
-
-		var Errors errorHandler.Errors
-		Errors.ActionForbidden("User must be logged in")
-		response.SetCode(errorHandler.ACTION_FORBIDDEN)
-		response.JSON(Errors)
-	}
+func Mandatory(w http.ResponseWriter, r *http.Request) (bool, *http.Request) {
+	r = request.SetContextValue(r, "user", "user")
+	return true, r
+}
 
-	return
+func Test(w http.ResponseWriter, r *http.Request) (bool, *http.Request) {
+	return false, nil
 }