mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2025-11-02 23:41:05 +00:00
563 lines
15 KiB
Go
563 lines
15 KiB
Go
// Copyright 2015 The Gogs Authors. All rights reserved.
|
|
// Use of this source code is governed by a MIT-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package models
|
|
|
|
import (
|
|
"fmt"
|
|
)
|
|
|
|
type ErrNameReserved struct {
|
|
Name string
|
|
}
|
|
|
|
func IsErrNameReserved(err error) bool {
|
|
_, ok := err.(ErrNameReserved)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrNameReserved) Error() string {
|
|
return fmt.Sprintf("name is reserved [name: %s]", err.Name)
|
|
}
|
|
|
|
type ErrNamePatternNotAllowed struct {
|
|
Pattern string
|
|
}
|
|
|
|
func IsErrNamePatternNotAllowed(err error) bool {
|
|
_, ok := err.(ErrNamePatternNotAllowed)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrNamePatternNotAllowed) Error() string {
|
|
return fmt.Sprintf("name pattern is not allowed [pattern: %s]", err.Pattern)
|
|
}
|
|
|
|
// ____ ___
|
|
// | | \______ ___________
|
|
// | | / ___// __ \_ __ \
|
|
// | | /\___ \\ ___/| | \/
|
|
// |______//____ >\___ >__|
|
|
// \/ \/
|
|
|
|
type ErrUserAlreadyExist struct {
|
|
Name string
|
|
}
|
|
|
|
func IsErrUserAlreadyExist(err error) bool {
|
|
_, ok := err.(ErrUserAlreadyExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrUserAlreadyExist) Error() string {
|
|
return fmt.Sprintf("user already exists [name: %s]", err.Name)
|
|
}
|
|
|
|
type ErrUserNotExist struct {
|
|
UID int64
|
|
Name string
|
|
}
|
|
|
|
func IsErrUserNotExist(err error) bool {
|
|
_, ok := err.(ErrUserNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrUserNotExist) Error() string {
|
|
return fmt.Sprintf("user does not exist [uid: %d, name: %s]", err.UID, err.Name)
|
|
}
|
|
|
|
type ErrEmailAlreadyUsed struct {
|
|
Email string
|
|
}
|
|
|
|
func IsErrEmailAlreadyUsed(err error) bool {
|
|
_, ok := err.(ErrEmailAlreadyUsed)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrEmailAlreadyUsed) Error() string {
|
|
return fmt.Sprintf("e-mail has been used [email: %s]", err.Email)
|
|
}
|
|
|
|
type ErrUserOwnRepos struct {
|
|
UID int64
|
|
}
|
|
|
|
func IsErrUserOwnRepos(err error) bool {
|
|
_, ok := err.(ErrUserOwnRepos)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrUserOwnRepos) Error() string {
|
|
return fmt.Sprintf("user still has ownership of repositories [uid: %d]", err.UID)
|
|
}
|
|
|
|
type ErrUserHasOrgs struct {
|
|
UID int64
|
|
}
|
|
|
|
func IsErrUserHasOrgs(err error) bool {
|
|
_, ok := err.(ErrUserHasOrgs)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrUserHasOrgs) Error() string {
|
|
return fmt.Sprintf("user still has membership of organizations [uid: %d]", err.UID)
|
|
}
|
|
|
|
type ErrReachLimitOfRepo struct {
|
|
Limit int
|
|
}
|
|
|
|
func IsErrReachLimitOfRepo(err error) bool {
|
|
_, ok := err.(ErrReachLimitOfRepo)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrReachLimitOfRepo) Error() string {
|
|
return fmt.Sprintf("user has reached maximum limit of repositories [limit: %d]", err.Limit)
|
|
}
|
|
|
|
// __ __.__ __ .__
|
|
// / \ / \__| | _|__|
|
|
// \ \/\/ / | |/ / |
|
|
// \ /| | <| |
|
|
// \__/\ / |__|__|_ \__|
|
|
// \/ \/
|
|
|
|
type ErrWikiAlreadyExist struct {
|
|
Title string
|
|
}
|
|
|
|
func IsErrWikiAlreadyExist(err error) bool {
|
|
_, ok := err.(ErrWikiAlreadyExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrWikiAlreadyExist) Error() string {
|
|
return fmt.Sprintf("wiki page already exists [title: %s]", err.Title)
|
|
}
|
|
|
|
// __________ ___. .__ .__ ____ __.
|
|
// \______ \__ _\_ |__ | | |__| ____ | |/ _|____ ___.__.
|
|
// | ___/ | \ __ \| | | |/ ___\ | <_/ __ < | |
|
|
// | | | | / \_\ \ |_| \ \___ | | \ ___/\___ |
|
|
// |____| |____/|___ /____/__|\___ > |____|__ \___ > ____|
|
|
// \/ \/ \/ \/\/
|
|
|
|
type ErrKeyUnableVerify struct {
|
|
Result string
|
|
}
|
|
|
|
func IsErrKeyUnableVerify(err error) bool {
|
|
_, ok := err.(ErrKeyUnableVerify)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrKeyUnableVerify) Error() string {
|
|
return fmt.Sprintf("Unable to verify key content [result: %s]", err.Result)
|
|
}
|
|
|
|
type ErrKeyNotExist struct {
|
|
ID int64
|
|
}
|
|
|
|
func IsErrKeyNotExist(err error) bool {
|
|
_, ok := err.(ErrKeyNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrKeyNotExist) Error() string {
|
|
return fmt.Sprintf("public key does not exist [id: %d]", err.ID)
|
|
}
|
|
|
|
type ErrKeyAlreadyExist struct {
|
|
OwnerID int64
|
|
Content string
|
|
}
|
|
|
|
func IsErrKeyAlreadyExist(err error) bool {
|
|
_, ok := err.(ErrKeyAlreadyExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrKeyAlreadyExist) Error() string {
|
|
return fmt.Sprintf("public key already exists [owner_id: %d, content: %s]", err.OwnerID, err.Content)
|
|
}
|
|
|
|
type ErrKeyNameAlreadyUsed struct {
|
|
OwnerID int64
|
|
Name string
|
|
}
|
|
|
|
func IsErrKeyNameAlreadyUsed(err error) bool {
|
|
_, ok := err.(ErrKeyNameAlreadyUsed)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrKeyNameAlreadyUsed) Error() string {
|
|
return fmt.Sprintf("public key already exists [owner_id: %d, name: %s]", err.OwnerID, err.Name)
|
|
}
|
|
|
|
type ErrKeyAccessDenied struct {
|
|
UserID int64
|
|
KeyID int64
|
|
Note string
|
|
}
|
|
|
|
func IsErrKeyAccessDenied(err error) bool {
|
|
_, ok := err.(ErrKeyAccessDenied)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrKeyAccessDenied) Error() string {
|
|
return fmt.Sprintf("user does not have access to the key [user_id: %d, key_id: %d, note: %s]",
|
|
err.UserID, err.KeyID, err.Note)
|
|
}
|
|
|
|
type ErrDeployKeyNotExist struct {
|
|
ID int64
|
|
KeyID int64
|
|
RepoID int64
|
|
}
|
|
|
|
func IsErrDeployKeyNotExist(err error) bool {
|
|
_, ok := err.(ErrDeployKeyNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrDeployKeyNotExist) Error() string {
|
|
return fmt.Sprintf("Deploy key does not exist [id: %d, key_id: %d, repo_id: %d]", err.ID, err.KeyID, err.RepoID)
|
|
}
|
|
|
|
type ErrDeployKeyAlreadyExist struct {
|
|
KeyID int64
|
|
RepoID int64
|
|
}
|
|
|
|
func IsErrDeployKeyAlreadyExist(err error) bool {
|
|
_, ok := err.(ErrDeployKeyAlreadyExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrDeployKeyAlreadyExist) Error() string {
|
|
return fmt.Sprintf("public key already exists [key_id: %d, repo_id: %d]", err.KeyID, err.RepoID)
|
|
}
|
|
|
|
type ErrDeployKeyNameAlreadyUsed struct {
|
|
RepoID int64
|
|
Name string
|
|
}
|
|
|
|
func IsErrDeployKeyNameAlreadyUsed(err error) bool {
|
|
_, ok := err.(ErrDeployKeyNameAlreadyUsed)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrDeployKeyNameAlreadyUsed) Error() string {
|
|
return fmt.Sprintf("public key already exists [repo_id: %d, name: %s]", err.RepoID, err.Name)
|
|
}
|
|
|
|
// _____ ___________ __
|
|
// / _ \ ____ ____ ____ ______ _____\__ ___/___ | | __ ____ ____
|
|
// / /_\ \_/ ___\/ ___\/ __ \ / ___// ___/ | | / _ \| |/ // __ \ / \
|
|
// / | \ \__\ \__\ ___/ \___ \ \___ \ | |( <_> ) <\ ___/| | \
|
|
// \____|__ /\___ >___ >___ >____ >____ > |____| \____/|__|_ \\___ >___| /
|
|
// \/ \/ \/ \/ \/ \/ \/ \/ \/
|
|
|
|
type ErrAccessTokenNotExist struct {
|
|
SHA string
|
|
}
|
|
|
|
func IsErrAccessTokenNotExist(err error) bool {
|
|
_, ok := err.(ErrAccessTokenNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrAccessTokenNotExist) Error() string {
|
|
return fmt.Sprintf("access token does not exist [sha: %s]", err.SHA)
|
|
}
|
|
|
|
// ________ .__ __ .__
|
|
// \_____ \_______ _________ ____ |__|____________ _/ |_|__| ____ ____
|
|
// / | \_ __ \/ ___\__ \ / \| \___ /\__ \\ __\ |/ _ \ / \
|
|
// / | \ | \/ /_/ > __ \| | \ |/ / / __ \| | | ( <_> ) | \
|
|
// \_______ /__| \___ (____ /___| /__/_____ \(____ /__| |__|\____/|___| /
|
|
// \/ /_____/ \/ \/ \/ \/ \/
|
|
|
|
type ErrLastOrgOwner struct {
|
|
UID int64
|
|
}
|
|
|
|
func IsErrLastOrgOwner(err error) bool {
|
|
_, ok := err.(ErrLastOrgOwner)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrLastOrgOwner) Error() string {
|
|
return fmt.Sprintf("user is the last member of owner team [uid: %d]", err.UID)
|
|
}
|
|
|
|
// __________ .__ __
|
|
// \______ \ ____ ______ ____ _____|__|/ |_ ___________ ___.__.
|
|
// | _// __ \\____ \ / _ \/ ___/ \ __\/ _ \_ __ < | |
|
|
// | | \ ___/| |_> > <_> )___ \| || | ( <_> ) | \/\___ |
|
|
// |____|_ /\___ > __/ \____/____ >__||__| \____/|__| / ____|
|
|
// \/ \/|__| \/ \/
|
|
|
|
type ErrRepoNotExist struct {
|
|
ID int64
|
|
UID int64
|
|
Name string
|
|
}
|
|
|
|
func IsErrRepoNotExist(err error) bool {
|
|
_, ok := err.(ErrRepoNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrRepoNotExist) Error() string {
|
|
return fmt.Sprintf("repository does not exist [id: %d, uid: %d, name: %s]", err.ID, err.UID, err.Name)
|
|
}
|
|
|
|
type ErrRepoAlreadyExist struct {
|
|
Uname string
|
|
Name string
|
|
}
|
|
|
|
func IsErrRepoAlreadyExist(err error) bool {
|
|
_, ok := err.(ErrRepoAlreadyExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrRepoAlreadyExist) Error() string {
|
|
return fmt.Sprintf("repository already exists [uname: %s, name: %s]", err.Uname, err.Name)
|
|
}
|
|
|
|
type ErrInvalidCloneAddr struct {
|
|
IsURLError bool
|
|
IsInvalidPath bool
|
|
IsPermissionDenied bool
|
|
}
|
|
|
|
func IsErrInvalidCloneAddr(err error) bool {
|
|
_, ok := err.(ErrInvalidCloneAddr)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrInvalidCloneAddr) Error() string {
|
|
return fmt.Sprintf("invalid clone address [is_url_error: %v, is_invalid_path: %v, is_permission_denied: %v]",
|
|
err.IsURLError, err.IsInvalidPath, err.IsPermissionDenied)
|
|
}
|
|
|
|
type ErrUpdateTaskNotExist struct {
|
|
UUID string
|
|
}
|
|
|
|
func IsErrUpdateTaskNotExist(err error) bool {
|
|
_, ok := err.(ErrUpdateTaskNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrUpdateTaskNotExist) Error() string {
|
|
return fmt.Sprintf("update task does not exist [uuid: %s]", err.UUID)
|
|
}
|
|
|
|
type ErrReleaseAlreadyExist struct {
|
|
TagName string
|
|
}
|
|
|
|
func IsErrReleaseAlreadyExist(err error) bool {
|
|
_, ok := err.(ErrReleaseAlreadyExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrReleaseAlreadyExist) Error() string {
|
|
return fmt.Sprintf("Release tag already exist [tag_name: %s]", err.TagName)
|
|
}
|
|
|
|
type ErrReleaseNotExist struct {
|
|
ID int64
|
|
TagName string
|
|
}
|
|
|
|
func IsErrReleaseNotExist(err error) bool {
|
|
_, ok := err.(ErrReleaseNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrReleaseNotExist) Error() string {
|
|
return fmt.Sprintf("Release tag does not exist [id: %d, tag_name: %s]", err.ID, err.TagName)
|
|
}
|
|
|
|
// __ __ ___. .__ __
|
|
// / \ / \ ____\_ |__ | |__ ____ ____ | | __
|
|
// \ \/\/ // __ \| __ \| | \ / _ \ / _ \| |/ /
|
|
// \ /\ ___/| \_\ \ Y ( <_> | <_> ) <
|
|
// \__/\ / \___ >___ /___| /\____/ \____/|__|_ \
|
|
// \/ \/ \/ \/ \/
|
|
|
|
type ErrWebhookNotExist struct {
|
|
ID int64
|
|
}
|
|
|
|
func IsErrWebhookNotExist(err error) bool {
|
|
_, ok := err.(ErrWebhookNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrWebhookNotExist) Error() string {
|
|
return fmt.Sprintf("webhook does not exist [id: %d]", err.ID)
|
|
}
|
|
|
|
// .___
|
|
// | | ______ ________ __ ____
|
|
// | |/ ___// ___/ | \_/ __ \
|
|
// | |\___ \ \___ \| | /\ ___/
|
|
// |___/____ >____ >____/ \___ >
|
|
// \/ \/ \/
|
|
|
|
type ErrIssueNotExist struct {
|
|
ID int64
|
|
RepoID int64
|
|
Index int64
|
|
}
|
|
|
|
func IsErrIssueNotExist(err error) bool {
|
|
_, ok := err.(ErrIssueNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrIssueNotExist) Error() string {
|
|
return fmt.Sprintf("issue does not exist [id: %d, repo_id: %d, index: %d]", err.ID, err.RepoID, err.Index)
|
|
}
|
|
|
|
// __________ .__ .__ __________ __
|
|
// \______ \__ __| | | |\______ \ ____ ________ __ ____ _______/ |_
|
|
// | ___/ | \ | | | | _// __ \/ ____/ | \_/ __ \ / ___/\ __\
|
|
// | | | | / |_| |_| | \ ___< <_| | | /\ ___/ \___ \ | |
|
|
// |____| |____/|____/____/____|_ /\___ >__ |____/ \___ >____ > |__|
|
|
// \/ \/ |__| \/ \/
|
|
|
|
type ErrPullRequestNotExist struct {
|
|
ID int64
|
|
IssueID int64
|
|
HeadRepoID int64
|
|
BaseRepoID int64
|
|
HeadBarcnh string
|
|
BaseBranch string
|
|
}
|
|
|
|
func IsErrPullRequestNotExist(err error) bool {
|
|
_, ok := err.(ErrPullRequestNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrPullRequestNotExist) Error() string {
|
|
return fmt.Sprintf("pull request does not exist [id: %d, issue_id: %d, head_repo_id: %d, base_repo_id: %d, head_branch: %s, base_branch: %s]",
|
|
err.ID, err.IssueID, err.HeadRepoID, err.BaseRepoID, err.HeadBarcnh, err.BaseBranch)
|
|
}
|
|
|
|
// _________ __
|
|
// \_ ___ \ ____ _____ _____ ____ _____/ |_
|
|
// / \ \/ / _ \ / \ / \_/ __ \ / \ __\
|
|
// \ \___( <_> ) Y Y \ Y Y \ ___/| | \ |
|
|
// \______ /\____/|__|_| /__|_| /\___ >___| /__|
|
|
// \/ \/ \/ \/ \/
|
|
|
|
type ErrCommentNotExist struct {
|
|
ID int64
|
|
}
|
|
|
|
func IsErrCommentNotExist(err error) bool {
|
|
_, ok := err.(ErrCommentNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrCommentNotExist) Error() string {
|
|
return fmt.Sprintf("comment does not exist [id: %d]", err.ID)
|
|
}
|
|
|
|
// .____ ___. .__
|
|
// | | _____ \_ |__ ____ | |
|
|
// | | \__ \ | __ \_/ __ \| |
|
|
// | |___ / __ \| \_\ \ ___/| |__
|
|
// |_______ (____ /___ /\___ >____/
|
|
// \/ \/ \/ \/
|
|
|
|
type ErrLabelNotExist struct {
|
|
ID int64
|
|
}
|
|
|
|
func IsErrLabelNotExist(err error) bool {
|
|
_, ok := err.(ErrLabelNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrLabelNotExist) Error() string {
|
|
return fmt.Sprintf("label does not exist [id: %d]", err.ID)
|
|
}
|
|
|
|
// _____ .__.__ __
|
|
// / \ |__| | ____ _______/ |_ ____ ____ ____
|
|
// / \ / \| | | _/ __ \ / ___/\ __\/ _ \ / \_/ __ \
|
|
// / Y \ | |_\ ___/ \___ \ | | ( <_> ) | \ ___/
|
|
// \____|__ /__|____/\___ >____ > |__| \____/|___| /\___ >
|
|
// \/ \/ \/ \/ \/
|
|
|
|
type ErrMilestoneNotExist struct {
|
|
ID int64
|
|
RepoID int64
|
|
}
|
|
|
|
func IsErrMilestoneNotExist(err error) bool {
|
|
_, ok := err.(ErrMilestoneNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrMilestoneNotExist) Error() string {
|
|
return fmt.Sprintf("milestone does not exist [id: %d, repo_id: %d]", err.ID, err.RepoID)
|
|
}
|
|
|
|
// _____ __ __ .__ __
|
|
// / _ \_/ |__/ |______ ____ | |__ _____ ____ _____/ |_
|
|
// / /_\ \ __\ __\__ \ _/ ___\| | \ / \_/ __ \ / \ __\
|
|
// / | \ | | | / __ \\ \___| Y \ Y Y \ ___/| | \ |
|
|
// \____|__ /__| |__| (____ /\___ >___| /__|_| /\___ >___| /__|
|
|
// \/ \/ \/ \/ \/ \/ \/
|
|
|
|
type ErrAttachmentNotExist struct {
|
|
ID int64
|
|
UUID string
|
|
}
|
|
|
|
func IsErrAttachmentNotExist(err error) bool {
|
|
_, ok := err.(ErrAttachmentNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrAttachmentNotExist) Error() string {
|
|
return fmt.Sprintf("attachment does not exist [id: %d, uuid: %s]", err.ID, err.UUID)
|
|
}
|
|
|
|
// _____ __ .__ __ .__ __ .__
|
|
// / _ \ __ ___/ |_| |__ ____ _____/ |_|__| ____ _____ _/ |_|__| ____ ____
|
|
// / /_\ \| | \ __\ | \_/ __ \ / \ __\ |/ ___\\__ \\ __\ |/ _ \ / \
|
|
// / | \ | /| | | Y \ ___/| | \ | | \ \___ / __ \| | | ( <_> ) | \
|
|
// \____|__ /____/ |__| |___| /\___ >___| /__| |__|\___ >____ /__| |__|\____/|___| /
|
|
// \/ \/ \/ \/ \/ \/ \/
|
|
|
|
type ErrAuthenticationNotExist struct {
|
|
ID int64
|
|
}
|
|
|
|
func IsErrAuthenticationNotExist(err error) bool {
|
|
_, ok := err.(ErrAuthenticationNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrAuthenticationNotExist) Error() string {
|
|
return fmt.Sprintf("Authentication does not exist [id: %d]", err.ID)
|
|
}
|