Jan Dittberner
11582d3590
- 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)
302 lines
8.1 KiB
Go
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() {
|
|
}
|