Project structure created and Creating the necessary files

Author: soheilkhaledabdi

.gitignore

@@ -0,0 +1,26 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+*.DS_store
+*.log
+*.log.gz
+__debug_bin
+*/cmd/uploads

api/api.go

@@ -0,0 +1,21 @@
+package api
+
+import (
+	"fmt"
+
+	"github.com/Asrez/GoAPIBlog/config"
+	"github.com/gin-gonic/gin"
+)
+
+func InitServer(){
+	config := config.GetConfig()
+	r := gin.New()
+	r.Use(gin.Logger()  ,gin.Recovery())
+
+	// v1 := r.Group("api/v1")
+	// {
+		
+	// }
+
+	r.Run(fmt.Sprintf(":%s", config.Server.InternalPort))
+}

api/dto/auth.go

@@ -0,0 +1,21 @@
+package dto
+
+type TokenDetail struct {
+	AccessToken            string `json:"accessToken"`
+	RefreshToken           string `json:"refreshToken"`
+	AccessTokenExpireTime  int64  `json:"accessTokenExpireTime"`
+	RefreshTokenExpireTime int64  `json:"refreshTokenExpireTime"`
+}
+
+type RegisterUserByUsernameRequest struct {
+	FirstName string `json:"firstName" binding:"required,min=3"`
+	LastName  string `json:"lastName" binding:"required,min=6"`
+	Username  string `json:"username" binding:"required,min=5"`
+	Email     string `json:"email" binding:"min=6,email"`
+	Password  string `json:"password" binding:"required,password,min=6"`
+}
+
+type LoginByUsernameRequest struct {
+	Username string `json:"username" binding:"required,min=5"`
+	Password string `json:"password" binding:"required,min=6"`
+}

api/helpers/base_response.go

@@ -0,0 +1,46 @@
+package helper
+
+import (
+	validation "github.com/Asrez/GoAPIBlog/api/validations"
+)
+
+
+type BaseHttpResponse struct {
+	Result           any                           `json:"result"`
+	Success          bool                          `json:"success"`
+	ResultCode       ResultCode                           `json:"resultCode"`
+	ValidationErrors *[]validation.ValidationError `json:"validationErrors"`
+	Error            any                           `json:"error"`
+}
+
+func GenerateBaseResponse(result any, success bool, resultCode ResultCode) *BaseHttpResponse {
+	return &BaseHttpResponse{Result: result,
+		Success:    success,
+		ResultCode: resultCode,
+	}
+}
+
+func GenerateBaseResponseWithError(result any, success bool, resultCode ResultCode, err error) *BaseHttpResponse {
+	return &BaseHttpResponse{Result: result,
+		Success:    success,
+		ResultCode: resultCode,
+		Error:      err.Error(),
+	}
+
+}
+
+func GenerateBaseResponseWithAnyError(result any, success bool, resultCode ResultCode, err any) *BaseHttpResponse {
+	return &BaseHttpResponse{Result: result,
+		Success:    success,
+		ResultCode: resultCode,
+		Error:      err,
+	}
+}
+
+func GenerateBaseResponseWithValidationError(result any, success bool, resultCode ResultCode, err error) *BaseHttpResponse {
+	return &BaseHttpResponse{Result: result,
+		Success:          success,
+		ResultCode:       resultCode,
+		ValidationErrors: validation.GetValidationErrors(err),
+	}
+}

api/helpers/result_code.go

@@ -0,0 +1,15 @@
+package helper
+
+type ResultCode int
+
+const (
+	Success         ResultCode = 0
+	ValidationError ResultCode = 40001
+	AuthError       ResultCode = 40101
+	ForbiddenError       ResultCode = 40301
+	NotFoundError ResultCode = 40401
+	LimiterError    ResultCode = 42901
+	OtpLimiterError ResultCode = 42902
+	CustomRecovery  ResultCode = 50001
+	InternalError   ResultCode = 50002
+)

api/helpers/status_code_mapping.go

@@ -0,0 +1,22 @@
+package helper
+
+import (
+	"net/http"
+	"github.com/Asrez/GoAPIBlog/pkg/service_errors"
+)
+
+var StatusCodeMapping = map[string]int{
+	// User
+	service_errors.EmailExists:      409,
+	service_errors.UsernameExists:   409,
+	service_errors.RecordNotFound:   404,
+	service_errors.PermissionDenied: 403,
+}
+
+func TranslateErrorToStatusCode(err error) int {
+	value, ok := StatusCodeMapping[err.Error()]
+	if !ok {
+		return http.StatusInternalServerError
+	}
+	return value
+}

api/middlewares/auth.go

