update report function

api/reportHandler.go

@@ -0,0 +1,137 @@
+package api
+
+import (
+	"net/http"
+	"slices"
+	"strings"
+
+	"gitea.tecamino.com/paadi/memberDB/models"
+	"github.com/gin-gonic/gin"
+)
+
+type counter struct {
+	event int
+	total int
+}
+
+func (a *APIHandler) GetReport(c *gin.Context) {
+	if !a.DBHandlerIsInitialized() {
+		a.logger.Error("GetReport", "database handler is not initialized")
+		c.JSON(http.StatusInternalServerError, nil)
+		return
+	}
+
+	var err error
+	var report models.Report
+	var request models.ReportFilter
+
+	err = c.BindJSON(&request)
+	if err != nil {
+		a.logger.Error("GetReport", err)
+		c.JSON(http.StatusBadRequest, nil)
+		return
+	}
+
+	if len(request.Date) == 0 {
+		c.JSON(http.StatusOK, gin.H{
+			"data": report,
+		})
+		return
+	}
+
+	var events []models.Event
+
+	if len(request.Name) > 0 {
+		events, err = a.DbHandler.GetEventByKey("name", request.Name, true)
+	} else {
+		events, err = a.DbHandler.GetEvent(0)
+	}
+
+	if err != nil {
+		a.logger.Error("GetReport", err)
+		c.JSON(http.StatusBadRequest, gin.H{
+			"message": err.Error(),
+		})
+		return
+	}
+
+	report.Data = make(map[string]*models.Data)
+
+	//helper
+	count := make(map[string]*counter)
+
+	addedMember := make(map[uint]bool)
+
+	if len(events) == 0 {
+		c.JSON(http.StatusOK, gin.H{})
+		return
+	}
+
+	for _, e := range events {
+
+		for _, d := range request.Date {
+			if !strings.Contains(e.Date, d) {
+				continue
+			}
+		}
+
+		var data *models.Data
+		if _, ok := count[e.Day]; !ok {
+			count[e.Day] = &counter{}
+		}
+		count[e.Day].event += 1
+
+		data, ok := report.Data[e.Day]
+		if !ok {
+			data = &models.Data{}
+			report.Data[e.Day] = data
+		}
+
+		if data.Minimal > len(e.Attendees) {
+			data.Minimal = len(e.Attendees)
+		}
+
+		if data.Maximal < len(e.Attendees) {
+			data.Maximal = len(e.Attendees)
+		}
+
+		count[e.Day].total = +len(e.Attendees)
+		data.Average = count[e.Day].total / count[e.Day].event
+
+		for _, a := range e.Attendees {
+			if _, ok := addedMember[a.Id]; ok {
+				continue
+			}
+			report.Attendees = append(report.Attendees, a)
+			addedMember[a.Id] = true
+		}
+	}
+
+	// add all member not attended
+	members, err := a.DbHandler.GetMember(0)
+	if err != nil {
+		a.logger.Error("GetReport", err)
+		c.JSON(http.StatusBadRequest, gin.H{
+			"message": err.Error(),
+		})
+		return
+	}
+
+	for _, m := range members {
+		if _, ok := addedMember[m.Id]; ok {
+			continue
+		} else if len(request.Groups) > 0 {
+			if m.Group == nil {
+				continue
+			} else if !slices.Contains(request.Groups, m.Group.Id) {
+				continue
+			}
+
+		}
+		report.NonAttendees = append(report.NonAttendees, &m)
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"data": report,
+	})
+}

api/responsibleHandler.go

@@ -56,7 +56,7 @@ func (a *APIHandler) GetResponsible(c *gin.Context) {
 		}
 	}
 
