URL string `json:"url"`
}
+// APIInvalidTopicsError is error format response to invalid topics
+// swagger:response invalidTopicsError
+type APIInvalidTopicsError struct {
+ Topics []string `json:"invalidTopics"`
+ Message string `json:"message"`
+}
+
//APIEmpty is an empty response
// swagger:response empty
type APIEmpty struct{}
package admin
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
// "$ref": "#/responses/forbidden"
// "422":
// "$ref": "#/responses/validationError"
+
u := user.GetUserByParams(ctx)
if ctx.Written() {
return
if models.IsErrUserAlreadyExist(err) ||
models.IsErrNameReserved(err) ||
models.IsErrNamePatternNotAllowed(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "CreateOrganization", err)
+ ctx.Error(http.StatusInternalServerError, "CreateOrganization", err)
}
return
}
- ctx.JSON(201, convert.ToOrganization(org))
+ ctx.JSON(http.StatusCreated, convert.ToOrganization(org))
}
//GetAllOrgs API for getting information of all the organizations
// "$ref": "#/responses/OrganizationList"
// "403":
// "$ref": "#/responses/forbidden"
+
users, _, err := models.SearchUsers(&models.SearchUserOptions{
Type: models.UserTypeOrganization,
OrderBy: models.SearchOrderByAlphabetically,
Private: true,
})
if err != nil {
- ctx.Error(500, "SearchOrganizations", err)
+ ctx.Error(http.StatusInternalServerError, "SearchOrganizations", err)
return
}
orgs := make([]*api.Organization, len(users))
for i := range users {
orgs[i] = convert.ToOrganization(users[i])
}
- ctx.JSON(200, &orgs)
+ ctx.JSON(http.StatusOK, &orgs)
}
// "$ref": "#/responses/Repository"
// "403":
// "$ref": "#/responses/forbidden"
+ // "404":
+ // "$ref": "#/responses/notFound"
+ // "409":
+ // "$ref": "#/responses/error"
// "422":
// "$ref": "#/responses/validationError"
+
owner := user.GetUserByParams(ctx)
if ctx.Written() {
return
import (
"errors"
+ "net/http"
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
source, err := models.GetLoginSourceByID(sourceID)
if err != nil {
if models.IsErrLoginSourceNotExist(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "GetLoginSourceByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetLoginSourceByID", err)
}
return
}
// "$ref": "#/responses/User"
// "403":
// "$ref": "#/responses/forbidden"
+ // "400":
+ // "$ref": "#/responses/error"
// "422":
// "$ref": "#/responses/validationError"
+
u := &models.User{
Name: form.Username,
FullName: form.FullName,
}
if !password.IsComplexEnough(form.Password) {
err := errors.New("PasswordComplexity")
- ctx.Error(400, "PasswordComplexity", err)
+ ctx.Error(http.StatusBadRequest, "PasswordComplexity", err)
return
}
if err := models.CreateUser(u); err != nil {
models.IsErrEmailAlreadyUsed(err) ||
models.IsErrNameReserved(err) ||
models.IsErrNamePatternNotAllowed(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "CreateUser", err)
+ ctx.Error(http.StatusInternalServerError, "CreateUser", err)
}
return
}
if form.SendNotify {
mailer.SendRegisterNotifyMail(ctx.Locale, u)
}
- ctx.JSON(201, convert.ToUser(u, ctx.IsSigned, ctx.User.IsAdmin))
+ ctx.JSON(http.StatusCreated, convert.ToUser(u, ctx.IsSigned, ctx.User.IsAdmin))
}
// EditUser api for modifying a user's information
// "$ref": "#/responses/forbidden"
// "422":
// "$ref": "#/responses/validationError"
+
u := user.GetUserByParams(ctx)
if ctx.Written() {
return
if len(form.Password) > 0 {
if !password.IsComplexEnough(form.Password) {
err := errors.New("PasswordComplexity")
- ctx.Error(400, "PasswordComplexity", err)
+ ctx.Error(http.StatusBadRequest, "PasswordComplexity", err)
return
}
var err error
if u.Salt, err = models.GetUserSalt(); err != nil {
- ctx.Error(500, "UpdateUser", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateUser", err)
return
}
u.HashPassword(form.Password)
if err := models.UpdateUser(u); err != nil {
if models.IsErrEmailAlreadyUsed(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "UpdateUser", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateUser", err)
}
return
}
log.Trace("Account profile updated by admin (%s): %s", ctx.User.Name, u.Name)
- ctx.JSON(200, convert.ToUser(u, ctx.IsSigned, ctx.User.IsAdmin))
+ ctx.JSON(http.StatusOK, convert.ToUser(u, ctx.IsSigned, ctx.User.IsAdmin))
}
// DeleteUser api for deleting a user
// "$ref": "#/responses/forbidden"
// "422":
// "$ref": "#/responses/validationError"
+
u := user.GetUserByParams(ctx)
if ctx.Written() {
return
if err := models.DeleteUser(u); err != nil {
if models.IsErrUserOwnRepos(err) ||
models.IsErrUserHasOrgs(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "DeleteUser", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteUser", err)
}
return
}
log.Trace("Account deleted by admin(%s): %s", ctx.User.Name, u.Name)
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// CreatePublicKey api for creating a public key to a user
// "$ref": "#/responses/forbidden"
// "422":
// "$ref": "#/responses/validationError"
+
u := user.GetUserByParams(ctx)
if ctx.Written() {
return
// "$ref": "#/responses/forbidden"
// "404":
// "$ref": "#/responses/notFound"
+
u := user.GetUserByParams(ctx)
if ctx.Written() {
return
if models.IsErrKeyNotExist(err) {
ctx.NotFound()
} else if models.IsErrKeyAccessDenied(err) {
- ctx.Error(403, "", "You do not have access to this key")
+ ctx.Error(http.StatusForbidden, "", "You do not have access to this key")
} else {
- ctx.Error(500, "DeleteUserPublicKey", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteUserPublicKey", err)
}
return
}
log.Trace("Key deleted by admin(%s): %s", ctx.User.Name, u.Name)
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
//GetAllUsers API for getting information of all the users
// "$ref": "#/responses/UserList"
// "403":
// "$ref": "#/responses/forbidden"
+
users, _, err := models.SearchUsers(&models.SearchUserOptions{
Type: models.UserTypeIndividual,
OrderBy: models.SearchOrderByAlphabetically,
PageSize: -1,
})
if err != nil {
- ctx.Error(500, "GetAllUsers", err)
+ ctx.Error(http.StatusInternalServerError, "GetAllUsers", err)
return
}
results[i] = convert.ToUser(users[i], ctx.IsSigned, ctx.User.IsAdmin)
}
- ctx.JSON(200, &results)
+ ctx.JSON(http.StatusOK, &results)
}
package v1
import (
+ "net/http"
"strings"
"code.gitea.io/gitea/models"
if models.IsErrUserNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetUserByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByName", err)
}
return
}
log.Trace("Sudo from (%s) to: %s", ctx.User.Name, user.Name)
ctx.User = user
} else {
- ctx.JSON(403, map[string]string{
+ ctx.JSON(http.StatusForbidden, map[string]string{
"message": "Only administrators allowed to sudo.",
})
return
if models.IsErrUserNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetUserByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByName", err)
}
return
}
} else if models.IsErrRepoRedirectNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "LookupRepoRedirect", err)
+ ctx.Error(http.StatusInternalServerError, "LookupRepoRedirect", err)
}
} else {
- ctx.Error(500, "GetRepositoryByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetRepositoryByName", err)
}
return
}
ctx.Repo.Permission, err = models.GetUserRepoPermission(repo, ctx.User)
if err != nil {
- ctx.Error(500, "GetUserRepoPermission", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserRepoPermission", err)
return
}
ctx.RequireCSRF()
return
}
- ctx.Context.Error(401)
+ ctx.Context.Error(http.StatusUnauthorized)
}
}
func reqBasicAuth() macaron.Handler {
return func(ctx *context.APIContext) {
if !ctx.Context.IsBasicAuth {
- ctx.Context.Error(401)
+ ctx.Context.Error(http.StatusUnauthorized)
return
}
ctx.CheckForOTP()
func reqSiteAdmin() macaron.Handler {
return func(ctx *context.Context) {
if !ctx.IsUserSiteAdmin() {
- ctx.Error(403)
+ ctx.Error(http.StatusForbidden)
return
}
}
func reqOwner() macaron.Handler {
return func(ctx *context.Context) {
if !ctx.IsUserRepoOwner() && !ctx.IsUserSiteAdmin() {
- ctx.Error(403)
+ ctx.Error(http.StatusForbidden)
return
}
}
func reqAdmin() macaron.Handler {
return func(ctx *context.Context) {
if !ctx.IsUserRepoAdmin() && !ctx.IsUserSiteAdmin() {
- ctx.Error(403)
+ ctx.Error(http.StatusForbidden)
return
}
}
func reqRepoWriter(unitTypes ...models.UnitType) macaron.Handler {
return func(ctx *context.Context) {
if !ctx.IsUserRepoWriter(unitTypes) && !ctx.IsUserRepoAdmin() && !ctx.IsUserSiteAdmin() {
- ctx.Error(403)
+ ctx.Error(http.StatusForbidden)
return
}
}
func reqRepoReader(unitType models.UnitType) macaron.Handler {
return func(ctx *context.Context) {
if !ctx.IsUserRepoReaderSpecific(unitType) && !ctx.IsUserRepoAdmin() && !ctx.IsUserSiteAdmin() {
- ctx.Error(403)
+ ctx.Error(http.StatusForbidden)
return
}
}
func reqAnyRepoReader() macaron.Handler {
return func(ctx *context.Context) {
if !ctx.IsUserRepoReaderAny() && !ctx.IsUserSiteAdmin() {
- ctx.Error(403)
+ ctx.Error(http.StatusForbidden)
return
}
}
} else if ctx.Org.Team != nil {
orgID = ctx.Org.Team.OrgID
} else {
- ctx.Error(500, "", "reqOrgOwnership: unprepared context")
+ ctx.Error(http.StatusInternalServerError, "", "reqOrgOwnership: unprepared context")
return
}
isOwner, err := models.IsOrganizationOwner(orgID, ctx.User.ID)
if err != nil {
- ctx.Error(500, "IsOrganizationOwner", err)
+ ctx.Error(http.StatusInternalServerError, "IsOrganizationOwner", err)
return
} else if !isOwner {
if ctx.Org.Organization != nil {
- ctx.Error(403, "", "Must be an organization owner")
+ ctx.Error(http.StatusForbidden, "", "Must be an organization owner")
} else {
ctx.NotFound()
}
return
}
if ctx.Org.Team == nil {
- ctx.Error(500, "", "reqTeamMembership: unprepared context")
+ ctx.Error(http.StatusInternalServerError, "", "reqTeamMembership: unprepared context")
return
}
var orgID = ctx.Org.Team.OrgID
isOwner, err := models.IsOrganizationOwner(orgID, ctx.User.ID)
if err != nil {
- ctx.Error(500, "IsOrganizationOwner", err)
+ ctx.Error(http.StatusInternalServerError, "IsOrganizationOwner", err)
return
} else if isOwner {
return
}
if isTeamMember, err := models.IsTeamMember(orgID, ctx.Org.Team.ID, ctx.User.ID); err != nil {
- ctx.Error(500, "IsTeamMember", err)
+ ctx.Error(http.StatusInternalServerError, "IsTeamMember", err)
return
} else if !isTeamMember {
isOrgMember, err := models.IsOrganizationMember(orgID, ctx.User.ID)
if err != nil {
- ctx.Error(500, "IsOrganizationMember", err)
+ ctx.Error(http.StatusInternalServerError, "IsOrganizationMember", err)
} else if isOrgMember {
- ctx.Error(403, "", "Must be a team member")
+ ctx.Error(http.StatusForbidden, "", "Must be a team member")
} else {
ctx.NotFound()
}
} else if ctx.Org.Team != nil {
orgID = ctx.Org.Team.OrgID
} else {
- ctx.Error(500, "", "reqOrgMembership: unprepared context")
+ ctx.Error(http.StatusInternalServerError, "", "reqOrgMembership: unprepared context")
return
}
if isMember, err := models.IsOrganizationMember(orgID, ctx.User.ID); err != nil {
- ctx.Error(500, "IsOrganizationMember", err)
+ ctx.Error(http.StatusInternalServerError, "IsOrganizationMember", err)
return
} else if !isMember {
if ctx.Org.Organization != nil {
- ctx.Error(403, "", "Must be an organization member")
+ ctx.Error(http.StatusForbidden, "", "Must be an organization member")
} else {
ctx.NotFound()
}
func reqGitHook() macaron.Handler {
return func(ctx *context.APIContext) {
if !ctx.User.CanEditGitHook() {
- ctx.Error(403, "", "must be allowed to edit Git hooks")
+ ctx.Error(http.StatusForbidden, "", "must be allowed to edit Git hooks")
return
}
}
if models.IsErrOrgNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetOrgByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetOrgByName", err)
}
return
}
if models.IsErrUserNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetTeamById", err)
+ ctx.Error(http.StatusInternalServerError, "GetTeamById", err)
}
return
}
// "$ref": "#/responses/MarkdownRender"
// "422":
// "$ref": "#/responses/validationError"
+
if ctx.HasAPIError() {
- ctx.Error(422, "", ctx.GetErrMsg())
+ ctx.Error(http.StatusUnprocessableEntity, "", ctx.GetErrMsg())
return
}
if form.Wiki {
_, err := ctx.Write([]byte(markdown.RenderWiki(md, urlPrefix, meta)))
if err != nil {
- ctx.Error(http.StatusInternalServerError, "", err)
+ ctx.InternalServerError(err)
return
}
} else {
_, err := ctx.Write(markdown.Render(md, urlPrefix, meta))
if err != nil {
- ctx.Error(http.StatusInternalServerError, "", err)
+ ctx.InternalServerError(err)
return
}
}
default:
_, err := ctx.Write(markdown.RenderRaw([]byte(form.Text), "", false))
if err != nil {
- ctx.Error(http.StatusInternalServerError, "", err)
+ ctx.InternalServerError(err)
return
}
}
// "$ref": "#/responses/MarkdownRender"
// "422":
// "$ref": "#/responses/validationError"
+
body, err := ctx.Req.Body().Bytes()
if err != nil {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
return
}
_, err = ctx.Write(markdown.RenderRaw(body, "", false))
if err != nil {
- ctx.Error(http.StatusInternalServerError, "", err)
+ ctx.InternalServerError(err)
return
}
}
package misc
import (
+ "net/http"
+
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
)
// Swagger render swagger-ui page with v1 json
func Swagger(ctx *context.Context) {
ctx.Data["APIJSONVersion"] = "v1"
- ctx.HTML(200, tplSwagger)
+ ctx.HTML(http.StatusOK, tplSwagger)
}
package misc
import (
+ "net/http"
+
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/structs"
// responses:
// "200":
// "$ref": "#/responses/ServerVersion"
- ctx.JSON(200, &structs.ServerVersion{Version: setting.AppVer})
+ ctx.JSON(http.StatusOK, &structs.ServerVersion{Version: setting.AppVer})
}
package org
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
// responses:
// "200":
// "$ref": "#/responses/HookList"
+
org := ctx.Org.Organization
orgHooks, err := models.GetWebhooksByOrgID(org.ID)
if err != nil {
- ctx.Error(500, "GetWebhooksByOrgID", err)
+ ctx.Error(http.StatusInternalServerError, "GetWebhooksByOrgID", err)
return
}
hooks := make([]*api.Hook, len(orgHooks))
for i, hook := range orgHooks {
hooks[i] = convert.ToHook(org.HomeLink(), hook)
}
- ctx.JSON(200, hooks)
+ ctx.JSON(http.StatusOK, hooks)
}
// GetHook get an organization's hook by id
// responses:
// "200":
// "$ref": "#/responses/Hook"
+
org := ctx.Org.Organization
hookID := ctx.ParamsInt64(":id")
hook, err := utils.GetOrgHook(ctx, org.ID, hookID)
if err != nil {
return
}
- ctx.JSON(200, convert.ToHook(org.HomeLink(), hook))
+ ctx.JSON(http.StatusOK, convert.ToHook(org.HomeLink(), hook))
}
// CreateHook create a hook for an organization
// responses:
// "204":
// "$ref": "#/responses/empty"
+
org := ctx.Org.Organization
hookID := ctx.ParamsInt64(":id")
if err := models.DeleteWebhookByOrgID(org.ID, hookID); err != nil {
if models.IsErrWebhookNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "DeleteWebhookByOrgID", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteWebhookByOrgID", err)
}
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
import (
"fmt"
+ "net/http"
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
PublicOnly: publicOnly,
})
if err != nil {
- ctx.Error(500, "GetUsersByIDs", err)
+ ctx.Error(http.StatusInternalServerError, "GetUsersByIDs", err)
return
}
for i, member := range members {
apiMembers[i] = convert.ToUser(member, ctx.IsSigned, ctx.User != nil && ctx.User.IsAdmin)
}
- ctx.JSON(200, apiMembers)
+ ctx.JSON(http.StatusOK, apiMembers)
}
// ListMembers list an organization's members
// responses:
// "200":
// "$ref": "#/responses/UserList"
+
publicOnly := true
if ctx.User != nil {
isMember, err := ctx.Org.Organization.IsOrgMember(ctx.User.ID)
if err != nil {
- ctx.Error(500, "IsOrgMember", err)
+ ctx.Error(http.StatusInternalServerError, "IsOrgMember", err)
return
}
publicOnly = !isMember
// responses:
// "200":
// "$ref": "#/responses/UserList"
+
listMembers(ctx, true)
}
// responses:
// "204":
// description: user is a member
+ // "302":
+ // description: redirection to /orgs/{org}/public_members/{username}
// "404":
// description: user is not a member
+
userToCheck := user.GetUserByParams(ctx)
if ctx.Written() {
return
if ctx.User != nil {
userIsMember, err := ctx.Org.Organization.IsOrgMember(ctx.User.ID)
if err != nil {
- ctx.Error(500, "IsOrgMember", err)
+ ctx.Error(http.StatusInternalServerError, "IsOrgMember", err)
return
} else if userIsMember {
userToCheckIsMember, err := ctx.Org.Organization.IsOrgMember(userToCheck.ID)
if err != nil {
- ctx.Error(500, "IsOrgMember", err)
+ ctx.Error(http.StatusInternalServerError, "IsOrgMember", err)
} else if userToCheckIsMember {
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
} else {
ctx.NotFound()
}
// description: user is a public member
// "404":
// description: user is not a public member
+
userToCheck := user.GetUserByParams(ctx)
if ctx.Written() {
return
}
if userToCheck.IsPublicMember(ctx.Org.Organization.ID) {
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
} else {
ctx.NotFound()
}
// responses:
// "204":
// description: membership publicized
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
userToPublicize := user.GetUserByParams(ctx)
if ctx.Written() {
return
}
if userToPublicize.ID != ctx.User.ID {
- ctx.Error(403, "", "Cannot publicize another member")
+ ctx.Error(http.StatusForbidden, "", "Cannot publicize another member")
return
}
err := models.ChangeOrgUserStatus(ctx.Org.Organization.ID, userToPublicize.ID, true)
if err != nil {
- ctx.Error(500, "ChangeOrgUserStatus", err)
+ ctx.Error(http.StatusInternalServerError, "ChangeOrgUserStatus", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// ConcealMember make a member's membership not public
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
userToConceal := user.GetUserByParams(ctx)
if ctx.Written() {
return
}
if userToConceal.ID != ctx.User.ID {
- ctx.Error(403, "", "Cannot conceal another member")
+ ctx.Error(http.StatusForbidden, "", "Cannot conceal another member")
return
}
err := models.ChangeOrgUserStatus(ctx.Org.Organization.ID, userToConceal.ID, false)
if err != nil {
- ctx.Error(500, "ChangeOrgUserStatus", err)
+ ctx.Error(http.StatusInternalServerError, "ChangeOrgUserStatus", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// DeleteMember remove a member from an organization
// responses:
// "204":
// description: member removed
+
member := user.GetUserByParams(ctx)
if ctx.Written() {
return
}
if err := ctx.Org.Organization.RemoveMember(member.ID); err != nil {
- ctx.Error(500, "RemoveMember", err)
+ ctx.Error(http.StatusInternalServerError, "RemoveMember", err)
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package org
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
func listUserOrgs(ctx *context.APIContext, u *models.User, all bool) {
if err := u.GetOrganizations(all); err != nil {
- ctx.Error(500, "GetOrganizations", err)
+ ctx.Error(http.StatusInternalServerError, "GetOrganizations", err)
return
}
for i := range u.Orgs {
apiOrgs[i] = convert.ToOrganization(u.Orgs[i])
}
- ctx.JSON(200, &apiOrgs)
+ ctx.JSON(http.StatusOK, &apiOrgs)
}
// ListMyOrgs list all my orgs
// responses:
// "200":
// "$ref": "#/responses/OrganizationList"
+
listUserOrgs(ctx, ctx.User, true)
}
// responses:
// "200":
// "$ref": "#/responses/OrganizationList"
+
u := user.GetUserByParams(ctx)
if ctx.Written() {
return
// "$ref": "#/responses/validationError"
if !ctx.User.CanCreateOrganization() {
- ctx.Error(403, "Create organization not allowed", nil)
+ ctx.Error(http.StatusForbidden, "Create organization not allowed", nil)
return
}
if models.IsErrUserAlreadyExist(err) ||
models.IsErrNameReserved(err) ||
models.IsErrNamePatternNotAllowed(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "CreateOrganization", err)
+ ctx.Error(http.StatusInternalServerError, "CreateOrganization", err)
}
return
}
- ctx.JSON(201, convert.ToOrganization(org))
+ ctx.JSON(http.StatusCreated, convert.ToOrganization(org))
}
// Get get an organization
// responses:
// "200":
// "$ref": "#/responses/Organization"
+
if !models.HasOrgVisible(ctx.Org.Organization, ctx.User) {
ctx.NotFound("HasOrgVisible", nil)
return
}
- ctx.JSON(200, convert.ToOrganization(ctx.Org.Organization))
+ ctx.JSON(http.StatusOK, convert.ToOrganization(ctx.Org.Organization))
}
// Edit change an organization's information
// responses:
// "200":
// "$ref": "#/responses/Organization"
+
org := ctx.Org.Organization
org.FullName = form.FullName
org.Description = form.Description
org.Visibility = api.VisibilityModes[form.Visibility]
}
if err := models.UpdateUserCols(org, "full_name", "description", "website", "location", "visibility"); err != nil {
- ctx.Error(500, "EditOrganization", err)
+ ctx.Error(http.StatusInternalServerError, "EditOrganization", err)
return
}
- ctx.JSON(200, convert.ToOrganization(org))
+ ctx.JSON(http.StatusOK, convert.ToOrganization(org))
}
//Delete an organization
// responses:
// "204":
// "$ref": "#/responses/empty"
+
if err := models.DeleteOrganization(ctx.Org.Organization); err != nil {
- ctx.Error(500, "DeleteOrganization", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteOrganization", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package org
import (
+ "net/http"
"strings"
"code.gitea.io/gitea/models"
// responses:
// "200":
// "$ref": "#/responses/TeamList"
+
org := ctx.Org.Organization
if err := org.GetTeams(); err != nil {
- ctx.Error(500, "GetTeams", err)
+ ctx.Error(http.StatusInternalServerError, "GetTeams", err)
return
}
apiTeams := make([]*api.Team, len(org.Teams))
for i := range org.Teams {
if err := org.Teams[i].GetUnits(); err != nil {
- ctx.Error(500, "GetUnits", err)
+ ctx.Error(http.StatusInternalServerError, "GetUnits", err)
return
}
apiTeams[i] = convert.ToTeam(org.Teams[i])
}
- ctx.JSON(200, apiTeams)
+ ctx.JSON(http.StatusOK, apiTeams)
}
// ListUserTeams list all the teams a user belongs to
// responses:
// "200":
// "$ref": "#/responses/TeamList"
+
teams, err := models.GetUserTeams(ctx.User.ID)
if err != nil {
- ctx.Error(500, "GetUserTeams", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserTeams", err)
return
}
if !ok {
org, err := models.GetUserByID(teams[i].OrgID)
if err != nil {
- ctx.Error(500, "GetUserByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByID", err)
return
}
apiOrg = convert.ToOrganization(org)
apiTeams[i] = convert.ToTeam(teams[i])
apiTeams[i].Organization = apiOrg
}
- ctx.JSON(200, apiTeams)
+ ctx.JSON(http.StatusOK, apiTeams)
}
// GetTeam api for get a team
// responses:
// "200":
// "$ref": "#/responses/Team"
- ctx.JSON(200, convert.ToTeam(ctx.Org.Team))
+
+ ctx.JSON(http.StatusOK, convert.ToTeam(ctx.Org.Team))
}
// CreateTeam api for create a team
// responses:
// "201":
// "$ref": "#/responses/Team"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
team := &models.Team{
OrgID: ctx.Org.Organization.ID,
Name: form.Name,
if err := models.NewTeam(team); err != nil {
if models.IsErrTeamAlreadyExist(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "NewTeam", err)
+ ctx.Error(http.StatusInternalServerError, "NewTeam", err)
}
return
}
- ctx.JSON(201, convert.ToTeam(team))
+ ctx.JSON(http.StatusCreated, convert.ToTeam(team))
}
// EditTeam api for edit a team
// responses:
// "200":
// "$ref": "#/responses/Team"
+
team := ctx.Org.Team
team.Description = form.Description
unitTypes := models.FindUnitTypes(form.Units...)
}
if err := models.UpdateTeam(team, isAuthChanged, isIncludeAllChanged); err != nil {
- ctx.Error(500, "EditTeam", err)
+ ctx.Error(http.StatusInternalServerError, "EditTeam", err)
return
}
- ctx.JSON(200, convert.ToTeam(team))
+ ctx.JSON(http.StatusOK, convert.ToTeam(team))
}
// DeleteTeam api for delete a team
// responses:
// "204":
// description: team deleted
+
if err := models.DeleteTeam(ctx.Org.Team); err != nil {
- ctx.Error(500, "DeleteTeam", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteTeam", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// GetTeamMembers api for get a team's members
// responses:
// "200":
// "$ref": "#/responses/UserList"
+
isMember, err := models.IsOrganizationMember(ctx.Org.Team.OrgID, ctx.User.ID)
if err != nil {
- ctx.Error(500, "IsOrganizationMember", err)
+ ctx.Error(http.StatusInternalServerError, "IsOrganizationMember", err)
return
} else if !isMember {
ctx.NotFound()
}
team := ctx.Org.Team
if err := team.GetMembers(); err != nil {
- ctx.Error(500, "GetTeamMembers", err)
+ ctx.Error(http.StatusInternalServerError, "GetTeamMembers", err)
return
}
members := make([]*api.User, len(team.Members))
for i, member := range team.Members {
members[i] = convert.ToUser(member, ctx.IsSigned, ctx.User.IsAdmin)
}
- ctx.JSON(200, members)
+ ctx.JSON(http.StatusOK, members)
}
// GetTeamMember api for get a particular member of team
// responses:
// "200":
// "$ref": "#/responses/User"
+ // "404":
+ // "$ref": "#/responses/notFound"
+
u := user.GetUserByParams(ctx)
if ctx.Written() {
return
teamID := ctx.ParamsInt64("teamid")
isTeamMember, err := models.IsUserInTeams(u.ID, []int64{teamID})
if err != nil {
- ctx.Error(500, "IsUserInTeams", err)
+ ctx.Error(http.StatusInternalServerError, "IsUserInTeams", err)
return
} else if !isTeamMember {
ctx.NotFound()
return
}
- ctx.JSON(200, convert.ToUser(u, ctx.IsSigned, ctx.User.IsAdmin))
+ ctx.JSON(http.StatusOK, convert.ToUser(u, ctx.IsSigned, ctx.User.IsAdmin))
}
// AddTeamMember api for add a member to a team
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "404":
+ // "$ref": "#/responses/notFound"
+
u := user.GetUserByParams(ctx)
if ctx.Written() {
return
}
if err := ctx.Org.Team.AddMember(u.ID); err != nil {
- ctx.Error(500, "AddMember", err)
+ ctx.Error(http.StatusInternalServerError, "AddMember", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// RemoveTeamMember api for remove one member from a team
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "404":
+ // "$ref": "#/responses/notFound"
+
u := user.GetUserByParams(ctx)
if ctx.Written() {
return
}
if err := ctx.Org.Team.RemoveMember(u.ID); err != nil {
- ctx.Error(500, "RemoveMember", err)
+ ctx.Error(http.StatusInternalServerError, "RemoveMember", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// GetTeamRepos api for get a team's repos
// responses:
// "200":
// "$ref": "#/responses/RepositoryList"
+
team := ctx.Org.Team
if err := team.GetRepositories(); err != nil {
- ctx.Error(500, "GetTeamRepos", err)
+ ctx.Error(http.StatusInternalServerError, "GetTeamRepos", err)
}
repos := make([]*api.Repository, len(team.Repos))
for i, repo := range team.Repos {
access, err := models.AccessLevel(ctx.User, repo)
if err != nil {
- ctx.Error(500, "GetTeamRepos", err)
+ ctx.Error(http.StatusInternalServerError, "GetTeamRepos", err)
return
}
repos[i] = repo.APIFormat(access)
}
- ctx.JSON(200, repos)
+ ctx.JSON(http.StatusOK, repos)
}
// getRepositoryByParams get repository by a team's organization ID and repo name
if models.IsErrRepoNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetRepositoryByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetRepositoryByName", err)
}
return nil
}
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
repo := getRepositoryByParams(ctx)
if ctx.Written() {
return
}
if access, err := models.AccessLevel(ctx.User, repo); err != nil {
- ctx.Error(500, "AccessLevel", err)
+ ctx.Error(http.StatusInternalServerError, "AccessLevel", err)
return
} else if access < models.AccessModeAdmin {
- ctx.Error(403, "", "Must have admin-level access to the repository")
+ ctx.Error(http.StatusForbidden, "", "Must have admin-level access to the repository")
return
}
if err := ctx.Org.Team.AddRepository(repo); err != nil {
- ctx.Error(500, "AddRepository", err)
+ ctx.Error(http.StatusInternalServerError, "AddRepository", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// RemoveTeamRepository api for removing a repository from a team
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
repo := getRepositoryByParams(ctx)
if ctx.Written() {
return
}
if access, err := models.AccessLevel(ctx.User, repo); err != nil {
- ctx.Error(500, "AccessLevel", err)
+ ctx.Error(http.StatusInternalServerError, "AccessLevel", err)
return
} else if access < models.AccessModeAdmin {
- ctx.Error(403, "", "Must have admin-level access to the repository")
+ ctx.Error(http.StatusForbidden, "", "Must have admin-level access to the repository")
return
}
if err := ctx.Org.Team.RemoveRepository(repo.ID); err != nil {
- ctx.Error(500, "RemoveRepository", err)
+ ctx.Error(http.StatusInternalServerError, "RemoveRepository", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// SearchTeam api for searching teams
// type: array
// items:
// "$ref": "#/definitions/Team"
+
opts := &models.SearchTeamOptions{
UserID: ctx.User.ID,
Keyword: strings.TrimSpace(ctx.Query("q")),
teams, _, err := models.SearchTeam(opts)
if err != nil {
log.Error("SearchTeam failed: %v", err)
- ctx.JSON(500, map[string]interface{}{
+ ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
"ok": false,
"error": "SearchTeam internal failure",
})
for i := range teams {
if err := teams[i].GetUnits(); err != nil {
log.Error("Team GetUnits failed: %v", err)
- ctx.JSON(500, map[string]interface{}{
+ ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
"ok": false,
"error": "SearchTeam failed to get units",
})
apiTeams[i] = convert.ToTeam(teams[i])
}
- ctx.JSON(200, map[string]interface{}{
+ ctx.JSON(http.StatusOK, map[string]interface{}{
"ok": true,
"data": apiTeams,
})
// responses:
// "200":
// "$ref": "#/responses/GitBlobResponse"
+ // "400":
+ // "$ref": "#/responses/error"
sha := ctx.Params("sha")
if len(sha) == 0 {
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
"code.gitea.io/gitea/modules/git"
// responses:
// "200":
// "$ref": "#/responses/Branch"
+
if ctx.Repo.TreePath != "" {
// if TreePath != "", then URL contained extra slashes
// (i.e. "master/subbranch" instead of "master"), so branch does
if git.IsErrBranchNotExist(err) {
ctx.NotFound(err)
} else {
- ctx.Error(500, "GetBranch", err)
+ ctx.Error(http.StatusInternalServerError, "GetBranch", err)
}
return
}
c, err := branch.GetCommit()
if err != nil {
- ctx.Error(500, "GetCommit", err)
+ ctx.Error(http.StatusInternalServerError, "GetCommit", err)
return
}
branchProtection, err := ctx.Repo.Repository.GetBranchProtection(ctx.Repo.BranchName)
if err != nil {
- ctx.Error(500, "GetBranchProtection", err)
+ ctx.Error(http.StatusInternalServerError, "GetBranchProtection", err)
return
}
- ctx.JSON(200, convert.ToBranch(ctx.Repo.Repository, branch, c, branchProtection, ctx.User))
+ ctx.JSON(http.StatusOK, convert.ToBranch(ctx.Repo.Repository, branch, c, branchProtection, ctx.User))
}
// ListBranches list all the branches of a repository
// responses:
// "200":
// "$ref": "#/responses/BranchList"
+
branches, err := ctx.Repo.Repository.GetBranches()
if err != nil {
- ctx.Error(500, "GetBranches", err)
+ ctx.Error(http.StatusInternalServerError, "GetBranches", err)
return
}
for i := range branches {
c, err := branches[i].GetCommit()
if err != nil {
- ctx.Error(500, "GetCommit", err)
+ ctx.Error(http.StatusInternalServerError, "GetCommit", err)
return
}
branchProtection, err := ctx.Repo.Repository.GetBranchProtection(branches[i].Name)
if err != nil {
- ctx.Error(500, "GetBranchProtection", err)
+ ctx.Error(http.StatusInternalServerError, "GetBranchProtection", err)
return
}
apiBranches[i] = convert.ToBranch(ctx.Repo.Repository, branches[i], c, branchProtection, ctx.User)
}
- ctx.JSON(200, &apiBranches)
+ ctx.JSON(http.StatusOK, &apiBranches)
}
import (
"errors"
+ "net/http"
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
// responses:
// "200":
// "$ref": "#/responses/UserList"
+
collaborators, err := ctx.Repo.Repository.GetCollaborators()
if err != nil {
- ctx.Error(500, "ListCollaborators", err)
+ ctx.Error(http.StatusInternalServerError, "ListCollaborators", err)
return
}
users := make([]*api.User, len(collaborators))
for i, collaborator := range collaborators {
users[i] = convert.ToUser(collaborator.User, ctx.IsSigned, ctx.User != nil && ctx.User.IsAdmin)
}
- ctx.JSON(200, users)
+ ctx.JSON(http.StatusOK, users)
}
// IsCollaborator check if a user is a collaborator of a repository
// "204":
// "$ref": "#/responses/empty"
// "404":
- // "$ref": "#/responses/empty"
+ // "$ref": "#/responses/notFound"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
user, err := models.GetUserByName(ctx.Params(":collaborator"))
if err != nil {
if models.IsErrUserNotExist(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "GetUserByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByName", err)
}
return
}
isColab, err := ctx.Repo.Repository.IsCollaborator(user.ID)
if err != nil {
- ctx.Error(500, "IsCollaborator", err)
+ ctx.Error(http.StatusInternalServerError, "IsCollaborator", err)
return
}
if isColab {
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
} else {
ctx.NotFound()
}
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
collaborator, err := models.GetUserByName(ctx.Params(":collaborator"))
if err != nil {
if models.IsErrUserNotExist(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "GetUserByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByName", err)
}
return
}
if !collaborator.IsActive {
- ctx.Error(500, "InactiveCollaborator", errors.New("collaborator's account is inactive"))
+ ctx.Error(http.StatusInternalServerError, "InactiveCollaborator", errors.New("collaborator's account is inactive"))
return
}
if err := ctx.Repo.Repository.AddCollaborator(collaborator); err != nil {
- ctx.Error(500, "AddCollaborator", err)
+ ctx.Error(http.StatusInternalServerError, "AddCollaborator", err)
return
}
if form.Permission != nil {
if err := ctx.Repo.Repository.ChangeCollaborationAccessMode(collaborator.ID, models.ParseAccessMode(*form.Permission)); err != nil {
- ctx.Error(500, "ChangeCollaborationAccessMode", err)
+ ctx.Error(http.StatusInternalServerError, "ChangeCollaborationAccessMode", err)
return
}
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// DeleteCollaborator delete a collaborator from a repository
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
collaborator, err := models.GetUserByName(ctx.Params(":collaborator"))
if err != nil {
if models.IsErrUserNotExist(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "GetUserByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByName", err)
}
return
}
if err := ctx.Repo.Repository.DeleteCollaboration(collaborator.ID); err != nil {
- ctx.Error(500, "DeleteCollaboration", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteCollaboration", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
import (
"math"
+ "net/http"
"strconv"
"time"
return
}
- ctx.JSON(200, json)
+ ctx.JSON(http.StatusOK, json)
}
// GetAllCommits get all commits via
// "$ref": "#/responses/EmptyRepository"
if ctx.Repo.Repository.IsEmpty {
- ctx.JSON(409, api.APIError{
+ ctx.JSON(http.StatusConflict, api.APIError{
Message: "Git Repository is empty.",
URL: setting.API.SwaggerURL,
})
ctx.Header().Set("X-PageCount", strconv.Itoa(pageCount))
ctx.Header().Set("X-HasMore", strconv.FormatBool(page < pageCount))
- ctx.JSON(200, &apiCommits)
+ ctx.JSON(http.StatusOK, &apiCommits)
}
func toCommit(ctx *context.APIContext, repo *models.Repository, commit *git.Commit, userCache map[string]*models.User) (*api.Commit, error) {
// responses:
// 200:
// description: success
+ // "404":
+ // "$ref": "#/responses/notFound"
+
if ctx.Repo.Repository.IsEmpty {
ctx.NotFound()
return
// responses:
// 200:
// description: success
+ // "404":
+ // "$ref": "#/responses/notFound"
+
repoPath := models.RepoPath(ctx.Params(":username"), ctx.Params(":reponame"))
gitRepo, err := git.OpenRepository(repoPath)
if err != nil {
// responses:
// 200:
// description: success
+ // "404":
+ // "$ref": "#/responses/notFound"
+
ec, err := ctx.Repo.GetEditorconfig()
if err != nil {
if git.IsErrNotExist(err) {
// responses:
// "200":
// "$ref": "#/responses/FileDeleteResponse"
+
if !CanWriteFiles(ctx.Repo) {
ctx.Error(http.StatusInternalServerError, "DeleteFile", models.ErrUserDoesNotHaveAccessToRepo{
UserID: ctx.User.ID,
package repo
import (
+ "fmt"
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
api "code.gitea.io/gitea/modules/structs"
// responses:
// "200":
// "$ref": "#/responses/RepositoryList"
+
forks, err := ctx.Repo.Repository.GetForks()
if err != nil {
- ctx.Error(500, "GetForks", err)
+ ctx.Error(http.StatusInternalServerError, "GetForks", err)
return
}
apiForks := make([]*api.Repository, len(forks))
for i, fork := range forks {
access, err := models.AccessLevel(ctx.User, fork)
if err != nil {
- ctx.Error(500, "AccessLevel", err)
+ ctx.Error(http.StatusInternalServerError, "AccessLevel", err)
return
}
apiForks[i] = fork.APIFormat(access)
}
- ctx.JSON(200, apiForks)
+ ctx.JSON(http.StatusOK, apiForks)
}
// CreateFork create a fork of a repo
// responses:
// "202":
// "$ref": "#/responses/Repository"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
repo := ctx.Repo.Repository
var forker *models.User // user/org that will own the fork
if form.Organization == nil {
org, err := models.GetOrgByName(*form.Organization)
if err != nil {
if models.IsErrOrgNotExist(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "GetOrgByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetOrgByName", err)
}
return
}
ctx.ServerError("IsOrgMember", err)
return
} else if !isMember {
- ctx.Status(403)
+ ctx.Error(http.StatusForbidden, "isMemberNot", fmt.Sprintf("User is no Member of Organisation '%s'", org.Name))
return
}
forker = org
fork, err := repo_service.ForkRepository(ctx.User, forker, repo, repo.Name, repo.Description)
if err != nil {
- ctx.Error(500, "ForkRepository", err)
+ ctx.Error(http.StatusInternalServerError, "ForkRepository", err)
return
}
- ctx.JSON(202, fork.APIFormat(models.AccessModeOwner))
+ //TODO change back to 201
+ ctx.JSON(http.StatusAccepted, fork.APIFormat(models.AccessModeOwner))
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
"code.gitea.io/gitea/modules/git"
// responses:
// "200":
// "$ref": "#/responses/GitHookList"
+
hooks, err := ctx.Repo.GitRepo.Hooks()
if err != nil {
- ctx.Error(500, "Hooks", err)
+ ctx.Error(http.StatusInternalServerError, "Hooks", err)
return
}
for i := range hooks {
apiHooks[i] = convert.ToGitHook(hooks[i])
}
- ctx.JSON(200, &apiHooks)
+ ctx.JSON(http.StatusOK, &apiHooks)
}
// GetGitHook get a repo's Git hook by id
// "$ref": "#/responses/GitHook"
// "404":
// "$ref": "#/responses/notFound"
+
hookID := ctx.Params(":id")
hook, err := ctx.Repo.GitRepo.GetHook(hookID)
if err != nil {
if err == git.ErrNotValidHook {
ctx.NotFound()
} else {
- ctx.Error(500, "GetHook", err)
+ ctx.Error(http.StatusInternalServerError, "GetHook", err)
}
return
}
- ctx.JSON(200, convert.ToGitHook(hook))
+ ctx.JSON(http.StatusOK, convert.ToGitHook(hook))
}
// EditGitHook modify a Git hook of a repository
// "$ref": "#/responses/GitHook"
// "404":
// "$ref": "#/responses/notFound"
+
hookID := ctx.Params(":id")
hook, err := ctx.Repo.GitRepo.GetHook(hookID)
if err != nil {
if err == git.ErrNotValidHook {
ctx.NotFound()
} else {
- ctx.Error(500, "GetHook", err)
+ ctx.Error(http.StatusInternalServerError, "GetHook", err)
}
return
}
hook.Content = form.Content
if err = hook.Update(); err != nil {
- ctx.Error(500, "hook.Update", err)
+ ctx.Error(http.StatusInternalServerError, "hook.Update", err)
return
}
- ctx.JSON(200, convert.ToGitHook(hook))
+ ctx.JSON(http.StatusOK, convert.ToGitHook(hook))
}
// DeleteGitHook delete a Git hook of a repository
// "$ref": "#/responses/empty"
// "404":
// "$ref": "#/responses/notFound"
+
hookID := ctx.Params(":id")
hook, err := ctx.Repo.GitRepo.GetHook(hookID)
if err != nil {
if err == git.ErrNotValidHook {
ctx.NotFound()
} else {
- ctx.Error(500, "GetHook", err)
+ ctx.Error(http.StatusInternalServerError, "GetHook", err)
}
return
}
hook.Content = ""
if err = hook.Update(); err != nil {
- ctx.Error(500, "hook.Update", err)
+ ctx.Error(http.StatusInternalServerError, "hook.Update", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/git"
api "code.gitea.io/gitea/modules/structs"
func getGitRefsInternal(ctx *context.APIContext, filter string) {
refs, lastMethodName, err := getGitRefs(ctx, filter)
if err != nil {
- ctx.Error(500, lastMethodName, err)
+ ctx.Error(http.StatusInternalServerError, lastMethodName, err)
return
}
}
// If single reference is found and it matches filter exactly return it as object
if len(apiRefs) == 1 && apiRefs[0].Ref == filter {
- ctx.JSON(200, &apiRefs[0])
+ ctx.JSON(http.StatusOK, &apiRefs[0])
return
}
- ctx.JSON(200, &apiRefs)
+ ctx.JSON(http.StatusOK, &apiRefs)
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
// responses:
// "200":
// "$ref": "#/responses/HookList"
+
hooks, err := models.GetWebhooksByRepoID(ctx.Repo.Repository.ID)
if err != nil {
- ctx.Error(500, "GetWebhooksByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "GetWebhooksByRepoID", err)
return
}
for i := range hooks {
apiHooks[i] = convert.ToHook(ctx.Repo.RepoLink, hooks[i])
}
- ctx.JSON(200, &apiHooks)
+ ctx.JSON(http.StatusOK, &apiHooks)
}
// GetHook get a repo's hook by id
// responses:
// "200":
// "$ref": "#/responses/Hook"
+ // "404":
+ // "$ref": "#/responses/notFound"
+
repo := ctx.Repo
hookID := ctx.ParamsInt64(":id")
hook, err := utils.GetRepoHook(ctx, repo.Repository.ID, hookID)
if err != nil {
return
}
- ctx.JSON(200, convert.ToHook(repo.RepoLink, hook))
+ ctx.JSON(http.StatusOK, convert.ToHook(repo.RepoLink, hook))
}
// TestHook tests a hook
// responses:
// "204":
// "$ref": "#/responses/empty"
+
if ctx.Repo.Commit == nil {
// if repo does not have any commits, then don't send a webhook
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
return
}
Pusher: convert.ToUser(ctx.User, ctx.IsSigned, false),
Sender: convert.ToUser(ctx.User, ctx.IsSigned, false),
}); err != nil {
- ctx.Error(500, "PrepareWebhook: ", err)
+ ctx.Error(http.StatusInternalServerError, "PrepareWebhook: ", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// CreateHook create a hook for a repository
if models.IsErrWebhookNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "DeleteWebhookByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteWebhookByRepoID", err)
}
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// responses:
// "200":
// "$ref": "#/responses/IssueList"
+
var isClosed util.OptionalBool
switch ctx.Query("state") {
case "closed":
OrderBy: models.SearchOrderByRecentUpdated,
})
if err != nil {
- ctx.Error(500, "SearchRepositoryByName", err)
+ ctx.Error(http.StatusInternalServerError, "SearchRepositoryByName", err)
return
}
if splitted := strings.Split(labels, ","); labels != "" && len(splitted) > 0 {
labelIDs, err = models.GetLabelIDsInReposByNames(repoIDs, splitted)
if err != nil {
- ctx.Error(500, "GetLabelIDsInRepoByNames", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelIDsInRepoByNames", err)
return
}
}
}
if err != nil {
- ctx.Error(500, "Issues", err)
+ ctx.Error(http.StatusInternalServerError, "Issues", err)
return
}
}
ctx.SetLinkHeader(issueCount, setting.UI.IssuePagingNum)
- ctx.JSON(200, &apiIssues)
+ ctx.JSON(http.StatusOK, &apiIssues)
}
// ListIssues list the issues of a repository
// responses:
// "200":
// "$ref": "#/responses/IssueList"
+
var isClosed util.OptionalBool
switch ctx.Query("state") {
case "closed":
if splitted := strings.Split(ctx.Query("labels"), ","); len(splitted) > 0 {
labelIDs, err = models.GetLabelIDsInRepoByNames(ctx.Repo.Repository.ID, splitted)
if err != nil {
- ctx.Error(500, "GetLabelIDsInRepoByNames", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelIDsInRepoByNames", err)
return
}
}
}
if err != nil {
- ctx.Error(500, "Issues", err)
+ ctx.Error(http.StatusInternalServerError, "Issues", err)
return
}
}
ctx.SetLinkHeader(ctx.Repo.Repository.NumIssues, setting.UI.IssuePagingNum)
- ctx.JSON(200, &apiIssues)
+ ctx.JSON(http.StatusOK, &apiIssues)
}
// GetIssue get an issue of a repository
// responses:
// "200":
// "$ref": "#/responses/Issue"
+ // "404":
+ // "$ref": "#/responses/notFound"
+
issue, err := models.GetIssueWithAttrsByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
- ctx.JSON(200, issue.APIFormat())
+ ctx.JSON(http.StatusOK, issue.APIFormat())
}
// CreateIssue create an issue of a repository
// responses:
// "201":
// "$ref": "#/responses/Issue"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+ // "412":
+ // "$ref": "#/responses/error"
+ // "422":
+ // "$ref": "#/responses/validationError"
var deadlineUnix timeutil.TimeStamp
if form.Deadline != nil && ctx.Repo.CanWrite(models.UnitTypeIssues) {
assigneeIDs, err = models.MakeIDsFromAPIAssigneesToAdd(form.Assignee, form.Assignees)
if err != nil {
if models.IsErrUserNotExist(err) {
- ctx.Error(422, "", fmt.Sprintf("Assignee does not exist: [name: %s]", err))
+ ctx.Error(http.StatusUnprocessableEntity, "", fmt.Sprintf("Assignee does not exist: [name: %s]", err))
} else {
- ctx.Error(500, "AddAssigneeByName", err)
+ ctx.Error(http.StatusInternalServerError, "AddAssigneeByName", err)
}
return
}
for _, aID := range assigneeIDs {
assignee, err := models.GetUserByID(aID)
if err != nil {
- ctx.Error(500, "GetUserByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByID", err)
return
}
valid, err := models.CanBeAssigned(assignee, ctx.Repo.Repository, false)
if err != nil {
- ctx.Error(500, "canBeAssigned", err)
+ ctx.Error(http.StatusInternalServerError, "canBeAssigned", err)
return
}
if !valid {
- ctx.Error(422, "canBeAssigned", models.ErrUserDoesNotHaveAccessToRepo{UserID: aID, RepoName: ctx.Repo.Repository.Name})
+ ctx.Error(http.StatusUnprocessableEntity, "canBeAssigned", models.ErrUserDoesNotHaveAccessToRepo{UserID: aID, RepoName: ctx.Repo.Repository.Name})
return
}
}
if err := issue_service.NewIssue(ctx.Repo.Repository, issue, form.Labels, nil, assigneeIDs); err != nil {
if models.IsErrUserDoesNotHaveAccessToRepo(err) {
- ctx.Error(400, "UserDoesNotHaveAccessToRepo", err)
+ ctx.Error(http.StatusBadRequest, "UserDoesNotHaveAccessToRepo", err)
return
}
- ctx.Error(500, "NewIssue", err)
+ ctx.Error(http.StatusInternalServerError, "NewIssue", err)
return
}
ctx.Error(http.StatusPreconditionFailed, "DependenciesLeft", "cannot close this issue because it still has open dependencies")
return
}
- ctx.Error(500, "ChangeStatus", err)
+ ctx.Error(http.StatusInternalServerError, "ChangeStatus", err)
return
}
}
// Refetch from database to assign some automatic values
issue, err = models.GetIssueByID(issue.ID)
if err != nil {
- ctx.Error(500, "GetIssueByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByID", err)
return
}
- ctx.JSON(201, issue.APIFormat())
+ ctx.JSON(http.StatusCreated, issue.APIFormat())
}
// EditIssue modify an issue of a repository
// responses:
// "201":
// "$ref": "#/responses/Issue"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+ // "404":
+ // "$ref": "#/responses/notFound"
+ // "412":
+ // "$ref": "#/responses/error"
+
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
err = issue.LoadAttributes()
if err != nil {
- ctx.Error(500, "LoadAttributes", err)
+ ctx.Error(http.StatusInternalServerError, "LoadAttributes", err)
return
}
if !issue.IsPoster(ctx.User.ID) && !ctx.Repo.CanWrite(models.UnitTypeIssues) {
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return
}
}
if err := models.UpdateIssueDeadline(issue, deadlineUnix, ctx.User); err != nil {
- ctx.Error(500, "UpdateIssueDeadline", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateIssueDeadline", err)
return
}
issue.DeadlineUnix = deadlineUnix
err = issue_service.UpdateAssignees(issue, oneAssignee, form.Assignees, ctx.User)
if err != nil {
- ctx.Error(500, "UpdateAssignees", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateAssignees", err)
return
}
}
oldMilestoneID := issue.MilestoneID
issue.MilestoneID = *form.Milestone
if err = issue_service.ChangeMilestoneAssign(issue, ctx.User, oldMilestoneID); err != nil {
- ctx.Error(500, "ChangeMilestoneAssign", err)
+ ctx.Error(http.StatusInternalServerError, "ChangeMilestoneAssign", err)
return
}
}
if err = models.UpdateIssue(issue); err != nil {
- ctx.Error(500, "UpdateIssue", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateIssue", err)
return
}
if form.State != nil {
ctx.Error(http.StatusPreconditionFailed, "DependenciesLeft", "cannot close this issue because it still has open dependencies")
return
}
- ctx.Error(500, "ChangeStatus", err)
+ ctx.Error(http.StatusInternalServerError, "ChangeStatus", err)
return
}
}
// Refetch from database to assign some automatic values
issue, err = models.GetIssueByID(issue.ID)
if err != nil {
- ctx.Error(500, "GetIssueByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByID", err)
return
}
- ctx.JSON(201, issue.APIFormat())
+ ctx.JSON(http.StatusCreated, issue.APIFormat())
}
// UpdateIssueDeadline updates an issue deadline
// "201":
// "$ref": "#/responses/IssueDeadline"
// "403":
- // description: Not repo writer
+ // "$ref": "#/responses/forbidden"
// "404":
- // description: Issue not found
+ // "$ref": "#/responses/notFound"
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
if !ctx.Repo.CanWrite(models.UnitTypeIssues) {
- ctx.Status(403)
+ ctx.Error(http.StatusForbidden, "", "Not repo writer")
return
}
}
if err := models.UpdateIssueDeadline(issue, deadlineUnix, ctx.User); err != nil {
- ctx.Error(500, "UpdateIssueDeadline", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateIssueDeadline", err)
return
}
- ctx.JSON(201, api.IssueDeadline{Deadline: &deadline})
+ ctx.JSON(http.StatusCreated, api.IssueDeadline{Deadline: &deadline})
}
import (
"errors"
+ "net/http"
"time"
"code.gitea.io/gitea/models"
// responses:
// "200":
// "$ref": "#/responses/CommentList"
+
var since time.Time
if len(ctx.Query("since")) > 0 {
since, _ = time.Parse(time.RFC3339, ctx.Query("since"))
// comments,err:=models.GetCommentsByIssueIDSince(, since)
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
- ctx.Error(500, "GetRawIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetRawIssueByIndex", err)
return
}
issue.Repo = ctx.Repo.Repository
Type: models.CommentTypeComment,
})
if err != nil {
- ctx.Error(500, "FindComments", err)
+ ctx.Error(http.StatusInternalServerError, "FindComments", err)
return
}
if err := models.CommentList(comments).LoadPosters(); err != nil {
- ctx.Error(500, "LoadPosters", err)
+ ctx.Error(http.StatusInternalServerError, "LoadPosters", err)
return
}
comment.Issue = issue
apiComments[i] = comments[i].APIFormat()
}
- ctx.JSON(200, &apiComments)
+ ctx.JSON(http.StatusOK, &apiComments)
}
// ListRepoIssueComments returns all issue-comments for a repo
// responses:
// "200":
// "$ref": "#/responses/CommentList"
+
var since time.Time
if len(ctx.Query("since")) > 0 {
since, _ = time.Parse(time.RFC3339, ctx.Query("since"))
Type: models.CommentTypeComment,
})
if err != nil {
- ctx.Error(500, "FindComments", err)
+ ctx.Error(http.StatusInternalServerError, "FindComments", err)
return
}
if err = models.CommentList(comments).LoadPosters(); err != nil {
- ctx.Error(500, "LoadPosters", err)
+ ctx.Error(http.StatusInternalServerError, "LoadPosters", err)
return
}
apiComments := make([]*api.Comment, len(comments))
if err := models.CommentList(comments).LoadIssues(); err != nil {
- ctx.Error(500, "LoadIssues", err)
+ ctx.Error(http.StatusInternalServerError, "LoadIssues", err)
return
}
if err := models.CommentList(comments).LoadPosters(); err != nil {
- ctx.Error(500, "LoadPosters", err)
+ ctx.Error(http.StatusInternalServerError, "LoadPosters", err)
return
}
if _, err := models.CommentList(comments).Issues().LoadRepositories(); err != nil {
- ctx.Error(500, "LoadRepositories", err)
+ ctx.Error(http.StatusInternalServerError, "LoadRepositories", err)
return
}
for i := range comments {
apiComments[i] = comments[i].APIFormat()
}
- ctx.JSON(200, &apiComments)
+ ctx.JSON(http.StatusOK, &apiComments)
}
// CreateIssueComment create a comment for an issue
// responses:
// "201":
// "$ref": "#/responses/Comment"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
return
}
if issue.IsLocked && !ctx.Repo.CanWrite(models.UnitTypeIssues) && !ctx.User.IsAdmin {
- ctx.Error(403, "CreateIssueComment", errors.New(ctx.Tr("repo.issues.comment_on_locked")))
+ ctx.Error(http.StatusForbidden, "CreateIssueComment", errors.New(ctx.Tr("repo.issues.comment_on_locked")))
return
}
comment, err := comment_service.CreateIssueComment(ctx.User, ctx.Repo.Repository, issue, form.Body, nil)
if err != nil {
- ctx.Error(500, "CreateIssueComment", err)
+ ctx.Error(http.StatusInternalServerError, "CreateIssueComment", err)
return
}
- ctx.JSON(201, comment.APIFormat())
+ ctx.JSON(http.StatusCreated, comment.APIFormat())
}
// EditIssueComment modify a comment of an issue
// responses:
// "200":
// "$ref": "#/responses/Comment"
+ // "204":
+ // "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
editIssueComment(ctx, form)
}
if models.IsErrCommentNotExist(err) {
ctx.NotFound(err)
} else {
- ctx.Error(500, "GetCommentByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetCommentByID", err)
}
return
}
if !ctx.IsSigned || (ctx.User.ID != comment.PosterID && !ctx.Repo.IsAdmin()) {
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return
} else if comment.Type != models.CommentTypeComment {
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
return
}
oldContent := comment.Content
comment.Content = form.Body
if err := comment_service.UpdateComment(comment, ctx.User, oldContent); err != nil {
- ctx.Error(500, "UpdateComment", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateComment", err)
return
}
- ctx.JSON(200, comment.APIFormat())
+ ctx.JSON(http.StatusOK, comment.APIFormat())
}
// DeleteIssueComment delete a comment from an issue
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
deleteIssueComment(ctx)
}
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
deleteIssueComment(ctx)
}
if models.IsErrCommentNotExist(err) {
ctx.NotFound(err)
} else {
- ctx.Error(500, "GetCommentByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetCommentByID", err)
}
return
}
if !ctx.IsSigned || (ctx.User.ID != comment.PosterID && !ctx.Repo.IsAdmin()) {
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return
} else if comment.Type != models.CommentTypeComment {
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
return
}
if err = comment_service.DeleteComment(comment, ctx.User); err != nil {
- ctx.Error(500, "DeleteCommentByID", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteCommentByID", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
api "code.gitea.io/gitea/modules/structs"
// "$ref": "#/responses/LabelList"
// "404":
// "$ref": "#/responses/notFound"
+
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
if err := issue.LoadAttributes(); err != nil {
- ctx.Error(500, "LoadAttributes", err)
+ ctx.Error(http.StatusInternalServerError, "LoadAttributes", err)
return
}
for i := range issue.Labels {
apiLabels[i] = issue.Labels[i].APIFormat()
}
- ctx.JSON(200, &apiLabels)
+ ctx.JSON(http.StatusOK, &apiLabels)
}
// AddIssueLabels add labels for an issue
// responses:
// "200":
// "$ref": "#/responses/LabelList"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
if !ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull) {
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return
}
labels, err := models.GetLabelsInRepoByIDs(ctx.Repo.Repository.ID, form.Labels)
if err != nil {
- ctx.Error(500, "GetLabelsInRepoByIDs", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelsInRepoByIDs", err)
return
}
if err = issue_service.AddLabels(issue, ctx.User, labels); err != nil {
- ctx.Error(500, "AddLabels", err)
+ ctx.Error(http.StatusInternalServerError, "AddLabels", err)
return
}
labels, err = models.GetLabelsByIssueID(issue.ID)
if err != nil {
- ctx.Error(500, "GetLabelsByIssueID", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelsByIssueID", err)
return
}
for i := range labels {
apiLabels[i] = labels[i].APIFormat()
}
- ctx.JSON(200, &apiLabels)
+ ctx.JSON(http.StatusOK, &apiLabels)
}
// DeleteIssueLabel delete a label for an issue
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
if !ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull) {
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return
}
label, err := models.GetLabelInRepoByID(ctx.Repo.Repository.ID, ctx.ParamsInt64(":id"))
if err != nil {
if models.IsErrLabelNotExist(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "GetLabelInRepoByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelInRepoByID", err)
}
return
}
if err := models.DeleteIssueLabel(issue, label, ctx.User); err != nil {
- ctx.Error(500, "DeleteIssueLabel", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteIssueLabel", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// ReplaceIssueLabels replace labels for an issue
// responses:
// "200":
// "$ref": "#/responses/LabelList"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
if !ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull) {
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return
}
labels, err := models.GetLabelsInRepoByIDs(ctx.Repo.Repository.ID, form.Labels)
if err != nil {
- ctx.Error(500, "GetLabelsInRepoByIDs", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelsInRepoByIDs", err)
return
}
if err := issue.ReplaceLabels(labels, ctx.User); err != nil {
- ctx.Error(500, "ReplaceLabels", err)
+ ctx.Error(http.StatusInternalServerError, "ReplaceLabels", err)
return
}
labels, err = models.GetLabelsByIssueID(issue.ID)
if err != nil {
- ctx.Error(500, "GetLabelsByIssueID", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelsByIssueID", err)
return
}
for i := range labels {
apiLabels[i] = labels[i].APIFormat()
}
- ctx.JSON(200, &apiLabels)
+ ctx.JSON(http.StatusOK, &apiLabels)
}
// ClearIssueLabels delete all the labels for an issue
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
if !ctx.Repo.CanWriteIssuesOrPulls(issue.IsPull) {
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return
}
if err := issue_service.ClearLabels(issue, ctx.User); err != nil {
- ctx.Error(500, "ClearLabels", err)
+ ctx.Error(http.StatusInternalServerError, "ClearLabels", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
import (
"errors"
+ "net/http"
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
// responses:
// "200":
// "$ref": "#/responses/ReactionResponseList"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
comment, err := models.GetCommentByID(ctx.ParamsInt64(":id"))
if err != nil {
if models.IsErrCommentNotExist(err) {
ctx.NotFound(err)
} else {
- ctx.Error(500, "GetCommentByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetCommentByID", err)
}
return
}
if !ctx.Repo.CanRead(models.UnitTypeIssues) && !ctx.User.IsAdmin {
- ctx.Error(403, "GetIssueCommentReactions", errors.New("no permission to get reactions"))
+ ctx.Error(http.StatusForbidden, "GetIssueCommentReactions", errors.New("no permission to get reactions"))
return
}
reactions, err := models.FindCommentReactions(comment)
if err != nil {
- ctx.Error(500, "FindIssueReactions", err)
+ ctx.Error(http.StatusInternalServerError, "FindIssueReactions", err)
return
}
_, err = reactions.LoadUsers()
if err != nil {
- ctx.Error(500, "ReactionList.LoadUsers()", err)
+ ctx.Error(http.StatusInternalServerError, "ReactionList.LoadUsers()", err)
return
}
})
}
- ctx.JSON(200, result)
+ ctx.JSON(http.StatusOK, result)
}
// PostIssueCommentReaction add a reaction to a comment of a issue
// responses:
// "201":
// "$ref": "#/responses/ReactionResponse"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
changeIssueCommentReaction(ctx, form, true)
}
// responses:
// "200":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
changeIssueCommentReaction(ctx, form, false)
}
if models.IsErrCommentNotExist(err) {
ctx.NotFound(err)
} else {
- ctx.Error(500, "GetCommentByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetCommentByID", err)
}
return
}
err = comment.LoadIssue()
if err != nil {
- ctx.Error(500, "comment.LoadIssue() failed", err)
+ ctx.Error(http.StatusInternalServerError, "comment.LoadIssue() failed", err)
}
if comment.Issue.IsLocked && !ctx.Repo.CanWrite(models.UnitTypeIssues) && !ctx.User.IsAdmin {
- ctx.Error(403, "ChangeIssueCommentReaction", errors.New("no permission to change reaction"))
+ ctx.Error(http.StatusForbidden, "ChangeIssueCommentReaction", errors.New("no permission to change reaction"))
return
}
reaction, err := models.CreateCommentReaction(ctx.User, comment.Issue, comment, form.Reaction)
if err != nil {
if models.IsErrForbiddenIssueReaction(err) {
- ctx.Error(403, err.Error(), err)
+ ctx.Error(http.StatusForbidden, err.Error(), err)
} else {
- ctx.Error(500, "CreateCommentReaction", err)
+ ctx.Error(http.StatusInternalServerError, "CreateCommentReaction", err)
}
return
}
_, err = reaction.LoadUser()
if err != nil {
- ctx.Error(500, "Reaction.LoadUser()", err)
+ ctx.Error(http.StatusInternalServerError, "Reaction.LoadUser()", err)
return
}
- ctx.JSON(201, api.ReactionResponse{
+ ctx.JSON(http.StatusCreated, api.ReactionResponse{
User: reaction.User.APIFormat(),
Reaction: reaction.Type,
Created: reaction.CreatedUnix.AsTime(),
// DeleteIssueCommentReaction part
err = models.DeleteCommentReaction(ctx.User, comment.Issue, comment, form.Reaction)
if err != nil {
- ctx.Error(500, "DeleteCommentReaction", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteCommentReaction", err)
return
}
- ctx.Status(200)
+ //ToDo respond 204
+ ctx.Status(http.StatusOK)
}
}
// responses:
// "200":
// "$ref": "#/responses/ReactionResponseList"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
issue, err := models.GetIssueWithAttrsByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
if !ctx.Repo.CanRead(models.UnitTypeIssues) && !ctx.User.IsAdmin {
- ctx.Error(403, "GetIssueReactions", errors.New("no permission to get reactions"))
+ ctx.Error(http.StatusForbidden, "GetIssueReactions", errors.New("no permission to get reactions"))
return
}
reactions, err := models.FindIssueReactions(issue)
if err != nil {
- ctx.Error(500, "FindIssueReactions", err)
+ ctx.Error(http.StatusInternalServerError, "FindIssueReactions", err)
return
}
_, err = reactions.LoadUsers()
if err != nil {
- ctx.Error(500, "ReactionList.LoadUsers()", err)
+ ctx.Error(http.StatusInternalServerError, "ReactionList.LoadUsers()", err)
return
}
})
}
- ctx.JSON(200, result)
+ ctx.JSON(http.StatusOK, result)
}
// PostIssueReaction add a reaction to a comment of a issue
// responses:
// "201":
// "$ref": "#/responses/ReactionResponse"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
changeIssueReaction(ctx, form, true)
}
// responses:
// "200":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
changeIssueReaction(ctx, form, false)
}
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
if issue.IsLocked && !ctx.Repo.CanWrite(models.UnitTypeIssues) && !ctx.User.IsAdmin {
- ctx.Error(403, "ChangeIssueCommentReaction", errors.New("no permission to change reaction"))
+ ctx.Error(http.StatusForbidden, "ChangeIssueCommentReaction", errors.New("no permission to change reaction"))
return
}
reaction, err := models.CreateIssueReaction(ctx.User, issue, form.Reaction)
if err != nil {
if models.IsErrForbiddenIssueReaction(err) {
- ctx.Error(403, err.Error(), err)
+ ctx.Error(http.StatusForbidden, err.Error(), err)
} else {
- ctx.Error(500, "CreateCommentReaction", err)
+ ctx.Error(http.StatusInternalServerError, "CreateCommentReaction", err)
}
return
}
_, err = reaction.LoadUser()
if err != nil {
- ctx.Error(500, "Reaction.LoadUser()", err)
+ ctx.Error(http.StatusInternalServerError, "Reaction.LoadUser()", err)
return
}
- ctx.JSON(201, api.ReactionResponse{
+ ctx.JSON(http.StatusCreated, api.ReactionResponse{
User: reaction.User.APIFormat(),
Reaction: reaction.Type,
Created: reaction.CreatedUnix.AsTime(),
// DeleteIssueReaction part
err = models.DeleteIssueReaction(ctx.User, issue, form.Reaction)
if err != nil {
- ctx.Error(500, "DeleteIssueReaction", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteIssueReaction", err)
return
}
- ctx.Status(200)
+ //ToDo respond 204
+ ctx.Status(http.StatusOK)
}
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
)
// "403":
// description: Not repo writer, user does not have rights to toggle stopwatch
// "404":
- // description: Issue not found
+ // "$ref": "#/responses/notFound"
// "409":
// description: Cannot start a stopwatch again if it already exists
+
issue, err := prepareIssueStopwatch(ctx, false)
if err != nil {
return
}
if err := models.CreateOrStopIssueStopwatch(ctx.User, issue); err != nil {
- ctx.Error(500, "CreateOrStopIssueStopwatch", err)
+ ctx.Error(http.StatusInternalServerError, "CreateOrStopIssueStopwatch", err)
return
}
- ctx.Status(201)
+ ctx.Status(http.StatusCreated)
}
// StopIssueStopwatch stops a stopwatch for the given issue.
// "403":
// description: Not repo writer, user does not have rights to toggle stopwatch
// "404":
- // description: Issue not found
+ // "$ref": "#/responses/notFound"
// "409":
// description: Cannot stop a non existent stopwatch
+
issue, err := prepareIssueStopwatch(ctx, true)
if err != nil {
return
}
if err := models.CreateOrStopIssueStopwatch(ctx.User, issue); err != nil {
- ctx.Error(500, "CreateOrStopIssueStopwatch", err)
+ ctx.Error(http.StatusInternalServerError, "CreateOrStopIssueStopwatch", err)
return
}
- ctx.Status(201)
+ ctx.Status(http.StatusCreated)
}
// DeleteIssueStopwatch delete a specific stopwatch
// "403":
// description: Not repo writer, user does not have rights to toggle stopwatch
// "404":
- // description: Issue not found
+ // "$ref": "#/responses/notFound"
// "409":
// description: Cannot cancel a non existent stopwatch
+
issue, err := prepareIssueStopwatch(ctx, true)
if err != nil {
return
}
if err := models.CancelStopwatch(ctx.User, issue); err != nil {
- ctx.Error(500, "CancelStopwatch", err)
+ ctx.Error(http.StatusInternalServerError, "CancelStopwatch", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
func prepareIssueStopwatch(ctx *context.APIContext, shouldExist bool) (*models.Issue, error) {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return nil, err
}
if !ctx.Repo.CanWrite(models.UnitTypeIssues) {
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return nil, err
}
if !ctx.Repo.CanUseTimetracker(issue, ctx.User) {
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return nil, err
}
if models.StopwatchExists(ctx.User.ID, issue.ID) != shouldExist {
if shouldExist {
- ctx.Error(409, "StopwatchExists", "cannot stop/cancel a non existent stopwatch")
+ ctx.Error(http.StatusConflict, "StopwatchExists", "cannot stop/cancel a non existent stopwatch")
} else {
- ctx.Error(409, "StopwatchExists", "cannot start a stopwatch again if it already exists")
+ ctx.Error(http.StatusConflict, "StopwatchExists", "cannot start a stopwatch again if it already exists")
}
return nil, err
}
sws, err := models.GetUserStopwatches(ctx.User.ID)
if err != nil {
- ctx.Error(500, "GetUserStopwatches", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserStopwatches", err)
return
}
apiSWs, err := sws.APIFormat()
if err != nil {
- ctx.Error(500, "APIFormat", err)
+ ctx.Error(http.StatusInternalServerError, "APIFormat", err)
return
}
- ctx.JSON(200, apiSWs)
+ ctx.JSON(http.StatusOK, apiSWs)
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
)
// "304":
// description: User can only subscribe itself if he is no admin
// "404":
- // description: Issue not found
+ // "$ref": "#/responses/notFound"
+
setIssueSubscription(ctx, true)
}
// "304":
// description: User can only subscribe itself if he is no admin
// "404":
- // description: Issue not found
+ // "$ref": "#/responses/notFound"
+
setIssueSubscription(ctx, false)
}
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
if models.IsErrUserNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetUserByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByName", err)
}
return
//only admin and user for itself can change subscription
if user.ID != ctx.User.ID && !ctx.User.IsAdmin {
- ctx.Error(403, "User", nil)
+ ctx.Error(http.StatusForbidden, "User", nil)
return
}
if err := models.CreateOrUpdateIssueWatch(user.ID, issue.ID, watch); err != nil {
- ctx.Error(500, "CreateOrUpdateIssueWatch", err)
+ ctx.Error(http.StatusInternalServerError, "CreateOrUpdateIssueWatch", err)
return
}
- ctx.Status(201)
+ ctx.Status(http.StatusCreated)
}
// GetIssueSubscribers return subscribers of an issue
// "200":
// "$ref": "#/responses/UserList"
// "404":
- // description: Issue not found
+ // "$ref": "#/responses/notFound"
+
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
iwl, err := models.GetIssueWatchers(issue.ID)
if err != nil {
- ctx.Error(500, "GetIssueWatchers", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueWatchers", err)
return
}
users, err := iwl.LoadWatchUsers()
if err != nil {
- ctx.Error(500, "LoadWatchUsers", err)
+ ctx.Error(http.StatusInternalServerError, "LoadWatchUsers", err)
return
}
- ctx.JSON(200, users.APIFormat())
+ ctx.JSON(http.StatusOK, users.APIFormat())
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
api "code.gitea.io/gitea/modules/structs"
// responses:
// "200":
// "$ref": "#/responses/TrackedTimeList"
+ // "404":
+ // "$ref": "#/responses/notFound"
+
if !ctx.Repo.Repository.IsTimetrackerEnabled() {
ctx.NotFound("Timetracker is disabled")
return
if models.IsErrIssueNotExist(err) {
ctx.NotFound(err)
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
trackedTimes, err := models.GetTrackedTimes(models.FindTrackedTimesOptions{IssueID: issue.ID})
if err != nil {
- ctx.Error(500, "GetTrackedTimesByIssue", err)
+ ctx.Error(http.StatusInternalServerError, "GetTrackedTimesByIssue", err)
return
}
apiTrackedTimes := trackedTimesToAPIFormat(trackedTimes)
- ctx.JSON(200, &apiTrackedTimes)
+ ctx.JSON(http.StatusOK, &apiTrackedTimes)
}
// AddTime adds time manual to the given issue
// "400":
// "$ref": "#/responses/error"
// "403":
- // "$ref": "#/responses/error"
+ // "$ref": "#/responses/forbidden"
+
issue, err := models.GetIssueByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrIssueNotExist(err) {
ctx.NotFound(err)
} else {
- ctx.Error(500, "GetIssueByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetIssueByIndex", err)
}
return
}
if !ctx.Repo.CanUseTimetracker(issue, ctx.User) {
if !ctx.Repo.Repository.IsTimetrackerEnabled() {
- ctx.JSON(400, struct{ Message string }{Message: "time tracking disabled"})
+ ctx.Error(http.StatusBadRequest, "", "time tracking disabled")
return
}
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return
}
trackedTime, err := models.AddTime(ctx.User, issue, form.Time)
if err != nil {
- ctx.Error(500, "AddTime", err)
+ ctx.Error(http.StatusInternalServerError, "AddTime", err)
return
}
- ctx.JSON(200, trackedTime.APIFormat())
+ ctx.JSON(http.StatusOK, trackedTime.APIFormat())
}
// ListTrackedTimesByUser lists all tracked times of the user
// responses:
// "200":
// "$ref": "#/responses/TrackedTimeList"
+ // "400":
+ // "$ref": "#/responses/error"
+
if !ctx.Repo.Repository.IsTimetrackerEnabled() {
- ctx.JSON(400, struct{ Message string }{Message: "time tracking disabled"})
+ ctx.Error(http.StatusBadRequest, "", "time tracking disabled")
return
}
user, err := models.GetUserByName(ctx.Params(":timetrackingusername"))
if models.IsErrUserNotExist(err) {
ctx.NotFound(err)
} else {
- ctx.Error(500, "GetUserByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByName", err)
}
return
}
UserID: user.ID,
RepositoryID: ctx.Repo.Repository.ID})
if err != nil {
- ctx.Error(500, "GetTrackedTimesByUser", err)
+ ctx.Error(http.StatusInternalServerError, "GetTrackedTimesByUser", err)
return
}
apiTrackedTimes := trackedTimesToAPIFormat(trackedTimes)
- ctx.JSON(200, &apiTrackedTimes)
+ ctx.JSON(http.StatusOK, &apiTrackedTimes)
}
// ListTrackedTimesByRepository lists all tracked times of the repository
// responses:
// "200":
// "$ref": "#/responses/TrackedTimeList"
+ // "400":
+ // "$ref": "#/responses/error"
+
if !ctx.Repo.Repository.IsTimetrackerEnabled() {
- ctx.JSON(400, struct{ Message string }{Message: "time tracking disabled"})
+ ctx.Error(http.StatusBadRequest, "", "time tracking disabled")
return
}
trackedTimes, err := models.GetTrackedTimes(models.FindTrackedTimesOptions{
RepositoryID: ctx.Repo.Repository.ID})
if err != nil {
- ctx.Error(500, "GetTrackedTimesByUser", err)
+ ctx.Error(http.StatusInternalServerError, "GetTrackedTimesByUser", err)
return
}
apiTrackedTimes := trackedTimesToAPIFormat(trackedTimes)
- ctx.JSON(200, &apiTrackedTimes)
+ ctx.JSON(http.StatusOK, &apiTrackedTimes)
}
// ListMyTrackedTimes lists all tracked times of the current user
// responses:
// "200":
// "$ref": "#/responses/TrackedTimeList"
+
trackedTimes, err := models.GetTrackedTimes(models.FindTrackedTimesOptions{UserID: ctx.User.ID})
if err != nil {
- ctx.Error(500, "GetTrackedTimesByUser", err)
+ ctx.Error(http.StatusInternalServerError, "GetTrackedTimesByUser", err)
return
}
apiTrackedTimes := trackedTimesToAPIFormat(trackedTimes)
- ctx.JSON(200, &apiTrackedTimes)
+ ctx.JSON(http.StatusOK, &apiTrackedTimes)
}
import (
"fmt"
+ "net/http"
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
// responses:
// "200":
// "$ref": "#/responses/DeployKeyList"
+
var keys []*models.DeployKey
var err error
}
if err != nil {
- ctx.Error(500, "ListDeployKeys", err)
+ ctx.Error(http.StatusInternalServerError, "ListDeployKeys", err)
return
}
apiKeys := make([]*api.DeployKey, len(keys))
for i := range keys {
if err = keys[i].GetContent(); err != nil {
- ctx.Error(500, "GetContent", err)
+ ctx.Error(http.StatusInternalServerError, "GetContent", err)
return
}
apiKeys[i] = convert.ToDeployKey(apiLink, keys[i])
}
}
- ctx.JSON(200, &apiKeys)
+ ctx.JSON(http.StatusOK, &apiKeys)
}
// GetDeployKey get a deploy key by id
// responses:
// "200":
// "$ref": "#/responses/DeployKey"
+
key, err := models.GetDeployKeyByID(ctx.ParamsInt64(":id"))
if err != nil {
if models.IsErrDeployKeyNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetDeployKeyByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetDeployKeyByID", err)
}
return
}
if err = key.GetContent(); err != nil {
- ctx.Error(500, "GetContent", err)
+ ctx.Error(http.StatusInternalServerError, "GetContent", err)
return
}
if ctx.User.IsAdmin || ((ctx.Repo.Repository.ID == key.RepoID) && (ctx.User.ID == ctx.Repo.Owner.ID)) {
apiKey, _ = appendPrivateInformation(apiKey, key, ctx.Repo.Repository)
}
- ctx.JSON(200, apiKey)
+ ctx.JSON(http.StatusOK, apiKey)
}
// HandleCheckKeyStringError handle check key error
func HandleCheckKeyStringError(ctx *context.APIContext, err error) {
if models.IsErrSSHDisabled(err) {
- ctx.Error(422, "", "SSH is disabled")
+ ctx.Error(http.StatusUnprocessableEntity, "", "SSH is disabled")
} else if models.IsErrKeyUnableVerify(err) {
- ctx.Error(422, "", "Unable to verify key content")
+ ctx.Error(http.StatusUnprocessableEntity, "", "Unable to verify key content")
} else {
- ctx.Error(422, "", fmt.Errorf("Invalid key content: %v", err))
+ ctx.Error(http.StatusUnprocessableEntity, "", fmt.Errorf("Invalid key content: %v", err))
}
}
func HandleAddKeyError(ctx *context.APIContext, err error) {
switch {
case models.IsErrDeployKeyAlreadyExist(err):
- ctx.Error(422, "", "This key has already been added to this repository")
+ ctx.Error(http.StatusUnprocessableEntity, "", "This key has already been added to this repository")
case models.IsErrKeyAlreadyExist(err):
- ctx.Error(422, "", "Key content has been used as non-deploy key")
+ ctx.Error(http.StatusUnprocessableEntity, "", "Key content has been used as non-deploy key")
case models.IsErrKeyNameAlreadyUsed(err):
- ctx.Error(422, "", "Key title has been used")
+ ctx.Error(http.StatusUnprocessableEntity, "", "Key title has been used")
default:
- ctx.Error(500, "AddKey", err)
+ ctx.Error(http.StatusInternalServerError, "AddKey", err)
}
}
// responses:
// "201":
// "$ref": "#/responses/DeployKey"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
content, err := models.CheckPublicKeyString(form.Key)
if err != nil {
HandleCheckKeyStringError(ctx, err)
key.Content = content
apiLink := composeDeployKeysAPILink(ctx.Repo.Owner.Name + "/" + ctx.Repo.Repository.Name)
- ctx.JSON(201, convert.ToDeployKey(apiLink, key))
+ ctx.JSON(http.StatusCreated, convert.ToDeployKey(apiLink, key))
}
// DeleteDeploykey delete deploy key for a repository
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
if err := models.DeleteDeployKey(ctx.User, ctx.ParamsInt64(":id")); err != nil {
if models.IsErrKeyAccessDenied(err) {
- ctx.Error(403, "", "You do not have access to this key")
+ ctx.Error(http.StatusForbidden, "", "You do not have access to this key")
} else {
- ctx.Error(500, "DeleteDeployKey", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteDeployKey", err)
}
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package repo
import (
+ "net/http"
"strconv"
"code.gitea.io/gitea/models"
// responses:
// "200":
// "$ref": "#/responses/LabelList"
+
labels, err := models.GetLabelsByRepoID(ctx.Repo.Repository.ID, ctx.Query("sort"))
if err != nil {
- ctx.Error(500, "GetLabelsByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelsByRepoID", err)
return
}
for i := range labels {
apiLabels[i] = labels[i].APIFormat()
}
- ctx.JSON(200, &apiLabels)
+ ctx.JSON(http.StatusOK, &apiLabels)
}
// GetLabel get label by repository and label id
// responses:
// "200":
// "$ref": "#/responses/Label"
+
var (
label *models.Label
err error
if models.IsErrLabelNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetLabelByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelByRepoID", err)
}
return
}
- ctx.JSON(200, label.APIFormat())
+ ctx.JSON(http.StatusOK, label.APIFormat())
}
// CreateLabel create a label for a repository
// responses:
// "201":
// "$ref": "#/responses/Label"
+
label := &models.Label{
Name: form.Name,
Color: form.Color,
Description: form.Description,
}
if err := models.NewLabel(label); err != nil {
- ctx.Error(500, "NewLabel", err)
+ ctx.Error(http.StatusInternalServerError, "NewLabel", err)
return
}
- ctx.JSON(201, label.APIFormat())
+ ctx.JSON(http.StatusCreated, label.APIFormat())
}
// EditLabel modify a label for a repository
// responses:
// "200":
// "$ref": "#/responses/Label"
+
label, err := models.GetLabelInRepoByID(ctx.Repo.Repository.ID, ctx.ParamsInt64(":id"))
if err != nil {
if models.IsErrLabelNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetLabelByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelByRepoID", err)
}
return
}
ctx.ServerError("UpdateLabel", err)
return
}
- ctx.JSON(200, label.APIFormat())
+ ctx.JSON(http.StatusOK, label.APIFormat())
}
// DeleteLabel delete a label for a repository
// responses:
// "204":
// "$ref": "#/responses/empty"
+
if err := models.DeleteLabel(ctx.Repo.Repository.ID, ctx.ParamsInt64(":id")); err != nil {
- ctx.Error(500, "DeleteLabel", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteLabel", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package repo
import (
+ "net/http"
"time"
"code.gitea.io/gitea/models"
// responses:
// "200":
// "$ref": "#/responses/MilestoneList"
+
milestones, err := models.GetMilestonesByRepoID(ctx.Repo.Repository.ID, api.StateType(ctx.Query("state")))
if err != nil {
- ctx.Error(500, "GetMilestonesByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "GetMilestonesByRepoID", err)
return
}
for i := range milestones {
apiMilestones[i] = milestones[i].APIFormat()
}
- ctx.JSON(200, &apiMilestones)
+ ctx.JSON(http.StatusOK, &apiMilestones)
}
// GetMilestone get a milestone for a repository
// responses:
// "200":
// "$ref": "#/responses/Milestone"
+
milestone, err := models.GetMilestoneByRepoID(ctx.Repo.Repository.ID, ctx.ParamsInt64(":id"))
if err != nil {
if models.IsErrMilestoneNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetMilestoneByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "GetMilestoneByRepoID", err)
}
return
}
- ctx.JSON(200, milestone.APIFormat())
+ ctx.JSON(http.StatusOK, milestone.APIFormat())
}
// CreateMilestone create a milestone for a repository
// responses:
// "201":
// "$ref": "#/responses/Milestone"
+
if form.Deadline == nil {
defaultDeadline, _ := time.ParseInLocation("2006-01-02", "9999-12-31", time.Local)
form.Deadline = &defaultDeadline
}
if err := models.NewMilestone(milestone); err != nil {
- ctx.Error(500, "NewMilestone", err)
+ ctx.Error(http.StatusInternalServerError, "NewMilestone", err)
return
}
- ctx.JSON(201, milestone.APIFormat())
+ ctx.JSON(http.StatusCreated, milestone.APIFormat())
}
// EditMilestone modify a milestone for a repository
// responses:
// "200":
// "$ref": "#/responses/Milestone"
+
milestone, err := models.GetMilestoneByRepoID(ctx.Repo.Repository.ID, ctx.ParamsInt64(":id"))
if err != nil {
if models.IsErrMilestoneNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetMilestoneByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "GetMilestoneByRepoID", err)
}
return
}
ctx.ServerError("UpdateMilestone", err)
return
}
- ctx.JSON(200, milestone.APIFormat())
+ ctx.JSON(http.StatusOK, milestone.APIFormat())
}
// DeleteMilestone delete a milestone for a repository
// responses:
// "204":
// "$ref": "#/responses/empty"
+
if err := models.DeleteMilestoneByRepoID(ctx.Repo.Repository.ID, ctx.ParamsInt64(":id")); err != nil {
- ctx.Error(500, "DeleteMilestoneByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteMilestoneByRepoID", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// responses:
// "200":
// "$ref": "#/responses/PullRequestList"
+
prs, maxResults, err := models.PullRequests(ctx.Repo.Repository.ID, &models.PullRequestsOptions{
Page: ctx.QueryInt("page"),
State: ctx.QueryTrim("state"),
})
if err != nil {
- ctx.Error(500, "PullRequests", err)
+ ctx.Error(http.StatusInternalServerError, "PullRequests", err)
return
}
apiPrs := make([]*api.PullRequest, len(prs))
for i := range prs {
if err = prs[i].LoadIssue(); err != nil {
- ctx.Error(500, "LoadIssue", err)
+ ctx.Error(http.StatusInternalServerError, "LoadIssue", err)
return
}
if err = prs[i].LoadAttributes(); err != nil {
- ctx.Error(500, "LoadAttributes", err)
+ ctx.Error(http.StatusInternalServerError, "LoadAttributes", err)
return
}
if err = prs[i].GetBaseRepo(); err != nil {
- ctx.Error(500, "GetBaseRepo", err)
+ ctx.Error(http.StatusInternalServerError, "GetBaseRepo", err)
return
}
if err = prs[i].GetHeadRepo(); err != nil {
- ctx.Error(500, "GetHeadRepo", err)
+ ctx.Error(http.StatusInternalServerError, "GetHeadRepo", err)
return
}
apiPrs[i] = prs[i].APIFormat()
}
ctx.SetLinkHeader(int(maxResults), models.ItemsPerPage)
- ctx.JSON(200, &apiPrs)
+ ctx.JSON(http.StatusOK, &apiPrs)
}
// GetPullRequest returns a single PR based on index
// responses:
// "200":
// "$ref": "#/responses/PullRequest"
+
pr, err := models.GetPullRequestByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrPullRequestNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetPullRequestByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetPullRequestByIndex", err)
}
return
}
if err = pr.GetBaseRepo(); err != nil {
- ctx.Error(500, "GetBaseRepo", err)
+ ctx.Error(http.StatusInternalServerError, "GetBaseRepo", err)
return
}
if err = pr.GetHeadRepo(); err != nil {
- ctx.Error(500, "GetHeadRepo", err)
+ ctx.Error(http.StatusInternalServerError, "GetHeadRepo", err)
return
}
- ctx.JSON(200, pr.APIFormat())
+ ctx.JSON(http.StatusOK, pr.APIFormat())
}
// CreatePullRequest does what it says
// responses:
// "201":
// "$ref": "#/responses/PullRequest"
+ // "409":
+ // "$ref": "#/responses/error"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
var (
repo = ctx.Repo.Repository
labelIDs []int64
existingPr, err := models.GetUnmergedPullRequest(headRepo.ID, ctx.Repo.Repository.ID, headBranch, baseBranch)
if err != nil {
if !models.IsErrPullRequestNotExist(err) {
- ctx.Error(500, "GetUnmergedPullRequest", err)
+ ctx.Error(http.StatusInternalServerError, "GetUnmergedPullRequest", err)
return
}
} else {
HeadBranch: existingPr.HeadBranch,
BaseBranch: existingPr.BaseBranch,
}
- ctx.Error(409, "GetUnmergedPullRequest", err)
+ ctx.Error(http.StatusConflict, "GetUnmergedPullRequest", err)
return
}
if len(form.Labels) > 0 {
labels, err := models.GetLabelsInRepoByIDs(ctx.Repo.Repository.ID, form.Labels)
if err != nil {
- ctx.Error(500, "GetLabelsInRepoByIDs", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelsInRepoByIDs", err)
return
}
if models.IsErrMilestoneNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetMilestoneByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "GetMilestoneByRepoID", err)
}
return
}
assigneeIDs, err := models.MakeIDsFromAPIAssigneesToAdd(form.Assignee, form.Assignees)
if err != nil {
if models.IsErrUserNotExist(err) {
- ctx.Error(422, "", fmt.Sprintf("Assignee does not exist: [name: %s]", err))
+ ctx.Error(http.StatusUnprocessableEntity, "", fmt.Sprintf("Assignee does not exist: [name: %s]", err))
} else {
- ctx.Error(500, "AddAssigneeByName", err)
+ ctx.Error(http.StatusInternalServerError, "AddAssigneeByName", err)
}
return
}
for _, aID := range assigneeIDs {
assignee, err := models.GetUserByID(aID)
if err != nil {
- ctx.Error(500, "GetUserByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByID", err)
return
}
valid, err := models.CanBeAssigned(assignee, repo, true)
if err != nil {
- ctx.Error(500, "canBeAssigned", err)
+ ctx.Error(http.StatusInternalServerError, "canBeAssigned", err)
return
}
if !valid {
- ctx.Error(422, "canBeAssigned", models.ErrUserDoesNotHaveAccessToRepo{UserID: aID, RepoName: repo.Name})
+ ctx.Error(http.StatusUnprocessableEntity, "canBeAssigned", models.ErrUserDoesNotHaveAccessToRepo{UserID: aID, RepoName: repo.Name})
return
}
}
if err := pull_service.NewPullRequest(repo, prIssue, labelIDs, []string{}, pr, assigneeIDs); err != nil {
if models.IsErrUserDoesNotHaveAccessToRepo(err) {
- ctx.Error(400, "UserDoesNotHaveAccessToRepo", err)
+ ctx.Error(http.StatusBadRequest, "UserDoesNotHaveAccessToRepo", err)
return
}
- ctx.Error(500, "NewPullRequest", err)
+ ctx.Error(http.StatusInternalServerError, "NewPullRequest", err)
return
}
notification.NotifyNewPullRequest(pr)
log.Trace("Pull request created: %d/%d", repo.ID, prIssue.ID)
- ctx.JSON(201, pr.APIFormat())
+ ctx.JSON(http.StatusCreated, pr.APIFormat())
}
// EditPullRequest does what it says
// responses:
// "201":
// "$ref": "#/responses/PullRequest"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+ // "412":
+ // "$ref": "#/responses/error"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
pr, err := models.GetPullRequestByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrPullRequestNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetPullRequestByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetPullRequestByIndex", err)
}
return
}
issue.Repo = ctx.Repo.Repository
if !issue.IsPoster(ctx.User.ID) && !ctx.Repo.CanWrite(models.UnitTypePullRequests) {
- ctx.Status(403)
+ ctx.Status(http.StatusForbidden)
return
}
}
if err := models.UpdateIssueDeadline(issue, deadlineUnix, ctx.User); err != nil {
- ctx.Error(500, "UpdateIssueDeadline", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateIssueDeadline", err)
return
}
issue.DeadlineUnix = deadlineUnix
err = issue_service.UpdateAssignees(issue, form.Assignee, form.Assignees, ctx.User)
if err != nil {
if models.IsErrUserNotExist(err) {
- ctx.Error(422, "", fmt.Sprintf("Assignee does not exist: [name: %s]", err))
+ ctx.Error(http.StatusUnprocessableEntity, "", fmt.Sprintf("Assignee does not exist: [name: %s]", err))
} else {
- ctx.Error(500, "UpdateAssignees", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateAssignees", err)
}
return
}
oldMilestoneID := issue.MilestoneID
issue.MilestoneID = form.Milestone
if err = issue_service.ChangeMilestoneAssign(issue, ctx.User, oldMilestoneID); err != nil {
- ctx.Error(500, "ChangeMilestoneAssign", err)
+ ctx.Error(http.StatusInternalServerError, "ChangeMilestoneAssign", err)
return
}
}
if ctx.Repo.CanWrite(models.UnitTypePullRequests) && form.Labels != nil {
labels, err := models.GetLabelsInRepoByIDs(ctx.Repo.Repository.ID, form.Labels)
if err != nil {
- ctx.Error(500, "GetLabelsInRepoByIDsError", err)
+ ctx.Error(http.StatusInternalServerError, "GetLabelsInRepoByIDsError", err)
return
}
if err = issue.ReplaceLabels(labels, ctx.User); err != nil {
- ctx.Error(500, "ReplaceLabelsError", err)
+ ctx.Error(http.StatusInternalServerError, "ReplaceLabelsError", err)
return
}
}
if err = models.UpdateIssue(issue); err != nil {
- ctx.Error(500, "UpdateIssue", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateIssue", err)
return
}
if form.State != nil {
ctx.Error(http.StatusPreconditionFailed, "DependenciesLeft", "cannot close this pull request because it still has open dependencies")
return
}
- ctx.Error(500, "ChangeStatus", err)
+ ctx.Error(http.StatusInternalServerError, "ChangeStatus", err)
return
}
}
if models.IsErrPullRequestNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetPullRequestByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetPullRequestByIndex", err)
}
return
}
// TODO this should be 200, not 201
- ctx.JSON(201, pr.APIFormat())
+ ctx.JSON(http.StatusCreated, pr.APIFormat())
}
// IsPullRequestMerged checks if a PR exists given an index
// description: pull request has been merged
// "404":
// description: pull request has not been merged
+
pr, err := models.GetPullRequestByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrPullRequestNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetPullRequestByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetPullRequestByIndex", err)
}
return
}
if pr.HasMerged {
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
ctx.NotFound()
}
// "$ref": "#/responses/empty"
// "405":
// "$ref": "#/responses/empty"
+ // "409":
+ // "$ref": "#/responses/error"
+
pr, err := models.GetPullRequestByIndex(ctx.Repo.Repository.ID, ctx.ParamsInt64(":index"))
if err != nil {
if models.IsErrPullRequestNotExist(err) {
ctx.NotFound("GetPullRequestByIndex", err)
} else {
- ctx.Error(500, "GetPullRequestByIndex", err)
+ ctx.Error(http.StatusInternalServerError, "GetPullRequestByIndex", err)
}
return
}
if ctx.IsSigned {
// Update issue-user.
if err = pr.Issue.ReadBy(ctx.User.ID); err != nil {
- ctx.Error(500, "ReadBy", err)
+ ctx.Error(http.StatusInternalServerError, "ReadBy", err)
return
}
}
}
if !pr.CanAutoMerge() || pr.HasMerged || pr.IsWorkInProgress() {
- ctx.Status(405)
+ ctx.Status(http.StatusMethodNotAllowed)
return
}
isPass, err := pull_service.IsPullCommitStatusPass(pr)
if err != nil {
- ctx.Error(500, "IsPullCommitStatusPass", err)
+ ctx.Error(http.StatusInternalServerError, "IsPullCommitStatusPass", err)
return
}
if !isPass && !ctx.IsUserRepoAdmin() {
- ctx.Status(405)
+ ctx.Status(http.StatusMethodNotAllowed)
return
}
if err := pull_service.Merge(pr, ctx.User, ctx.Repo.GitRepo, models.MergeStyle(form.Do), message); err != nil {
if models.IsErrInvalidMergeStyle(err) {
- ctx.Status(405)
+ ctx.Status(http.StatusMethodNotAllowed)
return
} else if models.IsErrMergeConflicts(err) {
conflictError := err.(models.ErrMergeConflicts)
conflictError := err.(models.ErrMergeUnrelatedHistories)
ctx.JSON(http.StatusConflict, conflictError)
} else if models.IsErrMergePushOutOfDate(err) {
- ctx.Status(http.StatusConflict)
+ ctx.Error(http.StatusConflict, "Merge", "merge push out of date")
return
}
- ctx.Error(500, "Merge", err)
+ ctx.Error(http.StatusInternalServerError, "Merge", err)
return
}
log.Trace("Pull request merged: %d", pr.ID)
- ctx.Status(200)
+ ctx.Status(http.StatusOK)
}
func parseCompareInfo(ctx *context.APIContext, form api.CreatePullRequestOption) (*models.User, *models.Repository, *git.Repository, *git.CompareInfo, string, string) {
} else {
headGitRepo, err = git.OpenRepository(models.RepoPath(headUser.Name, headRepo.Name))
if err != nil {
- ctx.Error(500, "OpenRepository", err)
+ ctx.Error(http.StatusInternalServerError, "OpenRepository", err)
return nil, nil, nil, nil, "", ""
}
}
compareInfo, err := headGitRepo.GetCompareInfo(models.RepoPath(baseRepo.Owner.Name, baseRepo.Name), baseBranch, headBranch)
if err != nil {
headGitRepo.Close()
- ctx.Error(500, "GetCompareInfo", err)
+ ctx.Error(http.StatusInternalServerError, "GetCompareInfo", err)
return nil, nil, nil, nil, "", ""
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
// responses:
// "200":
// "$ref": "#/responses/Release"
+
id := ctx.ParamsInt64(":id")
release, err := models.GetReleaseByID(id)
if err != nil {
- ctx.Error(500, "GetReleaseByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetReleaseByID", err)
return
}
if release.RepoID != ctx.Repo.Repository.ID {
return
}
if err := release.LoadAttributes(); err != nil {
- ctx.Error(500, "LoadAttributes", err)
+ ctx.Error(http.StatusInternalServerError, "LoadAttributes", err)
return
}
- ctx.JSON(200, release.APIFormat())
+ ctx.JSON(http.StatusOK, release.APIFormat())
}
func getPagesInfo(ctx *context.APIContext) (int, int) {
// responses:
// "200":
// "$ref": "#/responses/ReleaseList"
+
page, limit := getPagesInfo(ctx)
releases, err := models.GetReleasesByRepoID(ctx.Repo.Repository.ID, models.FindReleasesOptions{
IncludeDrafts: ctx.Repo.AccessMode >= models.AccessModeWrite,
IncludeTags: false,
}, page, limit)
if err != nil {
- ctx.Error(500, "GetReleasesByRepoID", err)
+ ctx.Error(http.StatusInternalServerError, "GetReleasesByRepoID", err)
return
}
rels := make([]*api.Release, len(releases))
for i, release := range releases {
if err := release.LoadAttributes(); err != nil {
- ctx.Error(500, "LoadAttributes", err)
+ ctx.Error(http.StatusInternalServerError, "LoadAttributes", err)
return
}
rels[i] = release.APIFormat()
}
- ctx.JSON(200, rels)
+ ctx.JSON(http.StatusOK, rels)
}
// CreateRelease create a release
// responses:
// "201":
// "$ref": "#/responses/Release"
+ // "409":
+ // "$ref": "#/responses/error"
+
rel, err := models.GetRelease(ctx.Repo.Repository.ID, form.TagName)
if err != nil {
if !models.IsErrReleaseNotExist(err) {
}
if err := releaseservice.CreateRelease(ctx.Repo.GitRepo, rel, nil); err != nil {
if models.IsErrReleaseAlreadyExist(err) {
- ctx.Status(409)
+ ctx.Error(http.StatusConflict, "ReleaseAlreadyExist", err)
} else {
- ctx.Error(500, "CreateRelease", err)
+ ctx.Error(http.StatusInternalServerError, "CreateRelease", err)
}
return
}
} else {
if !rel.IsTag {
- ctx.Status(409)
+ ctx.Error(http.StatusConflict, "GetRelease", "Release is has no Tag")
return
}
return
}
}
- ctx.JSON(201, rel.APIFormat())
+ ctx.JSON(http.StatusCreated, rel.APIFormat())
}
// EditRelease edit a release
// responses:
// "200":
// "$ref": "#/responses/Release"
+
id := ctx.ParamsInt64(":id")
rel, err := models.GetReleaseByID(id)
if err != nil && !models.IsErrReleaseNotExist(err) {
- ctx.Error(500, "GetReleaseByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetReleaseByID", err)
return
}
if err != nil && models.IsErrReleaseNotExist(err) ||
rel.IsPrerelease = *form.IsPrerelease
}
if err := releaseservice.UpdateRelease(ctx.User, ctx.Repo.GitRepo, rel, nil); err != nil {
- ctx.Error(500, "UpdateRelease", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateRelease", err)
return
}
rel, err = models.GetReleaseByID(id)
if err != nil {
- ctx.Error(500, "GetReleaseByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetReleaseByID", err)
return
}
if err := rel.LoadAttributes(); err != nil {
- ctx.Error(500, "LoadAttributes", err)
+ ctx.Error(http.StatusInternalServerError, "LoadAttributes", err)
return
}
- ctx.JSON(200, rel.APIFormat())
+ ctx.JSON(http.StatusOK, rel.APIFormat())
}
// DeleteRelease delete a release from a repository
// responses:
// "204":
// "$ref": "#/responses/empty"
+
id := ctx.ParamsInt64(":id")
rel, err := models.GetReleaseByID(id)
if err != nil && !models.IsErrReleaseNotExist(err) {
- ctx.Error(500, "GetReleaseByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetReleaseByID", err)
return
}
if err != nil && models.IsErrReleaseNotExist(err) ||
return
}
if err := releaseservice.DeleteReleaseByID(id, ctx.User, false); err != nil {
- ctx.Error(500, "DeleteReleaseByID", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteReleaseByID", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package repo
import (
+ "net/http"
"strings"
"code.gitea.io/gitea/models"
// responses:
// "200":
// "$ref": "#/responses/Attachment"
+
releaseID := ctx.ParamsInt64(":id")
attachID := ctx.ParamsInt64(":asset")
attach, err := models.GetAttachmentByID(attachID)
if err != nil {
- ctx.Error(500, "GetAttachmentByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetAttachmentByID", err)
return
}
if attach.ReleaseID != releaseID {
return
}
// FIXME Should prove the existence of the given repo, but results in unnecessary database requests
- ctx.JSON(200, attach.APIFormat())
+ ctx.JSON(http.StatusOK, attach.APIFormat())
}
// ListReleaseAttachments lists all attachments of the release
// responses:
// "200":
// "$ref": "#/responses/AttachmentList"
+
releaseID := ctx.ParamsInt64(":id")
release, err := models.GetReleaseByID(releaseID)
if err != nil {
- ctx.Error(500, "GetReleaseByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetReleaseByID", err)
return
}
if release.RepoID != ctx.Repo.Repository.ID {
return
}
if err := release.LoadAttributes(); err != nil {
- ctx.Error(500, "LoadAttributes", err)
+ ctx.Error(http.StatusInternalServerError, "LoadAttributes", err)
return
}
- ctx.JSON(200, release.APIFormat().Attachments)
+ ctx.JSON(http.StatusOK, release.APIFormat().Attachments)
}
// CreateReleaseAttachment creates an attachment and saves the given file
// responses:
// "201":
// "$ref": "#/responses/Attachment"
+ // "400":
+ // "$ref": "#/responses/error"
// Check if attachments are enabled
if !setting.AttachmentEnabled {
releaseID := ctx.ParamsInt64(":id")
release, err := models.GetReleaseByID(releaseID)
if err != nil {
- ctx.Error(500, "GetReleaseByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetReleaseByID", err)
return
}
// Get uploaded file from request
file, header, err := ctx.GetFile("attachment")
if err != nil {
- ctx.Error(500, "GetFile", err)
+ ctx.Error(http.StatusInternalServerError, "GetFile", err)
return
}
defer file.Close()
// Check if the filetype is allowed by the settings
err = upload.VerifyAllowedContentType(buf, strings.Split(setting.AttachmentAllowedTypes, ","))
if err != nil {
- ctx.Error(400, "DetectContentType", err)
+ ctx.Error(http.StatusBadRequest, "DetectContentType", err)
return
}
ReleaseID: release.ID,
}, buf, file)
if err != nil {
- ctx.Error(500, "NewAttachment", err)
+ ctx.Error(http.StatusInternalServerError, "NewAttachment", err)
return
}
- ctx.JSON(201, attach.APIFormat())
+ ctx.JSON(http.StatusCreated, attach.APIFormat())
}
// EditReleaseAttachment updates the given attachment
attachID := ctx.ParamsInt64(":asset")
attach, err := models.GetAttachmentByID(attachID)
if err != nil {
- ctx.Error(500, "GetAttachmentByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetAttachmentByID", err)
return
}
if attach.ReleaseID != releaseID {
}
if err := models.UpdateAttachment(attach); err != nil {
- ctx.Error(500, "UpdateAttachment", attach)
+ ctx.Error(http.StatusInternalServerError, "UpdateAttachment", attach)
}
- ctx.JSON(201, attach.APIFormat())
+ ctx.JSON(http.StatusCreated, attach.APIFormat())
}
// DeleteReleaseAttachment delete a given attachment
attachID := ctx.ParamsInt64(":asset")
attach, err := models.GetAttachmentByID(attachID)
if err != nil {
- ctx.Error(500, "GetAttachmentByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetAttachmentByID", err)
return
}
if attach.ReleaseID != releaseID {
// FIXME Should prove the existence of the given repo, but results in unnecessary database requests
if err := models.DeleteAttachment(attach, true); err != nil {
- ctx.Error(500, "DeleteAttachment", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteAttachment", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// "$ref": "#/responses/SearchResults"
// "422":
// "$ref": "#/responses/validationError"
+
opts := &models.SearchRepoOptions{
Keyword: strings.Trim(ctx.Query("q"), " "),
OwnerID: ctx.QueryInt64("uid"),
var err error
repos, count, err := models.SearchRepository(opts)
if err != nil {
- ctx.JSON(500, api.SearchError{
+ ctx.JSON(http.StatusInternalServerError, api.SearchError{
OK: false,
Error: err.Error(),
})
results := make([]*api.Repository, len(repos))
for i, repo := range repos {
if err = repo.GetOwner(); err != nil {
- ctx.JSON(500, api.SearchError{
+ ctx.JSON(http.StatusInternalServerError, api.SearchError{
OK: false,
Error: err.Error(),
})
}
accessMode, err := models.AccessLevel(ctx.User, repo)
if err != nil {
- ctx.JSON(500, api.SearchError{
+ ctx.JSON(http.StatusInternalServerError, api.SearchError{
OK: false,
Error: err.Error(),
})
ctx.SetLinkHeader(int(count), setting.API.MaxResponseItems)
ctx.Header().Set("X-Total-Count", fmt.Sprintf("%d", count))
- ctx.JSON(200, api.SearchResults{
+ ctx.JSON(http.StatusOK, api.SearchResults{
OK: true,
Data: results,
})
})
if err != nil {
if models.IsErrRepoAlreadyExist(err) {
- ctx.Error(409, "", "The repository with the same name already exists.")
+ ctx.Error(http.StatusConflict, "", "The repository with the same name already exists.")
} else if models.IsErrNameReserved(err) ||
models.IsErrNamePatternNotAllowed(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "CreateRepository", err)
+ ctx.Error(http.StatusInternalServerError, "CreateRepository", err)
}
return
}
- ctx.JSON(201, repo.APIFormat(models.AccessModeOwner))
+ ctx.JSON(http.StatusCreated, repo.APIFormat(models.AccessModeOwner))
}
// Create one repository of mine
// description: The repository with the same name already exists.
// "422":
// "$ref": "#/responses/validationError"
+
if ctx.User.IsOrganization() {
// Shouldn't reach this condition, but just in case.
- ctx.Error(422, "", "not allowed creating repository for organization")
+ ctx.Error(http.StatusUnprocessableEntity, "", "not allowed creating repository for organization")
return
}
CreateUserRepo(ctx, ctx.User, opt)
// "$ref": "#/responses/validationError"
// "403":
// "$ref": "#/responses/forbidden"
+
org, err := models.GetOrgByName(ctx.Params(":org"))
if err != nil {
if models.IsErrOrgNotExist(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "GetOrgByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetOrgByName", err)
}
return
}
ctx.ServerError("CanCreateOrgRepo", err)
return
} else if !canCreate {
- ctx.Error(403, "", "Given user is not allowed to create repository in organization.")
+ ctx.Error(http.StatusForbidden, "", "Given user is not allowed to create repository in organization.")
return
}
}
// responses:
// "201":
// "$ref": "#/responses/Repository"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
ctxUser := ctx.User
// Not equal means context user is an organization,
// or is another user/organization if current user is admin.
org, err := models.GetUserByID(form.UID)
if err != nil {
if models.IsErrUserNotExist(err) {
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(500, "GetUserByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByID", err)
}
return
}
}
if ctx.HasError() {
- ctx.Error(422, "", ctx.GetErrMsg())
+ ctx.Error(http.StatusUnprocessableEntity, "", ctx.GetErrMsg())
return
}
if !ctx.User.IsAdmin {
if !ctxUser.IsOrganization() && ctx.User.ID != ctxUser.ID {
- ctx.Error(403, "", "Given user is not an organization.")
+ ctx.Error(http.StatusForbidden, "", "Given user is not an organization.")
return
}
// Check ownership of organization.
isOwner, err := ctxUser.IsOwnedBy(ctx.User.ID)
if err != nil {
- ctx.Error(500, "IsOwnedBy", err)
+ ctx.Error(http.StatusInternalServerError, "IsOwnedBy", err)
return
} else if !isOwner {
- ctx.Error(403, "", "Given user is not owner of organization.")
+ ctx.Error(http.StatusForbidden, "", "Given user is not owner of organization.")
return
}
}
addrErr := err.(models.ErrInvalidCloneAddr)
switch {
case addrErr.IsURLError:
- ctx.Error(422, "", err)
+ ctx.Error(http.StatusUnprocessableEntity, "", err)
case addrErr.IsPermissionDenied:
- ctx.Error(422, "", "You are not allowed to import local repositories.")
+ ctx.Error(http.StatusUnprocessableEntity, "", "You are not allowed to import local repositories.")
case addrErr.IsInvalidPath:
- ctx.Error(422, "", "Invalid local path, it does not exist or not a directory.")
+ ctx.Error(http.StatusUnprocessableEntity, "", "Invalid local path, it does not exist or not a directory.")
default:
- ctx.Error(500, "ParseRemoteAddr", "Unknown error type (ErrInvalidCloneAddr): "+err.Error())
+ ctx.Error(http.StatusInternalServerError, "ParseRemoteAddr", "Unknown error type (ErrInvalidCloneAddr): "+err.Error())
}
} else {
- ctx.Error(500, "ParseRemoteAddr", err)
+ ctx.Error(http.StatusInternalServerError, "ParseRemoteAddr", err)
}
return
}
}
log.Trace("Repository migrated: %s/%s", ctxUser.Name, form.RepoName)
- ctx.JSON(201, repo.APIFormat(models.AccessModeAdmin))
+ ctx.JSON(http.StatusCreated, repo.APIFormat(models.AccessModeAdmin))
}
func handleMigrateError(ctx *context.APIContext, repoOwner *models.User, remoteAddr string, err error) {
switch {
case models.IsErrRepoAlreadyExist(err):
- ctx.Error(409, "", "The repository with the same name already exists.")
+ ctx.Error(http.StatusConflict, "", "The repository with the same name already exists.")
case migrations.IsRateLimitError(err):
- ctx.Error(422, "", "Remote visit addressed rate limitation.")
+ ctx.Error(http.StatusUnprocessableEntity, "", "Remote visit addressed rate limitation.")
case migrations.IsTwoFactorAuthError(err):
- ctx.Error(422, "", "Remote visit required two factors authentication.")
+ ctx.Error(http.StatusUnprocessableEntity, "", "Remote visit required two factors authentication.")
case models.IsErrReachLimitOfRepo(err):
- ctx.Error(422, "", fmt.Sprintf("You have already reached your limit of %d repositories.", repoOwner.MaxCreationLimit()))
+ ctx.Error(http.StatusUnprocessableEntity, "", fmt.Sprintf("You have already reached your limit of %d repositories.", repoOwner.MaxCreationLimit()))
case models.IsErrNameReserved(err):
- ctx.Error(422, "", fmt.Sprintf("The username '%s' is reserved.", err.(models.ErrNameReserved).Name))
+ ctx.Error(http.StatusUnprocessableEntity, "", fmt.Sprintf("The username '%s' is reserved.", err.(models.ErrNameReserved).Name))
case models.IsErrNamePatternNotAllowed(err):
- ctx.Error(422, "", fmt.Sprintf("The pattern '%s' is not allowed in a username.", err.(models.ErrNamePatternNotAllowed).Pattern))
+ ctx.Error(http.StatusUnprocessableEntity, "", fmt.Sprintf("The pattern '%s' is not allowed in a username.", err.(models.ErrNamePatternNotAllowed).Pattern))
default:
err = util.URLSanitizedError(err, remoteAddr)
if strings.Contains(err.Error(), "Authentication failed") ||
strings.Contains(err.Error(), "Bad credentials") ||
strings.Contains(err.Error(), "could not read Username") {
- ctx.Error(422, "", fmt.Sprintf("Authentication failed: %v.", err))
+ ctx.Error(http.StatusUnprocessableEntity, "", fmt.Sprintf("Authentication failed: %v.", err))
} else if strings.Contains(err.Error(), "fatal:") {
- ctx.Error(422, "", fmt.Sprintf("Migration failed: %v.", err))
+ ctx.Error(http.StatusUnprocessableEntity, "", fmt.Sprintf("Migration failed: %v.", err))
} else {
- ctx.Error(500, "MigrateRepository", err)
+ ctx.Error(http.StatusInternalServerError, "MigrateRepository", err)
}
}
}
// responses:
// "200":
// "$ref": "#/responses/Repository"
- ctx.JSON(200, ctx.Repo.Repository.APIFormat(ctx.Repo.AccessMode))
+
+ ctx.JSON(http.StatusOK, ctx.Repo.Repository.APIFormat(ctx.Repo.AccessMode))
}
// GetByID returns a single Repository
// responses:
// "200":
// "$ref": "#/responses/Repository"
+
repo, err := models.GetRepositoryByID(ctx.ParamsInt64(":id"))
if err != nil {
if models.IsErrRepoNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetRepositoryByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetRepositoryByID", err)
}
return
}
perm, err := models.GetUserRepoPermission(repo, ctx.User)
if err != nil {
- ctx.Error(500, "AccessLevel", err)
+ ctx.Error(http.StatusInternalServerError, "AccessLevel", err)
return
} else if !perm.HasAccess() {
ctx.NotFound()
return
}
- ctx.JSON(200, repo.APIFormat(perm.AccessMode))
+ ctx.JSON(http.StatusOK, repo.APIFormat(perm.AccessMode))
}
// Edit edit repository properties
// "$ref": "#/responses/forbidden"
// "422":
// "$ref": "#/responses/validationError"
+
if err := updateBasicProperties(ctx, opts); err != nil {
return
}
// "$ref": "#/responses/empty"
// "403":
// "$ref": "#/responses/forbidden"
+
owner := ctx.Repo.Owner
repo := ctx.Repo.Repository
canDelete, err := repo.CanUserDelete(ctx.User)
if err != nil {
- ctx.Error(500, "CanUserDelete", err)
+ ctx.Error(http.StatusInternalServerError, "CanUserDelete", err)
return
} else if !canDelete {
- ctx.Error(403, "", "Given user is not owner of organization.")
+ ctx.Error(http.StatusForbidden, "", "Given user is not owner of organization.")
return
}
if err := repo_service.DeleteRepository(ctx.User, repo); err != nil {
- ctx.Error(500, "DeleteRepository", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteRepository", err)
return
}
log.Trace("Repository deleted: %s/%s", owner.Name, repo.Name)
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// MirrorSync adds a mirrored repository to the sync queue
// responses:
// "200":
// "$ref": "#/responses/empty"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
repo := ctx.Repo.Repository
if !ctx.Repo.CanWrite(models.UnitTypeCode) {
- ctx.Error(403, "MirrorSync", "Must have write access")
+ ctx.Error(http.StatusForbidden, "MirrorSync", "Must have write access")
}
mirror_service.StartToMirror(repo.ID)
- ctx.Status(200)
+ ctx.Status(http.StatusOK)
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
api "code.gitea.io/gitea/modules/structs"
// responses:
// "200":
// "$ref": "#/responses/UserList"
+
stargazers, err := ctx.Repo.Repository.GetStargazers(-1)
if err != nil {
- ctx.Error(500, "GetStargazers", err)
+ ctx.Error(http.StatusInternalServerError, "GetStargazers", err)
return
}
users := make([]*api.User, len(stargazers))
for i, stargazer := range stargazers {
users[i] = convert.ToUser(stargazer, ctx.IsSigned, ctx.User != nil && ctx.User.IsAdmin)
}
- ctx.JSON(200, users)
+ ctx.JSON(http.StatusOK, users)
}
import (
"fmt"
+ "net/http"
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
// responses:
// "201":
// "$ref": "#/responses/Status"
+ // "400":
+ // "$ref": "#/responses/error"
+
sha := ctx.Params("sha")
if len(sha) == 0 {
- ctx.Error(400, "sha not given", nil)
+ ctx.Error(http.StatusBadRequest, "sha not given", nil)
return
}
status := &models.CommitStatus{
Context: form.Context,
}
if err := repofiles.CreateCommitStatus(ctx.Repo.Repository, ctx.User, sha, status); err != nil {
- ctx.Error(500, "CreateCommitStatus", err)
+ ctx.Error(http.StatusInternalServerError, "CreateCommitStatus", err)
return
}
- ctx.JSON(201, status.APIFormat())
+ ctx.JSON(http.StatusCreated, status.APIFormat())
}
// GetCommitStatuses returns all statuses for any given commit hash
// responses:
// "200":
// "$ref": "#/responses/StatusList"
+ // "400":
+ // "$ref": "#/responses/error"
+
getCommitStatuses(ctx, ctx.Params("sha"))
}
// responses:
// "200":
// "$ref": "#/responses/StatusList"
+ // "400":
+ // "$ref": "#/responses/error"
filter := ctx.Params("ref")
if len(filter) == 0 {
- ctx.Error(400, "ref not given", nil)
+ ctx.Error(http.StatusBadRequest, "ref not given", nil)
return
}
for _, reftype := range []string{"heads", "tags"} { //Search branches and tags
refSHA, lastMethodName, err := searchRefCommitByType(ctx, reftype, filter)
if err != nil {
- ctx.Error(500, lastMethodName, err)
+ ctx.Error(http.StatusInternalServerError, lastMethodName, err)
return
}
if refSHA != "" {
func getCommitStatuses(ctx *context.APIContext, sha string) {
if len(sha) == 0 {
- ctx.Error(400, "ref/sha not given", nil)
+ ctx.Error(http.StatusBadRequest, "ref/sha not given", nil)
return
}
repo := ctx.Repo.Repository
State: ctx.QueryTrim("state"),
})
if err != nil {
- ctx.Error(500, "GetCommitStatuses", fmt.Errorf("GetCommitStatuses[%s, %s, %d]: %v", repo.FullName(), sha, ctx.QueryInt("page"), err))
+ ctx.Error(http.StatusInternalServerError, "GetCommitStatuses", fmt.Errorf("GetCommitStatuses[%s, %s, %d]: %v", repo.FullName(), sha, ctx.QueryInt("page"), err))
return
}
apiStatuses = append(apiStatuses, status.APIFormat())
}
- ctx.JSON(200, apiStatuses)
+ ctx.JSON(http.StatusOK, apiStatuses)
}
type combinedCommitStatus struct {
// responses:
// "200":
// "$ref": "#/responses/Status"
+ // "400":
+ // "$ref": "#/responses/error"
+
sha := ctx.Params("ref")
if len(sha) == 0 {
- ctx.Error(400, "ref/sha not given", nil)
+ ctx.Error(http.StatusBadRequest, "ref/sha not given", nil)
return
}
repo := ctx.Repo.Repository
statuses, err := models.GetLatestCommitStatus(repo, sha, page)
if err != nil {
- ctx.Error(500, "GetLatestCommitStatus", fmt.Errorf("GetLatestCommitStatus[%s, %s, %d]: %v", repo.FullName(), sha, page, err))
+ ctx.Error(http.StatusInternalServerError, "GetLatestCommitStatus", fmt.Errorf("GetLatestCommitStatus[%s, %s, %d]: %v", repo.FullName(), sha, page, err))
return
}
if len(statuses) == 0 {
- ctx.Status(200)
+ ctx.Status(http.StatusOK)
return
}
}
}
- ctx.JSON(200, retStatus)
+ ctx.JSON(http.StatusOK, retStatus)
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
api "code.gitea.io/gitea/modules/structs"
// responses:
// "200":
// "$ref": "#/responses/UserList"
+
subscribers, err := ctx.Repo.Repository.GetWatchers(0)
if err != nil {
- ctx.Error(500, "GetWatchers", err)
+ ctx.Error(http.StatusInternalServerError, "GetWatchers", err)
return
}
users := make([]*api.User, len(subscribers))
for i, subscriber := range subscribers {
users[i] = convert.ToUser(subscriber, ctx.IsSigned, ctx.User != nil && ctx.User.IsAdmin)
}
- ctx.JSON(200, users)
+ ctx.JSON(http.StatusOK, users)
}
// responses:
// "200":
// "$ref": "#/responses/TagList"
+
tags, err := ctx.Repo.GitRepo.GetTagInfos()
if err != nil {
- ctx.Error(500, "GetTags", err)
+ ctx.Error(http.StatusInternalServerError, "GetTags", err)
return
}
apiTags[i] = convert.ToTag(ctx.Repo.Repository, tags[i])
}
- ctx.JSON(200, &apiTags)
+ ctx.JSON(http.StatusOK, &apiTags)
}
// GetTag get the tag of a repository.
// responses:
// "200":
// "$ref": "#/responses/AnnotatedTag"
+ // "400":
+ // "$ref": "#/responses/error"
sha := ctx.Params("sha")
if len(sha) == 0 {
})
if err != nil {
log.Error("ListTopics failed: %v", err)
- ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
- "message": "ListTopics failed.",
- })
+ ctx.InternalServerError(err)
return
}
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "422":
+ // "$ref": "#/responses/invalidTopicsError"
topicNames := form.Topics
validTopics, invalidTopics := models.SanitizeAndValidateTopics(topicNames)
err := models.SaveTopics(ctx.Repo.Repository.ID, validTopics...)
if err != nil {
log.Error("SaveTopics failed: %v", err)
- ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
- "message": "Save topics failed.",
- })
+ ctx.InternalServerError(err)
return
}
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "422":
+ // "$ref": "#/responses/invalidTopicsError"
topicName := strings.TrimSpace(strings.ToLower(ctx.Params(":topic")))
if !models.ValidateTopic(topicName) {
- ctx.Error(http.StatusUnprocessableEntity, "", "Topic name is invalid")
+ ctx.JSON(http.StatusUnprocessableEntity, map[string]interface{}{
+ "invalidTopics": topicName,
+ "message": "Topic name is invalid",
+ })
return
}
})
if err != nil {
log.Error("AddTopic failed: %v", err)
- ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
- "message": "ListTopics failed.",
- })
+ ctx.InternalServerError(err)
return
}
if len(topics) >= 25 {
_, err = models.AddTopic(ctx.Repo.Repository.ID, topicName)
if err != nil {
log.Error("AddTopic failed: %v", err)
- ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
- "message": "AddTopic failed.",
- })
+ ctx.InternalServerError(err)
return
}
// responses:
// "204":
// "$ref": "#/responses/empty"
+ // "422":
+ // "$ref": "#/responses/invalidTopicsError"
+
topicName := strings.TrimSpace(strings.ToLower(ctx.Params(":topic")))
if !models.ValidateTopic(topicName) {
- ctx.Error(http.StatusUnprocessableEntity, "", "Topic name is invalid")
+ ctx.JSON(http.StatusUnprocessableEntity, map[string]interface{}{
+ "invalidTopics": topicName,
+ "message": "Topic name is invalid",
+ })
return
}
topic, err := models.DeleteTopic(ctx.Repo.Repository.ID, topicName)
if err != nil {
log.Error("DeleteTopic failed: %v", err)
- ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
- "message": "DeleteTopic failed.",
- })
+ ctx.InternalServerError(err)
return
}
// responses:
// "200":
// "$ref": "#/responses/TopicListResponse"
+ // "403":
+ // "$ref": "#/responses/forbidden"
+
if ctx.User == nil {
- ctx.JSON(http.StatusForbidden, map[string]interface{}{
- "message": "Only owners could change the topics.",
- })
+ ctx.Error(http.StatusForbidden, "UserIsNil", "Only owners could change the topics.")
return
}
})
if err != nil {
log.Error("SearchTopics failed: %v", err)
- ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
- "message": "Search topics failed.",
- })
+ ctx.InternalServerError(err)
return
}
package repo
import (
+ "net/http"
+
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/repofiles"
)
// responses:
// "200":
// "$ref": "#/responses/GitTreeResponse"
+ // "400":
+ // "$ref": "#/responses/error"
sha := ctx.Params(":sha")
if len(sha) == 0 {
- ctx.Error(400, "", "sha not provided")
+ ctx.Error(http.StatusBadRequest, "", "sha not provided")
return
}
if tree, err := repofiles.GetTreeBySHA(ctx.Repo.Repository, sha, ctx.QueryInt("page"), ctx.QueryInt("per_page"), ctx.QueryBool("recursive")); err != nil {
- ctx.Error(400, "", err.Error())
+ ctx.Error(http.StatusBadRequest, "", err.Error())
} else {
- ctx.JSON(200, tree)
+ ctx.JSON(http.StatusOK, tree)
}
}
package user
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
api "code.gitea.io/gitea/modules/structs"
// responses:
// "200":
// "$ref": "#/responses/AccessTokenList"
+
tokens, err := models.ListAccessTokens(ctx.User.ID)
if err != nil {
- ctx.Error(500, "ListAccessTokens", err)
+ ctx.Error(http.StatusInternalServerError, "ListAccessTokens", err)
return
}
TokenLastEight: tokens[i].TokenLastEight,
}
}
- ctx.JSON(200, &apiTokens)
+ ctx.JSON(http.StatusOK, &apiTokens)
}
// CreateAccessToken create access tokens
// responses:
// "200":
// "$ref": "#/responses/AccessToken"
+
t := &models.AccessToken{
UID: ctx.User.ID,
Name: form.Name,
}
if err := models.NewAccessToken(t); err != nil {
- ctx.Error(500, "NewAccessToken", err)
+ ctx.Error(http.StatusInternalServerError, "NewAccessToken", err)
return
}
- ctx.JSON(201, &api.AccessToken{
+ ctx.JSON(http.StatusCreated, &api.AccessToken{
Name: t.Name,
Token: t.Token,
ID: t.ID,
// responses:
// "204":
// "$ref": "#/responses/empty"
+
tokenID := ctx.ParamsInt64(":id")
if err := models.DeleteAccessTokenByID(tokenID, ctx.User.ID); err != nil {
if models.IsErrAccessTokenNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "DeleteAccessTokenByID", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteAccessTokenByID", err)
}
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package user
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
// responses:
// "200":
// "$ref": "#/responses/EmailList"
+
emails, err := models.GetEmailAddresses(ctx.User.ID)
if err != nil {
- ctx.Error(500, "GetEmailAddresses", err)
+ ctx.Error(http.StatusInternalServerError, "GetEmailAddresses", err)
return
}
apiEmails := make([]*api.Email, len(emails))
for i := range emails {
apiEmails[i] = convert.ToEmail(emails[i])
}
- ctx.JSON(200, &apiEmails)
+ ctx.JSON(http.StatusOK, &apiEmails)
}
// AddEmail add an email address
// responses:
// '201':
// "$ref": "#/responses/EmailList"
+ // "422":
+ // "$ref": "#/responses/validationError"
+
if len(form.Emails) == 0 {
- ctx.Status(422)
+ ctx.Error(http.StatusUnprocessableEntity, "", "Email list empty")
return
}
if err := models.AddEmailAddresses(emails); err != nil {
if models.IsErrEmailAlreadyUsed(err) {
- ctx.Error(422, "", "Email address has been used: "+err.(models.ErrEmailAlreadyUsed).Email)
+ ctx.Error(http.StatusUnprocessableEntity, "", "Email address has been used: "+err.(models.ErrEmailAlreadyUsed).Email)
} else {
- ctx.Error(500, "AddEmailAddresses", err)
+ ctx.Error(http.StatusInternalServerError, "AddEmailAddresses", err)
}
return
}
for i := range emails {
apiEmails[i] = convert.ToEmail(emails[i])
}
- ctx.JSON(201, &apiEmails)
+ ctx.JSON(http.StatusCreated, &apiEmails)
}
// DeleteEmail delete email
// responses:
// "204":
// "$ref": "#/responses/empty"
+
if len(form.Emails) == 0 {
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
return
}
}
if err := models.DeleteEmailAddresses(emails); err != nil {
- ctx.Error(500, "DeleteEmailAddresses", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteEmailAddresses", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package user
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
for i := range users {
apiUsers[i] = convert.ToUser(users[i], ctx.IsSigned, ctx.User != nil && ctx.User.IsAdmin)
}
- ctx.JSON(200, &apiUsers)
+ ctx.JSON(http.StatusOK, &apiUsers)
}
func listUserFollowers(ctx *context.APIContext, u *models.User) {
users, err := u.GetFollowers(ctx.QueryInt("page"))
if err != nil {
- ctx.Error(500, "GetUserFollowers", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserFollowers", err)
return
}
responseAPIUsers(ctx, users)
// responses:
// "200":
// "$ref": "#/responses/UserList"
+
listUserFollowers(ctx, ctx.User)
}
// responses:
// "200":
// "$ref": "#/responses/UserList"
+
u := GetUserByParams(ctx)
if ctx.Written() {
return
func listUserFollowing(ctx *context.APIContext, u *models.User) {
users, err := u.GetFollowing(ctx.QueryInt("page"))
if err != nil {
- ctx.Error(500, "GetFollowing", err)
+ ctx.Error(http.StatusInternalServerError, "GetFollowing", err)
return
}
responseAPIUsers(ctx, users)
// responses:
// "200":
// "$ref": "#/responses/UserList"
+
listUserFollowing(ctx, ctx.User)
}
// responses:
// "200":
// "$ref": "#/responses/UserList"
+
u := GetUserByParams(ctx)
if ctx.Written() {
return
func checkUserFollowing(ctx *context.APIContext, u *models.User, followID int64) {
if u.IsFollowing(followID) {
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
} else {
ctx.NotFound()
}
// "$ref": "#/responses/empty"
// "404":
// "$ref": "#/responses/notFound"
+
target := GetUserByParams(ctx)
if ctx.Written() {
return
// "$ref": "#/responses/empty"
// "404":
// "$ref": "#/responses/notFound"
+
u := GetUserByParams(ctx)
if ctx.Written() {
return
// responses:
// "204":
// "$ref": "#/responses/empty"
+
target := GetUserByParams(ctx)
if ctx.Written() {
return
}
if err := models.FollowUser(ctx.User.ID, target.ID); err != nil {
- ctx.Error(500, "FollowUser", err)
+ ctx.Error(http.StatusInternalServerError, "FollowUser", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// Unfollow unfollow a user
// responses:
// "204":
// "$ref": "#/responses/empty"
+
target := GetUserByParams(ctx)
if ctx.Written() {
return
}
if err := models.UnfollowUser(ctx.User.ID, target.ID); err != nil {
- ctx.Error(500, "UnfollowUser", err)
+ ctx.Error(http.StatusInternalServerError, "UnfollowUser", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package user
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
func listGPGKeys(ctx *context.APIContext, uid int64) {
keys, err := models.ListGPGKeys(uid)
if err != nil {
- ctx.Error(500, "ListGPGKeys", err)
+ ctx.Error(http.StatusInternalServerError, "ListGPGKeys", err)
return
}
apiKeys[i] = convert.ToGPGKey(keys[i])
}
- ctx.JSON(200, &apiKeys)
+ ctx.JSON(http.StatusOK, &apiKeys)
}
//ListGPGKeys get the GPG key list of a user
// responses:
// "200":
// "$ref": "#/responses/GPGKeyList"
+
user := GetUserByParams(ctx)
if ctx.Written() {
return
// responses:
// "200":
// "$ref": "#/responses/GPGKeyList"
+
listGPGKeys(ctx, ctx.User.ID)
}
// "$ref": "#/responses/GPGKey"
// "404":
// "$ref": "#/responses/notFound"
+
key, err := models.GetGPGKeyByID(ctx.ParamsInt64(":id"))
if err != nil {
if models.IsErrGPGKeyNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetGPGKeyByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetGPGKeyByID", err)
}
return
}
- ctx.JSON(200, convert.ToGPGKey(key))
+ ctx.JSON(http.StatusOK, convert.ToGPGKey(key))
}
// CreateUserGPGKey creates new GPG key to given user by ID.
HandleAddGPGKeyError(ctx, err)
return
}
- ctx.JSON(201, convert.ToGPGKey(key))
+ ctx.JSON(http.StatusCreated, convert.ToGPGKey(key))
}
// swagger:parameters userCurrentPostGPGKey
// "$ref": "#/responses/GPGKey"
// "422":
// "$ref": "#/responses/validationError"
+
CreateUserGPGKey(ctx, form, ctx.User.ID)
}
// "$ref": "#/responses/empty"
// "403":
// "$ref": "#/responses/forbidden"
+
if err := models.DeleteGPGKey(ctx.User, ctx.ParamsInt64(":id")); err != nil {
if models.IsErrGPGKeyAccessDenied(err) {
- ctx.Error(403, "", "You do not have access to this key")
+ ctx.Error(http.StatusForbidden, "", "You do not have access to this key")
} else {
- ctx.Error(500, "DeleteGPGKey", err)
+ ctx.Error(http.StatusInternalServerError, "DeleteGPGKey", err)
}
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// HandleAddGPGKeyError handle add GPGKey error
func HandleAddGPGKeyError(ctx *context.APIContext, err error) {
switch {
case models.IsErrGPGKeyAccessDenied(err):
- ctx.Error(422, "", "You do not have access to this GPG key")
+ ctx.Error(http.StatusUnprocessableEntity, "", "You do not have access to this GPG key")
case models.IsErrGPGKeyIDAlreadyUsed(err):
- ctx.Error(422, "", "A key with the same id already exists")
+ ctx.Error(http.StatusUnprocessableEntity, "", "A key with the same id already exists")
default:
- ctx.Error(500, "AddGPGKey", err)
+ ctx.Error(http.StatusInternalServerError, "AddGPGKey", err)
}
}
package user
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
if models.IsErrUserNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetUserByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByName", err)
}
return nil
}
}
if err != nil {
- ctx.Error(500, "ListPublicKeys", err)
+ ctx.Error(http.StatusInternalServerError, "ListPublicKeys", err)
return
}
}
}
- ctx.JSON(200, &apiKeys)
+ ctx.JSON(http.StatusOK, &apiKeys)
}
// ListMyPublicKeys list all of the authenticated user's public keys
// responses:
// "200":
// "$ref": "#/responses/PublicKeyList"
+
listPublicKeys(ctx, ctx.User)
}
// responses:
// "200":
// "$ref": "#/responses/PublicKeyList"
+
user := GetUserByParams(ctx)
if ctx.Written() {
return
// "$ref": "#/responses/PublicKey"
// "404":
// "$ref": "#/responses/notFound"
+
key, err := models.GetPublicKeyByID(ctx.ParamsInt64(":id"))
if err != nil {
if models.IsErrKeyNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetPublicKeyByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetPublicKeyByID", err)
}
return
}
if ctx.User.IsAdmin || ctx.User.ID == key.OwnerID {
apiKey, _ = appendPrivateInformation(apiKey, key, ctx.User)
}
- ctx.JSON(200, apiKey)
+ ctx.JSON(http.StatusOK, apiKey)
}
// CreateUserPublicKey creates new public key to given user by ID.
if ctx.User.IsAdmin || ctx.User.ID == key.OwnerID {
apiKey, _ = appendPrivateInformation(apiKey, key, ctx.User)
}
- ctx.JSON(201, apiKey)
+ ctx.JSON(http.StatusCreated, apiKey)
}
// CreatePublicKey create one public key for me
// "$ref": "#/responses/PublicKey"
// "422":
// "$ref": "#/responses/validationError"
+
CreateUserPublicKey(ctx, form, ctx.User.ID)
}
// "$ref": "#/responses/forbidden"
// "404":
// "$ref": "#/responses/notFound"
+
if err := models.DeletePublicKey(ctx.User, ctx.ParamsInt64(":id")); err != nil {
if models.IsErrKeyNotExist(err) {
ctx.NotFound()
} else if models.IsErrKeyAccessDenied(err) {
- ctx.Error(403, "", "You do not have access to this key")
+ ctx.Error(http.StatusForbidden, "", "You do not have access to this key")
} else {
- ctx.Error(500, "DeletePublicKey", err)
+ ctx.Error(http.StatusInternalServerError, "DeletePublicKey", err)
}
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
package user
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
api "code.gitea.io/gitea/modules/structs"
func listUserRepos(ctx *context.APIContext, u *models.User, private bool) {
repos, err := models.GetUserRepositories(u.ID, private, 1, u.NumRepos, "")
if err != nil {
- ctx.Error(500, "GetUserRepositories", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserRepositories", err)
return
}
for i := range repos {
access, err := models.AccessLevel(ctx.User, repos[i])
if err != nil {
- ctx.Error(500, "AccessLevel", err)
+ ctx.Error(http.StatusInternalServerError, "AccessLevel", err)
return
}
if ctx.IsSigned && ctx.User.IsAdmin || access >= models.AccessModeRead {
apiRepos = append(apiRepos, repos[i].APIFormat(access))
}
}
- ctx.JSON(200, &apiRepos)
+ ctx.JSON(http.StatusOK, &apiRepos)
}
// ListUserRepos - list the repos owned by the given user.
// responses:
// "200":
// "$ref": "#/responses/RepositoryList"
+
user := GetUserByParams(ctx)
if ctx.Written() {
return
// responses:
// "200":
// "$ref": "#/responses/RepositoryList"
+
ownRepos, err := models.GetUserRepositories(ctx.User.ID, true, 1, ctx.User.NumRepos, "")
if err != nil {
- ctx.Error(500, "GetUserRepositories", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserRepositories", err)
return
}
accessibleReposMap, err := ctx.User.GetRepositoryAccesses()
if err != nil {
- ctx.Error(500, "GetRepositoryAccesses", err)
+ ctx.Error(http.StatusInternalServerError, "GetRepositoryAccesses", err)
return
}
apiRepos[i] = repo.APIFormat(access)
i++
}
- ctx.JSON(200, &apiRepos)
+ ctx.JSON(http.StatusOK, &apiRepos)
}
// ListOrgRepos - list the repositories of an organization.
// responses:
// "200":
// "$ref": "#/responses/RepositoryList"
+
listUserRepos(ctx, ctx.Org.Organization, ctx.IsSigned)
}
package user
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
api "code.gitea.io/gitea/modules/structs"
// responses:
// "200":
// "$ref": "#/responses/RepositoryList"
+
user := GetUserByParams(ctx)
private := user.ID == ctx.User.ID
repos, err := getStarredRepos(user, private)
if err != nil {
- ctx.Error(500, "getStarredRepos", err)
+ ctx.Error(http.StatusInternalServerError, "getStarredRepos", err)
}
- ctx.JSON(200, &repos)
+ ctx.JSON(http.StatusOK, &repos)
}
// GetMyStarredRepos returns the repos that the authenticated user has starred
// responses:
// "200":
// "$ref": "#/responses/RepositoryList"
+
repos, err := getStarredRepos(ctx.User, true)
if err != nil {
- ctx.Error(500, "getStarredRepos", err)
+ ctx.Error(http.StatusInternalServerError, "getStarredRepos", err)
}
- ctx.JSON(200, &repos)
+ ctx.JSON(http.StatusOK, &repos)
}
// IsStarring returns whether the authenticated is starring the repo
// "$ref": "#/responses/empty"
// "404":
// "$ref": "#/responses/notFound"
+
if models.IsStaring(ctx.User.ID, ctx.Repo.Repository.ID) {
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
} else {
ctx.NotFound()
}
// responses:
// "204":
// "$ref": "#/responses/empty"
+
err := models.StarRepo(ctx.User.ID, ctx.Repo.Repository.ID, true)
if err != nil {
- ctx.Error(500, "StarRepo", err)
+ ctx.Error(http.StatusInternalServerError, "StarRepo", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// Unstar the repo specified in the APIContext, as the authenticated user
// responses:
// "204":
// "$ref": "#/responses/empty"
+
err := models.StarRepo(ctx.User.ID, ctx.Repo.Repository.ID, false)
if err != nil {
- ctx.Error(500, "StarRepo", err)
+ ctx.Error(http.StatusInternalServerError, "StarRepo", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// type: array
// items:
// "$ref": "#/definitions/User"
+
opts := &models.SearchUserOptions{
Keyword: strings.Trim(ctx.Query("q"), " "),
UID: com.StrTo(ctx.Query("uid")).MustInt64(),
users, _, err := models.SearchUsers(opts)
if err != nil {
- ctx.JSON(500, map[string]interface{}{
+ ctx.JSON(http.StatusInternalServerError, map[string]interface{}{
"ok": false,
"error": err.Error(),
})
results[i] = convert.ToUser(users[i], ctx.IsSigned, ctx.User != nil && ctx.User.IsAdmin)
}
- ctx.JSON(200, map[string]interface{}{
+ ctx.JSON(http.StatusOK, map[string]interface{}{
"ok": true,
"data": results,
})
// "$ref": "#/responses/User"
// "404":
// "$ref": "#/responses/notFound"
+
u, err := models.GetUserByName(ctx.Params(":username"))
if err != nil {
if models.IsErrUserNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetUserByName", err)
+ ctx.Error(http.StatusInternalServerError, "GetUserByName", err)
}
return
}
- ctx.JSON(200, convert.ToUser(u, ctx.IsSigned, ctx.User != nil && (ctx.User.ID == u.ID || ctx.User.IsAdmin)))
+ ctx.JSON(http.StatusOK, convert.ToUser(u, ctx.IsSigned, ctx.User != nil && (ctx.User.ID == u.ID || ctx.User.IsAdmin)))
}
// GetAuthenticatedUser get current user's information
// responses:
// "200":
// "$ref": "#/responses/User"
- ctx.JSON(200, convert.ToUser(ctx.User, ctx.IsSigned, ctx.User != nil))
+
+ ctx.JSON(http.StatusOK, convert.ToUser(ctx.User, ctx.IsSigned, ctx.User != nil))
}
// GetUserHeatmapData is the handler to get a users heatmap
ctx.Error(http.StatusInternalServerError, "GetUserHeatmapDataByUser", err)
return
}
- ctx.JSON(200, heatmap)
+ ctx.JSON(http.StatusOK, heatmap)
}
package user
import (
+ "net/http"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
// responses:
// "200":
// "$ref": "#/responses/RepositoryList"
+
user := GetUserByParams(ctx)
private := user.ID == ctx.User.ID
repos, err := getWatchedRepos(user, private)
if err != nil {
- ctx.Error(500, "getWatchedRepos", err)
+ ctx.Error(http.StatusInternalServerError, "getWatchedRepos", err)
}
- ctx.JSON(200, &repos)
+ ctx.JSON(http.StatusOK, &repos)
}
// GetMyWatchedRepos returns the repos that the authenticated user is watching
// responses:
// "200":
// "$ref": "#/responses/RepositoryList"
+
repos, err := getWatchedRepos(ctx.User, true)
if err != nil {
- ctx.Error(500, "getWatchedRepos", err)
+ ctx.Error(http.StatusInternalServerError, "getWatchedRepos", err)
}
- ctx.JSON(200, &repos)
+ ctx.JSON(http.StatusOK, &repos)
}
// IsWatching returns whether the authenticated user is watching the repo
// responses:
// "200":
// "$ref": "#/responses/WatchInfo"
+
if models.IsWatching(ctx.User.ID, ctx.Repo.Repository.ID) {
- ctx.JSON(200, api.WatchInfo{
+ ctx.JSON(http.StatusOK, api.WatchInfo{
Subscribed: true,
Ignored: false,
Reason: nil,
// responses:
// "200":
// "$ref": "#/responses/WatchInfo"
+
err := models.WatchRepo(ctx.User.ID, ctx.Repo.Repository.ID, true)
if err != nil {
- ctx.Error(500, "WatchRepo", err)
+ ctx.Error(http.StatusInternalServerError, "WatchRepo", err)
return
}
- ctx.JSON(200, api.WatchInfo{
+ ctx.JSON(http.StatusOK, api.WatchInfo{
Subscribed: true,
Ignored: false,
Reason: nil,
// responses:
// "204":
// "$ref": "#/responses/empty"
+
err := models.WatchRepo(ctx.User.ID, ctx.Repo.Repository.ID, false)
if err != nil {
- ctx.Error(500, "UnwatchRepo", err)
+ ctx.Error(http.StatusInternalServerError, "UnwatchRepo", err)
return
}
- ctx.Status(204)
+ ctx.Status(http.StatusNoContent)
}
// subscriptionURL returns the URL of the subscription API endpoint of a repo
if models.IsErrWebhookNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetWebhookByOrgID", err)
+ ctx.Error(http.StatusInternalServerError, "GetWebhookByOrgID", err)
}
return nil, err
}
if models.IsErrWebhookNotExist(err) {
ctx.NotFound()
} else {
- ctx.Error(500, "GetWebhookByID", err)
+ ctx.Error(http.StatusInternalServerError, "GetWebhookByID", err)
}
return nil, err
}
// write the appropriate error to `ctx`. Return whether the form is valid
func CheckCreateHookOption(ctx *context.APIContext, form *api.CreateHookOption) bool {
if !models.IsValidHookTaskType(form.Type) {
- ctx.Error(422, "", "Invalid hook type")
+ ctx.Error(http.StatusUnprocessableEntity, "", "Invalid hook type")
return false
}
for _, name := range []string{"url", "content_type"} {
if _, ok := form.Config[name]; !ok {
- ctx.Error(422, "", "Missing config option: "+name)
+ ctx.Error(http.StatusUnprocessableEntity, "", "Missing config option: "+name)
return false
}
}
if !models.IsValidHookContentType(form.Config["content_type"]) {
- ctx.Error(422, "", "Invalid content type")
+ ctx.Error(http.StatusUnprocessableEntity, "", "Invalid content type")
return false
}
return true
if w.HookTaskType == models.SLACK {
channel, ok := form.Config["channel"]
if !ok {
- ctx.Error(422, "", "Missing config option: channel")
+ ctx.Error(http.StatusUnprocessableEntity, "", "Missing config option: channel")
return nil, false
}
if !utils.IsValidSlackChannel(channel) {
- ctx.Error(400, "", "Invalid slack channel name")
+ ctx.Error(http.StatusBadRequest, "", "Invalid slack channel name")
return nil, false
}
Color: form.Config["color"],
})
if err != nil {
- ctx.Error(500, "slack: JSON marshal failed", err)
+ ctx.Error(http.StatusInternalServerError, "slack: JSON marshal failed", err)
return nil, false
}
w.Meta = string(meta)
}
if err := w.UpdateEvent(); err != nil {
- ctx.Error(500, "UpdateEvent", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateEvent", err)
return nil, false
} else if err := models.CreateWebhook(w); err != nil {
- ctx.Error(500, "CreateWebhook", err)
+ ctx.Error(http.StatusInternalServerError, "CreateWebhook", err)
return nil, false
}
return w, true
if err != nil {
return
}
- ctx.JSON(200, convert.ToHook(org.HomeLink(), updated))
+ ctx.JSON(http.StatusOK, convert.ToHook(org.HomeLink(), updated))
}
// EditRepoHook edit webhook `w` according to `form`. Writes to `ctx` accordingly
if err != nil {
return
}
- ctx.JSON(200, convert.ToHook(repo.RepoLink, updated))
+ ctx.JSON(http.StatusOK, convert.ToHook(repo.RepoLink, updated))
}
// editHook edit the webhook `w` according to `form`. If an error occurs, write
}
if ct, ok := form.Config["content_type"]; ok {
if !models.IsValidHookContentType(ct) {
- ctx.Error(422, "", "Invalid content type")
+ ctx.Error(http.StatusUnprocessableEntity, "", "Invalid content type")
return false
}
w.ContentType = models.ToHookContentType(ct)
Color: form.Config["color"],
})
if err != nil {
- ctx.Error(500, "slack: JSON marshal failed", err)
+ ctx.Error(http.StatusInternalServerError, "slack: JSON marshal failed", err)
return false
}
w.Meta = string(meta)
w.BranchFilter = form.BranchFilter
if err := w.UpdateEvent(); err != nil {
- ctx.Error(500, "UpdateEvent", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateEvent", err)
return false
}
}
if err := models.UpdateWebhook(w); err != nil {
- ctx.Error(500, "UpdateWebhook", err)
+ ctx.Error(http.StatusInternalServerError, "UpdateWebhook", err)
return false
}
return true
"201": {
"$ref": "#/responses/User"
},
+ "400": {
+ "$ref": "#/responses/error"
+ },
"403": {
"$ref": "#/responses/forbidden"
},
"403": {
"$ref": "#/responses/forbidden"
},
+ "404": {
+ "$ref": "#/responses/notFound"
+ },
+ "409": {
+ "$ref": "#/responses/error"
+ },
"422": {
"$ref": "#/responses/validationError"
}
"204": {
"description": "user is a member"
},
+ "302": {
+ "description": "redirection to /orgs/{org}/public_members/{username}"
+ },
"404": {
"description": "user is not a member"
}
"responses": {
"204": {
"description": "membership publicized"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
},
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
}
"responses": {
"201": {
"$ref": "#/responses/Team"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
}
"responses": {
"201": {
"$ref": "#/responses/Repository"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
}
"responses": {
"200": {
"description": "success"
+ },
+ "404": {
+ "$ref": "#/responses/notFound"
}
}
}
"$ref": "#/responses/empty"
},
"404": {
- "$ref": "#/responses/empty"
+ "$ref": "#/responses/notFound"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
},
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
},
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/Status"
+ },
+ "400": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"200": {
"description": "success"
+ },
+ "404": {
+ "$ref": "#/responses/notFound"
}
}
}
"responses": {
"202": {
"$ref": "#/responses/Repository"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/GitBlobResponse"
+ },
+ "400": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/AnnotatedTag"
+ },
+ "400": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/GitTreeResponse"
+ },
+ "400": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/Hook"
+ },
+ "404": {
+ "$ref": "#/responses/notFound"
}
}
},
"responses": {
"201": {
"$ref": "#/responses/Issue"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
+ },
+ "412": {
+ "$ref": "#/responses/error"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
}
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
},
"responses": {
"200": {
"$ref": "#/responses/ReactionResponseList"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
},
"responses": {
"201": {
"$ref": "#/responses/ReactionResponse"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
},
"responses": {
"200": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/TrackedTimeList"
+ },
+ "404": {
+ "$ref": "#/responses/notFound"
}
}
},
"$ref": "#/responses/error"
},
"403": {
- "$ref": "#/responses/error"
+ "$ref": "#/responses/forbidden"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/Issue"
+ },
+ "404": {
+ "$ref": "#/responses/notFound"
}
}
},
"responses": {
"201": {
"$ref": "#/responses/Issue"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
+ },
+ "404": {
+ "$ref": "#/responses/notFound"
+ },
+ "412": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"201": {
"$ref": "#/responses/Comment"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
}
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
},
"responses": {
"200": {
"$ref": "#/responses/Comment"
+ },
+ "204": {
+ "$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
}
"$ref": "#/responses/IssueDeadline"
},
"403": {
- "description": "Not repo writer"
+ "$ref": "#/responses/forbidden"
},
"404": {
- "description": "Issue not found"
+ "$ref": "#/responses/notFound"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/LabelList"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
},
"responses": {
"200": {
"$ref": "#/responses/LabelList"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
},
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
}
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/ReactionResponseList"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
},
"responses": {
"201": {
"$ref": "#/responses/ReactionResponse"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
},
"responses": {
"200": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
}
"description": "Not repo writer, user does not have rights to toggle stopwatch"
},
"404": {
- "description": "Issue not found"
+ "$ref": "#/responses/notFound"
},
"409": {
"description": "Cannot cancel a non existent stopwatch"
"description": "Not repo writer, user does not have rights to toggle stopwatch"
},
"404": {
- "description": "Issue not found"
+ "$ref": "#/responses/notFound"
},
"409": {
"description": "Cannot start a stopwatch again if it already exists"
"description": "Not repo writer, user does not have rights to toggle stopwatch"
},
"404": {
- "description": "Issue not found"
+ "$ref": "#/responses/notFound"
},
"409": {
"description": "Cannot stop a non existent stopwatch"
"$ref": "#/responses/UserList"
},
"404": {
- "description": "Issue not found"
+ "$ref": "#/responses/notFound"
}
}
}
"description": "User can only subscribe itself if he is no admin"
},
"404": {
- "description": "Issue not found"
+ "$ref": "#/responses/notFound"
}
}
},
"description": "User can only subscribe itself if he is no admin"
},
"404": {
- "description": "Issue not found"
+ "$ref": "#/responses/notFound"
}
}
}
"responses": {
"201": {
"$ref": "#/responses/DeployKey"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
}
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
}
"responses": {
"201": {
"$ref": "#/responses/PullRequest"
+ },
+ "409": {
+ "$ref": "#/responses/error"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
}
"responses": {
"201": {
"$ref": "#/responses/PullRequest"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
+ },
+ "412": {
+ "$ref": "#/responses/error"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
}
},
"405": {
"$ref": "#/responses/empty"
+ },
+ "409": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"200": {
"description": "success"
+ },
+ "404": {
+ "$ref": "#/responses/notFound"
}
}
}
"responses": {
"201": {
"$ref": "#/responses/Release"
+ },
+ "409": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"201": {
"$ref": "#/responses/Attachment"
+ },
+ "400": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/StatusList"
+ },
+ "400": {
+ "$ref": "#/responses/error"
}
}
},
"responses": {
"201": {
"$ref": "#/responses/Status"
+ },
+ "400": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/TrackedTimeList"
+ },
+ "400": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/TrackedTimeList"
+ },
+ "400": {
+ "$ref": "#/responses/error"
}
}
}
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "422": {
+ "$ref": "#/responses/invalidTopicsError"
}
}
}
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "422": {
+ "$ref": "#/responses/invalidTopicsError"
}
}
},
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "422": {
+ "$ref": "#/responses/invalidTopicsError"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/User"
+ },
+ "404": {
+ "$ref": "#/responses/notFound"
}
}
},
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "404": {
+ "$ref": "#/responses/notFound"
}
}
},
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "404": {
+ "$ref": "#/responses/notFound"
}
}
}
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
},
"responses": {
"204": {
"$ref": "#/responses/empty"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
}
"responses": {
"200": {
"$ref": "#/responses/TopicListResponse"
+ },
+ "403": {
+ "$ref": "#/responses/forbidden"
}
}
}
"responses": {
"201": {
"$ref": "#/responses/EmailList"
+ },
+ "422": {
+ "$ref": "#/responses/validationError"
}
}
},
}
}
},
+ "invalidTopicsError": {
+ "description": "APIInvalidTopicsError is error format response to invalid topics",
+ "headers": {
+ "invalidTopics": {
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "message": {
+ "type": "string"
+ }
+ }
+ },
"notFound": {
"description": "APINotFound is a not found empty response"
},
projects / gitea.git / commitdiff