danielepintore/gitea
1
0
Fork 0
mirror of https://github.com/go-gitea/gitea.git synced 2026-07-13 09:55:22 +02:00
Code Issues Packages Projects Releases Wiki Activity

refactor APIError to accept string message

Browse Source
This commit is contained in:
copilot-swe-agent[bot]
2026-06-06 11:53:36 +00:00
committed by GitHub
parent 72d4a2a314
commit 1279c0a320
66 changed files with 512 additions and 504 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
routers/api/v1/admin/org.go
View File

@@ -67,7 +67,7 @@ func CreateOrg(ctx *context.APIContext) {
db.IsErrNameReserved(err) ||
db.IsErrNameCharsNotAllowed(err) ||
db.IsErrNamePatternNotAllowed(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

36
routers/api/v1/admin/user.go
View File

@@ -40,7 +40,7 @@ func parseAuthSource(ctx *context.APIContext, u *user_model.User, sourceID int64
source, err := auth.GetSourceByID(ctx, sourceID)
if err != nil {
if auth.IsErrSourceNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -98,13 +98,13 @@ func CreateUser(ctx *context.APIContext) {
if u.LoginType == auth.Plain {
if len(form.Password) < setting.MinPasswordLength {
err := errors.New("PasswordIsRequired")
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}
if !password.IsComplexEnough(form.Password) {
err := errors.New("PasswordComplexity")
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}
@@ -112,7 +112,7 @@ func CreateUser(ctx *context.APIContext) {
if password.IsErrIsPwnedRequest(err) {
log.Error(err.Error())
}
ctx.APIError(http.StatusBadRequest, errors.New("PasswordPwned"))
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(errors.New("PasswordPwned")))
return
}
}
@@ -143,7 +143,7 @@ func CreateUser(ctx *context.APIContext) {
user_model.IsErrEmailCharIsNotSupported(err) ||
user_model.IsErrEmailInvalid(err) ||
db.IsErrNamePatternNotAllowed(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -204,11 +204,11 @@ func EditUser(ctx *context.APIContext) {
if err := user_service.UpdateAuth(ctx, ctx.ContextUser, authOpts); err != nil {
switch {
case errors.Is(err, password.ErrMinLength):
ctx.APIError(http.StatusBadRequest, fmt.Errorf("password must be at least %d characters", setting.MinPasswordLength))
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(fmt.Errorf("password must be at least %d characters", setting.MinPasswordLength)))
case errors.Is(err, password.ErrComplexity):
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
case errors.Is(err, password.ErrIsPwned), password.IsErrIsPwnedRequest(err):
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
default:
ctx.APIErrorInternal(err)
}
@@ -222,9 +222,9 @@ func EditUser(ctx *context.APIContext) {
if !user_model.IsEmailDomainAllowed(*form.Email) {
err = fmt.Errorf("the domain of user email %s conflicts with EMAIL_DOMAIN_ALLOWLIST or EMAIL_DOMAIN_BLOCKLIST", *form.Email)
}
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
case user_model.IsErrEmailAlreadyUsed(err):
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
default:
ctx.APIErrorInternal(err)
}
@@ -249,7 +249,7 @@ func EditUser(ctx *context.APIContext) {
if err := user_service.UpdateUser(ctx, ctx.ContextUser, opts); err != nil {
if user_model.IsErrDeleteLastAdminUser(err) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -289,13 +289,13 @@ func DeleteUser(ctx *context.APIContext) {
// "$ref": "#/responses/validationError"
if ctx.ContextUser.IsOrganization() {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("%s is an organization not a user", ctx.ContextUser.Name))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("%s is an organization not a user", ctx.ContextUser.Name)))
return
}
// admin should not delete themself
if ctx.ContextUser.ID == ctx.Doer.ID {
ctx.APIError(http.StatusUnprocessableEntity, errors.New("you cannot delete yourself"))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(errors.New("you cannot delete yourself")))
return
}
@@ -304,7 +304,7 @@ func DeleteUser(ctx *context.APIContext) {
org_model.IsErrUserHasOrgs(err) ||
packages_model.IsErrUserOwnPackages(err) ||
user_model.IsErrDeleteLastAdminUser(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -378,7 +378,7 @@ func DeleteUserPublicKey(ctx *context.APIContext) {
if asymkey_model.IsErrKeyNotExist(err) {
ctx.APIErrorNotFound()
} else if asymkey_model.IsErrKeyAccessDenied(err) {
ctx.APIError(http.StatusForbidden, "You do not have access to this key")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("You do not have access to this key"))
} else {
ctx.APIErrorInternal(err)
}
@@ -475,7 +475,7 @@ func SearchUsers(ctx *context.APIContext) {
if visibility, ok := api.VisibilityModes[visibilityParam]; ok {
visible = []api.VisibleType{visibility}
} else {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("Invalid visibility: \"%s\"", visibilityParam))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("Invalid visibility: \"%s\"", visibilityParam)))
return
}
}
@@ -551,7 +551,7 @@ func RenameUser(ctx *context.APIContext) {
// "$ref": "#/responses/validationError"
if ctx.ContextUser.IsOrganization() {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("%s is an organization not a user", ctx.ContextUser.Name))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("%s is an organization not a user", ctx.ContextUser.Name)))
return
}
@@ -560,7 +560,7 @@ func RenameUser(ctx *context.APIContext) {
// Check if username has been changed
if err := user_service.RenameUser(ctx, ctx.ContextUser, newName, ctx.Doer); err != nil {
if user_model.IsErrUserAlreadyExist(err) || db.IsErrNameReserved(err) || db.IsErrNamePatternNotAllowed(err) || db.IsErrNameCharsNotAllowed(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

64
routers/api/v1/api.go
View File

@@ -237,7 +237,7 @@ func doerNeedTwoFactorAuth(ctx gocontext.Context, doer *user_model.User) (bool,
func reqPackageAccess(accessMode perm.AccessMode) func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if ctx.Package.AccessMode < accessMode && !ctx.IsUserSiteAdmin() {
ctx.APIError(http.StatusForbidden, "user should have specific permission or be a site admin")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should have specific permission or be a site admin"))
return
}
}
@@ -258,39 +258,39 @@ func checkTokenPublicOnly() func(ctx *context.APIContext) {
switch category {
case auth_model.AccessTokenScopeCategoryRepository:
if !ctx.TokenCanAccessRepo(ctx.Repo.Repository) {
ctx.APIError(http.StatusForbidden, "token scope is limited to public repos")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("token scope is limited to public repos"))
return
}
case auth_model.AccessTokenScopeCategoryIssue:
if !ctx.TokenCanAccessRepo(ctx.Repo.Repository) {
ctx.APIError(http.StatusForbidden, "token scope is limited to public issues")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("token scope is limited to public issues"))
return
}
case auth_model.AccessTokenScopeCategoryOrganization:
orgPrivate := ctx.Org.Organization != nil && !ctx.Org.Organization.Visibility.IsPublic()
userOrgPrivate := ctx.ContextUser != nil && ctx.ContextUser.IsOrganization() && !ctx.ContextUser.Visibility.IsPublic()
if orgPrivate || userOrgPrivate {
ctx.APIError(http.StatusForbidden, "token scope is limited to public orgs")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("token scope is limited to public orgs"))
return
}
case auth_model.AccessTokenScopeCategoryUser:
if ctx.ContextUser != nil && ctx.ContextUser.IsTokenAccessAllowed() && !ctx.ContextUser.Visibility.IsPublic() {
ctx.APIError(http.StatusForbidden, "token scope is limited to public users")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("token scope is limited to public users"))
return
}
case auth_model.AccessTokenScopeCategoryActivityPub:
if ctx.ContextUser != nil && ctx.ContextUser.IsTokenAccessAllowed() && !ctx.ContextUser.Visibility.IsPublic() {
ctx.APIError(http.StatusForbidden, "token scope is limited to public activitypub")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("token scope is limited to public activitypub"))
return
}
case auth_model.AccessTokenScopeCategoryNotification:
if !ctx.TokenCanAccessRepo(ctx.Repo.Repository) {
ctx.APIError(http.StatusForbidden, "token scope is limited to public notifications")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("token scope is limited to public notifications"))
return
}
case auth_model.AccessTokenScopeCategoryPackage:
if ctx.Package != nil && ctx.Package.Owner.Visibility.IsPrivate() {
ctx.APIError(http.StatusForbidden, "token scope is limited to public packages")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("token scope is limited to public packages"))
return
}
}
@@ -304,7 +304,7 @@ func rejectPublicOnly() func(ctx *context.APIContext) {
return
}
ctx.APIError(http.StatusForbidden, "this endpoint is not available for public-only tokens")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("this endpoint is not available for public-only tokens"))
}
}
@@ -339,12 +339,12 @@ func tokenRequiresScopes(requiredScopeCategories ...auth_model.AccessTokenScopeC
requiredScopes := auth_model.GetRequiredScopes(requiredScopeLevel, requiredScopeCategories...)
allow, err := scope.HasScope(requiredScopes...)
if err != nil {
ctx.APIError(http.StatusForbidden, "checking scope failed: "+err.Error())
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("checking scope failed: "+err.Error()))
return
}
if !allow {
ctx.APIError(http.StatusForbidden, fmt.Sprintf("token does not have at least one of required scope(s), required=%v, token scope=%v", requiredScopes, scope))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(fmt.Sprintf("token does not have at least one of required scope(s), required=%v, token scope=%v", requiredScopes, scope)))
return
}
@@ -353,7 +353,7 @@ func tokenRequiresScopes(requiredScopeCategories ...auth_model.AccessTokenScopeC
// check if scope only applies to public resources
publicOnly, err := scope.PublicOnly()
if err != nil {
ctx.APIError(http.StatusForbidden, "parsing public resource scope failed: "+err.Error())
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("parsing public resource scope failed: "+err.Error()))
return
}
@@ -369,14 +369,14 @@ func reqToken() func(ctx *context.APIContext) {
if ctx.IsSigned {
return
}
ctx.APIError(http.StatusUnauthorized, "token is required")
ctx.APIError(http.StatusUnauthorized, ctx.APIErrorMessage("token is required"))
}
}
func reqExploreSignIn() func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if (setting.Service.RequireSignInViewStrict || setting.Service.Explore.RequireSigninView) && !ctx.IsSigned {
ctx.APIError(http.StatusUnauthorized, "you must be signed in to search for users")
ctx.APIError(http.StatusUnauthorized, ctx.APIErrorMessage("you must be signed in to search for users"))
}
}
}
@@ -395,7 +395,7 @@ func reqBasicOrRevProxyAuth() func(ctx *context.APIContext) {
return
}
if !ctx.IsBasicAuth {
ctx.APIError(http.StatusUnauthorized, "auth required")
ctx.APIError(http.StatusUnauthorized, ctx.APIErrorMessage("auth required"))
return
}
}
@@ -405,7 +405,7 @@ func reqBasicOrRevProxyAuth() func(ctx *context.APIContext) {
func reqSiteAdmin() func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if !ctx.IsUserSiteAdmin() {
ctx.APIError(http.StatusForbidden, "user should be the site admin")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should be the site admin"))
return
}
}
@@ -415,7 +415,7 @@ func reqSiteAdmin() func(ctx *context.APIContext) {
func reqOwner() func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if !ctx.Repo.Permission.IsOwner() && !ctx.IsUserSiteAdmin() {
ctx.APIError(http.StatusForbidden, "user should be the owner of the repo")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should be the owner of the repo"))
return
}
}
@@ -425,7 +425,7 @@ func reqOwner() func(ctx *context.APIContext) {
func reqSelfOrAdmin() func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if !ctx.IsUserSiteAdmin() && ctx.ContextUser != ctx.Doer {
ctx.APIError(http.StatusForbidden, "doer should be the site admin or be same as the contextUser")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("doer should be the site admin or be same as the contextUser"))
return
}
}
@@ -435,7 +435,7 @@ func reqSelfOrAdmin() func(ctx *context.APIContext) {
func reqAdmin() func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if !ctx.IsUserRepoAdmin() && !ctx.IsUserSiteAdmin() {
ctx.APIError(http.StatusForbidden, "user should be an owner or a collaborator with admin write of a repository")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should be an owner or a collaborator with admin write of a repository"))
return
}
}
@@ -445,7 +445,7 @@ func reqAdmin() func(ctx *context.APIContext) {
func reqRepoWriter(unitTypes ...unit.Type) func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if !ctx.IsUserRepoWriter(unitTypes) && !ctx.IsUserRepoAdmin() && !ctx.IsUserSiteAdmin() {
ctx.APIError(http.StatusForbidden, "user should have a permission to write to a repo")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should have a permission to write to a repo"))
return
}
}
@@ -455,7 +455,7 @@ func reqRepoWriter(unitTypes ...unit.Type) func(ctx *context.APIContext) {
func reqRepoReader(unitType unit.Type) func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if !ctx.Repo.Permission.CanRead(unitType) && !ctx.IsUserRepoAdmin() && !ctx.IsUserSiteAdmin() {
ctx.APIError(http.StatusForbidden, "user should have specific read permission or be a repo admin or a site admin")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should have specific read permission or be a repo admin or a site admin"))
return
}
}
@@ -465,7 +465,7 @@ func reqRepoReader(unitType unit.Type) func(ctx *context.APIContext) {
func reqAnyRepoReader() func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if !ctx.Repo.Permission.HasAnyUnitAccess() && !ctx.IsUserSiteAdmin() {
ctx.APIError(http.StatusForbidden, "user should have any permission to read repository or permissions of site admin")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should have any permission to read repository or permissions of site admin"))
return
}
}
@@ -495,7 +495,7 @@ func reqOrgOwnership() func(ctx *context.APIContext) {
return
} else if !isOwner {
if ctx.Org.Organization != nil {
ctx.APIError(http.StatusForbidden, "Must be an organization owner")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Must be an organization owner"))
} else {
ctx.APIErrorNotFound()
}
@@ -533,7 +533,7 @@ func reqTeamMembership() func(ctx *context.APIContext) {
if err != nil {
ctx.APIErrorInternal(err)
} else if isOrgMember {
ctx.APIError(http.StatusForbidden, "Must be a team member")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Must be a team member"))
} else {
ctx.APIErrorNotFound()
}
@@ -565,7 +565,7 @@ func reqOrgMembership() func(ctx *context.APIContext) {
return
} else if !isMember {
if ctx.Org.Organization != nil {
ctx.APIError(http.StatusForbidden, "Must be an organization member")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Must be an organization member"))
} else {
ctx.APIErrorNotFound()
}
@@ -577,7 +577,7 @@ func reqOrgMembership() func(ctx *context.APIContext) {
func reqGitHook() func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if !ctx.Doer.CanEditGitHook() {
ctx.APIError(http.StatusForbidden, "must be allowed to edit Git hooks")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("must be allowed to edit Git hooks"))
return
}
}
@@ -587,7 +587,7 @@ func reqGitHook() func(ctx *context.APIContext) {
func reqWebhooksEnabled() func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if setting.DisableWebhooks {
ctx.APIError(http.StatusForbidden, "webhooks disabled by administrator")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("webhooks disabled by administrator"))
return
}
}
@@ -597,7 +597,7 @@ func reqWebhooksEnabled() func(ctx *context.APIContext) {
func reqStarsEnabled() func(ctx *context.APIContext) {
return func(ctx *context.APIContext) {
if setting.Repository.DisableStars {
ctx.APIError(http.StatusForbidden, "stars disabled by administrator")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("stars disabled by administrator"))
return
}
}
@@ -734,14 +734,14 @@ func mustEnableWiki(ctx *context.APIContext) {
// FIXME: for consistency, maybe most mustNotBeArchived checks should be replaced with mustEnableEditor
func mustNotBeArchived(ctx *context.APIContext) {
if ctx.Repo.Repository.IsArchived {
ctx.APIError(http.StatusLocked, fmt.Errorf("%s is archived", ctx.Repo.Repository.FullName()))
ctx.APIError(http.StatusLocked, ctx.APIErrorMessage(fmt.Errorf("%s is archived", ctx.Repo.Repository.FullName())))
return
}
}
func mustEnableEditor(ctx *context.APIContext) {
if !ctx.Repo.Repository.CanEnableEditor() {
ctx.APIError(http.StatusLocked, fmt.Errorf("%s is not allowed to edit", ctx.Repo.Repository.FullName()))
ctx.APIError(http.StatusLocked, ctx.APIErrorMessage(fmt.Errorf("%s is not allowed to edit", ctx.Repo.Repository.FullName())))
return
}
}
@@ -759,7 +759,7 @@ func bind[T any](_ T) any {
theObj := new(T) // create a new form obj for every request but not use obj directly
errs := binding.Bind(ctx.Req, theObj)
if len(errs) > 0 {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Sprintf("%s: %s", errs[0].FieldNames, errs[0].Error()))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Sprintf("%s: %s", errs[0].FieldNames, errs[0].Error())))
return
}
web.SetForm(ctx, theObj)
@@ -785,7 +785,7 @@ func apiAuth(authMethod auth.Method) func(*context.APIContext) {
if err != nil {
msg, ok := auth.ErrAsUserAuthMessage(err)
msg = util.Iif(ok, msg, "invalid username, password or token")
ctx.APIError(http.StatusUnauthorized, msg)
ctx.APIError(http.StatusUnauthorized, ctx.APIErrorMessage(msg))
return
}
ctx.Doer = ar.Doer

4
routers/api/v1/notify/notifications.go
View File

@@ -28,7 +28,7 @@ func NewAvailable(ctx *context.APIContext) {
Status: []activities_model.NotificationStatus{activities_model.NotificationStatusUnread},
})
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
@@ -38,7 +38,7 @@ func NewAvailable(ctx *context.APIContext) {
func getFindNotificationOptions(ctx *context.APIContext) *activities_model.FindNotificationOptions {
before, since, err := context.GetQueryBeforeSince(ctx.Base)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return nil
}
opts := &activities_model.FindNotificationOptions{

2
routers/api/v1/notify/repo.go
View File

@@ -183,7 +183,7 @@ func ReadRepoNotifications(ctx *context.APIContext) {
if len(qLastRead) > 0 {
tmpLastRead, err := time.Parse(time.RFC3339, qLastRead)
if err != nil {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}
if !tmpLastRead.IsZero() {

4
routers/api/v1/notify/threads.go
View File

@@ -104,14 +104,14 @@ func getThread(ctx *context.APIContext) *activities_model.Notification {
n, err := activities_model.GetNotificationByID(ctx, ctx.PathParamInt64("id"))
if err != nil {
if db.IsErrNotExist(err) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
return nil
}
if n.UserID != ctx.Doer.ID && !ctx.Doer.IsAdmin {
ctx.APIError(http.StatusForbidden, fmt.Errorf("only user itself and admin are allowed to read/change this thread %d", n.ID))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(fmt.Errorf("only user itself and admin are allowed to read/change this thread %d", n.ID)))
return nil
}
return n

2
routers/api/v1/notify/user.go
View File

@@ -134,7 +134,7 @@ func ReadNotifications(ctx *context.APIContext) {
if len(qLastRead) > 0 {
tmpLastRead, err := time.Parse(time.RFC3339, qLastRead)
if err != nil {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}
if !tmpLastRead.IsZero() {

22
routers/api/v1/org/action.go
View File

@@ -111,9 +111,9 @@ func (Action) CreateOrUpdateSecret(ctx *context.APIContext) {
_, created, err := secret_service.CreateOrUpdateSecret(ctx, ctx.Org.Organization.ID, 0, ctx.PathParam("secretname"), opt.Data, opt.Description)
if err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -158,9 +158,9 @@ func (Action) DeleteSecret(ctx *context.APIContext) {
err := secret_service.DeleteSecretByName(ctx, ctx.Org.Organization.ID, 0, ctx.PathParam("secretname"))
if err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -277,7 +277,7 @@ func (Action) GetVariable(ctx *context.APIContext) {
})
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -327,9 +327,9 @@ func (Action) DeleteVariable(ctx *context.APIContext) {
if err := actions_service.DeleteVariableByName(ctx, ctx.Org.Organization.ID, 0, ctx.PathParam("variablename")); err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -387,13 +387,13 @@ func (Action) CreateVariable(ctx *context.APIContext) {
return
}
if v != nil && v.ID > 0 {
ctx.APIError(http.StatusConflict, util.NewAlreadyExistErrorf("variable name %s already exists", variableName))
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(util.NewAlreadyExistErrorf("variable name %s already exists", variableName)))
return
}
if _, err := actions_service.CreateVariable(ctx, ownerID, 0, variableName, opt.Value, opt.Description); err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -445,7 +445,7 @@ func (Action) UpdateVariable(ctx *context.APIContext) {
})
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -462,7 +462,7 @@ func (Action) UpdateVariable(ctx *context.APIContext) {
if _, err := actions_service.UpdateVariableNameData(ctx, v); err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

2
routers/api/v1/org/avatar.go
View File

@@ -39,7 +39,7 @@ func UpdateAvatar(ctx *context.APIContext) {
content, err := base64.StdEncoding.DecodeString(form.Image)
if err != nil {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}

4
routers/api/v1/org/label.go
View File

@@ -90,7 +90,7 @@ func CreateLabel(ctx *context.APIContext) {
form.Color = strings.Trim(form.Color, " ")
color, err := label.NormalizeColor(form.Color)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
form.Color = color
@@ -209,7 +209,7 @@ func EditLabel(ctx *context.APIContext) {
if form.Color != nil {
color, err := label.NormalizeColor(*form.Color)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
l.Color = color

4
routers/api/v1/org/member.go
View File

@@ -221,9 +221,9 @@ func checkCanChangeOrgUserStatus(ctx *context.APIContext, targetUser *user_model
// allow org owners to change status of members
isOwner, err := ctx.Org.Organization.IsOwnedBy(ctx, ctx.Doer.ID)
if err != nil {
ctx.APIError(http.StatusInternalServerError, err)
ctx.APIError(http.StatusInternalServerError, ctx.APIErrorMessage(err))
} else if !isOwner {
ctx.APIError(http.StatusForbidden, "Cannot change member visibility")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Cannot change member visibility"))
}
}

8
routers/api/v1/org/org.go
View File

@@ -256,7 +256,7 @@ func Create(ctx *context.APIContext) {
// "$ref": "#/responses/validationError"
form := web.GetForm(ctx).(*api.CreateOrgOption)
if !ctx.Doer.CanCreateOrganization() {
ctx.APIError(http.StatusForbidden, nil)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(nil))
return
}
@@ -282,7 +282,7 @@ func Create(ctx *context.APIContext) {
db.IsErrNameReserved(err) ||
db.IsErrNameCharsNotAllowed(err) ||
db.IsErrNamePatternNotAllowed(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -355,7 +355,7 @@ func Rename(ctx *context.APIContext) {
orgUser := ctx.Org.Organization.AsUser()
if err := user_service.RenameUser(ctx, orgUser, form.NewName, ctx.Doer); err != nil {
if user_model.IsErrUserAlreadyExist(err) || db.IsErrNameReserved(err) || db.IsErrNamePatternNotAllowed(err) || db.IsErrNameCharsNotAllowed(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -394,7 +394,7 @@ func Edit(ctx *context.APIContext) {
if err := org.UpdateOrgEmailAddress(ctx, ctx.Org.Organization, form.Email); err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)

8
routers/api/v1/org/team.go
View File

@@ -236,7 +236,7 @@ func CreateTeam(ctx *context.APIContext) {
if err := org_service.NewTeam(ctx, team); err != nil {
if organization.IsErrTeamAlreadyExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -490,7 +490,7 @@ func AddTeamMember(ctx *context.APIContext) {
}
if err := org_service.AddTeamMember(ctx, ctx.Org.Team, u); err != nil {
if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -691,7 +691,7 @@ func AddTeamRepository(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if access < perm.AccessModeAdmin {
ctx.APIError(http.StatusForbidden, "Must have admin-level access to the repository")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Must have admin-level access to the repository"))
return
}
if err := repo_service.TeamAddRepository(ctx, ctx.Org.Team, repo); err != nil {
@@ -743,7 +743,7 @@ func RemoveTeamRepository(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if access < perm.AccessModeAdmin {
ctx.APIError(http.StatusForbidden, "Must have admin-level access to the repository")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Must have admin-level access to the repository"))
return
}
if err := repo_service.RemoveRepositoryFromTeam(ctx, ctx.Org.Team, repo.ID); err != nil {

16
routers/api/v1/packages/package.go
View File

@@ -329,7 +329,7 @@ func GetLatestPackageVersion(ctx *context.APIContext) {
return
}
if len(pvs) == 0 {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
return
}
@@ -383,7 +383,7 @@ func LinkPackage(ctx *context.APIContext) {
pkg, err := packages.GetPackageByName(ctx, ctx.ContextUser.ID, packages.Type(ctx.PathParam("type")), ctx.PathParam("name"))
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -393,7 +393,7 @@ func LinkPackage(ctx *context.APIContext) {
repo, err := repo_model.GetRepositoryByName(ctx, ctx.ContextUser.ID, ctx.PathParam("repo_name"))
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -404,9 +404,9 @@ func LinkPackage(ctx *context.APIContext) {
if err != nil {
switch {
case errors.Is(err, util.ErrInvalidArgument):
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
case errors.Is(err, util.ErrPermissionDenied):
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
default:
ctx.APIErrorInternal(err)
}
@@ -445,7 +445,7 @@ func UnlinkPackage(ctx *context.APIContext) {
pkg, err := packages.GetPackageByName(ctx, ctx.ContextUser.ID, packages.Type(ctx.PathParam("type")), ctx.PathParam("name"))
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -456,9 +456,9 @@ func UnlinkPackage(ctx *context.APIContext) {
if err != nil {
switch {
case errors.Is(err, util.ErrPermissionDenied):
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
case errors.Is(err, util.ErrInvalidArgument):
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
default:
ctx.APIErrorInternal(err)
}

64
routers/api/v1/repo/action.go
View File

@@ -141,9 +141,9 @@ func (Action) CreateOrUpdateSecret(ctx *context.APIContext) {
_, created, err := secret_service.CreateOrUpdateSecret(ctx, 0, repo.ID, ctx.PathParam("secretname"), opt.Data, opt.Description)
if err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -195,9 +195,9 @@ func (Action) DeleteSecret(ctx *context.APIContext) {
err := secret_service.DeleteSecretByName(ctx, 0, repo.ID, ctx.PathParam("secretname"))
if err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -243,7 +243,7 @@ func (Action) GetVariable(ctx *context.APIContext) {
})
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -298,9 +298,9 @@ func (Action) DeleteVariable(ctx *context.APIContext) {
if err := actions_service.DeleteVariableByName(ctx, 0, ctx.Repo.Repository.ID, ctx.PathParam("variablename")); err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -361,13 +361,13 @@ func (Action) CreateVariable(ctx *context.APIContext) {
return
}
if v != nil && v.ID > 0 {
ctx.APIError(http.StatusConflict, util.NewAlreadyExistErrorf("variable name %s already exists", variableName))
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(util.NewAlreadyExistErrorf("variable name %s already exists", variableName)))
return
}
if _, err := actions_service.CreateVariable(ctx, 0, repoID, variableName, opt.Value, opt.Description); err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -422,7 +422,7 @@ func (Action) UpdateVariable(ctx *context.APIContext) {
})
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -439,7 +439,7 @@ func (Action) UpdateVariable(ctx *context.APIContext) {
if _, err := actions_service.UpdateVariableNameData(ctx, v); err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -957,7 +957,7 @@ func ActionsGetWorkflow(ctx *context.APIContext) {
workflow, err := convert.GetActionWorkflow(ctx, ctx.Repo.GitRepo, ctx.Repo.Repository, workflowID)
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -1005,7 +1005,7 @@ func ActionsDisableWorkflow(ctx *context.APIContext) {
err := actions_service.EnableOrDisableWorkflow(ctx, workflowID, false)
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -1062,7 +1062,7 @@ func ActionsDispatchWorkflow(ctx *context.APIContext) {
workflowID := ctx.PathParam("workflow_id")
opt := web.GetForm(ctx).(*api.CreateActionWorkflowDispatch)
if opt.Ref == "" {
ctx.APIError(http.StatusUnprocessableEntity, util.NewInvalidArgumentErrorf("ref is required parameter"))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(util.NewInvalidArgumentErrorf("ref is required parameter")))
return
}
@@ -1088,11 +1088,11 @@ func ActionsDispatchWorkflow(ctx *context.APIContext) {
})
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrPermissionDenied) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -1151,7 +1151,7 @@ func ActionsEnableWorkflow(ctx *context.APIContext) {
err := actions_service.EnableOrDisableWorkflow(ctx, workflowID, true)
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -1490,13 +1490,13 @@ func RerunWorkflowJob(ctx *context.APIContext) {
func handleWorkflowRerunError(ctx *context.APIContext, err error) {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
} else if errors.Is(err, util.ErrAlreadyExist) {
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
return
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1560,7 +1560,7 @@ func ListWorkflowRunJobs(ctx *context.APIContext) {
// Avoid the list all jobs functionality for this api route to be used with a runID == 0.
if runID <= 0 {
ctx.APIError(http.StatusBadRequest, util.NewInvalidArgumentErrorf("runID must be a positive integer"))
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(util.NewInvalidArgumentErrorf("runID must be a positive integer")))
return
}
@@ -1790,7 +1790,7 @@ func DeleteActionRun(ctx *context.APIContext) {
}
if !run.Status.IsDone() {
ctx.APIError(http.StatusBadRequest, "this workflow run is not done")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("this workflow run is not done"))
return
}
@@ -1908,7 +1908,7 @@ func GetArtifact(ctx *context.APIContext) {
return
}
// v3 not supported due to not having one unique id
ctx.APIError(http.StatusNotFound, "Artifact not found")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("Artifact not found"))
}
// DeleteArtifact Deletes a specific artifact for a workflow run.
@@ -1956,7 +1956,7 @@ func DeleteArtifact(ctx *context.APIContext) {
return
}
// v3 not supported due to not having one unique id
ctx.APIError(http.StatusNotFound, "Artifact not found")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("Artifact not found"))
}
func buildSignature(endp string, expires, artifactID int64) []byte {
@@ -2012,7 +2012,7 @@ func DownloadArtifact(ctx *context.APIContext) {
// if artifacts status is not uploaded-confirmed, treat it as not found
if art.Status == actions_model.ArtifactStatusExpired {
ctx.APIError(http.StatusNotFound, "Artifact has expired")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("Artifact has expired"))
return
}
@@ -2030,7 +2030,7 @@ func DownloadArtifact(ctx *context.APIContext) {
return
}
// v3 not supported due to not having one unique id
ctx.APIError(http.StatusNotFound, "Artifact not found")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("Artifact not found"))
}
// DownloadArtifactRaw Downloads a specific artifact for a workflow run directly.
@@ -2057,18 +2057,18 @@ func DownloadArtifactRaw(ctx *context.APIContext) {
expectedSig := buildSignature(buildDownloadRawEndpoint(repo, art.ID), expires, art.ID)
if !hmac.Equal(sigBytes, expectedSig) {
ctx.APIError(http.StatusUnauthorized, "Error unauthorized")
ctx.APIError(http.StatusUnauthorized, ctx.APIErrorMessage("Error unauthorized"))
return
}
t := time.Unix(expires, 0)
if t.Before(time.Now()) {
ctx.APIError(http.StatusUnauthorized, "Error link expired")
ctx.APIError(http.StatusUnauthorized, ctx.APIErrorMessage("Error link expired"))
return
}
// if artifacts status is not uploaded-confirmed, treat it as not found
if art.Status == actions_model.ArtifactStatusExpired {
ctx.APIError(http.StatusNotFound, "Artifact has expired")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("Artifact has expired"))
return
}
if actions_service.IsArtifactV4(art) {
@@ -2080,7 +2080,7 @@ func DownloadArtifactRaw(ctx *context.APIContext) {
return
}
// v3 not supported due to not having one unique id
ctx.APIError(http.StatusNotFound, "artifact not found")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("artifact not found"))
}
// Try to get the artifact by ID and check access
@@ -2097,7 +2097,7 @@ func getArtifactByPathParam(ctx *context.APIContext, repo *repo_model.Repository
if !ok ||
art.RepoID != repo.ID ||
art.Status != actions_model.ArtifactStatusUploadConfirmed && art.Status != actions_model.ArtifactStatusExpired {
ctx.APIError(http.StatusNotFound, "artifact not found")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("artifact not found"))
return nil
}
return art

2
routers/api/v1/repo/avatar.go
View File

@@ -44,7 +44,7 @@ func UpdateAvatar(ctx *context.APIContext) {
content, err := base64.StdEncoding.DecodeString(form.Image)
if err != nil {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}

4
routers/api/v1/repo/blob.go
View File

@@ -43,12 +43,12 @@ func GetBlob(ctx *context.APIContext) {
sha := ctx.PathParam("sha")
if len(sha) == 0 {
ctx.APIError(http.StatusBadRequest, "sha not provided")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("sha not provided"))
return
}
if blob, err := files_service.GetBlobBySHA(ctx.Repo.Repository, ctx.Repo.GitRepo, sha); err != nil {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.JSON(http.StatusOK, blob)
}

90
routers/api/v1/repo/branch.go
View File

@@ -122,12 +122,12 @@ func DeleteBranch(ctx *context.APIContext) {
// "423":
// "$ref": "#/responses/repoArchivedError"
if ctx.Repo.Repository.IsEmpty {
ctx.APIError(http.StatusNotFound, "Git Repository is empty.")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("Git Repository is empty."))
return
}
if ctx.Repo.Repository.IsMirror {
ctx.APIError(http.StatusForbidden, "Git Repository is a mirror.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Git Repository is a mirror."))
return
}
@@ -155,9 +155,9 @@ func DeleteBranch(ctx *context.APIContext) {
case git.IsErrBranchNotExist(err):
ctx.APIErrorNotFound(err)
case errors.Is(err, repo_service.ErrBranchIsDefault):
ctx.APIError(http.StatusForbidden, errors.New("can not delete default or pull request target branch"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("can not delete default or pull request target branch")))
case errors.Is(err, git_model.ErrBranchIsProtected):
ctx.APIError(http.StatusForbidden, errors.New("branch protected"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("branch protected")))
default:
ctx.APIErrorInternal(err)
}
@@ -204,12 +204,12 @@ func CreateBranch(ctx *context.APIContext) {
// "$ref": "#/responses/repoArchivedError"
if ctx.Repo.Repository.IsEmpty {
ctx.APIError(http.StatusNotFound, "Git Repository is empty.")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("Git Repository is empty."))
return
}
if ctx.Repo.Repository.IsMirror {
ctx.APIError(http.StatusForbidden, "Git Repository is a mirror.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Git Repository is a mirror."))
return
}
@@ -232,7 +232,7 @@ func CreateBranch(ctx *context.APIContext) {
return
}
} else {
ctx.APIError(http.StatusNotFound, "The old branch does not exist")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("The old branch does not exist"))
return
}
} else {
@@ -246,13 +246,13 @@ func CreateBranch(ctx *context.APIContext) {
err = repo_service.CreateNewBranchFromCommit(ctx, ctx.Doer, ctx.Repo.Repository, oldCommit.ID.String(), opt.BranchName)
if err != nil {
if git_model.IsErrBranchNotExist(err) {
ctx.APIError(http.StatusNotFound, "The old branch does not exist")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("The old branch does not exist"))
} else if release_service.IsErrTagAlreadyExists(err) {
ctx.APIError(http.StatusConflict, "The branch with the same tag already exists.")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("The branch with the same tag already exists."))
} else if git_model.IsErrBranchAlreadyExists(err) || git.IsErrPushOutOfDate(err) {
ctx.APIError(http.StatusConflict, "The branch already exists.")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("The branch already exists."))
} else if git_model.IsErrBranchNameConflict(err) {
ctx.APIError(http.StatusConflict, "The branch with the same name already exists.")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("The branch with the same name already exists."))
} else {
ctx.APIErrorInternal(err)
}
@@ -433,12 +433,12 @@ func UpdateBranch(ctx *context.APIContext) {
repo := ctx.Repo.Repository
if repo.IsEmpty {
ctx.APIError(http.StatusNotFound, "Git Repository is empty.")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("Git Repository is empty."))
return
}
if repo.IsMirror {
ctx.APIError(http.StatusForbidden, "Git Repository is a mirror.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Git Repository is a mirror."))
return
}
@@ -448,10 +448,10 @@ func UpdateBranch(ctx *context.APIContext) {
case git_model.IsErrBranchNotExist(err):
ctx.APIErrorNotFound(err)
case errors.Is(err, util.ErrInvalidArgument):
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
case git.IsErrPushRejected(err):
rej := err.(*git.ErrPushRejected)
ctx.APIError(http.StatusForbidden, rej.Message)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(rej.Message))
default:
ctx.APIErrorInternal(err)
}
@@ -506,12 +506,12 @@ func RenameBranch(ctx *context.APIContext) {
repo := ctx.Repo.Repository
if repo.IsEmpty {
ctx.APIError(http.StatusNotFound, "Git Repository is empty.")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("Git Repository is empty."))
return
}
if repo.IsMirror {
ctx.APIError(http.StatusForbidden, "Git Repository is a mirror.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Git Repository is a mirror."))
return
}
@@ -519,20 +519,20 @@ func RenameBranch(ctx *context.APIContext) {
if err != nil {
switch {
case repo_model.IsErrUserDoesNotHaveAccessToRepo(err):
ctx.APIError(http.StatusForbidden, "User must be a repo or site admin to rename default or protected branches.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("User must be a repo or site admin to rename default or protected branches."))
case errors.Is(err, git_model.ErrBranchIsProtected):
ctx.APIError(http.StatusForbidden, "Failed to rename branch due to branch protection rules.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Failed to rename branch due to branch protection rules."))
default:
ctx.APIErrorInternal(err)
}
return
}
if msg == "target_exist" {
ctx.APIError(http.StatusUnprocessableEntity, "Cannot rename a branch using the same name or rename to a branch that already exists.")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Cannot rename a branch using the same name or rename to a branch that already exists."))
return
}
if msg == "from_not_exist" {
ctx.APIError(http.StatusNotFound, "Branch doesn't exist.")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("Branch doesn't exist."))
return
}
@@ -663,7 +663,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
ruleName = form.BranchName //nolint:staticcheck // deprecated field
}
if len(ruleName) == 0 {
ctx.APIError(http.StatusBadRequest, "both rule_name and branch_name are empty")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("both rule_name and branch_name are empty"))
return
}
@@ -672,7 +672,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if protectBranch != nil {
ctx.APIError(http.StatusForbidden, "Branch protection already exist")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Branch protection already exist"))
return
}
@@ -684,7 +684,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
whitelistUsers, err := user_model.GetUserIDsByNames(ctx, form.PushWhitelistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -693,7 +693,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
forcePushAllowlistUsers, err := user_model.GetUserIDsByNames(ctx, form.ForcePushAllowlistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -702,7 +702,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
mergeWhitelistUsers, err := user_model.GetUserIDsByNames(ctx, form.MergeWhitelistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -711,7 +711,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
approvalsWhitelistUsers, err := user_model.GetUserIDsByNames(ctx, form.ApprovalsWhitelistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -722,7 +722,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
bypassAllowlistUsers, err = user_model.GetUserIDsByNames(ctx, form.BypassAllowlistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -734,7 +734,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
whitelistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.PushWhitelistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -743,7 +743,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
forcePushAllowlistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.ForcePushAllowlistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -752,7 +752,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
mergeWhitelistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.MergeWhitelistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -761,7 +761,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
approvalsWhitelistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.ApprovalsWhitelistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -771,7 +771,7 @@ func CreateBranchProtection(ctx *context.APIContext) {
bypassAllowlistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.BypassAllowlistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -999,7 +999,7 @@ func EditBranchProtection(ctx *context.APIContext) {
whitelistUsers, err = user_model.GetUserIDsByNames(ctx, form.PushWhitelistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1012,7 +1012,7 @@ func EditBranchProtection(ctx *context.APIContext) {
forcePushAllowlistUsers, err = user_model.GetUserIDsByNames(ctx, form.ForcePushAllowlistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1025,7 +1025,7 @@ func EditBranchProtection(ctx *context.APIContext) {
mergeWhitelistUsers, err = user_model.GetUserIDsByNames(ctx, form.MergeWhitelistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1038,7 +1038,7 @@ func EditBranchProtection(ctx *context.APIContext) {
approvalsWhitelistUsers, err = user_model.GetUserIDsByNames(ctx, form.ApprovalsWhitelistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1051,7 +1051,7 @@ func EditBranchProtection(ctx *context.APIContext) {
bypassAllowlistUsers, err = user_model.GetUserIDsByNames(ctx, form.BypassAllowlistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1067,7 +1067,7 @@ func EditBranchProtection(ctx *context.APIContext) {
whitelistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.PushWhitelistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1080,7 +1080,7 @@ func EditBranchProtection(ctx *context.APIContext) {
forcePushAllowlistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.ForcePushAllowlistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1093,7 +1093,7 @@ func EditBranchProtection(ctx *context.APIContext) {
mergeWhitelistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.MergeWhitelistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1106,7 +1106,7 @@ func EditBranchProtection(ctx *context.APIContext) {
approvalsWhitelistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.ApprovalsWhitelistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1119,7 +1119,7 @@ func EditBranchProtection(ctx *context.APIContext) {
bypassAllowlistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.BypassAllowlistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1331,10 +1331,10 @@ func MergeUpstream(ctx *context.APIContext) {
mergeStyle, err := repo_service.MergeUpstream(ctx, ctx.Doer, ctx.Repo.Repository, form.Branch, form.FfOnly)
if err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)

14
routers/api/v1/repo/collaborators.go
View File

@@ -107,7 +107,7 @@ func IsCollaborator(ctx *context.APIContext) {
user, err := user_model.GetUserByName(ctx, ctx.PathParam("collaborator"))
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -167,7 +167,7 @@ func AddOrUpdateCollaborator(ctx *context.APIContext) {
collaborator, err := user_model.GetUserByName(ctx, ctx.PathParam("collaborator"))
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -186,7 +186,7 @@ func AddOrUpdateCollaborator(ctx *context.APIContext) {
if err := repo_service.AddOrUpdateCollaborator(ctx, ctx.Repo.Repository, collaborator, p); err != nil {
if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -230,7 +230,7 @@ func DeleteCollaborator(ctx *context.APIContext) {
collaborator, err := user_model.GetUserByName(ctx, ctx.PathParam("collaborator"))
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -277,14 +277,14 @@ func GetRepoPermissions(ctx *context.APIContext) {
collaboratorUsername := ctx.PathParam("collaborator")
if !ctx.Doer.IsAdmin && !strings.EqualFold(ctx.Doer.LowerName, collaboratorUsername) && !ctx.IsUserRepoAdmin() {
ctx.APIError(http.StatusForbidden, "Only admins can query all permissions, repo admins can query all repo permissions, collaborators can query only their own")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Only admins can query all permissions, repo admins can query all repo permissions, collaborators can query only their own"))
return
}
collaborator, err := user_model.GetUserByName(ctx, collaboratorUsername)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -326,7 +326,7 @@ func GetReviewers(ctx *context.APIContext) {
canChooseReviewer := issue_service.CanDoerChangeReviewRequests(ctx, ctx.Doer, ctx.Repo.Repository, 0)
if !canChooseReviewer {
ctx.APIError(http.StatusForbidden, errors.New("doer has no permission to get reviewers"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("doer has no permission to get reviewers")))
return
}

8
routers/api/v1/repo/commits.go
View File

@@ -66,7 +66,7 @@ func GetSingleCommit(ctx *context.APIContext) {
sha := ctx.PathParam("sha")
if !git.IsValidRefPattern(sha) {
ctx.APIError(http.StatusUnprocessableEntity, "no valid ref or sha: "+sha)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("no valid ref or sha: "+sha))
return
}
@@ -166,13 +166,13 @@ func GetAllCommits(ctx *context.APIContext) {
// Validate since/until as ISO 8601 (RFC3339)
if since != "" {
if _, err := time.Parse(time.RFC3339, since); err != nil {
ctx.APIError(http.StatusUnprocessableEntity, "invalid 'since' format, expected ISO 8601 (RFC3339)")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("invalid 'since' format, expected ISO 8601 (RFC3339)"))
return
}
}
if until != "" {
if _, err := time.Parse(time.RFC3339, until); err != nil {
ctx.APIError(http.StatusUnprocessableEntity, "invalid 'until' format, expected ISO 8601 (RFC3339)")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("invalid 'until' format, expected ISO 8601 (RFC3339)"))
return
}
}
@@ -383,7 +383,7 @@ func GetCommitPullRequest(ctx *context.APIContext) {
pr, err := issues_model.GetPullRequestByMergedCommit(ctx, ctx.Repo.Repository.ID, ctx.PathParam("sha"))
if err != nil {
if issues_model.IsErrPullRequestNotExist(err) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

8
routers/api/v1/repo/download.go
View File

@@ -17,9 +17,9 @@ func serveRepoArchive(ctx *context.APIContext, reqFileName string, paths []strin
aReq, err := archiver_service.NewRequest(ctx.Repo.Repository, ctx.Repo.GitRepo, reqFileName, paths)
if err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -28,7 +28,7 @@ func serveRepoArchive(ctx *context.APIContext, reqFileName string, paths []strin
err = archiver_service.ServeRepoArchive(ctx.Base, aReq)
if err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -47,7 +47,7 @@ func DownloadArchive(ctx *context.APIContext) {
case "bundle":
tp = repo_model.ArchiveBundle
default:
ctx.APIError(http.StatusBadRequest, "Unknown archive type: "+ballType)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Unknown archive type: "+ballType))
return
}
serveRepoArchive(ctx, ctx.PathParam("*")+"."+tp.String(), ctx.FormStrings("path"))

20
routers/api/v1/repo/file.go
View File

@@ -331,7 +331,7 @@ func ReqChangeRepoFileOptionsAndCheck(ctx *context.APIContext) {
commonOpts.BranchName = util.IfZero(commonOpts.BranchName, ctx.Repo.Repository.DefaultBranch)
commonOpts.NewBranchName = util.IfZero(commonOpts.NewBranchName, commonOpts.BranchName)
if !ctx.Repo.CanWriteToBranch(ctx, ctx.Doer, commonOpts.NewBranchName) && !ctx.IsUserSiteAdmin() {
ctx.APIError(http.StatusForbidden, "user should have a permission to write to the target branch")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should have a permission to write to the target branch"))
return
}
changeFileOpts := &files_service.ChangeRepoFilesOptions{
@@ -409,7 +409,7 @@ func ChangeFiles(ctx *context.APIContext) {
for _, file := range apiOpts.Files {
contentReader, err := base64Reader(file.ContentBase64)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
// FIXME: ChangeFileOperation.SHA is NOT required for update or delete if last commit is provided in the options
@@ -483,7 +483,7 @@ func CreateFile(ctx *context.APIContext) {
}
contentReader, err := base64Reader(apiOpts.ContentBase64)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
@@ -554,7 +554,7 @@ func UpdateFile(ctx *context.APIContext) {
}
contentReader, err := base64Reader(apiOpts.ContentBase64)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
willCreate := apiOpts.SHA == ""
@@ -580,21 +580,21 @@ func UpdateFile(ctx *context.APIContext) {
func handleChangeRepoFilesError(ctx *context.APIContext, err error) {
if git.IsErrPushRejected(err) {
err := err.(*git.ErrPushRejected)
ctx.APIError(http.StatusForbidden, err.Message)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err.Message))
return
}
if files_service.IsErrUserCannotCommit(err) || pull_service.IsErrFilePathProtected(err) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
return
}
if git_model.IsErrBranchAlreadyExists(err) || files_service.IsErrFilenameInvalid(err) || pull_service.IsErrSHADoesNotMatch(err) ||
files_service.IsErrFilePathInvalid(err) || files_service.IsErrRepoFileAlreadyExists(err) ||
files_service.IsErrCommitIDDoesNotMatch(err) || files_service.IsErrSHAOrCommitIDNotProvided(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -770,7 +770,7 @@ func GetContentsExt(ctx *context.APIContext) {
case "commit_message":
opts.IncludeCommitMessage = true
default:
ctx.APIError(http.StatusBadRequest, fmt.Sprintf("unknown include option %q", includeOpt))
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(fmt.Sprintf("unknown include option %q", includeOpt)))
return
}
}
@@ -957,7 +957,7 @@ func handleGetFileContents(ctx *context.APIContext) {
if !ok {
err := json.Unmarshal(util.UnsafeStringToBytes(ctx.FormString("body")), &opts)
if err != nil {
ctx.APIError(http.StatusBadRequest, "invalid body parameter")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("invalid body parameter"))
return
}
}

6
routers/api/v1/repo/fork.go
View File

@@ -105,7 +105,7 @@ func prepareDoerCreateRepoInOrg(ctx *context.APIContext, orgName string) *organi
return nil
}
if !canCreate {
ctx.APIError(http.StatusForbidden, "User is not allowed to create repositories in this organization.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("User is not allowed to create repositories in this organization."))
return nil
}
}
@@ -165,9 +165,9 @@ func CreateFork(ctx *context.APIContext) {
})
if err != nil {
if errors.Is(err, util.ErrAlreadyExist) || repo_model.IsErrReachLimitOfRepo(err) {
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
} else if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

34
routers/api/v1/repo/issue.go
View File

@@ -187,7 +187,7 @@ func SearchIssues(ctx *context.APIContext) {
before, since, err := context.GetQueryBeforeSince(ctx.Base)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
@@ -196,7 +196,7 @@ func SearchIssues(ctx *context.APIContext) {
repoIDs, allPublic, err := buildSearchIssuesRepoIDs(ctx)
if err != nil {
if errors.Is(err, util.ErrNotExist) || errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -384,7 +384,7 @@ func ListIssues(ctx *context.APIContext) {
// "$ref": "#/responses/notFound"
before, since, err := context.GetQueryBeforeSince(ctx.Base)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
@@ -661,7 +661,7 @@ func CreateIssue(ctx *context.APIContext) {
assigneeIDs, err = issues_model.MakeIDsFromAPIAssigneesToAdd(ctx, form.Assignee, form.Assignees)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Sprintf("Assignee does not exist: [name: %s]", err))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Sprintf("Assignee does not exist: [name: %s]", err)))
} else {
ctx.APIErrorInternal(err)
}
@@ -682,7 +682,7 @@ func CreateIssue(ctx *context.APIContext) {
return
}
if !valid {
ctx.APIError(http.StatusUnprocessableEntity, repo_model.ErrUserDoesNotHaveAccessToRepo{UserID: aID, RepoName: ctx.Repo.Repository.Name})
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(repo_model.ErrUserDoesNotHaveAccessToRepo{UserID: aID, RepoName: ctx.Repo.Repository.Name}))
return
}
}
@@ -693,9 +693,9 @@ func CreateIssue(ctx *context.APIContext) {
if err := issue_service.NewIssue(ctx, ctx.Repo.Repository, issue, form.Labels, nil, assigneeIDs, form.Projects); err != nil {
if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrPermissionDenied) || errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -705,7 +705,7 @@ func CreateIssue(ctx *context.APIContext) {
if form.Closed {
if err := issue_service.CloseIssue(ctx, issue, ctx.Doer, ""); err != nil {
if issues_model.IsErrDependenciesLeft(err) {
ctx.APIError(http.StatusPreconditionFailed, "cannot close this issue because it still has open dependencies")
ctx.APIError(http.StatusPreconditionFailed, ctx.APIErrorMessage("cannot close this issue because it still has open dependencies"))
return
}
ctx.APIErrorInternal(err)
@@ -794,7 +794,7 @@ func EditIssue(ctx *context.APIContext) {
// handles concurrent requests.
// TODO: wrap all mutations in a transaction to fully prevent partial writes.
if form.ContentVersion != nil && *form.ContentVersion != issue.ContentVersion {
ctx.APIError(http.StatusConflict, issues_model.ErrIssueAlreadyChanged)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(issues_model.ErrIssueAlreadyChanged))
return
}
@@ -813,7 +813,7 @@ func EditIssue(ctx *context.APIContext) {
err = issue_service.ChangeContent(ctx, issue, ctx.Doer, *form.Body, contentVersion)
if err != nil {
if errors.Is(err, issues_model.ErrIssueAlreadyChanged) {
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
return
}
@@ -835,7 +835,7 @@ func EditIssue(ctx *context.APIContext) {
if form.RemoveDeadline == nil || !*form.RemoveDeadline {
if form.Deadline == nil {
ctx.APIError(http.StatusBadRequest, "The due_date cannot be empty")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("The due_date cannot be empty"))
return
}
if !form.Deadline.IsZero() {
@@ -869,7 +869,7 @@ func EditIssue(ctx *context.APIContext) {
err = issue_service.UpdateAssignees(ctx, issue, oneAssignee, form.Assignees, ctx.Doer)
if err != nil {
if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -902,7 +902,7 @@ func EditIssue(ctx *context.APIContext) {
return
}
if issue.PullRequest.HasMerged {
ctx.APIError(http.StatusPreconditionFailed, "cannot change state of this pull request, it was already merged")
ctx.APIError(http.StatusPreconditionFailed, ctx.APIErrorMessage("cannot change state of this pull request, it was already merged"))
return
}
}
@@ -918,7 +918,7 @@ func EditIssue(ctx *context.APIContext) {
if canWrite && form.Projects != nil {
if err := issues_model.IssueAssignOrRemoveProject(ctx, issue, ctx.Doer, *form.Projects); err != nil {
if errors.Is(err, util.ErrPermissionDenied) || errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -1034,7 +1034,7 @@ func UpdateIssueDeadline(ctx *context.APIContext) {
}
if !ctx.Repo.Permission.CanWriteIssuesOrPulls(issue.IsPull) {
ctx.APIError(http.StatusForbidden, "Not repo writer")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Not repo writer"))
return
}
@@ -1049,14 +1049,14 @@ func UpdateIssueDeadline(ctx *context.APIContext) {
func closeOrReopenIssue(ctx *context.APIContext, issue *issues_model.Issue, state api.StateType) {
if state != api.StateOpen && state != api.StateClosed {
ctx.APIError(http.StatusPreconditionFailed, fmt.Sprintf("unknown state: %s", state))
ctx.APIError(http.StatusPreconditionFailed, ctx.APIErrorMessage(fmt.Sprintf("unknown state: %s", state)))
return
}
if state == api.StateClosed && !issue.IsClosed {
if err := issue_service.CloseIssue(ctx, issue, ctx.Doer, ""); err != nil {
if issues_model.IsErrDependenciesLeft(err) {
ctx.APIError(http.StatusPreconditionFailed, "cannot close this issue or pull request because it still has open dependencies")
ctx.APIError(http.StatusPreconditionFailed, ctx.APIErrorMessage("cannot close this issue or pull request because it still has open dependencies"))
return
}
ctx.APIErrorInternal(err)

8
routers/api/v1/repo/issue_attachment.go
View File

@@ -194,9 +194,9 @@ func CreateIssueAttachment(ctx *context.APIContext) {
})
if err != nil {
if upload.IsErrFileTypeForbidden(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrContentTooLarge) {
ctx.APIError(http.StatusRequestEntityTooLarge, err)
ctx.APIError(http.StatusRequestEntityTooLarge, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -272,7 +272,7 @@ func EditIssueAttachment(ctx *context.APIContext) {
if err := attachment_service.UpdateAttachment(ctx, setting.Attachment.AllowedTypes, attachment); err != nil {
if upload.IsErrFileTypeForbidden(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -373,7 +373,7 @@ func getIssueAttachmentSafeRead(ctx *context.APIContext, issue *issues_model.Iss
func canUserWriteIssueAttachment(ctx *context.APIContext, issue *issues_model.Issue) bool {
canEditIssue := ctx.IsSigned && (ctx.Doer.ID == issue.PosterID || ctx.IsUserRepoAdmin() || ctx.IsUserSiteAdmin() || ctx.Repo.Permission.CanWriteIssuesOrPulls(issue.IsPull))
if !canEditIssue {
ctx.APIError(http.StatusForbidden, "user should have permission to write issue")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should have permission to write issue"))
return false
}

12
routers/api/v1/repo/issue_comment.go
View File

@@ -65,7 +65,7 @@ func ListIssueComments(ctx *context.APIContext) {
before, since, err := context.GetQueryBeforeSince(ctx.Base)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.PathParamInt64("index"))
@@ -169,7 +169,7 @@ func ListIssueCommentsAndTimeline(ctx *context.APIContext) {
before, since, err := context.GetQueryBeforeSince(ctx.Base)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
issue, err := issues_model.GetIssueByIndex(ctx, ctx.Repo.Repository.ID, ctx.PathParamInt64("index"))
@@ -274,7 +274,7 @@ func ListRepoIssueComments(ctx *context.APIContext) {
before, since, err := context.GetQueryBeforeSince(ctx.Base)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
@@ -392,14 +392,14 @@ func CreateIssueComment(ctx *context.APIContext) {
}
if issue.IsLocked && !ctx.Repo.Permission.CanWriteIssuesOrPulls(issue.IsPull) && !ctx.Doer.IsAdmin {
ctx.APIError(http.StatusForbidden, errors.New(ctx.Locale.TrString("repo.issues.comment_on_locked")))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New(ctx.Locale.TrString("repo.issues.comment_on_locked"))))
return
}
comment, err := issue_service.CreateIssueComment(ctx, ctx.Doer, ctx.Repo.Repository, issue, form.Body, nil)
if err != nil {
if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -595,7 +595,7 @@ func editIssueComment(ctx *context.APIContext, form api.EditIssueCommentOption)
comment.Content = form.Body
if err := issue_service.UpdateComment(ctx, comment, comment.ContentVersion, ctx.Doer, oldContent); err != nil {
if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

12
routers/api/v1/repo/issue_comment_attachment.go
View File

@@ -202,9 +202,9 @@ func CreateIssueCommentAttachment(ctx *context.APIContext) {
})
if err != nil {
if upload.IsErrFileTypeForbidden(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrContentTooLarge) {
ctx.APIError(http.StatusRequestEntityTooLarge, err)
ctx.APIError(http.StatusRequestEntityTooLarge, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -218,7 +218,7 @@ func CreateIssueCommentAttachment(ctx *context.APIContext) {
if err = issue_service.UpdateComment(ctx, comment, comment.ContentVersion, ctx.Doer, comment.Content); err != nil {
if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -285,7 +285,7 @@ func EditIssueCommentAttachment(ctx *context.APIContext) {
if err := attachment_service.UpdateAttachment(ctx, setting.Attachment.AllowedTypes, attach); err != nil {
if upload.IsErrFileTypeForbidden(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -354,7 +354,7 @@ func getIssueCommentSafe(ctx *context.APIContext) *issues_model.Comment {
return nil
}
if comment.Issue == nil || comment.Issue.RepoID != ctx.Repo.Repository.ID {
ctx.APIError(http.StatusNotFound, "no matching issue comment found")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("no matching issue comment found"))
return nil
}
@@ -381,7 +381,7 @@ func getIssueCommentAttachmentSafeWrite(ctx *context.APIContext) *repo_model.Att
func canUserWriteIssueCommentAttachment(ctx *context.APIContext, comment *issues_model.Comment) bool {
canEditComment := ctx.IsSigned && (ctx.Doer.ID == comment.PosterID || ctx.IsUserRepoAdmin() || ctx.IsUserSiteAdmin()) && ctx.Repo.Permission.CanWriteIssuesOrPulls(comment.Issue.IsPull)
if !canEditComment {
ctx.APIError(http.StatusForbidden, "user should have permission to edit comment")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should have permission to edit comment"))
return false
}

8
routers/api/v1/repo/issue_label.go
View File

@@ -181,7 +181,7 @@ func DeleteIssueLabel(ctx *context.APIContext) {
label, err := issues_model.GetLabelByID(ctx, ctx.PathParamInt64("id"))
if err != nil {
if issues_model.IsErrLabelNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -320,7 +320,7 @@ func prepareForReplaceOrAdd(ctx *context.APIContext, form api.IssueLabelsOption)
}
if !ctx.Repo.Permission.CanWriteIssuesOrPulls(issue.IsPull) {
ctx.APIError(http.StatusForbidden, "write permission is required")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("write permission is required"))
return nil, nil, errors.New("permission denied")
}
@@ -336,12 +336,12 @@ func prepareForReplaceOrAdd(ctx *context.APIContext, form api.IssueLabelsOption)
case reflect.String:
labelNames = append(labelNames, rv.String())
default:
ctx.APIError(http.StatusBadRequest, "a label must be an integer or a string")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("a label must be an integer or a string"))
return nil, nil, errors.New("invalid label")
}
}
if len(labelIDs) > 0 && len(labelNames) > 0 {
ctx.APIError(http.StatusBadRequest, "labels should be an array of strings or integers")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("labels should be an array of strings or integers"))
return nil, nil, errors.New("invalid labels")
}
if len(labelNames) > 0 {

4
routers/api/v1/repo/issue_lock.go
View File

@@ -63,7 +63,7 @@ func LockIssue(ctx *context.APIContext) {
}
if !ctx.Repo.Permission.CanWriteIssuesOrPulls(issue.IsPull) {
ctx.APIError(http.StatusForbidden, errors.New("no permission to lock this issue"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("no permission to lock this issue")))
return
}
@@ -130,7 +130,7 @@ func UnlockIssue(ctx *context.APIContext) {
}
if !ctx.Repo.Permission.CanWriteIssuesOrPulls(issue.IsPull) {
ctx.APIError(http.StatusForbidden, errors.New("no permission to unlock this issue"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("no permission to unlock this issue")))
return
}

2
routers/api/v1/repo/issue_pin.go
View File

@@ -46,7 +46,7 @@ func PinIssue(ctx *context.APIContext) {
if issues_model.IsErrIssueNotExist(err) {
ctx.APIErrorNotFound()
} else if issues_model.IsErrIssueMaxPinReached(err) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

12
routers/api/v1/repo/issue_reaction.go
View File

@@ -72,7 +72,7 @@ func GetIssueCommentReactions(ctx *context.APIContext) {
}
if !ctx.Repo.Permission.CanReadIssuesOrPulls(comment.Issue.IsPull) {
ctx.APIError(http.StatusForbidden, errors.New("no permission to get reactions"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("no permission to get reactions")))
return
}
@@ -214,7 +214,7 @@ func changeIssueCommentReaction(ctx *context.APIContext, form api.EditReactionOp
}
if comment.Issue.IsLocked && !ctx.Repo.Permission.CanWriteIssuesOrPulls(comment.Issue.IsPull) {
ctx.APIError(http.StatusForbidden, errors.New("no permission to change reaction"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("no permission to change reaction")))
return
}
@@ -223,7 +223,7 @@ func changeIssueCommentReaction(ctx *context.APIContext, form api.EditReactionOp
reaction, err := issue_service.CreateCommentReaction(ctx, ctx.Doer, comment, form.Reaction)
if err != nil {
if issues_model.IsErrForbiddenIssueReaction(err) || errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else if issues_model.IsErrReactionAlreadyExist(err) {
ctx.JSON(http.StatusOK, api.Reaction{
User: convert.ToUser(ctx, ctx.Doer, ctx.Doer),
@@ -305,7 +305,7 @@ func GetIssueReactions(ctx *context.APIContext) {
}
if !ctx.Repo.Permission.CanReadIssuesOrPulls(issue.IsPull) {
ctx.APIError(http.StatusForbidden, errors.New("no permission to get reactions"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("no permission to get reactions")))
return
}
@@ -429,7 +429,7 @@ func changeIssueReaction(ctx *context.APIContext, form api.EditReactionOption, i
}
if issue.IsLocked && !ctx.Repo.Permission.CanWriteIssuesOrPulls(issue.IsPull) {
ctx.APIError(http.StatusForbidden, errors.New("no permission to change reaction"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("no permission to change reaction")))
return
}
@@ -438,7 +438,7 @@ func changeIssueReaction(ctx *context.APIContext, form api.EditReactionOption, i
reaction, err := issue_service.CreateIssueReaction(ctx, ctx.Doer, issue, form.Reaction)
if err != nil {
if issues_model.IsErrForbiddenIssueReaction(err) || errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else if issues_model.IsErrReactionAlreadyExist(err) {
ctx.JSON(http.StatusOK, api.Reaction{
User: convert.ToUser(ctx, ctx.Doer, ctx.Doer),

6
routers/api/v1/repo/issue_stopwatch.go
View File

@@ -57,7 +57,7 @@ func StartIssueStopwatch(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if !ok {
ctx.APIError(http.StatusConflict, "cannot start a stopwatch again if it already exists")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("cannot start a stopwatch again if it already exists"))
return
}
@@ -109,7 +109,7 @@ func StopIssueStopwatch(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if !ok {
ctx.APIError(http.StatusConflict, "cannot stop a non-existent stopwatch")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("cannot stop a non-existent stopwatch"))
return
}
ctx.Status(http.StatusCreated)
@@ -160,7 +160,7 @@ func DeleteIssueStopwatch(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if !ok {
ctx.APIError(http.StatusConflict, "cannot cancel a non-existent stopwatch")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("cannot cancel a non-existent stopwatch"))
return
}

2
routers/api/v1/repo/issue_subscription.go
View File

@@ -128,7 +128,7 @@ func setIssueSubscription(ctx *context.APIContext, watch bool) {
// only admin and user for itself can change subscription
if user.ID != ctx.Doer.ID && !ctx.Doer.IsAdmin {
ctx.APIError(http.StatusForbidden, fmt.Errorf("%s is not permitted to change subscriptions for %s", ctx.Doer.Name, user.Name))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(fmt.Errorf("%s is not permitted to change subscriptions for %s", ctx.Doer.Name, user.Name)))
return
}

24
routers/api/v1/repo/issue_tracked_time.go
View File

@@ -95,7 +95,7 @@ func ListTrackedTimes(ctx *context.APIContext) {
if qUser != "" {
user, err := user_model.GetUserByName(ctx, qUser)
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else if err != nil {
ctx.APIErrorInternal(err)
return
@@ -104,7 +104,7 @@ func ListTrackedTimes(ctx *context.APIContext) {
}
if opts.CreatedBeforeUnix, opts.CreatedAfterUnix, err = context.GetQueryBeforeSince(ctx.Base); err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
@@ -116,7 +116,7 @@ func ListTrackedTimes(ctx *context.APIContext) {
if opts.UserID == 0 {
opts.UserID = ctx.Doer.ID
} else {
ctx.APIError(http.StatusForbidden, errors.New("query by user not allowed; not enough rights"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("query by user not allowed; not enough rights")))
return
}
}
@@ -193,7 +193,7 @@ func AddTime(ctx *context.APIContext) {
if !ctx.Repo.CanUseTimetracker(ctx, issue, ctx.Doer) {
if !ctx.Repo.Repository.IsTimetrackerEnabled(ctx) {
ctx.APIError(http.StatusBadRequest, "time tracking disabled")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("time tracking disabled"))
return
}
ctx.Status(http.StatusForbidden)
@@ -286,7 +286,7 @@ func ResetIssueTime(ctx *context.APIContext) {
err = issues_model.DeleteIssueUserTimes(ctx, issue, ctx.Doer)
if err != nil {
if db.IsErrNotExist(err) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -419,7 +419,7 @@ func ListTrackedTimesByUser(ctx *context.APIContext) {
// "$ref": "#/responses/notFound"
if !ctx.Repo.Repository.IsTimetrackerEnabled(ctx) {
ctx.APIError(http.StatusBadRequest, "time tracking disabled")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("time tracking disabled"))
return
}
user, err := user_model.GetUserByName(ctx, ctx.PathParam("timetrackingusername"))
@@ -437,7 +437,7 @@ func ListTrackedTimesByUser(ctx *context.APIContext) {
}
if !ctx.IsUserRepoAdmin() && !ctx.Doer.IsAdmin && ctx.Doer.ID != user.ID {
ctx.APIError(http.StatusForbidden, errors.New("query by user not allowed; not enough rights"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("query by user not allowed; not enough rights")))
return
}
@@ -509,7 +509,7 @@ func ListTrackedTimesByRepository(ctx *context.APIContext) {
// "$ref": "#/responses/notFound"
if !ctx.Repo.Repository.IsTimetrackerEnabled(ctx) {
ctx.APIError(http.StatusBadRequest, "time tracking disabled")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("time tracking disabled"))
return
}
@@ -523,7 +523,7 @@ func ListTrackedTimesByRepository(ctx *context.APIContext) {
if qUser != "" {
user, err := user_model.GetUserByName(ctx, qUser)
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else if err != nil {
ctx.APIErrorInternal(err)
return
@@ -533,7 +533,7 @@ func ListTrackedTimesByRepository(ctx *context.APIContext) {
var err error
if opts.CreatedBeforeUnix, opts.CreatedAfterUnix, err = context.GetQueryBeforeSince(ctx.Base); err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
@@ -545,7 +545,7 @@ func ListTrackedTimesByRepository(ctx *context.APIContext) {
if opts.UserID == 0 {
opts.UserID = ctx.Doer.ID
} else {
ctx.APIError(http.StatusForbidden, errors.New("query by user not allowed; not enough rights"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("query by user not allowed; not enough rights")))
return
}
}
@@ -607,7 +607,7 @@ func ListMyTrackedTimes(ctx *context.APIContext) {
var err error
if opts.CreatedBeforeUnix, opts.CreatedAfterUnix, err = context.GetQueryBeforeSince(ctx.Base); err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}

16
routers/api/v1/repo/key.go
View File

@@ -175,11 +175,11 @@ func GetDeployKey(ctx *context.APIContext) {
// HandleCheckKeyStringError handle check key error
func HandleCheckKeyStringError(ctx *context.APIContext, err error) {
if db.IsErrSSHDisabled(err) {
ctx.APIError(http.StatusUnprocessableEntity, "SSH is disabled")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("SSH is disabled"))
} else if asymkey_model.IsErrKeyUnableVerify(err) {
ctx.APIError(http.StatusUnprocessableEntity, "Unable to verify key content")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Unable to verify key content"))
} else {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("Invalid key content: %w", err))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("Invalid key content: %w", err)))
}
}
@@ -187,13 +187,13 @@ func HandleCheckKeyStringError(ctx *context.APIContext, err error) {
func HandleAddKeyError(ctx *context.APIContext, err error) {
switch {
case asymkey_model.IsErrDeployKeyAlreadyExist(err):
ctx.APIError(http.StatusUnprocessableEntity, "This key has already been added to this repository")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("This key has already been added to this repository"))
case asymkey_model.IsErrKeyAlreadyExist(err):
ctx.APIError(http.StatusUnprocessableEntity, "Key content has been used as non-deploy key")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Key content has been used as non-deploy key"))
case asymkey_model.IsErrKeyNameAlreadyUsed(err):
ctx.APIError(http.StatusUnprocessableEntity, "Key title has been used")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Key title has been used"))
case asymkey_model.IsErrDeployKeyNameAlreadyUsed(err):
ctx.APIError(http.StatusUnprocessableEntity, "A key with the same name already exists")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("A key with the same name already exists"))
default:
ctx.APIErrorInternal(err)
}
@@ -281,7 +281,7 @@ func DeleteDeploykey(ctx *context.APIContext) {
if err := asymkey_service.DeleteDeployKey(ctx, ctx.Repo.Repository, ctx.PathParamInt64("id")); err != nil {
if asymkey_model.IsErrKeyAccessDenied(err) {
ctx.APIError(http.StatusForbidden, "You do not have access to this key")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("You do not have access to this key"))
} else {
ctx.APIErrorInternal(err)
}

4
routers/api/v1/repo/label.go
View File

@@ -153,7 +153,7 @@ func CreateLabel(ctx *context.APIContext) {
color, err := label.NormalizeColor(form.Color)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
form.Color = color
@@ -231,7 +231,7 @@ func EditLabel(ctx *context.APIContext) {
if form.Color != nil {
color, err := label.NormalizeColor(*form.Color)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
l.Color = color

42
routers/api/v1/repo/migrate.go
View File

@@ -72,7 +72,7 @@ func Migrate(ctx *context.APIContext) {
}
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -81,7 +81,7 @@ func Migrate(ctx *context.APIContext) {
if !ctx.Doer.IsAdmin {
if !repoOwner.IsOrganization() && ctx.Doer.ID != repoOwner.ID {
ctx.APIError(http.StatusForbidden, "Given user is not an organization.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Given user is not an organization."))
return
}
@@ -92,7 +92,7 @@ func Migrate(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if !isOwner {
ctx.APIError(http.StatusForbidden, "Given user is not owner of organization.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Given user is not owner of organization."))
return
}
}
@@ -110,12 +110,12 @@ func Migrate(ctx *context.APIContext) {
gitServiceType := convert.ToGitServiceType(form.Service)
if form.Mirror && setting.Mirror.DisableNewPull {
ctx.APIError(http.StatusForbidden, errors.New("the site administrator has disabled the creation of new pull mirrors"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("the site administrator has disabled the creation of new pull mirrors")))
return
}
if setting.Repository.DisableMigrations {
ctx.APIError(http.StatusForbidden, errors.New("the site administrator has disabled migrations"))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(errors.New("the site administrator has disabled migrations")))
return
}
@@ -219,33 +219,33 @@ func Migrate(ctx *context.APIContext) {
func handleMigrateError(ctx *context.APIContext, repoOwner *user_model.User, err error) {
switch {
case repo_model.IsErrRepoAlreadyExist(err):
ctx.APIError(http.StatusConflict, "The repository with the same name already exists.")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("The repository with the same name already exists."))
case repo_model.IsErrRepoFilesAlreadyExist(err):
ctx.APIError(http.StatusConflict, "Files already exist for this repository. Adopt them or delete them.")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("Files already exist for this repository. Adopt them or delete them."))
case migrations.IsRateLimitError(err):
ctx.APIError(http.StatusUnprocessableEntity, "Remote visit addressed rate limitation.")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Remote visit addressed rate limitation."))
case migrations.IsTwoFactorAuthError(err):
ctx.APIError(http.StatusUnprocessableEntity, "Remote visit required two factors authentication.")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Remote visit required two factors authentication."))
case repo_model.IsErrReachLimitOfRepo(err):
ctx.APIError(http.StatusUnprocessableEntity, fmt.Sprintf("You have already reached your limit of %d repositories.", repoOwner.MaxCreationLimit()))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Sprintf("You have already reached your limit of %d repositories.", repoOwner.MaxCreationLimit())))
case db.IsErrNameReserved(err):
ctx.APIError(http.StatusUnprocessableEntity, fmt.Sprintf("The username '%s' is reserved.", err.(db.ErrNameReserved).Name))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Sprintf("The username '%s' is reserved.", err.(db.ErrNameReserved).Name)))
case db.IsErrNameCharsNotAllowed(err):
ctx.APIError(http.StatusUnprocessableEntity, fmt.Sprintf("The username '%s' contains invalid characters.", err.(db.ErrNameCharsNotAllowed).Name))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Sprintf("The username '%s' contains invalid characters.", err.(db.ErrNameCharsNotAllowed).Name)))
case db.IsErrNamePatternNotAllowed(err):
ctx.APIError(http.StatusUnprocessableEntity, fmt.Sprintf("The pattern '%s' is not allowed in a username.", err.(db.ErrNamePatternNotAllowed).Pattern))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Sprintf("The pattern '%s' is not allowed in a username.", err.(db.ErrNamePatternNotAllowed).Pattern)))
case git.IsErrInvalidCloneAddr(err):
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
case base.IsErrNotSupported(err):
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
default:
err = util.SanitizeErrorCredentialURLs(err)
if strings.Contains(err.Error(), "Authentication failed") ||
strings.Contains(err.Error(), "Bad credentials") ||
strings.Contains(err.Error(), "could not read Username") {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Sprintf("Authentication failed: %v.", err))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Sprintf("Authentication failed: %v.", err)))
} else if strings.Contains(err.Error(), "fatal:") {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Sprintf("Migration failed: %v.", err))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Sprintf("Migration failed: %v.", err)))
} else {
ctx.APIErrorInternal(err)
}
@@ -257,15 +257,15 @@ func handleRemoteAddrError(ctx *context.APIContext, err error) {
addrErr := err.(*git.ErrInvalidCloneAddr)
switch {
case addrErr.IsURLError:
ctx.APIError(http.StatusUnprocessableEntity, "The provided URL is invalid.")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("The provided URL is invalid."))
case addrErr.IsPermissionDenied:
if addrErr.LocalPath {
ctx.APIError(http.StatusUnprocessableEntity, "You are not allowed to import local repositories.")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("You are not allowed to import local repositories."))
} else {
ctx.APIError(http.StatusUnprocessableEntity, "You can not import from disallowed hosts.")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("You can not import from disallowed hosts."))
}
case addrErr.IsInvalidPath:
ctx.APIError(http.StatusUnprocessableEntity, "Invalid local path, it does not exist or not a directory.")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Invalid local path, it does not exist or not a directory."))
default:
ctx.APIErrorInternal(fmt.Errorf("unknown error type (ErrInvalidCloneAddr): %w", err))
}

36
routers/api/v1/repo/mirror.go
View File

@@ -53,17 +53,17 @@ func MirrorSync(ctx *context.APIContext) {
repo := ctx.Repo.Repository
if !ctx.Repo.Permission.CanWrite(unit.TypeCode) {
ctx.APIError(http.StatusForbidden, "Must have write access")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Must have write access"))
}
if !setting.Mirror.Enabled {
ctx.APIError(http.StatusBadRequest, "Mirror feature is disabled")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Mirror feature is disabled"))
return
}
if _, err := repo_model.GetMirrorByRepoID(ctx, repo.ID); err != nil {
if errors.Is(err, repo_model.ErrMirrorNotExist) {
ctx.APIError(http.StatusBadRequest, "Repository is not a mirror")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Repository is not a mirror"))
return
}
ctx.APIErrorInternal(err)
@@ -106,13 +106,13 @@ func PushMirrorSync(ctx *context.APIContext) {
// "$ref": "#/responses/validationError"
if !setting.Mirror.Enabled {
ctx.APIError(http.StatusBadRequest, "Mirror feature is disabled")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Mirror feature is disabled"))
return
}
// Get All push mirrors of a specific repo
pushMirrors, _, err := repo_model.GetPushMirrorsByRepoID(ctx, ctx.Repo.Repository.ID, db.ListOptions{})
if err != nil {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
return
}
@@ -124,7 +124,7 @@ func PushMirrorSync(ctx *context.APIContext) {
}
}
if len(failedPushMirrors) != 0 {
ctx.APIError(http.StatusUnprocessableEntity, "error occurred when syncing push mirrors: "+strings.Join(failedPushMirrors, ", "))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("error occurred when syncing push mirrors: "+strings.Join(failedPushMirrors, ", ")))
return
}
ctx.Status(http.StatusOK)
@@ -167,7 +167,7 @@ func ListPushMirrors(ctx *context.APIContext) {
// "$ref": "#/responses/notFound"
if !setting.Mirror.Enabled {
ctx.APIError(http.StatusBadRequest, "Mirror feature is disabled")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Mirror feature is disabled"))
return
}
@@ -175,7 +175,7 @@ func ListPushMirrors(ctx *context.APIContext) {
// Get all push mirrors for the specified repository.
pushMirrors, count, err := repo_model.GetPushMirrorsByRepoID(ctx, repo.ID, utils.GetListOptions(ctx))
if err != nil {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
return
}
@@ -225,7 +225,7 @@ func GetPushMirrorByName(ctx *context.APIContext) {
// "$ref": "#/responses/notFound"
if !setting.Mirror.Enabled {
ctx.APIError(http.StatusBadRequest, "Mirror feature is disabled")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Mirror feature is disabled"))
return
}
@@ -239,7 +239,7 @@ func GetPushMirrorByName(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if !exist {
ctx.APIError(http.StatusNotFound, nil)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(nil))
return
}
@@ -286,7 +286,7 @@ func AddPushMirror(ctx *context.APIContext) {
// "$ref": "#/responses/notFound"
if !setting.Mirror.Enabled {
ctx.APIError(http.StatusBadRequest, "Mirror feature is disabled")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Mirror feature is disabled"))
return
}
@@ -326,7 +326,7 @@ func DeletePushMirrorByRemoteName(ctx *context.APIContext) {
// "$ref": "#/responses/error"
if !setting.Mirror.Enabled {
ctx.APIError(http.StatusBadRequest, "Mirror feature is disabled")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Mirror feature is disabled"))
return
}
@@ -334,7 +334,7 @@ func DeletePushMirrorByRemoteName(ctx *context.APIContext) {
// Delete push mirror on repo by name.
err := repo_model.DeletePushMirrors(ctx, repo_model.PushMirrorOptions{RepoID: ctx.Repo.Repository.ID, RemoteName: remoteName})
if err != nil {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
return
}
ctx.Status(http.StatusNoContent)
@@ -345,7 +345,7 @@ func CreatePushMirror(ctx *context.APIContext, mirrorOption *api.CreatePushMirro
interval, err := time.ParseDuration(mirrorOption.Interval)
if err != nil || (interval != 0 && interval < setting.Mirror.MinInterval) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}
@@ -402,13 +402,13 @@ func HandleRemoteAddressError(ctx *context.APIContext, err error) {
addrErr := err.(*git.ErrInvalidCloneAddr)
switch {
case addrErr.IsProtocolInvalid:
ctx.APIError(http.StatusBadRequest, "Invalid mirror protocol")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Invalid mirror protocol"))
case addrErr.IsURLError:
ctx.APIError(http.StatusBadRequest, "Invalid Url ")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Invalid Url "))
case addrErr.IsPermissionDenied:
ctx.APIError(http.StatusUnauthorized, "Permission denied")
ctx.APIError(http.StatusUnauthorized, ctx.APIErrorMessage("Permission denied"))
default:
ctx.APIError(http.StatusBadRequest, "Unknown error")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Unknown error"))
}
return
}

2
routers/api/v1/repo/notes.go
View File

@@ -54,7 +54,7 @@ func GetNote(ctx *context.APIContext) {
sha := ctx.PathParam("sha")
if !git.IsValidRefPattern(sha) {
ctx.APIError(http.StatusUnprocessableEntity, "no valid ref or sha: "+sha)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("no valid ref or sha: "+sha))
return
}
getNote(ctx, sha)

84
routers/api/v1/repo/pull.go
View File

@@ -126,7 +126,7 @@ func ListPullRequests(ctx *context.APIContext) {
poster, err := user_model.GetUserByName(ctx, posterStr)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -407,7 +407,7 @@ func CreatePullRequest(ctx *context.APIContext) {
form := *web.GetForm(ctx).(*api.CreatePullRequestOption)
if form.Head == form.Base {
ctx.APIError(http.StatusUnprocessableEntity, "Invalid PullRequest: There are no changes between the head and the base")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Invalid PullRequest: There are no changes between the head and the base"))
return
}
@@ -425,7 +425,7 @@ func CreatePullRequest(ctx *context.APIContext) {
defer closer()
if !compareResult.BaseRef.IsBranch() || !compareResult.HeadRef.IsBranch() {
ctx.APIError(http.StatusUnprocessableEntity, "Invalid PullRequest: base and head must be branches")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Invalid PullRequest: base and head must be branches"))
return
}
@@ -448,7 +448,7 @@ func CreatePullRequest(ctx *context.APIContext) {
HeadBranch: existingPr.HeadBranch,
BaseBranch: existingPr.BaseBranch,
}
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
return
}
@@ -531,7 +531,7 @@ func CreatePullRequest(ctx *context.APIContext) {
assigneeIDs, err := issues_model.MakeIDsFromAPIAssigneesToAdd(ctx, form.Assignee, form.Assignees)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Sprintf("Assignee does not exist: [name: %s]", err))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Sprintf("Assignee does not exist: [name: %s]", err)))
} else {
ctx.APIErrorInternal(err)
}
@@ -551,7 +551,7 @@ func CreatePullRequest(ctx *context.APIContext) {
return
}
if !valid {
ctx.APIError(http.StatusUnprocessableEntity, repo_model.ErrUserDoesNotHaveAccessToRepo{UserID: aID, RepoName: repo.Name})
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(repo_model.ErrUserDoesNotHaveAccessToRepo{UserID: aID, RepoName: repo.Name}))
return
}
}
@@ -570,11 +570,11 @@ func CreatePullRequest(ctx *context.APIContext) {
if err := pull_service.NewPullRequest(ctx, prOpts); err != nil {
if repo_model.IsErrUserDoesNotHaveAccessToRepo(err) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else if errors.Is(err, issues_model.ErrMustCollaborator) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -663,7 +663,7 @@ func EditPullRequest(ctx *context.APIContext) {
// handles concurrent requests.
// TODO: wrap all mutations in a transaction to fully prevent partial writes.
if form.ContentVersion != nil && *form.ContentVersion != issue.ContentVersion {
ctx.APIError(http.StatusConflict, issues_model.ErrIssueAlreadyChanged)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(issues_model.ErrIssueAlreadyChanged))
return
}
@@ -682,7 +682,7 @@ func EditPullRequest(ctx *context.APIContext) {
err = issue_service.ChangeContent(ctx, issue, ctx.Doer, *form.Body, contentVersion)
if err != nil {
if errors.Is(err, issues_model.ErrIssueAlreadyChanged) {
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
return
}
@@ -719,9 +719,9 @@ func EditPullRequest(ctx *context.APIContext) {
err = issue_service.UpdateAssignees(ctx, issue, form.Assignee, form.Assignees, ctx.Doer)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Sprintf("Assignee does not exist: [name: %s]", err))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Sprintf("Assignee does not exist: [name: %s]", err)))
} else if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -769,7 +769,7 @@ func EditPullRequest(ctx *context.APIContext) {
if form.State != nil {
if pr.HasMerged {
ctx.APIError(http.StatusPreconditionFailed, "cannot change state of this pull request, it was already merged")
ctx.APIError(http.StatusPreconditionFailed, ctx.APIErrorMessage("cannot change state of this pull request, it was already merged"))
return
}
@@ -788,18 +788,18 @@ func EditPullRequest(ctx *context.APIContext) {
return
}
if !branchExist {
ctx.APIError(http.StatusNotFound, fmt.Errorf("new base '%s' not exist", form.Base))
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(fmt.Errorf("new base '%s' not exist", form.Base)))
return
}
if err := pull_service.ChangeTargetBranch(ctx, pr, ctx.Doer, form.Base); err != nil {
if issues_model.IsErrPullRequestAlreadyExists(err) {
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
return
} else if issues_model.IsErrIssueIsClosed(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
} else if pull_service.IsErrPullRequestHasMerged(err) {
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -812,7 +812,7 @@ func EditPullRequest(ctx *context.APIContext) {
if form.AllowMaintainerEdit != nil {
if err := pull_service.SetAllowEdits(ctx, ctx.Doer, pr, *form.AllowMaintainerEdit); err != nil {
if errors.Is(err, pull_service.ErrUserHasNoPermissionForAction) {
ctx.APIError(http.StatusForbidden, fmt.Sprintf("SetAllowEdits: %s", err))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(fmt.Sprintf("SetAllowEdits: %s", err)))
return
}
ctx.APIErrorInternal(err)
@@ -969,19 +969,19 @@ func MergePullRequest(ctx *context.APIContext) {
if errors.Is(err, pull_service.ErrIsClosed) {
ctx.APIErrorNotFound()
} else if errors.Is(err, pull_service.ErrNoPermissionToMerge) {
ctx.APIError(http.StatusMethodNotAllowed, "User not allowed to merge PR")
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage("User not allowed to merge PR"))
} else if errors.Is(err, pull_service.ErrHasMerged) {
ctx.APIError(http.StatusMethodNotAllowed, "The PR is already merged")
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage("The PR is already merged"))
} else if errors.Is(err, pull_service.ErrIsWorkInProgress) {
ctx.APIError(http.StatusMethodNotAllowed, "Work in progress PRs cannot be merged")
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage("Work in progress PRs cannot be merged"))
} else if errors.Is(err, pull_service.ErrNotMergeableState) {
ctx.APIError(http.StatusMethodNotAllowed, "Please try again later")
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage("Please try again later"))
} else if errors.Is(err, pull_service.ErrNotReadyToMerge) {
ctx.APIError(http.StatusMethodNotAllowed, err)
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage(err))
} else if asymkey_service.IsErrWontSign(err) {
ctx.APIError(http.StatusMethodNotAllowed, err)
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage(err))
} else if errors.Is(err, pull_service.ErrHeadCommitsNotAllVerified) {
ctx.APIError(http.StatusMethodNotAllowed, err)
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -992,11 +992,11 @@ func MergePullRequest(ctx *context.APIContext) {
if manuallyMerged {
if err := pull_service.MergedManually(ctx, pr, ctx.Doer, ctx.Repo.GitRepo, form.MergeCommitID); err != nil {
if pull_service.IsErrInvalidMergeStyle(err) {
ctx.APIError(http.StatusMethodNotAllowed, fmt.Errorf("%s is not allowed an allowed merge style for this repository", repo_model.MergeStyle(form.Do)))
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage(fmt.Errorf("%s is not allowed an allowed merge style for this repository", repo_model.MergeStyle(form.Do))))
return
}
if strings.Contains(err.Error(), "Wrong commit ID") {
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1034,7 +1034,7 @@ func MergePullRequest(ctx *context.APIContext) {
scheduled, err := automerge.ScheduleAutoMerge(ctx, ctx.Doer, pr, repo_model.MergeStyle(form.Do), message, deleteBranchAfterMerge)
if err != nil {
if pull_model.IsErrAlreadyScheduledToAutoMerge(err) {
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1048,7 +1048,7 @@ func MergePullRequest(ctx *context.APIContext) {
if err := pull_service.Merge(ctx, pr, ctx.Doer, repo_model.MergeStyle(form.Do), form.HeadCommitID, message, false); err != nil {
if pull_service.IsErrInvalidMergeStyle(err) {
ctx.APIError(http.StatusMethodNotAllowed, fmt.Errorf("%s is not allowed an allowed merge style for this repository", repo_model.MergeStyle(form.Do)))
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage(fmt.Errorf("%s is not allowed an allowed merge style for this repository", repo_model.MergeStyle(form.Do))))
} else if pull_service.IsErrMergeConflicts(err) {
conflictError := err.(pull_service.ErrMergeConflicts)
ctx.JSON(http.StatusConflict, conflictError)
@@ -1059,15 +1059,15 @@ func MergePullRequest(ctx *context.APIContext) {
conflictError := err.(pull_service.ErrMergeUnrelatedHistories)
ctx.JSON(http.StatusConflict, conflictError)
} else if git.IsErrPushOutOfDate(err) {
ctx.APIError(http.StatusConflict, "merge push out of date")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("merge push out of date"))
} else if pull_service.IsErrSHADoesNotMatch(err) {
ctx.APIError(http.StatusConflict, "head out of date")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("head out of date"))
} else if git.IsErrPushRejected(err) {
errPushRej := err.(*git.ErrPushRejected)
if len(errPushRej.Message) == 0 {
ctx.APIError(http.StatusConflict, "PushRejected without remote error message")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("PushRejected without remote error message"))
} else {
ctx.APIError(http.StatusConflict, "PushRejected with remote message: "+errPushRej.Message)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("PushRejected with remote message: "+errPushRej.Message))
}
} else {
ctx.APIErrorInternal(err)
@@ -1093,14 +1093,14 @@ func parseCompareInfo(ctx *context.APIContext, compareParam string) (result *git
// remove the check when we support compare with carets
if compareReq.BaseOriRefSuffix != "" {
ctx.APIError(http.StatusBadRequest, "Unsupported comparison syntax: ref with suffix")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Unsupported comparison syntax: ref with suffix"))
return nil, nil
}
_, headRepo, err := common.GetHeadOwnerAndRepo(ctx, baseRepo, compareReq)
switch {
case errors.Is(err, util.ErrInvalidArgument):
ctx.APIError(http.StatusBadRequest, err.Error())
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err.Error()))
return nil, nil
case errors.Is(err, util.ErrNotExist):
ctx.APIErrorNotFound()
@@ -1230,7 +1230,7 @@ func UpdatePullRequest(ctx *context.APIContext) {
}
if pr.HasMerged {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
@@ -1240,7 +1240,7 @@ func UpdatePullRequest(ctx *context.APIContext) {
}
if pr.Issue.IsClosed {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
@@ -1273,10 +1273,10 @@ func UpdatePullRequest(ctx *context.APIContext) {
if err = pull_service.Update(graceful.GetManager().ShutdownContext(), pr, ctx.Doer, message, rebase); err != nil {
if pull_service.IsErrMergeConflicts(err) {
ctx.APIError(http.StatusConflict, "merge failed because of conflict")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("merge failed because of conflict"))
return
} else if pull_service.IsErrRebaseConflicts(err) {
ctx.APIError(http.StatusConflict, "rebase failed because of conflict")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("rebase failed because of conflict"))
return
}
ctx.APIErrorInternal(err)
@@ -1348,7 +1348,7 @@ func CancelScheduledAutoMerge(ctx *context.APIContext) {
return
}
if !allowed {
ctx.APIError(http.StatusForbidden, "user has no permission to cancel the scheduled auto merge")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user has no permission to cancel the scheduled auto merge"))
return
}
}
@@ -1436,7 +1436,7 @@ func GetPullRequestCommits(ctx *context.APIContext) {
}
if gitcmd.IsStderr(err, gitcmd.StderrBadRevision) {
ctx.APIError(http.StatusNotFound, "invalid base branch or revision")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("invalid base branch or revision"))
return
} else if err != nil {
ctx.APIErrorInternal(err)

40
routers/api/v1/repo/pull_review.go
View File

@@ -267,7 +267,7 @@ func CreatePullReviewCommentReply(ctx *context.APIContext) {
return
}
if parent.ReviewID == 0 {
ctx.APIError(http.StatusBadRequest, "comment is not a review comment")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("comment is not a review comment"))
return
}
@@ -374,7 +374,7 @@ func updatePullReviewCommentResolve(ctx *context.APIContext, isResolve bool) {
return
}
if !canMarkConv {
ctx.APIError(http.StatusForbidden, "user should have permission to resolve comment")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user should have permission to resolve comment"))
return
}
@@ -398,12 +398,12 @@ func getPullReviewCommentToResolve(ctx *context.APIContext) *issues_model.Commen
}
if !comment.Issue.IsPull {
ctx.APIError(http.StatusBadRequest, "comment does not belong to a pull request")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("comment does not belong to a pull request"))
return nil
}
if comment.Type != issues_model.CommentTypeCode {
ctx.APIError(http.StatusBadRequest, "comment is not a review comment")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("comment is not a review comment"))
return nil
}
@@ -458,7 +458,7 @@ func DeletePullReview(ctx *context.APIContext) {
return
}
if !ctx.Doer.IsAdmin && ctx.Doer.ID != review.ReviewerID {
ctx.APIError(http.StatusForbidden, nil)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(nil))
return
}
@@ -575,7 +575,7 @@ func CreatePullReview(ctx *context.APIContext) {
review, _, err := pull_service.SubmitReview(ctx, ctx.Doer, ctx.Repo.GitRepo, pr.Issue, reviewType, opts.Body, opts.CommitID, nil)
if err != nil {
if errors.Is(err, pull_service.ErrSubmitReviewOnClosedPR) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -641,7 +641,7 @@ func SubmitPullReview(ctx *context.APIContext) {
}
if review.Type != issues_model.ReviewTypePending {
ctx.APIError(http.StatusUnprocessableEntity, errors.New("only a pending review can be submitted"))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(errors.New("only a pending review can be submitted")))
return
}
@@ -653,7 +653,7 @@ func SubmitPullReview(ctx *context.APIContext) {
// if review stay pending return
if reviewType == issues_model.ReviewTypePending {
ctx.APIError(http.StatusUnprocessableEntity, errors.New("review stay pending"))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(errors.New("review stay pending")))
return
}
@@ -667,7 +667,7 @@ func SubmitPullReview(ctx *context.APIContext) {
review, _, err = pull_service.SubmitReview(ctx, ctx.Doer, ctx.Repo.GitRepo, pr.Issue, reviewType, opts.Body, headCommitID, nil)
if err != nil {
if errors.Is(err, pull_service.ErrSubmitReviewOnClosedPR) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -698,7 +698,7 @@ func preparePullReviewType(ctx *context.APIContext, pr *issues_model.PullRequest
case api.ReviewStateApproved:
// can not approve your own PR
if pr.Issue.IsPoster(ctx.Doer.ID) {
ctx.APIError(http.StatusUnprocessableEntity, errors.New("approve your own pull is not allowed"))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(errors.New("approve your own pull is not allowed")))
return -1, true
}
reviewType = issues_model.ReviewTypeApprove
@@ -707,7 +707,7 @@ func preparePullReviewType(ctx *context.APIContext, pr *issues_model.PullRequest
case api.ReviewStateRequestChanges:
// can not reject your own PR
if pr.Issue.IsPoster(ctx.Doer.ID) {
ctx.APIError(http.StatusUnprocessableEntity, errors.New("reject your own pull is not allowed"))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(errors.New("reject your own pull is not allowed")))
return -1, true
}
reviewType = issues_model.ReviewTypeReject
@@ -717,7 +717,7 @@ func preparePullReviewType(ctx *context.APIContext, pr *issues_model.PullRequest
needsBody = false
// if there is no body we need to ensure that there are comments
if !hasBody && !hasComments {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("review event %s requires a body or a comment", event))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("review event %s requires a body or a comment", event)))
return -1, true
}
default:
@@ -726,7 +726,7 @@ func preparePullReviewType(ctx *context.APIContext, pr *issues_model.PullRequest
// reject reviews with empty body if a body is required for this call
if needsBody && !hasBody {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("review event %s requires a body", event))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("review event %s requires a body", event)))
return -1, true
}
@@ -935,11 +935,11 @@ func apiReviewRequest(ctx *context.APIContext, opts api.PullReviewRequestOptions
comment, err := issue_service.ReviewRequest(ctx, pr.Issue, ctx.Doer, &permDoer, reviewer, isAdd)
if err != nil {
if issues_model.IsErrReviewRequestOnClosedPR(err) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
return
}
if issues_model.IsErrNotValidReviewRequest(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -960,11 +960,11 @@ func apiReviewRequest(ctx *context.APIContext, opts api.PullReviewRequestOptions
comment, err := issue_service.TeamReviewRequest(ctx, pr.Issue, ctx.Doer, teamReviewer, isAdd)
if err != nil {
if issues_model.IsErrReviewRequestOnClosedPR(err) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
return
}
if issues_model.IsErrNotValidReviewRequest(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -1086,7 +1086,7 @@ func UnDismissPullReview(ctx *context.APIContext) {
func dismissReview(ctx *context.APIContext, msg string, isDismiss, dismissPriors bool) {
if !ctx.Repo.Permission.IsAdmin() {
ctx.APIError(http.StatusForbidden, "Must be repo admin")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Must be repo admin"))
return
}
review, _, isWrong := prepareSingleReview(ctx)
@@ -1095,14 +1095,14 @@ func dismissReview(ctx *context.APIContext, msg string, isDismiss, dismissPriors
}
if review.Type != issues_model.ReviewTypeApprove && review.Type != issues_model.ReviewTypeReject {
ctx.APIError(http.StatusForbidden, "not need to dismiss this review because it's type is not Approve or change request")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("not need to dismiss this review because it's type is not Approve or change request"))
return
}
_, err := pull_service.DismissReview(ctx, review.ID, ctx.Repo.Repository.ID, msg, ctx.Doer, isDismiss, dismissPriors)
if err != nil {
if pull_service.IsErrDismissRequestOnClosedPR(err) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)

12
routers/api/v1/repo/release.go
View File

@@ -243,7 +243,7 @@ func CreateRelease(ctx *context.APIContext) {
form := web.GetForm(ctx).(*api.CreateReleaseOption)
if ctx.Repo.Repository.IsEmpty {
ctx.APIError(http.StatusUnprocessableEntity, errors.New("repo is empty"))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(errors.New("repo is empty")))
return
}
rel, err := repo_model.GetRelease(ctx, ctx.Repo.Repository.ID, form.TagName)
@@ -273,11 +273,11 @@ func CreateRelease(ctx *context.APIContext) {
// It doesn't need to be the same as the "release note"
if err := release_service.CreateRelease(ctx.Repo.GitRepo, rel, nil, form.TagMessage); err != nil {
if repo_model.IsErrReleaseAlreadyExist(err) {
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
} else if release_service.IsErrProtectedTagName(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else if git.IsErrNotExist(err) {
ctx.APIError(http.StatusNotFound, fmt.Errorf("target \"%v\" not found: %w", rel.Target, err))
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(fmt.Errorf("target \"%v\" not found: %w", rel.Target, err)))
} else {
ctx.APIErrorInternal(err)
}
@@ -285,7 +285,7 @@ func CreateRelease(ctx *context.APIContext) {
}
} else {
if !rel.IsTag {
ctx.APIError(http.StatusConflict, "Release is has no Tag")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("Release is has no Tag"))
return
}
@@ -433,7 +433,7 @@ func DeleteRelease(ctx *context.APIContext) {
}
if err := release_service.DeleteReleaseByID(ctx, ctx.Repo.Repository, rel, ctx.Doer, false); err != nil {
if release_service.IsErrProtectedTagName(err) {
ctx.APIError(http.StatusUnprocessableEntity, "user not allowed to delete protected tag")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("user not allowed to delete protected tag"))
return
}
ctx.APIErrorInternal(err)

8
routers/api/v1/repo/release_attachment.go
View File

@@ -237,7 +237,7 @@ func CreateReleaseAttachment(ctx *context.APIContext) {
}
if filename == "" {
ctx.APIError(http.StatusBadRequest, "Could not determine name of attachment.")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Could not determine name of attachment."))
return
}
@@ -250,12 +250,12 @@ func CreateReleaseAttachment(ctx *context.APIContext) {
})
if err != nil {
if upload.IsErrFileTypeForbidden(err) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}
if errors.Is(err, util.ErrContentTooLarge) {
ctx.APIError(http.StatusRequestEntityTooLarge, err)
ctx.APIError(http.StatusRequestEntityTooLarge, ctx.APIErrorMessage(err))
return
}
@@ -340,7 +340,7 @@ func EditReleaseAttachment(ctx *context.APIContext) {
if err := attachment_service.UpdateAttachment(ctx, setting.Repository.Release.AllowedTypes, attach); err != nil {
if upload.IsErrFileTypeForbidden(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)

2
routers/api/v1/repo/release_tags.go
View File

@@ -121,7 +121,7 @@ func DeleteReleaseByTag(ctx *context.APIContext) {
if err = release_service.DeleteReleaseByID(ctx, ctx.Repo.Repository, release, ctx.Doer, false); err != nil {
if release_service.IsErrProtectedTagName(err) {
ctx.APIError(http.StatusUnprocessableEntity, "user not allowed to delete protected tag")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("user not allowed to delete protected tag"))
return
}
ctx.APIErrorInternal(err)

54
routers/api/v1/repo/repo.go
View File

@@ -173,7 +173,7 @@ func Search(ctx *context.APIContext) {
opts.Collaborate = optional.Some(true)
case "":
default:
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("Invalid search mode: \"%s\"", mode))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("Invalid search mode: \"%s\"", mode)))
return
}
@@ -234,7 +234,7 @@ func CreateUserRepo(ctx *context.APIContext, owner *user_model.User, opt api.Cre
// If the readme template does not exist, a 400 will be returned.
if opt.AutoInit && len(opt.Readme) > 0 && !slices.Contains(repo_module.Readmes, opt.Readme) {
ctx.APIError(http.StatusBadRequest, fmt.Errorf("readme template does not exist, available templates: %v", repo_module.Readmes))
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(fmt.Errorf("readme template does not exist, available templates: %v", repo_module.Readmes)))
return
}
@@ -254,13 +254,13 @@ func CreateUserRepo(ctx *context.APIContext, owner *user_model.User, opt api.Cre
})
if err != nil {
if repo_model.IsErrRepoAlreadyExist(err) {
ctx.APIError(http.StatusConflict, "The repository with the same name already exists.")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("The repository with the same name already exists."))
} else if db.IsErrNameReserved(err) ||
db.IsErrNamePatternNotAllowed(err) ||
label.IsErrTemplateLoad(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrPermissionDenied) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -302,7 +302,7 @@ func Create(ctx *context.APIContext) {
opt := web.GetForm(ctx).(*api.CreateRepoOption)
if ctx.Doer.IsOrganization() {
// Shouldn't reach this condition, but just in case.
ctx.APIError(http.StatusUnprocessableEntity, "not allowed creating repository for organization")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("not allowed creating repository for organization"))
return
}
CreateUserRepo(ctx, ctx.Doer, *opt)
@@ -346,12 +346,12 @@ func Generate(ctx *context.APIContext) {
form := web.GetForm(ctx).(*api.GenerateRepoOption)
if !ctx.Repo.Repository.IsTemplate {
ctx.APIError(http.StatusUnprocessableEntity, "this is not a template repo")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("this is not a template repo"))
return
}
if ctx.Doer.IsOrganization() {
ctx.APIError(http.StatusUnprocessableEntity, "not allowed creating repository for organization")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("not allowed creating repository for organization"))
return
}
@@ -370,7 +370,7 @@ func Generate(ctx *context.APIContext) {
}
if !opts.IsValid() {
ctx.APIError(http.StatusUnprocessableEntity, "must select at least one template item")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("must select at least one template item"))
return
}
@@ -391,7 +391,7 @@ func Generate(ctx *context.APIContext) {
}
if !ctx.Doer.IsAdmin && !ctxUser.IsOrganization() {
ctx.APIError(http.StatusForbidden, "Only admin can generate repository for other user.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Only admin can generate repository for other user."))
return
}
@@ -401,7 +401,7 @@ func Generate(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if !canCreate {
ctx.APIError(http.StatusForbidden, "Given user is not allowed to create repository in organization.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Given user is not allowed to create repository in organization."))
return
}
}
@@ -410,10 +410,10 @@ func Generate(ctx *context.APIContext) {
repo, err := repo_service.GenerateRepository(ctx, ctx.Doer, ctxUser, ctx.Repo.Repository, opts)
if err != nil {
if repo_model.IsErrRepoAlreadyExist(err) {
ctx.APIError(http.StatusConflict, "The repository with the same name already exists.")
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage("The repository with the same name already exists."))
} else if db.IsErrNameReserved(err) ||
db.IsErrNamePatternNotAllowed(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -652,13 +652,13 @@ func updateBasicProperties(ctx *context.APIContext, opts api.EditRepoOption) err
if err := repo_service.ChangeRepositoryName(ctx, ctx.Doer, repo, newRepoName); err != nil {
switch {
case repo_model.IsErrRepoAlreadyExist(err):
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
case db.IsErrNameReserved(err):
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
case db.IsErrNamePatternNotAllowed(err):
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
default:
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("ChangeRepositoryName: %w", err))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("ChangeRepositoryName: %w", err)))
}
return err
}
@@ -692,7 +692,7 @@ func updateBasicProperties(ctx *context.APIContext, opts api.EditRepoOption) err
// when ForcePrivate enabled, you could change public repo to private, but only admin users can change private to public
if visibilityChanged && setting.Repository.ForcePrivate && !*opts.Private && !ctx.Doer.IsAdmin {
err := errors.New("cannot change private repository to public")
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return err
}
@@ -756,12 +756,12 @@ func updateRepoUnits(ctx *context.APIContext, opts api.EditRepoOption) error {
// Check that values are valid
if !validation.IsValidURL(opts.ExternalTracker.ExternalTrackerURL) {
err := errors.New("External tracker URL not valid")
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return err
}
if len(opts.ExternalTracker.ExternalTrackerFormat) != 0 && !validation.IsValidExternalTrackerURLFormat(opts.ExternalTracker.ExternalTrackerFormat) {
err := errors.New("External tracker URL format not valid")
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return err
}
@@ -818,7 +818,7 @@ func updateRepoUnits(ctx *context.APIContext, opts api.EditRepoOption) error {
// Check that values are valid
if !validation.IsValidURL(opts.ExternalWiki.ExternalWikiURL) {
err := errors.New("External wiki URL not valid")
ctx.APIError(http.StatusUnprocessableEntity, "Invalid external wiki URL")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Invalid external wiki URL"))
return err
}
@@ -897,7 +897,7 @@ func updateRepoUnits(ctx *context.APIContext, opts api.EditRepoOption) error {
// so unrelated PATCH calls don't reject historical configs.
if opts.AllowMergeUpdate != nil || opts.AllowRebaseUpdate != nil || opts.DefaultUpdateStyle != nil {
if err := config.ValidateUpdateSettings(); err != nil {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return err
}
}
@@ -988,7 +988,7 @@ func updateRepoArchivedState(ctx *context.APIContext, opts api.EditRepoOption) e
if opts.Archived != nil {
if repo.IsMirror {
err := errors.New("repo is a mirror, cannot archive/un-archive")
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return err
}
if *opts.Archived {
@@ -1042,14 +1042,14 @@ func updateMirror(ctx *context.APIContext, opts api.EditRepoOption) error {
interval, err := time.ParseDuration(*opts.MirrorInterval)
if err != nil {
log.Error("Wrong format for MirrorInternal Sent: %s", err)
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return err
}
// Ensure the provided duration is not too short
if interval != 0 && interval < setting.Mirror.MinInterval {
err := fmt.Errorf("invalid mirror interval: %s is below minimum interval: %s", interval, setting.Mirror.MinInterval)
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return err
}
@@ -1119,7 +1119,7 @@ func updateMirror(ctx *context.APIContext, opts api.EditRepoOption) error {
// finally update the mirror in the DB
if err := repo_model.UpdateMirror(ctx, mirror); err != nil {
log.Error("Failed to Set Mirror Interval: %s", err)
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return err
}
@@ -1160,7 +1160,7 @@ func Delete(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if !canDelete {
ctx.APIError(http.StatusForbidden, "Given user is not owner of organization.")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Given user is not owner of organization."))
return
}

2
routers/api/v1/repo/status.go
View File

@@ -55,7 +55,7 @@ func NewCommitStatus(ctx *context.APIContext) {
form := web.GetForm(ctx).(*api.CreateStatusOption)
sha := ctx.PathParam("sha")
if len(sha) == 0 {
ctx.APIError(http.StatusBadRequest, nil)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(nil))
return
}
status := &git_model.CommitStatus{

30
routers/api/v1/repo/tag.go
View File

@@ -103,19 +103,19 @@ func GetAnnotatedTag(ctx *context.APIContext) {
sha := ctx.PathParam("sha")
if len(sha) == 0 {
ctx.APIError(http.StatusBadRequest, "SHA not provided")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("SHA not provided"))
return
}
tag, err := ctx.Repo.GitRepo.GetAnnotatedTag(sha)
if err != nil {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}
commit, err := ctx.Repo.GitRepo.GetTagCommit(tag.Name)
if err != nil {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}
ctx.JSON(http.StatusOK, convert.ToAnnotatedTag(ctx, ctx.Repo.Repository, tag, commit))
@@ -203,17 +203,17 @@ func CreateTag(ctx *context.APIContext) {
commit, err := ctx.Repo.GitRepo.GetCommit(form.Target)
if err != nil {
ctx.APIError(http.StatusNotFound, fmt.Errorf("target not found: %w", err))
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(fmt.Errorf("target not found: %w", err)))
return
}
if err := release_service.CreateNewTag(ctx, ctx.Doer, ctx.Repo.Repository, commit.ID.String(), form.TagName, form.Message); err != nil {
if release_service.IsErrTagAlreadyExists(err) {
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
return
}
if release_service.IsErrProtectedTagName(err) {
ctx.APIError(http.StatusUnprocessableEntity, "user not allowed to create protected tag")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("user not allowed to create protected tag"))
return
}
@@ -278,13 +278,13 @@ func DeleteTag(ctx *context.APIContext) {
}
if !tag.IsTag {
ctx.APIError(http.StatusConflict, errors.New("a tag attached to a release cannot be deleted directly"))
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(errors.New("a tag attached to a release cannot be deleted directly")))
return
}
if err = release_service.DeleteReleaseByID(ctx, ctx.Repo.Repository, tag, ctx.Doer, true); err != nil {
if release_service.IsErrProtectedTagName(err) {
ctx.APIError(http.StatusUnprocessableEntity, "user not allowed to delete protected tag")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("user not allowed to delete protected tag"))
return
}
ctx.APIErrorInternal(err)
@@ -416,12 +416,12 @@ func CreateTagProtection(ctx *context.APIContext) {
namePattern := strings.TrimSpace(form.NamePattern)
if namePattern == "" {
ctx.APIError(http.StatusBadRequest, "name_pattern are empty")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("name_pattern are empty"))
return
}
if len(form.WhitelistUsernames) == 0 && len(form.WhitelistTeams) == 0 {
ctx.APIError(http.StatusBadRequest, "both whitelist_usernames and whitelist_teams are empty")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("both whitelist_usernames and whitelist_teams are empty"))
return
}
@@ -430,7 +430,7 @@ func CreateTagProtection(ctx *context.APIContext) {
ctx.APIErrorInternal(err)
return
} else if pt != nil {
ctx.APIError(http.StatusForbidden, "Tag protection already exist")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("Tag protection already exist"))
return
}
@@ -438,7 +438,7 @@ func CreateTagProtection(ctx *context.APIContext) {
whitelistUsers, err = user_model.GetUserIDsByNames(ctx, form.WhitelistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -449,7 +449,7 @@ func CreateTagProtection(ctx *context.APIContext) {
whitelistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.WhitelistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -546,7 +546,7 @@ func EditTagProtection(ctx *context.APIContext) {
whitelistTeams, err = organization.GetTeamIDsByNames(ctx, repo.OwnerID, form.WhitelistTeams, false)
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)
@@ -560,7 +560,7 @@ func EditTagProtection(ctx *context.APIContext) {
whitelistUsers, err = user_model.GetUserIDsByNames(ctx, form.WhitelistUsernames, false)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
return
}
ctx.APIErrorInternal(err)

14
routers/api/v1/repo/teams.go
View File

@@ -38,7 +38,7 @@ func ListTeams(ctx *context.APIContext) {
// "$ref": "#/responses/notFound"
if !ctx.Repo.Owner.IsOrganization() {
ctx.APIError(http.StatusMethodNotAllowed, "repo is not owned by an organization")
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage("repo is not owned by an organization"))
return
}
@@ -89,7 +89,7 @@ func IsTeam(ctx *context.APIContext) {
// "$ref": "#/responses/error"
if !ctx.Repo.Owner.IsOrganization() {
ctx.APIError(http.StatusMethodNotAllowed, "repo is not owned by an organization")
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage("repo is not owned by an organization"))
return
}
@@ -185,10 +185,10 @@ func DeleteTeam(ctx *context.APIContext) {
func changeRepoTeam(ctx *context.APIContext, add bool) {
if !ctx.Repo.Owner.IsOrganization() {
ctx.APIError(http.StatusMethodNotAllowed, "repo is not owned by an organization")
ctx.APIError(http.StatusMethodNotAllowed, ctx.APIErrorMessage("repo is not owned by an organization"))
}
if !ctx.Repo.Owner.RepoAdminChangeTeamAccess && !ctx.Repo.Permission.IsOwner() {
ctx.APIError(http.StatusForbidden, "user is nor repo admin nor owner")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("user is nor repo admin nor owner"))
return
}
@@ -201,13 +201,13 @@ func changeRepoTeam(ctx *context.APIContext, add bool) {
var err error
if add {
if repoHasTeam {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("team '%s' is already added to repo", team.Name))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("team '%s' is already added to repo", team.Name)))
return
}
err = repo_service.TeamAddRepository(ctx, team, ctx.Repo.Repository)
} else {
if !repoHasTeam {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("team '%s' was not added to repo", team.Name))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("team '%s' was not added to repo", team.Name)))
return
}
err = repo_service.RemoveRepositoryFromTeam(ctx, team, ctx.Repo.Repository.ID)
@@ -224,7 +224,7 @@ func getTeamByParam(ctx *context.APIContext) *organization.Team {
team, err := organization.GetTeam(ctx, ctx.Repo.Owner.ID, ctx.PathParam("team"))
if err != nil {
if organization.IsErrTeamNotExist(err) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
return nil
}
ctx.APIErrorInternal(err)

28
routers/api/v1/repo/transfer.go
View File

@@ -61,7 +61,7 @@ func Transfer(ctx *context.APIContext) {
newOwner, err := user_model.GetUserByName(ctx, opts.NewOwner)
if err != nil {
if user_model.IsErrUserNotExist(err) {
ctx.APIError(http.StatusNotFound, "The new owner does not exist or cannot be found")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("The new owner does not exist or cannot be found"))
return
}
ctx.APIErrorInternal(err)
@@ -71,7 +71,7 @@ func Transfer(ctx *context.APIContext) {
if newOwner.Type == user_model.UserTypeOrganization {
if !ctx.Doer.IsAdmin && newOwner.Visibility == api.VisibleTypePrivate && !organization.OrgFromUser(newOwner).HasMemberWithUserID(ctx, ctx.Doer.ID) {
// The user shouldn't know about this organization
ctx.APIError(http.StatusNotFound, "The new owner does not exist or cannot be found")
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("The new owner does not exist or cannot be found"))
return
}
}
@@ -79,7 +79,7 @@ func Transfer(ctx *context.APIContext) {
var teams []*organization.Team
if opts.TeamIDs != nil {
if !newOwner.IsOrganization() {
ctx.APIError(http.StatusUnprocessableEntity, "Teams can only be added to organization-owned repositories")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Teams can only be added to organization-owned repositories"))
return
}
@@ -87,12 +87,12 @@ func Transfer(ctx *context.APIContext) {
for _, tID := range *opts.TeamIDs {
team, err := organization.GetTeamByID(ctx, tID)
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("team %d not found", tID))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("team %d not found", tID)))
return
}
if team.OrgID != org.ID {
ctx.APIError(http.StatusForbidden, fmt.Errorf("team %d belongs not to org %d", tID, org.ID))
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(fmt.Errorf("team %d belongs not to org %d", tID, org.ID)))
return
}
@@ -110,13 +110,13 @@ func Transfer(ctx *context.APIContext) {
if err := repo_service.StartRepositoryTransfer(ctx, ctx.Doer, newOwner, ctx.Repo.Repository, teams); err != nil {
switch {
case repo_model.IsErrRepoTransferInProgress(err):
ctx.APIError(http.StatusConflict, err)
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(err))
case repo_model.IsErrRepoAlreadyExist(err):
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
case repo_service.IsRepositoryLimitReached(err):
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
case errors.Is(err, user_model.ErrBlockedUser):
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
default:
ctx.APIErrorInternal(err)
}
@@ -163,11 +163,11 @@ func AcceptTransfer(ctx *context.APIContext) {
if err != nil {
switch {
case repo_model.IsErrNoPendingTransfer(err):
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
case errors.Is(err, util.ErrPermissionDenied):
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
case repo_service.IsRepositoryLimitReached(err):
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
default:
ctx.APIErrorInternal(err)
}
@@ -207,9 +207,9 @@ func RejectTransfer(ctx *context.APIContext) {
if err != nil {
switch {
case repo_model.IsErrNoPendingTransfer(err):
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
case errors.Is(err, util.ErrPermissionDenied):
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
default:
ctx.APIErrorInternal(err)
}

4
routers/api/v1/repo/tree.go
View File

@@ -58,11 +58,11 @@ func GetTree(ctx *context.APIContext) {
sha := ctx.PathParam("sha")
if len(sha) == 0 {
ctx.APIError(http.StatusBadRequest, "sha not provided")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("sha not provided"))
return
}
if tree, err := files_service.GetTreeBySHA(ctx, ctx.Repo.Repository, ctx.Repo.GitRepo, sha, ctx.FormInt("page"), ctx.FormInt("per_page"), ctx.FormBool("recursive")); err != nil {
ctx.APIError(http.StatusBadRequest, err.Error())
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err.Error()))
} else {
ctx.SetTotalCountHeader(int64(tree.TotalCount))
ctx.JSON(http.StatusOK, tree)

10
routers/api/v1/repo/wiki.go
View File

@@ -59,7 +59,7 @@ func NewWikiPage(ctx *context.APIContext) {
form := web.GetForm(ctx).(*api.CreateWikiPageOptions)
if util.IsEmptyString(form.Title) {
ctx.APIError(http.StatusBadRequest, nil)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(nil))
return
}
@@ -71,16 +71,16 @@ func NewWikiPage(ctx *context.APIContext) {
content, err := base64.StdEncoding.DecodeString(form.ContentBase64)
if err != nil {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}
form.ContentBase64 = string(content)
if err := wiki_service.AddWikiPage(ctx, ctx.Doer, ctx.Repo.Repository, wikiName, form.ContentBase64, form.Message); err != nil {
if repo_model.IsErrWikiReservedName(err) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if repo_model.IsErrWikiAlreadyExist(err) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -149,7 +149,7 @@ func EditWikiPage(ctx *context.APIContext) {
content, err := base64.StdEncoding.DecodeString(form.ContentBase64)
if err != nil {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}
form.ContentBase64 = string(content)

4
routers/api/v1/shared/action.go
View File

@@ -53,7 +53,7 @@ func ListJobs(ctx *context.APIContext, ownerID, repoID, runID int64, runAttemptI
for _, status := range ctx.FormStrings("status") {
values, err := convertToInternal(status)
if err != nil {
ctx.APIError(http.StatusBadRequest, fmt.Errorf("Invalid status %s", status))
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(fmt.Errorf("Invalid status %s", status)))
return
}
opts.Statuses = append(opts.Statuses, values...)
@@ -155,7 +155,7 @@ func ListRuns(ctx *context.APIContext, ownerID, repoID int64) {
for _, status := range ctx.FormStrings("status") {
values, err := convertToInternal(status)
if err != nil {
ctx.APIError(http.StatusBadRequest, fmt.Errorf("Invalid status %s", status))
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(fmt.Errorf("Invalid status %s", status)))
return
}
opts.Status = append(opts.Status, values...)

4
routers/api/v1/shared/block.go
View File

@@ -68,7 +68,7 @@ func BlockUser(ctx *context.APIContext, blocker *user_model.User) {
if err := user_service.BlockUser(ctx, ctx.Doer, blocker, blockee, ctx.FormString("note")); err != nil {
if errors.Is(err, user_model.ErrCanNotBlock) || errors.Is(err, user_model.ErrBlockOrganization) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -87,7 +87,7 @@ func UnblockUser(ctx *context.APIContext, doer, blocker *user_model.User) {
if err := user_service.UnblockUser(ctx, doer, blocker, blockee); err != nil {
if errors.Is(err, user_model.ErrCanNotUnblock) || errors.Is(err, user_model.ErrBlockOrganization) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

2
routers/api/v1/shared/runners.go
View File

@@ -137,7 +137,7 @@ func UpdateRunner(ctx *context.APIContext, ownerID, repoID, runnerID int64) {
form := web.GetForm(ctx).(*api.EditActionRunnerOption)
if form.Disabled == nil {
ctx.APIError(http.StatusUnprocessableEntity, "[Disabled]: Required")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("[Disabled]: Required"))
return
}

22
routers/api/v1/user/action.go
View File

@@ -53,9 +53,9 @@ func CreateOrUpdateSecret(ctx *context.APIContext) {
_, created, err := secret_service.CreateOrUpdateSecret(ctx, ctx.Doer.ID, 0, ctx.PathParam("secretname"), opt.Data, opt.Description)
if err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -95,9 +95,9 @@ func DeleteSecret(ctx *context.APIContext) {
err := secret_service.DeleteSecretByName(ctx, ctx.Doer.ID, 0, ctx.PathParam("secretname"))
if err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -148,13 +148,13 @@ func CreateVariable(ctx *context.APIContext) {
return
}
if v != nil && v.ID > 0 {
ctx.APIError(http.StatusConflict, util.NewAlreadyExistErrorf("variable name %s already exists", variableName))
ctx.APIError(http.StatusConflict, ctx.APIErrorMessage(util.NewAlreadyExistErrorf("variable name %s already exists", variableName)))
return
}
if _, err := actions_service.CreateVariable(ctx, ownerID, 0, variableName, opt.Value, opt.Description); err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -201,7 +201,7 @@ func UpdateVariable(ctx *context.APIContext) {
})
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -218,7 +218,7 @@ func UpdateVariable(ctx *context.APIContext) {
if _, err := actions_service.UpdateVariableNameData(ctx, v); err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -253,9 +253,9 @@ func DeleteVariable(ctx *context.APIContext) {
if err := actions_service.DeleteVariableByName(ctx, ctx.Doer.ID, 0, ctx.PathParam("variablename")); err != nil {
if errors.Is(err, util.ErrInvalidArgument) {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
} else if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}
@@ -292,7 +292,7 @@ func GetVariable(ctx *context.APIContext) {
})
if err != nil {
if errors.Is(err, util.ErrNotExist) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

18
routers/api/v1/user/app.go
View File

@@ -112,17 +112,17 @@ func CreateAccessToken(ctx *context.APIContext) {
return
}
if exist {
ctx.APIError(http.StatusBadRequest, errors.New("access token name has been used already"))
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(errors.New("access token name has been used already")))
return
}
scope, err := auth_model.AccessTokenScope(strings.Join(form.Scopes, ",")).Normalize()
if err != nil {
ctx.APIError(http.StatusBadRequest, fmt.Errorf("invalid access token scope provided: %w", err))
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(fmt.Errorf("invalid access token scope provided: %w", err)))
return
}
if scope == "" {
ctx.APIError(http.StatusBadRequest, "access token must have a scope")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("access token must have a scope"))
return
}
t.Scope = scope
@@ -188,7 +188,7 @@ func DeleteAccessToken(ctx *context.APIContext) {
case 1:
tokenID = tokens[0].ID
default:
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("multiple matches for token name '%s'", token))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("multiple matches for token name '%s'", token)))
return
}
}
@@ -230,7 +230,7 @@ func CreateOauth2Application(ctx *context.APIContext) {
data := web.GetForm(ctx).(*api.CreateOAuth2ApplicationOptions)
if invalidURI := forms.DetectInvalidOAuth2ApplicationRedirectURI(data.RedirectURIs); invalidURI != "" {
ctx.APIError(http.StatusBadRequest, "invalid redirect URI: "+invalidURI)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("invalid redirect URI: "+invalidURI))
return
}
app, err := auth_model.CreateOAuth2Application(ctx, auth_model.CreateOAuth2ApplicationOptions{
@@ -241,12 +241,12 @@ func CreateOauth2Application(ctx *context.APIContext) {
SkipSecondaryAuthorization: data.SkipSecondaryAuthorization,
})
if err != nil {
ctx.APIError(http.StatusBadRequest, "error creating oauth2 application")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("error creating oauth2 application"))
return
}
secret, err := app.GenerateClientSecret(ctx)
if err != nil {
ctx.APIError(http.StatusBadRequest, "error creating application secret")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("error creating application secret"))
return
}
app.ClientSecret = secret
@@ -394,7 +394,7 @@ func UpdateOauth2Application(ctx *context.APIContext) {
data := web.GetForm(ctx).(*api.CreateOAuth2ApplicationOptions)
if invalidURI := forms.DetectInvalidOAuth2ApplicationRedirectURI(data.RedirectURIs); invalidURI != "" {
ctx.APIError(http.StatusBadRequest, "invalid redirect URI: "+invalidURI)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("invalid redirect URI: "+invalidURI))
return
}
@@ -416,7 +416,7 @@ func UpdateOauth2Application(ctx *context.APIContext) {
}
app.ClientSecret, err = app.GenerateClientSecret(ctx)
if err != nil {
ctx.APIError(http.StatusBadRequest, "error updating application secret")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("error updating application secret"))
return
}

2
routers/api/v1/user/avatar.go
View File

@@ -32,7 +32,7 @@ func UpdateAvatar(ctx *context.APIContext) {
content, err := base64.StdEncoding.DecodeString(form.Image)
if err != nil {
ctx.APIError(http.StatusBadRequest, err)
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage(err))
return
}

8
routers/api/v1/user/email.go
View File

@@ -59,13 +59,13 @@ func AddEmail(ctx *context.APIContext) {
form := web.GetForm(ctx).(*api.CreateEmailOption)
if len(form.Emails) == 0 {
ctx.APIError(http.StatusUnprocessableEntity, "Email list empty")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Email list empty"))
return
}
if err := user_service.AddEmailAddresses(ctx, ctx.Doer, form.Emails); err != nil {
if user_model.IsErrEmailAlreadyUsed(err) {
ctx.APIError(http.StatusUnprocessableEntity, "Email address has been used: "+err.(user_model.ErrEmailAlreadyUsed).Email)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Email address has been used: "+err.(user_model.ErrEmailAlreadyUsed).Email))
} else if user_model.IsErrEmailCharIsNotSupported(err) || user_model.IsErrEmailInvalid(err) {
email := ""
if typedError, ok := err.(user_model.ErrEmailInvalid); ok {
@@ -76,7 +76,7 @@ func AddEmail(ctx *context.APIContext) {
}
errMsg := fmt.Sprintf("Email address %q invalid", email)
ctx.APIError(http.StatusUnprocessableEntity, errMsg)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(errMsg))
} else {
ctx.APIErrorInternal(err)
}
@@ -122,7 +122,7 @@ func DeleteEmail(ctx *context.APIContext) {
if err := user_service.DeleteEmailAddresses(ctx, ctx.Doer, form.Emails); err != nil {
if user_model.IsErrEmailAddressNotExist(err) {
ctx.APIError(http.StatusNotFound, err)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

2
routers/api/v1/user/follower.go
View File

@@ -233,7 +233,7 @@ func Follow(ctx *context.APIContext) {
if err := user_model.FollowUser(ctx, ctx.Doer, ctx.ContextUser); err != nil {
if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

10
routers/api/v1/user/gpg_key.go
View File

@@ -205,7 +205,7 @@ func VerifyUserGPGKey(ctx *context.APIContext) {
if err != nil {
if asymkey_model.IsErrGPGInvalidTokenSignature(err) {
ctx.APIError(http.StatusUnprocessableEntity, "The provided GPG key, signature and token do not match or token is out of date. Provide a valid signature for the token: "+token)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("The provided GPG key, signature and token do not match or token is out of date. Provide a valid signature for the token: "+token))
return
}
ctx.APIErrorInternal(err)
@@ -292,13 +292,13 @@ func DeleteGPGKey(ctx *context.APIContext) {
func HandleAddGPGKeyError(ctx *context.APIContext, err error, token string) {
switch {
case asymkey_model.IsErrGPGKeyIDAlreadyUsed(err):
ctx.APIError(http.StatusUnprocessableEntity, "A key with the same id already exists")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("A key with the same id already exists"))
case asymkey_model.IsErrGPGKeyParsing(err):
ctx.APIError(http.StatusUnprocessableEntity, err)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(err))
case asymkey_model.IsErrGPGNoEmailFound(err):
ctx.APIError(http.StatusNotFound, "None of the emails attached to the GPG key could be found. It may still be added if you provide a valid signature for the token: "+token)
ctx.APIError(http.StatusNotFound, ctx.APIErrorMessage("None of the emails attached to the GPG key could be found. It may still be added if you provide a valid signature for the token: "+token))
case asymkey_model.IsErrGPGInvalidTokenSignature(err):
ctx.APIError(http.StatusUnprocessableEntity, "The provided GPG key, signature and token do not match or token is out of date. Provide a valid signature for the token: "+token)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("The provided GPG key, signature and token do not match or token is out of date. Provide a valid signature for the token: "+token))
default:
ctx.APIErrorInternal(err)
}

4
routers/api/v1/user/key.go
View File

@@ -287,13 +287,13 @@ func DeletePublicKey(ctx *context.APIContext) {
}
if externallyManaged {
ctx.APIError(http.StatusForbidden, "SSH Key is externally managed for this user")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("SSH Key is externally managed for this user"))
return
}
if err := asymkey_service.DeletePublicKey(ctx, ctx.Doer, id); err != nil {
if asymkey_model.IsErrKeyAccessDenied(err) {
ctx.APIError(http.StatusForbidden, "You do not have access to this key")
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage("You do not have access to this key"))
} else {
ctx.APIErrorInternal(err)
}

2
routers/api/v1/user/star.go
View File

@@ -174,7 +174,7 @@ func Star(ctx *context.APIContext) {
err := repo_model.StarRepo(ctx, ctx.Doer, ctx.Repo.Repository, true)
if err != nil {
if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

2
routers/api/v1/user/watch.go
View File

@@ -172,7 +172,7 @@ func Watch(ctx *context.APIContext) {
err := repo_model.WatchRepo(ctx, ctx.Doer, ctx.Repo.Repository, true)
if err != nil {
if errors.Is(err, user_model.ErrBlockedUser) {
ctx.APIError(http.StatusForbidden, err)
ctx.APIError(http.StatusForbidden, ctx.APIErrorMessage(err))
} else {
ctx.APIErrorInternal(err)
}

18
routers/api/v1/utils/hook.go
View File

@@ -81,21 +81,21 @@ func GetRepoHook(ctx *context.APIContext, repoID, hookID int64) (*webhook.Webhoo
// write the appropriate error to `ctx`. Return whether the form is valid
func checkCreateHookOption(ctx *context.APIContext, form *api.CreateHookOption) bool {
if !webhook_service.IsValidHookTaskType(form.Type) {
ctx.APIError(http.StatusUnprocessableEntity, "Invalid hook type: "+form.Type)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Invalid hook type: "+form.Type))
return false
}
for _, name := range []string{"url", "content_type"} {
if _, ok := form.Config[name]; !ok {
ctx.APIError(http.StatusUnprocessableEntity, "Missing config option: "+name)
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Missing config option: "+name))
return false
}
}
if !webhook.IsValidHookContentType(form.Config["content_type"]) {
ctx.APIError(http.StatusUnprocessableEntity, "Invalid content type")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Invalid content type"))
return false
}
if !validation.IsValidURL(form.Config["url"]) {
ctx.APIError(http.StatusUnprocessableEntity, "Invalid url")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Invalid url"))
return false
}
return true
@@ -207,7 +207,7 @@ func addHook(ctx *context.APIContext, form *api.CreateHookOption, ownerID, repoI
if form.Config["is_system_webhook"] != "" {
sw, err := strconv.ParseBool(form.Config["is_system_webhook"])
if err != nil {
ctx.APIError(http.StatusUnprocessableEntity, "Invalid is_system_webhook value")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Invalid is_system_webhook value"))
return nil, false
}
isSystemWebhook = sw
@@ -237,13 +237,13 @@ func addHook(ctx *context.APIContext, form *api.CreateHookOption, ownerID, repoI
if w.Type == webhook_module.SLACK {
channel, ok := form.Config["channel"]
if !ok {
ctx.APIError(http.StatusUnprocessableEntity, "Missing config option: channel")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Missing config option: channel"))
return nil, false
}
channel = strings.TrimSpace(channel)
if !webhook_service.IsValidSlackChannel(channel) {
ctx.APIError(http.StatusBadRequest, "Invalid slack channel name")
ctx.APIError(http.StatusBadRequest, ctx.APIErrorMessage("Invalid slack channel name"))
return nil, false
}
@@ -341,14 +341,14 @@ func editHook(ctx *context.APIContext, form *api.EditHookOption, w *webhook.Webh
if form.Config != nil {
if url, ok := form.Config["url"]; ok {
if !validation.IsValidURL(url) {
ctx.APIError(http.StatusUnprocessableEntity, "Invalid url")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Invalid url"))
return false
}
w.URL = url
}
if ct, ok := form.Config["content_type"]; ok {
if !webhook.IsValidHookContentType(ct) {
ctx.APIError(http.StatusUnprocessableEntity, "Invalid content type")
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage("Invalid content type"))
return false
}
w.ContentType = webhook.ToHookContentType(ct)

4
routers/api/v1/utils/sort.go
View File

@@ -26,12 +26,12 @@ func ResolveSortOrder(ctx *context.APIContext, orderByMap map[string]map[string]
}
orderMap, ok := orderByMap[sortOrder]
if !ok {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("Invalid sort order: %q", sortOrder))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("Invalid sort order: %q", sortOrder)))
return "", false
}
orderBy, ok := orderMap[sortMode]
if !ok {
ctx.APIError(http.StatusUnprocessableEntity, fmt.Errorf("Invalid sort mode: %q", sortMode))
ctx.APIError(http.StatusUnprocessableEntity, ctx.APIErrorMessage(fmt.Errorf("Invalid sort mode: %q", sortMode)))
return "", false
}
return orderBy, true

8
services/context/api.go
View File

@@ -155,6 +155,14 @@ func (ctx *APIContext) APIError(status int, msg string) {
})
}
// APIErrorMessage converts any object to an API error message.
func (ctx *APIContext) APIErrorMessage(obj any) string {
if err, ok := obj.(error); ok {
return err.Error()
}
return fmt.Sprintf("%s", obj)
}
type apiContextKeyType struct{}
var apiContextKey = apiContextKeyType{}