@@ -0,0 +1,52 @@
+package middlewares
+
+import (
+	"net/http"
+	"strings"
+	helper "github.com/Asrez/GoAPIBlog/api/helpers"
+	"github.com/Asrez/GoAPIBlog/config"
+	"github.com/Asrez/GoAPIBlog/constants"
+	"github.com/Asrez/GoAPIBlog/pkg/service_errors"
+	"github.com/Asrez/GoAPIBlog/services"
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt"
+)
+
+func Authentication(cfg *config.Config) gin.HandlerFunc {
+	var tokenService = services.NewTokenService(cfg)
+
+	return func(c *gin.Context) {
+		var err error
+		claimMap := map[string]interface{}{}
+		auth := c.GetHeader(constants.AuthorizationHeaderKey)
+		token := strings.Split(auth, " ")
+		if auth == "" {
+			err = &service_errors.ServiceError{EndUserMessage: service_errors.TokenRequired}
+		} else {
+			claimMap, err = tokenService.GetClaims(token[1])
+			if err != nil {
+				switch err.(*jwt.ValidationError).Errors {
+				case jwt.ValidationErrorExpired:
+					err = &service_errors.ServiceError{EndUserMessage: service_errors.TokenExpired}
+				default:
+					err = &service_errors.ServiceError{EndUserMessage: service_errors.TokenInvalid}
+				}
+			}
+		}
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, helper.GenerateBaseResponseWithError(
+				nil, false, helper.AuthError, err,
+			))
+			return
+		}
+
+		c.Set(constants.UserIdKey, claimMap[constants.UserIdKey])
+		c.Set(constants.FirstNameKey, claimMap[constants.FirstNameKey])
+		c.Set(constants.LastNameKey, claimMap[constants.LastNameKey])
+		c.Set(constants.UsernameKey, claimMap[constants.UsernameKey])
+		c.Set(constants.EmailKey, claimMap[constants.EmailKey])
+		c.Set(constants.ExpireTimeKey, claimMap[constants.ExpireTimeKey])
+
+		c.Next()
+	}
+}

api/validations/custom.go

@@ -0,0 +1,29 @@
+package validation
+
+import (
+	"errors"
+	"github.com/go-playground/validator/v10"
+)
+
+type ValidationError struct {
+	Property string `json:"property"`
+	Tag      string `json:"tag"`
+	Value    string `json:"value"`
+	Message  string `json:"message"`
+}
+
+func GetValidationErrors(err error) *[]ValidationError {
+	var validationErrors []ValidationError
+	var ve validator.ValidationErrors
+	if errors.As(err,&ve){
+		for _, err := range err.(validator.ValidationErrors){
+			var el ValidationError
+			el.Property = err.Field()
+			el.Tag = err.Tag()
+			el.Value = err.Param()
+			validationErrors = append(validationErrors, el)
+		}
+		return &validationErrors
+	}
+	return nil
+}

api/validations/passwod.go

@@ -0,0 +1,16 @@
+package validation
+
+import (
+	"github.com/Asrez/GoAPIBlog/common"
+	"github.com/go-playground/validator/v10"
+)
+
+func PasswordValidator(fld validator.FieldLevel) bool {
+	value, ok := fld.Field().Interface().(string)
+	if !ok {
+		fld.Param()
+		return false
+	}
+
+	return common.CheckPassword(value)
+}

cmd/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"github.com/Asrez/GoAPIBlog/api"
+	"github.com/Asrez/GoAPIBlog/config"
+	"github.com/Asrez/GoAPIBlog/data/db"
+	"github.com/Asrez/GoAPIBlog/data/migration"
+	"github.com/Asrez/GoAPIBlog/pkg/logging"
+)
+
+func main(){
+	cfg := config.GetConfig()
+	logger := logging.NewLogger(cfg)
+	err := db.InitDb(cfg)
+	defer db.CloseDb()
+
+	if err != nil {
+		logger.Fatal(logging.Postgres , logging.Startup , err.Error(),nil)
+	}
+
+	migration.Up()
+	api.InitServer()
+}

common/string.go

@@ -0,0 +1,144 @@
+package common
+
+import (
+	"math/rand"
+	"regexp"
+	"strings"
+	"unicode"
+	"github.com/Asrez/GoAPIBlog/config"
+)
+
+var (
+	lowerCharSet   = "abcdedfghijklmnopqrst"
+	upperCharSet   = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	specialCharSet = "!@#$%&*"
+	numberSet      = "0123456789"
+	allCharSet     = lowerCharSet + upperCharSet + specialCharSet + numberSet
+)
+
+var matchFirstCap = regexp.MustCompile("(.)([A-Z][a-z]+)")
+var matchAllCap = regexp.MustCompile("([a-z0-9])([A-Z])")
+
+func CheckPassword(password string) bool {
+	cfg := config.GetConfig()
+	if len(password) < cfg.Password.MinLength {
+		return false
+	}
+
+	if cfg.Password.IncludeChars && !HasLetter(password) {
+		return false
+	}
+
+	if cfg.Password.IncludeDigits && !HasDigits(password) {
+		return false
+	}
+
+	if cfg.Password.IncludeLowercase && !HasLower(password) {
+		return false
+	}
+
+	if cfg.Password.IncludeUppercase && !HasUpper(password) {
+		return false
+	}
+
+	return true
+}
+
+func GeneratePassword() string {
+	var password strings.Builder
+
+	cfg := config.GetConfig()
+	passwordLength := cfg.Password.MinLength + 2
+	minSpecialChar := 2
+	minNum := 3
+	if !cfg.Password.IncludeDigits {
+		minNum = 0
+	}
+
+	minUpperCase := 3
+	if !cfg.Password.IncludeUppercase {
+		minUpperCase = 0
+	}
+
+	minLowerCase := 3
+	if !cfg.Password.IncludeLowercase {
+		minLowerCase = 0
+	}
+
+	//Set special character
+	for i := 0; i < minSpecialChar; i++ {
+		random := rand.Intn(len(specialCharSet))
+		password.WriteString(string(specialCharSet[random]))
+	}
+
+	//Set numeric
+	for i := 0; i < minNum; i++ {
+		random := rand.Intn(len(numberSet))
+		password.WriteString(string(numberSet[random]))
+	}
+
+	//Set uppercase
+	for i := 0; i < minUpperCase; i++ {
+		random := rand.Intn(len(upperCharSet))
+		password.WriteString(string(upperCharSet[random]))
+	}
+
+	//Set lowercase
+	for i := 0; i < minLowerCase; i++ {
+		random := rand.Intn(len(lowerCharSet))
+		password.WriteString(string(lowerCharSet[random]))
+	}
+
+	remainingLength := passwordLength - minSpecialChar - minNum - minUpperCase
+	for i := 0; i < remainingLength; i++ {
+		random := rand.Intn(len(allCharSet))
+		password.WriteString(string(allCharSet[random]))
+	}
+	inRune := []rune(password.String())
+	rand.Shuffle(len(inRune), func(i, j int) {
+		inRune[i], inRune[j] = inRune[j], inRune[i]
+	})
+	return string(inRune)
+}
+
+func HasUpper(s string) bool {
+	for _, r := range s {
+		if unicode.IsUpper(r) && unicode.IsLetter(r) {
+			return true
+		}
+	}
+	return false
+}
+
+func HasLower(s string) bool {
+	for _, r := range s {
+		if unicode.IsLower(r) && unicode.IsLetter(r) {
+			return true
+		}
+	}
+	return false
+}
+
+func HasLetter(s string) bool {
+	for _, r := range s {
+		if unicode.IsLetter(r) {
+			return true
+		}
+	}
+	return false
+}
+
+func HasDigits(s string) bool {
+	for _, r := range s {
+		if unicode.IsDigit(r) {
+			return true
+		}
+	}
+	return false
+}
+
+func ToSnakeCase(str string) string {
+	snake := matchFirstCap.ReplaceAllString(str, "${1}_${2}")
+	snake = matchAllCap.ReplaceAllString(snake, "${1}_${2}")
+	return strings.ToLower(snake)
+}

