Updated complete code with comments at places where required

PythonHacker24 · PythonHacker24 · commit e97402e09959 · 2025-05-24T16:16:38.000+05:30
diff --git a/config/app.go b/config/app.go
@@ -17,10 +17,13 @@ type App struct {
 
 /* normalization function */
 func (a *App) Normalize() error {
+
+	/* set default name to laclm */
 	if a.Name == "" {
 		a.Name = "laclm"
 	}
 
+	/* set default version to v1.1 */
 	if a.Version == "" {
 		a.Name = "v1.1"
 	}
@@ -30,10 +33,12 @@ func (a *App) Normalize() error {
 		we want production to be true
 	*/
 
+	/* set default session timeout to 24 hours */
 	if a.SessionTimeout == 0 {
 		a.SessionTimeout = 24
 	}
 
+	/* check if base path is specified */
 	if a.BasePath == "" {
 		return errors.New(heredoc.Doc(`
 			Base path is not specified in the configuration file. 
diff --git a/config/authentication.go b/config/authentication.go
@@ -25,9 +25,11 @@ func (a *Authentication) Normalize() error {
 	return a.LDAPConfig.Normalize()
 }
 
+/* ldap authentication normalization function */
 func (l *LDAPConfig) Normalize() error {
 	/* TLS will be false by default */
 
+	/* check if address is specified */
 	if l.Address == "" {
 		return errors.New(heredoc.Doc(`
 			LDAP address is not specified in the configuration file. 
@@ -36,6 +38,7 @@ func (l *LDAPConfig) Normalize() error {
 		`))
 	}
 
+	/* check if admin DN is specified */
 	if l.AdminDN == "" {
 		return errors.New(heredoc.Doc(`
 			LDAP admin DN is not specified in the configuration file. 
@@ -44,6 +47,7 @@ func (l *LDAPConfig) Normalize() error {
 		`))
 	}
 
+	/* check if admin password is specified */
 	if l.AdminPassword == "" {
 		return errors.New(heredoc.Doc(`
 			LDAP admin password is not specified in the configuration file. 
@@ -52,6 +56,7 @@ func (l *LDAPConfig) Normalize() error {
 		`))
 	}
 
+	/* check if search base is specified */
 	if l.SearchBase == "" {
 		return errors.New(heredoc.Doc(`
 			LDAP search base is not specified in the configuration file. 
diff --git a/config/backend_security.go b/config/backend_security.go
@@ -14,6 +14,8 @@ type BackendSecurity struct {
 
 /* normalization function */
 func (b *BackendSecurity) Normalize() error {
+
+	/* check if JWT token secret is specified */
 	if b.JWTTokenSecret == "" {
 		return errors.New(heredoc.Doc(`
 			JWT Token Security is not specified in the configuration file. 
@@ -22,6 +24,7 @@ func (b *BackendSecurity) Normalize() error {
 		`))
 	}
 
+	/* set default JWT expiry to 24 hours */
 	if b.JWTExpiry == 0 {
 		b.JWTExpiry = 24
 	}
diff --git a/config/database.go b/config/database.go
@@ -24,6 +24,7 @@ func (d *Database) Normalize() error {
 	return d.TransactionLogRedis.Normalize()
 }
 
+/* transaction log redis normalization function */
 func (r *TransactionLogRedis) Normalize() error {
 	if r.Address == "" {
 		return errors.New(heredoc.Doc(`
diff --git a/config/filesystem.go b/config/filesystem.go
@@ -29,17 +29,23 @@ func (f *FileSystemServers) Normalize() error {
 		`))
 	}
 
+	/* set default method to local */
 	if f.Method == "" {
 		f.Method = "local"
 	}
 
+	/* check if method is remote */
 	if f.Method == "remote" {
+		/* check if remote is specified */
 		if f.Remote == nil {
 			return errors.New(heredoc.Doc(`
-			
+				Remote file server not specified in the configuration file. 
+
+				Please check the docs for more information: 
 			`))
 		}
 
+		/* check if host is specified */
 		if f.Remote.Host == "" {
 			return errors.New(heredoc.Doc(`
 				Address not provided for remote file server
@@ -48,6 +54,7 @@ func (f *FileSystemServers) Normalize() error {
 			`))
 		}
 
+		/* check if port is specified */
 		if f.Remote.Port == 0 {
 			return errors.New(heredoc.Doc(`
 				Port not provided for remote file server 	
diff --git a/config/logging.go b/config/logging.go
@@ -11,14 +11,18 @@ type Logging struct {
 
 /* normalization function */
 func (l *Logging) Normalize() error {
+
+	/* set default file to log/app.log */
 	if l.File == "" {
 		l.File = "log/app.log"
 	}
 
+	/* set default max size to 100MB */
 	if l.MaxSize == 0 {
 		l.MaxSize = 100
 	}
 
+	/* set default max backups to 3 */
 	if l.MaxBackups == 0 {
 		l.MaxBackups = 3
 	}
diff --git a/config/server.go b/config/server.go
@@ -8,10 +8,13 @@ type Server struct {
 
 /* normalization function */
 func (s *Server) Normalize() error {
+
+	/* set default host to localhost */
 	if s.Host == "" {
 		s.Host = "localhost"
 	}
 
+	/* set default port to 8080 */
 	if s.Port == 0 {
 		s.Port = 8080
 	}
diff --git a/internal/auth/auth.go b/internal/auth/auth.go
@@ -14,6 +14,7 @@ import (
 func GenerateJWT(username string) (string, error) {
 	expiryHours := config.BackendConfig.BackendSecurity.JWTExpiry
 
+	/* generate JWT token with claims */
 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
 		"username": username,
 		"exp":      time.Now().Add(time.Hour * time.Duration(expiryHours)).Unix(),
@@ -24,17 +25,21 @@ func GenerateJWT(username string) (string, error) {
 
 /* validate JWT token and return claims */
 func ValidateJWT(tokenString string) (jwt.MapClaims, error) {
+
+	/* parse the token */
 	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
 		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
 			return nil, fmt.Errorf("unexpected signing method")
 		}
 		return []byte(config.BackendConfig.BackendSecurity.JWTTokenSecret), nil
 	})
 
+	/* check if token is valid */
 	if err != nil {
 		return nil, fmt.Errorf("JWT parsing error: %w", err)
 	}
 
+	/* check if token is valid */
 	if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
 		return claims, nil
 	}
diff --git a/internal/auth/handler.go b/internal/auth/handler.go
@@ -15,13 +15,15 @@ func LoginHandler(w http.ResponseWriter, r *http.Request) {
 
 	/* POST Request only - specified in routes */
 
+	/* decode the request body */
 	var user User
 	err := json.NewDecoder(r.Body).Decode(&user)
 	if err != nil {
 		http.Error(w, "Invalid request body", http.StatusBadRequest)
 		return
 	}
 
+	/* check if username and password are specified */
 	if user.Username == "" || user.Password == "" {
 		http.Error(w, "Username and password are required", http.StatusBadRequest)
 		return
@@ -32,6 +34,8 @@ func LoginHandler(w http.ResponseWriter, r *http.Request) {
 		user.Password,
 		config.BackendConfig.Authentication.LDAPConfig.SearchBase,
 	)
+
+	/* check if authentication is successful */
 	if !authStatus {
 		zap.L().Warn("User with invalid credentials attempted to log in")
 		http.Error(w, "Invalid credentials", http.StatusUnauthorized)
diff --git a/internal/auth/ldap.go b/internal/auth/ldap.go
@@ -24,6 +24,7 @@ func AuthenticateUser(username, password, searchbase string) bool {
 	var err error
 	ldapAddress := config.BackendConfig.Authentication.LDAPConfig.Address
 
+	/* check if TLS is enabled */
 	if config.BackendConfig.Authentication.LDAPConfig.TLS {
 		l, err = ldap.DialURL(ldapAddress, ldap.DialWithTLSConfig(&tls.Config{
 
diff --git a/internal/health/handler.go b/internal/health/handler.go
@@ -11,9 +11,11 @@ import (
 func HealthHandler(w http.ResponseWriter, r *http.Request) {
 	var response HealthResponse
 
+	/* set the content type and write the response */
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusOK)
 
+	/* set the status to ok */
 	response.Status = "ok"
 	if err := json.NewEncoder(w).Encode(response); err != nil {
 		zap.L().Error("Failed to send health response from the handler",
diff --git a/internal/utils/utils.go b/internal/utils/utils.go
@@ -35,23 +35,25 @@ func InitLogger(isProduction bool) {
 	} else {
 
 		/* development level logging - configured for debug */
-
+		/* set the encoder to console encoder */
 		cfg := zap.NewDevelopmentEncoderConfig()
 		cfg.EncodeLevel = zapcore.CapitalColorLevelEncoder
 		encoder = zapcore.NewConsoleEncoder(cfg)
 		logLevel = zapcore.DebugLevel
 		writeSyncer = zapcore.AddSync(os.Stdout)
 	}
 
+	/* create the core */
 	core := zapcore.NewCore(
 		encoder,
 		writeSyncer,
 		logLevel,
 	)
 
+	/* create the logger */
 	Log = zap.New(core, zap.AddCaller(), zap.AddStacktrace(zapcore.ErrorLevel))
 
-	/* allow global logging with zap.L() */
+	/* allow global logging with zap.L() - zap.L() is a global logger */
 	zap.ReplaceGlobals(Log)
 
 	log.Println("Initialized Zap Logger")

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,8 @@ type BackendSecurity struct {`
`14`	`14`
`15`	`15`	`/* normalization function */`
`16`	`16`	`func (b *BackendSecurity) Normalize() error {`
	`17`	`+`
	`18`	`+ /* check if JWT token secret is specified */`
`17`	`19`	`if b.JWTTokenSecret == "" {`
`18`	`20`	return errors.New(heredoc.Doc(`
`19`	`21`	`JWT Token Security is not specified in the configuration file.`
`@@ -22,6 +24,7 @@ func (b *BackendSecurity) Normalize() error {`
`22`	`24`	`))
`23`	`25`	`}`
`24`	`26`
	`27`	`+ /* set default JWT expiry to 24 hours */`
`25`	`28`	`if b.JWTExpiry == 0 {`
`26`	`29`	`b.JWTExpiry = 24`
`27`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ func (d *Database) Normalize() error {`
`24`	`24`	`return d.TransactionLogRedis.Normalize()`
`25`	`25`	`}`
`26`	`26`
	`27`	`+/* transaction log redis normalization function */`
`27`	`28`	`func (r *TransactionLogRedis) Normalize() error {`
`28`	`29`	`if r.Address == "" {`
`29`	`30`	return errors.New(heredoc.Doc(`
Original file line number	Diff line number	Diff line change
`@@ -11,14 +11,18 @@ type Logging struct {`
`11`	`11`
`12`	`12`	`/* normalization function */`
`13`	`13`	`func (l *Logging) Normalize() error {`
	`14`	`+`
	`15`	`+ /* set default file to log/app.log */`
`14`	`16`	`if l.File == "" {`
`15`	`17`	`l.File = "log/app.log"`
`16`	`18`	`}`
`17`	`19`
	`20`	`+ /* set default max size to 100MB */`
`18`	`21`	`if l.MaxSize == 0 {`
`19`	`22`	`l.MaxSize = 100`
`20`	`23`	`}`
`21`	`24`
	`25`	`+ /* set default max backups to 3 */`
`22`	`26`	`if l.MaxBackups == 0 {`
`23`	`27`	`l.MaxBackups = 3`
`24`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,10 +8,13 @@ type Server struct {`
`8`	`8`
`9`	`9`	`/* normalization function */`
`10`	`10`	`func (s *Server) Normalize() error {`
	`11`	`+`
	`12`	`+ /* set default host to localhost */`
`11`	`13`	`if s.Host == "" {`
`12`	`14`	`s.Host = "localhost"`
`13`	`15`	`}`
`14`	`16`
	`17`	`+ /* set default port to 8080 */`
`15`	`18`	`if s.Port == 0 {`
`16`	`19`	`s.Port = 8080`
`17`	`20`	`}`