1a9821f57a
* Move access and repo permission to models/perm/access * fix test * fix git test * Move functions sequence * Some improvements per @KN4CK3R and @delvh * Move issues related code to models/issues * Move some issues related sub package * Merge * Fix test * Fix test * Fix test * Fix test * Rename some files
727 lines
21 KiB
Go
727 lines
21 KiB
Go
// Copyright 2015 The Gogs Authors. All rights reserved.
|
|
// Copyright 2019 The Gitea 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"
|
|
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
|
"code.gitea.io/gitea/modules/git"
|
|
)
|
|
|
|
// ErrUserOwnRepos represents a "UserOwnRepos" kind of error.
|
|
type ErrUserOwnRepos struct {
|
|
UID int64
|
|
}
|
|
|
|
// IsErrUserOwnRepos checks if an error is a ErrUserOwnRepos.
|
|
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)
|
|
}
|
|
|
|
// ErrUserHasOrgs represents a "UserHasOrgs" kind of error.
|
|
type ErrUserHasOrgs struct {
|
|
UID int64
|
|
}
|
|
|
|
// IsErrUserHasOrgs checks if an error is a ErrUserHasOrgs.
|
|
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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// __ __.__ __ .__
|
|
// / \ / \__| | _|__|
|
|
// \ \/\/ / | |/ / |
|
|
// \ /| | <| |
|
|
// \__/\ / |__|__|_ \__|
|
|
// \/ \/
|
|
|
|
// ErrWikiAlreadyExist represents a "WikiAlreadyExist" kind of error.
|
|
type ErrWikiAlreadyExist struct {
|
|
Title string
|
|
}
|
|
|
|
// IsErrWikiAlreadyExist checks if an error is an ErrWikiAlreadyExist.
|
|
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)
|
|
}
|
|
|
|
// ErrWikiReservedName represents a reserved name error.
|
|
type ErrWikiReservedName struct {
|
|
Title string
|
|
}
|
|
|
|
// IsErrWikiReservedName checks if an error is an ErrWikiReservedName.
|
|
func IsErrWikiReservedName(err error) bool {
|
|
_, ok := err.(ErrWikiReservedName)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrWikiReservedName) Error() string {
|
|
return fmt.Sprintf("wiki title is reserved: %s", err.Title)
|
|
}
|
|
|
|
// ErrWikiInvalidFileName represents an invalid wiki file name.
|
|
type ErrWikiInvalidFileName struct {
|
|
FileName string
|
|
}
|
|
|
|
// IsErrWikiInvalidFileName checks if an error is an ErrWikiInvalidFileName.
|
|
func IsErrWikiInvalidFileName(err error) bool {
|
|
_, ok := err.(ErrWikiInvalidFileName)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrWikiInvalidFileName) Error() string {
|
|
return fmt.Sprintf("Invalid wiki filename: %s", err.FileName)
|
|
}
|
|
|
|
// _____ ___________ __
|
|
// / _ \ ____ ____ ____ ______ _____\__ ___/___ | | __ ____ ____
|
|
// / /_\ \_/ ___\/ ___\/ __ \ / ___// ___/ | | / _ \| |/ // __ \ / \
|
|
// / | \ \__\ \__\ ___/ \___ \ \___ \ | |( <_> ) <\ ___/| | \
|
|
// \____|__ /\___ >___ >___ >____ >____ > |____| \____/|__|_ \\___ >___| /
|
|
// \/ \/ \/ \/ \/ \/ \/ \/ \/
|
|
|
|
// ErrAccessTokenNotExist represents a "AccessTokenNotExist" kind of error.
|
|
type ErrAccessTokenNotExist struct {
|
|
Token string
|
|
}
|
|
|
|
// IsErrAccessTokenNotExist checks if an error is a ErrAccessTokenNotExist.
|
|
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.Token)
|
|
}
|
|
|
|
// ErrAccessTokenEmpty represents a "AccessTokenEmpty" kind of error.
|
|
type ErrAccessTokenEmpty struct{}
|
|
|
|
// IsErrAccessTokenEmpty checks if an error is a ErrAccessTokenEmpty.
|
|
func IsErrAccessTokenEmpty(err error) bool {
|
|
_, ok := err.(ErrAccessTokenEmpty)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrAccessTokenEmpty) Error() string {
|
|
return "access token is empty"
|
|
}
|
|
|
|
// ErrNoPendingRepoTransfer is an error type for repositories without a pending
|
|
// transfer request
|
|
type ErrNoPendingRepoTransfer struct {
|
|
RepoID int64
|
|
}
|
|
|
|
func (e ErrNoPendingRepoTransfer) Error() string {
|
|
return fmt.Sprintf("repository doesn't have a pending transfer [repo_id: %d]", e.RepoID)
|
|
}
|
|
|
|
// IsErrNoPendingTransfer is an error type when a repository has no pending
|
|
// transfers
|
|
func IsErrNoPendingTransfer(err error) bool {
|
|
_, ok := err.(ErrNoPendingRepoTransfer)
|
|
return ok
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// ErrForkAlreadyExist represents a "ForkAlreadyExist" kind of error.
|
|
type ErrForkAlreadyExist struct {
|
|
Uname string
|
|
RepoName string
|
|
ForkName string
|
|
}
|
|
|
|
// IsErrForkAlreadyExist checks if an error is an ErrForkAlreadyExist.
|
|
func IsErrForkAlreadyExist(err error) bool {
|
|
_, ok := err.(ErrForkAlreadyExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrForkAlreadyExist) Error() string {
|
|
return fmt.Sprintf("repository is already forked by user [uname: %s, repo path: %s, fork path: %s]", err.Uname, err.RepoName, err.ForkName)
|
|
}
|
|
|
|
// ErrInvalidCloneAddr represents a "InvalidCloneAddr" kind of error.
|
|
type ErrInvalidCloneAddr struct {
|
|
Host string
|
|
IsURLError bool
|
|
IsInvalidPath bool
|
|
IsProtocolInvalid bool
|
|
IsPermissionDenied bool
|
|
LocalPath bool
|
|
}
|
|
|
|
// IsErrInvalidCloneAddr checks if an error is a ErrInvalidCloneAddr.
|
|
func IsErrInvalidCloneAddr(err error) bool {
|
|
_, ok := err.(*ErrInvalidCloneAddr)
|
|
return ok
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
// ErrUpdateTaskNotExist represents a "UpdateTaskNotExist" kind of error.
|
|
type ErrUpdateTaskNotExist struct {
|
|
UUID string
|
|
}
|
|
|
|
// IsErrUpdateTaskNotExist checks if an error is a ErrUpdateTaskNotExist.
|
|
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)
|
|
}
|
|
|
|
// ErrReleaseAlreadyExist represents a "ReleaseAlreadyExist" kind of error.
|
|
type ErrReleaseAlreadyExist struct {
|
|
TagName string
|
|
}
|
|
|
|
// IsErrReleaseAlreadyExist checks if an error is a ErrReleaseAlreadyExist.
|
|
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)
|
|
}
|
|
|
|
// ErrReleaseNotExist represents a "ReleaseNotExist" kind of error.
|
|
type ErrReleaseNotExist struct {
|
|
ID int64
|
|
TagName string
|
|
}
|
|
|
|
// IsErrReleaseNotExist checks if an error is a ErrReleaseNotExist.
|
|
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)
|
|
}
|
|
|
|
// ErrInvalidTagName represents a "InvalidTagName" kind of error.
|
|
type ErrInvalidTagName struct {
|
|
TagName string
|
|
}
|
|
|
|
// IsErrInvalidTagName checks if an error is a ErrInvalidTagName.
|
|
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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// ErrFilePathInvalid represents a "FilePathInvalid" kind of error.
|
|
type ErrFilePathInvalid struct {
|
|
Message string
|
|
Path string
|
|
Name string
|
|
Type git.EntryMode
|
|
}
|
|
|
|
// IsErrFilePathInvalid checks if an error is an ErrFilePathInvalid.
|
|
func IsErrFilePathInvalid(err error) bool {
|
|
_, ok := err.(ErrFilePathInvalid)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrFilePathInvalid) Error() string {
|
|
if err.Message != "" {
|
|
return err.Message
|
|
}
|
|
return fmt.Sprintf("path is invalid [path: %s]", err.Path)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// __________ .__
|
|
// \______ \____________ ____ ____ | |__
|
|
// | | _/\_ __ \__ \ / \_/ ___\| | \
|
|
// | | \ | | \// __ \| | \ \___| Y \
|
|
// |______ / |__| (____ /___| /\___ >___| /
|
|
// \/ \/ \/ \/ \/
|
|
|
|
// ErrBranchDoesNotExist represents an error that branch with such name does not exist.
|
|
type ErrBranchDoesNotExist struct {
|
|
BranchName string
|
|
}
|
|
|
|
// IsErrBranchDoesNotExist checks if an error is an ErrBranchDoesNotExist.
|
|
func IsErrBranchDoesNotExist(err error) bool {
|
|
_, ok := err.(ErrBranchDoesNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrBranchDoesNotExist) Error() string {
|
|
return fmt.Sprintf("branch does not exist [name: %s]", err.BranchName)
|
|
}
|
|
|
|
// ErrBranchAlreadyExists represents an error that branch with such name already exists.
|
|
type ErrBranchAlreadyExists struct {
|
|
BranchName string
|
|
}
|
|
|
|
// IsErrBranchAlreadyExists checks if an error is an ErrBranchAlreadyExists.
|
|
func IsErrBranchAlreadyExists(err error) bool {
|
|
_, ok := err.(ErrBranchAlreadyExists)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrBranchAlreadyExists) Error() string {
|
|
return fmt.Sprintf("branch already exists [name: %s]", err.BranchName)
|
|
}
|
|
|
|
// ErrBranchNameConflict represents an error that branch name conflicts with other branch.
|
|
type ErrBranchNameConflict struct {
|
|
BranchName string
|
|
}
|
|
|
|
// IsErrBranchNameConflict checks if an error is an ErrBranchNameConflict.
|
|
func IsErrBranchNameConflict(err error) bool {
|
|
_, ok := err.(ErrBranchNameConflict)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrBranchNameConflict) Error() string {
|
|
return fmt.Sprintf("branch conflicts with existing branch [name: %s]", err.BranchName)
|
|
}
|
|
|
|
// ErrBranchesEqual represents an error that branch name conflicts with other branch.
|
|
type ErrBranchesEqual struct {
|
|
BaseBranchName string
|
|
HeadBranchName string
|
|
}
|
|
|
|
// IsErrBranchesEqual checks if an error is an ErrBranchesEqual.
|
|
func IsErrBranchesEqual(err error) bool {
|
|
_, ok := err.(ErrBranchesEqual)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrBranchesEqual) Error() string {
|
|
return fmt.Sprintf("branches are equal [head: %sm base: %s]", err.HeadBranchName, err.BaseBranchName)
|
|
}
|
|
|
|
// ErrDisallowedToMerge represents an error that a branch is protected and the current user is not allowed to modify it.
|
|
type ErrDisallowedToMerge struct {
|
|
Reason string
|
|
}
|
|
|
|
// IsErrDisallowedToMerge checks if an error is an ErrDisallowedToMerge.
|
|
func IsErrDisallowedToMerge(err error) bool {
|
|
_, ok := err.(ErrDisallowedToMerge)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrDisallowedToMerge) Error() string {
|
|
return fmt.Sprintf("not allowed to merge [reason: %s]", err.Reason)
|
|
}
|
|
|
|
// ErrTagAlreadyExists represents an error that tag with such name already exists.
|
|
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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// 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 {
|
|
return "a SHA or commit ID must be proved when updating a file"
|
|
}
|
|
|
|
// ErrInvalidMergeStyle represents an error if merging with disabled merge strategy
|
|
type ErrInvalidMergeStyle struct {
|
|
ID int64
|
|
Style repo_model.MergeStyle
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// ErrMergeConflicts represents an error if merging fails with a conflict
|
|
type ErrMergeConflicts struct {
|
|
Style repo_model.MergeStyle
|
|
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 {
|
|
Style repo_model.MergeStyle
|
|
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 {
|
|
Style repo_model.MergeStyle
|
|
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)
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
// _________ __ __ .__
|
|
// / _____// |_ ____ ________ _ _______ _/ |_ ____ | |__
|
|
// \_____ \\ __\/ _ \\____ \ \/ \/ /\__ \\ __\/ ___\| | \
|
|
// / \| | ( <_> ) |_> > / / __ \| | \ \___| Y \
|
|
// /_______ /|__| \____/| __/ \/\_/ (____ /__| \___ >___| /
|
|
// \/ |__| \/ \/ \/
|
|
|
|
// ErrStopwatchNotExist represents a "Stopwatch Not Exist" kind of error.
|
|
type ErrStopwatchNotExist struct {
|
|
ID int64
|
|
}
|
|
|
|
// IsErrStopwatchNotExist checks if an error is a ErrStopwatchNotExist.
|
|
func IsErrStopwatchNotExist(err error) bool {
|
|
_, ok := err.(ErrStopwatchNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrStopwatchNotExist) Error() string {
|
|
return fmt.Sprintf("stopwatch does not exist [id: %d]", err.ID)
|
|
}
|
|
|
|
// ___________ __ .______________.__
|
|
// \__ ___/___________ ____ | | __ ____ __| _/\__ ___/|__| _____ ____
|
|
// | | \_ __ \__ \ _/ ___\| |/ // __ \ / __ | | | | |/ \_/ __ \
|
|
// | | | | \// __ \\ \___| <\ ___// /_/ | | | | | Y Y \ ___/
|
|
// |____| |__| (____ /\___ >__|_ \\___ >____ | |____| |__|__|_| /\___ >
|
|
// \/ \/ \/ \/ \/ \/ \/
|
|
|
|
// ErrTrackedTimeNotExist represents a "TrackedTime Not Exist" kind of error.
|
|
type ErrTrackedTimeNotExist struct {
|
|
ID int64
|
|
}
|
|
|
|
// IsErrTrackedTimeNotExist checks if an error is a ErrTrackedTimeNotExist.
|
|
func IsErrTrackedTimeNotExist(err error) bool {
|
|
_, ok := err.(ErrTrackedTimeNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrTrackedTimeNotExist) Error() string {
|
|
return fmt.Sprintf("tracked time does not exist [id: %d]", err.ID)
|
|
}
|
|
|
|
// ____ ___ .__ .___
|
|
// | | \______ | | _________ __| _/
|
|
// | | /\____ \| | / _ \__ \ / __ |
|
|
// | | / | |_> > |_( <_> ) __ \_/ /_/ |
|
|
// |______/ | __/|____/\____(____ /\____ |
|
|
// |__| \/ \/
|
|
//
|
|
|
|
// ErrUploadNotExist represents a "UploadNotExist" kind of error.
|
|
type ErrUploadNotExist struct {
|
|
ID int64
|
|
UUID string
|
|
}
|
|
|
|
// IsErrUploadNotExist checks if an error is a ErrUploadNotExist.
|
|
func IsErrUploadNotExist(err error) bool {
|
|
_, ok := err.(ErrUploadNotExist)
|
|
return ok
|
|
}
|
|
|
|
func (err ErrUploadNotExist) Error() string {
|
|
return fmt.Sprintf("attachment does not exist [id: %d, uuid: %s]", err.ID, err.UUID)
|
|
}
|