config/config-development.yml

@@ -0,0 +1,36 @@
+server:
+  internalPort: 8000
+  externalPort: 8000
+  runMode: debug
+
+logger:
+  filePath: ../logs/
+  encoding: json
+  level: debug
+  logger: zap
+
+postgres :
+  host : localhost
+  port : 5432
+  user : postgres
+  password : sH1382@@
+  dbName : weather
+  sslMode : disable
+  maxIdleConns: 15
+  maxOpenConns: 100
+  connMaxLifetime: 5
+
+
+password:
+  includeChars: true
+  includeDigits: true
+  minLength: 6
+  maxLength: 64
+  includeUppercase: true
+  includeLowercase: true
+
+jwt:
+  secret: "mySecretKey"
+  refreshSecret: "mySecretKey"
+  accessTokenExpireDuration: 1440
+  refreshTokenExpireDuration: 60

config/config.go

@@ -0,0 +1,122 @@
+package config
+
+import (
+	"errors"
+	"log"
+	"os"
+	"time"
+	"github.com/spf13/viper"
+)
+
+type Config struct {
+	Server   ServerConfig
+	Postgres PostgresConfig
+	Password PasswordConfig
+	Logger   LoggerConfig
+	JWT      JWTConfig
+	API 	APIConfig
+}
+
+type ServerConfig struct {
+	InternalPort    string
+	ExternalPort    string
+	RunMode string
+}
+
+type LoggerConfig struct {
+	FilePath string
+	Encoding string
+	Level    string
+	Logger   string
+}
+
+type PostgresConfig struct {
+	Host            string
+	Port            string
+	User            string
+	Password        string
+	DbName          string
+	SSLMode         string
+	MaxIdleConns    int
+	MaxOpenConns    int
+	ConnMaxLifetime time.Duration
+}
+
+
+type PasswordConfig struct {
+	IncludeChars     bool
+	IncludeDigits    bool
+	MinLength        int
+	MaxLength        int
+	IncludeUppercase bool
+	IncludeLowercase bool
+}
+
+
+
+type JWTConfig struct {
+	AccessTokenExpireDuration  time.Duration
+	RefreshTokenExpireDuration time.Duration
+	Secret                     string
+	RefreshSecret              string
+}
+
+type APIConfig struct {
+	BaseUrl string
+	Token string
+	
+}
+
+func GetConfig() *Config {
+	cfgPath := getConfigPath(os.Getenv("APP_ENV"))
+	v, err := LoadConfig(cfgPath, "yml")
+	if err != nil {
+		log.Fatalf("Error in load config %v", err)
+	}
+
+	cfg, err := ParseConfig(v)
+	envPort := os.Getenv("PORT")
+	if envPort != ""{
+		cfg.Server.ExternalPort = envPort
+		log.Printf("Set external port from environment -> %s", cfg.Server.ExternalPort)
+	}else{
+		cfg.Server.ExternalPort = cfg.Server.InternalPort
+		log.Printf("Set external port from environment -> %s", cfg.Server.ExternalPort)
+	}
+	if err != nil {
+		log.Fatalf("Error in parse config %v", err)
+	}
+
+	return cfg
+}
+
+func ParseConfig(v *viper.Viper) (*Config, error) {
+	var cfg Config
+	err := v.Unmarshal(&cfg)
+	if err != nil {
+		log.Printf("Unable to parse config: %v", err)
+		return nil, err
+	}
+	return &cfg, nil
+}
+func LoadConfig(filename string, fileType string) (*viper.Viper, error) {
+	v := viper.New()
+	v.SetConfigType(fileType)
+	v.SetConfigName(filename)
+	v.AddConfigPath(".")
+	v.AutomaticEnv()
+
+	err := v.ReadInConfig()
+	if err != nil {
+		log.Printf("Unable to read config: %v", err)
+		if _, ok := err.(viper.ConfigFileNotFoundError); ok {
+			return nil, errors.New("config file not found")
+		}
+		return nil, err
+	}
+	return v, nil
+}
+
+func getConfigPath(env string) string {
+	return "../config/config-development"
+}

