2015-03-16 11:04:27 +03:00
// Copyright 2015 The Gogs Authors. All rights reserved.
2019-04-17 19:06:35 +03:00
// Copyright 2019 The Gitea Authors. All rights reserved.
2022-11-27 21:20:29 +03:00
// SPDX-License-Identifier: MIT
2015-03-16 11:04:27 +03:00
package models
2019-04-17 19:06:35 +03:00
import (
"fmt"
2021-12-10 04:27:50 +03:00
repo_model "code.gitea.io/gitea/models/repo"
2019-04-17 19:06:35 +03:00
"code.gitea.io/gitea/modules/git"
2022-10-18 08:50:37 +03:00
"code.gitea.io/gitea/modules/util"
2019-04-17 19:06:35 +03:00
)
2015-03-16 11:04:27 +03:00
2016-11-24 11:20:28 +03:00
// ErrUserOwnRepos represents a "UserOwnRepos" kind of error.
2015-03-18 04:51:39 +03:00
type ErrUserOwnRepos struct {
UID int64
}
2016-11-24 11:20:28 +03:00
// IsErrUserOwnRepos checks if an error is a ErrUserOwnRepos.
2015-03-18 04:51:39 +03:00
func IsErrUserOwnRepos ( err error ) bool {
_ , ok := err . ( ErrUserOwnRepos )
return ok
}
func ( err ErrUserOwnRepos ) Error ( ) string {
2015-11-04 02:40:52 +03:00
return fmt . Sprintf ( "user still has ownership of repositories [uid: %d]" , err . UID )
2015-03-18 04:51:39 +03:00
}
2016-11-24 11:20:28 +03:00
// ErrUserHasOrgs represents a "UserHasOrgs" kind of error.
2015-03-18 04:51:39 +03:00
type ErrUserHasOrgs struct {
UID int64
}
2016-11-24 11:20:28 +03:00
// IsErrUserHasOrgs checks if an error is a ErrUserHasOrgs.
2015-03-18 04:51:39 +03:00
func IsErrUserHasOrgs ( err error ) bool {
_ , ok := err . ( ErrUserHasOrgs )
return ok
}
func ( err ErrUserHasOrgs ) Error ( ) string {
2015-11-04 02:40:52 +03:00
return fmt . Sprintf ( "user still has membership of organizations [uid: %d]" , err . UID )
2015-03-18 04:51:39 +03:00
}
2022-03-30 11:42:47 +03:00
// ErrUserOwnPackages notifies that the user (still) owns the packages.
type ErrUserOwnPackages struct {
UID int64
}
// IsErrUserOwnPackages checks if an error is an ErrUserOwnPackages.
func IsErrUserOwnPackages ( err error ) bool {
_ , ok := err . ( ErrUserOwnPackages )
return ok
}
func ( err ErrUserOwnPackages ) Error ( ) string {
return fmt . Sprintf ( "user still has ownership of packages [uid: %d]" , err . UID )
}
2021-03-01 03:47:30 +03:00
// ErrNoPendingRepoTransfer is an error type for repositories without a pending
// transfer request
type ErrNoPendingRepoTransfer struct {
RepoID int64
}
2022-10-18 08:50:37 +03:00
func ( err ErrNoPendingRepoTransfer ) Error ( ) string {
return fmt . Sprintf ( "repository doesn't have a pending transfer [repo_id: %d]" , err . RepoID )
2021-03-01 03:47:30 +03:00
}
// IsErrNoPendingTransfer is an error type when a repository has no pending
// transfers
func IsErrNoPendingTransfer ( err error ) bool {
_ , ok := err . ( ErrNoPendingRepoTransfer )
return ok
}
2022-10-18 08:50:37 +03:00
func ( err ErrNoPendingRepoTransfer ) Unwrap ( ) error {
return util . ErrNotExist
}
2021-03-01 03:47:30 +03:00
// ErrRepoTransferInProgress represents the state of a repository that has an
// ongoing transfer
type ErrRepoTransferInProgress struct {
Uname string
Name string
}
// IsErrRepoTransferInProgress checks if an error is a ErrRepoTransferInProgress.
func IsErrRepoTransferInProgress ( err error ) bool {
_ , ok := err . ( ErrRepoTransferInProgress )
return ok
}
func ( err ErrRepoTransferInProgress ) Error ( ) string {
return fmt . Sprintf ( "repository is already being transferred [uname: %s, name: %s]" , err . Uname , err . Name )
}
2022-10-18 08:50:37 +03:00
func ( err ErrRepoTransferInProgress ) Unwrap ( ) error {
return util . ErrAlreadyExist
}
2016-11-24 11:20:28 +03:00
// ErrInvalidCloneAddr represents a "InvalidCloneAddr" kind of error.
2015-11-04 02:40:52 +03:00
type ErrInvalidCloneAddr struct {
2021-03-16 00:52:11 +03:00
Host string
2015-11-04 02:40:52 +03:00
IsURLError bool
IsInvalidPath bool
2021-03-16 00:52:11 +03:00
IsProtocolInvalid bool
2015-11-04 02:40:52 +03:00
IsPermissionDenied bool
2021-03-16 00:52:11 +03:00
LocalPath bool
2015-11-04 02:40:52 +03:00
}
2016-11-24 11:20:28 +03:00
// IsErrInvalidCloneAddr checks if an error is a ErrInvalidCloneAddr.
2015-11-04 02:40:52 +03:00
func IsErrInvalidCloneAddr ( err error ) bool {
2021-03-16 00:52:11 +03:00
_ , ok := err . ( * ErrInvalidCloneAddr )
2015-11-04 02:40:52 +03:00
return ok
}
2021-03-16 00:52:11 +03:00
func ( err * ErrInvalidCloneAddr ) Error ( ) string {
if err . IsInvalidPath {
return fmt . Sprintf ( "migration/cloning from '%s' is not allowed: the provided path is invalid" , err . Host )
}
if err . IsProtocolInvalid {
return fmt . Sprintf ( "migration/cloning from '%s' is not allowed: the provided url protocol is not allowed" , err . Host )
}
if err . IsPermissionDenied {
return fmt . Sprintf ( "migration/cloning from '%s' is not allowed." , err . Host )
}
if err . IsURLError {
return fmt . Sprintf ( "migration/cloning from '%s' is not allowed: the provided url is invalid" , err . Host )
}
return fmt . Sprintf ( "migration/cloning from '%s' is not allowed" , err . Host )
2015-11-04 02:40:52 +03:00
}
2022-10-18 08:50:37 +03:00
func ( err * ErrInvalidCloneAddr ) Unwrap ( ) error {
return util . ErrInvalidArgument
}
2016-11-24 11:20:28 +03:00
// ErrUpdateTaskNotExist represents a "UpdateTaskNotExist" kind of error.
2015-11-05 05:57:10 +03:00
type ErrUpdateTaskNotExist struct {
UUID string
}
2016-11-24 11:20:28 +03:00
// IsErrUpdateTaskNotExist checks if an error is a ErrUpdateTaskNotExist.
2015-11-05 05:57:10 +03:00
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 )
}
2022-10-18 08:50:37 +03:00
func ( err ErrUpdateTaskNotExist ) Unwrap ( ) error {
return util . ErrNotExist
}
2016-11-24 11:20:28 +03:00
// ErrInvalidTagName represents a "InvalidTagName" kind of error.
2016-07-23 10:59:19 +03:00
type ErrInvalidTagName struct {
TagName string
}
2016-11-24 11:20:28 +03:00
// IsErrInvalidTagName checks if an error is a ErrInvalidTagName.
2016-07-23 10:59:19 +03:00
func IsErrInvalidTagName ( err error ) bool {
_ , ok := err . ( ErrInvalidTagName )
return ok
}
func ( err ErrInvalidTagName ) Error ( ) string {
return fmt . Sprintf ( "release tag name is not valid [tag_name: %s]" , err . TagName )
2015-11-16 07:52:46 +03:00
}
2022-10-18 08:50:37 +03:00
func ( err ErrInvalidTagName ) Unwrap ( ) error {
return util . ErrInvalidArgument
}
2021-06-25 17:28:55 +03:00
// ErrProtectedTagName represents a "ProtectedTagName" kind of error.
type ErrProtectedTagName struct {
TagName string
}
// IsErrProtectedTagName checks if an error is a ErrProtectedTagName.
func IsErrProtectedTagName ( err error ) bool {
_ , ok := err . ( ErrProtectedTagName )
return ok
}
func ( err ErrProtectedTagName ) Error ( ) string {
return fmt . Sprintf ( "release tag name is protected [tag_name: %s]" , err . TagName )
}
2022-10-18 08:50:37 +03:00
func ( err ErrProtectedTagName ) Unwrap ( ) error {
return util . ErrPermissionDenied
}
2019-04-17 19:06:35 +03:00
// ErrRepoFileAlreadyExists represents a "RepoFileAlreadyExist" kind of error.
type ErrRepoFileAlreadyExists struct {
Path string
}
// IsErrRepoFileAlreadyExists checks if an error is a ErrRepoFileAlreadyExists.
func IsErrRepoFileAlreadyExists ( err error ) bool {
_ , ok := err . ( ErrRepoFileAlreadyExists )
return ok
}
func ( err ErrRepoFileAlreadyExists ) Error ( ) string {
return fmt . Sprintf ( "repository file already exists [path: %s]" , err . Path )
}
2022-10-18 08:50:37 +03:00
func ( err ErrRepoFileAlreadyExists ) Unwrap ( ) error {
return util . ErrAlreadyExist
}
2019-04-17 19:06:35 +03:00
// ErrRepoFileDoesNotExist represents a "RepoFileDoesNotExist" kind of error.
type ErrRepoFileDoesNotExist struct {
Path string
Name string
}
// IsErrRepoFileDoesNotExist checks if an error is a ErrRepoDoesNotExist.
func IsErrRepoFileDoesNotExist ( err error ) bool {
_ , ok := err . ( ErrRepoFileDoesNotExist )
return ok
}
func ( err ErrRepoFileDoesNotExist ) Error ( ) string {
return fmt . Sprintf ( "repository file does not exist [path: %s]" , err . Path )
}
2022-10-18 08:50:37 +03:00
func ( err ErrRepoFileDoesNotExist ) Unwrap ( ) error {
return util . ErrNotExist
}
2019-04-17 19:06:35 +03:00
// ErrFilenameInvalid represents a "FilenameInvalid" kind of error.
type ErrFilenameInvalid struct {
Path string
}
// IsErrFilenameInvalid checks if an error is an ErrFilenameInvalid.
func IsErrFilenameInvalid ( err error ) bool {
_ , ok := err . ( ErrFilenameInvalid )
return ok
}
func ( err ErrFilenameInvalid ) Error ( ) string {
return fmt . Sprintf ( "path contains a malformed path component [path: %s]" , err . Path )
}
2022-10-18 08:50:37 +03:00
func ( err ErrFilenameInvalid ) Unwrap ( ) error {
return util . ErrInvalidArgument
}
2019-04-17 19:06:35 +03:00
// ErrUserCannotCommit represents "UserCannotCommit" kind of error.
type ErrUserCannotCommit struct {
UserName string
}
// IsErrUserCannotCommit checks if an error is an ErrUserCannotCommit.
func IsErrUserCannotCommit ( err error ) bool {
_ , ok := err . ( ErrUserCannotCommit )
return ok
}
func ( err ErrUserCannotCommit ) Error ( ) string {
return fmt . Sprintf ( "user cannot commit to repo [user: %s]" , err . UserName )
}
2022-10-18 08:50:37 +03:00
func ( err ErrUserCannotCommit ) Unwrap ( ) error {
return util . ErrPermissionDenied
}
2019-04-17 19:06:35 +03:00
// ErrFilePathInvalid represents a "FilePathInvalid" kind of error.
type ErrFilePathInvalid struct {
Message string
Path string
Name string
Type git . EntryMode
2016-08-11 15:48:08 +03:00
}
2019-04-17 19:06:35 +03:00
// IsErrFilePathInvalid checks if an error is an ErrFilePathInvalid.
func IsErrFilePathInvalid ( err error ) bool {
_ , ok := err . ( ErrFilePathInvalid )
2016-08-11 15:48:08 +03:00
return ok
}
2019-04-17 19:06:35 +03:00
func ( err ErrFilePathInvalid ) Error ( ) string {
if err . Message != "" {
return err . Message
}
return fmt . Sprintf ( "path is invalid [path: %s]" , err . Path )
2016-08-11 15:48:08 +03:00
}
2022-10-18 08:50:37 +03:00
func ( err ErrFilePathInvalid ) Unwrap ( ) error {
return util . ErrInvalidArgument
}
2020-03-27 01:26:34 +03:00
// ErrFilePathProtected represents a "FilePathProtected" kind of error.
type ErrFilePathProtected struct {
Message string
Path string
}
// IsErrFilePathProtected checks if an error is an ErrFilePathProtected.
func IsErrFilePathProtected ( err error ) bool {
_ , ok := err . ( ErrFilePathProtected )
return ok
}
func ( err ErrFilePathProtected ) Error ( ) string {
if err . Message != "" {
return err . Message
}
return fmt . Sprintf ( "path is protected and can not be changed [path: %s]" , err . Path )
}
2022-10-18 08:50:37 +03:00
func ( err ErrFilePathProtected ) Unwrap ( ) error {
return util . ErrPermissionDenied
}
2022-03-31 17:53:08 +03:00
// ErrDisallowedToMerge represents an error that a branch is protected and the current user is not allowed to modify it.
type ErrDisallowedToMerge struct {
2018-03-13 06:46:14 +03:00
Reason string
}
2022-03-31 17:53:08 +03:00
// IsErrDisallowedToMerge checks if an error is an ErrDisallowedToMerge.
func IsErrDisallowedToMerge ( err error ) bool {
_ , ok := err . ( ErrDisallowedToMerge )
2018-03-13 06:46:14 +03:00
return ok
}
2022-03-31 17:53:08 +03:00
func ( err ErrDisallowedToMerge ) Error ( ) string {
2018-03-13 06:46:14 +03:00
return fmt . Sprintf ( "not allowed to merge [reason: %s]" , err . Reason )
}
2022-10-18 08:50:37 +03:00
func ( err ErrDisallowedToMerge ) Unwrap ( ) error {
return util . ErrPermissionDenied
}
2019-04-17 19:06:35 +03:00
// ErrTagAlreadyExists represents an error that tag with such name already exists.
2017-10-15 22:59:24 +03:00
type ErrTagAlreadyExists struct {
TagName string
}
// IsErrTagAlreadyExists checks if an error is an ErrTagAlreadyExists.
func IsErrTagAlreadyExists ( err error ) bool {
_ , ok := err . ( ErrTagAlreadyExists )
return ok
}
func ( err ErrTagAlreadyExists ) Error ( ) string {
return fmt . Sprintf ( "tag already exists [name: %s]" , err . TagName )
}
2022-10-18 08:50:37 +03:00
func ( err ErrTagAlreadyExists ) Unwrap ( ) error {
return util . ErrAlreadyExist
}
2019-04-17 19:06:35 +03:00
// ErrSHADoesNotMatch represents a "SHADoesNotMatch" kind of error.
type ErrSHADoesNotMatch struct {
Path string
GivenSHA string
CurrentSHA string
}
// IsErrSHADoesNotMatch checks if an error is a ErrSHADoesNotMatch.
func IsErrSHADoesNotMatch ( err error ) bool {
_ , ok := err . ( ErrSHADoesNotMatch )
return ok
}
func ( err ErrSHADoesNotMatch ) Error ( ) string {
return fmt . Sprintf ( "sha does not match [given: %s, expected: %s]" , err . GivenSHA , err . CurrentSHA )
}
// ErrSHANotFound represents a "SHADoesNotMatch" kind of error.
type ErrSHANotFound struct {
SHA string
}
// IsErrSHANotFound checks if an error is a ErrSHANotFound.
func IsErrSHANotFound ( err error ) bool {
_ , ok := err . ( ErrSHANotFound )
return ok
}
func ( err ErrSHANotFound ) Error ( ) string {
return fmt . Sprintf ( "sha not found [%s]" , err . SHA )
}
2022-10-18 08:50:37 +03:00
func ( err ErrSHANotFound ) Unwrap ( ) error {
return util . ErrNotExist
}
2019-04-17 19:06:35 +03:00
// ErrCommitIDDoesNotMatch represents a "CommitIDDoesNotMatch" kind of error.
type ErrCommitIDDoesNotMatch struct {
GivenCommitID string
CurrentCommitID string
}
// IsErrCommitIDDoesNotMatch checks if an error is a ErrCommitIDDoesNotMatch.
func IsErrCommitIDDoesNotMatch ( err error ) bool {
_ , ok := err . ( ErrCommitIDDoesNotMatch )
return ok
}
func ( err ErrCommitIDDoesNotMatch ) Error ( ) string {
return fmt . Sprintf ( "file CommitID does not match [given: %s, expected: %s]" , err . GivenCommitID , err . CurrentCommitID )
}
// ErrSHAOrCommitIDNotProvided represents a "SHAOrCommitIDNotProvided" kind of error.
type ErrSHAOrCommitIDNotProvided struct { }
// IsErrSHAOrCommitIDNotProvided checks if an error is a ErrSHAOrCommitIDNotProvided.
func IsErrSHAOrCommitIDNotProvided ( err error ) bool {
_ , ok := err . ( ErrSHAOrCommitIDNotProvided )
return ok
}
func ( err ErrSHAOrCommitIDNotProvided ) Error ( ) string {
2021-07-08 14:38:13 +03:00
return "a SHA or commit ID must be proved when updating a file"
2019-04-17 19:06:35 +03:00
}
2018-01-05 21:56:50 +03:00
// ErrInvalidMergeStyle represents an error if merging with disabled merge strategy
type ErrInvalidMergeStyle struct {
ID int64
2021-12-10 04:27:50 +03:00
Style repo_model . MergeStyle
2018-01-05 21:56:50 +03:00
}
// IsErrInvalidMergeStyle checks if an error is a ErrInvalidMergeStyle.
func IsErrInvalidMergeStyle ( err error ) bool {
_ , ok := err . ( ErrInvalidMergeStyle )
return ok
}
func ( err ErrInvalidMergeStyle ) Error ( ) string {
return fmt . Sprintf ( "merge strategy is not allowed or is invalid [repo_id: %d, strategy: %s]" ,
err . ID , err . Style )
}
2022-10-18 08:50:37 +03:00
func ( err ErrInvalidMergeStyle ) Unwrap ( ) error {
return util . ErrInvalidArgument
}
2019-11-10 11:42:51 +03:00
// ErrMergeConflicts represents an error if merging fails with a conflict
type ErrMergeConflicts struct {
2021-12-10 04:27:50 +03:00
Style repo_model . MergeStyle
2019-11-10 11:42:51 +03:00
StdOut string
StdErr string
Err error
}
// IsErrMergeConflicts checks if an error is a ErrMergeConflicts.
func IsErrMergeConflicts ( err error ) bool {
_ , ok := err . ( ErrMergeConflicts )
return ok
}
func ( err ErrMergeConflicts ) Error ( ) string {
return fmt . Sprintf ( "Merge Conflict Error: %v: %s\n%s" , err . Err , err . StdErr , err . StdOut )
}
// ErrMergeUnrelatedHistories represents an error if merging fails due to unrelated histories
type ErrMergeUnrelatedHistories struct {
2021-12-10 04:27:50 +03:00
Style repo_model . MergeStyle
2019-11-10 11:42:51 +03:00
StdOut string
StdErr string
Err error
}
// IsErrMergeUnrelatedHistories checks if an error is a ErrMergeUnrelatedHistories.
func IsErrMergeUnrelatedHistories ( err error ) bool {
_ , ok := err . ( ErrMergeUnrelatedHistories )
return ok
}
func ( err ErrMergeUnrelatedHistories ) Error ( ) string {
return fmt . Sprintf ( "Merge UnrelatedHistories Error: %v: %s\n%s" , err . Err , err . StdErr , err . StdOut )
}
// ErrRebaseConflicts represents an error if rebase fails with a conflict
type ErrRebaseConflicts struct {
2021-12-10 04:27:50 +03:00
Style repo_model . MergeStyle
2019-11-10 11:42:51 +03:00
CommitSHA string
StdOut string
StdErr string
Err error
}
// IsErrRebaseConflicts checks if an error is a ErrRebaseConflicts.
func IsErrRebaseConflicts ( err error ) bool {
_ , ok := err . ( ErrRebaseConflicts )
return ok
}
func ( err ErrRebaseConflicts ) Error ( ) string {
return fmt . Sprintf ( "Rebase Error: %v: Whilst Rebasing: %s\n%s\n%s" , err . Err , err . CommitSHA , err . StdErr , err . StdOut )
}
2019-12-16 09:20:25 +03:00
// ErrPullRequestHasMerged represents a "PullRequestHasMerged"-error
type ErrPullRequestHasMerged struct {
ID int64
IssueID int64
HeadRepoID int64
BaseRepoID int64
HeadBranch string
BaseBranch string
}
// IsErrPullRequestHasMerged checks if an error is a ErrPullRequestHasMerged.
func IsErrPullRequestHasMerged ( err error ) bool {
_ , ok := err . ( ErrPullRequestHasMerged )
return ok
}
// Error does pretty-printing :D
func ( err ErrPullRequestHasMerged ) Error ( ) string {
return fmt . Sprintf ( "pull request has merged [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 . HeadBranch , err . BaseBranch )
}