2015-03-16 04:04:27 -04:00
|
|
|
// Copyright 2015 The Gogs Authors. All rights reserved.
|
2019-04-17 12:06:35 -04:00
|
|
|
// Copyright 2019 The Gitea Authors. All rights reserved.
|
2015-03-16 04:04:27 -04:00
|
|
|
// Use of this source code is governed by a MIT-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package models
|
|
|
|
|
2019-04-17 12:06:35 -04:00
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
|
|
|
|
"code.gitea.io/gitea/modules/git"
|
|
|
|
)
|
2015-03-16 04:04:27 -04:00
|
|
|
|
2019-09-24 01:02:49 -04:00
|
|
|
// ErrNotExist represents a non-exist error.
|
|
|
|
type ErrNotExist struct {
|
|
|
|
ID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrNotExist checks if an error is an ErrNotExist
|
|
|
|
func IsErrNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("record does not exist [id: %d]", err.ID)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrNameReserved represents a "reserved name" error.
|
2015-03-26 17:11:47 -04:00
|
|
|
type ErrNameReserved struct {
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrNameReserved checks if an error is a ErrNameReserved.
|
2015-03-26 17:11:47 -04:00
|
|
|
func IsErrNameReserved(err error) bool {
|
|
|
|
_, ok := err.(ErrNameReserved)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrNameReserved) Error() string {
|
2015-11-03 18:40:52 -05:00
|
|
|
return fmt.Sprintf("name is reserved [name: %s]", err.Name)
|
2015-03-26 17:11:47 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrNamePatternNotAllowed represents a "pattern not allowed" error.
|
2015-03-26 17:11:47 -04:00
|
|
|
type ErrNamePatternNotAllowed struct {
|
|
|
|
Pattern string
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04:00
|
|
|
// IsErrNamePatternNotAllowed checks if an error is an ErrNamePatternNotAllowed.
|
2015-03-26 17:11:47 -04:00
|
|
|
func IsErrNamePatternNotAllowed(err error) bool {
|
|
|
|
_, ok := err.(ErrNamePatternNotAllowed)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrNamePatternNotAllowed) Error() string {
|
2015-11-03 18:40:52 -05:00
|
|
|
return fmt.Sprintf("name pattern is not allowed [pattern: %s]", err.Pattern)
|
2015-03-26 17:11:47 -04:00
|
|
|
}
|
|
|
|
|
2020-02-23 14:52:05 -05:00
|
|
|
// ErrNameCharsNotAllowed represents a "character not allowed in name" error.
|
|
|
|
type ErrNameCharsNotAllowed struct {
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrNameCharsNotAllowed checks if an error is an ErrNameCharsNotAllowed.
|
|
|
|
func IsErrNameCharsNotAllowed(err error) bool {
|
|
|
|
_, ok := err.(ErrNameCharsNotAllowed)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrNameCharsNotAllowed) Error() string {
|
|
|
|
return fmt.Sprintf("User name is invalid [%s]: must be valid alpha or numeric or dash(-_) or dot characters", err.Name)
|
|
|
|
}
|
|
|
|
|
2017-11-20 22:49:33 -05:00
|
|
|
// ErrSSHDisabled represents an "SSH disabled" error.
|
2021-03-14 14:52:12 -04:00
|
|
|
type ErrSSHDisabled struct{}
|
2017-11-20 22:49:33 -05:00
|
|
|
|
|
|
|
// IsErrSSHDisabled checks if an error is a ErrSSHDisabled.
|
|
|
|
func IsErrSSHDisabled(err error) bool {
|
|
|
|
_, ok := err.(ErrSSHDisabled)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrSSHDisabled) Error() string {
|
|
|
|
return "SSH is disabled"
|
|
|
|
}
|
|
|
|
|
2015-03-17 21:51:39 -04:00
|
|
|
// ____ ___
|
|
|
|
// | | \______ ___________
|
|
|
|
// | | / ___// __ \_ __ \
|
|
|
|
// | | /\___ \\ ___/| | \/
|
|
|
|
// |______//____ >\___ >__|
|
|
|
|
// \/ \/
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrUserAlreadyExist represents a "user already exists" error.
|
2015-03-26 17:11:47 -04:00
|
|
|
type ErrUserAlreadyExist struct {
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrUserAlreadyExist checks if an error is a ErrUserAlreadyExists.
|
2015-03-26 17:11:47 -04:00
|
|
|
func IsErrUserAlreadyExist(err error) bool {
|
|
|
|
_, ok := err.(ErrUserAlreadyExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrUserAlreadyExist) Error() string {
|
2015-11-03 18:40:52 -05:00
|
|
|
return fmt.Sprintf("user already exists [name: %s]", err.Name)
|
2015-03-26 17:11:47 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrUserNotExist represents a "UserNotExist" kind of error.
|
2015-08-04 23:14:17 -04:00
|
|
|
type ErrUserNotExist struct {
|
2016-11-11 18:01:09 -05:00
|
|
|
UID int64
|
|
|
|
Name string
|
|
|
|
KeyID int64
|
2015-08-04 23:14:17 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrUserNotExist checks if an error is a ErrUserNotExist.
|
2015-08-04 23:14:17 -04:00
|
|
|
func IsErrUserNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrUserNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrUserNotExist) Error() string {
|
2016-11-11 18:01:09 -05:00
|
|
|
return fmt.Sprintf("user does not exist [uid: %d, name: %s, keyid: %d]", err.UID, err.Name, err.KeyID)
|
2015-08-04 23:14:17 -04:00
|
|
|
}
|
|
|
|
|
2019-02-19 02:19:28 -05:00
|
|
|
// ErrUserProhibitLogin represents a "ErrUserProhibitLogin" kind of error.
|
|
|
|
type ErrUserProhibitLogin struct {
|
|
|
|
UID int64
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrUserProhibitLogin checks if an error is a ErrUserProhibitLogin
|
|
|
|
func IsErrUserProhibitLogin(err error) bool {
|
|
|
|
_, ok := err.(ErrUserProhibitLogin)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrUserProhibitLogin) Error() string {
|
|
|
|
return fmt.Sprintf("user is not allowed login [uid: %d, name: %s]", err.UID, err.Name)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrUserInactive represents a "ErrUserInactive" kind of error.
|
|
|
|
type ErrUserInactive struct {
|
|
|
|
UID int64
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrUserInactive checks if an error is a ErrUserInactive
|
|
|
|
func IsErrUserInactive(err error) bool {
|
|
|
|
_, ok := err.(ErrUserInactive)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrUserInactive) Error() string {
|
|
|
|
return fmt.Sprintf("user is inactive [uid: %d, name: %s]", err.UID, err.Name)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrUserOwnRepos represents a "UserOwnRepos" kind of error.
|
2015-03-17 21:51:39 -04:00
|
|
|
type ErrUserOwnRepos struct {
|
|
|
|
UID int64
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrUserOwnRepos checks if an error is a ErrUserOwnRepos.
|
2015-03-17 21:51:39 -04:00
|
|
|
func IsErrUserOwnRepos(err error) bool {
|
|
|
|
_, ok := err.(ErrUserOwnRepos)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrUserOwnRepos) Error() string {
|
2015-11-03 18:40:52 -05:00
|
|
|
return fmt.Sprintf("user still has ownership of repositories [uid: %d]", err.UID)
|
2015-03-17 21:51:39 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrUserHasOrgs represents a "UserHasOrgs" kind of error.
|
2015-03-17 21:51:39 -04:00
|
|
|
type ErrUserHasOrgs struct {
|
|
|
|
UID int64
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrUserHasOrgs checks if an error is a ErrUserHasOrgs.
|
2015-03-17 21:51:39 -04:00
|
|
|
func IsErrUserHasOrgs(err error) bool {
|
|
|
|
_, ok := err.(ErrUserHasOrgs)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrUserHasOrgs) Error() string {
|
2015-11-03 18:40:52 -05:00
|
|
|
return fmt.Sprintf("user still has membership of organizations [uid: %d]", err.UID)
|
2015-03-17 21:51:39 -04:00
|
|
|
}
|
|
|
|
|
2016-12-30 21:33:30 -05:00
|
|
|
// ErrUserNotAllowedCreateOrg represents a "UserNotAllowedCreateOrg" kind of error.
|
2021-03-14 14:52:12 -04:00
|
|
|
type ErrUserNotAllowedCreateOrg struct{}
|
2016-12-30 21:33:30 -05:00
|
|
|
|
|
|
|
// IsErrUserNotAllowedCreateOrg checks if an error is an ErrUserNotAllowedCreateOrg.
|
|
|
|
func IsErrUserNotAllowedCreateOrg(err error) bool {
|
|
|
|
_, ok := err.(ErrUserNotAllowedCreateOrg)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrUserNotAllowedCreateOrg) Error() string {
|
2020-03-30 14:52:45 -04:00
|
|
|
return "user is not allowed to create organizations"
|
2016-12-30 21:33:30 -05:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrReachLimitOfRepo represents a "ReachLimitOfRepo" kind of error.
|
2015-12-10 12:37:53 -05:00
|
|
|
type ErrReachLimitOfRepo struct {
|
|
|
|
Limit int
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrReachLimitOfRepo checks if an error is a ErrReachLimitOfRepo.
|
2015-12-10 12:37:53 -05:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2015-11-27 01:50:38 -05:00
|
|
|
// __ __.__ __ .__
|
|
|
|
// / \ / \__| | _|__|
|
|
|
|
// \ \/\/ / | |/ / |
|
|
|
|
// \ /| | <| |
|
|
|
|
// \__/\ / |__|__|_ \__|
|
|
|
|
// \/ \/
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrWikiAlreadyExist represents a "WikiAlreadyExist" kind of error.
|
2015-11-27 01:50:38 -05:00
|
|
|
type ErrWikiAlreadyExist struct {
|
|
|
|
Title string
|
|
|
|
}
|
|
|
|
|
2017-11-28 04:43:51 -05:00
|
|
|
// IsErrWikiAlreadyExist checks if an error is an ErrWikiAlreadyExist.
|
2015-11-27 01:50:38 -05:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2017-11-28 04:43:51 -05:00
|
|
|
// 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)
|
|
|
|
}
|
|
|
|
|
2018-02-05 09:56:30 -05:00
|
|
|
// 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)
|
|
|
|
}
|
|
|
|
|
2015-08-06 10:48:11 -04:00
|
|
|
// __________ ___. .__ .__ ____ __.
|
|
|
|
// \______ \__ _\_ |__ | | |__| ____ | |/ _|____ ___.__.
|
|
|
|
// | ___/ | \ __ \| | | |/ ___\ | <_/ __ < | |
|
|
|
|
// | | | | / \_\ \ |_| \ \___ | | \ ___/\___ |
|
|
|
|
// |____| |____/|___ /____/__|\___ > |____|__ \___ > ____|
|
|
|
|
// \/ \/ \/ \/\/
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrKeyUnableVerify represents a "KeyUnableVerify" kind of error.
|
2015-11-18 21:21:47 -05:00
|
|
|
type ErrKeyUnableVerify struct {
|
|
|
|
Result string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrKeyUnableVerify checks if an error is a ErrKeyUnableVerify.
|
2015-11-18 21:21:47 -05:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrKeyNotExist represents a "KeyNotExist" kind of error.
|
2015-08-06 10:48:11 -04:00
|
|
|
type ErrKeyNotExist struct {
|
|
|
|
ID int64
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrKeyNotExist checks if an error is a ErrKeyNotExist.
|
2015-08-06 10:48:11 -04:00
|
|
|
func IsErrKeyNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrKeyNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrKeyNotExist) Error() string {
|
2015-11-03 18:40:52 -05:00
|
|
|
return fmt.Sprintf("public key does not exist [id: %d]", err.ID)
|
2015-08-06 10:48:11 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrKeyAlreadyExist represents a "KeyAlreadyExist" kind of error.
|
2015-08-06 10:48:11 -04:00
|
|
|
type ErrKeyAlreadyExist struct {
|
2017-02-14 01:12:52 -05:00
|
|
|
OwnerID int64
|
|
|
|
Fingerprint string
|
|
|
|
Content string
|
2015-08-06 10:48:11 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrKeyAlreadyExist checks if an error is a ErrKeyAlreadyExist.
|
2015-08-06 10:48:11 -04:00
|
|
|
func IsErrKeyAlreadyExist(err error) bool {
|
|
|
|
_, ok := err.(ErrKeyAlreadyExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrKeyAlreadyExist) Error() string {
|
2019-04-26 11:01:54 -04:00
|
|
|
return fmt.Sprintf("public key already exists [owner_id: %d, finger_print: %s, content: %s]",
|
2017-02-14 01:12:52 -05:00
|
|
|
err.OwnerID, err.Fingerprint, err.Content)
|
2015-08-06 10:48:11 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrKeyNameAlreadyUsed represents a "KeyNameAlreadyUsed" kind of error.
|
2015-08-06 10:48:11 -04:00
|
|
|
type ErrKeyNameAlreadyUsed struct {
|
|
|
|
OwnerID int64
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrKeyNameAlreadyUsed checks if an error is a ErrKeyNameAlreadyUsed.
|
2015-08-06 10:48:11 -04:00
|
|
|
func IsErrKeyNameAlreadyUsed(err error) bool {
|
|
|
|
_, ok := err.(ErrKeyNameAlreadyUsed)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrKeyNameAlreadyUsed) Error() string {
|
2015-11-03 18:40:52 -05:00
|
|
|
return fmt.Sprintf("public key already exists [owner_id: %d, name: %s]", err.OwnerID, err.Name)
|
2015-08-06 10:48:11 -04:00
|
|
|
}
|
|
|
|
|
2017-09-05 09:45:18 -04:00
|
|
|
// ErrGPGNoEmailFound represents a "ErrGPGNoEmailFound" kind of error.
|
|
|
|
type ErrGPGNoEmailFound struct {
|
|
|
|
FailedEmails []string
|
2021-07-13 09:28:07 -04:00
|
|
|
ID string
|
2017-04-26 09:10:43 -04:00
|
|
|
}
|
|
|
|
|
2017-09-05 09:45:18 -04:00
|
|
|
// IsErrGPGNoEmailFound checks if an error is a ErrGPGNoEmailFound.
|
|
|
|
func IsErrGPGNoEmailFound(err error) bool {
|
|
|
|
_, ok := err.(ErrGPGNoEmailFound)
|
2017-04-26 09:10:43 -04:00
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
2017-09-05 09:45:18 -04:00
|
|
|
func (err ErrGPGNoEmailFound) Error() string {
|
|
|
|
return fmt.Sprintf("none of the emails attached to the GPG key could be found: %v", err.FailedEmails)
|
2017-04-26 09:10:43 -04:00
|
|
|
}
|
|
|
|
|
2021-07-13 09:28:07 -04:00
|
|
|
// ErrGPGInvalidTokenSignature represents a "ErrGPGInvalidTokenSignature" kind of error.
|
|
|
|
type ErrGPGInvalidTokenSignature struct {
|
|
|
|
Wrapped error
|
|
|
|
ID string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrGPGInvalidTokenSignature checks if an error is a ErrGPGInvalidTokenSignature.
|
|
|
|
func IsErrGPGInvalidTokenSignature(err error) bool {
|
|
|
|
_, ok := err.(ErrGPGInvalidTokenSignature)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrGPGInvalidTokenSignature) Error() string {
|
|
|
|
return "the provided signature does not sign the token with the provided key"
|
|
|
|
}
|
|
|
|
|
2017-04-26 09:10:43 -04:00
|
|
|
// ErrGPGKeyParsing represents a "ErrGPGKeyParsing" kind of error.
|
|
|
|
type ErrGPGKeyParsing struct {
|
|
|
|
ParseError error
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrGPGKeyParsing checks if an error is a ErrGPGKeyParsing.
|
|
|
|
func IsErrGPGKeyParsing(err error) bool {
|
|
|
|
_, ok := err.(ErrGPGKeyParsing)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrGPGKeyParsing) Error() string {
|
|
|
|
return fmt.Sprintf("failed to parse gpg key %s", err.ParseError.Error())
|
|
|
|
}
|
|
|
|
|
2017-03-15 21:27:35 -04:00
|
|
|
// ErrGPGKeyNotExist represents a "GPGKeyNotExist" kind of error.
|
|
|
|
type ErrGPGKeyNotExist struct {
|
|
|
|
ID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrGPGKeyNotExist checks if an error is a ErrGPGKeyNotExist.
|
|
|
|
func IsErrGPGKeyNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrGPGKeyNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrGPGKeyNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("public gpg key does not exist [id: %d]", err.ID)
|
|
|
|
}
|
|
|
|
|
2019-04-14 12:43:56 -04:00
|
|
|
// ErrGPGKeyImportNotExist represents a "GPGKeyImportNotExist" kind of error.
|
|
|
|
type ErrGPGKeyImportNotExist struct {
|
|
|
|
ID string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrGPGKeyImportNotExist checks if an error is a ErrGPGKeyImportNotExist.
|
|
|
|
func IsErrGPGKeyImportNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrGPGKeyImportNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrGPGKeyImportNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("public gpg key import does not exist [id: %s]", err.ID)
|
|
|
|
}
|
|
|
|
|
2017-03-15 21:27:35 -04:00
|
|
|
// ErrGPGKeyIDAlreadyUsed represents a "GPGKeyIDAlreadyUsed" kind of error.
|
|
|
|
type ErrGPGKeyIDAlreadyUsed struct {
|
|
|
|
KeyID string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrGPGKeyIDAlreadyUsed checks if an error is a ErrKeyNameAlreadyUsed.
|
|
|
|
func IsErrGPGKeyIDAlreadyUsed(err error) bool {
|
|
|
|
_, ok := err.(ErrGPGKeyIDAlreadyUsed)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrGPGKeyIDAlreadyUsed) Error() string {
|
|
|
|
return fmt.Sprintf("public key already exists [key_id: %s]", err.KeyID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrGPGKeyAccessDenied represents a "GPGKeyAccessDenied" kind of Error.
|
|
|
|
type ErrGPGKeyAccessDenied struct {
|
|
|
|
UserID int64
|
|
|
|
KeyID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrGPGKeyAccessDenied checks if an error is a ErrGPGKeyAccessDenied.
|
|
|
|
func IsErrGPGKeyAccessDenied(err error) bool {
|
|
|
|
_, ok := err.(ErrGPGKeyAccessDenied)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
// Error pretty-prints an error of type ErrGPGKeyAccessDenied.
|
|
|
|
func (err ErrGPGKeyAccessDenied) Error() string {
|
|
|
|
return fmt.Sprintf("user does not have access to the key [user_id: %d, key_id: %d]",
|
|
|
|
err.UserID, err.KeyID)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrKeyAccessDenied represents a "KeyAccessDenied" kind of error.
|
2015-12-03 00:24:37 -05:00
|
|
|
type ErrKeyAccessDenied struct {
|
|
|
|
UserID int64
|
|
|
|
KeyID int64
|
|
|
|
Note string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrKeyAccessDenied checks if an error is a ErrKeyAccessDenied.
|
2015-12-03 00:24:37 -05:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrDeployKeyNotExist represents a "DeployKeyNotExist" kind of error.
|
2015-11-18 21:21:47 -05:00
|
|
|
type ErrDeployKeyNotExist struct {
|
|
|
|
ID int64
|
|
|
|
KeyID int64
|
|
|
|
RepoID int64
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrDeployKeyNotExist checks if an error is a ErrDeployKeyNotExist.
|
2015-11-18 21:21:47 -05:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrDeployKeyAlreadyExist represents a "DeployKeyAlreadyExist" kind of error.
|
2015-08-06 10:48:11 -04:00
|
|
|
type ErrDeployKeyAlreadyExist struct {
|
|
|
|
KeyID int64
|
|
|
|
RepoID int64
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrDeployKeyAlreadyExist checks if an error is a ErrDeployKeyAlreadyExist.
|
2015-08-06 10:48:11 -04:00
|
|
|
func IsErrDeployKeyAlreadyExist(err error) bool {
|
|
|
|
_, ok := err.(ErrDeployKeyAlreadyExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrDeployKeyAlreadyExist) Error() string {
|
2015-11-03 18:40:52 -05:00
|
|
|
return fmt.Sprintf("public key already exists [key_id: %d, repo_id: %d]", err.KeyID, err.RepoID)
|
2015-08-06 10:48:11 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrDeployKeyNameAlreadyUsed represents a "DeployKeyNameAlreadyUsed" kind of error.
|
2015-08-06 10:48:11 -04:00
|
|
|
type ErrDeployKeyNameAlreadyUsed struct {
|
|
|
|
RepoID int64
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrDeployKeyNameAlreadyUsed checks if an error is a ErrDeployKeyNameAlreadyUsed.
|
2015-08-06 10:48:11 -04:00
|
|
|
func IsErrDeployKeyNameAlreadyUsed(err error) bool {
|
|
|
|
_, ok := err.(ErrDeployKeyNameAlreadyUsed)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrDeployKeyNameAlreadyUsed) Error() string {
|
2020-10-12 09:44:56 -04:00
|
|
|
return fmt.Sprintf("public key with name already exists [repo_id: %d, name: %s]", err.RepoID, err.Name)
|
2015-08-06 10:48:11 -04:00
|
|
|
}
|
|
|
|
|
2015-09-02 02:40:15 -04:00
|
|
|
// _____ ___________ __
|
|
|
|
// / _ \ ____ ____ ____ ______ _____\__ ___/___ | | __ ____ ____
|
|
|
|
// / /_\ \_/ ___\/ ___\/ __ \ / ___// ___/ | | / _ \| |/ // __ \ / \
|
|
|
|
// / | \ \__\ \__\ ___/ \___ \ \___ \ | |( <_> ) <\ ___/| | \
|
|
|
|
// \____|__ /\___ >___ >___ >____ >____ > |____| \____/|__|_ \\___ >___| /
|
|
|
|
// \/ \/ \/ \/ \/ \/ \/ \/ \/
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrAccessTokenNotExist represents a "AccessTokenNotExist" kind of error.
|
2015-09-02 02:40:15 -04:00
|
|
|
type ErrAccessTokenNotExist struct {
|
2019-05-04 11:45:34 -04:00
|
|
|
Token string
|
2015-09-02 02:40:15 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrAccessTokenNotExist checks if an error is a ErrAccessTokenNotExist.
|
2015-09-02 02:40:15 -04:00
|
|
|
func IsErrAccessTokenNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrAccessTokenNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrAccessTokenNotExist) Error() string {
|
2019-05-04 11:45:34 -04:00
|
|
|
return fmt.Sprintf("access token does not exist [sha: %s]", err.Token)
|
2015-09-02 02:40:15 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrAccessTokenEmpty represents a "AccessTokenEmpty" kind of error.
|
2021-03-14 14:52:12 -04:00
|
|
|
type ErrAccessTokenEmpty struct{}
|
2016-06-27 05:02:39 -04:00
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrAccessTokenEmpty checks if an error is a ErrAccessTokenEmpty.
|
2016-06-27 05:02:39 -04:00
|
|
|
func IsErrAccessTokenEmpty(err error) bool {
|
|
|
|
_, ok := err.(ErrAccessTokenEmpty)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrAccessTokenEmpty) Error() string {
|
2020-03-30 14:52:45 -04:00
|
|
|
return "access token is empty"
|
2016-06-27 05:02:39 -04:00
|
|
|
}
|
|
|
|
|
2015-03-17 21:51:39 -04:00
|
|
|
// ________ .__ __ .__
|
|
|
|
// \_____ \_______ _________ ____ |__|____________ _/ |_|__| ____ ____
|
|
|
|
// / | \_ __ \/ ___\__ \ / \| \___ /\__ \\ __\ |/ _ \ / \
|
|
|
|
// / | \ | \/ /_/ > __ \| | \ |/ / / __ \| | | ( <_> ) | \
|
|
|
|
// \_______ /__| \___ (____ /___| /__/_____ \(____ /__| |__|\____/|___| /
|
|
|
|
// \/ /_____/ \/ \/ \/ \/ \/
|
|
|
|
|
2017-07-06 09:30:19 -04:00
|
|
|
// ErrOrgNotExist represents a "OrgNotExist" kind of error.
|
|
|
|
type ErrOrgNotExist struct {
|
|
|
|
ID int64
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrOrgNotExist checks if an error is a ErrOrgNotExist.
|
|
|
|
func IsErrOrgNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrOrgNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrOrgNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("org does not exist [id: %d, name: %s]", err.ID, err.Name)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrLastOrgOwner represents a "LastOrgOwner" kind of error.
|
2015-03-17 21:51:39 -04:00
|
|
|
type ErrLastOrgOwner struct {
|
|
|
|
UID int64
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrLastOrgOwner checks if an error is a ErrLastOrgOwner.
|
2015-03-17 21:51:39 -04:00
|
|
|
func IsErrLastOrgOwner(err error) bool {
|
|
|
|
_, ok := err.(ErrLastOrgOwner)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrLastOrgOwner) Error() string {
|
2015-11-03 18:40:52 -05:00
|
|
|
return fmt.Sprintf("user is the last member of owner team [uid: %d]", err.UID)
|
2015-03-17 21:51:39 -04:00
|
|
|
}
|
|
|
|
|
2017-11-28 15:58:37 -05:00
|
|
|
//.____ ____________________
|
|
|
|
//| | \_ _____/ _____/
|
|
|
|
//| | | __) \_____ \
|
|
|
|
//| |___| \ / \
|
|
|
|
//|_______ \___ / /_______ /
|
|
|
|
// \/ \/ \/
|
|
|
|
|
|
|
|
// ErrLFSLockNotExist represents a "LFSLockNotExist" kind of error.
|
|
|
|
type ErrLFSLockNotExist struct {
|
|
|
|
ID int64
|
|
|
|
RepoID int64
|
|
|
|
Path string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrLFSLockNotExist checks if an error is a ErrLFSLockNotExist.
|
|
|
|
func IsErrLFSLockNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrLFSLockNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrLFSLockNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("lfs lock does not exist [id: %d, rid: %d, path: %s]", err.ID, err.RepoID, err.Path)
|
|
|
|
}
|
|
|
|
|
2018-01-27 11:48:15 -05:00
|
|
|
// ErrLFSUnauthorizedAction represents a "LFSUnauthorizedAction" kind of error.
|
|
|
|
type ErrLFSUnauthorizedAction struct {
|
2017-11-28 15:58:37 -05:00
|
|
|
RepoID int64
|
|
|
|
UserName string
|
2018-01-27 11:48:15 -05:00
|
|
|
Mode AccessMode
|
2017-11-28 15:58:37 -05:00
|
|
|
}
|
|
|
|
|
2018-01-27 11:48:15 -05:00
|
|
|
// IsErrLFSUnauthorizedAction checks if an error is a ErrLFSUnauthorizedAction.
|
|
|
|
func IsErrLFSUnauthorizedAction(err error) bool {
|
|
|
|
_, ok := err.(ErrLFSUnauthorizedAction)
|
2017-11-28 15:58:37 -05:00
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
2018-01-27 11:48:15 -05:00
|
|
|
func (err ErrLFSUnauthorizedAction) Error() string {
|
|
|
|
if err.Mode == AccessModeWrite {
|
|
|
|
return fmt.Sprintf("User %s doesn't have write access for lfs lock [rid: %d]", err.UserName, err.RepoID)
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("User %s doesn't have read access for lfs lock [rid: %d]", err.UserName, err.RepoID)
|
2017-11-28 15:58:37 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// ErrLFSLockAlreadyExist represents a "LFSLockAlreadyExist" kind of error.
|
|
|
|
type ErrLFSLockAlreadyExist struct {
|
|
|
|
RepoID int64
|
|
|
|
Path string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrLFSLockAlreadyExist checks if an error is a ErrLFSLockAlreadyExist.
|
|
|
|
func IsErrLFSLockAlreadyExist(err error) bool {
|
|
|
|
_, ok := err.(ErrLFSLockAlreadyExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrLFSLockAlreadyExist) Error() string {
|
|
|
|
return fmt.Sprintf("lfs lock already exists [rid: %d, path: %s]", err.RepoID, err.Path)
|
|
|
|
}
|
|
|
|
|
2019-11-02 03:37:05 -04:00
|
|
|
// ErrLFSFileLocked represents a "LFSFileLocked" kind of error.
|
|
|
|
type ErrLFSFileLocked struct {
|
|
|
|
RepoID int64
|
|
|
|
Path string
|
|
|
|
UserName string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrLFSFileLocked checks if an error is a ErrLFSFileLocked.
|
|
|
|
func IsErrLFSFileLocked(err error) bool {
|
|
|
|
_, ok := err.(ErrLFSFileLocked)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrLFSFileLocked) Error() string {
|
|
|
|
return fmt.Sprintf("File is lfs locked [repo: %d, locked by: %s, path: %s]", err.RepoID, err.UserName, err.Path)
|
|
|
|
}
|
|
|
|
|
2015-03-16 04:04:27 -04:00
|
|
|
// __________ .__ __
|
|
|
|
// \______ \ ____ ______ ____ _____|__|/ |_ ___________ ___.__.
|
|
|
|
// | _// __ \\____ \ / _ \/ ___/ \ __\/ _ \_ __ < | |
|
|
|
|
// | | \ ___/| |_> > <_> )___ \| || | ( <_> ) | \/\___ |
|
|
|
|
// |____|_ /\___ > __/ \____/____ >__||__| \____/|__| / ____|
|
|
|
|
// \/ \/|__| \/ \/
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrRepoNotExist represents a "RepoNotExist" kind of error.
|
2015-03-16 04:04:27 -04:00
|
|
|
type ErrRepoNotExist struct {
|
2017-12-02 02:34:39 -05:00
|
|
|
ID int64
|
|
|
|
UID int64
|
|
|
|
OwnerName string
|
|
|
|
Name string
|
2015-03-16 04:04:27 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrRepoNotExist checks if an error is a ErrRepoNotExist.
|
2015-03-16 04:04:27 -04:00
|
|
|
func IsErrRepoNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrRepoNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrRepoNotExist) Error() string {
|
2017-12-02 02:34:39 -05:00
|
|
|
return fmt.Sprintf("repository does not exist [id: %d, uid: %d, owner_name: %s, name: %s]",
|
|
|
|
err.ID, err.UID, err.OwnerName, err.Name)
|
2015-03-16 04:04:27 -04:00
|
|
|
}
|
2015-08-05 06:26:18 -04:00
|
|
|
|
2021-02-28 19:47:30 -05:00
|
|
|
// 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)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrRepoAlreadyExist represents a "RepoAlreadyExist" kind of error.
|
2015-08-08 05:10:34 -04:00
|
|
|
type ErrRepoAlreadyExist struct {
|
|
|
|
Uname string
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrRepoAlreadyExist checks if an error is a ErrRepoAlreadyExist.
|
2015-08-08 05:10:34 -04:00
|
|
|
func IsErrRepoAlreadyExist(err error) bool {
|
|
|
|
_, ok := err.(ErrRepoAlreadyExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrRepoAlreadyExist) Error() string {
|
2015-08-27 11:06:14 -04:00
|
|
|
return fmt.Sprintf("repository already exists [uname: %s, name: %s]", err.Uname, err.Name)
|
|
|
|
}
|
|
|
|
|
2020-09-25 00:09:23 -04:00
|
|
|
// ErrRepoFilesAlreadyExist represents a "RepoFilesAlreadyExist" kind of error.
|
|
|
|
type ErrRepoFilesAlreadyExist struct {
|
|
|
|
Uname string
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrRepoFilesAlreadyExist checks if an error is a ErrRepoAlreadyExist.
|
|
|
|
func IsErrRepoFilesAlreadyExist(err error) bool {
|
|
|
|
_, ok := err.(ErrRepoFilesAlreadyExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrRepoFilesAlreadyExist) Error() string {
|
|
|
|
return fmt.Sprintf("repository files already exist [uname: %s, name: %s]", err.Uname, err.Name)
|
|
|
|
}
|
|
|
|
|
2019-06-12 16:20:43 -04:00
|
|
|
// 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)
|
|
|
|
}
|
|
|
|
|
2017-02-05 09:35:03 -05:00
|
|
|
// ErrRepoRedirectNotExist represents a "RepoRedirectNotExist" kind of error.
|
|
|
|
type ErrRepoRedirectNotExist struct {
|
2017-02-13 21:12:03 -05:00
|
|
|
OwnerID int64
|
2017-02-05 09:35:03 -05:00
|
|
|
RepoName string
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04:00
|
|
|
// IsErrRepoRedirectNotExist check if an error is an ErrRepoRedirectNotExist.
|
2017-02-05 09:35:03 -05:00
|
|
|
func IsErrRepoRedirectNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrRepoRedirectNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrRepoRedirectNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("repository redirect does not exist [uid: %d, name: %s]", err.OwnerID, err.RepoName)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrInvalidCloneAddr represents a "InvalidCloneAddr" kind of error.
|
2015-11-03 18:40:52 -05:00
|
|
|
type ErrInvalidCloneAddr struct {
|
2021-03-15 17:52:11 -04:00
|
|
|
Host string
|
2015-11-03 18:40:52 -05:00
|
|
|
IsURLError bool
|
|
|
|
IsInvalidPath bool
|
2021-03-15 17:52:11 -04:00
|
|
|
IsProtocolInvalid bool
|
2015-11-03 18:40:52 -05:00
|
|
|
IsPermissionDenied bool
|
2021-03-15 17:52:11 -04:00
|
|
|
LocalPath bool
|
|
|
|
NotResolvedIP bool
|
|
|
|
PrivateNet string
|
2015-11-03 18:40:52 -05:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrInvalidCloneAddr checks if an error is a ErrInvalidCloneAddr.
|
2015-11-03 18:40:52 -05:00
|
|
|
func IsErrInvalidCloneAddr(err error) bool {
|
2021-03-15 17:52:11 -04:00
|
|
|
_, ok := err.(*ErrInvalidCloneAddr)
|
2015-11-03 18:40:52 -05:00
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
2021-03-15 17:52:11 -04:00
|
|
|
func (err *ErrInvalidCloneAddr) Error() string {
|
|
|
|
if err.NotResolvedIP {
|
|
|
|
return fmt.Sprintf("migration/cloning from '%s' is not allowed: unknown hostname", err.Host)
|
|
|
|
}
|
|
|
|
if len(err.PrivateNet) != 0 {
|
|
|
|
return fmt.Sprintf("migration/cloning from '%s' is not allowed: the host resolve to a private ip address '%s'", err.Host, err.PrivateNet)
|
|
|
|
}
|
|
|
|
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-03 18:40:52 -05:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrUpdateTaskNotExist represents a "UpdateTaskNotExist" kind of error.
|
2015-11-04 21:57:10 -05:00
|
|
|
type ErrUpdateTaskNotExist struct {
|
|
|
|
UUID string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrUpdateTaskNotExist checks if an error is a ErrUpdateTaskNotExist.
|
2015-11-04 21:57:10 -05: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)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrReleaseAlreadyExist represents a "ReleaseAlreadyExist" kind of error.
|
2015-11-15 23:52:46 -05:00
|
|
|
type ErrReleaseAlreadyExist struct {
|
|
|
|
TagName string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrReleaseAlreadyExist checks if an error is a ErrReleaseAlreadyExist.
|
2015-11-15 23:52:46 -05:00
|
|
|
func IsErrReleaseAlreadyExist(err error) bool {
|
|
|
|
_, ok := err.(ErrReleaseAlreadyExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrReleaseAlreadyExist) Error() string {
|
2016-07-23 03:59:19 -04:00
|
|
|
return fmt.Sprintf("release tag already exist [tag_name: %s]", err.TagName)
|
2015-11-15 23:52:46 -05:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrReleaseNotExist represents a "ReleaseNotExist" kind of error.
|
2015-11-15 23:52:46 -05:00
|
|
|
type ErrReleaseNotExist struct {
|
2015-11-20 02:38:41 -05:00
|
|
|
ID int64
|
2015-11-15 23:52:46 -05:00
|
|
|
TagName string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrReleaseNotExist checks if an error is a ErrReleaseNotExist.
|
2015-11-15 23:52:46 -05:00
|
|
|
func IsErrReleaseNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrReleaseNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrReleaseNotExist) Error() string {
|
2016-07-23 03:59:19 -04:00
|
|
|
return fmt.Sprintf("release tag does not exist [id: %d, tag_name: %s]", err.ID, err.TagName)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrInvalidTagName represents a "InvalidTagName" kind of error.
|
2016-07-23 03:59:19 -04:00
|
|
|
type ErrInvalidTagName struct {
|
|
|
|
TagName string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrInvalidTagName checks if an error is a ErrInvalidTagName.
|
2016-07-23 03:59:19 -04: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-15 23:52:46 -05:00
|
|
|
}
|
|
|
|
|
2021-06-25 10:28:55 -04: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)
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04: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)
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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
|
2016-08-11 08:48:08 -04:00
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04:00
|
|
|
// IsErrFilePathInvalid checks if an error is an ErrFilePathInvalid.
|
|
|
|
func IsErrFilePathInvalid(err error) bool {
|
|
|
|
_, ok := err.(ErrFilePathInvalid)
|
2016-08-11 08:48:08 -04:00
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04: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 08:48:08 -04:00
|
|
|
}
|
|
|
|
|
2020-03-26 18:26:34 -04: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)
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04:00
|
|
|
// ErrUserDoesNotHaveAccessToRepo represets an error where the user doesn't has access to a given repo.
|
2018-05-09 12:29:04 -04:00
|
|
|
type ErrUserDoesNotHaveAccessToRepo struct {
|
|
|
|
UserID int64
|
|
|
|
RepoName string
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04:00
|
|
|
// IsErrUserDoesNotHaveAccessToRepo checks if an error is a ErrRepoFileAlreadyExists.
|
2018-05-09 12:29:04 -04:00
|
|
|
func IsErrUserDoesNotHaveAccessToRepo(err error) bool {
|
|
|
|
_, ok := err.(ErrUserDoesNotHaveAccessToRepo)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrUserDoesNotHaveAccessToRepo) Error() string {
|
2021-07-08 07:38:13 -04:00
|
|
|
return fmt.Sprintf("user doesn't have access to repo [user_id: %d, repo_name: %s]", err.UserID, err.RepoName)
|
2018-05-09 12:29:04 -04:00
|
|
|
}
|
|
|
|
|
2020-01-15 03:32:57 -05:00
|
|
|
// ErrWontSign explains the first reason why a commit would not be signed
|
|
|
|
// There may be other reasons - this is just the first reason found
|
|
|
|
type ErrWontSign struct {
|
|
|
|
Reason signingMode
|
|
|
|
}
|
|
|
|
|
|
|
|
func (e *ErrWontSign) Error() string {
|
|
|
|
return fmt.Sprintf("wont sign: %s", e.Reason)
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrWontSign checks if an error is a ErrWontSign
|
|
|
|
func IsErrWontSign(err error) bool {
|
|
|
|
_, ok := err.(*ErrWontSign)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
2016-02-02 17:07:40 -05:00
|
|
|
// __________ .__
|
|
|
|
// \______ \____________ ____ ____ | |__
|
|
|
|
// | | _/\_ __ \__ \ / \_/ ___\| | \
|
|
|
|
// | | \ | | \// __ \| | \ \___| Y \
|
|
|
|
// |______ / |__| (____ /___| /\___ >___| /
|
|
|
|
// \/ \/ \/ \/ \/
|
|
|
|
|
2020-05-29 14:16:20 -04:00
|
|
|
// 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)
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04:00
|
|
|
// ErrBranchAlreadyExists represents an error that branch with such name already exists.
|
2017-10-15 15:59:24 -04:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04:00
|
|
|
// ErrBranchNameConflict represents an error that branch name conflicts with other branch.
|
2017-10-15 15:59:24 -04:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
|
2019-12-16 01:20:25 -05:00
|
|
|
// 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)
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04:00
|
|
|
// ErrNotAllowedToMerge represents an error that a branch is protected and the current user is not allowed to modify it.
|
2018-03-12 23:46:14 -04:00
|
|
|
type ErrNotAllowedToMerge struct {
|
|
|
|
Reason string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrNotAllowedToMerge checks if an error is an ErrNotAllowedToMerge.
|
|
|
|
func IsErrNotAllowedToMerge(err error) bool {
|
|
|
|
_, ok := err.(ErrNotAllowedToMerge)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrNotAllowedToMerge) Error() string {
|
|
|
|
return fmt.Sprintf("not allowed to merge [reason: %s]", err.Reason)
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04:00
|
|
|
// ErrTagAlreadyExists represents an error that tag with such name already exists.
|
2017-10-15 15:59:24 -04: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)
|
|
|
|
}
|
|
|
|
|
2019-04-17 12:06:35 -04: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)
|
|
|
|
}
|
|
|
|
|
|
|
|
// 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 07:38:13 -04:00
|
|
|
return "a SHA or commit ID must be proved when updating a file"
|
2019-04-17 12:06:35 -04:00
|
|
|
}
|
|
|
|
|
2015-08-12 05:04:23 -04:00
|
|
|
// .___
|
|
|
|
// | | ______ ________ __ ____
|
|
|
|
// | |/ ___// ___/ | \_/ __ \
|
|
|
|
// | |\___ \ \___ \| | /\ ___/
|
|
|
|
// |___/____ >____ >____/ \___ >
|
|
|
|
// \/ \/ \/
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrIssueNotExist represents a "IssueNotExist" kind of error.
|
2015-08-12 05:04:23 -04:00
|
|
|
type ErrIssueNotExist struct {
|
|
|
|
ID int64
|
|
|
|
RepoID int64
|
|
|
|
Index int64
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrIssueNotExist checks if an error is a ErrIssueNotExist.
|
2015-08-12 05:04:23 -04:00
|
|
|
func IsErrIssueNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrIssueNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrIssueNotExist) Error() string {
|
2015-08-19 16:31:28 -04:00
|
|
|
return fmt.Sprintf("issue does not exist [id: %d, repo_id: %d, index: %d]", err.ID, err.RepoID, err.Index)
|
|
|
|
}
|
|
|
|
|
2019-12-16 01:20:25 -05:00
|
|
|
// ErrIssueIsClosed represents a "IssueIsClosed" kind of error.
|
|
|
|
type ErrIssueIsClosed struct {
|
|
|
|
ID int64
|
|
|
|
RepoID int64
|
|
|
|
Index int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrIssueIsClosed checks if an error is a ErrIssueNotExist.
|
|
|
|
func IsErrIssueIsClosed(err error) bool {
|
|
|
|
_, ok := err.(ErrIssueIsClosed)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrIssueIsClosed) Error() string {
|
|
|
|
return fmt.Sprintf("issue is closed [id: %d, repo_id: %d, index: %d]", err.ID, err.RepoID, err.Index)
|
|
|
|
}
|
|
|
|
|
2019-09-08 04:28:40 -04:00
|
|
|
// ErrIssueLabelTemplateLoad represents a "ErrIssueLabelTemplateLoad" kind of error.
|
|
|
|
type ErrIssueLabelTemplateLoad struct {
|
|
|
|
TemplateFile string
|
|
|
|
OriginalError error
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrIssueLabelTemplateLoad checks if an error is a ErrIssueLabelTemplateLoad.
|
|
|
|
func IsErrIssueLabelTemplateLoad(err error) bool {
|
|
|
|
_, ok := err.(ErrIssueLabelTemplateLoad)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrIssueLabelTemplateLoad) Error() string {
|
|
|
|
return fmt.Sprintf("Failed to load label template file '%s': %v", err.TemplateFile, err.OriginalError)
|
|
|
|
}
|
|
|
|
|
2019-10-02 18:28:30 -04:00
|
|
|
// ErrNewIssueInsert is used when the INSERT statement in newIssue fails
|
|
|
|
type ErrNewIssueInsert struct {
|
|
|
|
OriginalError error
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrNewIssueInsert checks if an error is a ErrNewIssueInsert.
|
|
|
|
func IsErrNewIssueInsert(err error) bool {
|
|
|
|
_, ok := err.(ErrNewIssueInsert)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrNewIssueInsert) Error() string {
|
|
|
|
return err.OriginalError.Error()
|
|
|
|
}
|
|
|
|
|
2019-12-15 16:57:34 -05:00
|
|
|
// ErrIssueWasClosed is used when close a closed issue
|
|
|
|
type ErrIssueWasClosed struct {
|
|
|
|
ID int64
|
|
|
|
Index int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrIssueWasClosed checks if an error is a ErrIssueWasClosed.
|
|
|
|
func IsErrIssueWasClosed(err error) bool {
|
|
|
|
_, ok := err.(ErrIssueWasClosed)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrIssueWasClosed) Error() string {
|
|
|
|
return fmt.Sprintf("Issue [%d] %d was already closed", err.ID, err.Index)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrPullWasClosed is used close a closed pull request
|
|
|
|
type ErrPullWasClosed struct {
|
|
|
|
ID int64
|
|
|
|
Index int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrPullWasClosed checks if an error is a ErrErrPullWasClosed.
|
|
|
|
func IsErrPullWasClosed(err error) bool {
|
|
|
|
_, ok := err.(ErrPullWasClosed)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrPullWasClosed) Error() string {
|
|
|
|
return fmt.Sprintf("Pull request [%d] %d was already closed", err.ID, err.Index)
|
|
|
|
}
|
|
|
|
|
2019-12-07 17:04:19 -05:00
|
|
|
// ErrForbiddenIssueReaction is used when a forbidden reaction was try to created
|
|
|
|
type ErrForbiddenIssueReaction struct {
|
|
|
|
Reaction string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrForbiddenIssueReaction checks if an error is a ErrForbiddenIssueReaction.
|
|
|
|
func IsErrForbiddenIssueReaction(err error) bool {
|
|
|
|
_, ok := err.(ErrForbiddenIssueReaction)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrForbiddenIssueReaction) Error() string {
|
|
|
|
return fmt.Sprintf("'%s' is not an allowed reaction", err.Reaction)
|
|
|
|
}
|
|
|
|
|
2019-12-31 03:21:21 -05:00
|
|
|
// ErrReactionAlreadyExist is used when a existing reaction was try to created
|
|
|
|
type ErrReactionAlreadyExist struct {
|
|
|
|
Reaction string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrReactionAlreadyExist checks if an error is a ErrReactionAlreadyExist.
|
|
|
|
func IsErrReactionAlreadyExist(err error) bool {
|
|
|
|
_, ok := err.(ErrReactionAlreadyExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrReactionAlreadyExist) Error() string {
|
|
|
|
return fmt.Sprintf("reaction '%s' already exists", err.Reaction)
|
|
|
|
}
|
|
|
|
|
2015-09-01 19:07:02 -04:00
|
|
|
// __________ .__ .__ __________ __
|
|
|
|
// \______ \__ __| | | |\______ \ ____ ________ __ ____ _______/ |_
|
|
|
|
// | ___/ | \ | | | | _// __ \/ ____/ | \_/ __ \ / ___/\ __\
|
|
|
|
// | | | | / |_| |_| | \ ___< <_| | | /\ ___/ \___ \ | |
|
|
|
|
// |____| |____/|____/____/____|_ /\___ >__ |____/ \___ >____ > |__|
|
|
|
|
// \/ \/ |__| \/ \/
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrPullRequestNotExist represents a "PullRequestNotExist" kind of error.
|
2015-09-02 05:09:12 -04:00
|
|
|
type ErrPullRequestNotExist struct {
|
|
|
|
ID int64
|
2015-10-22 14:47:24 -04:00
|
|
|
IssueID int64
|
2015-09-02 05:09:12 -04:00
|
|
|
HeadRepoID int64
|
|
|
|
BaseRepoID int64
|
2017-01-04 19:50:34 -05:00
|
|
|
HeadBranch string
|
2015-09-02 05:09:12 -04:00
|
|
|
BaseBranch string
|
2015-09-01 19:07:02 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrPullRequestNotExist checks if an error is a ErrPullRequestNotExist.
|
2015-09-02 05:09:12 -04:00
|
|
|
func IsErrPullRequestNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrPullRequestNotExist)
|
2015-09-01 19:07:02 -04:00
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
2015-09-02 05:09:12 -04:00
|
|
|
func (err ErrPullRequestNotExist) Error() string {
|
2015-10-22 14:47:24 -04:00
|
|
|
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]",
|
2017-01-04 19:50:34 -05:00
|
|
|
err.ID, err.IssueID, err.HeadRepoID, err.BaseRepoID, err.HeadBranch, err.BaseBranch)
|
2015-09-01 19:07:02 -04:00
|
|
|
}
|
|
|
|
|
2016-12-02 06:10:39 -05:00
|
|
|
// ErrPullRequestAlreadyExists represents a "PullRequestAlreadyExists"-error
|
|
|
|
type ErrPullRequestAlreadyExists struct {
|
|
|
|
ID int64
|
|
|
|
IssueID int64
|
|
|
|
HeadRepoID int64
|
|
|
|
BaseRepoID int64
|
|
|
|
HeadBranch string
|
|
|
|
BaseBranch string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrPullRequestAlreadyExists checks if an error is a ErrPullRequestAlreadyExists.
|
|
|
|
func IsErrPullRequestAlreadyExists(err error) bool {
|
|
|
|
_, ok := err.(ErrPullRequestAlreadyExists)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
// Error does pretty-printing :D
|
|
|
|
func (err ErrPullRequestAlreadyExists) Error() string {
|
|
|
|
return fmt.Sprintf("pull request already exists for these targets [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)
|
|
|
|
}
|
|
|
|
|
2019-04-25 23:03:39 -04:00
|
|
|
// ErrPullRequestHeadRepoMissing represents a "ErrPullRequestHeadRepoMissing" error
|
|
|
|
type ErrPullRequestHeadRepoMissing struct {
|
|
|
|
ID int64
|
|
|
|
HeadRepoID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrErrPullRequestHeadRepoMissing checks if an error is a ErrPullRequestHeadRepoMissing.
|
|
|
|
func IsErrErrPullRequestHeadRepoMissing(err error) bool {
|
|
|
|
_, ok := err.(ErrPullRequestHeadRepoMissing)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
// Error does pretty-printing :D
|
|
|
|
func (err ErrPullRequestHeadRepoMissing) Error() string {
|
|
|
|
return fmt.Sprintf("pull request head repo missing [id: %d, head_repo_id: %d]",
|
|
|
|
err.ID, err.HeadRepoID)
|
|
|
|
}
|
|
|
|
|
2018-01-05 13:56:50 -05:00
|
|
|
// ErrInvalidMergeStyle represents an error if merging with disabled merge strategy
|
|
|
|
type ErrInvalidMergeStyle struct {
|
|
|
|
ID int64
|
|
|
|
Style 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)
|
|
|
|
}
|
|
|
|
|
2019-11-10 03:42:51 -05:00
|
|
|
// ErrMergeConflicts represents an error if merging fails with a conflict
|
|
|
|
type ErrMergeConflicts struct {
|
|
|
|
Style 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 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 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)
|
|
|
|
}
|
|
|
|
|
2019-12-16 01:20:25 -05: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)
|
|
|
|
}
|
|
|
|
|
2015-08-19 16:31:28 -04:00
|
|
|
// _________ __
|
|
|
|
// \_ ___ \ ____ _____ _____ ____ _____/ |_
|
|
|
|
// / \ \/ / _ \ / \ / \_/ __ \ / \ __\
|
|
|
|
// \ \___( <_> ) Y Y \ Y Y \ ___/| | \ |
|
|
|
|
// \______ /\____/|__|_| /__|_| /\___ >___| /__|
|
|
|
|
// \/ \/ \/ \/ \/
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrCommentNotExist represents a "CommentNotExist" kind of error.
|
2015-08-19 16:31:28 -04:00
|
|
|
type ErrCommentNotExist struct {
|
2016-08-26 16:40:53 -04:00
|
|
|
ID int64
|
|
|
|
IssueID int64
|
2015-08-19 16:31:28 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrCommentNotExist checks if an error is a ErrCommentNotExist.
|
2015-08-19 16:31:28 -04:00
|
|
|
func IsErrCommentNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrCommentNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrCommentNotExist) Error() string {
|
2016-08-26 16:40:53 -04:00
|
|
|
return fmt.Sprintf("comment does not exist [id: %d, issue_id: %d]", err.ID, err.IssueID)
|
2015-08-12 05:04:23 -04:00
|
|
|
}
|
|
|
|
|
2017-09-12 02:48:13 -04:00
|
|
|
// _________ __ __ .__
|
|
|
|
// / _____// |_ ____ ________ _ _______ _/ |_ ____ | |__
|
|
|
|
// \_____ \\ __\/ _ \\____ \ \/ \/ /\__ \\ __\/ ___\| | \
|
|
|
|
// / \| | ( <_> ) |_> > / / __ \| | \ \___| 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)
|
|
|
|
}
|
|
|
|
|
2015-08-10 02:42:50 -04:00
|
|
|
// .____ ___. .__
|
|
|
|
// | | _____ \_ |__ ____ | |
|
|
|
|
// | | \__ \ | __ \_/ __ \| |
|
|
|
|
// | |___ / __ \| \_\ \ ___/| |__
|
|
|
|
// |_______ (____ /___ /\___ >____/
|
|
|
|
// \/ \/ \/ \/
|
|
|
|
|
Add Organization Wide Labels (#10814)
* Add organization wide labels
Implement organization wide labels similar to organization wide
webhooks. This lets you create individual labels for organizations that can be used
for all repos under that organization (so being able to reuse the same
label across multiple repos).
This makes it possible for small organizations with many repos to use
labels effectively.
Fixes #7406
* Add migration
* remove comments
* fix tests
* Update options/locale/locale_en-US.ini
Removed unused translation string
* show org labels in issue search label filter
* Use more clear var name
* rename migration after merge from master
* comment typo
* update migration again after rebase with master
* check for orgID <=0 per guillep2k review
* fmt
* Apply suggestions from code review
Co-Authored-By: guillep2k <18600385+guillep2k@users.noreply.github.com>
* remove unused code
* Make sure RepoID is 0 when searching orgID per code review
* more changes/code review requests
* More descriptive translation var per code review
* func description/delete comment when issue label deleted instead of hiding it
* remove comment
* only use issues in that repo when calculating number of open issues for org label on repo label page
* Add integration test for IssuesSearch API with labels
* remove unused function
* Update models/issue_label.go
Co-Authored-By: guillep2k <18600385+guillep2k@users.noreply.github.com>
* Use subquery in GetLabelIDsInReposByNames
* Fix tests to use correct orgID
* fix more tests
* IssuesSearch api now uses new BuildLabelNamesIssueIDsCondition. Add a few more tests as well
* update comment for clarity
* Revert previous code change now that we can use the new BuildLabelNamesIssueIDsCondition
* Don't sort repos by date in IssuesSearch API
After much debugging I've found a strange issue where in some cases MySQL will return a different result than other enigines if a query is sorted by a null collumn. For example with our integration test data where we don't set updated_unix in repository fixtures:
SELECT `id`, `owner_id`, `owner_name`, `lower_name`, `name`, `description`, `website`, `original_service_type`, `original_url`, `default_branch`, `num_watches`, `num_stars`, `num_forks`, `num_issues`, `num_closed_issues`, `num_pulls`, `num_closed_pulls`, `num_milestones`, `num_closed_milestones`, `is_private`, `is_empty`, `is_archived`, `is_mirror`, `status`, `is_fork`, `fork_id`, `is_template`, `template_id`, `size`, `is_fsck_enabled`, `close_issues_via_commit_in_any_branch`, `topics`, `avatar`, `created_unix`, `updated_unix` FROM `repository` ORDER BY updated_unix DESC LIMIT 15 OFFSET 45
Returns different results for MySQL than other engines. However, the similar query:
SELECT `id`, `owner_id`, `owner_name`, `lower_name`, `name`, `description`, `website`, `original_service_type`, `original_url`, `default_branch`, `num_watches`, `num_stars`, `num_forks`, `num_issues`, `num_closed_issues`, `num_pulls`, `num_closed_pulls`, `num_milestones`, `num_closed_milestones`, `is_private`, `is_empty`, `is_archived`, `is_mirror`, `status`, `is_fork`, `fork_id`, `is_template`, `template_id`, `size`, `is_fsck_enabled`, `close_issues_via_commit_in_any_branch`, `topics`, `avatar`, `created_unix`, `updated_unix` FROM `repository` ORDER BY updated_unix DESC LIMIT 15 OFFSET 30
Returns the same results.
This causes integration tests to fail on MySQL in certain cases but would never show up in a real installation. Since this API call always returns issues based on the optionally provided repo_priority_id or the issueID itself, there is no change to results by changing the repo sorting method used to get ids earlier in the function.
* linter is back!
* code review
* remove now unused option
* Fix newline at end of files
* more unused code
* update to master
* check for matching ids before query
* Update models/issue_label.go
Co-Authored-By: 6543 <6543@obermui.de>
* Update models/issue_label.go
* update comments
* Update routers/org/setting.go
Co-authored-by: Lauris BH <lauris@nix.lv>
Co-authored-by: guillep2k <18600385+guillep2k@users.noreply.github.com>
Co-authored-by: 6543 <6543@obermui.de>
2020-04-01 00:14:46 -04:00
|
|
|
// ErrRepoLabelNotExist represents a "RepoLabelNotExist" kind of error.
|
|
|
|
type ErrRepoLabelNotExist struct {
|
|
|
|
LabelID int64
|
|
|
|
RepoID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrRepoLabelNotExist checks if an error is a RepoErrLabelNotExist.
|
|
|
|
func IsErrRepoLabelNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrRepoLabelNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrRepoLabelNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("label does not exist [label_id: %d, repo_id: %d]", err.LabelID, err.RepoID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrOrgLabelNotExist represents a "OrgLabelNotExist" kind of error.
|
|
|
|
type ErrOrgLabelNotExist struct {
|
|
|
|
LabelID int64
|
|
|
|
OrgID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrOrgLabelNotExist checks if an error is a OrgErrLabelNotExist.
|
|
|
|
func IsErrOrgLabelNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrOrgLabelNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrOrgLabelNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("label does not exist [label_id: %d, org_id: %d]", err.LabelID, err.OrgID)
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrLabelNotExist represents a "LabelNotExist" kind of error.
|
2015-08-10 02:42:50 -04:00
|
|
|
type ErrLabelNotExist struct {
|
2016-08-03 14:51:22 -04:00
|
|
|
LabelID int64
|
2015-08-10 02:42:50 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrLabelNotExist checks if an error is a ErrLabelNotExist.
|
2015-08-10 02:42:50 -04:00
|
|
|
func IsErrLabelNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrLabelNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrLabelNotExist) Error() string {
|
Add Organization Wide Labels (#10814)
* Add organization wide labels
Implement organization wide labels similar to organization wide
webhooks. This lets you create individual labels for organizations that can be used
for all repos under that organization (so being able to reuse the same
label across multiple repos).
This makes it possible for small organizations with many repos to use
labels effectively.
Fixes #7406
* Add migration
* remove comments
* fix tests
* Update options/locale/locale_en-US.ini
Removed unused translation string
* show org labels in issue search label filter
* Use more clear var name
* rename migration after merge from master
* comment typo
* update migration again after rebase with master
* check for orgID <=0 per guillep2k review
* fmt
* Apply suggestions from code review
Co-Authored-By: guillep2k <18600385+guillep2k@users.noreply.github.com>
* remove unused code
* Make sure RepoID is 0 when searching orgID per code review
* more changes/code review requests
* More descriptive translation var per code review
* func description/delete comment when issue label deleted instead of hiding it
* remove comment
* only use issues in that repo when calculating number of open issues for org label on repo label page
* Add integration test for IssuesSearch API with labels
* remove unused function
* Update models/issue_label.go
Co-Authored-By: guillep2k <18600385+guillep2k@users.noreply.github.com>
* Use subquery in GetLabelIDsInReposByNames
* Fix tests to use correct orgID
* fix more tests
* IssuesSearch api now uses new BuildLabelNamesIssueIDsCondition. Add a few more tests as well
* update comment for clarity
* Revert previous code change now that we can use the new BuildLabelNamesIssueIDsCondition
* Don't sort repos by date in IssuesSearch API
After much debugging I've found a strange issue where in some cases MySQL will return a different result than other enigines if a query is sorted by a null collumn. For example with our integration test data where we don't set updated_unix in repository fixtures:
SELECT `id`, `owner_id`, `owner_name`, `lower_name`, `name`, `description`, `website`, `original_service_type`, `original_url`, `default_branch`, `num_watches`, `num_stars`, `num_forks`, `num_issues`, `num_closed_issues`, `num_pulls`, `num_closed_pulls`, `num_milestones`, `num_closed_milestones`, `is_private`, `is_empty`, `is_archived`, `is_mirror`, `status`, `is_fork`, `fork_id`, `is_template`, `template_id`, `size`, `is_fsck_enabled`, `close_issues_via_commit_in_any_branch`, `topics`, `avatar`, `created_unix`, `updated_unix` FROM `repository` ORDER BY updated_unix DESC LIMIT 15 OFFSET 45
Returns different results for MySQL than other engines. However, the similar query:
SELECT `id`, `owner_id`, `owner_name`, `lower_name`, `name`, `description`, `website`, `original_service_type`, `original_url`, `default_branch`, `num_watches`, `num_stars`, `num_forks`, `num_issues`, `num_closed_issues`, `num_pulls`, `num_closed_pulls`, `num_milestones`, `num_closed_milestones`, `is_private`, `is_empty`, `is_archived`, `is_mirror`, `status`, `is_fork`, `fork_id`, `is_template`, `template_id`, `size`, `is_fsck_enabled`, `close_issues_via_commit_in_any_branch`, `topics`, `avatar`, `created_unix`, `updated_unix` FROM `repository` ORDER BY updated_unix DESC LIMIT 15 OFFSET 30
Returns the same results.
This causes integration tests to fail on MySQL in certain cases but would never show up in a real installation. Since this API call always returns issues based on the optionally provided repo_priority_id or the issueID itself, there is no change to results by changing the repo sorting method used to get ids earlier in the function.
* linter is back!
* code review
* remove now unused option
* Fix newline at end of files
* more unused code
* update to master
* check for matching ids before query
* Update models/issue_label.go
Co-Authored-By: 6543 <6543@obermui.de>
* Update models/issue_label.go
* update comments
* Update routers/org/setting.go
Co-authored-by: Lauris BH <lauris@nix.lv>
Co-authored-by: guillep2k <18600385+guillep2k@users.noreply.github.com>
Co-authored-by: 6543 <6543@obermui.de>
2020-04-01 00:14:46 -04:00
|
|
|
return fmt.Sprintf("label does not exist [label_id: %d]", err.LabelID)
|
2016-08-03 12:24:16 -04:00
|
|
|
}
|
|
|
|
|
2020-08-16 23:07:38 -04:00
|
|
|
// __________ __ __
|
|
|
|
// \______ \_______ ____ |__| ____ _____/ |_ ______
|
|
|
|
// | ___/\_ __ \/ _ \ | |/ __ \_/ ___\ __\/ ___/
|
|
|
|
// | | | | \( <_> ) | \ ___/\ \___| | \___ \
|
|
|
|
// |____| |__| \____/\__| |\___ >\___ >__| /____ >
|
|
|
|
// \______| \/ \/ \/
|
|
|
|
|
|
|
|
// ErrProjectNotExist represents a "ProjectNotExist" kind of error.
|
|
|
|
type ErrProjectNotExist struct {
|
|
|
|
ID int64
|
|
|
|
RepoID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrProjectNotExist checks if an error is a ErrProjectNotExist
|
|
|
|
func IsErrProjectNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrProjectNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrProjectNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("projects does not exist [id: %d]", err.ID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrProjectBoardNotExist represents a "ProjectBoardNotExist" kind of error.
|
|
|
|
type ErrProjectBoardNotExist struct {
|
|
|
|
BoardID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrProjectBoardNotExist checks if an error is a ErrProjectBoardNotExist
|
|
|
|
func IsErrProjectBoardNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrProjectBoardNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrProjectBoardNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("project board does not exist [id: %d]", err.BoardID)
|
|
|
|
}
|
|
|
|
|
2015-08-05 06:26:18 -04:00
|
|
|
// _____ .__.__ __
|
|
|
|
// / \ |__| | ____ _______/ |_ ____ ____ ____
|
|
|
|
// / \ / \| | | _/ __ \ / ___/\ __\/ _ \ / \_/ __ \
|
|
|
|
// / Y \ | |_\ ___/ \___ \ | | ( <_> ) | \ ___/
|
|
|
|
// \____|__ /__|____/\___ >____ > |__| \____/|___| /\___ >
|
|
|
|
// \/ \/ \/ \/ \/
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrMilestoneNotExist represents a "MilestoneNotExist" kind of error.
|
2015-08-05 06:26:18 -04:00
|
|
|
type ErrMilestoneNotExist struct {
|
2015-08-10 06:57:57 -04:00
|
|
|
ID int64
|
|
|
|
RepoID int64
|
2020-04-30 00:15:39 -04:00
|
|
|
Name string
|
2015-08-05 06:26:18 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrMilestoneNotExist checks if an error is a ErrMilestoneNotExist.
|
2015-08-05 06:26:18 -04:00
|
|
|
func IsErrMilestoneNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrMilestoneNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrMilestoneNotExist) Error() string {
|
2020-04-30 00:15:39 -04:00
|
|
|
if len(err.Name) > 0 {
|
|
|
|
return fmt.Sprintf("milestone does not exist [name: %s, repo_id: %d]", err.Name, err.RepoID)
|
|
|
|
}
|
2015-08-10 06:57:57 -04:00
|
|
|
return fmt.Sprintf("milestone does not exist [id: %d, repo_id: %d]", err.ID, err.RepoID)
|
2015-08-05 06:26:18 -04:00
|
|
|
}
|
2015-08-11 11:24:40 -04:00
|
|
|
|
2016-01-29 17:06:14 -05:00
|
|
|
// ___________
|
|
|
|
// \__ ___/___ _____ _____
|
|
|
|
// | |_/ __ \\__ \ / \
|
|
|
|
// | |\ ___/ / __ \| Y Y \
|
|
|
|
// |____| \___ >____ /__|_| /
|
|
|
|
// \/ \/ \/
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrTeamAlreadyExist represents a "TeamAlreadyExist" kind of error.
|
2016-01-29 17:06:14 -05:00
|
|
|
type ErrTeamAlreadyExist struct {
|
|
|
|
OrgID int64
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrTeamAlreadyExist checks if an error is a ErrTeamAlreadyExist.
|
2016-01-29 17:06:14 -05:00
|
|
|
func IsErrTeamAlreadyExist(err error) bool {
|
|
|
|
_, ok := err.(ErrTeamAlreadyExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrTeamAlreadyExist) Error() string {
|
|
|
|
return fmt.Sprintf("team already exists [org_id: %d, name: %s]", err.OrgID, err.Name)
|
2015-12-05 17:13:13 -05:00
|
|
|
}
|
2016-08-11 08:48:08 -04:00
|
|
|
|
2019-09-23 16:08:03 -04:00
|
|
|
// ErrTeamNotExist represents a "TeamNotExist" error
|
|
|
|
type ErrTeamNotExist struct {
|
|
|
|
OrgID int64
|
|
|
|
TeamID int64
|
|
|
|
Name string
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrTeamNotExist checks if an error is a ErrTeamNotExist.
|
|
|
|
func IsErrTeamNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrTeamNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrTeamNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("team does not exist [org_id %d, team_id %d, name: %s]", err.OrgID, err.TeamID, err.Name)
|
|
|
|
}
|
|
|
|
|
2016-08-11 08:48:08 -04:00
|
|
|
// ____ ___ .__ .___
|
|
|
|
// | | \______ | | _________ __| _/
|
|
|
|
// | | /\____ \| | / _ \__ \ / __ |
|
|
|
|
// | | / | |_> > |_( <_> ) __ \_/ /_/ |
|
|
|
|
// |______/ | __/|____/\____(____ /\____ |
|
|
|
|
// |__| \/ \/
|
|
|
|
//
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// ErrUploadNotExist represents a "UploadNotExist" kind of error.
|
2016-08-11 08:48:08 -04:00
|
|
|
type ErrUploadNotExist struct {
|
2016-08-30 08:07:50 -04:00
|
|
|
ID int64
|
|
|
|
UUID string
|
2016-08-11 08:48:08 -04:00
|
|
|
}
|
|
|
|
|
2016-11-24 03:20:28 -05:00
|
|
|
// IsErrUploadNotExist checks if an error is a ErrUploadNotExist.
|
2016-08-11 08:48:08 -04:00
|
|
|
func IsErrUploadNotExist(err error) bool {
|
2021-11-19 08:39:57 -05:00
|
|
|
_, ok := err.(ErrUploadNotExist)
|
2016-08-11 08:48:08 -04:00
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrUploadNotExist) Error() string {
|
2016-08-30 08:07:50 -04:00
|
|
|
return fmt.Sprintf("attachment does not exist [id: %d, uuid: %s]", err.ID, err.UUID)
|
2016-08-11 08:48:08 -04:00
|
|
|
}
|
2017-02-22 02:14:37 -05:00
|
|
|
|
|
|
|
// ___________ __ .__ .____ .__ ____ ___
|
|
|
|
// \_ _____/__ ____/ |_ ___________ ____ _____ | | | | ____ ____ |__| ____ | | \______ ___________
|
|
|
|
// | __)_\ \/ /\ __\/ __ \_ __ \/ \\__ \ | | | | / _ \ / ___\| |/ \ | | / ___// __ \_ __ \
|
|
|
|
// | \> < | | \ ___/| | \/ | \/ __ \| |__ | |__( <_> ) /_/ > | | \ | | /\___ \\ ___/| | \/
|
|
|
|
// /_______ /__/\_ \ |__| \___ >__| |___| (____ /____/ |_______ \____/\___ /|__|___| / |______//____ >\___ >__|
|
|
|
|
// \/ \/ \/ \/ \/ \/ /_____/ \/ \/ \/
|
|
|
|
|
|
|
|
// ErrExternalLoginUserAlreadyExist represents a "ExternalLoginUserAlreadyExist" kind of error.
|
|
|
|
type ErrExternalLoginUserAlreadyExist struct {
|
|
|
|
ExternalID string
|
|
|
|
UserID int64
|
|
|
|
LoginSourceID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrExternalLoginUserAlreadyExist checks if an error is a ExternalLoginUserAlreadyExist.
|
|
|
|
func IsErrExternalLoginUserAlreadyExist(err error) bool {
|
|
|
|
_, ok := err.(ErrExternalLoginUserAlreadyExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrExternalLoginUserAlreadyExist) Error() string {
|
|
|
|
return fmt.Sprintf("external login user already exists [externalID: %s, userID: %d, loginSourceID: %d]", err.ExternalID, err.UserID, err.LoginSourceID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrExternalLoginUserNotExist represents a "ExternalLoginUserNotExist" kind of error.
|
|
|
|
type ErrExternalLoginUserNotExist struct {
|
|
|
|
UserID int64
|
|
|
|
LoginSourceID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrExternalLoginUserNotExist checks if an error is a ExternalLoginUserNotExist.
|
|
|
|
func IsErrExternalLoginUserNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrExternalLoginUserNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrExternalLoginUserNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("external login user link does not exists [userID: %d, loginSourceID: %d]", err.UserID, err.LoginSourceID)
|
|
|
|
}
|
2018-05-19 10:12:37 -04:00
|
|
|
|
2018-07-17 17:23:58 -04:00
|
|
|
// .___ ________ .___ .__
|
|
|
|
// | | ______ ________ __ ____ \______ \ ____ ______ ____ ____ __| _/____ ____ ____ |__| ____ ______
|
|
|
|
// | |/ ___// ___/ | \_/ __ \ | | \_/ __ \\____ \_/ __ \ / \ / __ |/ __ \ / \_/ ___\| |/ __ \ / ___/
|
|
|
|
// | |\___ \ \___ \| | /\ ___/ | ` \ ___/| |_> > ___/| | \/ /_/ \ ___/| | \ \___| \ ___/ \___ \
|
|
|
|
// |___/____ >____ >____/ \___ >_______ /\___ > __/ \___ >___| /\____ |\___ >___| /\___ >__|\___ >____ >
|
|
|
|
// \/ \/ \/ \/ \/|__| \/ \/ \/ \/ \/ \/ \/ \/
|
|
|
|
|
|
|
|
// ErrDependencyExists represents a "DependencyAlreadyExists" kind of error.
|
|
|
|
type ErrDependencyExists struct {
|
|
|
|
IssueID int64
|
|
|
|
DependencyID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrDependencyExists checks if an error is a ErrDependencyExists.
|
|
|
|
func IsErrDependencyExists(err error) bool {
|
|
|
|
_, ok := err.(ErrDependencyExists)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrDependencyExists) Error() string {
|
|
|
|
return fmt.Sprintf("issue dependency does already exist [issue id: %d, dependency id: %d]", err.IssueID, err.DependencyID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrDependencyNotExists represents a "DependencyAlreadyExists" kind of error.
|
|
|
|
type ErrDependencyNotExists struct {
|
|
|
|
IssueID int64
|
|
|
|
DependencyID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrDependencyNotExists checks if an error is a ErrDependencyExists.
|
|
|
|
func IsErrDependencyNotExists(err error) bool {
|
|
|
|
_, ok := err.(ErrDependencyNotExists)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrDependencyNotExists) Error() string {
|
|
|
|
return fmt.Sprintf("issue dependency does not exist [issue id: %d, dependency id: %d]", err.IssueID, err.DependencyID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrCircularDependency represents a "DependencyCircular" kind of error.
|
|
|
|
type ErrCircularDependency struct {
|
|
|
|
IssueID int64
|
|
|
|
DependencyID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrCircularDependency checks if an error is a ErrCircularDependency.
|
|
|
|
func IsErrCircularDependency(err error) bool {
|
|
|
|
_, ok := err.(ErrCircularDependency)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrCircularDependency) Error() string {
|
|
|
|
return fmt.Sprintf("circular dependencies exists (two issues blocking each other) [issue id: %d, dependency id: %d]", err.IssueID, err.DependencyID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrDependenciesLeft represents an error where the issue you're trying to close still has dependencies left.
|
|
|
|
type ErrDependenciesLeft struct {
|
|
|
|
IssueID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrDependenciesLeft checks if an error is a ErrDependenciesLeft.
|
|
|
|
func IsErrDependenciesLeft(err error) bool {
|
|
|
|
_, ok := err.(ErrDependenciesLeft)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrDependenciesLeft) Error() string {
|
|
|
|
return fmt.Sprintf("issue has open dependencies [issue id: %d]", err.IssueID)
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrUnknownDependencyType represents an error where an unknown dependency type was passed
|
|
|
|
type ErrUnknownDependencyType struct {
|
|
|
|
Type DependencyType
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrUnknownDependencyType checks if an error is ErrUnknownDependencyType
|
|
|
|
func IsErrUnknownDependencyType(err error) bool {
|
|
|
|
_, ok := err.(ErrUnknownDependencyType)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrUnknownDependencyType) Error() string {
|
|
|
|
return fmt.Sprintf("unknown dependency type [type: %d]", err.Type)
|
|
|
|
}
|
2018-08-06 00:43:22 -04:00
|
|
|
|
|
|
|
// __________ .__
|
|
|
|
// \______ \ _______ _|__| ______ _ __
|
|
|
|
// | _// __ \ \/ / |/ __ \ \/ \/ /
|
|
|
|
// | | \ ___/\ /| \ ___/\ /
|
|
|
|
// |____|_ /\___ >\_/ |__|\___ >\/\_/
|
|
|
|
// \/ \/ \/
|
|
|
|
|
|
|
|
// ErrReviewNotExist represents a "ReviewNotExist" kind of error.
|
|
|
|
type ErrReviewNotExist struct {
|
|
|
|
ID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrReviewNotExist checks if an error is a ErrReviewNotExist.
|
|
|
|
func IsErrReviewNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrReviewNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrReviewNotExist) Error() string {
|
|
|
|
return fmt.Sprintf("review does not exist [id: %d]", err.ID)
|
|
|
|
}
|
2019-03-08 11:42:50 -05:00
|
|
|
|
2020-10-12 15:55:13 -04:00
|
|
|
// ErrNotValidReviewRequest an not allowed review request modify
|
|
|
|
type ErrNotValidReviewRequest struct {
|
|
|
|
Reason string
|
|
|
|
UserID int64
|
|
|
|
RepoID int64
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsErrNotValidReviewRequest checks if an error is a ErrNotValidReviewRequest.
|
|
|
|
func IsErrNotValidReviewRequest(err error) bool {
|
2020-10-20 14:18:25 -04:00
|
|
|
_, ok := err.(ErrNotValidReviewRequest)
|
2020-10-12 15:55:13 -04:00
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrNotValidReviewRequest) Error() string {
|
|
|
|
return fmt.Sprintf("%s [user_id: %d, repo_id: %d]",
|
|
|
|
err.Reason,
|
|
|
|
err.UserID,
|
|
|
|
err.RepoID)
|
|
|
|
}
|