constants/constants.go

@@ -0,0 +1,11 @@
+package constants
+
+const (
+	AuthorizationHeaderKey string = "Authorization"
+	UserIdKey              string = "UserId"
+	FirstNameKey           string = "FirstName"
+	LastNameKey            string = "LastName"
+	UsernameKey            string = "Username"
+	EmailKey               string = "Email"
+	ExpireTimeKey          string = "Exp"
+)

data/db/postgres.go

@@ -0,0 +1,44 @@
+package db
+
+import (
+	"fmt"
+	"log"
+	"github.com/Asrez/GoAPIBlog/config"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+)
+
+var dbClient *gorm.DB
+
+func InitDb(cfg *config.Config) error {
+	var err error
+	cnn := fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=%s TimeZone=Asia/Tehran",
+		cfg.Postgres.Host, cfg.Postgres.Port, cfg.Postgres.User, cfg.Postgres.Password,
+		cfg.Postgres.DbName, cfg.Postgres.SSLMode)
+
+	dbClient, err = gorm.Open(postgres.Open(cnn), &gorm.Config{})
+	if err != nil {
+		return err
+	}
+
+	sqlDb, _ := dbClient.DB()
+	err = sqlDb.Ping()
+	if err != nil {
+		return err
+	}
+
+	sqlDb.SetMaxIdleConns(10)
+	sqlDb.SetMaxOpenConns(100)
+
+	log.Println("Db connection established")
+	return nil
+}
+
+func GetDb() *gorm.DB {
+	return dbClient
+}
+
+func CloseDb() {
+	con, _ := dbClient.DB()
+	con.Close()
+}

data/migration/init.go

@@ -0,0 +1,41 @@
+package migration
+
+import (
+	"github.com/Asrez/GoAPIBlog/config"
+	"github.com/Asrez/GoAPIBlog/data/db"
+	"github.com/Asrez/GoAPIBlog/pkg/logging"
+	"gorm.io/gorm"
+)
+
+
+var logger = logging.NewLogger(config.GetConfig())
+
+
+func Up(){
+	database := db.GetDb()
+	createTables(database)
+	logger.Info(logging.Postgres, logging.Migration, "UP", nil)
+
+}
+
+
+func addNewTable(database *gorm.DB, model interface{}, tables []interface{}) []interface{} {
+	if !database.Migrator().HasTable(model) {
+		tables = append(tables, model)
+	}
+	return tables
+}
+
+func createTables(database *gorm.DB){
+	tables := []interface{}{}
+
+	// tables = addNewTable(database , models.Categories{} , tables)
+
+
+	err := database.Migrator().CreateTable(tables...)
+	if err != nil {
+		logger.Error(logging.Postgres, logging.Migration, err.Error(), nil)
+	}
+	logger.Info(logging.Postgres, logging.Migration, "tables created", nil)
+
+}

data/models/base_models.go

@@ -0,0 +1,55 @@
+package models
+
+import (
+	"database/sql"
+	"time"
+	"gorm.io/gorm"
+)
+
+type BaseModel struct {
+	Id int `gorm:"primarykey"`
+
+	CreatedAt  time.Time    `gorm:"type:TIMESTAMP with time zone;not null"`
+	ModifiedAt sql.NullTime `gorm:"type:TIMESTAMP with time zone;null"`
+	DeletedAt  sql.NullTime `gorm:"type:TIMESTAMP with time zone;null"`
+
+	CreatedBy  int            `gorm:"not null"`
+	ModifiedBy *sql.NullInt64 `gorm:"null"`
+	DeletedBy  *sql.NullInt64 `gorm:"null"`
+}
+
+func (m *BaseModel) BeforeCreate(tx *gorm.DB) (err error) {
+	value := tx.Statement.Context.Value("UserId")
+	var userId = -1
+	// TODO: check userId type
+	if value != nil {
+		userId = int(value.(float64))
+	}
+	m.CreatedAt = time.Now().UTC()
+	m.CreatedBy = userId
+	return
+}
+
+func (m *BaseModel) BeforeUpdate(tx *gorm.DB) (err error) {
+	value := tx.Statement.Context.Value("UserId")
+	var userId = &sql.NullInt64{Valid: false}
+	// TODO: check userId type
+	if value != nil {
+		userId = &sql.NullInt64{Valid: true, Int64: int64(value.(float64))}
+	}
+	m.ModifiedAt = sql.NullTime{Time: time.Now().UTC(), Valid: true}
+	m.ModifiedBy = userId
+	return
+}
+
+func (m *BaseModel) BeforeDelete(tx *gorm.DB) (err error) {
+	value := tx.Statement.Context.Value("UserId")
+	var userId = &sql.NullInt64{Valid: false}
+	// TODO: check userId type
+	if value != nil {
+		userId = &sql.NullInt64{Valid: true, Int64: int64(value.(float64))}
+	}
+	m.DeletedAt = sql.NullTime{Time: time.Now().UTC(), Valid: true}
+	m.DeletedBy = userId
+	return
+}

data/models/models.go

