add new relational table requests

dbHandler.go

@@ -1,8 +1,9 @@
-package AccessHandler
+package dbHandler
 
 import (
 	"errors"
 	"fmt"
+	"os"
 	"path/filepath"
 	"reflect"
 	"strings"
@@ -57,12 +58,30 @@ func NewDBHandler(name, path string, logger *logging.Logger) (dH *DBHandler, err
 	if filepath.Ext(name) == "" {
 		name += ".db"
 	}
+
+	if path != "" {
+		if _, err := os.Stat(path); err != nil {
+			if err := os.MkdirAll(path, 0666); err != err {
+				return nil, err
+			}
+		}
+	}
+
 	dbPath := filepath.Join(path, name)
 	logger.Debug("NewDBHandler", "open database "+dbPath)
 	dH.db, err = gorm.Open(sqlite.Open(dbPath), &gorm.Config{})
 	return
 }
 
+// close DB
+func (dH *DBHandler) Close() error {
+	sqlDB, err := dH.db.DB()
+	if err != nil {
+		return err
+	}
+	return sqlDB.Close()
+}
+
 // addNewTable
 //
 // Description:
@@ -110,14 +129,21 @@ func (dH *DBHandler) AddNewColum(model any) error {
 //
 // Returns:
 //   - error: Any query error or “not found” message.
-func (dH *DBHandler) GetById(model any, id uint) error {
+func (dH *DBHandler) GetById(model any, id uint, relations ...string) (err error) {
 	dH.logger.Debug("getById", "find id "+fmt.Sprint(id))
 
-	if id == 0 {
-		return dH.db.Find(model).Error
+	query := dH.db
+
+	for _, relation := range relations {
+		query = query.Preload(relation)
 	}
 
-	err := dH.db.First(model, id).Error
+	if id == 0 {
+		return query.Find(model).Error
+	}
+
+	err = query.First(model, id).Error
+
 	if errors.Is(err, gorm.ErrRecordNotFound) {
 		return fmt.Errorf("no record found for id: %v", id)
 	} else if err != nil {
@@ -144,15 +170,20 @@ func (dH *DBHandler) GetById(model any, id uint) error {
 //
 // Returns:
 //   - error: Any database query error.
-func (dH *DBHandler) GetByKey(model any, key string, value any, LikeSearch bool) error {
+func (dH *DBHandler) GetByKey(model any, key string, value any, LikeSearch bool, relations ...string) error {
+	query := dH.db
+
+	for _, relation := range relations {
+		query = query.Preload(relation)
+	}
 	if LikeSearch {
 		value = strings.ReplaceAll(fmt.Sprint(value), "*", "%")
 		dH.logger.Debug("getByKey", "find like key "+key+" value "+fmt.Sprint(value))
-		return dH.db.Where(key+" LIKE ?", value).Find(model).Error
+		return query.Where(key+" LIKE ?", value).Find(model).Error
 	}
 
 	dH.logger.Debug("getByKey", "find equal key "+key+" value "+fmt.Sprint(value))
-	return dH.db.Find(model, key+" = ?", value).Error
+	return query.Find(model, key+" = ?", value).Error
 }
 
 // updateValuesById
@@ -172,18 +203,27 @@ func (dH *DBHandler) GetByKey(model any, key string, value any, LikeSearch bool)
 //
 // Returns:
 //   - error: If the model is invalid or query/update fails.
-func (dH *DBHandler) UpdateValuesById(model any, id uint) error {
-	dH.logger.Debug("updateValuesById", "model"+fmt.Sprint(model))
+func (dH *DBHandler) UpdateValuesById(model any, id uint, relations ...string) error {
+	dH.logger.Debug("updateValuesByKey", "model"+fmt.Sprint(model))
+
 	modelType := reflect.TypeOf(model)
 	if modelType.Kind() != reflect.Ptr {
 		return errors.New("model must be a pointer to struct")
 	}
 
 	lookUpModel := reflect.New(modelType.Elem()).Interface()
-	if err := dH.GetById(lookUpModel, id); err != nil {
+	if err := dH.GetById(lookUpModel, id, relations...); err != nil {
 		return err
 	}
-	return dH.db.Model(lookUpModel).Updates(model).Error
+
+	// Preload relations
+	query := dH.db
+	for _, relation := range relations {
+		query = query.Preload(relation)
+	}
+
+	// Update only provided keys
+	return query.Model(lookUpModel).Updates(model).Error
 }
 
 // updateValuesByKey
@@ -204,7 +244,7 @@ func (dH *DBHandler) UpdateValuesById(model any, id uint) error {
 //
 // Returns:
 //   - error: Any query or update error.
-func (dH *DBHandler) UpdateValuesByKey(model any, key string, value any) error {
+func (dH *DBHandler) UpdateValuesByKey(model any, key string, value any, relations ...string) error {
 	dH.logger.Debug("updateValuesByKey", "model"+fmt.Sprint(model))
 	modelType := reflect.TypeOf(model)
 	if modelType.Kind() != reflect.Ptr {
@@ -212,39 +252,35 @@ func (dH *DBHandler) UpdateValuesByKey(model any, key string, value any) error {
 	}
 
 	lookUpModel := reflect.New(modelType.Elem()).Interface()
-	if err := dH.GetByKey(lookUpModel, key, value, false); err != nil {
+	if err := dH.GetByKey(lookUpModel, key, value, false, relations...); err != nil {
 		return err
 	}
-	return dH.db.Model(lookUpModel).Updates(model).Error
+
+	query := dH.db
+
+	for _, relation := range relations {
+		query = query.Preload(relation)
+	}
+	return query.Model(lookUpModel).Updates(model).Error
 }
 
-// deleteById
-//
-// Description:
-//
-//	Deletes records by their ID(s).
-//
-// Behavior:
-//   - If the first ID == 0, all records in the table are deleted.
-//   - Otherwise, deletes the provided IDs.
-//
-// Parameters:
-//   - model: Model struct type representing the table.
-//   - id:    Variadic list of IDs to delete.
-//
-// Returns:
-//   - error: Any deletion error.
-func (dH *DBHandler) DeleteById(model any, id ...uint) error {
-	if id[0] == 0 {
-		dH.logger.Debug("deleteById", "delete all")
-		return dH.db.Where("1 = 1").Delete(model).Error
+func (dH *DBHandler) DeleteById(model any, relation string, ids ...uint) error {
+	if len(ids) == 0 {
+		return fmt.Errorf("no IDs provided")
 	}
 
-	dH.logger.Debug("deleteById", "delete ids"+fmt.Sprint(id))
-	if err := dH.Exists(model, "id", id, false); err != nil {
-		return err
+	if len(ids) == 1 && ids[0] == 0 {
+		dH.logger.Debug("deleteById", "delete ALL records!")
+		return dH.db.Session(&gorm.Session{AllowGlobalUpdate: true, FullSaveAssociations: true}).
+			Delete(model).Error
 	}
-	return dH.db.Delete(model, id).Error
+
+	dH.logger.Debug("deleteById", "delete ids "+fmt.Sprint(ids))
+
+	if err := dH.db.Delete(model, ids).Error; err != nil {
+		return fmt.Errorf("delete failed: %w", err)
+	}
+	return nil
 }
 
 // deleteByKey
@@ -264,7 +300,7 @@ func (dH *DBHandler) DeleteById(model any, id ...uint) error {
 //
 // Returns:
 //   - error: Any deletion error.
-func (dH *DBHandler) DeleteByKey(model any, key string, value any, LikeSearch bool) error {
+func (dH *DBHandler) DeleteByKey(model any, key string, value any, LikeSearch bool, relations ...string) error {
 	if LikeSearch {
 		value = strings.ReplaceAll(fmt.Sprint(value), "*", "%")
 		dH.logger.Debug("deleteByKey", "delete like key "+key+" value "+fmt.Sprint(value))
@@ -272,42 +308,63 @@ func (dH *DBHandler) DeleteByKey(model any, key string, value any, LikeSearch bo
 	}
 
 	dH.logger.Debug("deleteByKey", "delete equal key "+key+" value "+fmt.Sprint(value))
-	return dH.db.Where(key+" = ?", value).Delete(model).Error
+
+	query := dH.db
+
+	for _, relation := range relations {
+		query = query.Preload(relation)
 	}
 
-// exists
-//
-// Description:
-//
-//	Checks whether a record exists matching the specified key/value filter.
-//
-// Behavior:
-//   - Performs a `First` query on the database.
-//   - If `LikeSearch` is true, performs a LIKE query.
-//   - Returns an error if the record does not exist or query fails.
-//
-// Parameters:
-//   - model:      Model struct type to search.
-//   - key:        Column name to filter by.
-//   - value:      Value to match.
-//   - LikeSearch: Whether to use wildcard search.
-//
-// Returns:
-//   - error: “no record found” or DB error.
-func (dH *DBHandler) Exists(model any, key string, value any, LikeSearch bool) (err error) {
-	if LikeSearch {
-		value = strings.ReplaceAll(fmt.Sprint(value), "*", "%")
-		key = key + " LIKE ?"
-	} else {
-		key = key + " = ?"
+	return query.Where(key+" = ?", value).Delete(model).Error
 }
 
-	dH.logger.Debug("exists", "check if exists key "+key+" value "+fmt.Sprint(value))
-	err = dH.db.Where(key, value).First(model).Error
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return fmt.Errorf("no record found for %s %v", key[:len(key)-1], value)
-	} else if err != nil {
-		return fmt.Errorf("query failed: %w", err)
+func (dH *DBHandler) Exists(model any, key string, value any, likeSearch bool, relations ...string) (found bool) {
+	var query string
+	var args any
+
+	// Detect LIKE and IN behavior
+	val := reflect.ValueOf(value)
+	isSlice := val.Kind() == reflect.Slice
+
+	switch {
+	case isSlice:
+		if val.Len() == 0 {
+			dH.logger.Error("Exists", fmt.Sprintf("empty slice for %s", key))
+			return false
 		}
-	return
+		query = fmt.Sprintf("%s IN ?", key)
+		args = value
+
+	case likeSearch:
+		str := strings.ReplaceAll(fmt.Sprint(value), "*", "%")
+		query = fmt.Sprintf("%s LIKE ?", key)
+		args = str
+
+	default:
+		query = fmt.Sprintf("%s = ?", key)
+		args = value
+	}
+
+	dH.logger.Debug("exists", "checking existence for key "+query+" value "+fmt.Sprint(args))
+
+	datababase := dH.db
+	for _, relation := range relations {
+		datababase = datababase.Preload(relation)
+	}
+
+	tx := datababase.Where(query, args).Find(model)
+
+	if tx.Error != nil {
+		dH.logger.Error("Exists", fmt.Sprintf("query failed: %v", tx.Error))
+		return false
+	}
+	return tx.RowsAffected > 0
+}
+
+func (dH *DBHandler) AddRelation(model, relation any, relationName string) error {
+	return dH.db.Model(model).Association(relationName).Append(relation)
+}
+
+func (dH *DBHandler) DeleteRelation(model, relation any, relationName string) error {
+	return dH.db.Model(model).Association(relationName).Delete(relation)
 }

db_test.go

@@ -0,0 +1,107 @@
+package dbHandler
+
+import (
+	"os"
+	"testing"
+)
+
+type Event struct {
+	Id        int       `gorm:"primaryKey" json:"id"`
+	Name      string    `gorm:"column:name" json:"name"`
+	Attendees []*Member `gorm:"many2many:member_events;"`
+}
+
+type Member struct {
+	Id                  int      `gorm:"primaryKey" json:"id"`
+	FirstName           string   `gorm:"column:firstName" json:"firstName,omitempty"`
+	LastName            string   `gorm:"column:lastName" json:"lastName,omitempty"`
+	ResponsiblePersonID *int     `json:"responsiblePersonId"`
+	ResponsiblePerson   *Member  `gorm:"foreignKey:ResponsiblePersonID" json:"responsiblePerson"`
+	Events              []*Event `gorm:"many2many:member_events;" json:"events"`
+}
+
+func TestDbHandler(t *testing.T) {
+
+	dbHandler, err := NewDBHandler("test.db", "test", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := dbHandler.AddNewTable(&Member{}); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := dbHandler.AddNewTable(&Event{}); err != nil {
+		t.Fatal(err)
+	}
+
+	membersIN := []*Member{{FirstName: "adrian", LastName: "zuercher"}, {FirstName: "adichild", LastName: "zuercher"}}
+	for _, member := range membersIN {
+		dbHandler.AddNewColum(member)
+		event := &Event{
+			Name: "testEvent",
+		}
+		dbHandler.AddNewColum(event)
+		dbHandler.AddRelation(event, member, "Attendees")
+	}
+
+	var members []Member
+	if err := dbHandler.GetById(&members, "", 0); err != nil {
+		t.Fatal(err)
+	}
+	t.Log(members)
+
+	if err := dbHandler.GetById(&members, "Events", 0); err != nil {
+		t.Fatal(err)
+	}
+	t.Log(members)
+
+	for _, member := range members {
+		t.Log("Member:", member.FirstName, member.LastName)
+		for _, event := range member.Events {
+			t.Log("Event:", event)
+		}
+	}
+
+	var events []Event
+
+	if err := dbHandler.GetById(&events, "Attendees", 0); err != nil {
+		t.Fatal(err)
+	}
+
+	for _, event := range events {
+		t.Log("event:", event.Name)
+		for _, member := range event.Attendees {
+			t.Log("attendee:", member)
+		}
+	}
+
+	//add responsible
+	mem1 := &Member{}
+	if err := dbHandler.GetById(mem1, "", 2); err != nil {
+		t.Fatal(err)
+	}
+
+	mem2 := &Member{}
+	if err := dbHandler.GetById(mem2, "", 1); err != nil {
+		t.Fatal(err)
+	}
+
+	mem1.ResponsiblePerson = mem2
+	dbHandler.UpdateValuesById(mem1, "", uint(mem1.Id))
+
+	if err := dbHandler.GetById(mem1, "", 2); err != nil {
+		t.Fatal(err)
+	}
+
+	t.Log(mem1)
+	t.Log(mem1.ResponsiblePerson)
+
+	if err := dbHandler.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := os.RemoveAll("test"); err != nil {
+		t.Fatal(err)
+	}
+}