"github.com/dgrijalva/jwt-go"
"github.com/kballard/go-shellquote"
- "github.com/unknwon/com"
"github.com/urfave/cli"
)
if len(keys) != 2 || keys[0] != "key" {
fail("Key ID format error", "Invalid key argument: %s", c.Args()[0])
}
- keyID := com.StrTo(keys[1]).MustInt64()
+ keyID, err := strconv.ParseInt(keys[1], 10, 64)
+ if err != nil {
+ fail("Key ID format error", "Invalid key argument: %s", c.Args()[1])
+ }
cmd := os.Getenv("SSH_ORIGINAL_COMMAND")
if len(cmd) == 0 {
"github.com/go-git/go-git/v5/config"
"github.com/go-git/go-git/v5/plumbing"
context2 "github.com/gorilla/context"
- "github.com/unknwon/com"
"xorm.io/xorm"
)
models.LoadFixtures()
util.RemoveAll(setting.RepoRootPath)
util.RemoveAll(models.LocalCopyPath())
- com.CopyDir(path.Join(curDir, "integrations/gitea-repositories-meta"), setting.RepoRootPath)
+ util.CopyDir(path.Join(curDir, "integrations/gitea-repositories-meta"), setting.RepoRootPath)
log.Printf("[PR] Setting up router\n")
//routers.GlobalInit()
"code.gitea.io/gitea/modules/util"
"github.com/stretchr/testify/assert"
- "github.com/unknwon/com"
)
func withKeyFile(t *testing.T, keyname string, callback func(string)) {
func doGitClone(dstLocalPath string, u *url.URL) func(*testing.T) {
return func(t *testing.T) {
assert.NoError(t, git.CloneWithArgs(context.Background(), u.String(), dstLocalPath, allowLFSFilters(), git.CloneRepoOptions{}))
- assert.True(t, com.IsExist(filepath.Join(dstLocalPath, "README.md")))
+ exist, err := util.IsExist(filepath.Join(dstLocalPath, "README.md"))
+ assert.NoError(t, err)
+ assert.True(t, exist)
}
}
assert.NoError(t, err)
defer util.RemoveAll(tmpDir)
assert.Error(t, git.Clone(u.String(), tmpDir, git.CloneRepoOptions{}))
- assert.False(t, com.IsExist(filepath.Join(tmpDir, "README.md")))
+ exist, err := util.IsExist(filepath.Join(tmpDir, "README.md"))
+ assert.NoError(t, err)
+ assert.False(t, exist)
}
}
"github.com/PuerkitoBio/goquery"
"github.com/go-chi/chi"
"github.com/stretchr/testify/assert"
- "github.com/unknwon/com"
)
var c chi.Router
assert.NoError(t, models.LoadFixtures())
assert.NoError(t, util.RemoveAll(setting.RepoRootPath))
- assert.NoError(t, com.CopyDir(path.Join(filepath.Dir(setting.AppPath), "integrations/gitea-repositories-meta"),
- setting.RepoRootPath))
+ assert.NoError(t, util.CopyDir(path.Join(filepath.Dir(setting.AppPath), "integrations/gitea-repositories-meta"), setting.RepoRootPath))
return deferFn
}
assert.NoError(t, queue.GetManager().FlushAll(context.Background(), -1))
assert.NoError(t, models.LoadFixtures())
assert.NoError(t, util.RemoveAll(setting.RepoRootPath))
- assert.NoError(t, com.CopyDir(path.Join(filepath.Dir(setting.AppPath), "integrations/gitea-repositories-meta"),
- setting.RepoRootPath))
+ assert.NoError(t, util.CopyDir(path.Join(filepath.Dir(setting.AppPath), "integrations/gitea-repositories-meta"), setting.RepoRootPath))
}
"code.gitea.io/gitea/modules/util"
"github.com/stretchr/testify/assert"
- "github.com/unknwon/com"
"xorm.io/xorm"
)
assert.True(t, len(setting.RepoRootPath) != 0)
assert.NoError(t, util.RemoveAll(setting.RepoRootPath))
- assert.NoError(t, com.CopyDir(path.Join(filepath.Dir(setting.AppPath), "integrations/gitea-repositories-meta"), setting.RepoRootPath))
+ assert.NoError(t, util.CopyDir(path.Join(filepath.Dir(setting.AppPath), "integrations/gitea-repositories-meta"), setting.RepoRootPath))
setting.CheckLFSVersion()
setting.InitDBConfig()
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/timeutil"
- "github.com/unknwon/com"
"xorm.io/builder"
)
// GetIssueTitle returns the title of first issue associated
// with the action.
func (a *Action) GetIssueTitle() string {
- index := com.StrTo(a.GetIssueInfos()[0]).MustInt64()
+ index, _ := strconv.ParseInt(a.GetIssueInfos()[0], 10, 64)
issue, err := GetIssueByIndex(a.RepoID, index)
if err != nil {
log.Error("GetIssueByIndex: %v", err)
// GetIssueContent returns the content of first issue associated with
// this action.
func (a *Action) GetIssueContent() string {
- index := com.StrTo(a.GetIssueInfos()[0]).MustInt64()
+ index, _ := strconv.ParseInt(a.GetIssueInfos()[0], 10, 64)
issue, err := GetIssueByIndex(a.RepoID, index)
if err != nil {
log.Error("GetIssueByIndex: %v", err)
"code.gitea.io/gitea/modules/storage"
"code.gitea.io/gitea/modules/timeutil"
"code.gitea.io/gitea/modules/util"
-
- "github.com/unknwon/com"
)
//NoticeType describes the notice type
// TrStr returns a translation format string.
func (n *Notice) TrStr() string {
- return "admin.notices.type_" + com.ToStr(n.Type)
+ return fmt.Sprintf("admin.notices.type_%d", n.Type)
}
// CreateNotice creates new system notice.
"code.gitea.io/gitea/modules/util"
"github.com/gobwas/glob"
- "github.com/unknwon/com"
)
// ProtectedBranch struct
whitelist = make([]int64, 0, len(teams))
for i := range teams {
- if com.IsSliceContainsInt64(newWhitelist, teams[i].ID) {
+ if util.IsInt64InSlice(teams[i].ID, newWhitelist) {
whitelist = append(whitelist, teams[i].ID)
}
}
"code.gitea.io/gitea/modules/timeutil"
"code.gitea.io/gitea/modules/util"
- "github.com/unknwon/com"
"xorm.io/builder"
"xorm.io/xorm"
)
// HashTag returns unique hash tag for issue.
func (issue *Issue) HashTag() string {
- return "issue-" + com.ToStr(issue.ID)
+ return fmt.Sprintf("issue-%d", issue.ID)
}
// IsPoster returns true if given user by ID is the poster.
return 0
}
for _, result := range results[0] {
- return com.StrTo(string(result)).MustInt64()
+ c, _ := strconv.ParseInt(string(result), 10, 64)
+ return c
}
return 0
}
"code.gitea.io/gitea/modules/structs"
"code.gitea.io/gitea/modules/timeutil"
- "github.com/unknwon/com"
"xorm.io/builder"
"xorm.io/xorm"
)
// EventTag returns unique event hash tag for comment.
func (c *Comment) EventTag() string {
- return "event-" + com.ToStr(c.ID)
+ return fmt.Sprintf("event-%d", c.ID)
}
// LoadLabel if comment.Type is CommentTypeLabel, then load Label
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/references"
- "github.com/unknwon/com"
"xorm.io/xorm"
)
return ""
}
// FIXME: check this name for cross-repository references (#7901 if it gets merged)
- return "#" + com.ToStr(comment.RefIssue.Index)
+ return fmt.Sprintf("#%d", comment.RefIssue.Index)
}
// __________ .__ .__ __________ __
"fmt"
"net/smtp"
"net/textproto"
+ "strconv"
"strings"
"code.gitea.io/gitea/modules/auth/ldap"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/timeutil"
+ "code.gitea.io/gitea/modules/util"
- "github.com/unknwon/com"
"xorm.io/xorm"
"xorm.io/xorm/convert"
)
switch (*val).(type) {
case []uint8:
log.Trace("Cell2Int64 ([]uint8): %v", *val)
- return com.StrTo(string((*val).([]uint8))).MustInt64()
+
+ v, _ := strconv.ParseInt(string((*val).([]uint8)), 10, 64)
+ return v
}
return (*val).(int64)
}
case LoginSSPI:
source.Cfg = new(SSPIConfig)
default:
- panic("unrecognized login source type: " + com.ToStr(*val))
+ panic(fmt.Sprintf("unrecognized login source type: %v", *val))
}
}
}
idx := strings.Index(login, "@")
if idx == -1 {
return nil, ErrUserNotExist{0, login, 0}
- } else if !com.IsSliceContainsStr(strings.Split(cfg.AllowedDomains, ","), login[idx+1:]) {
+ } else if !util.IsStringInSlice(login[idx+1:], strings.Split(cfg.AllowedDomains, ","), true) {
return nil, ErrUserNotExist{0, login, 0}
}
}
"code.gitea.io/gitea/modules/secret"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/timeutil"
+ "code.gitea.io/gitea/modules/util"
"github.com/dgrijalva/jwt-go"
uuid "github.com/google/uuid"
- "github.com/unknwon/com"
"golang.org/x/crypto/bcrypt"
"xorm.io/xorm"
)
// ContainsRedirectURI checks if redirectURI is allowed for app
func (app *OAuth2Application) ContainsRedirectURI(redirectURI string) bool {
- return com.IsSliceContainsStr(app.RedirectURIs, redirectURI)
+ return util.IsStringInSlice(redirectURI, app.RedirectURIs, true)
}
// GenerateClientSecret will generate the client secret and returns the plaintext and saves the hash at the database
"code.gitea.io/gitea/modules/timeutil"
"code.gitea.io/gitea/modules/util"
- "github.com/unknwon/com"
"xorm.io/builder"
)
}
for _, f := range customFiles {
- if !com.IsSliceContainsStr(files, f) {
+ if !util.IsStringInSlice(f, files, true) {
files = append(files, f)
}
}
// Filter out invalid names and promote preferred licenses.
sortedLicenses := make([]string, 0, len(Licenses))
for _, name := range setting.Repository.PreferredLicenses {
- if com.IsSliceContainsStr(Licenses, name) {
+ if util.IsStringInSlice(name, Licenses, true) {
sortedLicenses = append(sortedLicenses, name)
}
}
for _, name := range Licenses {
- if !com.IsSliceContainsStr(setting.Repository.PreferredLicenses, name) {
+ if !util.IsStringInSlice(name, setting.Repository.PreferredLicenses, true) {
sortedLicenses = append(sortedLicenses, name)
}
}
return
}
for _, result := range results {
- id := com.StrTo(result["id"]).MustInt64()
+ id, _ := strconv.ParseInt(string(result["id"]), 10, 64)
select {
case <-ctx.Done():
log.Warn("CheckRepoStats: Cancelled before checking %s for Repo[%d]", checker.desc, id)
log.Error("Select %s: %v", desc, err)
} else {
for _, result := range results {
- id := com.StrTo(result["id"]).MustInt64()
+ id, _ := strconv.ParseInt(string(result["id"]), 10, 64)
select {
case <-ctx.Done():
log.Warn("CheckRepoStats: Cancelled during %s for repo ID %d", desc, id)
log.Error("Select %s: %v", desc, err)
} else {
for _, result := range results {
- id := com.StrTo(result["id"]).MustInt64()
+ id, _ := strconv.ParseInt(string(result["id"]), 10, 64)
select {
case <-ctx.Done():
log.Warn("CheckRepoStats: Cancelled")
log.Error("Select repository count 'num_forks': %v", err)
} else {
for _, result := range results {
- id := com.StrTo(result["id"]).MustInt64()
+ id, _ := strconv.ParseInt(string(result["id"]), 10, 64)
select {
case <-ctx.Done():
log.Warn("CheckRepoStats: Cancelled")
import (
"encoding/json"
+ "fmt"
"code.gitea.io/gitea/modules/timeutil"
- "github.com/unknwon/com"
"xorm.io/xorm"
"xorm.io/xorm/convert"
)
case UnitTypeIssues:
r.Config = new(IssuesConfig)
default:
- panic("unrecognized repo unit type: " + com.ToStr(*val))
+ panic(fmt.Sprintf("unrecognized repo unit type: %v", *val))
}
}
}
"math/big"
"os"
"path/filepath"
+ "strconv"
"strings"
"sync"
"time"
"code.gitea.io/gitea/modules/timeutil"
"code.gitea.io/gitea/modules/util"
- "github.com/unknwon/com"
"golang.org/x/crypto/ssh"
"xorm.io/builder"
"xorm.io/xorm"
}
keyType := strings.Trim(fields[len(fields)-1], "()\r\n")
- return strings.ToLower(keyType), com.StrTo(fields[0]).MustInt(), nil
+ length, err := strconv.ParseInt(fields[0], 10, 32)
+ if err != nil {
+ return "", 0, err
+ }
+ return strings.ToLower(keyType), int(length), nil
}
// SSHNativeParsePublicKey extracts the key type and length using the golang SSH library.
}
if isExist {
bakPath := fmt.Sprintf("%s_%d.gitea_bak", fPath, time.Now().Unix())
- if err = com.Copy(fPath, bakPath); err != nil {
+ if err = util.CopyFile(fPath, bakPath); err != nil {
return err
}
}
}
if isExist {
bakPath := fmt.Sprintf("%s_%d.gitea_bak", fPath, time.Now().Unix())
- if err = com.Copy(fPath, bakPath); err != nil {
+ if err = util.CopyFile(fPath, bakPath); err != nil {
return err
}
}
"code.gitea.io/gitea/modules/util"
"github.com/stretchr/testify/assert"
- "github.com/unknwon/com"
"xorm.io/xorm"
"xorm.io/xorm/names"
)
if err = util.RemoveAll(setting.RepoRootPath); err != nil {
fatalTestError("util.RemoveAll: %v\n", err)
}
- if err = com.CopyDir(filepath.Join(pathToGiteaRoot, "integrations", "gitea-repositories-meta"), setting.RepoRootPath); err != nil {
- fatalTestError("com.CopyDir: %v\n", err)
+ if err = util.CopyDir(filepath.Join(pathToGiteaRoot, "integrations", "gitea-repositories-meta"), setting.RepoRootPath); err != nil {
+ fatalTestError("util.CopyDir: %v\n", err)
}
exitStatus := m.Run()
assert.NoError(t, PrepareTestDatabase())
assert.NoError(t, util.RemoveAll(setting.RepoRootPath))
metaPath := filepath.Join(giteaRoot, "integrations", "gitea-repositories-meta")
- assert.NoError(t, com.CopyDir(metaPath, setting.RepoRootPath))
+ assert.NoError(t, util.CopyDir(metaPath, setting.RepoRootPath))
base.SetupGiteaRoot() // Makes sure GITEA_ROOT is set
}
"code.gitea.io/gitea/modules/timeutil"
"code.gitea.io/gitea/modules/util"
- "github.com/unknwon/com"
"golang.org/x/crypto/argon2"
"golang.org/x/crypto/bcrypt"
"golang.org/x/crypto/pbkdf2"
// GenerateEmailActivateCode generates an activate code based on user information and given e-mail.
func (u *User) GenerateEmailActivateCode(email string) string {
code := base.CreateTimeLimitCode(
- com.ToStr(u.ID)+email+u.LowerName+u.Passwd+u.Rands,
+ fmt.Sprintf("%d%s%s%s%s", u.ID, email, u.LowerName, u.Passwd, u.Rands),
setting.Service.ActiveCodeLives, nil)
// Add tail hex username
if user = getVerifyUser(code); user != nil {
// time limit code
prefix := code[:base.TimeLimitCodeLength]
- data := com.ToStr(user.ID) + user.Email + user.LowerName + user.Passwd + user.Rands
+ data := fmt.Sprintf("%d%s%s%s%s", user.ID, user.Email, user.LowerName, user.Passwd, user.Rands)
if base.VerifyTimeLimitCode(data, minutes, prefix) {
return user
if user := getVerifyUser(code); user != nil {
// time limit code
prefix := code[:base.TimeLimitCodeLength]
- data := com.ToStr(user.ID) + email + user.LowerName + user.Passwd + user.Rands
+ data := fmt.Sprintf("%d%s%s%s%s", user.ID, email, user.LowerName, user.Passwd, user.Rands)
if base.VerifyTimeLimitCode(data, minutes, prefix) {
emailAddress := &EmailAddress{UID: user.ID, Email: email}
"code.gitea.io/gitea/modules/setting"
"github.com/dustin/go-humanize"
- "github.com/unknwon/com"
)
// EncodeMD5 encodes string to md5 hex value.
// split code
start := code[:12]
lives := code[12:18]
- if d, err := com.StrTo(lives).Int(); err == nil {
- minutes = d
+ if d, err := strconv.ParseInt(lives, 10, 0); err == nil {
+ minutes = int(d)
}
// right active code
// create sha1 encode string
sh := sha1.New()
- _, _ = sh.Write([]byte(data + setting.SecretKey + startStr + endStr + com.ToStr(minutes)))
+ _, _ = sh.Write([]byte(fmt.Sprintf("%s%s%s%s%d", data, setting.SecretKey, startStr, endStr, minutes)))
encoded := hex.EncodeToString(sh.Sum(nil))
code := fmt.Sprintf("%s%06d%s", startStr, minutes, encoded)
func StringsToInt64s(strs []string) ([]int64, error) {
ints := make([]int64, len(strs))
for i := range strs {
- n, err := com.StrTo(strs[i]).Int64()
+ n, err := strconv.ParseInt(strs[i], 10, 64)
if err != nil {
return ints, err
}
api "code.gitea.io/gitea/modules/structs"
"code.gitea.io/gitea/modules/util"
"code.gitea.io/gitea/services/webhook"
-
- "github.com/unknwon/com"
)
// ToEmail convert models.EmailAddress to api.Email
return &api.PublicKey{
ID: key.ID,
Key: key.Content,
- URL: apiLink + com.ToStr(key.ID),
+ URL: fmt.Sprintf("%s%d", apiLink, key.ID),
Title: key.Name,
Fingerprint: key.Fingerprint,
Created: key.CreatedUnix.AsTime(),
KeyID: key.KeyID,
Key: key.Content,
Fingerprint: key.Fingerprint,
- URL: apiLink + com.ToStr(key.ID),
+ URL: fmt.Sprintf("%s%d", apiLink, key.ID),
Title: key.Name,
Created: key.CreatedUnix.AsTime(),
ReadOnly: key.Mode == models.AccessModeRead, // All deploy keys are read-only.
"strconv"
"strings"
"time"
-
- "github.com/unknwon/com"
)
// GPGSettings represents the default GPG settings for this repository
for _, line := range strings.Split(objects, "\n") {
switch {
case strings.HasPrefix(line, statCount):
- repoSize.Count = com.StrTo(line[7:]).MustInt64()
+ repoSize.Count, _ = strconv.ParseInt(line[7:], 10, 64)
case strings.HasPrefix(line, statSize):
- repoSize.Size = com.StrTo(line[6:]).MustInt64() * 1024
+ repoSize.Size, _ = strconv.ParseInt(line[6:], 10, 64)
+ repoSize.Size *= 1024
case strings.HasPrefix(line, statInpack):
- repoSize.InPack = com.StrTo(line[9:]).MustInt64()
+ repoSize.InPack, _ = strconv.ParseInt(line[9:], 10, 64)
case strings.HasPrefix(line, statPacks):
- repoSize.Packs = com.StrTo(line[7:]).MustInt64()
+ repoSize.Packs, _ = strconv.ParseInt(line[7:], 10, 64)
case strings.HasPrefix(line, statSizePack):
- repoSize.SizePack = com.StrTo(line[11:]).MustInt64() * 1024
+ repoSize.Count, _ = strconv.ParseInt(line[11:], 10, 64)
+ repoSize.Count *= 1024
case strings.HasPrefix(line, statPrunePackage):
- repoSize.PrunePack = com.StrTo(line[16:]).MustInt64()
+ repoSize.PrunePack, _ = strconv.ParseInt(line[16:], 10, 64)
case strings.HasPrefix(line, statGarbage):
- repoSize.Garbage = com.StrTo(line[9:]).MustInt64()
+ repoSize.Garbage, _ = strconv.ParseInt(line[9:], 10, 64)
case strings.HasPrefix(line, statSizeGarbage):
- repoSize.SizeGarbage = com.StrTo(line[14:]).MustInt64() * 1024
+ repoSize.SizeGarbage, _ = strconv.ParseInt(line[14:], 10, 64)
+ repoSize.SizeGarbage *= 1024
}
}
return repoSize
"code.gitea.io/gitea/modules/util"
"github.com/gliderlabs/ssh"
- "github.com/unknwon/com"
gossh "golang.org/x/crypto/ssh"
)
}
func sessionHandler(session ssh.Session) {
- keyID := session.Context().Value(giteaKeyID).(int64)
+ keyID := fmt.Sprintf("%d", session.Context().Value(giteaKeyID).(int64))
command := session.RawCommand()
log.Trace("SSH: Payload: %v", command)
- args := []string{"serv", "key-" + com.ToStr(keyID), "--config=" + setting.CustomConf}
+ args := []string{"serv", "key-" + keyID, "--config=" + setting.CustomConf}
log.Trace("SSH: Arguments: %v", args)
cmd := exec.Command(setting.AppPath, args...)
cmd.Env = append(
package util
-import "sort"
+import (
+ "sort"
+ "strings"
+)
// Int64Slice attaches the methods of Interface to []int64, sorting in increasing order.
type Int64Slice []int64
}
// IsStringInSlice sequential searches if string exists in slice.
-func IsStringInSlice(target string, slice []string) bool {
+func IsStringInSlice(target string, slice []string, insensitive ...bool) bool {
+ caseInsensitive := false
+ if len(insensitive) != 0 && insensitive[0] {
+ caseInsensitive = true
+ target = strings.ToLower(target)
+ }
+
for i := 0; i < len(slice); i++ {
- if slice[i] == target {
- return true
+ if caseInsensitive {
+ if strings.ToLower(slice[i]) == target {
+ return true
+ }
+ } else {
+ if slice[i] == target {
+ return true
+ }
}
}
return false
--- /dev/null
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package util
+
+import (
+ "github.com/unknwon/com"
+)
+
+// CopyFile copies file from source to target path.
+func CopyFile(src, dest string) error {
+ return com.Copy(src, dest)
+}
+
+// CopyDir copy files recursively from source to target directory.
+// It returns error when error occurs in underlying functions.
+func CopyDir(srcPath, destPath string) error {
+ return com.CopyDir(srcPath, destPath)
+}
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/util"
- "github.com/unknwon/com"
"xorm.io/xorm/convert"
)
log.Trace("Authentication changed by admin(%s): %d", ctx.User.Name, source.ID)
ctx.Flash.Success(ctx.Tr("admin.auths.update_success"))
- ctx.Redirect(setting.AppSubURL + "/admin/auths/" + com.ToStr(form.ID))
+ ctx.Redirect(setting.AppSubURL + "/admin/auths/" + fmt.Sprint(form.ID))
}
// DeleteAuthSource response for deleting an auth source
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/util"
-
- "github.com/unknwon/com"
)
const (
truefalse := map[string]bool{"1": true, "0": false}
- uid := com.StrTo(ctx.Query("uid")).MustInt64()
+ uid := ctx.QueryInt64("uid")
email := ctx.Query("email")
primary, okp := truefalse[ctx.Query("primary")]
activate, oka := truefalse[ctx.Query("activate")]
package admin
import (
+ "strconv"
+
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
-
- "github.com/unknwon/com"
)
const (
strs := ctx.QueryStrings("ids[]")
ids := make([]int64, 0, len(strs))
for i := range strs {
- id := com.StrTo(strs[i]).MustInt64()
+ id, _ := strconv.ParseInt(strs[i], 10, 64)
if id > 0 {
ids = append(ids, id)
}
package admin
import (
+ "fmt"
+ "strconv"
"strings"
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/routers"
"code.gitea.io/gitea/services/mailer"
-
- "github.com/unknwon/com"
)
const (
if len(form.LoginType) > 0 {
fields := strings.Split(form.LoginType, "-")
if len(fields) == 2 {
- u.LoginType = models.LoginType(com.StrTo(fields[0]).MustInt())
- u.LoginSource = com.StrTo(fields[1]).MustInt64()
+ lType, _ := strconv.ParseInt(fields[0], 10, 0)
+ u.LoginType = models.LoginType(lType)
+ u.LoginSource, _ = strconv.ParseInt(fields[1], 10, 64)
u.LoginName = form.LoginName
}
}
}
ctx.Flash.Success(ctx.Tr("admin.users.new_success", u.Name))
- ctx.Redirect(setting.AppSubURL + "/admin/users/" + com.ToStr(u.ID))
+ ctx.Redirect(setting.AppSubURL + "/admin/users/" + fmt.Sprint(u.ID))
}
func prepareUserInfo(ctx *context.Context) *models.User {
fields := strings.Split(form.LoginType, "-")
if len(fields) == 2 {
- loginType := models.LoginType(com.StrTo(fields[0]).MustInt())
- loginSource := com.StrTo(fields[1]).MustInt64()
+ loginType, _ := strconv.ParseInt(fields[0], 10, 0)
+ loginSource, _ := strconv.ParseInt(fields[1], 10, 64)
if u.LoginSource != loginSource {
u.LoginSource = loginSource
- u.LoginType = loginType
+ u.LoginType = models.LoginType(loginType)
}
}
"code.gitea.io/gitea/modules/convert"
api "code.gitea.io/gitea/modules/structs"
"code.gitea.io/gitea/routers/api/v1/utils"
-
- "github.com/unknwon/com"
)
// Search search users
opts := &models.SearchUserOptions{
Keyword: strings.Trim(ctx.Query("q"), " "),
- UID: com.StrTo(ctx.Query("uid")).MustInt64(),
+ UID: ctx.QueryInt64("uid"),
Type: models.UserTypeIndividual,
ListOptions: listOptions,
}
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
api "code.gitea.io/gitea/modules/structs"
+ "code.gitea.io/gitea/modules/util"
"code.gitea.io/gitea/routers/utils"
"code.gitea.io/gitea/services/webhook"
-
- "github.com/unknwon/com"
)
// GetOrgHook get an organization's webhook. If there is an error, write to
}
func issuesHook(events []string, event string) bool {
- return com.IsSliceContainsStr(events, event) || com.IsSliceContainsStr(events, string(models.HookEventIssues))
+ return util.IsStringInSlice(event, events, true) || util.IsStringInSlice(string(models.HookEventIssues), events, true)
}
func pullHook(events []string, event string) bool {
- return com.IsSliceContainsStr(events, event) || com.IsSliceContainsStr(events, string(models.HookEventPullRequest))
+ return util.IsStringInSlice(event, events, true) || util.IsStringInSlice(string(models.HookEventPullRequest), events, true)
}
// addHook add the hook specified by `form`, `orgID` and `repoID`. If there is
HookEvent: &models.HookEvent{
ChooseEvents: true,
HookEvents: models.HookEvents{
- Create: com.IsSliceContainsStr(form.Events, string(models.HookEventCreate)),
- Delete: com.IsSliceContainsStr(form.Events, string(models.HookEventDelete)),
- Fork: com.IsSliceContainsStr(form.Events, string(models.HookEventFork)),
+ Create: util.IsStringInSlice(string(models.HookEventCreate), form.Events, true),
+ Delete: util.IsStringInSlice(string(models.HookEventDelete), form.Events, true),
+ Fork: util.IsStringInSlice(string(models.HookEventFork), form.Events, true),
Issues: issuesHook(form.Events, "issues_only"),
IssueAssign: issuesHook(form.Events, string(models.HookEventIssueAssign)),
IssueLabel: issuesHook(form.Events, string(models.HookEventIssueLabel)),
IssueMilestone: issuesHook(form.Events, string(models.HookEventIssueMilestone)),
IssueComment: issuesHook(form.Events, string(models.HookEventIssueComment)),
- Push: com.IsSliceContainsStr(form.Events, string(models.HookEventPush)),
+ Push: util.IsStringInSlice(string(models.HookEventPush), form.Events, true),
PullRequest: pullHook(form.Events, "pull_request_only"),
PullRequestAssign: pullHook(form.Events, string(models.HookEventPullRequestAssign)),
PullRequestLabel: pullHook(form.Events, string(models.HookEventPullRequestLabel)),
PullRequestComment: pullHook(form.Events, string(models.HookEventPullRequestComment)),
PullRequestReview: pullHook(form.Events, "pull_request_review"),
PullRequestSync: pullHook(form.Events, string(models.HookEventPullRequestSync)),
- Repository: com.IsSliceContainsStr(form.Events, string(models.HookEventRepository)),
- Release: com.IsSliceContainsStr(form.Events, string(models.HookEventRelease)),
+ Repository: util.IsStringInSlice(string(models.HookEventRepository), form.Events, true),
+ Release: util.IsStringInSlice(string(models.HookEventRelease), form.Events, true),
},
BranchFilter: form.BranchFilter,
},
w.PushOnly = false
w.SendEverything = false
w.ChooseEvents = true
- w.Create = com.IsSliceContainsStr(form.Events, string(models.HookEventCreate))
- w.Push = com.IsSliceContainsStr(form.Events, string(models.HookEventPush))
- w.PullRequest = com.IsSliceContainsStr(form.Events, string(models.HookEventPullRequest))
- w.Create = com.IsSliceContainsStr(form.Events, string(models.HookEventCreate))
- w.Delete = com.IsSliceContainsStr(form.Events, string(models.HookEventDelete))
- w.Fork = com.IsSliceContainsStr(form.Events, string(models.HookEventFork))
- w.Issues = com.IsSliceContainsStr(form.Events, string(models.HookEventIssues))
- w.IssueComment = com.IsSliceContainsStr(form.Events, string(models.HookEventIssueComment))
- w.Push = com.IsSliceContainsStr(form.Events, string(models.HookEventPush))
- w.PullRequest = com.IsSliceContainsStr(form.Events, string(models.HookEventPullRequest))
- w.Repository = com.IsSliceContainsStr(form.Events, string(models.HookEventRepository))
- w.Release = com.IsSliceContainsStr(form.Events, string(models.HookEventRelease))
+ w.Create = util.IsStringInSlice(string(models.HookEventCreate), form.Events, true)
+ w.Push = util.IsStringInSlice(string(models.HookEventPush), form.Events, true)
+ w.PullRequest = util.IsStringInSlice(string(models.HookEventPullRequest), form.Events, true)
+ w.Create = util.IsStringInSlice(string(models.HookEventCreate), form.Events, true)
+ w.Delete = util.IsStringInSlice(string(models.HookEventDelete), form.Events, true)
+ w.Fork = util.IsStringInSlice(string(models.HookEventFork), form.Events, true)
+ w.Issues = util.IsStringInSlice(string(models.HookEventIssues), form.Events, true)
+ w.IssueComment = util.IsStringInSlice(string(models.HookEventIssueComment), form.Events, true)
+ w.Push = util.IsStringInSlice(string(models.HookEventPush), form.Events, true)
+ w.PullRequest = util.IsStringInSlice(string(models.HookEventPullRequest), form.Events, true)
+ w.Repository = util.IsStringInSlice(string(models.HookEventRepository), form.Events, true)
+ w.Release = util.IsStringInSlice(string(models.HookEventRelease), form.Events, true)
w.BranchFilter = form.BranchFilter
if err := w.UpdateEvent(); err != nil {
package routers
import (
+ "fmt"
"net/http"
"os"
"os/exec"
"code.gitea.io/gitea/modules/user"
"code.gitea.io/gitea/modules/util"
- "github.com/unknwon/com"
"gopkg.in/ini.v1"
)
cfg.Section("server").Key("DISABLE_SSH").SetValue("true")
} else {
cfg.Section("server").Key("DISABLE_SSH").SetValue("false")
- cfg.Section("server").Key("SSH_PORT").SetValue(com.ToStr(form.SSHPort))
+ cfg.Section("server").Key("SSH_PORT").SetValue(fmt.Sprint(form.SSHPort))
}
if form.LFSRootPath != "" {
} else {
cfg.Section("mailer").Key("ENABLED").SetValue("false")
}
- cfg.Section("service").Key("REGISTER_EMAIL_CONFIRM").SetValue(com.ToStr(form.RegisterConfirm))
- cfg.Section("service").Key("ENABLE_NOTIFY_MAIL").SetValue(com.ToStr(form.MailNotify))
-
- cfg.Section("server").Key("OFFLINE_MODE").SetValue(com.ToStr(form.OfflineMode))
- cfg.Section("picture").Key("DISABLE_GRAVATAR").SetValue(com.ToStr(form.DisableGravatar))
- cfg.Section("picture").Key("ENABLE_FEDERATED_AVATAR").SetValue(com.ToStr(form.EnableFederatedAvatar))
- cfg.Section("openid").Key("ENABLE_OPENID_SIGNIN").SetValue(com.ToStr(form.EnableOpenIDSignIn))
- cfg.Section("openid").Key("ENABLE_OPENID_SIGNUP").SetValue(com.ToStr(form.EnableOpenIDSignUp))
- cfg.Section("service").Key("DISABLE_REGISTRATION").SetValue(com.ToStr(form.DisableRegistration))
- cfg.Section("service").Key("ALLOW_ONLY_EXTERNAL_REGISTRATION").SetValue(com.ToStr(form.AllowOnlyExternalRegistration))
- cfg.Section("service").Key("ENABLE_CAPTCHA").SetValue(com.ToStr(form.EnableCaptcha))
- cfg.Section("service").Key("REQUIRE_SIGNIN_VIEW").SetValue(com.ToStr(form.RequireSignInView))
- cfg.Section("service").Key("DEFAULT_KEEP_EMAIL_PRIVATE").SetValue(com.ToStr(form.DefaultKeepEmailPrivate))
- cfg.Section("service").Key("DEFAULT_ALLOW_CREATE_ORGANIZATION").SetValue(com.ToStr(form.DefaultAllowCreateOrganization))
- cfg.Section("service").Key("DEFAULT_ENABLE_TIMETRACKING").SetValue(com.ToStr(form.DefaultEnableTimetracking))
- cfg.Section("service").Key("NO_REPLY_ADDRESS").SetValue(com.ToStr(form.NoReplyAddress))
+ cfg.Section("service").Key("REGISTER_EMAIL_CONFIRM").SetValue(fmt.Sprint(form.RegisterConfirm))
+ cfg.Section("service").Key("ENABLE_NOTIFY_MAIL").SetValue(fmt.Sprint(form.MailNotify))
+
+ cfg.Section("server").Key("OFFLINE_MODE").SetValue(fmt.Sprint(form.OfflineMode))
+ cfg.Section("picture").Key("DISABLE_GRAVATAR").SetValue(fmt.Sprint(form.DisableGravatar))
+ cfg.Section("picture").Key("ENABLE_FEDERATED_AVATAR").SetValue(fmt.Sprint(form.EnableFederatedAvatar))
+ cfg.Section("openid").Key("ENABLE_OPENID_SIGNIN").SetValue(fmt.Sprint(form.EnableOpenIDSignIn))
+ cfg.Section("openid").Key("ENABLE_OPENID_SIGNUP").SetValue(fmt.Sprint(form.EnableOpenIDSignUp))
+ cfg.Section("service").Key("DISABLE_REGISTRATION").SetValue(fmt.Sprint(form.DisableRegistration))
+ cfg.Section("service").Key("ALLOW_ONLY_EXTERNAL_REGISTRATION").SetValue(fmt.Sprint(form.AllowOnlyExternalRegistration))
+ cfg.Section("service").Key("ENABLE_CAPTCHA").SetValue(fmt.Sprint(form.EnableCaptcha))
+ cfg.Section("service").Key("REQUIRE_SIGNIN_VIEW").SetValue(fmt.Sprint(form.RequireSignInView))
+ cfg.Section("service").Key("DEFAULT_KEEP_EMAIL_PRIVATE").SetValue(fmt.Sprint(form.DefaultKeepEmailPrivate))
+ cfg.Section("service").Key("DEFAULT_ALLOW_CREATE_ORGANIZATION").SetValue(fmt.Sprint(form.DefaultAllowCreateOrganization))
+ cfg.Section("service").Key("DEFAULT_ENABLE_TIMETRACKING").SetValue(fmt.Sprint(form.DefaultEnableTimetracking))
+ cfg.Section("service").Key("NO_REPLY_ADDRESS").SetValue(fmt.Sprint(form.NoReplyAddress))
cfg.Section("").Key("RUN_MODE").SetValue("prod")
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
-
- "github.com/unknwon/com"
)
const (
// MembersAction response for operation to a member of organization
func MembersAction(ctx *context.Context) {
- uid := com.StrTo(ctx.Query("uid")).MustInt64()
+ uid := ctx.QueryInt64("uid")
if uid == 0 {
ctx.Redirect(ctx.Org.OrgLink + "/members")
return
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/routers/utils"
-
- "github.com/unknwon/com"
)
const (
// TeamsAction response for join, leave, remove, add operations to team
func TeamsAction(ctx *context.Context) {
- uid := com.StrTo(ctx.Query("uid")).MustInt64()
+ uid := ctx.QueryInt64("uid")
if uid == 0 {
ctx.Redirect(ctx.Org.OrgLink + "/teams")
return
}
err = ctx.Org.Team.AddRepository(repo)
case "remove":
- err = ctx.Org.Team.RemoveRepository(com.StrTo(ctx.Query("repoid")).MustInt64())
+ err = ctx.Org.Team.RemoveRepository(ctx.QueryInt64("repoid"))
case "addall":
err = ctx.Org.Team.AddAllRepositories()
case "removeall":
viewType := ctx.Query("type")
sortType := ctx.Query("sort")
types := []string{"all", "your_repositories", "assigned", "created_by", "mentioned"}
- if !com.IsSliceContainsStr(types, viewType) {
+ if !util.IsStringInSlice(viewType, types, true) {
viewType = "all"
}
}
log.Trace("Issue created: %d/%d", repo.ID, issue.ID)
- ctx.Redirect(ctx.Repo.RepoLink + "/issues/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/issues/" + fmt.Sprint(issue.Index))
}
// commentTag returns the CommentTag for a comment in/with the given repo, poster and issue
// Make sure type and URL matches.
if ctx.Params(":type") == "issues" && issue.IsPull {
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
return
} else if ctx.Params(":type") == "pulls" && !issue.IsPull {
- ctx.Redirect(ctx.Repo.RepoLink + "/issues/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/issues/" + fmt.Sprint(issue.Index))
return
}
log.Error("IsProtectedBranch: %v", err)
} else if !protected {
canDelete = true
- ctx.Data["DeleteBranchLink"] = ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index) + "/cleanup"
+ ctx.Data["DeleteBranchLink"] = ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index) + "/cleanup"
}
}
}
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/storage"
-
- "github.com/unknwon/com"
)
const (
}
var err error
metas[i] = &models.LFSMetaObject{}
- metas[i].Size, err = com.StrTo(oid[idx+1:]).Int64()
+ metas[i].Size, err = strconv.ParseInt(oid[idx+1:], 10, 64)
if err != nil {
ctx.ServerError("LFSAutoAssociate", fmt.Errorf("Illegal oid input: %s %v", oid, err))
return
"code.gitea.io/gitea/services/gitdiff"
pull_service "code.gitea.io/gitea/services/pull"
repo_service "code.gitea.io/gitea/services/repository"
-
- "github.com/unknwon/com"
)
const (
// ToDo: add check if maintainers are allowed to change branch ... (need migration & co)
if !allowedUpdate {
ctx.Flash.Error(ctx.Tr("repo.pulls.update_not_allowed"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
return
}
return
}
ctx.Flash.Error(flashError)
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
return
}
ctx.Flash.Error(err.Error())
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
return
}
time.Sleep(1 * time.Second)
ctx.Flash.Success(ctx.Tr("repo.pulls.update_branch_success"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
}
// MergePullRequest response for merging pull request
if issue.IsClosed {
if issue.IsPull {
ctx.Flash.Error(ctx.Tr("repo.pulls.is_closed"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
return
}
ctx.Flash.Error(ctx.Tr("repo.issues.closed_title"))
- ctx.Redirect(ctx.Repo.RepoLink + "/issues/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/issues/" + fmt.Sprint(issue.Index))
return
}
}
if !allowedMerge {
ctx.Flash.Error(ctx.Tr("repo.pulls.update_not_allowed"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
return
}
if !pr.CanAutoMerge() {
ctx.Flash.Error(ctx.Tr("repo.pulls.no_merge_not_ready"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
return
}
if pr.HasMerged {
ctx.Flash.Error(ctx.Tr("repo.pulls.has_merged"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(issue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(issue.Index))
return
}
if pr.IsWorkInProgress() {
ctx.Flash.Error(ctx.Tr("repo.pulls.no_merge_wip"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
return
}
return
} else if !isRepoAdmin {
ctx.Flash.Error(ctx.Tr("repo.pulls.no_merge_not_ready"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
return
}
}
if ctx.HasError() {
ctx.Flash.Error(ctx.Data["ErrorMsg"].(string))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
return
}
if !noDeps {
ctx.Flash.Error(ctx.Tr("repo.issues.dependency.pr_close_blocked"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
return
}
if err = pull_service.Merge(pr, ctx.User, ctx.Repo.GitRepo, models.MergeStyle(form.Do), message); err != nil {
if models.IsErrInvalidMergeStyle(err) {
ctx.Flash.Error(ctx.Tr("repo.pulls.invalid_merge_option"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
return
} else if models.IsErrMergeConflicts(err) {
conflictError := err.(models.ErrMergeConflicts)
return
}
ctx.Flash.Error(flashError)
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
return
} else if models.IsErrRebaseConflicts(err) {
conflictError := err.(models.ErrRebaseConflicts)
return
}
ctx.Flash.Error(flashError)
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
return
} else if models.IsErrMergeUnrelatedHistories(err) {
log.Debug("MergeUnrelatedHistories error: %v", err)
ctx.Flash.Error(ctx.Tr("repo.pulls.unrelated_histories"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
return
} else if git.IsErrPushOutOfDate(err) {
log.Debug("MergePushOutOfDate error: %v", err)
ctx.Flash.Error(ctx.Tr("repo.pulls.merge_out_of_date"))
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
return
} else if git.IsErrPushRejected(err) {
log.Debug("MergePushRejected error: %v", err)
}
ctx.Flash.Error(flashError)
}
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
return
}
ctx.ServerError("Merge", err)
}
log.Trace("Pull request merged: %d", pr.ID)
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pr.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pr.Index))
}
func stopTimerIfAvailable(user *models.User, issue *models.Issue) error {
}
ctx.Flash.Error(flashError)
}
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pullIssue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pullIssue.Index))
return
}
ctx.ServerError("NewPullRequest", err)
}
log.Trace("Pull request created: %d/%d", repo.ID, pullIssue.ID)
- ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + com.ToStr(pullIssue.Index))
+ ctx.Redirect(ctx.Repo.RepoLink + "/pulls/" + fmt.Sprint(pullIssue.Index))
}
// TriggerTask response for a trigger task request
defer func() {
ctx.JSON(200, map[string]interface{}{
- "redirect": pr.BaseRepo.Link() + "/pulls/" + com.ToStr(issue.Index),
+ "redirect": pr.BaseRepo.Link() + "/pulls/" + fmt.Sprint(issue.Index),
})
}()
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/setting"
api "code.gitea.io/gitea/modules/structs"
+ "code.gitea.io/gitea/modules/util"
"code.gitea.io/gitea/services/webhook"
-
- "github.com/unknwon/com"
)
const (
func checkHookType(ctx *context.Context) string {
hookType := strings.ToLower(ctx.Params(":type"))
- if !com.IsSliceContainsStr(setting.Webhook.Types, hookType) {
+ if !util.IsStringInSlice(hookType, setting.Webhook.Types, true) {
ctx.NotFound("checkHookType", nil)
return ""
}
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/test"
+ "code.gitea.io/gitea/modules/util"
"github.com/stretchr/testify/assert"
- "github.com/unknwon/com"
)
var queueMutex sync.Mutex
for _, req := range inFlight {
assert.True(t, req.IsComplete())
- assert.True(t, com.IsExist(req.GetArchivePath()))
+ exist, err := util.IsExist(req.GetArchivePath())
+ assert.NoError(t, err)
+ assert.True(t, exist)
}
arbitraryReq := inFlight[0]
"context"
"fmt"
"net/url"
+ "strconv"
"strings"
"time"
"code.gitea.io/gitea/modules/sync"
"code.gitea.io/gitea/modules/timeutil"
"code.gitea.io/gitea/modules/util"
-
- "github.com/unknwon/com"
)
// mirrorQueue holds an UniqueQueue object of the mirror
}()
mirrorQueue.Remove(repoID)
- m, err := models.GetMirrorByRepoID(com.StrTo(repoID).MustInt64())
+ id, _ := strconv.ParseInt(repoID, 10, 64)
+ m, err := models.GetMirrorByRepoID(id)
if err != nil {
log.Error("GetMirrorByRepoID [%s]: %v", repoID, err)
return
-
}
log.Trace("SyncMirrors [repo: %-v]: Running Sync", m.Repo)
"code.gitea.io/gitea/modules/queue"
"code.gitea.io/gitea/modules/timeutil"
"code.gitea.io/gitea/modules/util"
-
- "github.com/unknwon/com"
)
// prQueue represents a queue to handle update pull request tests
// handle passed PR IDs and test the PRs
func handle(data ...queue.Data) {
for _, datum := range data {
- prID := datum.(string)
- id := com.StrTo(prID).MustInt64()
+ id, _ := strconv.ParseInt(datum.(string), 10, 64)
log.Trace("Testing PR ID %d from the pull requests patch checking queue", id)
pr, err := models.GetPullRequestByID(id)
if err != nil {
- log.Error("GetPullRequestByID[%s]: %v", prID, err)
+ log.Error("GetPullRequestByID[%s]: %v", datum, err)
continue
} else if pr.HasMerged {
continue
"code.gitea.io/gitea/modules/queue"
"github.com/stretchr/testify/assert"
- "github.com/unknwon/com"
)
func TestPullRequest_AddToTaskQueue(t *testing.T) {
q, err := queue.NewChannelUniqueQueue(func(data ...queue.Data) {
for _, datum := range data {
- prID := datum.(string)
- id := com.StrTo(prID).MustInt64()
+ id, _ := strconv.ParseInt(datum.(string), 10, 64)
idChan <- id
}
}, queue.ChannelUniqueQueueConfiguration{
"code.gitea.io/gitea/modules/notification"
"code.gitea.io/gitea/modules/setting"
issue_service "code.gitea.io/gitea/services/issue"
-
- "github.com/unknwon/com"
)
// NewPullRequest creates new pull request with labels for repository.
defer headGitRepo.Close()
// Add a temporary remote.
- tmpRemote := "checkIfPRContentChanged-" + com.ToStr(time.Now().UnixNano())
+ tmpRemote := "checkIfPRContentChanged-" + fmt.Sprint(time.Now().UnixNano())
if err = headGitRepo.AddRemote(tmpRemote, pr.BaseRepo.RepoPath(), true); err != nil {
return false, fmt.Errorf("AddRemote: %s/%s-%s: %v", pr.HeadRepo.OwnerName, pr.HeadRepo.Name, tmpRemote, err)
}
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/notification"
"code.gitea.io/gitea/modules/sync"
-
- "github.com/unknwon/com"
)
// repoWorkingPool represents a working pool to order the parallel changes to the same repository
oldOwner := repo.Owner
- repoWorkingPool.CheckIn(com.ToStr(repo.ID))
+ repoWorkingPool.CheckIn(fmt.Sprint(repo.ID))
if err := models.TransferOwnership(doer, newOwner.Name, repo); err != nil {
- repoWorkingPool.CheckOut(com.ToStr(repo.ID))
+ repoWorkingPool.CheckOut(fmt.Sprint(repo.ID))
return err
}
- repoWorkingPool.CheckOut(com.ToStr(repo.ID))
+ repoWorkingPool.CheckOut(fmt.Sprint(repo.ID))
newRepo, err := models.GetRepositoryByID(repo.ID)
if err != nil {
// repo so that we can atomically rename the repo path and updates the
// local copy's origin accordingly.
- repoWorkingPool.CheckIn(com.ToStr(repo.ID))
+ repoWorkingPool.CheckIn(fmt.Sprint(repo.ID))
if err := models.ChangeRepositoryName(doer, repo, newRepoName); err != nil {
- repoWorkingPool.CheckOut(com.ToStr(repo.ID))
+ repoWorkingPool.CheckOut(fmt.Sprint(repo.ID))
return err
}
- repoWorkingPool.CheckOut(com.ToStr(repo.ID))
+ repoWorkingPool.CheckOut(fmt.Sprint(repo.ID))
notification.NotifyRenameRepository(doer, repo, oldRepoName)
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/notification"
"code.gitea.io/gitea/modules/notification/action"
+ "code.gitea.io/gitea/modules/util"
"github.com/stretchr/testify/assert"
- "github.com/unknwon/com"
)
var notifySync sync.Once
transferredRepo := models.AssertExistsAndLoadBean(t, &models.Repository{ID: 3}).(*models.Repository)
assert.EqualValues(t, 2, transferredRepo.OwnerID)
- assert.False(t, com.IsExist(models.RepoPath("user3", "repo3")))
- assert.True(t, com.IsExist(models.RepoPath("user2", "repo3")))
+ exist, err := util.IsExist(models.RepoPath("user3", "repo3"))
+ assert.NoError(t, err)
+ assert.False(t, exist)
+ exist, err = util.IsExist(models.RepoPath("user2", "repo3"))
+ assert.NoError(t, err)
+ assert.True(t, exist)
models.AssertExistsAndLoadBean(t, &models.Action{
OpType: models.ActionTransferRepo,
ActUserID: 2,
"net"
"net/http"
"net/url"
+ "strconv"
"strings"
"sync"
"time"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
"github.com/gobwas/glob"
- "github.com/unknwon/com"
)
// Deliver deliver hook task
log.Trace("DeliverHooks [repo_id: %v]", repoIDStr)
hookQueue.Remove(repoIDStr)
- repoID, err := com.StrTo(repoIDStr).Int64()
+ repoID, err := strconv.ParseInt(repoIDStr, 10, 64)
if err != nil {
log.Error("Invalid repo ID: %s", repoIDStr)
continue
repo_module "code.gitea.io/gitea/modules/repository"
"code.gitea.io/gitea/modules/sync"
"code.gitea.io/gitea/modules/util"
-
- "github.com/unknwon/com"
)
var (
if err = nameAllowed(newWikiName); err != nil {
return err
}
- wikiWorkingPool.CheckIn(com.ToStr(repo.ID))
- defer wikiWorkingPool.CheckOut(com.ToStr(repo.ID))
+ wikiWorkingPool.CheckIn(fmt.Sprint(repo.ID))
+ defer wikiWorkingPool.CheckOut(fmt.Sprint(repo.ID))
if err = InitWiki(repo); err != nil {
return fmt.Errorf("InitWiki: %v", err)
// DeleteWikiPage deletes a wiki page identified by its path.
func DeleteWikiPage(doer *models.User, repo *models.Repository, wikiName string) (err error) {
- wikiWorkingPool.CheckIn(com.ToStr(repo.ID))
- defer wikiWorkingPool.CheckOut(com.ToStr(repo.ID))
+ wikiWorkingPool.CheckIn(fmt.Sprint(repo.ID))
+ defer wikiWorkingPool.CheckOut(fmt.Sprint(repo.ID))
if err = InitWiki(repo); err != nil {
return fmt.Errorf("InitWiki: %v", err)
projects / gitea.git / commitdiff