ss.txt

// ? gorm unique

	// Register the custom validator
	// if err := validate.RegisterValidation("unique", uniqueValidator); err != nil {
	// 	panic(err)
	// }

    func uniqueValidator(fl validator.FieldLevel) bool {
	// db := fl.Parent().Addr().Interface().(*gorm.DB)
	// db := D.DB()
	db := dbEnv.GetDatabaseUrl()
	field := fl.FieldName()

	// Get the struct's value and use reflection to extract the field's value
	var s reflect.Value = fl.Parent()
	val := reflect.Indirect(s).FieldByName(field).String()

	var count int64
	db.Model(fl.Parent()).Where(fmt.Sprintf("%s = ?", field), val).Count(&count)

	return count == 0
}
// dev.go 
func GormG(c *fiber.Ctx) error {
	type pashm struct {
		Name string `json:"name" validate:"unique"`
	}
	payload := new(pashm)
	// parse payload
	if err := c.BodyParser(payload); err != nil {
		U.ResErr(c, err.Error())
	}
	if errs := U.Validate(payload); errs != nil {
		return c.Status(400).JSON(fiber.Map{"errors": errs})
	}
	return c.SendString("no error")
}
// db.go
// type DBConfig struct {
	// 	Host     string
	// 	Port     string
	// 	Username string
	// 	Password string
	// 	Server   string
	// 	Name     string
	// }
	// dbConfig := config.GetDBConfig()
	// dbConfig := DBConfig{}
	// dsn := fmt.Sprintf("postgres://%s:%s@%s:%s/%s", dbConfig.Username, dbConfig.Password, dbConfig.Server, dbConfig.Port, dbConfig.Name)
	
	func AdvancedUploadImage(c *fiber.Ctx) error {
	// Create a new file to store the uploaded data
	// dst, err := os.Create("uploaded_file.txt")
	// if err != nil {
	// 	return err
	// }
	// defer dst.Close()

	// // Get the request body stream
	// reader := c.Request().BodyStream()

	// // Read 1MiB at a time
	// buffer := make([]byte, 0, 1024*1024)
	// for {
	// 	length, err := io.ReadFull(reader, buffer[:cap(buffer)])
	// 	// Cap the buffer based on the actual length read
	// 	buffer = buffer[:length]
	// 	if err != nil {
	// 		// When the error is EOF, there are no longer any bytes to read
	// 		// meaning the request is completed
	// 		if err == io.EOF {
	// 			break
	// 		}

	// 		// If the error is an unexpected EOF, the requested size to read
	// 		// was larger than what was available. This is not an issue for
	// 		// as long as the length returned above is used, or the buffer
	// 		// is capped as it is above. Any error that is not an unexpected
	// 		// EOF is an actual error, which we handle accordingly
	// 		if err != io.ErrUnexpectedEOF {
	// 			return err
	// 		}
	// 	}

	// 	// Write the buffered data to the destination file
	// 	_, err = dst.Write(buffer)
	// 	if err != nil {
	// 		return err
	// 	}
	// }
	return c.SendString("DONE")
	// return c.JSON(fiber.Map{"data": fiber.Map{"img": c.BaseURL() + "/public/uploads/" + newFileName}})
}