chore: reorder part two

internal/server/api/api.go

@@ -0,0 +1,43 @@
+package api
+
+import (
+	"fmt"
+	"log/slog"
+
+	"orbits-server/internal/server/api/middleware"
+	"orbits-server/internal/server/api/routes"
+	"orbits-server/internal/server/bootstrap"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+// All error messages from slog must have an error field with the golang error
+// See bottom the the kickoff function for details
+
+func KickoffApi(logger *slog.Logger, env bootstrap.Environment, db *gorm.DB) {
+	gin.SetMode(gin.ReleaseMode)
+
+	// For a nice looking logger:
+	// r := gin.Default()
+	// JSON logger: https://gin-gonic.com/en/docs/logging/structured-logging/
+	r := gin.New()
+	r.Use(middleware.SlogMiddleware(logger))
+	r.Use(gin.Recovery())
+
+	api := r.Group("/api")
+	routes.RegisterApiRoutes(api /*env,*/, db)
+
+	file := r.Group("/file")
+	routes.RegisterFileRoutes(file, env, db)
+
+	r.Static("/assets", "./web/frontend/dist/assets")
+	r.NoRoute(func(c *gin.Context) {
+		c.File("./web/frontend/dist/index.html")
+	})
+
+	err := r.Run(fmt.Sprintf("%s:%d", env.Hostname, env.Port))
+	if err != nil {
+		slog.Error("failed to start the Gin server", "error", err)
+	}
+}

internal/server/api/middleware/middleware.go

@@ -0,0 +1,60 @@
+package middleware
+
+import (
+	"log/slog"
+	"net/http"
+	"orbits-server/internal/server/api/response"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+func SlogMiddleware(logger *slog.Logger) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		start := time.Now()
+		path := c.Request.URL.Path
+		query := c.Request.URL.RawQuery
+
+		c.Next()
+
+		logger.Debug("request",
+			slog.String("method", c.Request.Method),
+			slog.String("path", path),
+			slog.String("query", query),
+			slog.Int("status", c.Writer.Status()),
+			slog.Duration("latency", time.Since(start)),
+			slog.String("client_ip", c.ClientIP()),
+			slog.Int("body_size", c.Writer.Size()),
+		)
+
+		if len(c.Errors) > 0 {
+			for _, err := range c.Errors {
+				logger.Error("request error", slog.String("error", err.Error()))
+			}
+		}
+	}
+}
+
+func AuthMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		authorizationHeader := c.GetHeader("Authorization")
+		if len(authorizationHeader) == 0 {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, response.BasicResponse{
+				Msg: "Authorization header is required",
+			})
+			return
+		}
+
+		headerParts := strings.Split(authorizationHeader, " ")
+		if len(headerParts) != 2 || headerParts[0] != "Bearer" {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, response.BasicResponse{
+				Msg: "Authorization header is invalid",
+			})
+			return
+		}
+
+		givenKey := headerParts[1]
+		slog.Info(givenKey)
+	}
+}

internal/server/api/response/response.go

@@ -0,0 +1,11 @@
+package response
+
+const (
+	OkMes     string = "OK"
+	IntErrMes string = "An internal error occured, contact your administrator"
+)
+
+type BasicResponse struct {
+	Msg  string `json:"msg"`
+	Data any    `json:"data"`
+}

internal/server/api/routes/api.go

@@ -0,0 +1,52 @@
+package routes
+
+import (
+	"log/slog"
+	"net/http"
+	"orbits-server/internal/server/api/response"
+	"orbits-server/internal/server/database"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func RegisterApiRoutes(api *gin.RouterGroup /* env runtime.Environment,*/, db *gorm.DB) {
+	// prefix: api
+	// Display the information on what is going on at the moment
+	api.GET("/command", func(c *gin.Context) {
+		state, err := database.GetState(db)
+		if err != nil {
+			slog.Error("unable to determine state", "error", err)
+			c.JSON(http.StatusInternalServerError, response.BasicResponse{
+				Msg: response.IntErrMes,
+			})
+			return
+		}
+
+		c.JSON(http.StatusOK, response.BasicResponse{
+			Msg:  response.OkMes,
+			Data: state,
+		})
+	})
+
+	api.PATCH("/command", func(c *gin.Context) {
+
+	})
+
+	// define a route to check what is registered
+	api.GET("/available", func(c *gin.Context) {
+		files, err := database.GetFiles(db)
+		if err != nil {
+			slog.Error("failed to retrieve available files", "error", err)
+			c.JSON(http.StatusInternalServerError, response.BasicResponse{
+				Msg: response.IntErrMes,
+			})
+			return
+		}
+
+		c.JSON(http.StatusOK, response.BasicResponse{
+			Msg:  response.OkMes,
+			Data: files,
+		})
+	})
+}

internal/server/api/routes/file.go

@@ -0,0 +1,82 @@
+package routes
+
+import (
+	"errors"
+	"log/slog"
+	"net/http"
+	"orbits-server/internal/server/api/response"
+	"orbits-server/internal/server/bootstrap"
+	"orbits-server/internal/server/database"
+	"path/filepath"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+func RegisterFileRoutes(file *gin.RouterGroup, env bootstrap.Environment, db *gorm.DB) {
+	// /file/<file-name>
+	file.GET("/:filename", func(c *gin.Context) {
+		f := c.Param("filename")
+		p := filepath.Join(env.ContentDirectory, f)
+
+		c.File(p)
+	})
+
+	// define the upload route
+	// /file/upload
+	file.POST("/upload", func(c *gin.Context) {
+		f, err := c.FormFile("file")
+		if err != nil {
+			slog.Debug("no file or file headers provided on the request", "error", err)
+			c.JSON(http.StatusBadRequest, response.BasicResponse{
+				Msg: "a file is required",
+			})
+			return
+		}
+
+		readerStream, err := f.Open()
+		if err != nil {
+			slog.Error("failed to a reader stream")
+		}
+		defer readerStream.Close()
+
+		fileData, err := database.BuildFileRecord(readerStream, f.Filename, env.ContentDirectory)
+		if err != nil {
+			slog.Error("failed to enroll file to the database", "error", err)
+			c.JSON(http.StatusInternalServerError, response.BasicResponse{
+				Msg: response.IntErrMes,
+			})
+			return
+		}
+
+		if err := database.RegisterFile(db, fileData); err != nil {
+			if errors.Is(err, gorm.ErrDuplicatedKey) {
+				slog.Debug("discarding file since its checksum is a duplicate", "error", err)
+				c.JSON(http.StatusConflict, response.BasicResponse{
+					Msg: "file checksum already exists",
+				})
+			} else {
+				slog.Error("failed to insert filedata to the database", "error", err)
+				c.JSON(http.StatusInternalServerError, response.BasicResponse{
+					Msg: response.IntErrMes,
+				})
+			}
+			return
+		}
+
+		// save to filesystem after everything has given a green light
+		if err := c.SaveUploadedFile(f, fileData.FilePath); err != nil {
+			slog.Error("failed to receive the file over http:", "error", err)
+			c.JSON(http.StatusInternalServerError, response.BasicResponse{
+				Msg: response.IntErrMes,
+			})
+			return
+		}
+
+		slog.Info("saved file to local filesystem and database")
+		c.JSON(http.StatusCreated, response.BasicResponse{
+			Msg:  "file has succesfully been uploaded",
+			Data: fileData,
+		})
+	})
+}