implement dbhandler package and new test file

handlers/database.go

@@ -3,52 +3,36 @@ package handlers
 import (
 	"crypto/hmac"
 	"crypto/sha256"
-	"database/sql"
 	"encoding/hex"
-	"fmt"
-	"os"
-	"path/filepath"
 
-	_ "modernc.org/sqlite"
+	"gitea.tecamino.com/paadi/dbHandler"
+	"gitea.tecamino.com/paadi/tecamino-logger/logging"
 )
 
 type DatabaseHandler struct {
-	database *sql.DB
+	database *dbHandler.DBHandler
 	token    []byte
 }
 
-func NewDatabaseHandler(file string, create bool) (*DatabaseHandler, error) {
-	if create {
-		// createOrOpenDB creates or opens a SQLite database at the given path.
-		// Create the directory if it doesn't exist
-		dir := filepath.Dir(file)
+func NewDatabaseHandler(name, path string, logger *logging.Logger) (*DatabaseHandler, error) {
 
-		err := os.MkdirAll(dir, os.ModePerm)
-		if err != nil {
-			return nil, fmt.Errorf("failed to create directory: %w", err)
-		}
-	} else {
-		if _, err := os.Stat(file); err != nil {
-			return nil, fmt.Errorf("%s not found", file)
-		}
-	}
-
-	// Open the database (creates it if it doesn't exist)
-	db, err := sql.Open("sqlite", file)
+	database, err := dbHandler.NewDBHandler(name, path, logger)
 	if err != nil {
-		return nil, fmt.Errorf("failed to open database: %w", err)
+		return nil, err
 	}
-
-	// Test the connection
-	if err = db.Ping(); err != nil {
-		return nil, fmt.Errorf("failed to connect to database: %w", err)
-	}
-
-	return &DatabaseHandler{database: db}, nil
+	return &DatabaseHandler{database: database}, nil
 }
 
-func (dh *DatabaseHandler) SetToken(token string) {
-	dh.token = []byte(token)
+func (dH *DatabaseHandler) DatabaseOpened() bool {
+	return dH.database != nil
+}
+
+func (dH *DatabaseHandler) AddNewTable(model any) error {
+	return dH.database.AddNewTable(model)
+}
+
+func (dH *DatabaseHandler) AddNewColum(model any) error {
+	return dH.database.AddNewColum(model)
 }
 
 func (dh *DatabaseHandler) hashField(field string) string {
@@ -56,3 +40,7 @@ func (dh *DatabaseHandler) hashField(field string) string {
 	h.Write([]byte(field))
 	return hex.EncodeToString(h.Sum(nil))
 }
+
+func (dh *DatabaseHandler) SetToken(token string) {
+	dh.token = []byte(token)
+}

handlers/events.go

@@ -1,170 +1,95 @@
 package handlers
 
 import (
-	"encoding/json"
 	"errors"
-	"fmt"
 	"slices"
-	"strings"
 	"time"
 
 	"gitea.tecamino.com/paadi/memberDB/models"
 )
 
-func (dh *DatabaseHandler) CreateNewEventTable() error {
-	createTableSQL := `
-	CREATE TABLE IF NOT EXISTS events (
-		id INTEGER PRIMARY KEY AUTOINCREMENT,
-		name TEXT NOT NULL,
-		date TEXT UNIQUE NOT NULL,
-		attendees TEXT NOT NULL,
-		count INTEGER NOT NULL
-	);`
-
-	_, err := dh.database.Exec(createTableSQL)
-	if err != nil {
-		return fmt.Errorf("failed to create table: %w", err)
-	}
-	return nil
-}
-
 func (dh *DatabaseHandler) StartNewEvent(name string) error {
-	_, err := dh.database.Exec("INSERT INTO events (name, date, attendees, count) VALUES (?, ?, ?, ?)", name, time.Now().Format("2006-01-02 15:04:05"), "[]", 0)
-	return err
-}
-
-func (dh *DatabaseHandler) GetEvent(id int) (attendees []models.Event, err error) {
-	var args any
-	query := `SELECT id, name, date, attendees, count FROM events`
-
-	if id > 0 {
-		query += ` WHERE id = ?`
-		args = id
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
 	}
 
-	rows, err := dh.database.Query(query, args)
+	return dh.database.AddNewColum(&models.Event{
+		Name: name,
+		Date: time.Now().Format("2006-01-02 15:04:05"),
+	})
+}
+
+func (dh *DatabaseHandler) GetEvent(id uint) (attendees []models.Event, err error) {
+	if !dh.DatabaseOpened() {
+		return attendees, errors.New("database not opened")
+	}
+
+	err = dh.database.GetById(&attendees, id)
 	if err != nil {
 		return
 	}
-	defer rows.Close()
 
-	for rows.Next() {
-		var id, count int
-		var name, date, attendance string
-		if err = rows.Scan(&id, &name, &date, &attendance, &count); err != nil {
-			return
-		}
-
-		var a []models.Person
-
-		if err := json.Unmarshal([]byte(attendance), &a); err != nil {
-			return attendees, err
-		}
-
-		attendees = append(attendees, models.Event{
-			Id:        id,
-			Name:      name,
-			Date:      date,
-			Attendees: a,
-			Count:     count,
-		})
+	for i := range attendees {
+		attendees[i].Count = len(attendees[i].Attendees)
 	}
-
-	return attendees, nil
+	return
 }
 
-func (dh *DatabaseHandler) DeleteEvent(ids ...int) error {
+func (dh *DatabaseHandler) DeleteEvent(ids ...uint) error {
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
+	}
+
 	if len(ids) == 0 {
 		return errors.New("no ids given to be deleted")
 	}
 
-	placeholders := make([]string, len(ids))
-	args := make([]any, len(ids))
-	for i, id := range ids {
-		placeholders[i] = "?"
-		args[i] = id
-	}
-	query := fmt.Sprintf("DELETE FROM events WHERE id IN (%s)", strings.Join(placeholders, ","))
-
-	_, err := dh.database.Exec(query, args...)
-	return err
+	return dh.database.DeleteById(&models.Event{}, ids...)
 }
 
-func (dh *DatabaseHandler) AddAttendeesToEvent(event models.Event) error {
-
-	//get event from database by id
-	row := dh.database.QueryRow(`SELECT attendees FROM events WHERE id = ?`, event.Id)
-
-	var attendeesString string
-	if err := row.Scan(&attendeesString); err != nil {
-		return err
+func (dh *DatabaseHandler) AddAttendeesToEvent(newEvent models.Event) error {
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
 	}
-	fmt.Println(attendeesString)
 
-	var attendees []models.Person
-	err := json.Unmarshal([]byte(attendeesString), &attendees)
+	var event models.Event
+	err := dh.database.GetById(&event, uint(event.Id))
 	if err != nil {
 		return err
 	}
 
 next:
-	for _, newAttendee := range event.Attendees {
-		for _, attendee := range attendees {
+	for _, newAttendee := range newEvent.Attendees {
+		for _, attendee := range event.Attendees {
 			if attendee.FirstName == newAttendee.FirstName && attendee.LastName == newAttendee.LastName {
 				continue next
 			}
 		}
-		attendees = append(attendees, newAttendee)
+		event.Attendees = append(event.Attendees, newAttendee)
 	}
 
-	attendeesByte, err := json.Marshal(attendees)
-	if err != nil {
-		return err
-	}
+	event.Count = len(event.Attendees)
 
-	count := len(attendees)
-	_, err = dh.database.Exec("UPDATE events SET attendees= ? count= ? WHERE id= ?", string(attendeesByte), event.Id, count)
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return dh.database.UpdateValuesById(&event, uint(event.Id))
 }
 
-func (dh *DatabaseHandler) DeleteAttendeesFromEvent(event models.Event) error {
-	//get event from database by id
-	row := dh.database.QueryRow(`SELECT attendees FROM events WHERE id = ?`, event.Id)
-
-	var attendeesString string
-	if err := row.Scan(&attendeesString); err != nil {
-		return err
-	}
-	fmt.Println(attendeesString)
-
-	var attendees []models.Person
-	err := json.Unmarshal([]byte(attendeesString), &attendees)
-	if err != nil {
-		return err
+func (dh *DatabaseHandler) DeleteAttendeesFromEvent(newEvent models.Event) error {
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
 	}
 
-	for _, newAttendee := range event.Attendees {
-		for i, attendee := range attendees {
-			if attendee.FirstName == newAttendee.FirstName && attendee.LastName == newAttendee.LastName {
-				attendees = slices.Delete(attendees, i, i+1)
+	var event models.Event
+	dh.database.GetById(&event, uint(event.Id))
+
+next:
+	for _, newAttendee := range newEvent.Attendees {
+		for i := range event.Attendees {
+			if event.Attendees[i].FirstName == newAttendee.FirstName && event.Attendees[i].LastName == newAttendee.LastName {
+				event.Attendees = slices.Delete(event.Attendees, i, i+1)
+				continue next
 			}
 		}
 	}
-
-	attendeesByte, err := json.Marshal(attendees)
-	if err != nil {
-		return err
-	}
-
-	count := len(attendees)
-	_, err = dh.database.Exec("UPDATE events SET attendees= ? count= ? WHERE id= ?", string(attendeesByte), event.Id, count)
-	if err != nil {
-		return err
-	}
-
-	return nil
+	event.Count = len(event.Attendees)
+	return dh.database.UpdateValuesById(&event, uint(event.Id))
 }

handlers/members.go

@@ -1,10 +1,8 @@
 package handlers
 
 import (
-	"database/sql"
 	"errors"
 	"fmt"
-	"strings"
 	"time"
 
 	"gitea.tecamino.com/paadi/memberDB/crypto"
@@ -12,37 +10,12 @@ import (
 	"gitea.tecamino.com/paadi/memberDB/utils"
 )
 
-// CreateNewMemberTable creates a new member table.
-func (dh *DatabaseHandler) CreateNewMemberTable() error {
-	createTableSQL := `
-	CREATE TABLE IF NOT EXISTS members (
-		id INTEGER PRIMARY KEY AUTOINCREMENT,
-		first_name TEXT NOT NULL,
-		first_name_hash TEXT NOT NULL,
-		last_name TEXT NOT NULL,
-		last_name_hash TEXT NOT NULL,
-		birthday TEXT NOT NULL,
-		birthday_hash TEXT NOT NULL,
-		address TEXT NOT NULL,
-		zip_code TEXT NOT NULL,
-		town TEXT NOT NULL,
-		phone TEXT NOT NULL,
-		email TEXT UNIQUE NOT NULL,
-		first_visit TEXT NOT NULL,
-		last_visit TEXT NOT NULL,
-		member_group TEXT NOT NULL,
-		responsible_person TEXT NOT NULL
-	);`
-
-	_, err := dh.database.Exec(createTableSQL)
-	if err != nil {
-		return fmt.Errorf("failed to create table: %w", err)
-	}
-	return nil
-}
-
 // AddNewMember adds a new member to memeber table at least fist, las name and birthday has to be entered
 func (dh *DatabaseHandler) AddNewMember(members ...models.Member) error {
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
+	}
+
 	for _, member := range members {
 
 		exists, err := dh.memberExists(member)
@@ -123,7 +96,23 @@ func (dh *DatabaseHandler) AddNewMember(members ...models.Member) error {
 			return err
 		}
 
-		_, err = dh.database.Exec("INSERT INTO members (first_name, first_name_hash, last_name, last_name_hash, birthday, birthday_hash, address, zip_code, town, phone, email, first_visit, last_visit, member_group, responsible_person) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", encFirstName, dh.hashField(member.FirstName), encLastName, dh.hashField(member.LastName), encBirthday, dh.hashField(member.Birthday), encAddress, encZip, encTown, encPhone, encEmail, encFirstVisit, encLastVisit, encGroup, encResponsiblePerson)
+		member.FirstNameHash = dh.hashField(member.FirstName)
+		member.FirstName = encFirstName
+		member.LastNameHash = dh.hashField(member.LastName)
+		member.LastName = encLastName
+		member.BirthdayHash = dh.hashField(member.Birthday)
+		member.Birthday = encBirthday
+		member.Address = encAddress
+		member.Zip = encZip
+		member.Town = encTown
+		member.Phone = encPhone
+		member.Email = encEmail
+		member.FirstVisit = encFirstVisit
+		member.LastVisit = encLastVisit
+		member.Group = encGroup
+		member.ResponsiblePerson = encResponsiblePerson
+
+		err = dh.database.AddNewColum(&member)
 		if err != nil {
 			return err
 		}
@@ -132,290 +121,203 @@ func (dh *DatabaseHandler) AddNewMember(members ...models.Member) error {
 }
 
 // DeleteMember removes members by given ids
-func (dh *DatabaseHandler) DeleteMember(ids ...int) error {
+func (dh *DatabaseHandler) DeleteMember(ids ...uint) error {
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
+	}
+
 	if len(ids) == 0 {
 		return errors.New("no ids given to be deleted")
 	}
-
-	placeholders := make([]string, len(ids))
-	args := make([]any, len(ids))
-	for i, id := range ids {
-		placeholders[i] = "?"
-		args[i] = id
-	}
-	query := fmt.Sprintf("DELETE FROM members WHERE id IN (%s)", strings.Join(placeholders, ","))
-
-	_, err := dh.database.Exec(query, args...)
-	return err
+	return dh.database.DeleteById(&models.Member{}, ids...)
 }
 
 // GetMember returns one member by given id
-func (dh *DatabaseHandler) GetMember(id int) (members []models.Member, err error) {
-	var args any
-	query := `SELECT id, first_name, last_name, birthday, address, zip_code, town, phone, email, first_visit, last_visit, member_group, responsible_person FROM members`
-
-	if id > 0 {
-		query = ` WHERE id = ?`
-		args = id
+func (dh *DatabaseHandler) GetMember(id uint) (members []models.Member, err error) {
+	if !dh.DatabaseOpened() {
+		return members, errors.New("database not opened")
 	}
 
-	rows, err := dh.database.Query(query, args)
+	err = dh.database.GetById(&members, id)
 	if err != nil {
 		return
 	}
-	defer rows.Close()
 
-	for rows.Next() {
-		var id int
-		var encFirstName, encLastName, encBirthday, encAddress, encZip, encTown, encPhone, encEmail, encFirstVisit, encLastVisit, encGroup, encResponsiblePerson string
-		if err = rows.Scan(&id, &encFirstName, &encLastName, &encBirthday, &encAddress, &encZip, &encTown, &encPhone, &encEmail, &encFirstVisit, &encLastVisit, &encGroup, &encResponsiblePerson); err != nil {
+	for i := range members {
+		members[i].FirstName, err = crypto.Decrypt(members[i].FirstName, dh.token)
+		if err != nil {
 			return
 		}
 
-		firstName, err := crypto.Decrypt(encFirstName, dh.token)
+		members[i].LastName, err = crypto.Decrypt(members[i].LastName, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
 
-		lastName, err := crypto.Decrypt(encLastName, dh.token)
+		members[i].Birthday, err = crypto.Decrypt(members[i].Birthday, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
 
-		birthday, err := crypto.Decrypt(encBirthday, dh.token)
+		members[i].Address, err = crypto.Decrypt(members[i].Address, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
 
-		address, err := crypto.Decrypt(encAddress, dh.token)
+		members[i].Zip, err = crypto.Decrypt(members[i].Zip, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
 
-		zip, err := crypto.Decrypt(encZip, dh.token)
+		members[i].Town, err = crypto.Decrypt(members[i].Town, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
 
-		town, err := crypto.Decrypt(encTown, dh.token)
+		members[i].Phone, err = crypto.Decrypt(members[i].Phone, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
 
-		phone, err := crypto.Decrypt(encPhone, dh.token)
+		members[i].Email, err = crypto.Decrypt(members[i].Email, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
 
-		email, err := crypto.Decrypt(encEmail, dh.token)
+		members[i].FirstVisit, err = crypto.Decrypt(members[i].FirstVisit, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
 
-		firstVisit, err := crypto.Decrypt(encFirstVisit, dh.token)
+		members[i].LastVisit, err = crypto.Decrypt(members[i].LastVisit, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
 
-		lastVisit, err := crypto.Decrypt(encLastVisit, dh.token)
+		members[i].Group, err = crypto.Decrypt(members[i].Group, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
 
-		group, err := crypto.Decrypt(encGroup, dh.token)
+		members[i].ResponsiblePerson, err = crypto.Decrypt(members[i].ResponsiblePerson, dh.token)
 		if err != nil {
-			return members, err
+			return
 		}
-
-		responsiblePerson, err := crypto.Decrypt(encResponsiblePerson, dh.token)
-		if err != nil {
-			return members, err
-		}
-
-		members = append(members, models.Member{
-			Id:                id,
-			FirstName:         firstName,
-			LastName:          lastName,
-			Birthday:          birthday,
-			Address:           address,
-			Zip:               zip,
-			Town:              town,
-			Phone:             phone,
-			Email:             email,
-			FirstVisit:        firstVisit,
-			LastVisit:         lastVisit,
-			Group:             group,
-			ResponsiblePerson: responsiblePerson,
-		})
 	}
-
-	return members, nil
+	return
 }
 
 // UpdateMember updates/overrides all information given meber id
 func (dh *DatabaseHandler) UpdateMember(id int, member models.Member) (err error) {
-	var queryParameters []string
-	var args []any
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
+	}
 
 	if member.FirstName != "" {
-		encFirstName, err := crypto.Encrypt(member.FirstName, dh.token)
+		member.FirstNameHash = dh.hashField(member.FirstName)
+		member.FirstName, err = crypto.Encrypt(member.FirstName, dh.token)
 		if err != nil {
-			return err
+			return
 		}
-
-		queryParameters = append(queryParameters, "first_name = ?")
-		queryParameters = append(queryParameters, "first_name_hash  = ?")
-
-		args = append(args, encFirstName)
-		args = append(args, dh.hashField(member.FirstName))
 	}
 
 	if member.LastName != "" {
-		encLastName, err := crypto.Encrypt(member.LastName, dh.token)
+		member.LastNameHash = dh.hashField(member.LastName)
+		member.LastName, err = crypto.Encrypt(member.LastName, dh.token)
 		if err != nil {
-			return err
+			return
 		}
-
-		queryParameters = append(queryParameters, "last_name = ?")
-		queryParameters = append(queryParameters, "last_name_hash = ?")
-
-		args = append(args, encLastName)
-		args = append(args, dh.hashField(member.LastName))
 	}
 
 	//check correct birtday format
 	if member.Birthday != "" && utils.IsValidBirthday(member.Birthday) {
-		encBirthday, err := crypto.Encrypt(member.Birthday, dh.token)
+		member.BirthdayHash = dh.hashField(member.BirthdayHash)
+		member.Birthday, err = crypto.Encrypt(member.Birthday, dh.token)
 		if err != nil {
 			return err
 		}
-
-		queryParameters = append(queryParameters, "birthday = ?")
-		queryParameters = append(queryParameters, "birthday_hash = ?")
-
-		args = append(args, encBirthday)
-		args = append(args, dh.hashField(member.Birthday))
 	} else if member.Birthday != "" {
 		return errors.New("incorrect birthday format")
 	}
 
 	if member.Address != "" {
-		encAddress, err := crypto.Encrypt(member.Address, dh.token)
+		member.Address, err = crypto.Encrypt(member.Address, dh.token)
 		if err != nil {
 			return err
 		}
-		queryParameters = append(queryParameters, "address = ?")
-
-		args = append(args, encAddress)
 	}
 
 	if member.Zip != "" {
-		encZip, err := crypto.Encrypt(member.Zip, dh.token)
+		member.Zip, err = crypto.Encrypt(member.Zip, dh.token)
 		if err != nil {
 			return err
 		}
-		queryParameters = append(queryParameters, "zip_code = ?")
-
-		args = append(args, encZip)
 	}
 
 	if member.Town != "" {
-		encTown, err := crypto.Encrypt(member.Town, dh.token)
+		member.Town, err = crypto.Encrypt(member.Town, dh.token)
 		if err != nil {
 			return err
 		}
-		queryParameters = append(queryParameters, "town = ?")
-
-		args = append(args, encTown)
 	}
 
 	if member.Phone != "" {
-		encPhone, err := crypto.Encrypt(member.Phone, dh.token)
+		member.Phone, err = crypto.Encrypt(member.Phone, dh.token)
 		if err != nil {
 			return err
 		}
-		queryParameters = append(queryParameters, "phone = ?")
-
-		args = append(args, encPhone)
 	}
 
 	//check correct email format
 	if member.Email != "" && utils.IsValidEmail(member.Email) {
-		encEmail, err := crypto.Encrypt(member.Email, dh.token)
+		member.Email, err = crypto.Encrypt(member.Email, dh.token)
 		if err != nil {
 			return err
 		}
-		queryParameters = append(queryParameters, "email = ?")
-
-		args = append(args, encEmail)
 	} else if member.Email != "" {
 		return errors.New("incorrect email format")
 	}
 
 	if member.FirstVisit != "" {
-		encFirstVisit, err := crypto.Encrypt(member.FirstVisit, dh.token)
+		member.FirstVisit, err = crypto.Encrypt(member.FirstVisit, dh.token)
 		if err != nil {
 			return err
 		}
-		queryParameters = append(queryParameters, "first_visit = ?")
-
-		args = append(args, encFirstVisit)
 	}
 
 	if member.LastVisit != "" {
-		encLastVisit, err := crypto.Encrypt(member.LastVisit, dh.token)
+		member.LastVisit, err = crypto.Encrypt(member.LastVisit, dh.token)
 		if err != nil {
 			return err
 		}
-		queryParameters = append(queryParameters, "last_visit = ?")
-
-		args = append(args, encLastVisit)
 	}
 
 	if member.Group != "" {
-		encFirstVisit, err := crypto.Encrypt(member.Group, dh.token)
+		member.Group, err = crypto.Encrypt(member.Group, dh.token)
 		if err != nil {
 			return err
 		}
-		queryParameters = append(queryParameters, "member_group = ?")
-
-		args = append(args, encFirstVisit)
 	}
 
 	if member.ResponsiblePerson != "" {
-		encResponsiblePerson, err := crypto.Encrypt(member.ResponsiblePerson, dh.token)
+		member.ResponsiblePerson, err = crypto.Encrypt(member.ResponsiblePerson, dh.token)
 		if err != nil {
 			return err
 		}
-		queryParameters = append(queryParameters, "responsible_person = ?")
-
-		args = append(args, encResponsiblePerson)
 	}
-
-	query := `UPDATE members SET `
-	query += strings.Join(queryParameters, ", ")
-	query += ` WHERE id = ?`
-	args = append(args, id)
-
-	_, err = dh.database.Exec(query, args...)
-	return err
+	return dh.database.UpdateValuesById(&member, uint(member.Id))
 }
 
 // memberExists helper to check wheter member already exists
-func (dh *DatabaseHandler) memberExists(member models.Member) (bool, error) {
-	query := `
-		SELECT 1 FROM members
-		WHERE first_name_hash = ? AND last_name_hash = ? AND birthday_hash = ?
-		LIMIT 1
-	`
-	var exists int
-	err := dh.database.QueryRow(query, dh.hashField(member.FirstName), dh.hashField(member.LastName), dh.hashField(member.Birthday)).Scan(&exists)
-
-	if err == sql.ErrNoRows {
-		return false, nil // no match
-	} else if err != nil {
-		return false, err // db error
+func (dh *DatabaseHandler) memberExists(checkMember models.Member) (bool, error) {
+	if !dh.DatabaseOpened() {
+		return false, errors.New("database not opened")
 	}
 
-	return true, nil // match found
+	var member models.Member
+	err := dh.database.Exists(&member, "birthdayHash", dh.hashField(checkMember.Birthday), false)
+	if err != nil {
+		return false, nil
+	}
+	return dh.hashField(checkMember.FirstName) == member.FirstNameHash && dh.hashField(checkMember.LastName) == member.LastNameHash && dh.hashField(checkMember.Birthday) == member.BirthdayHash, nil
 }

handlers/responsible.go

@@ -1,30 +1,18 @@
 package handlers
 
 import (
-	"database/sql"
 	"errors"
-	"fmt"
-	"strings"
 
 	"gitea.tecamino.com/paadi/memberDB/models"
 )
 
-func (dh *DatabaseHandler) CreateNewResponsibleTable() error {
-	createTableSQL := `
-	CREATE TABLE IF NOT EXISTS responsible (
-		id INTEGER PRIMARY KEY AUTOINCREMENT,
-		first_name TEXT NOT NULL,
-		last_name TEXT UNIQUE NOT NULL
-	);`
-
-	_, err := dh.database.Exec(createTableSQL)
-	if err != nil {
-		return fmt.Errorf("failed to create table: %w", err)
-	}
-	return nil
-}
-
 func (dh *DatabaseHandler) AddNewResponsible(responsibles ...models.Person) error {
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
+	}
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
+	}
 	for _, responsible := range responsibles {
 
 		exists, err := dh.responsibleExists(responsible)
@@ -34,7 +22,7 @@ func (dh *DatabaseHandler) AddNewResponsible(responsibles ...models.Person) erro
 			continue
 		}
 
-		_, err = dh.database.Exec("INSERT INTO responsible (first_name, last_name) VALUES (?, ?)", responsible.FirstName, responsible.LastName)
+		err = dh.database.AddNewColum(&responsible)
 		if err != nil {
 			return err
 		}
@@ -42,69 +30,35 @@ func (dh *DatabaseHandler) AddNewResponsible(responsibles ...models.Person) erro
 	return nil
 }
 
-func (dh *DatabaseHandler) GetResponsible(id int) (persons []models.Person, err error) {
-	var args any
-	query := `SELECT id, first_name, last_name FROM responsible`
-
-	if id > 0 {
-		query = ` WHERE id = ?`
-		args = id
+func (dh *DatabaseHandler) GetResponsible(id uint) (persons []models.Person, err error) {
+	if !dh.DatabaseOpened() {
+		return persons, errors.New("database not opened")
 	}
 
-	rows, err := dh.database.Query(query, args)
-	if err != nil {
-		return
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var id int
-		var firstName, lastName string
-		if err = rows.Scan(&id, &firstName, &lastName); err != nil {
-			return
-		}
-
-		persons = append(persons, models.Person{
-			Id:        id,
-			FirstName: firstName,
-			LastName:  lastName,
-		})
-	}
-
-	return persons, nil
+	err = dh.database.GetById(&persons, id)
+	return
 }
 
-func (dh *DatabaseHandler) DeleteResponsible(ids ...int) error {
+func (dh *DatabaseHandler) DeleteResponsible(ids ...uint) error {
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
+	}
+
 	if len(ids) == 0 {
 		return errors.New("no ids given to be deleted")
 	}
-
-	placeholders := make([]string, len(ids))
-	args := make([]any, len(ids))
-	for i, id := range ids {
-		placeholders[i] = "?"
-		args[i] = id
-	}
-	query := fmt.Sprintf("DELETE FROM responsible WHERE id IN (%s)", strings.Join(placeholders, ","))
-
-	_, err := dh.database.Exec(query, args...)
-	return err
+	return dh.database.DeleteById(&models.Person{}, ids...)
 }
 
-func (dh *DatabaseHandler) responsibleExists(responsible models.Person) (bool, error) {
-	query := `
-		SELECT 1 FROM responsible
-		WHERE first_name = ? AND last_name = ?
-		LIMIT 1
-	`
-	var exists int
-	err := dh.database.QueryRow(query, responsible.FirstName, responsible.LastName).Scan(&exists)
-
-	if err == sql.ErrNoRows {
-		return false, nil // no match
-	} else if err != nil {
-		return false, err // db error
+func (dh *DatabaseHandler) responsibleExists(CheckResponsible models.Person) (bool, error) {
+	if !dh.DatabaseOpened() {
+		return false, errors.New("database not opened")
 	}
 
-	return true, nil // match found
+	var person models.Person
+	err := dh.database.Exists(&person, "lastName", CheckResponsible.LastName, false)
+	if err != nil {
+		return false, nil
+	}
+	return person.FirstName == CheckResponsible.FirstName && person.LastName == CheckResponsible.LastName, nil
 }