Formated the code with gofmt

Author: PythonHacker24

api/middleware/middleware.go

@@ -15,7 +15,7 @@ func LoggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
 
 		/* logging recieved request at the instant of receiving */
 		zap.L().Info("Recieved request",
-			zap.String("Method", r.Method),	
+			zap.String("Method", r.Method),
 			zap.String("Path", r.URL.Path),
 		)
 
@@ -36,11 +36,11 @@ func AuthenticationMiddleware(next http.HandlerFunc) http.HandlerFunc {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 
 		/* authenticate the request through JWT */
-		username, err := auth.ExtractUsernameFromRequest(r)		
+		username, err := auth.ExtractUsernameFromRequest(r)
 		if err != nil {
 			zap.L().Error("Error during authentication",
 				zap.Error(err),
-			)		
+			)
 			return
 		}
 

config/app.go

@@ -2,9 +2,9 @@ package config
 
 /* app parameters */
 type App struct {
-	Name        string `yaml:"name,omitempty"`
-	Version     string `yaml:"version,omitempty"`
-	DebugMode   bool   `yaml:"debug_mode,omitempty"`
+	Name      string `yaml:"name,omitempty"`
+	Version   string `yaml:"version,omitempty"`
+	DebugMode bool   `yaml:"debug_mode,omitempty"`
 }
 
 /* normalization function */
@@ -17,10 +17,10 @@ func (a *App) Normalize() error {
 		a.Name = "v1.1"
 	}
 
-	/* 
-		if debug_mode is not provided, it's false 
+	/*
+		if debug_mode is not provided, it's false
 		we want production to be true
 	*/
 
-	return nil 
+	return nil
 }

config/authentication.go

@@ -8,16 +8,16 @@ import (
 
 /* authentication parameters */
 type Authentication struct {
-	LDAPConfig		LDAPConfig 	`yaml:"ldap,omitempty"`
+	LDAPConfig LDAPConfig `yaml:"ldap,omitempty"`
 }
 
 /* ldap authentication parameters */
 type LDAPConfig struct {
-	TLS             bool		`yaml:"tls,omitempty"`
-	Address			string 		`yaml:"address,omitempty"`
-	AdminDN 		string		`yaml:"admin_dn,omitempty"`
-	AdminPassword	string		`yaml:"admin_password,omitempty"`
-	SearchBase		string		`yaml:"search_base,omitempty"`
+	TLS           bool   `yaml:"tls,omitempty"`
+	Address       string `yaml:"address,omitempty"`
+	AdminDN       string `yaml:"admin_dn,omitempty"`
+	AdminPassword string `yaml:"admin_password,omitempty"`
+	SearchBase    string `yaml:"search_base,omitempty"`
 }
 
 /* normalization function */
@@ -59,6 +59,6 @@ func (l *LDAPConfig) Normalize() error {
 			Please check the docs for more information: 
 		`))
 	}
-	
+
 	return nil
 }

config/backend_security.go

@@ -8,8 +8,8 @@ import (
 
 /* backend security configs */
 type BackendSecurity struct {
-	JWTTokenSecret 	string 	`yaml:"jwt_secret_token,omitempty"`
-	JWTExpiry 		int 	`yaml:"jwt_expiry,omitempty"`
+	JWTTokenSecret string `yaml:"jwt_secret_token,omitempty"`
+	JWTExpiry      int    `yaml:"jwt_expiry,omitempty"`
 }
 
 /* normalization function */
@@ -19,7 +19,7 @@ func (b *BackendSecurity) Normalize() error {
 			JWT Token Security is not specified in the configuration file. 
 
 			Please check the docs for more information: 
-		`)) 
+		`))
 	}
 
 	if b.JWTExpiry == 0 {

config/database.go

@@ -32,11 +32,11 @@ func (r *TransactionLogRedis) Normalize() error {
 			Please check the docs for more information: 
 		`))
 	}
