oef/orm/participant.go

package orm

import (
	"fmt"
	"strconv"

	"net/http"
	"strings"

	"git.andreafazzi.eu/andrea/oef/config"
	"git.andreafazzi.eu/andrea/oef/errors"
	"git.andreafazzi.eu/andrea/oef/i18n"
	"git.andreafazzi.eu/andrea/oef/renderer"
	"github.com/jinzhu/gorm"
)

type Participant struct {
	gorm.Model

	*UserModifierCreate
	*UserModifierUpdate

	UserID uint

	Firstname string
	Lastname  string

	FiscalCode string

	CategoryID uint `schema:"category_id"`
	SchoolID   uint `schema:"school_id"`

	User     *User
	School   *School
	Category *Category

	Responses []*Response

	ContestIDs []uint     `schema:"contest_ids" gorm:"-"`
	Contests   []*Contest `gorm:"many2many:subscriptions"`

	SelectedCategory map[uint]string `gorm:"-"`
	AllCategories    []*Category     `gorm:"-"`

	SelectedContest map[uint]string `gorm:"-"`
	AllContests     []*Contest      `gorm:"-"`

	SelectedSchool map[uint]string `gorm:"-"`
	AllSchools     []*School       `gorm:"-"`
}

func (model *Participant) sanitize(s string) string {
	lower := strings.ToLower(s)
	r := strings.NewReplacer("'", "", "-", "", " ", "", "ò", "o", "ì", "i")
	return r.Replace(lower)
}

func (model *Participant) username() string {
	return strings.ToUpper(model.FiscalCode)
}

func (model *Participant) GetID() uint { return model.ID }

func (model *Participant) String() string {
	return fmt.Sprintf("%s %s", strings.ToUpper(model.Lastname), strings.Title(strings.ToLower(model.Firstname)))
}

func setFlashMessage(w http.ResponseWriter, r *http.Request, key string) error {
	session, err := store.Get(r, "flash-session")
	if err != nil {
		return err
	}
	session.AddFlash(i18n.FlashMessages[key][config.Config.Language])
	err = session.Save(r, w)
	if err != nil {
		return err
	}
	return nil
}

func (model *Participant) exists() (*User, error) {
	var user User
	if err := DB().First(&user, &User{Username: model.username()}).Error; err != nil && err != gorm.ErrRecordNotFound {
		return nil, err
	} else if err == gorm.ErrRecordNotFound {
		return nil, nil
	}
	return &user, nil
}

func (model *Participant) BeforeSave(tx *gorm.DB) error {
	var user User
	if err := tx.FirstOrCreate(&user, &User{
		Username: model.username(),
		Role:     "participant",
	}).Error; err != nil {
		return err
	}
	model.UserID = user.ID
	return nil
}

func (model *Participant) AfterSave(tx *gorm.DB) error {
	for _, contest := range model.Contests {
		var response Response
		if err := tx.FirstOrCreate(
			&response,
			&Response{
				Name:          fmt.Sprintf("%s (%s)", contest.Name, model.String()),
				ContestID:     contest.ID,
				ParticipantID: model.UserID,
			}).Error; err != nil {
			return err
		}
	}
	return nil
}

func (model *Participant) AfterDelete(tx *gorm.DB) error {
	if err := tx.Unscoped().Delete(model.User).Error; err != nil {
		return err
	}
	return nil
}

func (model *Participant) Create(args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	if r.Method == "GET" {
		participant := new(Participant)
		if isSchool(r) {
			if err := DB().Find(&participant.AllCategories).Error; err != nil {
				return nil, err
			}
		} else {
			if err := DB().Find(&participant.AllCategories).Error; err != nil {
				return nil, err
			}
			if err := DB().Find(&participant.AllContests).Error; err != nil {
				return nil, err
			}
			if err := DB().Find(&participant.AllSchools).Error; err != nil {
				return nil, err
			}
		}
		return participant, nil
	} else {
		participant := new(Participant)
		err := renderer.Decode(participant, r)
		if err != nil {
			return nil, err
		}

		// Check if participant exists
		if user, err := participant.exists(); err == nil && user != nil {
			if err := DB().Where("user_id = ?", user.ID).Find(&participant).Error; err != nil {
				return nil, err
			}
			err := setFlashMessage(w, r, "participantExists")
			if err != nil {
				return nil, err
			}
			return participant, nil
		} else if err != nil {
			return nil, err
		}

		// If user has "school" role get school id from token
		if isSchool(r) {
			schoolID, err := strconv.Atoi(getUserIDFromToken(r))
			if err != nil {
				return nil, err
			}
			participant.SchoolID = uint(schoolID)
		}

		// Check if a participant of the same category exists
		var school School
		if err := DB().First(&school, participant.SchoolID).Error; err != nil {
			return nil, err
		}
		hasCategory, err := school.HasCategory(participant)
		if err != nil {
			return nil, err
		}
		if hasCategory {
			return nil, errors.CategoryExists
		}

		participant.UserModifierCreate = NewUserModifierCreate(r)

		participant, err = CreateParticipant(participant)
		if err != nil {
			return nil, err
		}
		return participant, nil
	}
}

