Route Proof Of Concept

dbmysql/client.go

@@ -12,8 +12,13 @@ const (
 	maxOpenConnections = 20
 )
 
+// MySQLClient struct.
+type MySQLClient struct {
+	db *sqlx.DB
+}
+
 // NewMySQLClient returns a mysql client
-func NewMySQLClient(user, pass, host, name string, readTimeout time.Duration) (*sqlx.DB, error) {
+func NewMySQLClient(user, pass, host, name string, readTimeout time.Duration) (*MySQLClient, error) {
 	connectionConfig := mysql.Config{User: user,
 		Passwd:          pass,
 		Net:             "tcp",
@@ -29,5 +34,6 @@ func NewMySQLClient(user, pass, host, name string, readTimeout time.Duration) (*
 	}
 	db.SetMaxIdleConns(maxIdleConnections)
 	db.SetMaxOpenConns(maxOpenConnections)
-	return db, nil
+
+	return &MySQLClient{db: db}, nil
 }

dbmysql/users.go

@@ -0,0 +1,56 @@
+package dbmysql
+
+import (
+	"fmt"
+
+	"github.com/Marchowes/ListMap/listmapper"
+	"github.com/Sirupsen/logrus"
+	"github.com/moogar0880/problems"
+)
+
+var (
+	foo = "bar"
+)
+
+// UserQueryParams object, holds user data.
+type UserQueryParams struct {
+	Username string `db:"user_name"`
+	Email    string `db:"email"`
+	Password string `db:"password"`
+	Level    string `db:"user_level"`
+}
+
+// User Struct
+type User struct {
+	Username string `db:"user_name"`
+	Email    string `db:"email"`
+	Password string `db:"password"`
+	Level    string `db:"user_level"`
+	//Created   string `db:"cust_id"`
+	//LastLogin string `db:"cust_id"`
+}
+
+// NewUserQueryParams returns a populated UserQueryParams object
+func NewUserQueryParams(username, email, password, level string) *UserQueryParams {
+
+	return &UserQueryParams{Username: username, Email: email, Password: password, Level: level}
+}
+
+// GetUsers gets users from mysql DB.
+func (db *MySQLClient) GetUsers(params *UserQueryParams) {
+	// stuff here
+
+}
+
+// GetUser gets single from mysql DB.
+func (db *MySQLClient) GetUser(username string, log *logrus.Entry) (*User, problems.StatusProblem) {
+	user := User{}
+	query := fmt.Sprintf("SELECT user_name, email, password, user_level FROM users where USER_NAME = '%s';", username)
+	err := db.db.Get(&user, query)
+	if err != nil {
+		log.WithError(err).Error("MySQL: Problem Getting User")
+		return nil, listmapper.InternalServerError
+	}
+	return &user, nil
+
+}

glide.yaml

@@ -7,3 +7,6 @@ import:
 - package: github.com/spf13/pflag
 - package: github.com/fsnotify/fsnotify
 - package: github.com/jmoiron/sqlx
+- package: github.com/Sirupsen/logrus
+- package: github.com/dyninc/qstring
+- package: github.com/moogar0880/problems

listmapper/context.go

@@ -0,0 +1,9 @@
+package listmapper
+
+const (
+	// MySQLClientKey is the client for the MySQL Backend.
+	MySQLClientKey = "mysqlclient"
+
+	// LoggingKey is the logrus logger.
+	LoggingKey = "logs"
+)

listmapper/errors.go

@@ -0,0 +1,15 @@
+package listmapper
+
+import (
+	"github.com/moogar0880/problems"
+)
+
+var (
+	// InvalidQueryParameters is for query parameters which contained invalid data.
+	InvalidQueryParameters = problems.NewDetailedProblem(400,
+		"Could Not Process Request: An invalid query parameter was submitted")
+
+	//InternalServerError is for internal server failures.
+	InternalServerError = problems.NewDetailedProblem(500,
+		"Internal Server Error")
+)

resources/users/users.go

@@ -0,0 +1,36 @@
+package users
+
+import (
+	"net/url"
+
+	"github.com/dyninc/qstring"
+)
+
+// User Struct
+type User struct {
+	Username  string
+	Email     string
+	Password  string
+	Level     string
+	Created   string
+	LastLogin string
+}
+
+// QueryParameters is a struct for the supported Users query parameters.
+type QueryParameters struct {
+	Username string `qstring:"username,omitempty"`
+	Email    string `qstring:"email,omitempty"`
+	Password string `qstring:"password,omitempty"`
+	Level    string `qstring:"level,omitempty"`
+}
+
+// NewQueryParams returns a new QueryParameters object
+func NewQueryParams(u *url.URL) (*QueryParameters, error) {
+	params := &QueryParameters{}
+	query := u.Query()
+	err := qstring.Unmarshal(query, params)
+	if err != nil {
+		return nil, err
+	}
+	return params, nil
+}

routers/common.go

@@ -0,0 +1,15 @@
+package routers
+
+import (
+	"encoding/json"
+
+	"github.com/gin-gonic/gin"
+	"github.com/moogar0880/problems"
+)
+
+// Abort writes passed in problems.StatusProblem to the Gin Response.
+func Abort(c *gin.Context, problem problems.StatusProblem) {
+	json, _ := json.Marshal(problem)
+	c.Data(problem.ProblemStatus(), problems.ProblemMediaType, json)
+	c.Abort()
+}

routers/users.go

@@ -0,0 +1,43 @@
+package routers
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/Marchowes/ListMap/dbmysql"
+	"github.com/Marchowes/ListMap/listmapper"
+	"github.com/Sirupsen/logrus"
+	"github.com/gin-gonic/gin"
+)
+
+// GetUsers gets users
+func GetUsers(c *gin.Context) {
+	log := c.MustGet(listmapper.LoggingKey).(*logrus.Entry)
+	//db := c.MustGet(listmapper.MySQLClientKey).(*dbmysql.MySQLClient)
+	//params, err := users.NewQueryParams(c.Request.URL)
+	//if err != nil {
+	//	log.WithError(err).Info("Invalid Query Parameters")
+	//	Abort(c, InvalidQueryParameters)
+	//	return
+	//}
+	log.Info("hi")
+
+}
+
+// GetUser gets users
+func GetUser(c *gin.Context) {
+	log := c.MustGet(listmapper.LoggingKey).(*logrus.Entry)
+	db := c.MustGet(listmapper.MySQLClientKey).(*dbmysql.MySQLClient)
+	username := c.Param("username")
+	user, prob := db.GetUser(username, log)
+	if prob != nil {
+		Abort(c, prob)
+		return
+	}
+	c.JSON(http.StatusOK, &user)
+}
+
+// PutUsers puts users
+func PutUsers(c *gin.Context) {
+	fmt.Println("holla")
+}

server/middleware.go

@@ -0,0 +1,17 @@
+package server
+
+import (
+	"github.com/Marchowes/ListMap/listmapper"
+	"github.com/Sirupsen/logrus"
+	"github.com/gin-gonic/gin"
+)
+
+// LoggingMiddleware injects a logrus logger.
+func LoggingMiddleware(c *gin.Context) {
+
+	logger := logrus.WithFields(logrus.Fields{
+		"Path": c.Request.URL.EscapedPath(),
+	})
+	c.Set(listmapper.LoggingKey, logger)
+
+}

server/mysql.go

@@ -4,12 +4,11 @@ import (
 	"time"
 
 	"github.com/Marchowes/ListMap/dbmysql"
-	"github.com/jmoiron/sqlx"
 	"github.com/spf13/viper"
 )
 
 // MySQLConnect connects to the MySQL Database and returns a client.
-func MySQLConnect() *sqlx.DB {
+func MySQLConnect() *dbmysql.MySQLClient {
 	readTimeout, err := time.ParseDuration(viper.GetString("mysql.readtimeout"))
 	if err != nil {
 		panic(err.Error())

server/server.go

@@ -6,29 +6,41 @@ import (
 	"os/signal"
 	"syscall"
 
+	"github.com/Marchowes/ListMap/dbmysql"
+	"github.com/Marchowes/ListMap/listmapper"
+	"github.com/Marchowes/ListMap/routers"
 	"github.com/gin-gonic/gin"
-	"github.com/jmoiron/sqlx"
 	"github.com/spf13/viper"
 )
 
 // Server struct
 type Server struct {
-	MySQLClient *sqlx.DB
+	MySQLClient *dbmysql.MySQLClient
 	router      *gin.Engine
+	UserRoutes  *gin.RouterGroup
 }
 
 // NewServer creates and returns a new Server instance
 func NewServer() *Server {
 	srv := &Server{router: gin.New(), MySQLClient: MySQLConnect()}
 
-	//srv.ConfigureRoutes()
+	srv.ConfigureRoutes()
 	return srv
 }
 
-// PUT ROUTES HERE
+// ConfigureRoutes Configures all the routes.
+func (srv *Server) ConfigureRoutes() {
+	srv.router.Use(injectMiddleware(srv))
+	srv.buildUserRoutes()
+}
 
-//func (srv *Server) ConfigureRoutes() {
-//}
+func injectMiddleware(srv *Server) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// Inject MySQL Client.
+		c.Set(listmapper.MySQLClientKey, srv.MySQLClient)
+		LoggingMiddleware(c)
+	}
+}
 
 // Run runs the server
 func (srv *Server) Run() {
@@ -46,3 +58,15 @@ func (srv *Server) Run() {
 	go srv.router.Run(on)
 	<-done
 }
+
+func (srv *Server) buildUserRoutes() {
+	srv.UserRoutes = srv.router.Group("/users")
+	{
+		srv.UserRoutes.GET("",
+			routers.GetUsers)
+		srv.UserRoutes.GET("/:username",
+			routers.GetUser)
+		srv.UserRoutes.PUT("",
+			routers.PutUsers)
+	}
+}