@@ -0,0 +1,9 @@
+package models
+
+ 
+type (
+	BaseTable struct {
+		Id int `gorm:"primarykey"`
+		Name string `gorm:"not null"`
+	}
+)

go.mod

@@ -0,0 +1,63 @@
+module github.com/Asrez/GoAPIBlog
+
+go 1.20
+
+require github.com/gin-gonic/gin v1.9.1
+
+require (
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/jackc/pgx/v5 v5.3.1 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/magiconair/properties v1.8.7 // indirect
+	github.com/mattn/go-colorable v0.1.12 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/spf13/afero v1.9.5 // indirect
+	github.com/spf13/cast v1.5.1 // indirect
+	github.com/spf13/jwalterweatherman v1.1.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/subosito/gotenv v1.4.2 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
+	go.uber.org/multierr v1.8.0 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+)
+
+require (
+	github.com/bxcodec/faker/v3 v3.8.1
+	github.com/bytedance/sonic v1.9.1 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.14.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/golang-jwt/jwt v3.2.2+incompatible
+	github.com/google/uuid v1.3.0
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/rs/zerolog v1.29.1
+	github.com/spf13/viper v1.16.0
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	go.uber.org/zap v1.24.0
+	golang.org/x/arch v0.3.0 // indirect
+	golang.org/x/crypto v0.9.0 // indirect
+	golang.org/x/net v0.10.0 // indirect
+	golang.org/x/sys v0.8.0 // indirect
+	golang.org/x/text v0.9.0 // indirect
+	google.golang.org/protobuf v1.30.0 // indirect
+	gopkg.in/natefinch/lumberjack.v2 v2.2.1
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+	gorm.io/driver/postgres v1.5.2
+	gorm.io/gorm v1.25.2
+)

go.sum

@@ -0,0 +1,47 @@
+package logging
+
+
+type Category string
+type SubCategory string
+type ExtraKey string
+
+
+const (
+	General Category = "General"
+	Internal Category = "Internal"
+	Postgres Category = "Postgres"
+	Redis Category = "Redis"
+	Validation Category = "Validation"
+	RequestResponse Category = "RequestResponse"
+)
+const (
+	// General
+	Startup         SubCategory = "Startup"
+	ExternalService SubCategory = "ExternalService"
+
+	// Postgres
+	Migration SubCategory = "Migration"
+	Select    SubCategory = "Select"
+	Rollback  SubCategory = "Rollback"
+	Update    SubCategory = "Update"
+	Delete    SubCategory = "Delete"
+	Insert    SubCategory = "Insert"
+
+	// Internal
+	Api                 SubCategory = "Api"
+)
+
+const (
+	AppName      ExtraKey = "AppName"
+	LoggerName   ExtraKey = "Logger"
+	ClientIp     ExtraKey = "ClientIp"
+	HostIp       ExtraKey = "HostIp"
+	Method       ExtraKey = "Method"
+	StatusCode   ExtraKey = "StatusCode"
+	BodySize     ExtraKey = "BodySize"
+	Path         ExtraKey = "Path"
+	Latency      ExtraKey = "Latency"
+	RequestBody  ExtraKey = "RequestBody"
+	ResponseBody ExtraKey = "ResponseBody"
+	ErrorMessage ExtraKey = "ErrorMessage"
+)

pkg/logging/category.go

@@ -0,0 +1,22 @@
+package logging
+
+func logParamsToZapParams(keys map[ExtraKey]interface{}) []interface{} {
+	params := make([]interface{}, 0, len(keys))
+
+	for k, v := range keys {
+		params = append(params, string(k))
+		params = append(params, v)
+	}
+
+	return params
+}
+
+func logParamsToZeroParams(keys map[ExtraKey]interface{}) map[string]interface{} {
+	params := map[string]interface{}{}
+
+	for k, v := range keys {
+		params[string(k)] = v
+	}
+
+	return params
+}

pkg/logging/log_helpers.go

@@ -0,0 +1,31 @@
+package logging
+
+import "github.com/Asrez/GoAPIBlog/config"
+
+type Logger interface {
+	Init()
+
+	Debug(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{})
+	Debugf(template string, args ...interface{})
+
+	Info(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{})
+	Infof(template string, args ...interface{})
+
+	Warn(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{})
+	Warnf(template string, args ...interface{})
+
+	Error(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{})
+	Errorf(template string, args ...interface{})
+
+	Fatal(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{})
+	Fatalf(template string, args ...interface{})
+}
+
+func NewLogger(cfg *config.Config) Logger {
+	if cfg.Logger.Logger == "zap" {
+		return newZapLogger(cfg)
+	} else if cfg.Logger.Logger == "zerolog" {
+		return newZeroLogger(cfg)
+	}
+	panic("logger not supported")
+}

pkg/logging/logger.go

