fix add Responsible

api/api.go

@@ -41,7 +41,7 @@ func NewAPI(host string, port int, logger *logging.Logger) (*API, error) {
 
 	v1.POST("/database/open", apiHandler.OpenDatabase)
 	v1.POST("/members/add", apiHandler.AddNewMember)
-	v1.POST("/members/edit", apiHandler.EditMember)
+	v1.POST("/members/edit", apiHandler.UpdateMember)
 	v1.POST("/members/delete", apiHandler.DeleteMember)
 	v1.POST("/members/import/csv", apiHandler.ImportCSV)
 

api/apiHandler.go

@@ -73,6 +73,10 @@ func (a *APIHandler) OpenDatabase(c *gin.Context) {
 		return
 	}
 
+	if err := a.DbHandler.SetTimezone(os.Getenv("TIMEZONE")); err != nil {
+		a.logger.Error("OpenDatabase", err)
+	}
+
 	if err := a.DbHandler.AddNewTable(&models.Member{}); err != nil {
 		a.logger.Error("OpenDatabase", err)
 		c.JSON(http.StatusInternalServerError, nil)
@@ -85,7 +89,13 @@ func (a *APIHandler) OpenDatabase(c *gin.Context) {
 		return
 	}
 
-	if err := a.DbHandler.AddNewTable(&models.Person{}); err != nil {
+	if err := a.DbHandler.AddNewTable(&models.Responsible{}); err != nil {
+		a.logger.Error("OpenDatabase", err)
+		c.JSON(http.StatusInternalServerError, nil)
+		return
+	}
+
+	if err := a.DbHandler.AddNewTable(&models.Group{}); err != nil {
 		a.logger.Error("OpenDatabase", err)
 		c.JSON(http.StatusInternalServerError, nil)
 		return

api/eventHandler.go

@@ -15,23 +15,23 @@ func (a *APIHandler) StartNewEvent(c *gin.Context) {
 		return
 	}
 
-	name := c.Query("name")
+	var event models.Event
-	if name == "" {
+	err := c.BindJSON(&event)
-		a.logger.Error("StartNewEvent", "missing query 'name'")
+	if err != nil {
-
+		a.logger.Error("StartNewEvent", err)
 		c.JSON(http.StatusInternalServerError, nil)
 		return
 	}
 
-	if err := a.DbHandler.StartNewEvent(name); err != nil {
+	if err := a.DbHandler.StartNewEvent(&event); err != nil {
 		a.logger.Error("StartNewEvent", err)
-
+		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
-		c.JSON(http.StatusInternalServerError, nil)
 		return
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"message": "New Event added " + name,
+		"message": "New Event added " + event.Name,
+		"data":    event,
 	})
 }
 
@@ -66,6 +66,36 @@ func (a *APIHandler) GetEvent(c *gin.Context) {
 	c.JSON(http.StatusOK, events)
 }
 
+func (a *APIHandler) UpdateEvent(c *gin.Context) {
+	if !a.DBHandlerIsInitialized() {
+		a.logger.Error("UpdateEvent", "database handler is not initialized")
+		c.JSON(http.StatusInternalServerError, nil)
+		return
+	}
+
+	var events []models.Event
+	err := c.BindJSON(&events)
+	if err != nil {
+		a.logger.Error("UpdateEvent", err)
+		c.JSON(http.StatusInternalServerError, nil)
+		return
+	}
+
+	for _, event := range events {
+		err = a.DbHandler.UpdateEvent(event.Id, event)
+		if err != nil {
+			a.logger.Error("UpdateEvent", err)
+			c.JSON(http.StatusBadRequest, gin.H{
+				"message": err.Error(),
+			})
+			return
+		}
+	}
+	c.JSON(http.StatusOK, gin.H{
+		"message": "event(s) updated",
+	})
+}
+
 func (a *APIHandler) DeleteEvent(c *gin.Context) {
 	if !a.DBHandlerIsInitialized() {
 		a.logger.Error("DeleteEvent", "database handler is not initialized")
@@ -115,7 +145,7 @@ func (a *APIHandler) AddNewAttendees(c *gin.Context) {
 
 	err = a.DbHandler.AddAttendeesToEvent(event)
 	if err != nil {
-		a.logger.Error("DeleteEvent", err)
+		a.logger.Error("AddNewAttendees", err)
 
 		c.JSON(http.StatusInternalServerError, gin.H{
 			"message": err.Error(),
@@ -147,7 +177,7 @@ func (a *APIHandler) DeleteAttendee(c *gin.Context) {
 
 	err = a.DbHandler.DeleteAttendeesFromEvent(event)
 	if err != nil {
-		a.logger.Error("DeleteAttendeesFromEvent", err)
+		a.logger.Error("DeleteAttendee", err)
 		c.JSON(http.StatusInternalServerError, gin.H{
 			"message": err.Error(),
 		})

api/groupHandler.go

@@ -0,0 +1,128 @@
+package api
+
+import (
+	"net/http"
+	"strconv"
+
+	"gitea.tecamino.com/paadi/memberDB/models"
+	"github.com/gin-gonic/gin"
+)
+
+func (a *APIHandler) NewGroup(c *gin.Context) {
+	if !a.DBHandlerIsInitialized() {
+		a.logger.Error("StartNewEvent", "database handler is not initialized")
+		c.JSON(http.StatusInternalServerError, nil)
+		return
+	}
+
+	var group models.Group
+	err := c.BindJSON(&group)
+	if err != nil {
+		a.logger.Error("NewGroup", err)
+		c.JSON(http.StatusInternalServerError, nil)
+		return
+	}
+
+	if err := a.DbHandler.NewGroup(&group); err != nil {
+		a.logger.Error("NewGroup", err)
+		c.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"message": "New group added " + group.Name,
+	})
+}
+
+func (a *APIHandler) GetGroup(c *gin.Context) {
+	if !a.DBHandlerIsInitialized() {
+		a.logger.Error("GetGroup", "database handler is not initialized")
+		c.JSON(http.StatusInternalServerError, nil)
+		return
+	}
+
+	var i int
+	var err error
+
+	id := c.Query("id")
+	if id != "" {
+		i, err = strconv.Atoi(id)
+		if err != nil {
+			a.logger.Error("GetGroup", err)
+
+			c.JSON(http.StatusInternalServerError, nil)
+			return
+		}
+	}
+
+	groups, err := a.DbHandler.GetGroup(uint(i))
+	if err != nil {
+		a.logger.Error("GetGroup", err)
+		c.JSON(http.StatusBadRequest, nil)
+		return
+	}
+
+	c.JSON(http.StatusOK, groups)
+}
+
+func (a *APIHandler) UpdateGroup(c *gin.Context) {
+	if !a.DBHandlerIsInitialized() {
+		a.logger.Error("UpdateGroup", "database handler is not initialized")
+		c.JSON(http.StatusInternalServerError, nil)
+		return
+	}
+
+	var groups []models.Group
+	err := c.BindJSON(&groups)
+	if err != nil {
+		a.logger.Error("UpdateGroup", err)
+		c.JSON(http.StatusInternalServerError, nil)
+		return
+	}
+
+	for _, event := range groups {
+		err = a.DbHandler.UpdateGroup(event.Id, event)
+		if err != nil {
+			a.logger.Error("UpdateGroup", err)
+			c.JSON(http.StatusBadRequest, gin.H{
+				"message": err.Error(),
+			})
+			return
+		}
+	}
+	c.JSON(http.StatusOK, gin.H{
+		"message": "group(s) updated",
+	})
+}
+
+func (a *APIHandler) DeleteGroup(c *gin.Context) {
+	if !a.DBHandlerIsInitialized() {
+		a.logger.Error("DeleteGroup", "database handler is not initialized")
+		c.JSON(http.StatusInternalServerError, nil)
+		return
+	}
+
+	var err error
+
+	var request struct {
+		Ids []uint `json:"ids"`
+	}
+	err = c.BindJSON(&request)
+	if err != nil {
+		a.logger.Error("DeleteGroup", err)
+		c.JSON(http.StatusBadRequest, nil)
+		return
+	}
+
+	err = a.DbHandler.DeleteGroup(request.Ids...)
+	if err != nil {
+		a.logger.Error("DeleteGroup", err)
+		c.JSON(http.StatusBadRequest, gin.H{
+			"message": err.Error(),
+		})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{
+		"message": "group deleted",
+	})
+}

api/membersHandler.go

@@ -37,9 +37,7 @@ func (a *APIHandler) AddNewMember(c *gin.Context) {
 	if member.LastName == "" {
 		text += "lastName "
 	}
-	if member.Birthday == "" {
+
-		text += "birthday "
-	}
 	if text != "" {
 		a.logger.Error("AddNewMember", text+"can not be empty")
 		c.JSON(http.StatusBadRequest, gin.H{
@@ -93,41 +91,23 @@ func (a *APIHandler) GetMember(c *gin.Context) {
 	c.JSON(http.StatusOK, members)
 }
 
-func (a *APIHandler) EditMember(c *gin.Context) {
+func (a *APIHandler) UpdateMember(c *gin.Context) {
 	if !a.DBHandlerIsInitialized() {
 		a.logger.Error("EditMember", "database handler is not initialized")
 		c.JSON(http.StatusInternalServerError, nil)
 		return
 	}
 
-	var i int
+	var members []models.Member
-	var err error
+	err := c.BindJSON(&members)
-
-	id := c.Query("id")
-	if id != "" {
-		i, err = strconv.Atoi(id)
-		if err != nil {
-			a.logger.Error("EditMember", err)
-			c.JSON(http.StatusInternalServerError, nil)
-			return
-		}
-	} else {
-		a.logger.Error("EditMember", err)
-		c.JSON(http.StatusBadRequest, gin.H{
-			"message": "query parameter 'id' missing",
-		})
-		return
-	}
-
-	var member models.Member
-	err = c.BindJSON(&member)
 	if err != nil {
 		a.logger.Error("EditMember", err)
 		c.JSON(http.StatusInternalServerError, nil)
 		return
 	}
 
-	err = a.DbHandler.UpdateMember(i, member)
+	for _, member := range members {
+		err = a.DbHandler.UpdateMember(member.Id, member)
 		if err != nil {
 			a.logger.Error("EditMember", err)
 			c.JSON(http.StatusBadRequest, gin.H{
@@ -135,8 +115,9 @@ func (a *APIHandler) EditMember(c *gin.Context) {
 			})
 			return
 		}
+	}
 	c.JSON(http.StatusOK, gin.H{
-		"message": "member updated",
+		"message": "member(s) updated",
 	})
 }
 

api/responsibleHandler.go

@@ -16,15 +16,15 @@ func (a *APIHandler) AddNewResponsible(c *gin.Context) {
 		return
 	}
 
-	var responsible models.Person
+	var responsibles []models.Responsible
-	err := c.BindJSON(&responsible)
+	err := c.BindJSON(&responsibles)
 	if err != nil {
 		a.logger.Error("AddNewResponsible", err)
 		c.JSON(http.StatusInternalServerError, nil)
 		return
 	}
 
-	err = a.DbHandler.AddNewResponsible(responsible)
+	err = a.DbHandler.AddNewResponsible(responsibles...)
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{
 			"message": err.Error(),
@@ -33,7 +33,7 @@ func (a *APIHandler) AddNewResponsible(c *gin.Context) {
 	}
 
 	c.JSON(http.StatusOK, gin.H{
-		"message": "responsible added",
+		"message": "responsible(s) added",
 	})
 }
 

go.mod

@@ -3,7 +3,7 @@ module gitea.tecamino.com/paadi/memberDB
 go 1.24.5
 
 require (
-	gitea.tecamino.com/paadi/dbHandler v1.0.4
+	gitea.tecamino.com/paadi/dbHandler v1.1.6
 	gitea.tecamino.com/paadi/tecamino-logger v0.2.1
 	github.com/gin-contrib/cors v1.7.6
 	github.com/gin-gonic/gin v1.11.0

go.sum

@@ -1,5 +1,5 @@
-gitea.tecamino.com/paadi/dbHandler v1.0.4 h1:ctnaec0GDdtw3gRQdUISVDYLJ9x+vt50VW41OemfhD4=
+gitea.tecamino.com/paadi/dbHandler v1.1.6 h1:Mz7ioUmozXx22oV3P7GHsvQn/2QKOjkNyzdptvqbaN8=
-gitea.tecamino.com/paadi/dbHandler v1.0.4/go.mod h1:y/xn/POJg1DO++67uKvnO23lJQgh+XFQq7HZCS9Getw=
+gitea.tecamino.com/paadi/dbHandler v1.1.6/go.mod h1:y/xn/POJg1DO++67uKvnO23lJQgh+XFQq7HZCS9Getw=
 gitea.tecamino.com/paadi/tecamino-logger v0.2.1 h1:sQTBKYPdzn9mmWX2JXZBtGBvNQH7cuXIwsl4TD0aMgE=
 gitea.tecamino.com/paadi/tecamino-logger v0.2.1/go.mod h1:FkzRTldUBBOd/iy2upycArDftSZ5trbsX5Ira5OzJgM=
 github.com/bytedance/sonic v1.14.0 h1:/OfKt8HFw0kh2rj8N0F6C/qPGRESq0BbaNZgcNXXzQQ=

handlers/database.go

@@ -4,6 +4,7 @@ import (
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/hex"
+	"time"
 
 	"gitea.tecamino.com/paadi/dbHandler"
 	"gitea.tecamino.com/paadi/tecamino-logger/logging"
@@ -11,6 +12,7 @@ import (
 
 type DatabaseHandler struct {
 	database     *dbHandler.DBHandler
+	timeLocation *time.Location
 	token        []byte
 }
 
@@ -23,6 +25,14 @@ func NewDatabaseHandler(name, path string, logger *logging.Logger) (*DatabaseHan
 	return &DatabaseHandler{database: database}, nil
 }
 
+func (dH *DatabaseHandler) SetTimezone(timezone string) (err error) {
+	if timezone == "" {
+		timezone = "Local"
+	}
+	dH.timeLocation, err = time.LoadLocation(timezone)
+	return
+}
+
 func (dH *DatabaseHandler) DatabaseOpened() bool {
 	return dH.database != nil
 }

handlers/events.go

@@ -2,25 +2,23 @@ package handlers
 
 import (
 	"errors"
-	"slices"
-	"time"
 
 	"gitea.tecamino.com/paadi/memberDB/models"
+	"gitea.tecamino.com/paadi/memberDB/utils"
 )
 
-func (dh *DatabaseHandler) StartNewEvent(name string) error {
+func (dh *DatabaseHandler) StartNewEvent(event *models.Event) error {
 	if !dh.DatabaseOpened() {
 		return errors.New("database not opened")
 	}
 
-	if nil == dh.database.Exists(&models.Event{}, "name", name, false) {
+	if dh.database.Exists(&models.Event{}, "", "name", event.Name, false) {
-		return errors.New("event with name: " + name + " exists already")
+		return errors.New("event with name: " + event.Name + " exists already")
 	}
 
-	return dh.database.AddNewColum(&models.Event{
+	event.Date = utils.GetCurrentTime(dh.timeLocation)
-		Name: name,
+	event.Day = utils.GetCurrentDay(dh.timeLocation)
-		Date: time.Now().Format("2006-01-02 15:04:05"),
+	return dh.database.AddNewColum(&event)
-	})
 }
 
 func (dh *DatabaseHandler) GetEvent(id uint) (event []models.Event, err error) {
@@ -28,17 +26,20 @@ func (dh *DatabaseHandler) GetEvent(id uint) (event []models.Event, err error) {
 		return event, errors.New("database not opened")
 	}
 
-	err = dh.database.GetById(&event, id)
+	err = dh.database.GetById(&event, "Attendees", id)
 	if err != nil {
 		return
 	}
-
-	for i := range event {
-		event[i].Count = len(event[i].Attendees)
-	}
 	return
 }
 
+func (dh *DatabaseHandler) UpdateEvent(id int, event models.Event) (err error) {
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
+	}
+	return dh.database.UpdateValuesById(&event, "", uint(event.Id))
+}
+
 func (dh *DatabaseHandler) DeleteEvent(ids ...uint) error {
 	if !dh.DatabaseOpened() {
 		return errors.New("database not opened")
@@ -48,7 +49,7 @@ func (dh *DatabaseHandler) DeleteEvent(ids ...uint) error {
 		return errors.New("no ids given to be deleted")
 	}
 
-	return dh.database.DeleteById(&models.Event{}, ids...)
+	return dh.database.DeleteById(&models.Event{}, "", ids...)
 }
 
 func (dh *DatabaseHandler) AddAttendeesToEvent(newEvent models.Event) error {
@@ -57,24 +58,24 @@ func (dh *DatabaseHandler) AddAttendeesToEvent(newEvent models.Event) error {
 	}
 
 	var event models.Event
-	err := dh.database.GetById(&event, uint(event.Id))
+	err := dh.database.GetById(&event, "Attendees", uint(newEvent.Id))
 	if err != nil {
 		return err
 	}
 
 next:
 	for _, newAttendee := range newEvent.Attendees {
+		if !dh.database.Exists(&models.Member{}, "", "id", newAttendee.Id, false) {
+			continue
+		}
 		for _, attendee := range event.Attendees {
 			if attendee.FirstName == newAttendee.FirstName && attendee.LastName == newAttendee.LastName {
 				continue next
 			}
 		}
-		event.Attendees = append(event.Attendees, newAttendee)
+		dh.database.AddRelation(&event, newAttendee, "Attendees")
 	}
-
+	return nil
-	event.Count = len(event.Attendees)
-
-	return dh.database.UpdateValuesById(&event, uint(event.Id))
 }
 
 func (dh *DatabaseHandler) DeleteAttendeesFromEvent(newEvent models.Event) error {
@@ -83,17 +84,14 @@ func (dh *DatabaseHandler) DeleteAttendeesFromEvent(newEvent models.Event) error
 	}
 
 	var event models.Event
-	dh.database.GetById(&event, uint(event.Id))
+	dh.database.GetById(&event, "Attendees", uint(newEvent.Id))
 
-next:
 	for _, newAttendee := range newEvent.Attendees {
-		for i := range event.Attendees {
+		for _, a := range event.Attendees {
-			if event.Attendees[i].FirstName == newAttendee.FirstName && event.Attendees[i].LastName == newAttendee.LastName {
+			if a.FirstName == newAttendee.FirstName && a.LastName == newAttendee.LastName {
-				event.Attendees = slices.Delete(event.Attendees, i, i+1)
+				dh.database.DeleteRelation(&event, a, "Attendees")
-				continue next
 			}
 		}
 	}
-	event.Count = len(event.Attendees)
+	return nil
-	return dh.database.UpdateValuesById(&event, uint(event.Id))
 }

handlers/group.go

@@ -0,0 +1,49 @@
+package handlers
+
+import (
+	"errors"
+
+	"gitea.tecamino.com/paadi/memberDB/models"
+)
+
+func (dh *DatabaseHandler) NewGroup(group *models.Group) error {
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
+	}
+
+	if dh.database.Exists(&models.Group{}, "", "name", group.Name, false) {
+		return errors.New("group with name: " + group.Name + " exists already")
+	}
+	return dh.database.AddNewColum(&group)
+}
+
+func (dh *DatabaseHandler) GetGroup(id uint) (group []models.Group, err error) {
+	if !dh.DatabaseOpened() {
+		return group, errors.New("database not opened")
+	}
+
+	err = dh.database.GetById(&group, "", id)
+	if err != nil {
+		return
+	}
+	return
+}
+
+func (dh *DatabaseHandler) UpdateGroup(id int, group models.Group) (err error) {
+	if !dh.DatabaseOpened() {
+		return errors.New("database not opened")
+	}
+	return dh.database.UpdateValuesById(&group, "", uint(group.Id))
+}
+
+func (dh *DatabaseHandler) DeleteGroup(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")
+	}
+
+	return dh.database.DeleteById(&models.Group{}, "", ids...)
+}

handlers/members.go

@@ -3,7 +3,6 @@ package handlers
 import (
 	"errors"
 	"fmt"
-	"time"
 
 	"gitea.tecamino.com/paadi/memberDB/crypto"
 	"gitea.tecamino.com/paadi/memberDB/models"
@@ -25,92 +24,21 @@ func (dh *DatabaseHandler) AddNewMember(members ...models.Member) error {
 			return fmt.Errorf("member %s %s %s exists already", member.FirstName, member.LastName, member.Birthday)
 		}
 
-		encFirstName, err := crypto.Encrypt(member.FirstName, dh.token)
-		if err != nil {
-			return err
-		}
-
-		encLastName, err := crypto.Encrypt(member.LastName, dh.token)
-		if err != nil {
-			return err
-		}
-
 		//check correct birtday format
 		if member.Birthday != "" && !utils.IsValidBirthday(member.Birthday) {
 			return errors.New("incorrect birthday format")
 		}
 
-		encBirthday, err := crypto.Encrypt(member.Birthday, dh.token)
-		if err != nil {
-			return err
-		}
-
-		encAddress, err := crypto.Encrypt(member.Address, dh.token)
-		if err != nil {
-			return err
-		}
-
-		encZip, err := crypto.Encrypt(member.Zip, dh.token)
-		if err != nil {
-			return err
-		}
-
-		encTown, err := crypto.Encrypt(member.Town, dh.token)
-		if err != nil {
-			return err
-		}
-
-		encPhone, err := crypto.Encrypt(member.Phone, dh.token)
-		if err != nil {
-			return err
-		}
-
 		//check correct email format
 		if member.Email != "" && !utils.IsValidEmail(member.Email) {
 			return errors.New("incorrect email format")
 		}
 
-		encEmail, err := crypto.Encrypt(member.Email, dh.token)
+		now := utils.GetCurrentTime(dh.timeLocation)
-		if err != nil {
+		member.FirstVisit = now
-			return err
+		member.LastVisit = now
-		}
 
-		now := time.Now().Format("2006-01-02 15:04:05")
+		member.Encrypt(dh.token)
-		encFirstVisit, err := crypto.Encrypt(now, dh.token)
-		if err != nil {
-			return err
-		}
-
-		encLastVisit, err := crypto.Encrypt(now, dh.token)
-		if err != nil {
-			return err
-		}
-
-		encGroup, err := crypto.Encrypt(member.Group, dh.token)
-		if err != nil {
-			return err
-		}
-
-		encResponsiblePerson, err := crypto.Encrypt(member.ResponsiblePerson, dh.token)
-		if err != nil {
-			return err
-		}
-
-		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 {
@@ -129,7 +57,7 @@ func (dh *DatabaseHandler) DeleteMember(ids ...uint) error {
 	if len(ids) == 0 {
 		return errors.New("no ids given to be deleted")
 	}
-	return dh.database.DeleteById(&models.Member{}, ids...)
+	return dh.database.DeleteById(&models.Member{}, "", ids...)
 }
 
 // GetMember returns one member by given id
@@ -138,70 +66,14 @@ func (dh *DatabaseHandler) GetMember(id uint) (members []models.Member, err erro
 		return members, errors.New("database not opened")
 	}
 
-	err = dh.database.GetById(&members, id)
+	err = dh.database.GetById(&members, "", id)
 	if err != nil {
 		return
 	}
 
 	for i := range members {
-		members[i].FirstName, err = crypto.Decrypt(members[i].FirstName, dh.token)
+		if err := members[i].Decrypt(dh.token); err != nil {
-		if err != nil {
+			return members, err
-			return
-		}
-
-		members[i].LastName, err = crypto.Decrypt(members[i].LastName, dh.token)
-		if err != nil {
-			return
-		}
-
-		members[i].Birthday, err = crypto.Decrypt(members[i].Birthday, dh.token)
-		if err != nil {
-			return
-		}
-
-		members[i].Address, err = crypto.Decrypt(members[i].Address, dh.token)
-		if err != nil {
-			return
-		}
-
-		members[i].Zip, err = crypto.Decrypt(members[i].Zip, dh.token)
-		if err != nil {
-			return
-		}
-
-		members[i].Town, err = crypto.Decrypt(members[i].Town, dh.token)
-		if err != nil {
-			return
-		}
-
-		members[i].Phone, err = crypto.Decrypt(members[i].Phone, dh.token)
-		if err != nil {
-			return
-		}
-
-		members[i].Email, err = crypto.Decrypt(members[i].Email, dh.token)
-		if err != nil {
-			return
-		}
-
-		members[i].FirstVisit, err = crypto.Decrypt(members[i].FirstVisit, dh.token)
-		if err != nil {
-			return
-		}
-
-		members[i].LastVisit, err = crypto.Decrypt(members[i].LastVisit, dh.token)
-		if err != nil {
-			return
-		}
-
-		members[i].Group, err = crypto.Decrypt(members[i].Group, dh.token)
-		if err != nil {
-			return
-		}
-
-		members[i].ResponsiblePerson, err = crypto.Decrypt(members[i].ResponsiblePerson, dh.token)
-		if err != nil {
-			return
 		}
 	}
 	return
@@ -292,20 +164,13 @@ func (dh *DatabaseHandler) UpdateMember(id int, member models.Member) (err error
 		}
 	}
 
-	if member.Group != "" {
+	if member.Comment != "" {
-		member.Group, err = crypto.Encrypt(member.Group, dh.token)
+		member.Comment, err = crypto.Encrypt(member.Comment, dh.token)
 		if err != nil {
 			return err
 		}
 	}
-
+	return dh.database.UpdateValuesById(&member, "", uint(member.Id))
-	if member.ResponsiblePerson != "" {
-		member.ResponsiblePerson, err = crypto.Encrypt(member.ResponsiblePerson, dh.token)
-		if err != nil {
-			return err
-		}
-	}
-	return dh.database.UpdateValuesById(&member, uint(member.Id))
 }
 
 // memberExists helper to check wheter member already exists
@@ -314,10 +179,16 @@ func (dh *DatabaseHandler) memberExists(checkMember models.Member) (bool, error)
 		return false, errors.New("database not opened")
 	}
 
-	var member models.Member
+	var members []models.Member
-	err := dh.database.Exists(&member, "birthdayHash", dh.hashField(checkMember.Birthday), false)
+	if !dh.database.Exists(&members, "", "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
+
+	for _, member := range members {
+		if dh.hashField(checkMember.FirstName) == member.FirstNameHash && dh.hashField(checkMember.LastName) == member.LastNameHash && dh.hashField(checkMember.Birthday) == member.BirthdayHash {
+			return true, nil
+		}
+	}
+
+	return false, nil
 }

handlers/responsible.go

@@ -6,36 +6,62 @@ import (
 	"gitea.tecamino.com/paadi/memberDB/models"
 )
 
-func (dh *DatabaseHandler) AddNewResponsible(responsibles ...models.Person) error {
+func (dh *DatabaseHandler) AddNewResponsible(responsibles ...models.Responsible) 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)
+next:
-		if err != nil {
+	for _, r := range responsibles {
-			return err
+		if r.MemberId == 0 && r.Id != 0 {
-		} else if exists {
+			r.MemberId = r.Id
+			r.Id = 0
+		}
+
+		//check if member exists
+		if !dh.database.Exists(&models.Member{}, "", "id", &r.MemberId, false) {
 			continue
 		}
+		// check if already exists
+		var oldResponsibles models.Responsibles
+		err := dh.database.GetById(&oldResponsibles, "Member", 0)
+		if err != nil {
+			return err
+		}
 
-		err = dh.database.AddNewColum(&responsible)
+		for _, oldR := range oldResponsibles {
+			if oldR.Member == nil {
+				continue
+			} else if oldR.Member.Id == int(r.MemberId) {
+				continue next
+			}
+		}
+
+		err = dh.database.AddNewColum(&r)
 		if err != nil {
 			return err
 		}
 	}
+
 	return nil
 }
 
-func (dh *DatabaseHandler) GetResponsible(id uint) (persons []models.Person, err error) {
+func (dh *DatabaseHandler) GetResponsible(id uint) (members []models.Member, err error) {
 	if !dh.DatabaseOpened() {
-		return persons, errors.New("database not opened")
+		return members, errors.New("database not opened")
 	}
 
-	err = dh.database.GetById(&persons, id)
+	var responsibles models.Responsibles
+	err = dh.database.GetById(&responsibles, "Member", id)
+
+	for _, r := range responsibles {
+
+		err := r.Member.Decrypt(dh.token)
+		if err != nil {
+			return members, err
+		}
+		members = append(members, *r.Member)
+	}
 	return
 }
 
@@ -47,18 +73,5 @@ func (dh *DatabaseHandler) DeleteResponsible(ids ...uint) error {
 	if len(ids) == 0 {
 		return errors.New("no ids given to be deleted")
 	}
-	return dh.database.DeleteById(&models.Person{}, ids...)
+	return dh.database.DeleteById(&models.Responsible{}, "", ids...)
-}
-
-func (dh *DatabaseHandler) responsibleExists(CheckResponsible models.Person) (bool, error) {
-	if !dh.DatabaseOpened() {
-		return false, errors.New("database not opened")
-	}
-
-	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
 }

member_test.go

@@ -44,7 +44,7 @@ func TestErrors(t *testing.T) {
 
 	v1.POST("/database/open", apiHandler.OpenDatabase)
 	v1.POST("/members/add", apiHandler.AddNewMember)
-	v1.POST("/members/edit", apiHandler.EditMember)
+	v1.POST("/members/edit", apiHandler.UpdateMember)
 	v1.POST("/members/delete", apiHandler.DeleteMember)
 	v1.POST("/members/import/csv", apiHandler.ImportCSV)
 
@@ -129,19 +129,20 @@ func TestMemberDB(t *testing.T) {
 
 	v1 := r.Group("v1")
 	v1.GET("/events", apiHandler.GetEvent)
-	v1.GET("/events/new", apiHandler.StartNewEvent)
-	v1.GET("/events/delete", apiHandler.DeleteEvent)
 	v1.GET("/members", apiHandler.GetMember)
 	v1.GET("/responsible", apiHandler.GetResponsible)
 
 	v1.POST("/database/open", apiHandler.OpenDatabase)
 	v1.POST("/members/add", apiHandler.AddNewMember)
-	v1.POST("/members/edit", apiHandler.EditMember)
+	v1.POST("/members/edit", apiHandler.UpdateMember)
 	v1.POST("/members/delete", apiHandler.DeleteMember)
 	v1.POST("/members/import/csv", apiHandler.ImportCSV)
 
+	v1.POST("/events/new", apiHandler.StartNewEvent)
 	v1.POST("/events/attendees/add", apiHandler.AddNewAttendees)
 	v1.POST("/events/attendees/delete", apiHandler.DeleteAttendee)
+	v1.POST("/events/edit", apiHandler.UpdateEvent)
+	v1.POST("/events/delete", apiHandler.DeleteEvent)
 
 	v1.POST("/responsible/add", apiHandler.AddNewResponsible)
 	v1.POST("/responsible/delete", apiHandler.DeleteResponsible)
@@ -174,22 +175,23 @@ func TestMemberDB(t *testing.T) {
 		request{Log: "add existing member", Name: "add existing member", Method: "POST", Path: "/v1/members/add", Payload: payload{FirstName: "Adrian", LastName: "Zürcher", Birthday: "23.06.1987"}, ignoreError: true},
 		request{Log: "add new member", Name: "add new member", Method: "POST", Path: "/v1/members/add", Payload: payload{FirstName: "Paulina", LastName: "Zürcher", Birthday: "15.01.1991"}},
 		request{Log: "get members", Name: "get members", Method: "GET", Path: "/v1/members"},
-		request{Log: "update members", Name: "update members", Method: "POST", Path: "/v1/members/edit?id=1", Payload: payload{Group: "testGroup"}},
+		request{Log: "update members", Name: "update members", Method: "POST", Path: "/v1/members/edit?id=1", Payload: []models.Member{{Group: &models.Group{Name: "testGroup"}}}},
 		request{Log: "get again members", Name: "get again members", Method: "GET", Path: "/v1/members"},
-		request{Log: "delete members", Name: "delete members", Method: "POST", Path: "/v1/members/delete", Payload: payload{Ids: []uint{2, 1}}},
+		//request{Log: "delete members", Name: "delete members", Method: "POST", Path: "/v1/members/delete", Payload: payload{Ids: []uint{2, 1}}},
 		request{Log: "get again members", Name: "get again members", Method: "GET", Path: "/v1/members"},
 
-		request{Log: "new event", Name: "new event", Method: "GET", Path: "/v1/events/new?name=testEvent"},
+		request{Log: "new event", Name: "new event", Method: "POST", Path: "/v1/events/new", Payload: models.Event{Name: "testEvent"}},
-		request{Log: "add new attendee", Name: "add new attendee", Method: "POST", Path: "/v1/events/attendees/add", Payload: models.Event{Attendees: models.Persons{{FirstName: "Adi", LastName: "Züri"}}}},
+		request{Log: "add new attendee", Name: "add new attendee", Method: "POST", Path: "/v1/events/attendees/add", Payload: models.Event{Attendees: []*models.Member{{Id: 26}}}},
-		request{Log: "add another attendee", Name: "add another attendee", Method: "POST", Path: "/v1/events/attendees/add", Payload: models.Event{Attendees: models.Persons{{FirstName: "Pau", LastName: "Züri"}}}},
+		request{Log: "add another attendee", Name: "add another attendee", Method: "POST", Path: "/v1/events/attendees/add", Payload: models.Event{Attendees: []*models.Member{{Id: 2}}}},
 		request{Log: "get events", Name: "get events", Method: "GET", Path: "/v1/events"},
-		request{Log: "add delete attendee", Name: "add delete attendee", Method: "POST", Path: "/v1/events/attendees/delete", Payload: models.Event{Attendees: models.Persons{{FirstName: "Adi", LastName: "Züri"}}}},
+		//request{Log: "delete attendee", Name: "add delete attendee", Method: "POST", Path: "/v1/events/attendees/delete", Payload: models.Event{Attendees: []*models.Member{{FirstName: "Adi", LastName: "Züri"}}}},
 		request{Log: "get events", Name: "get events", Method: "GET", Path: "/v1/events"},
 
-		request{Log: "add responsible", Name: "add responsible", Method: "POST", Path: "/v1/responsible/add", Payload: models.Person{FirstName: "Max", LastName: "Muster"}},
+		//request{Log: "add responsible", Name: "add responsible", Method: "POST", Path: "/v1/responsible/add", Payload: models.Responsibles{models.Responsible{Member: &models.Member{FirstName: "Adi", LastName: "Züri"}}}},
-		request{Log: "add another responsible", Name: "add another responsible", Method: "POST", Path: "/v1/responsible/add", Payload: models.Person{FirstName: "Hausi", LastName: "Muster"}},
+		request{Log: "add another responsible", Name: "add another responsible", Method: "POST", Path: "/v1/responsible/add", Payload: models.Responsibles{models.Responsible{MemberId: 1}}},
+		request{Log: "add another responsible", Name: "add another responsible", Method: "POST", Path: "/v1/responsible/add", Payload: models.Responsibles{models.Responsible{MemberId: 25}}},
 		request{Log: "get responsible", Name: "get responsible", Method: "GET", Path: "/v1/responsible"},
-		request{Log: "delete responsible id 1", Name: "delete responsible id 1", Method: "POST", Path: "/v1/responsible/delete", Payload: payload{Ids: []uint{1}}},
+		//request{Log: "delete responsible id 1", Name: "delete responsible id 1", Method: "POST", Path: "/v1/responsible/delete", Payload: payload{Ids: []uint{1}}},
 		request{Log: "get responsible", Name: "get responsible", Method: "GET", Path: "/v1/responsible"},
 	)
 

models/event.go

@@ -4,6 +4,6 @@ type Event struct {
 	Id        int       `gorm:"primaryKey" json:"id"`
 	Name      string    `gorm:"column:name" json:"name"`
 	Date      string    `gorm:"column:date" json:"date"`
-	Attendees Persons `gorm:"type:json" json:"attendees"`
+	Day       string    `gorm:"column:day" json:"day"`
-	Count     int     `gorm:"column:count" json:"count"`
+	Attendees []*Member `gorm:"many2many:member_events;"`
 }

models/group.go

@@ -0,0 +1,6 @@
+package models
+
+type Group struct {
+	Id   int    `gorm:"primaryKey" json:"id"`
+	Name string `gorm:"column:name" json:"name"`
+}

models/member.go

@@ -1,7 +1,12 @@
 package models
 
+import (
+	"gitea.tecamino.com/paadi/memberDB/crypto"
+	"gitea.tecamino.com/paadi/memberDB/utils"
+)
+
 type Member struct {
-	Id                int    `gorm:"primaryKey" json:"id"`
+	Id            int      `gorm:"primaryKey" json:"id,omitempty"`
 	FirstName     string   `gorm:"column:firstName" json:"firstName,omitempty"`
 	FirstNameHash string   `gorm:"column:firstNameHash" json:"-"`
 	LastName      string   `gorm:"column:lastName" json:"lastName,omitempty"`
@@ -15,6 +20,153 @@ type Member struct {
 	Email         string   `gorm:"column:email" json:"email,omitempty"`
 	FirstVisit    string   `gorm:"column:firstVisit" json:"firstVisit,omitempty"`
 	LastVisit     string   `gorm:"column:lastVisit" json:"lastVisit,omitempty"`
-	Group             string `gorm:"column:group" json:"group,omitempty"`
+	GroupId       *int     `json:"GroupId,omitempty"`
-	ResponsiblePerson string `gorm:"column:responsiblePerson" json:"responsiblePerson,omitempty"`
+	Group         *Group   `gorm:"foreignKey:GroupId" json:"group,omitempty"`
+	ResponsibleId *int     `json:"ResponsibleId,omitempty"`
+	Responsible   *Member  `gorm:"foreignKey:ResponsibleId" json:"responsible,omitempty"`
+	Comment       string   `gorm:"column:comment" json:"comment,omitempty"`
+	Events        []*Event `gorm:"many2many:member_events;" `
+}
+
+func (m *Member) Encrypt(token []byte) (err error) {
+
+	m.FirstNameHash = utils.HashField(m.FirstName, token)
+	m.FirstName, err = crypto.Encrypt(m.FirstName, token)
+	if err != nil {
+		return
+	}
+
+	m.LastNameHash = utils.HashField(m.LastName, token)
+	m.LastName, err = crypto.Encrypt(m.LastName, token)
+	if err != nil {
+		return
+	}
+
+	m.BirthdayHash = utils.HashField(m.Birthday, token)
+	m.Birthday, err = crypto.Encrypt(m.Birthday, token)
+	if err != nil {
+		return
+	}
+
+	m.Address, err = crypto.Encrypt(m.Address, token)
+	if err != nil {
+		return
+	}
+
+	m.Zip, err = crypto.Encrypt(m.Zip, token)
+	if err != nil {
+		return
+	}
+
+	m.Town, err = crypto.Encrypt(m.Town, token)
+	if err != nil {
+		return
+	}
+
+	m.Phone, err = crypto.Encrypt(m.Phone, token)
+	if err != nil {
+		return
+	}
+
+	m.Email, err = crypto.Encrypt(m.Email, token)
+	if err != nil {
+		return
+	}
+
+	m.FirstVisit, err = crypto.Encrypt(m.FirstVisit, token)
+	if err != nil {
+		return
+	}
+
+	m.LastVisit, err = crypto.Encrypt(m.LastVisit, token)
+	if err != nil {
+		return
+	}
+
+	m.Comment, err = crypto.Encrypt(m.Comment, token)
+	if err != nil {
+		return
+	}
+	return
+}
+
+func (m *Member) Decrypt(token []byte) (err error) {
+
+	if m.FirstName != "" {
+		m.FirstName, err = crypto.Decrypt(m.FirstName, token)
+		if err != nil {
+			return
+		}
+	}
+
+	if m.LastName != "" {
+		m.LastName, err = crypto.Decrypt(m.LastName, token)
+		if err != nil {
+			return
+		}
+	}
+
+	if m.Birthday != "" {
+		m.Birthday, err = crypto.Decrypt(m.Birthday, token)
+		if err != nil {
+			return
+		}
+	}
+
+	if m.Address != "" {
+		m.Address, err = crypto.Decrypt(m.Address, token)
+		if err != nil {
+			return
+		}
+	}
+
+	if m.Zip != "" {
+		m.Zip, err = crypto.Decrypt(m.Zip, token)
+		if err != nil {
+			return
+		}
+	}
+
+	if m.Town != "" {
+		m.Town, err = crypto.Decrypt(m.Town, token)
+		if err != nil {
+			return
+		}
+	}
+
+	if m.Phone != "" {
+		m.Phone, err = crypto.Decrypt(m.Phone, token)
+		if err != nil {
+			return
+		}
+	}
+
+	if m.Email != "" {
+		m.Email, err = crypto.Decrypt(m.Email, token)
+		if err != nil {
+			return
+		}
+	}
+
+	if m.FirstVisit != "" {
+		m.FirstVisit, err = crypto.Decrypt(m.FirstVisit, token)
+		if err != nil {
+			return
+		}
+	}
+
+	if m.LastVisit != "" {
+		m.LastVisit, err = crypto.Decrypt(m.LastVisit, token)
+		if err != nil {
+			return
+		}
+	}
+
+	if m.Comment != "" {
+		m.Comment, err = crypto.Decrypt(m.Comment, token)
+		if err != nil {
+			return
+		}
+	}
+	return
 }

models/person.go

@@ -1,29 +0,0 @@
-package models
-
-import (
-	"database/sql/driver"
-	"encoding/json"
-	"fmt"
-)
-
-type Persons []Person
-
-type Person struct {
-	Id        int    `gorm:"primaryKey" json:"id"`
-	FirstName string `gorm:"column:firstName" json:"firstName"`
-	LastName  string `gorm:"column:lastName" json:"lastName"`
-}
-
-// --- Implement driver.Valuer (for saving to DB)
-func (r Persons) Value() (driver.Value, error) {
-	return json.Marshal(r)
-}
-
-// --- Implement sql.Scanner (for reading from DB)
-func (r *Persons) Scan(value any) error {
-	bytes, ok := value.([]byte)
-	if !ok {
-		return fmt.Errorf("failed to unmarshal Settings: %v", value)
-	}
-	return json.Unmarshal(bytes, r)
-}

models/responsible.go

@@ -0,0 +1,9 @@
+package models
+
+type Responsible struct {
+	Id       uint `gorm:"primaryKey"`
+	MemberId uint
+	Member   *Member `gorm:"foreignKey:MemberId"`
+}
+
+type Responsibles []Responsible

utils/utils.go

@@ -1,6 +1,10 @@
 package utils
 
 import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
 	"net/mail"
 	"time"
 )
@@ -25,3 +29,17 @@ func IsValidBirthday(birthday string) bool {
 	}
 	return false
 }
+
+func GetCurrentTime(loc *time.Location) string {
+	return time.Now().In(loc).Format("2006-01-02 15:04:05")
+}
+
+func GetCurrentDay(loc *time.Location) string {
+	return fmt.Sprint(time.Now().In(loc).Weekday())
+}
+
+func HashField(field string, token []byte) string {
+	h := hmac.New(sha256.New, token)
+	h.Write([]byte(field))
+	return hex.EncodeToString(h.Sum(nil))
+}