-	
+
 	/* password can be empty */
 	if r.Password == "" {
 		/* just warn users to use password protected redis */
-		fmt.Printf("Prefer using password for redis for security purposes\n\n")	
+		fmt.Printf("Prefer using password for redis for security purposes\n\n")
 	}
 
 	/* r.DB default value can be 0 */

config/filesystem.go

@@ -26,27 +26,27 @@ func (f *FileSystemServers) Normalize() error {
 			Remote server file path not specified in the configuration file. 
 
 			Please check the docs for more information: 
-		`))	
+		`))
 	}
 
 	if f.Method == "" {
 		f.Method = "local"
 	}
-	
+
 	if f.Method == "remote" {
 		if f.Remote == nil {
 			return errors.New(heredoc.Doc(`
 			
 			`))
 		}
-		
+
 		if f.Remote.Host == "" {
 			return errors.New(heredoc.Doc(`
 				Address not provided for remote file server
 				
 				Please check the docs for more information: 
 			`))
-		} 
+		}
 
 		if f.Remote.Port == 0 {
 			return errors.New(heredoc.Doc(`

config/loader.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"os"
 
-	"gopkg.in/yaml.v3"
 	"github.com/davecgh/go-spew/spew"
+	"gopkg.in/yaml.v3"
 )
 
 /*
@@ -18,32 +18,32 @@ import (
 func LoadConfig(path string) error {
 
 	/* read the yaml config file */
-    data, err := os.ReadFile(path)
-    if err != nil {
-		return fmt.Errorf("config loading error %w", 
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("config loading error %w",
 			err,
 		)
 
-    }
+	}
 
 	/* expand all environment variables in the yaml config */
 	expanded := os.ExpandEnv(string(data))
 
 	/* unmarshal the yaml file to defined struct */
-    err = yaml.Unmarshal([]byte(expanded), &BackendConfig)
-    if err != nil {
-		return fmt.Errorf("config loading error %w", 
+	err = yaml.Unmarshal([]byte(expanded), &BackendConfig)
+	if err != nil {
+		return fmt.Errorf("config loading error %w",
 			err,
 		)
-    }
+	}
 
 	/* write the config file in console if in debug mode */
 	if BackendConfig.AppInfo.DebugMode {
 		fmt.Println("Contents of Config File (debug mode ON)")
 		spew.Dump(BackendConfig)
 		fmt.Println()
 	}
-	
+
 	/* normalize the complete backend config before proceeding */
 	return BackendConfig.Normalize()
 }

config/logging.go

@@ -22,7 +22,7 @@ func (l *Logging) Normalize() error {
 	if l.MaxBackups == 0 {
 		l.MaxBackups = 3
 	}
-	
+
 	/* let compression remain false by default */
 
 	return nil

internal/auth/auth.go

@@ -1,13 +1,13 @@
-package auth 
+package auth
 
 import (
 	"fmt"
-	"time"
 	"net/http"
 	"strings"
+	"time"
 
-	"github.com/golang-jwt/jwt/v5"
 	"github.com/PythonHacker24/linux-acl-management-backend/config"
+	"github.com/golang-jwt/jwt/v5"
 )
 
 /* generating jwt token for user identification with specified configs */
@@ -51,34 +51,34 @@ func ValidateJWT(tokenString string) (jwt.MapClaims, error) {
 func GetUsernameFromJWT(tokenString string) (string, error) {
 
 	/* get claims from JWT Token */
-    claims, err := ValidateJWT(tokenString)
-    if err != nil {
+	claims, err := ValidateJWT(tokenString)
+	if err != nil {
 		return "", fmt.Errorf("JWT validation error: %w", err)
-    }
+	}
 
 	/* extract username from JWT Token */
-    username, ok := claims["username"].(string)
-    if !ok {
-        return "", fmt.Errorf("username not found in token")
-    }
+	username, ok := claims["username"].(string)
+	if !ok {
+		return "", fmt.Errorf("username not found in token")
+	}
 
-    return username, nil
+	return username, nil
 }
 
 /* extract username from http request (wrapper around GetUsernameFromJWT for http requests) */
 func ExtractUsernameFromRequest(r *http.Request) (string, error) {
 
 	/* extract authentication hearder from http request */
-    authHeader := r.Header.Get("Authorization")
-    if authHeader == "" {
-        return "", fmt.Errorf("missing Authorization header")
-    }
-	
+	authHeader := r.Header.Get("Authorization")
+	if authHeader == "" {
+		return "", fmt.Errorf("missing Authorization header")
+	}
+
 	/* parse the token from the header */
-    tokenParts := strings.Split(authHeader, " ")
-    if len(tokenParts) != 2 || tokenParts[0] != "Bearer" {
-        return "", fmt.Errorf("invalid Authorization header format")
-    }
+	tokenParts := strings.Split(authHeader, " ")
+	if len(tokenParts) != 2 || tokenParts[0] != "Bearer" {
+		return "", fmt.Errorf("invalid Authorization header format")
+	}
 
-    return GetUsernameFromJWT(tokenParts[1])
+	return GetUsernameFromJWT(tokenParts[1])
 }

internal/auth/handler.go

@@ -12,53 +12,53 @@ import (
 
 /* Handles user login and creates a session */
 func LoginHandler(w http.ResponseWriter, r *http.Request) {
-	
+
 	/* POST Request only - specified in routes */
 
-    var user User
-    err := json.NewDecoder(r.Body).Decode(&user)
-    if err != nil {
-        http.Error(w, "Invalid request body", http.StatusBadRequest)
-        return
-    }
+	var user User
+	err := json.NewDecoder(r.Body).Decode(&user)
+	if err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
 
-    if user.Username == "" || user.Password == "" {
-        http.Error(w, "Username and password are required", http.StatusBadRequest)
-        return
-    }
+	if user.Username == "" || user.Password == "" {
+		http.Error(w, "Username and password are required", http.StatusBadRequest)
+		return
+	}
 
 	/* authenticate the user */
-    authStatus := AuthenticateUser(user.Username, 
-		user.Password, 
+	authStatus := AuthenticateUser(user.Username,
+		user.Password,
 		config.BackendConfig.Authentication.LDAPConfig.SearchBase,
 	)
-    if !authStatus {
+	if !authStatus {
 		zap.L().Warn("User with invalid credentials attempted to log in")
-        http.Error(w, "Invalid credentials", http.StatusUnauthorized)
-        return
-    }
+		http.Error(w, "Invalid credentials", http.StatusUnauthorized)
+		return
+	}
 
 	/* after building session manager */
-    session.CreateSession(user.Username)
+	session.CreateSession(user.Username)
 
 	/* generate JWT for user interaction */
-    token, err := GenerateJWT(user.Username)
-    if err != nil {
-        zap.L().Error("Error generating token", 
+	token, err := GenerateJWT(user.Username)
+	if err != nil {
+		zap.L().Error("Error generating token",
 			zap.Error(err),
 		)
-        http.Error(w, "Error generating token", http.StatusInternalServerError)
-        return
-    }
+		http.Error(w, "Error generating token", http.StatusInternalServerError)
+		return
+	}
 
 	/* create auth successful response */
-    response := map[string]string{"token": token}
-    w.Header().Set("Content-Type", "application/json")
-    if err := json.NewEncoder(w).Encode(response); err != nil {
-        zap.L().Error("Failed to encode response", 
+	response := map[string]string{"token": token}
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(response); err != nil {
+		zap.L().Error("Failed to encode response",
 			zap.Error(err),
 		)
-        http.Error(w, "Failed to encode response", http.StatusInternalServerError)
-        return
-    }
+		http.Error(w, "Failed to encode response", http.StatusInternalServerError)
+		return
+	}
 }