@@ -0,0 +1,128 @@
+package logging
+
+import (
+	"github.com/Asrez/GoAPIBlog/config"
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"gopkg.in/natefinch/lumberjack.v2"
+	"fmt"
+	"github.com/google/uuid"
+	"time"
+)
+
+var zapSinLogger *zap.SugaredLogger
+
+type zapLogger struct {
+	cfg    *config.Config
+	logger *zap.SugaredLogger
+}
+
+var zapLogLevelMapping = map[string]zapcore.Level{
+	"debug": zapcore.DebugLevel,
+	"info":  zapcore.InfoLevel,
+	"warn":  zapcore.WarnLevel,
+	"error": zapcore.ErrorLevel,
+	"fatal": zapcore.FatalLevel,
+}
+
+func newZapLogger(cfg *config.Config) *zapLogger {
+	logger := &zapLogger{cfg: cfg}
+	logger.Init()
+	return logger
+}
+
+func (l *zapLogger) getLogLevel() zapcore.Level {
+	level, exists := zapLogLevelMapping[l.cfg.Logger.Level]
+	if !exists {
+		return zapcore.DebugLevel
+	}
+	return level
+}
+
+func (l *zapLogger) Init() {
+	
+		fileName := fmt.Sprintf("%s%s-%s.%s",l.cfg.Logger.FilePath,time.Now().Format("2006-01-02"),uuid.New(),"log")
+		w := zapcore.AddSync(&lumberjack.Logger{
+			Filename:   fileName,
+			MaxSize:    1,
+			MaxAge:     20,
+			LocalTime:  true,
+			MaxBackups: 5,
+			Compress:   true,
+		})
+
+		config := zap.NewProductionEncoderConfig()
+		config.EncodeTime = zapcore.ISO8601TimeEncoder
+
+		core := zapcore.NewCore(
+			zapcore.NewJSONEncoder(config),
+			w,
+			l.getLogLevel(),
+		)
+
+		logger := zap.New(core, zap.AddCaller(),
+			zap.AddCallerSkip(1),
+			zap.AddStacktrace(zapcore.ErrorLevel),
+		).Sugar()
+
+		zapSinLogger = logger.With("AppName", "MyApp", "LoggerName", "Zaplog")
+
+
+	l.logger = zapSinLogger
+}
+
+func (l *zapLogger) Debug(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{}) {
+	params := prepareLogInfo(cat, sub, extra)
+
+	l.logger.Debugw(msg, params...)
+}
+
+func (l *zapLogger) Debugf(template string, args ...interface{}) {
+	l.logger.Debugf(template, args)
+}
+
+func (l *zapLogger) Info(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{}) {
+	params := prepareLogInfo(cat, sub, extra)
+	l.logger.Infow(msg, params...)
+}
+
+func (l *zapLogger) Infof(template string, args ...interface{}) {
+	l.logger.Infof(template, args)
+}
+
+func (l *zapLogger) Warn(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{}) {
+	params := prepareLogInfo(cat, sub, extra)
+	l.logger.Warnw(msg, params...)
+}
+
+func (l *zapLogger) Warnf(template string, args ...interface{}) {
+	l.logger.Warnf(template, args)
+}
+
+func (l *zapLogger) Error(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{}) {
+	params := prepareLogInfo(cat, sub, extra)
+	l.logger.Errorw(msg, params...)
+}
+
+func (l *zapLogger) Errorf(template string, args ...interface{}) {
+	l.logger.Errorf(template, args)
+}
+
+func (l *zapLogger) Fatal(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{}) {
+	params := prepareLogInfo(cat, sub, extra)
+	l.logger.Fatalw(msg, params...)
+}
+
+func (l *zapLogger) Fatalf(template string, args ...interface{}) {
+	l.logger.Fatalf(template, args)
+}
+
+func prepareLogInfo(cat Category, sub SubCategory, extra map[ExtraKey]interface{}) []interface{} {
+	if extra == nil {
+		extra = make(map[ExtraKey]interface{})
+	}
+	extra["Category"] = cat
+	extra["SubCategory"] = sub
+
+	return logParamsToZapParams(extra)
+}

pkg/logging/zap_logger.go

