Add PostgreSQL as a supported database

db/database.go

@@ -6,6 +6,7 @@ import (
 	"github.com/fossyy/filekeeper/logger"
 	"github.com/fossyy/filekeeper/types/models"
 	"gorm.io/driver/mysql"
+	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 	gormLogger "gorm.io/gorm/logger"
 	"os"
@@ -13,12 +14,15 @@ import (
 )
 
 var log *logger.AggregatedLogger
-var DB *gorm.DB
 
 type mySQLdb struct {
 	*gorm.DB
 }
 
+type postgresDB struct {
+	*gorm.DB
+}
+
 type Database interface {
 	IsUserRegistered(email string, username string) bool
 
@@ -40,7 +44,7 @@ type Database interface {
 func NewMYSQLdb(username, password, host, port, dbName string) Database {
 	var err error
 	connection := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", username, password, host, port, dbName)
-	DB, err = gorm.Open(mysql.New(mysql.Config{
+	DB, err := gorm.Open(mysql.New(mysql.Config{
 		DSN:                       connection,
 		DefaultStringSize:         256,
 		DisableDatetimePrecision:  true,
@@ -75,6 +79,39 @@ func NewMYSQLdb(username, password, host, port, dbName string) Database {
 	return &mySQLdb{DB}
 }
 
+func NewPostgresDB(username, password, host, port, dbName string) Database {
+	var err error
+	connection := fmt.Sprintf("host=%s user=%s password=%s dbname=%s port=%s sslmode=%s TimeZone=Asia/Jakarta", host, username, password, dbName, port, "disable")
+	DB, err := gorm.Open(postgres.New(postgres.Config{
+		DSN: connection,
+	}), &gorm.Config{
+		Logger: gormLogger.Default.LogMode(gormLogger.Silent),
+	})
+
+	if err != nil {
+		panic("failed to connect database: " + err.Error())
+	}
+
+	file, err := os.ReadFile("schema.sql")
+	if err != nil {
+		panic("Error opening file: " + err.Error())
+	}
+
+	queries := strings.Split(string(file), ";")
+	for _, query := range queries {
+		query = strings.TrimSpace(query)
+		if query == "" {
+			continue
+		}
+		err := DB.Exec(query).Error
+		if err != nil {
+			panic("Error executing query: " + err.Error())
+		}
+	}
+
+	return &postgresDB{DB}
+}
+
 func (db *mySQLdb) IsUserRegistered(email string, username string) bool {
 	var data models.User
 	err := db.DB.Table("users").Where("email = ? OR username = ?", email, username).First(&data).Error
@@ -166,13 +203,116 @@ func (db *mySQLdb) GetUploadInfo(fileID string) (*models.FilesUploaded, error) {
 }
 
 func (db *mySQLdb) UpdateUpdateIndex(index int, fileID string) {
-	db.DB.Table("files_uploadeds").Where("file_id = ?", fileID).Updates(map[string]interface{}{
+	db.DB.Table("files_uploadeds").Where("file_id = $1", fileID).Updates(map[string]interface{}{
 		"Uploaded": index,
 	})
 }
 
 func (db *mySQLdb) FinalizeFileUpload(fileID string) {
-	db.DB.Table("files_uploadeds").Where("file_id = ?", fileID).Updates(map[string]interface{}{
+	db.DB.Table("files_uploadeds").Where("file_id = $1", fileID).Updates(map[string]interface{}{
+		"Done": true,
+	})
+}
+
+// POSTGRES FUNCTION
+func (db *postgresDB) IsUserRegistered(email string, username string) bool {
+	var data models.User
+	err := db.DB.Table("users").Where("email = $1 OR username = $2", email, username).First(&data).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return false
+		}
+		return true
+	}
+	return true
+}
+
+func (db *postgresDB) CreateUser(user *models.User) error {
+	err := db.DB.Create(user).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *postgresDB) GetUser(email string) (*models.User, error) {
+	var user models.User
+	err := db.DB.Table("users").Where("email = $1", email).First(&user).Error
+	if err != nil {
+		return nil, err
+	}
+	return &user, nil
+}
+
+func (db *postgresDB) UpdateUserPassword(email string, password string) error {
+	err := db.DB.Table("users").Where("email = $1", email).Update("password", password).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *postgresDB) CreateFile(file *models.File) error {
+	err := db.DB.Create(file).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *postgresDB) GetFile(fileID string) (*models.File, error) {
+	var file models.File
+	err := db.DB.Table("files").Where("id = $1", fileID).First(&file).Error
+	if err != nil {
+		return nil, err
+	}
+	return &file, nil
+}
+
+func (db *postgresDB) GetUserFile(name string, ownerID string) (*models.File, error) {
+	var file models.File
+	err := db.DB.Table("files").Where("name = $1 AND owner_id = $2", name, ownerID).First(&file).Error
+	if err != nil {
+		return nil, err
+	}
+	return &file, nil
+}
+
+func (db *postgresDB) GetFiles(ownerID string) ([]*models.File, error) {
+	var files []*models.File
+	err := db.DB.Table("files").Where("owner_id = $1", ownerID).Find(&files).Error
+	if err != nil {
+		return nil, err
+	}
+	return files, err
+}
+
+// CreateUploadInfo It's not optimal, but it's okay for now. Consider implementing caching instead of pushing all updates to the database for better performance in the future.
+func (db *postgresDB) CreateUploadInfo(info models.FilesUploaded) error {
+	err := db.DB.Create(info).Error
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (db *postgresDB) GetUploadInfo(fileID string) (*models.FilesUploaded, error) {
+	var info models.FilesUploaded
+	err := db.DB.Table("files_uploadeds").Where("file_id = $1", fileID).First(&info).Error
+	if err != nil {
+		return nil, err
+	}
+	return &info, nil
+}
+
+func (db *postgresDB) UpdateUpdateIndex(index int, fileID string) {
+	db.DB.Table("files_uploadeds").Where("file_id = $1", fileID).Updates(map[string]interface{}{
+		"Uploaded": index,
+	})
+}
+
+func (db *postgresDB) FinalizeFileUpload(fileID string) {
+	db.DB.Table("files_uploadeds").Where("file_id = $1", fileID).Updates(map[string]interface{}{
 		"Done": true,
 	})
 }