140 lines
3.5 KiB
Go
140 lines
3.5 KiB
Go
package utils
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/json"
|
|
"errors"
|
|
"jannex/admin-dashboard-backend/modules/database"
|
|
"jannex/admin-dashboard-backend/modules/structs"
|
|
"math"
|
|
"math/big"
|
|
"time"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
"github.com/rs/zerolog/log"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func GetXAuhorizationHeader(c *fiber.Ctx) string {
|
|
return c.GetReqHeaders()[HeaderXAuthorization]
|
|
}
|
|
|
|
func GetXApiKeyHeader(c *fiber.Ctx) string {
|
|
return c.GetReqHeaders()[HeaderXApiKey]
|
|
}
|
|
|
|
func MarshalJson(v any) string {
|
|
json, err := json.Marshal(v)
|
|
|
|
if err != nil {
|
|
log.Error().Msgf("Failed to marshal json %s", err)
|
|
return ""
|
|
}
|
|
|
|
return string(json)
|
|
}
|
|
|
|
func GetSessionExpiresAtTime() time.Time {
|
|
return time.Now().Add(time.Second * SessionExpiresAtTime)
|
|
}
|
|
|
|
func IsPasswordLengthValid(password string) bool {
|
|
lenPassword := len(password)
|
|
|
|
if lenPassword < MinPassword || lenPassword > MaxPassword {
|
|
log.Error().Msg("Password length not valid")
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func GenerateSession() (string, error) {
|
|
var letters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
|
|
|
|
r := make([]byte, 36)
|
|
|
|
for i := 0; i < 36; i++ {
|
|
num, err := rand.Int(rand.Reader, big.NewInt(int64(len(letters))))
|
|
|
|
if err != nil {
|
|
log.Error().Msgf("Failed to session: %v", err)
|
|
return "", err
|
|
}
|
|
|
|
if i == 8 || i == 13 || i == 18 || i == 23 {
|
|
r[i] = 45
|
|
} else {
|
|
r[i] = letters[num.Int64()]
|
|
}
|
|
}
|
|
|
|
return string(r), nil
|
|
}
|
|
|
|
func ParamsParserHelper(c *fiber.Ctx, params interface{}) error {
|
|
if err := c.ParamsParser(params); err != nil {
|
|
log.Error().Msgf("Failed to parse params, err: %s", err.Error())
|
|
return errors.New("Failed to parse params")
|
|
}
|
|
|
|
if errValidation := ValidateStruct(params); errValidation != nil {
|
|
log.Error().Msgf("Failed to validate params, err: %v", errValidation)
|
|
return errors.New("Failed to validate params")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func BodyParserHelper(c *fiber.Ctx, body interface{}) error {
|
|
if err := c.BodyParser(body); err != nil {
|
|
log.Error().Msgf("Failed to parse body, err: %s", err.Error())
|
|
return errors.New("Failed to parse body")
|
|
}
|
|
|
|
if errValidation := ValidateStruct(body); errValidation != nil {
|
|
log.Error().Msgf("Failed to validate body, err: %v", errValidation)
|
|
return errors.New("Failed to validate body")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func QueryParserHelper(c *fiber.Ctx, query interface{}) error {
|
|
if err := c.QueryParser(query); err != nil {
|
|
log.Error().Msgf("Failed to parse query, err: %s", err.Error())
|
|
return errors.New("Failed to parse query")
|
|
}
|
|
|
|
if errValidation := ValidateStruct(query); errValidation != nil {
|
|
log.Error().Msgf("Failed to validate query, err: %v", errValidation)
|
|
return errors.New("Failed to validate query")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetTotalPages returns total pages for pagination
|
|
// Example whereQuery = "stock_item_id = ?" and args = stockItemId is Where("stock_item_id = ?", stockItemId)
|
|
func GetTotalPages(paginationLimit int, any interface{}, whereQuery interface{}, args ...interface{}) int {
|
|
var totalPages int64
|
|
|
|
database.DB.Model(any).
|
|
Where(whereQuery, args).
|
|
Count(&totalPages)
|
|
|
|
return int(math.Ceil(float64(totalPages) / float64(paginationLimit)))
|
|
}
|
|
|
|
func GetPageOffset(page int, paginationLimit int) int {
|
|
return (page - 1) * paginationLimit
|
|
}
|
|
|
|
func DbPageQuery(query structs.PageQuery, paginationLimit int, result any, orderBy, whereQuery interface{}, args ...interface{}) *gorm.DB {
|
|
return database.DB.Limit(paginationLimit).
|
|
Offset(GetPageOffset(query.Page, paginationLimit)).
|
|
Where(whereQuery, args).
|
|
Order(orderBy).
|
|
Find(result)
|
|
}
|