"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/templates"
"code.gitea.io/gitea/modules/translation"
- "code.gitea.io/gitea/modules/util"
"code.gitea.io/gitea/modules/web/middleware"
"code.gitea.io/gitea/services/auth"
return ctx.Resp.Header()
}
-// Form returns request form as string with default
-func (ctx *Context) Form(key string, defaults ...string) string {
- return (*Forms)(ctx.Req).MustString(key, defaults...)
-}
-
-// FormTrim returns request form as string with default and trimmed spaces
-func (ctx *Context) FormTrim(key string, defaults ...string) string {
- return (*Forms)(ctx.Req).MustTrimmed(key, defaults...)
-}
-
-// FormStrings returns request form as strings with default
-func (ctx *Context) FormStrings(key string, defaults ...[]string) []string {
- return (*Forms)(ctx.Req).MustStrings(key, defaults...)
-}
-
-// FormInt returns request form as int with default
-func (ctx *Context) FormInt(key string, defaults ...int) int {
- return (*Forms)(ctx.Req).MustInt(key, defaults...)
-}
-
-// FormInt64 returns request form as int64 with default
-func (ctx *Context) FormInt64(key string, defaults ...int64) int64 {
- return (*Forms)(ctx.Req).MustInt64(key, defaults...)
-}
-
-// FormBool returns request form as bool with default
-func (ctx *Context) FormBool(key string, defaults ...bool) bool {
- return (*Forms)(ctx.Req).MustBool(key, defaults...)
-}
-
-// FormOptionalBool returns request form as OptionalBool with default
-func (ctx *Context) FormOptionalBool(key string, defaults ...util.OptionalBool) util.OptionalBool {
- return (*Forms)(ctx.Req).MustOptionalBool(key, defaults...)
-}
-
// HandleText handles HTTP status code
func (ctx *Context) HandleText(status int, title string) {
if (status/100 == 4) || (status/100 == 5) {
package context
import (
- "errors"
- "net/http"
- "net/url"
"strconv"
"strings"
- "text/template"
- "code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/util"
)
-// Forms a new enhancement of http.Request
-type Forms http.Request
-
-// Values returns http.Request values
-func (f *Forms) Values() url.Values {
- return (*http.Request)(f).Form
-}
-
-// String returns request form as string
-func (f *Forms) String(key string) (string, error) {
- return (*http.Request)(f).FormValue(key), nil
-}
-
-// Trimmed returns request form as string with trimed spaces left and right
-func (f *Forms) Trimmed(key string) (string, error) {
- return strings.TrimSpace((*http.Request)(f).FormValue(key)), nil
+// FormString returns the first value matching the provided key in the form as a string
+func (ctx *Context) FormString(key string) string {
+ return ctx.Req.FormValue(key)
}
-// Strings returns request form as strings
-func (f *Forms) Strings(key string) ([]string, error) {
- if (*http.Request)(f).Form == nil {
- if err := (*http.Request)(f).ParseMultipartForm(32 << 20); err != nil {
- return nil, err
+// FormStrings returns a string slice for the provided key from the form
+func (ctx *Context) FormStrings(key string) []string {
+ if ctx.Req.Form == nil {
+ if err := ctx.Req.ParseMultipartForm(32 << 20); err != nil {
+ return nil
}
}
- if v, ok := (*http.Request)(f).Form[key]; ok {
- return v, nil
- }
- return nil, errors.New("not exist")
-}
-
-// Escape returns request form as escaped string
-func (f *Forms) Escape(key string) (string, error) {
- return template.HTMLEscapeString((*http.Request)(f).FormValue(key)), nil
-}
-
-// Int returns request form as int
-func (f *Forms) Int(key string) (int, error) {
- return strconv.Atoi((*http.Request)(f).FormValue(key))
-}
-
-// Int32 returns request form as int32
-func (f *Forms) Int32(key string) (int32, error) {
- v, err := strconv.ParseInt((*http.Request)(f).FormValue(key), 10, 32)
- return int32(v), err
-}
-
-// Int64 returns request form as int64
-func (f *Forms) Int64(key string) (int64, error) {
- return strconv.ParseInt((*http.Request)(f).FormValue(key), 10, 64)
-}
-
-// Uint returns request form as uint
-func (f *Forms) Uint(key string) (uint, error) {
- v, err := strconv.ParseUint((*http.Request)(f).FormValue(key), 10, 64)
- return uint(v), err
-}
-
-// Uint32 returns request form as uint32
-func (f *Forms) Uint32(key string) (uint32, error) {
- v, err := strconv.ParseUint((*http.Request)(f).FormValue(key), 10, 32)
- return uint32(v), err
-}
-
-// Uint64 returns request form as uint64
-func (f *Forms) Uint64(key string) (uint64, error) {
- return strconv.ParseUint((*http.Request)(f).FormValue(key), 10, 64)
-}
-
-// Bool returns request form as bool
-func (f *Forms) Bool(key string) (bool, error) {
- return strconv.ParseBool((*http.Request)(f).FormValue(key))
-}
-
-// Float32 returns request form as float32
-func (f *Forms) Float32(key string) (float32, error) {
- v, err := strconv.ParseFloat((*http.Request)(f).FormValue(key), 64)
- return float32(v), err
-}
-
-// Float64 returns request form as float64
-func (f *Forms) Float64(key string) (float64, error) {
- return strconv.ParseFloat((*http.Request)(f).FormValue(key), 64)
-}
-
-// MustString returns request form as string with default
-func (f *Forms) MustString(key string, defaults ...string) string {
- if v := (*http.Request)(f).FormValue(key); len(v) > 0 {
+ if v, ok := ctx.Req.Form[key]; ok {
return v
}
- if len(defaults) > 0 {
- return defaults[0]
- }
- return ""
+ return nil
}
-// MustTrimmed returns request form as string with default
-func (f *Forms) MustTrimmed(key string, defaults ...string) string {
- return strings.TrimSpace(f.MustString(key, defaults...))
+// FormTrim returns the first value for the provided key in the form as a space trimmed string
+func (ctx *Context) FormTrim(key string) string {
+ return strings.TrimSpace(ctx.Req.FormValue(key))
}
-// MustStrings returns request form as strings with default
-func (f *Forms) MustStrings(key string, defaults ...[]string) []string {
- if (*http.Request)(f).Form == nil {
- if err := (*http.Request)(f).ParseMultipartForm(32 << 20); err != nil {
- log.Error("ParseMultipartForm: %v", err)
- return []string{}
- }
- }
-
- if v, ok := (*http.Request)(f).Form[key]; ok {
- return v
- }
- if len(defaults) > 0 {
- return defaults[0]
- }
- return []string{}
-}
-
-// MustEscape returns request form as escaped string with default
-func (f *Forms) MustEscape(key string, defaults ...string) string {
- if v := (*http.Request)(f).FormValue(key); len(v) > 0 {
- return template.HTMLEscapeString(v)
- }
- if len(defaults) > 0 {
- return defaults[0]
- }
- return ""
-}
-
-// MustInt returns request form as int with default
-func (f *Forms) MustInt(key string, defaults ...int) int {
- v, err := strconv.Atoi((*http.Request)(f).FormValue(key))
- if len(defaults) > 0 && err != nil {
- return defaults[0]
- }
- return v
-}
-
-// MustInt32 returns request form as int32 with default
-func (f *Forms) MustInt32(key string, defaults ...int32) int32 {
- v, err := strconv.ParseInt((*http.Request)(f).FormValue(key), 10, 32)
- if len(defaults) > 0 && err != nil {
- return defaults[0]
- }
- return int32(v)
-}
-
-// MustInt64 returns request form as int64 with default
-func (f *Forms) MustInt64(key string, defaults ...int64) int64 {
- v, err := strconv.ParseInt((*http.Request)(f).FormValue(key), 10, 64)
- if len(defaults) > 0 && err != nil {
- return defaults[0]
- }
+// FormInt returns the first value for the provided key in the form as an int
+func (ctx *Context) FormInt(key string) int {
+ v, _ := strconv.Atoi(ctx.Req.FormValue(key))
return v
}
-// MustUint returns request form as uint with default
-func (f *Forms) MustUint(key string, defaults ...uint) uint {
- v, err := strconv.ParseUint((*http.Request)(f).FormValue(key), 10, 64)
- if len(defaults) > 0 && err != nil {
- return defaults[0]
- }
- return uint(v)
-}
-
-// MustUint32 returns request form as uint32 with default
-func (f *Forms) MustUint32(key string, defaults ...uint32) uint32 {
- v, err := strconv.ParseUint((*http.Request)(f).FormValue(key), 10, 32)
- if len(defaults) > 0 && err != nil {
- return defaults[0]
- }
- return uint32(v)
-}
-
-// MustUint64 returns request form as uint64 with default
-func (f *Forms) MustUint64(key string, defaults ...uint64) uint64 {
- v, err := strconv.ParseUint((*http.Request)(f).FormValue(key), 10, 64)
- if len(defaults) > 0 && err != nil {
- return defaults[0]
- }
- return v
-}
-
-// MustFloat32 returns request form as float32 with default
-func (f *Forms) MustFloat32(key string, defaults ...float32) float32 {
- v, err := strconv.ParseFloat((*http.Request)(f).FormValue(key), 32)
- if len(defaults) > 0 && err != nil {
- return defaults[0]
- }
- return float32(v)
-}
-
-// MustFloat64 returns request form as float64 with default
-func (f *Forms) MustFloat64(key string, defaults ...float64) float64 {
- v, err := strconv.ParseFloat((*http.Request)(f).FormValue(key), 64)
- if len(defaults) > 0 && err != nil {
- return defaults[0]
- }
+// FormInt64 returns the first value for the provided key in the form as an int64
+func (ctx *Context) FormInt64(key string) int64 {
+ v, _ := strconv.ParseInt(ctx.Req.FormValue(key), 10, 64)
return v
}
-// MustBool returns request form as bool with default
-func (f *Forms) MustBool(key string, defaults ...bool) bool {
- v, err := strconv.ParseBool((*http.Request)(f).FormValue(key))
- if len(defaults) > 0 && err != nil {
- return defaults[0]
- }
+// FormBool returns true if the value for the provided key in the form is "1" or "true"
+func (ctx *Context) FormBool(key string) bool {
+ v, _ := strconv.ParseBool(ctx.Req.FormValue(key))
return v
}
-// MustOptionalBool returns request form as OptionalBool with default
-func (f *Forms) MustOptionalBool(key string, defaults ...util.OptionalBool) util.OptionalBool {
- value := (*http.Request)(f).FormValue(key)
+// FormOptionalBool returns an OptionalBoolTrue or OptionalBoolFalse if the value
+// for the provided key exists in the form else it returns OptionalBoolNone
+func (ctx *Context) FormOptionalBool(key string) util.OptionalBool {
+ value := ctx.Req.FormValue(key)
if len(value) == 0 {
return util.OptionalBoolNone
}
- v, err := strconv.ParseBool((*http.Request)(f).FormValue(key))
- if len(defaults) > 0 && err != nil {
- return defaults[0]
- }
+ v, _ := strconv.ParseBool(ctx.Req.FormValue(key))
return util.OptionalBoolOf(v)
}
// Check access.
if ctx.Repo.Permission.AccessMode == models.AccessModeNone {
- if ctx.Form("go-get") == "1" {
+ if ctx.FormString("go-get") == "1" {
EarlyResponseForGoGetMeta(ctx)
return
}
owner, err = models.GetUserByName(userName)
if err != nil {
if models.IsErrUserNotExist(err) {
- if ctx.Form("go-get") == "1" {
+ if ctx.FormString("go-get") == "1" {
EarlyResponseForGoGetMeta(ctx)
return
}
if err == nil {
RedirectToRepo(ctx, redirectRepoID)
} else if models.IsErrRepoRedirectNotExist(err) {
- if ctx.Form("go-get") == "1" {
+ if ctx.FormString("go-get") == "1" {
EarlyResponseForGoGetMeta(ctx)
return
}
}
}
- if ctx.Form("go-get") == "1" {
+ if ctx.FormString("go-get") == "1" {
ctx.Data["GoGetImport"] = ComposeGoGetImport(owner.Name, repo.Name)
prefix := setting.AppURL + path.Join(owner.Name, repo.Name, "src", "branch", ctx.Repo.BranchName)
ctx.Data["GoDocDirectory"] = prefix + "{/dir}"
// "$ref": "#/responses/forbidden"
listOptions := utils.GetListOptions(ctx)
- repoNames, count, err := repository.ListUnadoptedRepositories(ctx.Form("query"), &listOptions)
+ repoNames, count, err := repository.ListUnadoptedRepositories(ctx.FormString("query"), &listOptions)
if err != nil {
ctx.InternalServerError(err)
}
func sudo() func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
- sudo := ctx.Form("sudo")
+ sudo := ctx.FormString("sudo")
if len(sudo) == 0 {
sudo = ctx.Req.Header.Get("Sudo")
}
// "$ref": "#/responses/empty"
lastRead := int64(0)
- qLastRead := strings.Trim(ctx.Form("last_read_at"), " ")
+ qLastRead := strings.Trim(ctx.FormString("last_read_at"), " ")
if len(qLastRead) > 0 {
tmpLastRead, err := time.Parse(time.RFC3339, qLastRead)
if err != nil {
return
}
- targetStatus := statusStringToNotificationStatus(ctx.Form("to-status"))
+ targetStatus := statusStringToNotificationStatus(ctx.FormString("to-status"))
if targetStatus == 0 {
targetStatus = models.NotificationStatusRead
}
return
}
- targetStatus := statusStringToNotificationStatus(ctx.Form("to-status"))
+ targetStatus := statusStringToNotificationStatus(ctx.FormString("to-status"))
if targetStatus == 0 {
targetStatus = models.NotificationStatusRead
}
// "$ref": "#/responses/empty"
lastRead := int64(0)
- qLastRead := strings.Trim(ctx.Form("last_read_at"), " ")
+ qLastRead := strings.Trim(ctx.FormString("last_read_at"), " ")
if len(qLastRead) > 0 {
tmpLastRead, err := time.Parse(time.RFC3339, qLastRead)
if err != nil {
return
}
- targetStatus := statusStringToNotificationStatus(ctx.Form("to-status"))
+ targetStatus := statusStringToNotificationStatus(ctx.FormString("to-status"))
if targetStatus == 0 {
targetStatus = models.NotificationStatusRead
}
// "200":
// "$ref": "#/responses/LabelList"
- labels, err := models.GetLabelsByOrgID(ctx.Org.Organization.ID, ctx.Form("sort"), utils.GetListOptions(ctx))
+ labels, err := models.GetLabelsByOrgID(ctx.Org.Organization.ID, ctx.FormString("sort"), utils.GetListOptions(ctx))
if err != nil {
ctx.Error(http.StatusInternalServerError, "GetLabelsByOrgID", err)
return
opts := &models.SearchTeamOptions{
UserID: ctx.User.ID,
- Keyword: strings.TrimSpace(ctx.Form("q")),
+ Keyword: strings.TrimSpace(ctx.FormString("q")),
OrgID: ctx.Org.Organization.ID,
- IncludeDesc: ctx.Form("include_desc") == "" || ctx.FormBool("include_desc"),
+ IncludeDesc: ctx.FormString("include_desc") == "" || ctx.FormBool("include_desc"),
ListOptions: listOptions,
}
listOptions.PageSize = setting.Git.CommitsRangeSize
}
- sha := ctx.Form("sha")
+ sha := ctx.FormString("sha")
var baseCommit *git.Commit
if len(sha) == 0 {
}
var isClosed util.OptionalBool
- switch ctx.Form("state") {
+ switch ctx.FormString("state") {
case "closed":
isClosed = util.OptionalBoolTrue
case "all":
var issues []*models.Issue
var filteredCount int64
- keyword := strings.Trim(ctx.Form("q"), " ")
+ keyword := strings.Trim(ctx.FormString("q"), " ")
if strings.IndexByte(keyword, 0) >= 0 {
keyword = ""
}
}
var isPull util.OptionalBool
- switch ctx.Form("type") {
+ switch ctx.FormString("type") {
case "pulls":
isPull = util.OptionalBoolTrue
case "issues":
isPull = util.OptionalBoolNone
}
- labels := strings.TrimSpace(ctx.Form("labels"))
+ labels := strings.TrimSpace(ctx.FormString("labels"))
var includedLabelNames []string
if len(labels) > 0 {
includedLabelNames = strings.Split(labels, ",")
}
- milestones := strings.TrimSpace(ctx.Form("milestones"))
+ milestones := strings.TrimSpace(ctx.FormString("milestones"))
var includedMilestones []string
if len(milestones) > 0 {
includedMilestones = strings.Split(milestones, ",")
}
var isClosed util.OptionalBool
- switch ctx.Form("state") {
+ switch ctx.FormString("state") {
case "closed":
isClosed = util.OptionalBoolTrue
case "all":
var issues []*models.Issue
var filteredCount int64
- keyword := strings.Trim(ctx.Form("q"), " ")
+ keyword := strings.Trim(ctx.FormString("q"), " ")
if strings.IndexByte(keyword, 0) >= 0 {
keyword = ""
}
}
}
- if splitted := strings.Split(ctx.Form("labels"), ","); len(splitted) > 0 {
+ if splitted := strings.Split(ctx.FormString("labels"), ","); len(splitted) > 0 {
labelIDs, err = models.GetLabelIDsInRepoByNames(ctx.Repo.Repository.ID, splitted)
if err != nil {
ctx.Error(http.StatusInternalServerError, "GetLabelIDsInRepoByNames", err)
}
var mileIDs []int64
- if part := strings.Split(ctx.Form("milestones"), ","); len(part) > 0 {
+ if part := strings.Split(ctx.FormString("milestones"), ","); len(part) > 0 {
for i := range part {
// uses names and fall back to ids
// non existent milestones are discarded
listOptions := utils.GetListOptions(ctx)
var isPull util.OptionalBool
- switch ctx.Form("type") {
+ switch ctx.FormString("type") {
case "pulls":
isPull = util.OptionalBoolTrue
case "issues":
}
func getUserIDForFilter(ctx *context.APIContext, queryName string) int64 {
- userName := ctx.Form(queryName)
+ userName := ctx.FormString(queryName)
if len(userName) == 0 {
return 0
}
IssueID: issue.ID,
}
- qUser := strings.Trim(ctx.Form("user"), " ")
+ qUser := strings.Trim(ctx.FormString("user"), " ")
if qUser != "" {
user, err := models.GetUserByName(qUser)
if models.IsErrUserNotExist(err) {
}
// Filters
- qUser := strings.Trim(ctx.Form("user"), " ")
+ qUser := strings.Trim(ctx.FormString("user"), " ")
if qUser != "" {
user, err := models.GetUserByName(qUser)
if models.IsErrUserNotExist(err) {
var keys []*models.DeployKey
var err error
- fingerprint := ctx.Form("fingerprint")
+ fingerprint := ctx.FormString("fingerprint")
keyID := ctx.FormInt64("key_id")
if fingerprint != "" || keyID != 0 {
keys, err = models.SearchDeployKeys(ctx.Repo.Repository.ID, keyID, fingerprint)
// "200":
// "$ref": "#/responses/LabelList"
- labels, err := models.GetLabelsByRepoID(ctx.Repo.Repository.ID, ctx.Form("sort"), utils.GetListOptions(ctx))
+ labels, err := models.GetLabelsByRepoID(ctx.Repo.Repository.ID, ctx.FormString("sort"), utils.GetListOptions(ctx))
if err != nil {
ctx.Error(http.StatusInternalServerError, "GetLabelsByRepoID", err)
return
milestones, err := models.GetMilestones(models.GetMilestonesOption{
ListOptions: utils.GetListOptions(ctx),
RepoID: ctx.Repo.Repository.ID,
- State: api.StateType(ctx.Form("state")),
- Name: ctx.Form("name"),
+ State: api.StateType(ctx.FormString("state")),
+ Name: ctx.FormString("name"),
})
if err != nil {
ctx.Error(http.StatusInternalServerError, "GetMilestones", err)
}
var filename = header.Filename
- if query := ctx.Form("name"); query != "" {
+ if query := ctx.FormString("name"); query != "" {
filename = query
}
opts := &models.SearchRepoOptions{
ListOptions: utils.GetListOptions(ctx),
Actor: ctx.User,
- Keyword: strings.Trim(ctx.Form("q"), " "),
+ Keyword: strings.Trim(ctx.FormString("q"), " "),
OwnerID: ctx.FormInt64("uid"),
PriorityOwnerID: ctx.FormInt64("priority_owner_id"),
TeamID: ctx.FormInt64("team_id"),
TopicOnly: ctx.FormBool("topic"),
Collaborate: util.OptionalBoolNone,
- Private: ctx.IsSigned && (ctx.Form("private") == "" || ctx.FormBool("private")),
+ Private: ctx.IsSigned && (ctx.FormString("private") == "" || ctx.FormBool("private")),
Template: util.OptionalBoolNone,
StarredByID: ctx.FormInt64("starredBy"),
IncludeDescription: ctx.FormBool("includeDesc"),
}
- if ctx.Form("template") != "" {
+ if ctx.FormString("template") != "" {
opts.Template = util.OptionalBoolOf(ctx.FormBool("template"))
}
opts.Collaborate = util.OptionalBoolFalse
}
- var mode = ctx.Form("mode")
+ var mode = ctx.FormString("mode")
switch mode {
case "source":
opts.Fork = util.OptionalBoolFalse
return
}
- if ctx.Form("archived") != "" {
+ if ctx.FormString("archived") != "" {
opts.Archived = util.OptionalBoolOf(ctx.FormBool("archived"))
}
- if ctx.Form("is_private") != "" {
+ if ctx.FormString("is_private") != "" {
opts.IsPrivate = util.OptionalBoolOf(ctx.FormBool("is_private"))
}
- var sortMode = ctx.Form("sort")
+ var sortMode = ctx.FormString("sort")
if len(sortMode) > 0 {
- var sortOrder = ctx.Form("order")
+ var sortOrder = ctx.FormString("order")
if len(sortOrder) == 0 {
sortOrder = "asc"
}
return
}
- kw := ctx.Form("q")
+ kw := ctx.FormString("q")
listOptions := utils.GetListOptions(ctx)
var keys []*models.PublicKey
var err error
- fingerprint := ctx.Form("fingerprint")
+ fingerprint := ctx.FormString("fingerprint")
username := ctx.Params("username")
if fingerprint != "" {
opts := &models.SearchUserOptions{
Actor: ctx.User,
- Keyword: strings.Trim(ctx.Form("q"), " "),
+ Keyword: strings.Trim(ctx.FormString("q"), " "),
UID: ctx.FormInt64("uid"),
Type: models.UserTypeIndividual,
ListOptions: listOptions,
// prepareQueryArg unescape and trim a query arg
func prepareQueryArg(ctx *context.APIContext, name string) (value string, err error) {
- value, err = url.PathUnescape(ctx.Form(name))
+ value, err = url.PathUnescape(ctx.FormString(name))
value = strings.TrimSpace(value)
return
}
// AuthorizedPublicKeyByContent searches content as prefix (leak e-mail part)
// and returns public key found.
func AuthorizedPublicKeyByContent(ctx *context.PrivateContext) {
- content := ctx.Form("content")
+ content := ctx.FormString("content")
publicKey, err := models.SearchPublicKeyByContent(content)
if err != nil {
// SendTestMail send test mail to confirm mail service is OK
func SendTestMail(ctx *context.Context) {
- email := ctx.Form("email")
+ email := ctx.FormString("email")
// Send a test email to the user's email address and redirect back to Config
if err := mailer.SendTestMail(email); err != nil {
ctx.Flash.Error(ctx.Tr("admin.config.test_mail_failed", email, err))
ctx.Status(404)
return
}
- timeout, err := time.ParseDuration(ctx.Form("timeout"))
+ timeout, err := time.ParseDuration(ctx.FormString("timeout"))
if err != nil {
timeout = -1
}
ctx.Redirect(setting.AppSubURL + "/admin/monitor/queue/" + strconv.FormatInt(qid, 10))
return
}
- timeout, err := time.ParseDuration(ctx.Form("timeout"))
+ timeout, err := time.ParseDuration(ctx.FormString("timeout"))
if err != nil {
ctx.Flash.Error(ctx.Tr("admin.monitor.queue.pool.addworkers.musttimeoutduration"))
ctx.Redirect(setting.AppSubURL + "/admin/monitor/queue/" + strconv.FormatInt(qid, 10))
return
}
- maxNumberStr := ctx.Form("max-number")
- numberStr := ctx.Form("number")
- timeoutStr := ctx.Form("timeout")
+ maxNumberStr := ctx.FormString("max-number")
+ numberStr := ctx.FormString("number")
+ timeoutStr := ctx.FormString("timeout")
var err error
var maxNumber, number int
orderBy models.SearchEmailOrderBy
)
- ctx.Data["SortType"] = ctx.Form("sort")
- switch ctx.Form("sort") {
+ ctx.Data["SortType"] = ctx.FormString("sort")
+ switch ctx.FormString("sort") {
case "email":
orderBy = models.SearchEmailOrderByEmail
case "reverseemail":
opts.Keyword = ctx.FormTrim("q")
opts.SortType = orderBy
- if len(ctx.Form("is_activated")) != 0 {
+ if len(ctx.FormString("is_activated")) != 0 {
opts.IsActivated = util.OptionalBoolOf(ctx.FormBool("activated"))
}
- if len(ctx.Form("is_primary")) != 0 {
+ if len(ctx.FormString("is_primary")) != 0 {
opts.IsPrimary = util.OptionalBoolOf(ctx.FormBool("primary"))
}
truefalse := map[string]bool{"1": true, "0": false}
uid := ctx.FormInt64("uid")
- email := ctx.Form("email")
- primary, okp := truefalse[ctx.Form("primary")]
- activate, oka := truefalse[ctx.Form("activate")]
+ email := ctx.FormString("email")
+ primary, okp := truefalse[ctx.FormString("primary")]
+ activate, oka := truefalse[ctx.FormString("activate")]
if uid == 0 || len(email) == 0 || !okp || !oka {
ctx.Error(http.StatusBadRequest)
ctx.Flash.Success(ctx.Tr("repo.settings.deletion_success"))
ctx.JSON(http.StatusOK, map[string]interface{}{
- "redirect": setting.AppSubURL + "/admin/repos?page=" + ctx.Form("page") + "&sort=" + ctx.Form("sort"),
+ "redirect": setting.AppSubURL + "/admin/repos?page=" + ctx.FormString("page") + "&sort=" + ctx.FormString("sort"),
})
}
doSearch := ctx.FormBool("search")
ctx.Data["search"] = doSearch
- q := ctx.Form("q")
+ q := ctx.FormString("q")
if !doSearch {
pager := context.NewPagination(0, opts.PageSize, opts.Page, 5)
// AdoptOrDeleteRepository adopts or deletes a repository
func AdoptOrDeleteRepository(ctx *context.Context) {
- dir := ctx.Form("id")
- action := ctx.Form("action")
+ dir := ctx.FormString("id")
+ action := ctx.FormString("action")
page := ctx.FormInt("page")
- q := ctx.Form("q")
+ q := ctx.FormString("q")
dirSplit := strings.SplitN(dir, "/", 2)
if len(dirSplit) != 2 {
ctx.Data["PageIsExplore"] = true
ctx.Data["PageIsExploreCode"] = true
- language := strings.TrimSpace(ctx.Form("l"))
- keyword := strings.TrimSpace(ctx.Form("q"))
+ language := strings.TrimSpace(ctx.FormString("l"))
+ keyword := strings.TrimSpace(ctx.FormString("q"))
page := ctx.FormInt("page")
if page <= 0 {
page = 1
}
- queryType := strings.TrimSpace(ctx.Form("t"))
+ queryType := strings.TrimSpace(ctx.FormString("t"))
isMatch := queryType == "match"
var (
orderBy models.SearchOrderBy
)
- ctx.Data["SortType"] = ctx.Form("sort")
- switch ctx.Form("sort") {
+ ctx.Data["SortType"] = ctx.FormString("sort")
+ switch ctx.FormString("sort") {
case "newest":
orderBy = models.SearchOrderByNewest
case "oldest":
orderBy = models.SearchOrderByRecentUpdated
}
- keyword := strings.Trim(ctx.Form("q"), " ")
+ keyword := strings.Trim(ctx.FormString("q"), " ")
topicOnly := ctx.FormBool("topic")
ctx.Data["TopicOnly"] = topicOnly
orderBy models.SearchOrderBy
)
- ctx.Data["SortType"] = ctx.Form("sort")
- switch ctx.Form("sort") {
+ ctx.Data["SortType"] = ctx.FormString("sort")
+ switch ctx.FormString("sort") {
case "newest":
orderBy = models.SearchOrderByIDReverse
case "oldest":
orderBy = models.SearchOrderByAlphabetically
}
- opts.Keyword = strings.Trim(ctx.Form("q"), " ")
+ opts.Keyword = strings.Trim(ctx.FormString("q"), " ")
opts.OrderBy = orderBy
if len(opts.Keyword) == 0 || isKeywordValid(opts.Keyword) {
users, count, err = models.SearchUsers(opts)
)
func goGet(ctx *context.Context) {
- if ctx.Req.Method != "GET" || ctx.Form("go-get") != "1" || len(ctx.Req.URL.Query()) > 1 {
+ if ctx.Req.Method != "GET" || ctx.FormString("go-get") != "1" || len(ctx.Req.URL.Query()) > 1 {
return
}
}
var orderBy models.SearchOrderBy
- ctx.Data["SortType"] = ctx.Form("sort")
- switch ctx.Form("sort") {
+ ctx.Data["SortType"] = ctx.FormString("sort")
+ switch ctx.FormString("sort") {
case "newest":
orderBy = models.SearchOrderByNewest
case "oldest":
orderBy = models.SearchOrderByRecentUpdated
}
- keyword := strings.Trim(ctx.Form("q"), " ")
+ keyword := strings.Trim(ctx.FormString("q"), " ")
ctx.Data["Keyword"] = keyword
page := ctx.FormInt("page")
// RetrieveLabels find all the labels of an organization
func RetrieveLabels(ctx *context.Context) {
- labels, err := models.GetLabelsByOrgID(ctx.Org.Organization.ID, ctx.Form("sort"), models.ListOptions{})
+ labels, err := models.GetLabelsByOrgID(ctx.Org.Organization.ID, ctx.FormString("sort"), models.ListOptions{})
if err != nil {
ctx.ServerError("RetrieveLabels.GetLabels", err)
return
}
ctx.Data["Labels"] = labels
ctx.Data["NumLabels"] = len(labels)
- ctx.Data["SortType"] = ctx.Form("sort")
+ ctx.Data["SortType"] = ctx.FormString("sort")
}
// NewLabel create new label for organization
org := ctx.Org.Organization
if ctx.Req.Method == "POST" {
- if org.Name != ctx.Form("org_name") {
+ if org.Name != ctx.FormString("org_name") {
ctx.Data["Err_OrgName"] = true
ctx.RenderWithErr(ctx.Tr("form.enterred_invalid_org_name"), tplSettingsDelete, nil)
return
return
}
- page := ctx.Form("page")
+ page := ctx.FormString("page")
var err error
switch ctx.Params(":action") {
case "join":
ctx.Error(http.StatusNotFound)
return
}
- uname := utils.RemoveUsernameParameterSuffix(strings.ToLower(ctx.Form("uname")))
+ uname := utils.RemoveUsernameParameterSuffix(strings.ToLower(ctx.FormString("uname")))
var u *models.User
u, err = models.GetUserByName(uname)
if err != nil {
action := ctx.Params(":action")
switch action {
case "add":
- repoName := path.Base(ctx.Form("repo_name"))
+ repoName := path.Base(ctx.FormString("repo_name"))
var repo *models.Repository
repo, err = models.GetRepositoryByName(ctx.Org.Organization.ID, repoName)
if err != nil {
// DeleteAttachment response for deleting issue's attachment
func DeleteAttachment(ctx *context.Context) {
- file := ctx.Form("file")
+ file := ctx.FormString("file")
attach, err := models.GetAttachmentByUUID(file)
if err != nil {
ctx.Error(http.StatusBadRequest, err.Error())
// DeleteBranchPost responses for delete merged branch
func DeleteBranchPost(ctx *context.Context) {
defer redirect(ctx)
- branchName := ctx.Form("name")
+ branchName := ctx.FormString("name")
if err := repo_service.DeleteBranch(ctx.User, ctx.Repo.Repository, ctx.Repo.GitRepo, branchName); err != nil {
switch {
defer redirect(ctx)
branchID := ctx.FormInt64("branch_id")
- branchName := ctx.Form("name")
+ branchName := ctx.FormString("name")
deletedBranch, err := ctx.Repo.Repository.GetDeletedBranchByID(branchID)
if err != nil {
ctx.Data["PageIsCommits"] = true
ctx.Data["PageIsViewCode"] = true
- query := strings.Trim(ctx.Form("q"), " ")
+ query := strings.Trim(ctx.FormString("q"), " ")
if len(query) == 0 {
ctx.Redirect(ctx.Repo.RepoLink + "/commits/" + ctx.Repo.BranchNameSubURL())
return
idxRight := ctx.FormInt("right")
leftHunkSize := ctx.FormInt("left_hunk_size")
rightHunkSize := ctx.FormInt("right_hunk_size")
- anchor := ctx.Form("anchor")
- direction := ctx.Form("direction")
- filePath := ctx.Form("path")
+ anchor := ctx.FormString("anchor")
+ direction := ctx.FormString("direction")
+ filePath := ctx.FormString("path")
gitRepo := ctx.Repo.GitRepo
chunkSize := gitdiff.BlobExcerptChunkSize
commit, err := gitRepo.GetCommit(commitID)
username := ctx.Params(":username")
reponame := strings.TrimSuffix(ctx.Params(":reponame"), ".git")
- if ctx.Form("go-get") == "1" {
+ if ctx.FormString("go-get") == "1" {
context.EarlyResponseForGoGetMeta(ctx)
return
}
var isPull, receivePack bool
- service := ctx.Form("service")
+ service := ctx.FormString("service")
if service == "git-receive-pack" ||
strings.HasSuffix(ctx.Req.URL.Path, "git-receive-pack") {
isPull = false
func issues(ctx *context.Context, milestoneID, projectID int64, isPullOption util.OptionalBool) {
var err error
- viewType := ctx.Form("type")
- sortType := ctx.Form("sort")
+ viewType := ctx.FormString("type")
+ sortType := ctx.FormString("sort")
types := []string{"all", "your_repositories", "assigned", "created_by", "mentioned", "review_requested"}
if !util.IsStringInSlice(viewType, types, true) {
viewType = "all"
repo := ctx.Repo.Repository
var labelIDs []int64
- selectLabels := ctx.Form("labels")
+ selectLabels := ctx.FormString("labels")
if len(selectLabels) > 0 && selectLabels != "0" {
labelIDs, err = base.StringsToInt64s(strings.Split(selectLabels, ","))
if err != nil {
}
}
- keyword := strings.Trim(ctx.Form("q"), " ")
+ keyword := strings.Trim(ctx.FormString("q"), " ")
if bytes.Contains([]byte(keyword), []byte{0x00}) {
keyword = ""
}
}
}
- isShowClosed := ctx.Form("state") == "closed"
+ isShowClosed := ctx.FormString("state") == "closed"
// if open issues are zero and close don't, use closed as default
- if len(ctx.Form("state")) == 0 && issueStats.OpenCount == 0 && issueStats.ClosedCount != 0 {
+ if len(ctx.FormString("state")) == 0 && issueStats.OpenCount == 0 && issueStats.ClosedCount != 0 {
isShowClosed = true
}
}
if repo.Owner.IsOrganization() {
- orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.Form("sort"), models.ListOptions{})
+ orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.FormString("sort"), models.ListOptions{})
if err != nil {
ctx.ServerError("GetLabelsByOrgID", err)
return
// Get milestones
ctx.Data["Milestones"], err = models.GetMilestones(models.GetMilestonesOption{
RepoID: ctx.Repo.Repository.ID,
- State: api.StateType(ctx.Form("state")),
+ State: api.StateType(ctx.FormString("state")),
})
if err != nil {
ctx.ServerError("GetAllRepoMilestones", err)
}
ctx.Data["Labels"] = labels
if repo.Owner.IsOrganization() {
- orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.Form("sort"), models.ListOptions{})
+ orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.FormString("sort"), models.ListOptions{})
if err != nil {
return nil
}
func setTemplateIfExists(ctx *context.Context, ctxDataKey string, possibleDirs []string, possibleFiles []string) {
templateCandidates := make([]string, 0, len(possibleFiles))
- if ctx.Form("template") != "" {
+ if ctx.FormString("template") != "" {
for _, dirName := range possibleDirs {
- templateCandidates = append(templateCandidates, path.Join(dirName, ctx.Form("template")))
+ templateCandidates = append(templateCandidates, path.Join(dirName, ctx.FormString("template")))
}
}
templateCandidates = append(templateCandidates, possibleFiles...) // Append files to the end because they should be fallback
if repoLabels, err := models.GetLabelsByRepoID(ctx.Repo.Repository.ID, "", models.ListOptions{}); err == nil {
ctx.Data["Labels"] = repoLabels
if ctx.Repo.Owner.IsOrganization() {
- if orgLabels, err := models.GetLabelsByOrgID(ctx.Repo.Owner.ID, ctx.Form("sort"), models.ListOptions{}); err == nil {
+ if orgLabels, err := models.GetLabelsByOrgID(ctx.Repo.Owner.ID, ctx.FormString("sort"), models.ListOptions{}); err == nil {
ctx.Data["OrgLabels"] = orgLabels
repoLabels = append(repoLabels, orgLabels...)
}
ctx.Data["RequireSimpleMDE"] = true
ctx.Data["RequireTribute"] = true
ctx.Data["PullRequestWorkInProgressPrefixes"] = setting.Repository.PullRequest.WorkInProgressPrefixes
- title := ctx.Form("title")
+ title := ctx.FormString("title")
ctx.Data["TitleQuery"] = title
- body := ctx.Form("body")
+ body := ctx.FormString("body")
ctx.Data["BodyQuery"] = body
ctx.Data["IsProjectsEnabled"] = ctx.Repo.CanRead(models.UnitTypeProjects)
ctx.Data["Labels"] = labels
if repo.Owner.IsOrganization() {
- orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.Form("sort"), models.ListOptions{})
+ orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.FormString("sort"), models.ListOptions{})
if err != nil {
ctx.ServerError("GetLabelsByOrgID", err)
return
}
func getActionIssues(ctx *context.Context) []*models.Issue {
- commaSeparatedIssueIDs := ctx.Form("issue_ids")
+ commaSeparatedIssueIDs := ctx.FormString("issue_ids")
if len(commaSeparatedIssueIDs) == 0 {
return nil
}
return
}
- content := ctx.Form("content")
+ content := ctx.FormString("content")
if err := issue_service.ChangeContent(issue, ctx.User, content); err != nil {
ctx.ServerError("ChangeContent", err)
return
}
content, err := markdown.RenderString(&markup.RenderContext{
- URLPrefix: ctx.Form("context"),
+ URLPrefix: ctx.FormString("context"),
Metas: ctx.Repo.Repository.ComposeMetas(),
GitRepo: ctx.Repo.GitRepo,
}, issue.Content)
}
assigneeID := ctx.FormInt64("id")
- action := ctx.Form("action")
+ action := ctx.FormString("action")
for _, issue := range issues {
switch action {
}
reviewID := ctx.FormInt64("id")
- action := ctx.Form("action")
+ action := ctx.FormString("action")
// TODO: Not support 'clear' now
if action != "attach" && action != "detach" {
}
var isClosed bool
- switch action := ctx.Form("action"); action {
+ switch action := ctx.FormString("action"); action {
case "open":
isClosed = false
case "close":
}
oldContent := comment.Content
- comment.Content = ctx.Form("content")
+ comment.Content = ctx.FormString("content")
if len(comment.Content) == 0 {
ctx.JSON(http.StatusOK, map[string]interface{}{
"content": "",
}
content, err := markdown.RenderString(&markup.RenderContext{
- URLPrefix: ctx.Form("context"),
+ URLPrefix: ctx.FormString("context"),
Metas: ctx.Repo.Repository.ComposeMetas(),
GitRepo: ctx.Repo.GitRepo,
}, comment.Content)
// RetrieveLabels find all the labels of a repository and organization
func RetrieveLabels(ctx *context.Context) {
- labels, err := models.GetLabelsByRepoID(ctx.Repo.Repository.ID, ctx.Form("sort"), models.ListOptions{})
+ labels, err := models.GetLabelsByRepoID(ctx.Repo.Repository.ID, ctx.FormString("sort"), models.ListOptions{})
if err != nil {
ctx.ServerError("RetrieveLabels.GetLabels", err)
return
ctx.Data["Labels"] = labels
if ctx.Repo.Owner.IsOrganization() {
- orgLabels, err := models.GetLabelsByOrgID(ctx.Repo.Owner.ID, ctx.Form("sort"), models.ListOptions{})
+ orgLabels, err := models.GetLabelsByOrgID(ctx.Repo.Owner.ID, ctx.FormString("sort"), models.ListOptions{})
if err != nil {
ctx.ServerError("GetLabelsByOrgID", err)
return
}
}
ctx.Data["NumLabels"] = len(labels)
- ctx.Data["SortType"] = ctx.Form("sort")
+ ctx.Data["SortType"] = ctx.FormString("sort")
}
// NewLabel create new label for repository
return
}
- switch action := ctx.Form("action"); action {
+ switch action := ctx.FormString("action"); action {
case "clear":
for _, issue := range issues {
if err := issue_service.ClearLabels(issue, ctx.User); err != nil {
ctx.NotFound("LFSLocks", nil)
return
}
- originalPath := ctx.Form("path")
+ originalPath := ctx.FormString("path")
lockPath := originalPath
if len(lockPath) == 0 {
ctx.Flash.Error(ctx.Tr("repo.settings.lfs_invalid_locking_path", originalPath))
ctx.NotFound("LFSFind", nil)
return
}
- oid := ctx.Form("oid")
+ oid := ctx.FormString("oid")
size := ctx.FormInt64("size")
if len(oid) == 0 || size == 0 {
ctx.NotFound("LFSFind", nil)
return
}
- sha := ctx.Form("sha")
+ sha := ctx.FormString("sha")
ctx.Data["Title"] = oid
ctx.Data["PageIsSettingsLFS"] = true
var hash git.SHA1
// SetDiffViewStyle set diff style as render variable
func SetDiffViewStyle(ctx *context.Context) {
- queryStyle := ctx.Form("style")
+ queryStyle := ctx.FormString("style")
if !ctx.IsSigned {
ctx.Data["IsSplitStyle"] = queryStyle == "split"
// SetWhitespaceBehavior set whitespace behavior as render variable
func SetWhitespaceBehavior(ctx *context.Context) {
- whitespaceBehavior := ctx.Form("whitespace")
+ whitespaceBehavior := ctx.FormString("whitespace")
switch whitespaceBehavior {
case "ignore-all", "ignore-eol", "ignore-change":
ctx.Data["WhitespaceBehavior"] = whitespaceBehavior
setMigrationContextData(ctx, serviceType)
if serviceType == 0 {
- ctx.Data["Org"] = ctx.Form("org")
- ctx.Data["Mirror"] = ctx.Form("mirror")
+ ctx.Data["Org"] = ctx.FormString("org")
+ ctx.Data["Mirror"] = ctx.FormString("mirror")
ctx.HTML(http.StatusOK, tplMigrate)
return
}
ctx.Data["private"] = getRepoPrivate(ctx)
- ctx.Data["mirror"] = ctx.Form("mirror") == "1"
- ctx.Data["lfs"] = ctx.Form("lfs") == "1"
- ctx.Data["wiki"] = ctx.Form("wiki") == "1"
- ctx.Data["milestones"] = ctx.Form("milestones") == "1"
- ctx.Data["labels"] = ctx.Form("labels") == "1"
- ctx.Data["issues"] = ctx.Form("issues") == "1"
- ctx.Data["pull_requests"] = ctx.Form("pull_requests") == "1"
- ctx.Data["releases"] = ctx.Form("releases") == "1"
+ ctx.Data["mirror"] = ctx.FormString("mirror") == "1"
+ ctx.Data["lfs"] = ctx.FormString("lfs") == "1"
+ ctx.Data["wiki"] = ctx.FormString("wiki") == "1"
+ ctx.Data["milestones"] = ctx.FormString("milestones") == "1"
+ ctx.Data["labels"] = ctx.FormString("labels") == "1"
+ ctx.Data["issues"] = ctx.FormString("issues") == "1"
+ ctx.Data["pull_requests"] = ctx.FormString("pull_requests") == "1"
+ ctx.Data["releases"] = ctx.FormString("releases") == "1"
ctxUser := checkContextUser(ctx, ctx.FormInt64("org"))
if ctx.Written() {
ctx.Data["PageIsIssueList"] = true
ctx.Data["PageIsMilestones"] = true
- isShowClosed := ctx.Form("state") == "closed"
+ isShowClosed := ctx.FormString("state") == "closed"
stats, err := models.GetMilestonesStatsByRepoCond(builder.And(builder.Eq{"id": ctx.Repo.Repository.ID}))
if err != nil {
ctx.ServerError("MilestoneStats", err)
ctx.Data["OpenCount"] = stats.OpenCount
ctx.Data["ClosedCount"] = stats.ClosedCount
- sortType := ctx.Form("sort")
+ sortType := ctx.FormString("sort")
- keyword := strings.Trim(ctx.Form("q"), " ")
+ keyword := strings.Trim(ctx.FormString("q"), " ")
page := ctx.FormInt("page")
if page <= 1 {
// TriggerTask response for a trigger task request
func TriggerTask(ctx *context.Context) {
pusherID := ctx.FormInt64("pusher")
- branch := ctx.Form("branch")
- secret := ctx.Form("secret")
+ branch := ctx.FormString("branch")
+ secret := ctx.FormString("secret")
if len(branch) == 0 || len(secret) == 0 || pusherID <= 0 {
ctx.Error(http.StatusNotFound)
log.Trace("TriggerTask: branch or secret is empty, or pusher ID is not valid")
// UpdateResolveConversation add or remove an Conversation resolved mark
func UpdateResolveConversation(ctx *context.Context) {
- origin := ctx.Form("origin")
- action := ctx.Form("action")
+ origin := ctx.FormString("origin")
+ action := ctx.FormString("action")
commentID := ctx.FormInt64("comment_id")
comment, err := models.GetCommentByID(commentID)
ctx.Data["RequireSimpleMDE"] = true
ctx.Data["RequireTribute"] = true
ctx.Data["tag_target"] = ctx.Repo.Repository.DefaultBranch
- if tagName := ctx.Form("tag"); len(tagName) > 0 {
+ if tagName := ctx.FormString("tag"); len(tagName) > 0 {
rel, err := models.GetRelease(ctx.Repo.Repository.ID, tagName)
if err != nil && !models.IsErrReleaseNotExist(err) {
ctx.ServerError("GetRelease", err)
return
}
- ctx.Repo.Repository.Description = ctx.Form("desc")
- ctx.Repo.Repository.Website = ctx.Form("site")
+ ctx.Repo.Repository.Description = ctx.FormString("desc")
+ ctx.Repo.Repository.Website = ctx.FormString("site")
err = models.UpdateRepository(ctx.Repo.Repository, false)
}
return
}
- ctx.RedirectToFirst(ctx.Form("redirect_to"), ctx.Repo.RepoLink)
+ ctx.RedirectToFirst(ctx.FormString("redirect_to"), ctx.Repo.RepoLink)
}
func acceptOrRejectRepoTransfer(ctx *context.Context, accept bool) error {
ctx.Redirect(ctx.Repo.RepoLink, 302)
return
}
- language := strings.TrimSpace(ctx.Form("l"))
- keyword := strings.TrimSpace(ctx.Form("q"))
+ language := strings.TrimSpace(ctx.FormString("l"))
+ keyword := strings.TrimSpace(ctx.FormString("q"))
page := ctx.FormInt("page")
if page <= 0 {
page = 1
}
- queryType := strings.TrimSpace(ctx.Form("t"))
+ queryType := strings.TrimSpace(ctx.FormString("t"))
isMatch := queryType == "match"
total, searchResults, searchResultLanguages, err := code_indexer.PerformSearch([]int64{ctx.Repo.Repository.ID},
repo := ctx.Repo.Repository
- switch ctx.Form("action") {
+ switch ctx.FormString("action") {
case "update":
if ctx.HasError() {
ctx.HTML(http.StatusOK, tplSettingsOptions)
return
}
- newOwner, err := models.GetUserByName(ctx.Form("new_owner_name"))
+ newOwner, err := models.GetUserByName(ctx.FormString("new_owner_name"))
if err != nil {
if models.IsErrUserNotExist(err) {
ctx.RenderWithErr(ctx.Tr("form.enterred_invalid_owner_name"), tplSettingsOptions, nil)
// CollaborationPost response for actions for a collaboration of a repository
func CollaborationPost(ctx *context.Context) {
- name := utils.RemoveUsernameParameterSuffix(strings.ToLower(ctx.Form("collaborator")))
+ name := utils.RemoveUsernameParameterSuffix(strings.ToLower(ctx.FormString("collaborator")))
if len(name) == 0 || ctx.Repo.Owner.LowerName == name {
ctx.Redirect(setting.AppSubURL + ctx.Req.URL.Path)
return
return
}
- name := utils.RemoveUsernameParameterSuffix(strings.ToLower(ctx.Form("team")))
+ name := utils.RemoveUsernameParameterSuffix(strings.ToLower(ctx.FormString("team")))
if len(name) == 0 {
ctx.Redirect(ctx.Repo.RepoLink + "/settings/collaboration")
return
}
return
}
- hook.Content = ctx.Form("content")
+ hook.Content = ctx.FormString("content")
if err = hook.Update(); err != nil {
ctx.ServerError("hook.Update", err)
return
repo := ctx.Repo.Repository
- switch ctx.Form("action") {
+ switch ctx.FormString("action") {
case "default_branch":
if ctx.HasError() {
ctx.HTML(http.StatusOK, tplBranches)
return
}
- branch := ctx.Form("branch")
+ branch := ctx.FormString("branch")
if !ctx.Repo.GitRepo.IsBranchExist(branch) {
ctx.Status(404)
return
}
var topics = make([]string, 0)
- var topicsStr = strings.TrimSpace(ctx.Form("topics"))
+ var topicsStr = strings.TrimSpace(ctx.FormString("topics"))
if len(topicsStr) > 0 {
topics = strings.Split(topicsStr, ",")
}
isTextFile := st.IsText()
isLFSFile := false
- isDisplayingSource := ctx.Form("display") == "source"
+ isDisplayingSource := ctx.FormString("display") == "source"
isDisplayingRendered := !isDisplayingSource
//Check for LFS meta file
return true
}
- redirectTo := ctx.Form("redirect_to")
+ redirectTo := ctx.FormString("redirect_to")
if len(redirectTo) > 0 {
middleware.SetRedirectToCookie(ctx.Resp, redirectTo)
} else {
// Activate render activate user page
func Activate(ctx *context.Context) {
- code := ctx.Form("code")
+ code := ctx.FormString("code")
if len(code) == 0 {
ctx.Data["IsActivatePage"] = true
// ActivatePost handles account activation with password check
func ActivatePost(ctx *context.Context) {
- code := ctx.Form("code")
+ code := ctx.FormString("code")
if len(code) == 0 {
ctx.Redirect(setting.AppSubURL + "/user/activate")
return
// if account is local account, verify password
if user.LoginSource == 0 {
- password := ctx.Form("password")
+ password := ctx.FormString("password")
if len(password) == 0 {
ctx.Data["Code"] = code
ctx.Data["NeedsPassword"] = true
// ActivateEmail render the activate email page
func ActivateEmail(ctx *context.Context) {
- code := ctx.Form("code")
- emailStr := ctx.Form("email")
+ code := ctx.FormString("code")
+ emailStr := ctx.FormString("email")
// Verify code.
if email := models.VerifyActiveEmailCode(code, emailStr); email != nil {
return
}
- email := ctx.Form("email")
+ email := ctx.FormString("email")
ctx.Data["Email"] = email
ctx.Data["IsResetRequest"] = true
}
ctx.Data["IsResetRequest"] = true
- email := ctx.Form("email")
+ email := ctx.FormString("email")
ctx.Data["Email"] = email
u, err := models.GetUserByEmail(email)
}
func commonResetPassword(ctx *context.Context) (*models.User, *models.TwoFactor) {
- code := ctx.Form("code")
+ code := ctx.FormString("code")
ctx.Data["Title"] = ctx.Tr("auth.reset_password")
ctx.Data["Code"] = code
}
// Validate password length.
- passwd := ctx.Form("password")
+ passwd := ctx.FormString("password")
if len(passwd) < setting.MinPasswordLength {
ctx.Data["IsResetForm"] = true
ctx.Data["Err_Password"] = true
regenerateScratchToken := false
if twofa != nil {
if ctx.FormBool("scratch_code") {
- if !twofa.VerifyScratchToken(ctx.Form("token")) {
+ if !twofa.VerifyScratchToken(ctx.FormString("token")) {
ctx.Data["IsResetForm"] = true
ctx.Data["Err_Token"] = true
ctx.RenderWithErr(ctx.Tr("auth.twofa_scratch_token_incorrect"), tplResetPassword, nil)
}
regenerateScratchToken = true
} else {
- passcode := ctx.Form("passcode")
+ passcode := ctx.FormString("passcode")
ok, err := twofa.ValidateTOTP(passcode)
if err != nil {
ctx.Error(http.StatusInternalServerError, "ValidateTOTP", err.Error())
log.Trace("User password reset: %s", u.Name)
ctx.Data["IsResetFailed"] = true
- remember := len(ctx.Form("remember")) != 0
+ remember := len(ctx.FormString("remember")) != 0
if regenerateScratchToken {
// Invalidate the scratch token.
func SignInOpenID(ctx *context.Context) {
ctx.Data["Title"] = ctx.Tr("sign_in")
- if ctx.Form("openid.return_to") != "" {
+ if ctx.FormString("openid.return_to") != "" {
signInOpenIDVerify(ctx)
return
}
return
}
- redirectTo := ctx.Form("redirect_to")
+ redirectTo := ctx.FormString("redirect_to")
if len(redirectTo) > 0 {
middleware.SetRedirectToCookie(ctx.Resp, redirectTo)
} else {
IncludePrivate: true,
OnlyPerformedBy: false,
IncludeDeleted: false,
- Date: ctx.Form("date"),
+ Date: ctx.FormString("date"),
})
if ctx.Written() {
repoCond = userRepoCond
repoIDs []int64
- reposQuery = ctx.Form("repos")
- isShowClosed = ctx.Form("state") == "closed"
- sortType = ctx.Form("sort")
+ reposQuery = ctx.FormString("repos")
+ isShowClosed = ctx.FormString("state") == "closed"
+ sortType = ctx.FormString("sort")
page = ctx.FormInt("page")
- keyword = strings.Trim(ctx.Form("q"), " ")
+ keyword = strings.Trim(ctx.FormString("q"), " ")
)
if page <= 1 {
var (
viewType string
- sortType = ctx.Form("sort")
+ sortType = ctx.FormString("sort")
filterMode = models.FilterModeAll
)
// - Remember pre-determined viewType string for later. Will be posted to ctx.Data.
// Organization does not have view type and filter mode.
// User:
- // - Use ctx.Form("type") to determine filterMode.
+ // - Use ctx.FormString("type") to determine filterMode.
// The type is set when clicking for example "assigned to me" on the overview page.
// - Remember either this or a fallback. Will be posted to ctx.Data.
// --------------------------------------------------------------------------------
// TODO: distinguish during routing
- viewType = ctx.Form("type")
+ viewType = ctx.FormString("type")
switch viewType {
case "assigned":
filterMode = models.FilterModeAssign
}
// keyword holds the search term entered into the search field.
- keyword := strings.Trim(ctx.Form("q"), " ")
+ keyword := strings.Trim(ctx.FormString("q"), " ")
ctx.Data["Keyword"] = keyword
// Execute keyword search for issues.
}
// Educated guess: Do or don't show closed issues.
- isShowClosed := ctx.Form("state") == "closed"
+ isShowClosed := ctx.FormString("state") == "closed"
opts.IsClosed = util.OptionalBoolOf(isShowClosed)
// Filter repos and count issues in them. Count will be used later.
// Get IDs for labels (a filter option for issues/pulls).
// Required for IssuesOptions.
var labelIDs []int64
- selectedLabels := ctx.Form("labels")
+ selectedLabels := ctx.FormString("labels")
if len(selectedLabels) > 0 && selectedLabels != "0" {
labelIDs, err = base.StringsToInt64s(strings.Split(selectedLabels, ","))
if err != nil {
}
opts.LabelIDs = labelIDs
- // Parse ctx.Form("repos") and remember matched repo IDs for later.
+ // Parse ctx.FormString("repos") and remember matched repo IDs for later.
// Gets set when clicking filters on the issues overview page.
- repoIDs := getRepoIDs(ctx.Form("repos"))
+ repoIDs := getRepoIDs(ctx.FormString("repos"))
if len(repoIDs) > 0 {
opts.RepoIDs = repoIDs
}
ctx.Data["IsShowClosed"] = isShowClosed
ctx.Data["IssueRefEndNames"], ctx.Data["IssueRefURLs"] =
- issue_service.GetRefEndNamesAndURLs(issues, ctx.Form("RepoLink"))
+ issue_service.GetRefEndNamesAndURLs(issues, ctx.FormString("RepoLink"))
ctx.Data["Issues"] = issues
// Email2User show user page via email
func Email2User(ctx *context.Context) {
- u, err := models.GetUserByEmail(ctx.Form("email"))
+ u, err := models.GetUserByEmail(ctx.FormString("email"))
if err != nil {
if models.IsErrUserNotExist(err) {
ctx.NotFound("GetUserByEmail", err)
return
}
if c.FormBool("div-only") {
- c.Data["SequenceNumber"] = c.Form("sequence-number")
+ c.Data["SequenceNumber"] = c.FormString("sequence-number")
c.HTML(http.StatusOK, tplNotificationDiv)
return
}
func getNotifications(c *context.Context) {
var (
- keyword = strings.Trim(c.Form("q"), " ")
+ keyword = strings.Trim(c.FormString("q"), " ")
status models.NotificationStatus
page = c.FormInt("page")
perPage = c.FormInt("perPage")
// redirect to last page if request page is more than total pages
pager := context.NewPagination(int(total), perPage, page, 5)
if pager.Paginater.Current() < page {
- c.Redirect(fmt.Sprintf("/notifications?q=%s&page=%d", c.Form("q"), pager.Paginater.Current()))
+ c.Redirect(fmt.Sprintf("/notifications?q=%s&page=%d", c.FormString("q"), pager.Paginater.Current()))
return
}
}
if !c.FormBool("noredirect") {
- url := fmt.Sprintf("%s/notifications?page=%s", setting.AppSubURL, c.Form("page"))
+ url := fmt.Sprintf("%s/notifications?page=%s", setting.AppSubURL, c.FormString("page"))
c.Redirect(url, http.StatusSeeOther)
}
ctx.Data["Orgs"] = orgs
ctx.Data["HasOrgsVisible"] = models.HasOrgsVisible(orgs, ctx.User)
- tab := ctx.Form("tab")
+ tab := ctx.FormString("tab")
ctx.Data["TabName"] = tab
page := ctx.FormInt("page")
orderBy models.SearchOrderBy
)
- ctx.Data["SortType"] = ctx.Form("sort")
- switch ctx.Form("sort") {
+ ctx.Data["SortType"] = ctx.FormString("sort")
+ switch ctx.FormString("sort") {
case "newest":
orderBy = models.SearchOrderByNewest
case "oldest":
orderBy = models.SearchOrderByRecentUpdated
}
- keyword := strings.Trim(ctx.Form("q"), " ")
+ keyword := strings.Trim(ctx.FormString("q"), " ")
ctx.Data["Keyword"] = keyword
switch tab {
case "followers":
IncludePrivate: showPrivate,
OnlyPerformedBy: true,
IncludeDeleted: false,
- Date: ctx.Form("date"),
+ Date: ctx.FormString("date"),
})
if ctx.Written() {
return
return
}
- ctx.RedirectToFirst(ctx.Form("redirect_to"), u.HomeLink())
+ ctx.RedirectToFirst(ctx.FormString("redirect_to"), u.HomeLink())
}
ctx.Data["PageIsSettingsAccount"] = true
// Make emailaddress primary.
- if ctx.Form("_method") == "PRIMARY" {
+ if ctx.FormString("_method") == "PRIMARY" {
if err := models.MakeEmailPrimary(&models.EmailAddress{ID: ctx.FormInt64("id")}); err != nil {
ctx.ServerError("MakeEmailPrimary", err)
return
return
}
// Send activation Email
- if ctx.Form("_method") == "SENDACTIVATION" {
+ if ctx.FormString("_method") == "SENDACTIVATION" {
var address string
if ctx.Cache.IsExist("MailResendLimit_" + ctx.User.LowerName) {
log.Error("Send activation: activation still pending")
return
}
// Set Email Notification Preference
- if ctx.Form("_method") == "NOTIFICATION" {
- preference := ctx.Form("preference")
+ if ctx.FormString("_method") == "NOTIFICATION" {
+ preference := ctx.FormString("preference")
if !(preference == models.EmailNotificationsEnabled ||
preference == models.EmailNotificationsOnMention ||
preference == models.EmailNotificationsDisabled) {
ctx.Data["Title"] = ctx.Tr("settings")
ctx.Data["PageIsSettingsAccount"] = true
- if _, err := auth.UserSignIn(ctx.User.Name, ctx.Form("password")); err != nil {
+ if _, err := auth.UserSignIn(ctx.User.Name, ctx.FormString("password")); err != nil {
if models.IsErrUserNotExist(err) {
loadAccountData(ctx)
allowDelete := ctx.IsUserSiteAdmin() || setting.Repository.AllowDeleteOfUnadoptedRepositories
ctx.Data["allowDelete"] = allowDelete
- dir := ctx.Form("id")
- action := ctx.Form("action")
+ dir := ctx.FormString("id")
+ action := ctx.FormString("action")
ctxUser := ctx.User
root := filepath.Join(models.UserPath(ctxUser.LowerName))
// DeleteKey response for delete user's SSH/GPG key
func DeleteKey(ctx *context.Context) {
- switch ctx.Form("type") {
+ switch ctx.FormString("type") {
case "gpg":
if err := models.DeleteGPGKey(ctx.User, ctx.FormInt64("id")); err != nil {
ctx.Flash.Error("DeleteGPGKey: " + err.Error())
}
ctx.Data["Principals"] = principals
- ctx.Data["VerifyingID"] = ctx.Form("verify_gpg")
+ ctx.Data["VerifyingID"] = ctx.FormString("verify_gpg")
}
ctx.Data["PageIsSettingsSecurity"] = true
ctx.Data["RequireU2F"] = true
- if ctx.Form("openid.return_to") != "" {
+ if ctx.FormString("openid.return_to") != "" {
settingsOpenIDVerify(ctx)
return
}
} else if limit < 0 {
limit = 0
}
- id := ctx.Form("id")
+ id := ctx.FormString("id")
if id != "" { //Case where we request a specific id
v, err := strconv.ParseInt(id, 10, 64)
if err != nil {
return
}
- path := ctx.Form("path")
+ path := ctx.FormString("path")
if path != "" { //Case where we request a specific id
lock, err := models.GetLFSLock(repository, path)
if err != nil && !models.IsErrLFSLockNotExist(err) {
projects / gitea.git / commitdiff