-	members, err := a.DbHandler.GetResponsible(uint(i))
+	responsibles, err := a.DbHandler.GetResponsible(uint(i))
 	if err != nil {
 		a.logger.Error("GetResponsible", err)
 		c.JSON(http.StatusBadRequest, gin.H{
@@ -64,7 +64,7 @@ func (a *APIHandler) GetResponsible(c *gin.Context) {
 		})
 		return
 	}
-	c.JSON(http.StatusOK, members)
+	c.JSON(http.StatusOK, responsibles)
 }
 
 func (a *APIHandler) DeleteResponsible(c *gin.Context) {

go.mod

@@ -1,9 +1,9 @@
 module gitea.tecamino.com/paadi/memberDB
 
-go 1.24.5
+go 1.25.4
 
 require (
-	gitea.tecamino.com/paadi/dbHandler v1.1.6
+	gitea.tecamino.com/paadi/dbHandler v1.1.10
 	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.1.6 h1:Mz7ioUmozXx22oV3P7GHsvQn/2QKOjkNyzdptvqbaN8=
-gitea.tecamino.com/paadi/dbHandler v1.1.6/go.mod h1:y/xn/POJg1DO++67uKvnO23lJQgh+XFQq7HZCS9Getw=
+gitea.tecamino.com/paadi/dbHandler v1.1.10 h1:zZQbDTJ0bu6CIW90Zms8yYIzTLHtWPNhVKRxLUXEDuE=
+gitea.tecamino.com/paadi/dbHandler v1.1.10/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/events.go

@@ -12,21 +12,51 @@ func (dh *DatabaseHandler) StartNewEvent(event *models.Event) error {
 		return errors.New("database not opened")
 	}
 
-	if dh.database.Exists(&models.Event{}, "", "name", event.Name, false) {
-		return errors.New("event with name: " + event.Name + " exists already")
-	}
-
 	event.Date = utils.GetCurrentTime(dh.timeLocation)
 	event.Day = utils.GetCurrentDay(dh.timeLocation)
 	return dh.database.AddNewColum(&event)
 }
 
-func (dh *DatabaseHandler) GetEvent(id uint) (event []models.Event, err error) {
+func (dh *DatabaseHandler) GetEvent(id uint) (events []models.Event, err error) {
 	if !dh.DatabaseOpened() {
-		return event, errors.New("database not opened")
+		return events, errors.New("database not opened")
 	}
 
-	err = dh.database.GetById(&event, "Attendees", id)
+	err = dh.database.GetById(&events, id, "Attendees")
+
+	idMap := make(map[uint]bool)
+	for i := range events {
+		for j := range events[i].Attendees {
+			if _, ok := idMap[events[i].Attendees[j].Id]; ok {
+				continue
+			}
+			idMap[events[i].Attendees[j].Id] = true
+			events[i].Attendees[j].Decrypt(dh.token)
+		}
+	}
+	if err != nil {
+		return
+	}
+	return
+}
+
+func (dh *DatabaseHandler) GetEventByKey(key string, value any, likeSearch bool) (events []models.Event, err error) {
+	if !dh.DatabaseOpened() {
+		return events, errors.New("database not opened")
+	}
+
+	err = dh.database.GetByKey(&events, key, value, likeSearch, "Attendees")
+
+	idMap := make(map[uint]bool)
+	for i := range events {
+		for j := range events[i].Attendees {
+			if _, ok := idMap[events[i].Attendees[j].Id]; ok {
+				continue
+			}
+			idMap[events[i].Attendees[j].Id] = true
+			events[i].Attendees[j].Decrypt(dh.token)
+		}
+	}
 	if err != nil {
 		return
 	}
@@ -37,7 +67,14 @@ 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))
+
+	if event.Date != "" {
+		event.Day, err = utils.GetDayFromDate(event.Date)
+		if err != nil {
+			return err
+		}
+	}
+	return dh.database.UpdateValuesById(&event, uint(event.Id))
 }
 
 func (dh *DatabaseHandler) DeleteEvent(ids ...uint) error {
@@ -58,14 +95,14 @@ func (dh *DatabaseHandler) AddAttendeesToEvent(newEvent models.Event) error {
 	}
 
 	var event models.Event
-	err := dh.database.GetById(&event, "Attendees", uint(newEvent.Id))
+	err := dh.database.GetById(&event, uint(newEvent.Id), "Attendees")
 	if err != nil {
 		return err
 	}
 
 next:
 	for _, newAttendee := range newEvent.Attendees {
-		if !dh.database.Exists(&models.Member{}, "", "id", newAttendee.Id, false) {
+		if !dh.database.Exists(&models.Member{}, "id", newAttendee.Id, false) {
 			continue
 		}
 		for _, attendee := range event.Attendees {
@@ -84,10 +121,11 @@ func (dh *DatabaseHandler) DeleteAttendeesFromEvent(newEvent models.Event) error
 	}
 
 	var event models.Event
-	dh.database.GetById(&event, "Attendees", uint(newEvent.Id))
+	dh.database.GetById(&event, uint(newEvent.Id), "Attendees")
 
 	for _, newAttendee := range newEvent.Attendees {
 		for _, a := range event.Attendees {
+			a.Decrypt(dh.token)
 			if a.FirstName == newAttendee.FirstName && a.LastName == newAttendee.LastName {
 				dh.database.DeleteRelation(&event, a, "Attendees")
 			}

handlers/group.go

@@ -11,7 +11,7 @@ func (dh *DatabaseHandler) NewGroup(group *models.Group) error {
 		return errors.New("database not opened")
 	}
 
-	if dh.database.Exists(&models.Group{}, "", "name", group.Name, false) {
+	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)
@@ -22,18 +22,18 @@ func (dh *DatabaseHandler) GetGroup(id uint) (group []models.Group, err error) {
 		return group, errors.New("database not opened")
 	}
 
-	err = dh.database.GetById(&group, "", id)
+	err = dh.database.GetById(&group, id)
 	if err != nil {
 		return
 	}
 	return
 }
 
-func (dh *DatabaseHandler) UpdateGroup(id int, group models.Group) (err error) {
+func (dh *DatabaseHandler) UpdateGroup(id uint, group models.Group) (err error) {
 	if !dh.DatabaseOpened() {
 		return errors.New("database not opened")
 	}
-	return dh.database.UpdateValuesById(&group, "", uint(group.Id))
+	return dh.database.UpdateValuesById(&group, uint(group.Id))
 }
 
 func (dh *DatabaseHandler) DeleteGroup(ids ...uint) error {

handlers/members.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 
-	"gitea.tecamino.com/paadi/memberDB/crypto"
 	"gitea.tecamino.com/paadi/memberDB/models"
 	"gitea.tecamino.com/paadi/memberDB/utils"
 )
@@ -66,111 +65,54 @@ 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, "Group", "Responsible", "Responsible.Member", "Events")
 	if err != nil {
 		return
 	}
 
+	//map for list all decrypted members so it only once derypt each member
+	decryptedList := make(map[uint]bool, 1)
 	for i := range members {
 		if err := members[i].Decrypt(dh.token); err != nil {
 			return members, err
 		}
+		if members[i].Responsible != nil {
+			//check if already decrypted
+			if decryptedList[members[i].Responsible.Member.Id] {
+				continue
+			}
+			members[i].Responsible.Member.Decrypt(dh.token)
+			decryptedList[members[i].Responsible.Member.Id] = true
+		}
 	}
 	return
 }
 
 // UpdateMember updates/overrides all information given meber id
-func (dh *DatabaseHandler) UpdateMember(id int, member models.Member) (err error) {
+func (dh *DatabaseHandler) UpdateMember(id uint, member models.Member) (err error) {
 	if !dh.DatabaseOpened() {
 		return errors.New("database not opened")
 	}
 
-	if member.FirstName != "" {
-		member.FirstNameHash = dh.hashField(member.FirstName)
-		member.FirstName, err = crypto.Encrypt(member.FirstName, dh.token)
-		if err != nil {
-			return
-		}
-	}
-
-	if member.LastName != "" {
-		member.LastNameHash = dh.hashField(member.LastName)
-		member.LastName, err = crypto.Encrypt(member.LastName, dh.token)
-		if err != nil {
-			return
-		}
-	}
-
 	//check correct birtday format
-	if member.Birthday != "" && utils.IsValidBirthday(member.Birthday) {
-		member.BirthdayHash = dh.hashField(member.BirthdayHash)
-		member.Birthday, err = crypto.Encrypt(member.Birthday, dh.token)
-		if err != nil {
-			return err
-		}
-	} else if member.Birthday != "" {
+	if member.Birthday != "" && !utils.IsValidBirthday(member.Birthday) {
 		return errors.New("incorrect birthday format")
 	}
 
-	if member.Address != "" {
-		member.Address, err = crypto.Encrypt(member.Address, dh.token)
-		if err != nil {
-			return err
-		}
-	}
-
-	if member.Zip != "" {
-		member.Zip, err = crypto.Encrypt(member.Zip, dh.token)
-		if err != nil {
-			return err
-		}
-	}
-
-	if member.Town != "" {
-		member.Town, err = crypto.Encrypt(member.Town, dh.token)
-		if err != nil {
-			return err
-		}
-	}
-
-	if member.Phone != "" {
-		member.Phone, err = crypto.Encrypt(member.Phone, dh.token)
-		if err != nil {
-			return err
-		}
-	}
-
 	//check correct email format
-	if member.Email != "" && utils.IsValidEmail(member.Email) {
-		member.Email, err = crypto.Encrypt(member.Email, dh.token)
-		if err != nil {
-			return err
-		}
-	} else if member.Email != "" {
+	if member.Email != "" && !utils.IsValidEmail(member.Email) {
 		return errors.New("incorrect email format")
 	}
 
-	if member.FirstVisit != "" {
-		member.FirstVisit, err = crypto.Encrypt(member.FirstVisit, dh.token)
-		if err != nil {
-			return err
-		}
+	if member.Group != nil {
+		member.GroupId = &member.Group.Id
 	}
 
-	if member.LastVisit != "" {
-		member.LastVisit, err = crypto.Encrypt(member.LastVisit, dh.token)
-		if err != nil {
-			return err
-		}
+	if member.Responsible != nil {
+		member.ResponsibleId = &member.Responsible.Id
 	}
-
-	if member.Comment != "" {
-		member.Comment, err = crypto.Encrypt(member.Comment, dh.token)
-		if err != nil {
-			return err
-		}
-	}
-	return dh.database.UpdateValuesById(&member, "", uint(member.Id))
+	member.Encrypt(dh.token)
+	return dh.database.UpdateValuesById(&member, uint(member.Id), "Group", "Responsible", "Responsible.Member")
 }
 
 // memberExists helper to check wheter member already exists
@@ -180,7 +122,7 @@ func (dh *DatabaseHandler) memberExists(checkMember models.Member) (bool, error)
 	}
 
 	var members []models.Member
-	if !dh.database.Exists(&members, "", "birthdayHash", dh.hashField(checkMember.Birthday), false) {
+	if !dh.database.Exists(&members, "birthdayHash", dh.hashField(checkMember.Birthday), false) {
 		return false, nil
 	}
 

handlers/report.go

@@ -0,0 +1,99 @@
+package handlers
+
+import (
+	"errors"
+	"slices"
+	"strings"
+
+	"gitea.tecamino.com/paadi/memberDB/models"
+)
+
+type counter struct {
+	event int
+	total int
+}
+
+func (dh *DatabaseHandler) GetReport(filter models.ReportFilter) (report models.Report, err error) {
+	if !dh.DatabaseOpened() {
+		return report, errors.New("database not opened")
+	}
+
+	if len(filter.Date) == 0 {
+		return
+	}
+
+	var events []models.Event
+
+	if len(filter.Name) > 0 {
+		err = dh.database.GetByKey(&events, "name", filter.Name, true)
+	} else {
+		events, err = dh.GetEvent(0)
+	}
+	if err != nil {
+		return
+	}
+
+	report.Data = make(map[string]*models.Data)
+
+	//helper
+	count := make(map[string]*counter)
+
+	addedMember := make(map[uint]bool)
+
+	for _, e := range events {
+
+		for _, d := range filter.Date {
+			if !strings.Contains(e.Date, d) {
+				continue
+			}
+		}
+
+		var data *models.Data
+		if _, ok := count[e.Day]; !ok {
+			count[e.Day] = &counter{}
+		}
+		count[e.Day].event += 1
+
+		data, ok := report.Data[e.Day]
+		if !ok {
+			data = &models.Data{}
+			report.Data[e.Day] = data
+		}
+
+		if data.Minimal > len(e.Attendees) {
+			data.Minimal = len(e.Attendees)
+		}
+
+		if data.Maximal < len(e.Attendees) {
+			data.Maximal = len(e.Attendees)
+		}
+
+		count[e.Day].total = +len(e.Attendees)
+		data.Average = count[e.Day].total / count[e.Day].event
+
+		for _, a := range e.Attendees {
+			if _, ok := addedMember[a.Id]; ok {
+				continue
+			}
+			report.Attendees = append(report.Attendees, a)
+			addedMember[a.Id] = true
+		}
+	}
+
+	// add all member not attended
+	members, err := dh.GetMember(0)
+	if err != nil {
+		return
+	}
+
+	for _, m := range members {
+		if _, ok := addedMember[m.Id]; ok {
+			continue
+		} else if !slices.Contains(filter.Groups, m.Group.Id) {
+			continue
+		}
+		report.NonAttendees = append(report.NonAttendees, &m)
+	}
+
+	return
+}

handlers/responsible.go

@@ -13,18 +13,14 @@ func (dh *DatabaseHandler) AddNewResponsible(responsibles ...models.Responsible)
 
 next:
 	for _, r := range responsibles {
-		if r.MemberId == 0 && r.Id != 0 {
-			r.MemberId = r.Id
-			r.Id = 0
-		}
 
 		//check if member exists
-		if !dh.database.Exists(&models.Member{}, "", "id", &r.MemberId, false) {
+		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)
+		err := dh.database.GetById(&oldResponsibles, 0, "Member")
 		if err != nil {
 			return err
 		}
@@ -32,7 +28,7 @@ next:
 		for _, oldR := range oldResponsibles {
 			if oldR.Member == nil {
 				continue
-			} else if oldR.Member.Id == int(r.MemberId) {
+			} else if oldR.Member.Id == r.MemberId {
 				continue next
 			}
 		}
@@ -46,21 +42,18 @@ next:
 	return nil
 }
 
-func (dh *DatabaseHandler) GetResponsible(id uint) (members []models.Member, err error) {
+func (dh *DatabaseHandler) GetResponsible(id uint) (responsibles models.Responsibles, err error) {
 	if !dh.DatabaseOpened() {
-		return members, errors.New("database not opened")
+		return responsibles, errors.New("database not opened")
 	}
 
-	var responsibles models.Responsibles
-	err = dh.database.GetById(&responsibles, "Member", id)
+	err = dh.database.GetById(&responsibles, id, "Member")
 
-	for _, r := range responsibles {
-
-		err := r.Member.Decrypt(dh.token)
+	for i := range responsibles {
+		err := responsibles[i].Member.Decrypt(dh.token)
 		if err != nil {
-			return members, err
+			return responsibles, err
 		}
-		members = append(members, *r.Member)
 	}
 	return
 }

models/event.go

@@ -5,5 +5,5 @@ type Event struct {
 	Name      string    `gorm:"column:name" json:"name"`
 	Date      string    `gorm:"column:date" json:"date"`
 	Day       string    `gorm:"column:day" json:"day"`
-	Attendees []*Member `gorm:"many2many:member_events;"`
+	Attendees []*Member `gorm:"many2many:member_events;constraint:OnDelete:CASCADE;" json:"attendees"`
 }

models/group.go

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

models/member.go

@@ -6,86 +6,106 @@ import (
 )
 
 type Member struct {
-	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"`
-	LastNameHash  string   `gorm:"column:lastNameHash" json:"-"`
-	Birthday      string   `gorm:"column:birthday" json:"birthday,omitempty"`
-	BirthdayHash  string   `gorm:"column:birthdayHash" json:"-"`
-	Address       string   `gorm:"column:address" json:"address,omitempty"`
-	Zip           string   `gorm:"column:zip" json:"zip,omitempty"`
-	Town          string   `gorm:"column:town" json:"town,omitempty"`
-	Phone         string   `gorm:"column:phone" json:"phone,omitempty"`
-	Email         string   `gorm:"column:email" json:"email,omitempty"`
-	FirstVisit    string   `gorm:"column:firstVisit" json:"firstVisit,omitempty"`
-	LastVisit     string   `gorm:"column:lastVisit" json:"lastVisit,omitempty"`
-	GroupId       *int     `json:"GroupId,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;" `
+	Id            uint         `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"`
+	LastNameHash  string       `gorm:"column:lastNameHash" json:"-"`
+	Birthday      string       `gorm:"column:birthday" json:"birthday,omitempty"`
+	BirthdayHash  string       `gorm:"column:birthdayHash" json:"-"`
+	Address       string       `gorm:"column:address" json:"address,omitempty"`
+	Zip           string       `gorm:"column:zip" json:"zip,omitempty"`
+	Town          string       `gorm:"column:town" json:"town,omitempty"`
+	Phone         string       `gorm:"column:phone" json:"phone,omitempty"`
+	Email         string       `gorm:"column:email" json:"email,omitempty"`
+	FirstVisit    string       `gorm:"column:firstVisit" json:"firstVisit,omitempty"`
+	LastVisit     string       `gorm:"column:lastVisit" json:"lastVisit,omitempty"`
+	GroupId       *uint        `json:"GroupId,omitempty"`
+	Group         *Group       `gorm:"foreignKey:GroupId;constraint:OnDelete:CASCADE;" json:"group,omitempty"`
+	ResponsibleId *uint        `json:"ResponsibleId,omitempty"`
+	Responsible   *Responsible `gorm:"foreignKey:ResponsibleId;references:Id" 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
+	if m.FirstName != "" {
+		m.FirstNameHash = utils.HashField(m.FirstName, token)
+		m.FirstName, err = crypto.Encrypt(m.FirstName, token)
+		if err != nil {
+			return
+		}
+	}
+	if m.LastName != "" {
+		m.LastNameHash = utils.HashField(m.LastName, token)
+		m.LastName, err = crypto.Encrypt(m.LastName, token)
+		if err != nil {
+			return
+		}
 	}
 
-	m.LastNameHash = utils.HashField(m.LastName, token)
-	m.LastName, err = crypto.Encrypt(m.LastName, token)
-	if err != nil {
-		return
+	if m.Birthday != "" {
+		m.BirthdayHash = utils.HashField(m.Birthday, token)
+		m.Birthday, err = crypto.Encrypt(m.Birthday, token)
+		if err != nil {
+			return
+		}
 	}
 
-	m.BirthdayHash = utils.HashField(m.Birthday, token)
-	m.Birthday, err = crypto.Encrypt(m.Birthday, token)
-	if err != nil {
-		return
+	if m.Address != "" {
+		m.Address, err = crypto.Encrypt(m.Address, token)
+		if err != nil {
+			return
+		}
 	}
 
-	m.Address, err = crypto.Encrypt(m.Address, token)
-	if err != nil {
-		return
+	if m.Zip != "" {
+		m.Zip, err = crypto.Encrypt(m.Zip, token)
+		if err != nil {
+			return
+		}
 	}
 
-	m.Zip, err = crypto.Encrypt(m.Zip, token)
-	if err != nil {
-		return
+	if m.Town != "" {
+		m.Town, err = crypto.Encrypt(m.Town, token)
+		if err != nil {
+			return
+		}
 	}
 
-	m.Town, err = crypto.Encrypt(m.Town, token)
-	if err != nil {
-		return
+	if m.Phone != "" {
+		m.Phone, err = crypto.Encrypt(m.Phone, token)
+		if err != nil {
+			return
+		}
 	}
 
-	m.Phone, err = crypto.Encrypt(m.Phone, token)
-	if err != nil {
-		return
+	if m.Email != "" {
+		m.Email, err = crypto.Encrypt(m.Email, token)
+		if err != nil {
+			return
+		}
 	}
 
-	m.Email, err = crypto.Encrypt(m.Email, token)
-	if err != nil {
-		return
+	if m.FirstVisit != "" {
+		m.FirstVisit, err = crypto.Encrypt(m.FirstVisit, token)
+		if err != nil {
+			return
+		}
 	}
 
-	m.FirstVisit, err = crypto.Encrypt(m.FirstVisit, token)
-	if err != nil {
-		return
+	if m.LastVisit != "" {
+		m.LastVisit, err = crypto.Encrypt(m.LastVisit, 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
+	if m.Comment != "" {
+		m.Comment, err = crypto.Encrypt(m.Comment, token)
+		if err != nil {
+			return
+		}
 	}
 	return
 }

models/report.go

@@ -0,0 +1,19 @@
+package models
+
+type ReportFilter struct {
+	Date   []string `json:"date"`
+	Groups []uint   `json:"groupIds,omitempty"`
+	Name   []string `json:"name,omitempty"`
+}
+
+type Report struct {
+	Data         map[string]*Data `json:"data,omitempty"`
+	Attendees    []*Member        `json:"attendees,omitempty"`
+	NonAttendees []*Member        `json:"nonAttendees,omitempty"`
+}
+
+type Data struct {
+	Minimal int `json:"minimal,omitempty"`
+	Average int `json:"average,omitempty"`
+	Maximal int `json:"maximal,omitempty"`
+}

models/responsible.go

@@ -1,9 +1,9 @@
 package models
 
 type Responsible struct {
-	Id       uint `gorm:"primaryKey"`
-	MemberId uint
-	Member   *Member `gorm:"foreignKey:MemberId"`
+	Id       uint    `gorm:"primaryKey" json:"id"`
+	MemberId uint    `json:"memberId"`
+	Member   *Member `gorm:"foreignKey:MemberId;constraint:OnDelete:CASCADE;" json:"member"`
 }
 
 type Responsibles []Responsible

utils/utils.go

@@ -38,6 +38,11 @@ func GetCurrentDay(loc *time.Location) string {
 	return fmt.Sprint(time.Now().In(loc).Weekday())
 }
 
+func GetDayFromDate(dateTime string) (string, error) {
+	t, err := time.Parse("2006-01-02 15:04:05", dateTime)
+	return fmt.Sprint(t.Weekday()), err
+}
+
 func HashField(field string, token []byte) string {
 	h := hmac.New(sha256.New, token)
 	h.Write([]byte(field))