2014-07-26 00:24:27 -04:00
|
|
|
// Copyright 2014 The Gogs Authors. All rights reserved.
|
2018-11-14 20:00:04 -05:00
|
|
|
// Copyright 2018 The Gitea Authors. All rights reserved.
|
2022-11-27 13:20:29 -05:00
|
|
|
// SPDX-License-Identifier: MIT
|
2014-07-26 00:24:27 -04:00
|
|
|
|
2021-01-26 10:36:53 -05:00
|
|
|
package forms
|
2014-07-26 00:24:27 -04:00
|
|
|
|
|
|
|
import (
|
2014-11-21 10:58:08 -05:00
|
|
|
"mime/multipart"
|
2021-01-26 10:36:53 -05:00
|
|
|
"net/http"
|
2018-11-14 20:00:04 -05:00
|
|
|
"strings"
|
|
|
|
|
2023-01-17 16:46:03 -05:00
|
|
|
auth_model "code.gitea.io/gitea/models/auth"
|
2024-03-11 02:07:36 -04:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2018-11-14 20:00:04 -05:00
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2021-06-26 15:53:14 -04:00
|
|
|
"code.gitea.io/gitea/modules/structs"
|
2021-01-30 03:55:53 -05:00
|
|
|
"code.gitea.io/gitea/modules/web/middleware"
|
2024-02-27 02:12:22 -05:00
|
|
|
"code.gitea.io/gitea/services/context"
|
2014-11-21 10:58:08 -05:00
|
|
|
|
2021-01-26 10:36:53 -05:00
|
|
|
"gitea.com/go-chi/binding"
|
2014-07-26 00:24:27 -04:00
|
|
|
)
|
|
|
|
|
2016-11-27 01:03:59 -05:00
|
|
|
// InstallForm form for installation page
|
2014-07-26 00:24:27 -04:00
|
|
|
type InstallForm struct {
|
2015-07-09 01:17:48 -04:00
|
|
|
DbType string `binding:"Required"`
|
|
|
|
DbHost string
|
|
|
|
DbUser string
|
|
|
|
DbPasswd string
|
|
|
|
DbName string
|
2015-07-20 00:34:53 -04:00
|
|
|
SSLMode string
|
2015-07-09 01:17:48 -04:00
|
|
|
DbPath string
|
2020-01-20 10:45:14 -05:00
|
|
|
DbSchema string
|
2015-07-09 01:17:48 -04:00
|
|
|
|
|
|
|
AppName string `binding:"Required" locale:"install.app_name"`
|
|
|
|
RepoRootPath string `binding:"Required"`
|
2016-12-25 20:16:37 -05:00
|
|
|
LFSRootPath string
|
2015-07-09 01:17:48 -04:00
|
|
|
RunUser string `binding:"Required"`
|
|
|
|
Domain string `binding:"Required"`
|
2015-08-19 08:36:19 -04:00
|
|
|
SSHPort int
|
2015-07-20 00:34:53 -04:00
|
|
|
HTTPPort string `binding:"Required"`
|
2016-11-27 01:03:59 -05:00
|
|
|
AppURL string `binding:"Required"`
|
2016-02-12 10:10:02 -05:00
|
|
|
LogRootPath string `binding:"Required"`
|
2015-07-09 01:17:48 -04:00
|
|
|
|
Rework mailer settings (#18982)
* `PROTOCOL`: can be smtp, smtps, smtp+startls, smtp+unix, sendmail, dummy
* `SMTP_ADDR`: domain for SMTP, or path to unix socket
* `SMTP_PORT`: port for SMTP; defaults to 25 for `smtp`, 465 for `smtps`, and 587 for `smtp+startls`
* `ENABLE_HELO`, `HELO_HOSTNAME`: reverse `DISABLE_HELO` to `ENABLE_HELO`; default to false + system hostname
* `FORCE_TRUST_SERVER_CERT`: replace the unclear `SKIP_VERIFY`
* `CLIENT_CERT_FILE`, `CLIENT_KEY_FILE`, `USE_CLIENT_CERT`: clarify client certificates here
Co-authored-by: wxiaoguang <wxiaoguang@gmail.com>
Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com>
2022-08-02 01:24:18 -04:00
|
|
|
SMTPAddr string
|
|
|
|
SMTPPort string
|
2015-07-20 00:34:53 -04:00
|
|
|
SMTPFrom string
|
2017-02-23 20:37:13 -05:00
|
|
|
SMTPUser string `binding:"OmitEmpty;MaxSize(254)" locale:"install.mailer_user"`
|
2015-07-20 00:34:53 -04:00
|
|
|
SMTPPasswd string
|
2015-07-09 01:17:48 -04:00
|
|
|
RegisterConfirm bool
|
|
|
|
MailNotify bool
|
|
|
|
|
2017-05-12 04:09:53 -04:00
|
|
|
OfflineMode bool
|
|
|
|
DisableGravatar bool
|
|
|
|
EnableFederatedAvatar bool
|
2017-08-19 11:34:49 -04:00
|
|
|
EnableOpenIDSignIn bool
|
|
|
|
EnableOpenIDSignUp bool
|
2017-05-12 04:09:53 -04:00
|
|
|
DisableRegistration bool
|
2018-05-13 03:51:16 -04:00
|
|
|
AllowOnlyExternalRegistration bool
|
2017-05-12 04:09:53 -04:00
|
|
|
EnableCaptcha bool
|
|
|
|
RequireSignInView bool
|
|
|
|
DefaultKeepEmailPrivate bool
|
2017-05-08 15:51:53 -04:00
|
|
|
DefaultAllowCreateOrganization bool
|
2017-09-12 02:48:13 -04:00
|
|
|
DefaultEnableTimetracking bool
|
2022-11-01 15:23:56 -04:00
|
|
|
EnableUpdateChecker bool
|
2017-05-12 04:09:53 -04:00
|
|
|
NoReplyAddress string
|
2015-07-09 01:17:48 -04:00
|
|
|
|
2021-02-16 17:37:20 -05:00
|
|
|
PasswordAlgorithm string
|
|
|
|
|
2022-11-04 05:04:08 -04:00
|
|
|
AdminName string `binding:"OmitEmpty;Username;MaxSize(30)" locale:"install.admin_name"`
|
2015-08-17 14:30:33 -04:00
|
|
|
AdminPasswd string `binding:"OmitEmpty;MaxSize(255)" locale:"install.admin_password"`
|
2015-07-08 07:47:56 -04:00
|
|
|
AdminConfirmPasswd string
|
2015-10-29 21:12:41 -04:00
|
|
|
AdminEmail string `binding:"OmitEmpty;MinSize(3);MaxSize(254);Include(@)" locale:"install.admin_email"`
|
2021-12-01 02:50:01 -05:00
|
|
|
|
|
|
|
// ReinstallConfirmFirst we can not use 1/2/3 or A/B/C here, there is a framework bug, can not parse "reinstall_confirm_1" or "reinstall_confirm_a"
|
|
|
|
ReinstallConfirmFirst bool
|
|
|
|
ReinstallConfirmSecond bool
|
|
|
|
ReinstallConfirmThird bool
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
|
|
|
|
2017-03-14 20:52:01 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *InstallForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// _____ ____ _________________ ___
|
|
|
|
// / _ \ | | \__ ___/ | \
|
|
|
|
// / /_\ \| | / | | / ~ \
|
|
|
|
// / | \ | / | | \ Y /
|
|
|
|
// \____|__ /______/ |____| \___|_ /
|
|
|
|
// \/ \/
|
|
|
|
|
2016-11-27 01:03:59 -05:00
|
|
|
// RegisterForm form for registering
|
2014-07-26 00:24:27 -04:00
|
|
|
type RegisterForm struct {
|
2022-11-22 16:13:18 -05:00
|
|
|
UserName string `binding:"Required;Username;MaxSize(40)"`
|
|
|
|
Email string `binding:"Required;MaxSize(254)"`
|
|
|
|
Password string `binding:"MaxSize(255)"`
|
|
|
|
Retype string
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *RegisterForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
|
|
|
|
2021-02-14 18:31:29 -05:00
|
|
|
// IsEmailDomainAllowed validates that the email address
|
|
|
|
// provided by the user matches what has been configured .
|
|
|
|
// The email is marked as allowed if it matches any of the
|
|
|
|
// domains in the whitelist or if it doesn't match any of
|
|
|
|
// domains in the blocklist, if any such list is not empty.
|
2023-05-21 20:05:44 -04:00
|
|
|
func (f *RegisterForm) IsEmailDomainAllowed() bool {
|
2024-03-11 02:07:36 -04:00
|
|
|
return user_model.IsEmailDomainAllowed(f.Email)
|
2021-02-14 18:31:29 -05:00
|
|
|
}
|
|
|
|
|
2018-09-13 08:04:25 -04:00
|
|
|
// MustChangePasswordForm form for updating your password after account creation
|
|
|
|
// by an admin
|
|
|
|
type MustChangePasswordForm struct {
|
|
|
|
Password string `binding:"Required;MaxSize(255)"`
|
|
|
|
Retype string
|
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *MustChangePasswordForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2018-09-13 08:04:25 -04:00
|
|
|
}
|
|
|
|
|
2017-03-17 10:16:08 -04:00
|
|
|
// SignInForm form for signing in with user/password
|
2014-07-26 00:24:27 -04:00
|
|
|
type SignInForm struct {
|
2015-09-14 22:50:44 -04:00
|
|
|
UserName string `binding:"Required;MaxSize(254)"`
|
2019-07-06 15:48:02 -04:00
|
|
|
// TODO remove required from password for SecondFactorAuthentication
|
2015-09-14 22:50:44 -04:00
|
|
|
Password string `binding:"Required;MaxSize(255)"`
|
|
|
|
Remember bool
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *SignInForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
|
|
|
|
2019-03-08 11:42:50 -05:00
|
|
|
// AuthorizationForm form for authorizing oauth2 clients
|
|
|
|
type AuthorizationForm struct {
|
|
|
|
ResponseType string `binding:"Required;In(code)"`
|
|
|
|
ClientID string `binding:"Required"`
|
|
|
|
RedirectURI string
|
|
|
|
State string
|
2021-01-01 11:33:27 -05:00
|
|
|
Scope string
|
|
|
|
Nonce string
|
2019-03-08 11:42:50 -05:00
|
|
|
|
|
|
|
// PKCE support
|
|
|
|
CodeChallengeMethod string // S256, plain
|
|
|
|
CodeChallenge string
|
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *AuthorizationForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2019-03-08 11:42:50 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// GrantApplicationForm form for authorizing oauth2 clients
|
|
|
|
type GrantApplicationForm struct {
|
|
|
|
ClientID string `binding:"Required"`
|
|
|
|
RedirectURI string
|
|
|
|
State string
|
2021-01-01 11:33:27 -05:00
|
|
|
Scope string
|
|
|
|
Nonce string
|
2019-03-08 11:42:50 -05:00
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *GrantApplicationForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2019-03-08 11:42:50 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// AccessTokenForm for issuing access tokens from authorization codes or refresh tokens
|
|
|
|
type AccessTokenForm struct {
|
2019-04-15 11:54:50 -04:00
|
|
|
GrantType string `json:"grant_type"`
|
|
|
|
ClientID string `json:"client_id"`
|
|
|
|
ClientSecret string `json:"client_secret"`
|
|
|
|
RedirectURI string `json:"redirect_uri"`
|
|
|
|
Code string `json:"code"`
|
|
|
|
RefreshToken string `json:"refresh_token"`
|
2019-03-08 11:42:50 -05:00
|
|
|
|
|
|
|
// PKCE support
|
2019-04-15 11:54:50 -04:00
|
|
|
CodeVerifier string `json:"code_verifier"`
|
2019-03-08 11:42:50 -05:00
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *AccessTokenForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2019-03-08 11:42:50 -05:00
|
|
|
}
|
|
|
|
|
2021-08-20 22:16:45 -04:00
|
|
|
// IntrospectTokenForm for introspecting tokens
|
|
|
|
type IntrospectTokenForm struct {
|
|
|
|
Token string `json:"token"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// Validate validates the fields
|
|
|
|
func (f *IntrospectTokenForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-08-20 22:16:45 -04:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
|
|
|
}
|
|
|
|
|
2014-07-26 00:24:27 -04:00
|
|
|
// __________________________________________.___ _______ ________ _________
|
|
|
|
// / _____/\_ _____/\__ ___/\__ ___/| |\ \ / _____/ / _____/
|
|
|
|
// \_____ \ | __)_ | | | | | |/ | \/ \ ___ \_____ \
|
|
|
|
// / \ | \ | | | | | / | \ \_\ \/ \
|
|
|
|
// /_______ //_______ / |____| |____| |___\____|__ /\______ /_______ /
|
|
|
|
// \/ \/ \/ \/ \/
|
|
|
|
|
2016-11-27 01:03:59 -05:00
|
|
|
// UpdateProfileForm form for updating profile
|
2014-07-26 00:24:27 -04:00
|
|
|
type UpdateProfileForm struct {
|
2022-11-04 05:04:08 -04:00
|
|
|
Name string `binding:"Username;MaxSize(40)"`
|
2020-06-05 16:01:53 -04:00
|
|
|
FullName string `binding:"MaxSize(100)"`
|
|
|
|
KeepEmailPrivate bool
|
2021-06-25 18:38:27 -04:00
|
|
|
Website string `binding:"ValidSiteUrl;MaxSize(255)"`
|
2020-06-05 16:01:53 -04:00
|
|
|
Location string `binding:"MaxSize(50)"`
|
|
|
|
Description string `binding:"MaxSize(255)"`
|
2021-06-26 15:53:14 -04:00
|
|
|
Visibility structs.VisibleType
|
2020-06-05 16:01:53 -04:00
|
|
|
KeepActivityPrivate bool
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
|
|
|
|
2017-03-14 20:52:01 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *UpdateProfileForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-10-27 11:40:08 -04:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
|
|
|
}
|
|
|
|
|
|
|
|
// UpdateLanguageForm form for updating profile
|
|
|
|
type UpdateLanguageForm struct {
|
|
|
|
Language string
|
|
|
|
}
|
|
|
|
|
|
|
|
// Validate validates the fields
|
|
|
|
func (f *UpdateLanguageForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
|
|
|
|
2016-11-27 01:03:59 -05:00
|
|
|
// Avatar types
|
2016-08-07 13:27:38 -04:00
|
|
|
const (
|
2016-11-07 11:55:31 -05:00
|
|
|
AvatarLocal string = "local"
|
|
|
|
AvatarByMail string = "bymail"
|
2016-08-07 13:27:38 -04:00
|
|
|
)
|
|
|
|
|
2016-11-27 01:03:59 -05:00
|
|
|
// AvatarForm form for changing avatar
|
2016-08-07 13:27:38 -04:00
|
|
|
type AvatarForm struct {
|
|
|
|
Source string
|
|
|
|
Avatar *multipart.FileHeader
|
|
|
|
Gravatar string `binding:"OmitEmpty;Email;MaxSize(254)"`
|
|
|
|
Federavatar bool
|
2014-11-21 10:58:08 -05:00
|
|
|
}
|
|
|
|
|
2017-03-14 20:52:01 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *AvatarForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2014-11-21 10:58:08 -05:00
|
|
|
}
|
|
|
|
|
2016-11-27 01:03:59 -05:00
|
|
|
// AddEmailForm form for adding new email
|
2014-12-17 10:42:54 -05:00
|
|
|
type AddEmailForm struct {
|
2015-09-10 11:40:34 -04:00
|
|
|
Email string `binding:"Required;Email;MaxSize(254)"`
|
2014-12-17 10:42:54 -05:00
|
|
|
}
|
|
|
|
|
2017-03-14 20:52:01 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *AddEmailForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2014-12-17 10:42:54 -05:00
|
|
|
}
|
|
|
|
|
2019-01-09 12:22:57 -05:00
|
|
|
// UpdateThemeForm form for updating a users' theme
|
|
|
|
type UpdateThemeForm struct {
|
|
|
|
Theme string `binding:"Required;MaxSize(30)"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// Validate validates the field
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *UpdateThemeForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2019-01-09 12:22:57 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// IsThemeExists checks if the theme is a theme available in the config.
|
|
|
|
func (f UpdateThemeForm) IsThemeExists() bool {
|
|
|
|
var exists bool
|
|
|
|
|
|
|
|
for _, v := range setting.UI.Themes {
|
2019-06-12 15:41:28 -04:00
|
|
|
if strings.EqualFold(v, f.Theme) {
|
2019-01-09 12:22:57 -05:00
|
|
|
exists = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return exists
|
|
|
|
}
|
|
|
|
|
2016-11-27 01:03:59 -05:00
|
|
|
// ChangePasswordForm form for changing password
|
2014-07-26 00:24:27 -04:00
|
|
|
type ChangePasswordForm struct {
|
2017-02-22 02:14:37 -05:00
|
|
|
OldPassword string `form:"old_password" binding:"MaxSize(255)"`
|
2015-08-17 14:30:33 -04:00
|
|
|
Password string `form:"password" binding:"Required;MaxSize(255)"`
|
2014-07-26 00:24:27 -04:00
|
|
|
Retype string `form:"retype"`
|
|
|
|
}
|
|
|
|
|
2017-03-14 20:52:01 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *ChangePasswordForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2014-07-26 00:24:27 -04:00
|
|
|
}
|
2014-11-12 06:48:50 -05:00
|
|
|
|
2017-03-17 10:16:08 -04:00
|
|
|
// AddOpenIDForm is for changing openid uri
|
|
|
|
type AddOpenIDForm struct {
|
2017-03-20 20:55:00 -04:00
|
|
|
Openid string `binding:"Required;MaxSize(256)"`
|
2017-03-17 10:16:08 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *AddOpenIDForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2017-03-17 10:16:08 -04:00
|
|
|
}
|
|
|
|
|
2017-04-26 09:10:43 -04:00
|
|
|
// AddKeyForm form for adding SSH/GPG key
|
|
|
|
type AddKeyForm struct {
|
2021-12-19 00:37:18 -05:00
|
|
|
Type string `binding:"OmitEmpty"`
|
|
|
|
Title string `binding:"Required;MaxSize(50)"`
|
|
|
|
Content string `binding:"Required"`
|
|
|
|
Signature string `binding:"OmitEmpty"`
|
|
|
|
KeyID string `binding:"OmitEmpty"`
|
|
|
|
Fingerprint string `binding:"OmitEmpty"`
|
|
|
|
IsWritable bool
|
2014-11-12 06:48:50 -05:00
|
|
|
}
|
|
|
|
|
2017-03-14 20:52:01 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *AddKeyForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2014-11-12 06:48:50 -05:00
|
|
|
}
|
|
|
|
|
2022-12-20 04:07:13 -05:00
|
|
|
// AddSecretForm for adding secrets
|
|
|
|
type AddSecretForm struct {
|
2023-06-20 18:54:15 -04:00
|
|
|
Name string `binding:"Required;MaxSize(255)"`
|
|
|
|
Data string `binding:"Required;MaxSize(65535)"`
|
2022-12-20 04:07:13 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Validate validates the fields
|
|
|
|
func (f *AddSecretForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-06-20 18:54:15 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
|
|
|
}
|
|
|
|
|
|
|
|
type EditVariableForm struct {
|
|
|
|
Name string `binding:"Required;MaxSize(255)"`
|
|
|
|
Data string `binding:"Required;MaxSize(65535)"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *EditVariableForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2022-12-20 04:07:13 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
|
|
|
}
|
|
|
|
|
2016-11-27 01:03:59 -05:00
|
|
|
// NewAccessTokenForm form for creating access token
|
2014-11-12 06:48:50 -05:00
|
|
|
type NewAccessTokenForm struct {
|
2023-11-28 22:47:05 -05:00
|
|
|
Name string `binding:"Required;MaxSize(255)" locale:"settings.token_name"`
|
2023-01-17 16:46:03 -05:00
|
|
|
Scope []string
|
2014-11-12 06:48:50 -05:00
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *NewAccessTokenForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2014-11-12 06:48:50 -05:00
|
|
|
}
|
2017-01-15 21:14:29 -05:00
|
|
|
|
2023-01-17 16:46:03 -05:00
|
|
|
func (f *NewAccessTokenForm) GetScope() (auth_model.AccessTokenScope, error) {
|
|
|
|
scope := strings.Join(f.Scope, ",")
|
|
|
|
s, err := auth_model.AccessTokenScope(scope).Normalize()
|
|
|
|
return s, err
|
|
|
|
}
|
|
|
|
|
2019-03-08 11:42:50 -05:00
|
|
|
// EditOAuth2ApplicationForm form for editing oauth2 applications
|
|
|
|
type EditOAuth2ApplicationForm struct {
|
2022-10-24 03:59:24 -04:00
|
|
|
Name string `binding:"Required;MaxSize(255)" form:"application_name"`
|
2023-06-05 03:00:12 -04:00
|
|
|
RedirectURIs string `binding:"Required" form:"redirect_uris"`
|
2022-10-24 03:59:24 -04:00
|
|
|
ConfidentialClient bool `form:"confidential_client"`
|
2019-03-08 11:42:50 -05:00
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *EditOAuth2ApplicationForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2019-03-08 11:42:50 -05:00
|
|
|
}
|
|
|
|
|
2017-01-15 21:14:29 -05:00
|
|
|
// TwoFactorAuthForm for logging in with 2FA token.
|
|
|
|
type TwoFactorAuthForm struct {
|
|
|
|
Passcode string `binding:"Required"`
|
|
|
|
}
|
|
|
|
|
2017-03-14 20:52:01 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *TwoFactorAuthForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2017-01-15 21:14:29 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// TwoFactorScratchAuthForm for logging in with 2FA scratch token.
|
|
|
|
type TwoFactorScratchAuthForm struct {
|
|
|
|
Token string `binding:"Required"`
|
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2021-01-26 10:36:53 -05:00
|
|
|
func (f *TwoFactorScratchAuthForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2017-01-15 21:14:29 -05:00
|
|
|
}
|
2018-05-19 10:12:37 -04:00
|
|
|
|
2022-01-14 10:03:31 -05:00
|
|
|
// WebauthnRegistrationForm for reserving an WebAuthn name
|
|
|
|
type WebauthnRegistrationForm struct {
|
2018-05-19 10:12:37 -04:00
|
|
|
Name string `binding:"Required"`
|
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2022-01-14 10:03:31 -05:00
|
|
|
func (f *WebauthnRegistrationForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2018-05-19 10:12:37 -04:00
|
|
|
}
|
|
|
|
|
2022-01-14 10:03:31 -05:00
|
|
|
// WebauthnDeleteForm for deleting WebAuthn keys
|
|
|
|
type WebauthnDeleteForm struct {
|
2018-05-19 10:12:37 -04:00
|
|
|
ID int64 `binding:"Required"`
|
|
|
|
}
|
|
|
|
|
2020-06-05 10:34:23 -04:00
|
|
|
// Validate validates the fields
|
2022-01-14 10:03:31 -05:00
|
|
|
func (f *WebauthnDeleteForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2021-01-30 03:55:53 -05:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
2018-05-19 10:12:37 -04:00
|
|
|
}
|
2022-03-30 04:42:47 -04:00
|
|
|
|
|
|
|
// PackageSettingForm form for package settings
|
|
|
|
type PackageSettingForm struct {
|
|
|
|
Action string
|
|
|
|
RepoID int64 `form:"repo_id"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// Validate validates the fields
|
|
|
|
func (f *PackageSettingForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
2023-05-20 21:50:53 -04:00
|
|
|
ctx := context.GetValidateContext(req)
|
2022-03-30 04:42:47 -04:00
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
|
|
|
}
|
2024-03-04 03:16:03 -05:00
|
|
|
|
|
|
|
type BlockUserForm struct {
|
|
|
|
Action string `binding:"Required;In(block,unblock,note)"`
|
|
|
|
Blockee string `binding:"Required"`
|
|
|
|
Note string
|
|
|
|
}
|
|
|
|
|
|
|
|
func (f *BlockUserForm) Validate(req *http.Request, errs binding.Errors) binding.Errors {
|
|
|
|
ctx := context.GetValidateContext(req)
|
|
|
|
return middleware.Validate(errs, ctx.Data, f, ctx.Locale)
|
|
|
|
}
|