cacert-boardvoting/internal/forms/forms.go
Jan Dittberner 11582d3590 Update linter config and apply suggestions
- remove copyright years (they are in git)
- remove outdated linter bug workarounds
- update .golangci.yml to match current schema (as of golangci-lint 1.59.0)
2024-06-08 12:51:34 +02:00

302 lines
8.1 KiB
Go

/*
Copyright CAcert Inc.
SPDX-License-Identifier: Apache-2.0
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package forms
import (
"fmt"
"strings"
"git.cacert.org/cacert-boardvoting/internal/models"
"git.cacert.org/cacert-boardvoting/internal/validator"
)
const (
minimumTitleLength = 3
maximumTitleLength = 200
minimumContentLength = 3
maximumContentLength = 8000
minimumJustificationLen = 3
threeDays = 3
oneWeek = 7
twoWeeks = 14
threeWeeks = 28
)
type Form interface {
Validate() error
Normalize()
}
func validateUserName(v *validator.Validator, name string, field string) {
v.CheckField(validator.NotBlank(name), field, "This field cannot be blank")
}
func validateEmailAddress(v *validator.Validator, address string, field string) {
v.CheckField(validator.NotBlank(address), field, "This field cannot be blank")
v.CheckField(validator.IsEmail(address), field, "This field must be an email address")
}
func validateReasoning(v *validator.Validator, reasoning string, field string) {
v.CheckField(validator.NotBlank(reasoning), field, "This field cannot be blank")
v.CheckField(
validator.MinChars(reasoning, minimumJustificationLen),
field,
fmt.Sprintf("This field must be at least %d characters long", minimumJustificationLen),
)
}
func validateMotionTitle(v *validator.Validator, title string, field string) {
v.CheckField(
validator.NotBlank(title),
field,
"This field cannot be blank",
)
v.CheckField(
validator.MinChars(title, minimumTitleLength),
field,
fmt.Sprintf("This field must be at least %d characters long", minimumTitleLength),
)
v.CheckField(
validator.MaxChars(title, maximumTitleLength),
field,
fmt.Sprintf("This field must be at most %d characters long", maximumTitleLength),
)
}
func validateMotionContent(v *validator.Validator, content string, field string) {
v.CheckField(
validator.NotBlank(content),
field,
"This field cannot be blank",
)
v.CheckField(
validator.MinChars(content, minimumContentLength),
field,
fmt.Sprintf("This field must be at least %d characters long", minimumContentLength),
)
v.CheckField(
validator.MaxChars(content, maximumContentLength),
field,
fmt.Sprintf("This field must be at most %d characters long", maximumContentLength),
)
}
type EditMotionForm struct {
Title string `form:"title"`
Content string `form:"content"`
Type *models.VoteType `form:"type"`
Due int `form:"due"`
validator.Validator `form:"-"`
}
func (f *EditMotionForm) Validate() error {
validateMotionTitle(&f.Validator, f.Title, "title")
validateMotionContent(&f.Validator, f.Content, "content")
f.CheckField(validator.NotNil(f.Type), "type", "You must choose a valid vote type")
f.CheckField(validator.PermittedInt(
f.Due, threeDays, oneWeek, twoWeeks, threeWeeks), "due", "invalid duration choice",
)
return nil
}
func (f *EditMotionForm) Normalize() {
f.Title = strings.TrimSpace(f.Title)
f.Content = strings.TrimSpace(f.Content)
}
type DirectVoteForm struct {
Choice *models.VoteChoice
}
func (f *DirectVoteForm) Validate() error { return nil }
func (f *DirectVoteForm) Normalize() {}
type ProxyVoteForm struct {
Voter *models.User `form:"voter"`
Choice *models.VoteChoice `form:"choice"`
Justification string `form:"justification"`
Voters []*models.User `form:"-"`
validator.Validator `form:"-"`
}
func (f *ProxyVoteForm) Validate() error {
f.CheckField(validator.NotNil(f.Voter), "voter", "Please choose a valid voter")
validateReasoning(&f.Validator, f.Justification, "justification")
f.CheckField(validator.NotNil(f.Choice), "choice", "A choice has to be made")
return nil
}
func (f *ProxyVoteForm) Normalize() {
f.Justification = strings.TrimSpace(f.Justification)
}
type EditUserForm struct {
User *models.User `form:"-"`
MailAddresses []string `form:"-"`
AllRoles []*models.Role `form:"-"`
Name string `form:"name"`
Roles []string `form:"roles"`
ReminderMail string `form:"reminder_mail"`
Reasoning string `form:"reasoning"`
validator.Validator `form:"-"`
}
func (f *EditUserForm) Validate() error {
addresses, err := f.User.EmailAddresses()
if err != nil {
return fmt.Errorf("error while validating form: %w", err)
}
validateUserName(&f.Validator, f.Name, "name")
f.CheckField(
validator.NotBlank(f.ReminderMail),
"reminder_mail",
"Must choose a reminder mail address",
)
f.CheckField(
validator.PermittedString(f.ReminderMail, addresses...),
"reminder_mail",
"Reminder mail must be one of the user's email addresses",
)
allRoleNames := make([]string, len(f.AllRoles))
for i := range f.AllRoles {
allRoleNames[i] = f.AllRoles[i].Name
}
f.CheckField(
validator.PermittedStringSet(f.Roles, allRoleNames),
"roles",
fmt.Sprintf("Roles must only contain values from %s", strings.Join(allRoleNames, ", ")),
)
validateReasoning(&f.Validator, f.Reasoning, "reasoning")
return nil
}
func (f *EditUserForm) Normalize() {
f.Name = strings.TrimSpace(f.Name)
f.Reasoning = strings.TrimSpace(f.Reasoning)
}
func (f *EditUserForm) UpdateUser(edit *models.User) {
edit.Reminder.String = f.ReminderMail
edit.Name = f.Name
}
type NewUserForm struct {
Name string `form:"name"`
EmailAddress string `form:"email_address"`
Reasoning string `form:"reasoning"`
validator.Validator `form:"-"`
}
func (f *NewUserForm) Validate() error {
validateUserName(&f.Validator, f.Name, "name")
validateEmailAddress(&f.Validator, f.EmailAddress, "email_address")
validateReasoning(&f.Validator, f.Reasoning, "reasoning")
return nil
}
func (f *NewUserForm) Normalize() {
f.Name = strings.TrimSpace(f.Name)
f.EmailAddress = strings.TrimSpace(f.EmailAddress)
f.Reasoning = strings.TrimSpace(f.Reasoning)
}
func (f *NewUserForm) FillUser() *models.User {
return &models.User{Name: f.Name}
}
type DeleteUserForm struct {
User *models.User `form:"user"`
Reasoning string `form:"reasoning"`
validator.Validator `form:"-"`
}
func (f *DeleteUserForm) Validate() error {
validateReasoning(&f.Validator, f.Reasoning, "reasoning")
return nil
}
func (f *DeleteUserForm) Normalize() {
f.Reasoning = strings.TrimSpace(f.Reasoning)
}
type AddEmailForm struct {
EmailAddress string `form:"email_address"`
Reasoning string `form:"reasoning"`
User *models.User `form:"-"`
EmailAddresses []string `form:"-"`
validator.Validator `form:"-"`
}
func (f *AddEmailForm) Validate() error {
validateEmailAddress(&f.Validator, f.EmailAddress, "email_address")
validateReasoning(&f.Validator, f.Reasoning, "reasoning")
return nil
}
func (f *AddEmailForm) Normalize() {
f.EmailAddress = strings.TrimSpace(f.EmailAddress)
f.Reasoning = strings.TrimSpace(f.Reasoning)
}
type DeleteEmailForm struct {
EmailAddress string `form:"-"`
User *models.User `form:"-"`
Reasoning string `form:"reasoning"`
validator.Validator `form:"-"`
}
func (f *DeleteEmailForm) Validate() error {
validateReasoning(&f.Validator, f.Reasoning, "reasoning")
return nil
}
func (f *DeleteEmailForm) Normalize() {
f.Reasoning = strings.TrimSpace(f.Reasoning)
}
type ChooseVoterForm struct {
Reasoning string `form:"reasoning"`
VoterIDs []int64 `form:"voters"`
Users []*models.User
validator.Validator `form:"-"`
}
func (f *ChooseVoterForm) Validate() error {
validateReasoning(&f.Validator, f.Reasoning, "reasoning")
return nil
}
func (f *ChooseVoterForm) Normalize() {
}