return models.DeleteUser(user)
}
-func runRepoSyncReleases(c *cli.Context) error {
+func runRepoSyncReleases(_ *cli.Context) error {
if err := initDB(); err != nil {
return err
}
)
}
-func runRegenerateHooks(c *cli.Context) error {
+func runRegenerateHooks(_ *cli.Context) error {
if err := initDB(); err != nil {
return err
}
return repo_module.SyncRepositoryHooks(graceful.GetManager().ShutdownContext())
}
-func runRegenerateKeys(c *cli.Context) error {
+func runRegenerateKeys(_ *cli.Context) error {
if err := initDB(); err != nil {
return err
}
}
// the environment setted on serv command
- isWiki := (os.Getenv(models.EnvRepoIsWiki) == "true")
+ isWiki := os.Getenv(models.EnvRepoIsWiki) == "true"
username := os.Getenv(models.EnvRepoUsername)
reponame := os.Getenv(models.EnvRepoName)
userID, _ := strconv.ParseInt(os.Getenv(models.EnvPusherID), 10, 64)
// the environment setted on serv command
repoUser := os.Getenv(models.EnvRepoUsername)
- isWiki := (os.Getenv(models.EnvRepoIsWiki) == "true")
+ isWiki := os.Getenv(models.EnvRepoIsWiki) == "true"
repoName := os.Getenv(models.EnvRepoName)
pusherID, _ := strconv.ParseInt(os.Getenv(models.EnvPusherID), 10, 64)
pusherName := os.Getenv(models.EnvPusherName)
return r
}
-// GetProtectedBranchByRepoID getting protected branch by repo ID
-func GetProtectedBranchByRepoID(repoID int64) ([]*ProtectedBranch, error) {
- protectedBranches := make([]*ProtectedBranch, 0)
- return protectedBranches, x.Where("repo_id = ?", repoID).Desc("updated_unix").Find(&protectedBranches)
-}
-
// GetProtectedBranchBy getting protected branch by ID/Name
func GetProtectedBranchBy(repoID int64, branchName string) (*ProtectedBranch, error) {
return getProtectedBranchBy(x, repoID, branchName)
return rel, nil
}
-// GetProtectedBranchByID getting protected branch by ID
-func GetProtectedBranchByID(id int64) (*ProtectedBranch, error) {
- rel := &ProtectedBranch{}
- has, err := x.ID(id).Get(rel)
- if err != nil {
- return nil, err
- }
- if !has {
- return nil, nil
- }
- return rel, nil
-}
-
// WhitelistOptions represent all sorts of whitelists used for protected branches
type WhitelistOptions struct {
UserIDs []int64
Find(&labelIDs)
}
-// GetLabelIDsInOrgsByNames returns a list of labelIDs by names in one of the given
-// organization.
-// it silently ignores label names that do not belong to the organization.
-func GetLabelIDsInOrgsByNames(orgIDs []int64, labelNames []string) ([]int64, error) {
- labelIDs := make([]int64, 0, len(labelNames))
- return labelIDs, x.Table("label").
- In("org_id", orgIDs).
- In("name", labelNames).
- Asc("name").
- Cols("id").
- Find(&labelIDs)
-}
-
// GetLabelInOrgByID returns a label by ID in given organization.
func GetLabelInOrgByID(orgID, labelID int64) (*Label, error) {
return getLabelInOrgByID(x, orgID, labelID)
func LFSObjectAccessible(user *User, oid string) (bool, error) {
if user.IsAdmin {
count, err := x.Count(&LFSMetaObject{Pointer: lfs.Pointer{Oid: oid}})
- return (count > 0), err
+ return count > 0, err
}
cond := accessibleRepositoryCondition(user)
count, err := x.Where(cond).Join("INNER", "repository", "`lfs_meta_object`.repository_id = `repository`.id").Count(&LFSMetaObject{Pointer: lfs.Pointer{Oid: oid}})
- return (count > 0), err
+ return count > 0, err
}
// LFSAutoAssociate auto associates accessible LFSMetaObjects
assert.NoError(t, err2)
assert.NoError(t, err3)
assert.Equal(t, int64(3), count)
- assert.Equal(t, (privateCount + publicCount), count)
+ assert.Equal(t, privateCount+publicCount, count)
}
func TestGetPublicRepositoryCount(t *testing.T) {
)
var (
- // ErrUserNotKeyOwner user does not own this key error
- ErrUserNotKeyOwner = errors.New("User does not own this public key")
-
// ErrEmailNotExist e-mail does not exist error
ErrEmailNotExist = errors.New("E-mail does not exist")
Select(groupBy+" AS timestamp, count(user_id) as contributions").
Table("action").
Where(cond).
- And("created_unix > ?", (timeutil.TimeStampNow() - 31536000)).
+ And("created_unix > ?", timeutil.TimeStampNow()-31536000).
GroupBy(groupByName).
OrderBy("timestamp").
Find(&hdata)
return openids, nil
}
+// isOpenIDUsed returns true if the openid has been used.
func isOpenIDUsed(e Engine, uri string) (bool, error) {
if len(uri) == 0 {
return true, nil
return e.Get(&UserOpenID{URI: uri})
}
-// IsOpenIDUsed returns true if the openid has been used.
-func IsOpenIDUsed(openid string) (bool, error) {
- return isOpenIDUsed(x, openid)
-}
-
// NOTE: make sure openid.URI is normalized already
func addUserOpenID(e Engine, openid *UserOpenID) error {
used, err := isOpenIDUsed(e, openid.URI)
}
}
}
- if m == nil {
- return nil
- }
+
if consumes != 0 {
s := segment.WithStop(segment.Start + 1)
ast.MergeOrAppendTextSegment(parent, s)
import (
"bytes"
"context"
- "errors"
"fmt"
"io"
"os/exec"
// then we delete the singleton.
var (
- // ErrExecTimeout represent a timeout error
- ErrExecTimeout = errors.New("Process execution timeout")
- manager *Manager
- managerInit sync.Once
+ manager *Manager
+ managerInit sync.Once
// DefaultContext is the default context to run processing commands in
DefaultContext = context.Background()
Has(data []byte) (bool, error)
}
-var _ (ByteFIFO) = &DummyByteFIFO{}
+var _ ByteFIFO = &DummyByteFIFO{}
// DummyByteFIFO represents a dummy fifo
type DummyByteFIFO struct{}
return 0
}
-var _ (UniqueByteFIFO) = &DummyUniqueByteFIFO{}
+var _ UniqueByteFIFO = &DummyUniqueByteFIFO{}
// DummyUniqueByteFIFO represents a dummy unique fifo
type DummyUniqueByteFIFO struct {
var err error
configBytes, err = json.Marshal(cfg)
- ok = (err == nil)
+ ok = err == nil
}
if !ok {
// no ... we've tried hard enough at this point - throw an error!
Name string
}
-var _ (Queue) = &ByteFIFOQueue{}
+var _ Queue = &ByteFIFOQueue{}
// ByteFIFOQueue is a Queue formed from a ByteFIFO and WorkerPool
type ByteFIFOQueue struct {
return q.terminated
}
-var _ (UniqueQueue) = &ByteFIFOUniqueQueue{}
+var _ UniqueQueue = &ByteFIFOUniqueQueue{}
// ByteFIFOUniqueQueue represents a UniqueQueue formed from a UniqueByteFifo
type ByteFIFOUniqueQueue struct {
return queue, nil
}
-var _ (ByteFIFO) = &LevelQueueByteFIFO{}
+var _ ByteFIFO = &LevelQueueByteFIFO{}
// LevelQueueByteFIFO represents a ByteFIFO formed from a LevelQueue
type LevelQueueByteFIFO struct {
Close() error
}
-var _ (ByteFIFO) = &RedisByteFIFO{}
+var _ ByteFIFO = &RedisByteFIFO{}
// RedisByteFIFO represents a ByteFIFO formed from a redisClient
type RedisByteFIFO struct {
return queue, nil
}
-var _ (UniqueByteFIFO) = &LevelUniqueQueueByteFIFO{}
+var _ UniqueByteFIFO = &LevelUniqueQueueByteFIFO{}
// LevelUniqueQueueByteFIFO represents a ByteFIFO formed from a LevelUniqueQueue
type LevelUniqueQueueByteFIFO struct {
return queue, nil
}
-var _ (UniqueByteFIFO) = &RedisUniqueByteFIFO{}
+var _ UniqueByteFIFO = &RedisUniqueByteFIFO{}
// RedisUniqueByteFIFO represents a UniqueByteFIFO formed from a redisClient
type RedisUniqueByteFIFO struct {
// our new section has length endPos - match[3]
// our old section has length match[9] - match[3]
- (*contentBytes) = (*contentBytes)[:len((*contentBytes))-match[9]+endPos]
+ *contentBytes = (*contentBytes)[:len(*contentBytes)-match[9]+endPos]
pos = endPos
}
}
continue
}
}
- close := (ref.Action == references.XRefActionCloses)
+ close := ref.Action == references.XRefActionCloses
if close && len(ref.TimeLog) > 0 {
if err := issueAddTime(refIssue, doer, c.Timestamp, ref.TimeLog); err != nil {
return err
LogRootPath string
DisableRouterLog bool
RouterLogLevel log.Level
- RouterLogMode string
EnableAccessLog bool
AccessLogTemplate string
EnableXORMLog bool
IsWindows bool
HasRobotsTxt bool
InternalToken string // internal access token
-
- // UILocation is the location on the UI, so that we can display the time on UI.
- // Currently only show the default time.Local, it could be added to app.ini after UI is ready
- UILocation = time.Local
)
// IsProd if it's a production mode
var err error
configBytes, err = json.Marshal(cfg)
- ok = (err == nil)
+ ok = err == nil
}
if !ok {
// no ... we've tried hard enough at this point - throw an error!
var (
// ErrURLNotSupported represents url is not supported
ErrURLNotSupported = errors.New("url method not supported")
- // ErrIterateObjectsNotSupported represents IterateObjects not supported
- ErrIterateObjectsNotSupported = errors.New("iterateObjects method not supported")
)
// ErrInvalidConfiguration is called when there is invalid configuration for a storage
UserID: ctx.User.ID,
Keyword: strings.TrimSpace(ctx.Query("q")),
OrgID: ctx.Org.Organization.ID,
- IncludeDesc: (ctx.Query("include_desc") == "" || ctx.QueryBool("include_desc")),
+ IncludeDesc: ctx.Query("include_desc") == "" || ctx.QueryBool("include_desc"),
ListOptions: listOptions,
}
keyword = ""
}
var issueIDs []int64
- var labelIDs []int64
if len(keyword) > 0 && len(repoIDs) > 0 {
if issueIDs, err = issue_indexer.SearchIssuesByKeyword(repoIDs, keyword); err != nil {
ctx.Error(http.StatusInternalServerError, "SearchIssuesByKeyword", err)
// Only fetch the issues if we either don't have a keyword or the search returned issues
// This would otherwise return all issues if no issues were found by the search.
- if len(keyword) == 0 || len(issueIDs) > 0 || len(labelIDs) > 0 {
+ if len(keyword) == 0 || len(issueIDs) > 0 || len(includedLabelNames) > 0 {
issuesOpt := &models.IssuesOptions{
ListOptions: models.ListOptions{
Page: ctx.QueryInt("page"),
}
}
if form.State != nil {
- issue.IsClosed = (api.StateClosed == api.StateType(*form.State))
+ issue.IsClosed = api.StateClosed == api.StateType(*form.State)
}
statusChangeComment, titleChanged, err := models.UpdateIssueByAPI(issue, ctx.User)
if err != nil {
}
if form.State != nil {
- issue.IsClosed = (api.StateClosed == api.StateType(*form.State))
+ issue.IsClosed = api.StateClosed == api.StateType(*form.State)
}
statusChangeComment, titleChanged, err := models.UpdateIssueByAPI(issue, ctx.User)
if err != nil {
if !ctx.IsSigned {
// Return unauthorized status event
- event := (&eventsource.Event{
+ event := &eventsource.Event{
Name: "close",
Data: "unauthorized",
- })
+ }
_, _ = event.WriteTo(ctx)
ctx.Resp.Flush()
return
break loop
}
// Replace the event - we don't want to expose the session ID to the user
- event = (&eventsource.Event{
+ event = &eventsource.Event{
Name: "logout",
Data: "elsewhere",
- })
+ }
}
_, err := event.WriteTo(ctx.Resp)
ctx.Data["PageIsOrgTeams"] = true
ctx.Data["PageIsOrgTeamsNew"] = true
ctx.Data["Units"] = models.Units
- var includesAllRepositories = (form.RepoAccess == "all")
+ var includesAllRepositories = form.RepoAccess == "all"
t := &models.Team{
OrgID: ctx.Org.Organization.ID,
isAuthChanged := false
isIncludeAllChanged := false
- var includesAllRepositories = (form.RepoAccess == "all")
+ var includesAllRepositories = form.RepoAccess == "all"
if !t.IsOwnerTeam() {
// Validate permission level.
auth := models.ParseAccessMode(form.Permission)
strings.HasSuffix(ctx.Req.URL.Path, "git-upload-archive") {
isPull = true
} else {
- isPull = (ctx.Req.Method == "GET")
+ isPull = ctx.Req.Method == "GET"
}
var accessMode models.AccessMode
)
var (
- // ErrTooManyFiles upload too many files
- ErrTooManyFiles = errors.New("Maximum number of files to upload exceeded")
// IssueTemplateCandidates issue templates
IssueTemplateCandidates = []string{
"ISSUE_TEMPLATE.md",
c.Data["merge_whitelist_users"] = strings.Join(base.Int64sToStrings(protectBranch.MergeWhitelistUserIDs), ",")
c.Data["approvals_whitelist_users"] = strings.Join(base.Int64sToStrings(protectBranch.ApprovalsWhitelistUserIDs), ",")
contexts, _ := models.FindRepoRecentCommitStatusContexts(c.Repo.Repository.ID, 7*24*time.Hour) // Find last week status check contexts
- for _, context := range protectBranch.StatusCheckContexts {
+ for _, ctx := range protectBranch.StatusCheckContexts {
var found bool
- for _, ctx := range contexts {
- if ctx == context {
+ for i := range contexts {
+ if contexts[i] == ctx {
found = true
break
}
}
if !found {
- contexts = append(contexts, context)
+ contexts = append(contexts, ctx)
}
}
if team != nil {
env = ctxUser.AccessibleTeamReposEnv(team)
- if err != nil {
- return nil, fmt.Errorf("AccessibleTeamReposEnv: %v", err)
- }
} else {
env, err = ctxUser.AccessibleReposEnv(ctxUser.ID)
if err != nil {
if err = ref.Issue.LoadRepo(); err != nil {
return err
}
- close := (ref.RefAction == references.XRefActionCloses)
+ close := ref.RefAction == references.XRefActionCloses
if close != ref.Issue.IsClosed {
if err = issue_service.ChangeStatus(ref.Issue, doer, close); err != nil {
return err
projects / gitea.git / commitdiff