init server

ginserver/logger.go

@@ -0,0 +1,71 @@
+package ginserver
+
+import (
+	"math/rand"
+	utils2 "nos-comptes/internal/utils"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+const (
+	letterBytes   = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	letterIdxBits = 6                    // 6 bits to represent a letter index
+	letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
+	letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
+)
+
+var src = rand.NewSource(time.Now().UnixNano())
+
+func randStringBytesMaskImprSrc(n int) string {
+	b := make([]byte, n)
+	// A src.Int63() generates 63 random bits, enough for letterIdxMax characters!
+	for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
+		if remain == 0 {
+			cache, remain = src.Int63(), letterIdxMax
+		}
+		if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
+			b[i] = letterBytes[idx]
+			i--
+		}
+		cache >>= letterIdxBits
+		remain--
+	}
+
+	return string(b)
+}
+
+func GetLoggerMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		correlationID := c.Request.Header.Get(utils2.HeaderNameCorrelationID)
+		if correlationID == "" {
+			correlationID = randStringBytesMaskImprSrc(30)
+			c.Writer.Header().Set(utils2.HeaderNameCorrelationID, correlationID)
+		}
+
+		logger := utils2.GetLogger()
+		logEntry := logger.WithField(utils2.HeaderNameCorrelationID, correlationID)
+
+		c.Set(utils2.ContextKeyLogger, logEntry)
+	}
+}
+
+func GetHTTPLoggerMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+
+		utils2.GetLoggerFromCtx(c).
+			WithField("method", c.Request.Method).
+			WithField("url", c.Request.RequestURI).
+			WithField("from", c.ClientIP()).
+			Info("start handling HTTP request")
+
+		c.Next()
+		d := time.Since(start)
+
+		utils2.GetLoggerFromCtx(c).
+			WithField("status", c.Writer.Status()).
+			WithField("duration", d.String()).
+			Info("end handling HTTP request")
+	}
+}

ginserver/router.go

@@ -0,0 +1,76 @@
+package ginserver
+
+import (
+	"net/http"
+	"nos-comptes/handler"
+	"nos-comptes/internal/account"
+	"nos-comptes/internal/expense"
+	sharedaccount "nos-comptes/internal/shared-account"
+	"nos-comptes/internal/storage/dao/postgresql"
+	"nos-comptes/internal/user"
+	"time"
+
+	"github.com/gin-gonic/gin"
+
+	"github.com/gin-contrib/cors"
+)
+
+func NewRouter(config *handler.Config) *gin.Engine {
+	gin.SetMode(gin.ReleaseMode)
+
+	router := gin.New()
+	router.HandleMethodNotAllowed = true
+
+	router.Use(cors.New(cors.Config{
+		AllowOrigins:     []string{"*"},
+		AllowMethods:     []string{"*"},
+		AllowHeaders:     []string{"*"},
+		ExposeHeaders:    []string{"*"},
+		AllowCredentials: true,
+		MaxAge:           12 * time.Hour,
+	}))
+	router.Use(gin.Recovery())
+	router.Use(GetLoggerMiddleware())
+	router.Use(GetHTTPLoggerMiddleware())
+
+	db := postgresql.NewDatabasePostgreSQL(config.DBConnectionURI)
+	hc := handler.NewContext()
+	uh := user.NewHandler(hc, db)
+	ah := account.NewHandler(hc, db)
+	sah := sharedaccount.NewHandler(hc, db)
+	eh := expense.NewHandler(hc, db)
+
+	public := router.Group("/")
+	public.Handle(http.MethodGet, "/_health", hc.GetHealth)
+
+	userRoute := public.Group("/users")
+	userRoute.Handle("LOGIN", "", uh.ConnectUser)
+	userRoute.Handle(http.MethodPost, "", uh.CreateUser)
+
+	securedUserRoute := userRoute.Group("")
+	//TODO add secure auth
+	securedUserRoute.Handle(http.MethodGet, "/:userId", uh.GetUser)
+	// end: user routes
+
+	securedAccountRoute := securedUserRoute.Group("/:userId/accounts")
+	//account route
+	securedAccountRoute.Handle(http.MethodGet, "/", ah.GetAllAccountOfUser)
+	securedAccountRoute.Handle(http.MethodPost, "/:accountId", ah.CreateAccountOfUser)
+	securedAccountRoute.Handle(http.MethodDelete, "/:accountId", ah.DeleteAccountOfUser)
+	securedAccountRoute.Handle(http.MethodGet, "/", ah.GetSpecificAccountOfUser)
+
+	securedSharedAccountRoute := securedUserRoute.Group("/:userId/sharedaccounts")
+	//shared route
+	securedSharedAccountRoute.Handle(http.MethodPost, "/:accountId", sah.ShareAnAccount)
+	securedSharedAccountRoute.Handle(http.MethodDelete, "/:accountId", sah.DeleteSharedAccount)
+	securedSharedAccountRoute.Handle(http.MethodGet, "/", sah.GetAllSharedAccountOfUser)
+	securedSharedAccountRoute.Handle(http.MethodGet, "/:sharedAccountId", sah.GetSpecificSharedAccountOfUser)
+
+	securedExpenseRoute := securedUserRoute.Group("/:userId/accounts/:accountId/expenses")
+	//expense route
+	securedExpenseRoute.Handle(http.MethodPost, "/", eh.CreateAnExpense)
+	securedExpenseRoute.Handle(http.MethodDelete, "/:expenseId", eh.DeleteExpense)
+	securedExpenseRoute.Handle(http.MethodGet, "/", eh.GetAllExpenses)
+	securedExpenseRoute.Handle(http.MethodGet, "/:expenseId", eh.GetAnExpenses)
+	return router
+}