@@ -0,0 +1,145 @@
+package logging
+
+import (
+	"fmt"
+	"os"
+	"sync"
+	"time"
+	"github.com/google/uuid"
+	"github.com/Asrez/GoAPIBlog/config"
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/pkgerrors"
+)
+
+var once sync.Once
+var zeroSinLogger *zerolog.Logger
+
+type zeroLogger struct {
+	cfg    *config.Config
+	logger *zerolog.Logger
+}
+
+var zeroLogLevelMapping = map[string]zerolog.Level{
+	"debug": zerolog.DebugLevel,
+	"info":  zerolog.InfoLevel,
+	"warn":  zerolog.WarnLevel,
+	"error": zerolog.ErrorLevel,
+	"fatal": zerolog.FatalLevel,
+}
+
+func newZeroLogger(cfg *config.Config) *zeroLogger {
+	logger := &zeroLogger{cfg: cfg}
+	logger.Init()
+	return logger
+}
+
+func (l *zeroLogger) getLogLevel() zerolog.Level {
+	level, exists := zeroLogLevelMapping[l.cfg.Logger.Level]
+	if !exists {
+		return zerolog.DebugLevel
+	}
+	return level
+}
+
+func (l *zeroLogger) Init() {
+	once.Do(func() {
+
+		zerolog.ErrorStackMarshaler = pkgerrors.MarshalStack
+		fileName := fmt.Sprintf("%s%s-%s.%s",l.cfg.Logger.FilePath,time.Now().Format("2006-01-02"),uuid.New(),"log")
+
+		file, err := os.OpenFile(fileName, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0666)
+		if err != nil {
+			panic("could not open log file")
+		}
+
+		var logger = zerolog.New(file).
+			With().
+			Timestamp().
+			Str("AppName", "MyApp").
+			Str("LoggerName", "Zerolog").
+			Logger()
+		zerolog.SetGlobalLevel(l.getLogLevel())
+		zeroSinLogger = &logger
+	})
+	l.logger = zeroSinLogger
+}
+
+func (l *zeroLogger) Debug(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{}) {
+
+	l.logger.
+		Debug().
+		Str("Category", string(cat)).
+		Str("SubCategory", string(sub)).
+		Fields(logParamsToZeroParams(extra)).
+		Msg(msg)
+}
+
+func (l *zeroLogger) Debugf(template string, args ...interface{}) {
+	l.logger.
+		Debug().
+		Msgf(template, args...)
+}
+
+func (l *zeroLogger) Info(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{}) {
+
+	l.logger.
+		Info().
+		Str("Category", string(cat)).
+		Str("SubCategory", string(sub)).
+		Fields(logParamsToZeroParams(extra)).
+		Msg(msg)
+}
+
+func (l *zeroLogger) Infof(template string, args ...interface{}) {
+	l.logger.
+		Info().
+		Msgf(template, args...)
+}
+
+func (l *zeroLogger) Warn(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{}) {
+
+	l.logger.
+		Warn().
+		Str("Category", string(cat)).
+		Str("SubCategory", string(sub)).
+		Fields(logParamsToZeroParams(extra)).
+		Msg(msg)
+}
+
+func (l *zeroLogger) Warnf(template string, args ...interface{}) {
+	l.logger.
+		Warn().
+		Msgf(template, args...)
+}
+
+func (l *zeroLogger) Error(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{}) {
+
+	l.logger.
+		Error().
+		Str("Category", string(cat)).
+		Str("SubCategory", string(sub)).
+		Fields(logParamsToZeroParams(extra)).
+		Msg(msg)
+}
+
+func (l *zeroLogger) Errorf(template string, args ...interface{}) {
+	l.logger.
+		Error().
+		Msgf(template, args...)
+}
+
+func (l *zeroLogger) Fatal(cat Category, sub SubCategory, msg string, extra map[ExtraKey]interface{}) {
+
+	l.logger.
+		Fatal().
+		Str("Category", string(cat)).
+		Str("SubCategory", string(sub)).
+		Fields(logParamsToZeroParams(extra)).
+		Msg(msg)
+}
+
+func (l *zeroLogger) Fatalf(template string, args ...interface{}) {
+	l.logger.
+		Fatal().
+		Msgf(template, args...)
+}

pkg/logging/zero_logger.go

@@ -0,0 +1,23 @@
+package service_errors
+
+const (
+	// Token
+	UnExpectedError = "Expected error"
+	ClaimsNotFound  = "Claims not found"
+	TokenRequired   = "token required"
+	TokenExpired    = "token expired"
+	TokenInvalid    = "token invalid"
+
+	// OTP
+	OptExists   = "Otp exists"
+	OtpUsed     = "Otp used"
+	OtpNotValid = "Otp invalid"
+
+	// User
+	EmailExists    = "Email exists"
+	UsernameExists = "Username exists"
+	PermissionDenied = "Permission denied"
+
+	// DB
+	RecordNotFound = "record not found"
+)

pkg/service_errors/error_code.go

@@ -0,0 +1,11 @@
+package service_errors
+
+type ServiceError struct {
+	EndUserMessage   string `json:"endUserMessage"`
+	TechnicalMessage string `json:"technicalMessage"`
+	Err              error
+}
+
+func (s *ServiceError) Error() string {
+	return s.EndUserMessage
+}

pkg/service_errors/service_error.go

