memberDB/handlers/members.go

package handlers

import (
	"errors"
	"fmt"
	"time"

	"gitea.tecamino.com/paadi/memberDB/crypto"
	"gitea.tecamino.com/paadi/memberDB/models"
	"gitea.tecamino.com/paadi/memberDB/utils"
)

// 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)
		if err != nil {
			return err
		} else if exists {
			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)
		if err != nil {
			return err
		}

		now := time.Now().Format("2006-01-02 15:04:05")
		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
		}

		encComment, err := crypto.Encrypt(member.Comment, 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.Comment = encComment

		err = dh.database.AddNewColum(&member)
		if err != nil {
			return err
		}
	}
	return nil
}

// DeleteMember removes members by given ids
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")
	}
	return dh.database.DeleteById(&models.Member{}, ids...)
}

// GetMember returns one member by given id
func (dh *DatabaseHandler) GetMember(id uint) (members []models.Member, err error) {
	if !dh.DatabaseOpened() {
		return members, errors.New("database not opened")
	}

	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 != nil {
			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].Comment, err = crypto.Decrypt(members[i].Comment, dh.token)
		if err != nil {
			return
		}
	}
	return
}

// UpdateMember updates/overrides all information given meber id
func (dh *DatabaseHandler) UpdateMember(id int, 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 != "" {
		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 != "" {
		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.LastVisit != "" {
		member.LastVisit, err = crypto.Encrypt(member.LastVisit, dh.token)
		if err != nil {
			return err
		}
	}

	if member.Group != "" {
		member.Group, err = crypto.Encrypt(member.Group, dh.token)
		if err != nil {
			return err
		}
	}

	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))
}

// memberExists helper to check wheter member already exists
func (dh *DatabaseHandler) memberExists(checkMember models.Member) (bool, error) {
	if !dh.DatabaseOpened() {
		return false, errors.New("database not opened")
	}

	var members []models.Member
	if !dh.database.Exists(&members, "birthdayHash", dh.hashField(checkMember.Birthday), false) {
		return false, 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
}