func (model *Participant) Read(args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	var participant Participant

	id := args["id"]

	// School user can access to its participants only!
	if isSchool(r) {
		if err := DB().Preload("School").First(&participant, id).Error; err != nil {
			return nil, err
		}

		if strconv.Itoa(int(participant.SchoolID)) != getUserIDFromToken(r) {
			setFlashMessage(w, r, "notAuthorized")
			return nil, errors.NotAuthorized
		}

		if err := DB().Preload("User").Preload("School").Preload("Category").First(&participant, id).Error; err != nil {
			return nil, err
		}

	} else {
		if err := DB().Preload("User").Preload("School").Preload("Responses").Preload("Contests").Preload("Category").First(&participant, id).Error; err != nil {
			return nil, err
		}
	}

	return &participant, nil
}

func (model *Participant) ReadAll(args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	var participants []*Participant

	// School user can access to its participants only!
	if isSchool(r) {
		schoolId, err := strconv.Atoi(getUserIDFromToken(r))
		if err != nil {
			return nil, err
		}
		if err := DB().Preload("Category").Preload("School").Preload("Contests").Order("lastname").Find(&participants, &Participant{SchoolID: uint(schoolId)}).Error; err != nil {
			return nil, err
		}
	} else {
		if err := DB().Preload("School").Preload("Contests").Preload("Responses").Order("created_at").Find(&participants).Error; err != nil {
			return nil, err
		}
	}
	return participants, nil
}

func (model *Participant) Update(args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	if r.Method == "GET" {
		result, err := model.Read(args, w, r)
		if err != nil {
			return nil, err
		}

		participant := result.(*Participant)

		if isSchool(r) {
			if err := DB().Find(&participant.AllCategories).Error; err != nil {
				return nil, err
			}

			participant.SelectedCategory = make(map[uint]string)
			participant.SelectedCategory[participant.CategoryID] = "selected"
		} else {
			if err := DB().Find(&participant.AllContests).Error; err != nil {
				return nil, err
			}

			participant.SelectedContest = make(map[uint]string)
			for _, c := range participant.Contests {
				participant.SelectedContest[c.ID] = "selected"
			}

			if err := DB().Find(&participant.AllSchools).Error; err != nil {
				return nil, err
			}

			participant.SelectedSchool = make(map[uint]string)
			participant.SelectedSchool[participant.SchoolID] = "selected"
		}
		return participant, nil
	} else {
		participant, err := model.Read(args, w, r)
		if err != nil {
			return nil, err
		}
		err = renderer.Decode(participant, r)
		if err != nil {
			return nil, err
		}

		if user, err := participant.(*Participant).exists(); err == nil && user != nil {
			if user.ID != participant.(*Participant).UserID {
				err := setFlashMessage(w, r, "participantExists")
				if err != nil {
					return nil, err
				}
				return participant, nil
			}
		} else if err != nil {
			return nil, err
		}

		// Check if a participant of the same category exists
		var school School
		if err := DB().First(&school, participant.(*Participant).SchoolID).Error; err != nil {
			return nil, err
		}
		hasCategory, err := school.HasCategory(participant.(*Participant))
		if err != nil {
			return nil, err
		}
		if hasCategory {
			return nil, errors.CategoryExists
		}

		if err := DB().Where(participant.(*Participant).ContestIDs).Find(&participant.(*Participant).Contests).Error; err != nil {
			return nil, err
		}

		participant.(*Participant).UserModifierUpdate = NewUserModifierUpdate(r)

		_, err = SaveParticipant(participant)
		if err != nil {
			return nil, err
		}

		if err := DB().Model(participant).Association("Contests").Replace(participant.(*Participant).Contests).Error; err != nil {
			return nil, err
		}

		participant, err = model.Read(args, w, r)
		if err != nil {
			return nil, err
		}
		return participant.(*Participant), nil
	}
}

func (model *Participant) Delete(args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	participant, err := model.Read(args, w, r)
	if err != nil {
		return nil, err
	}
	if err := DB().Unscoped().Delete(participant.(*Participant)).Error; err != nil {
		return nil, err
	}
	return participant.(*Participant), nil
}

func CreateParticipant(participant *Participant) (*Participant, error) {
	if err := DB().Where(participant.ContestIDs).Find(&participant.Contests).Error; err != nil {
		return nil, err
	}
	if err := DB().Create(participant).Error; err != nil {
		return nil, err
	}
	return participant, nil
}

func SaveParticipant(participant interface{}) (interface{}, error) {
	participant.(*Participant).FiscalCode = strings.ToUpper(participant.(*Participant).FiscalCode)

	if err := DB().Omit("Category", "School").Save(participant).Error; err != nil {
		return nil, err
	}
	return participant, nil
}