@@ -0,0 +1,105 @@
+package services
+
+import (
+	"time"
+
+	"github.com/Asrez/GoAPIBlog/api/dto"
+	"github.com/Asrez/GoAPIBlog/config"
+	"github.com/Asrez/GoAPIBlog/constants"
+	"github.com/Asrez/GoAPIBlog/pkg/logging"
+	"github.com/Asrez/GoAPIBlog/pkg/service_errors"
+	"github.com/golang-jwt/jwt"
+)
+
+type TokenService struct {
+	logger logging.Logger
+	cfg    *config.Config
+}
+
+type tokenDto struct {
+	UserId       int
+	FirstName    string
+	LastName     string
+	Username     string
+	MobileNumber string
+	Email        string
+	Roles        []string
+}
+
+func NewTokenService(cfg *config.Config) *TokenService {
+	logger := logging.NewLogger(cfg)
+	return &TokenService{
+		cfg:    cfg,
+		logger: logger,
+	}
+}
+
+func (s *TokenService) GenerateToken(token *tokenDto) (*dto.TokenDetail, error) {
+	td := &dto.TokenDetail{}
+	td.AccessTokenExpireTime = time.Now().Add(s.cfg.JWT.AccessTokenExpireDuration * time.Minute).Unix()
+	td.RefreshTokenExpireTime = time.Now().Add(s.cfg.JWT.RefreshTokenExpireDuration * time.Minute).Unix()
+
+	atc := jwt.MapClaims{}
+
+	atc[constants.UserIdKey] = token.UserId
+	atc[constants.FirstNameKey] = token.FirstName
+	atc[constants.LastNameKey] = token.LastName
+	atc[constants.UsernameKey] = token.Username
+	atc[constants.EmailKey] = token.Email
+	atc[constants.ExpireTimeKey] = td.AccessTokenExpireTime
+
+	at := jwt.NewWithClaims(jwt.SigningMethodHS256, atc)
+
+	var err error
+	td.AccessToken, err = at.SignedString([]byte(s.cfg.JWT.Secret))
+
+	if err != nil {
+		return nil, err
+	}
+
+	rtc := jwt.MapClaims{}
+
+	rtc[constants.UserIdKey] = token.UserId
+	rtc[constants.ExpireTimeKey] = td.RefreshTokenExpireTime
+
+	rt := jwt.NewWithClaims(jwt.SigningMethodHS256, rtc)
+
+	td.RefreshToken, err = rt.SignedString([]byte(s.cfg.JWT.RefreshSecret))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return td, nil
+}
+
+func (s *TokenService) VerifyToken(token string) (*jwt.Token, error) {
+	at, err := jwt.Parse(token, func(token *jwt.Token) (interface{}, error) {
+		_, ok := token.Method.(*jwt.SigningMethodHMAC)
+		if !ok {
+			return nil, &service_errors.ServiceError{EndUserMessage: service_errors.UnExpectedError}
+		}
+		return []byte(s.cfg.JWT.Secret), nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return at, nil
+}
+
+func (s *TokenService) GetClaims(token string) (claimMap map[string]interface{}, err error) {
+	claimMap = map[string]interface{}{}
+
+	verifyToken, err := s.VerifyToken(token)
+	if err != nil {
+		return nil, err
+	}
+	claims, ok := verifyToken.Claims.(jwt.MapClaims)
+	if ok && verifyToken.Valid {
+		for k, v := range claims {
+			claimMap[k] = v
+		}
+		return claimMap, nil
+	}
+	return nil, &service_errors.ServiceError{EndUserMessage: service_errors.ClaimsNotFound}
+}

services/token_servies.go

@@ -0,0 +1,122 @@
+package services
+
+import (
+	// "github.com/Asrez/GoAPIBlog/api/dto"
+	"github.com/Asrez/GoAPIBlog/config"
+	"github.com/Asrez/GoAPIBlog/pkg/logging"
+	"github.com/Asrez/GoAPIBlog/data/db"
+	"gorm.io/gorm"
+)
+
+type UserService struct {
+	logger       logging.Logger
+	cfg          *config.Config
+	tokenService *TokenService
+	database     *gorm.DB
+}
+
+func NewUserService(cfg *config.Config) *UserService {
+	database := db.GetDb()
+	logger := logging.NewLogger(cfg)
+	return &UserService{
+		cfg:          cfg,
+		database:     database,
+		logger:       logger,
+		tokenService: NewTokenService(cfg),
+	}
+}
+
+// // Login by username
+// func (s *UserService) LoginByUsername(req *dto.LoginByUsernameRequest) (*dto.TokenDetail, error) {
+// 	var user models.User
+// 	err := s.database.
+// 		Model(&models.User{}).
+// 		Where("username = ?", req.Username).
+// 		Find(&user).Error
+// 	if err != nil {
+// 		return nil, err
+// 	}
+// 	err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(req.Password))
+// 	if err != nil {
+// 		return nil, err
+// 	}
+// 	tdto := tokenDto{UserId: user.Id, FirstName: user.FirstName, LastName: user.LastName,
+// 		Email: user.Email, MobileNumber: user.MobileNumber}
+
+// 	token, err := s.tokenService.GenerateToken(&tdto)
+// 	if err != nil {
+// 		return nil, err
+// 	}
+// 	return token, nil
+
+// }
+
+// // Register by username
+// func (s *UserService) RegisterByUsername(req *dto.RegisterUserByUsernameRequest) error {
+// 	u := models.User{Username: req.Username, FirstName: req.FirstName, LastName: req.LastName, Email: req.Email}
+
+// 	exists, err := s.existsByEmail(req.Email)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	if exists {
+// 		return &service_errors.ServiceError{EndUserMessage: service_errors.EmailExists}
+// 	}
+// 	exists, err = s.existsByUsername(req.Username)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	if exists {
+// 		return &service_errors.ServiceError{EndUserMessage: service_errors.UsernameExists}
+// 	}
+
+// 	bp := []byte(req.Password)
+// 	hp, err := bcrypt.GenerateFromPassword(bp, bcrypt.DefaultCost)
+// 	if err != nil {
+// 		s.logger.Error(logging.General, logging.HashPassword, err.Error(), nil)
+// 		return err
+// 	}
+// 	u.Password = string(hp)
+// 	if err != nil {
+// 		s.logger.Error(logging.Postgres, logging.DefaultRoleNotFound, err.Error(), nil)
+// 		return err
+// 	}
+
+// 	tx := s.database.Begin()
+// 	err = tx.Create(&u).Error
+// 	if err != nil {
+// 		tx.Rollback()
+// 		s.logger.Error(logging.Postgres, logging.Rollback, err.Error(), nil)
+// 		return err
+// 	}
+// 	tx.Commit()
+// 	return nil
+
+// }
+
+
+// func (s *UserService) existsByEmail(email string) (bool, error) {
+// 	var exists bool
+// 	if err := s.database.Model(&models.User{}).
+// 		Select("count(*) > 0").
+// 		Where("email = ?", email).
+// 		Find(&exists).
+// 		Error; err != nil {
+// 		s.logger.Error(logging.Postgres, logging.Select, err.Error(), nil)
+// 		return false, err
+// 	}
+// 	return exists, nil
+// }
+
+// func (s *UserService) existsByUsername(username string) (bool, error) {
+// 	var exists bool
+// 	if err := s.database.Model(&models.User{}).
+// 		Select("count(*) > 0").
+// 		Where("username = ?", username).
+// 		Find(&exists).
+// 		Error; err != nil {
+// 		s.logger.Error(logging.Postgres, logging.Select, err.Error(), nil)
+// 		return false, err
+// 	}
+// 	return exists, nil
+// }