lael-labs/forgejo

cmd/migrate_storage.go+2−2

 	"fmt"
 	"strings"
-	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/migrations"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 }
 func migrateLFS(dstStorage storage.ObjectStorage) error {
-	return models.IterateLFS(func(mo *models.LFSMetaObject) error {
+	return git_model.IterateLFS(func(mo *git_model.LFSMetaObject) error {
 		_, err := storage.Copy(dstStorage, mo.RelativePath(), storage.LFS, mo.RelativePath())
 		return err
 	})

cmd/serv.go+2−2

 	"strings"
 	"time"
-	"code.gitea.io/gitea/models"
 	asymkey_model "code.gitea.io/gitea/models/asymkey"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/perm"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/json"
 			return fail("Internal error", "Failed to sign JWT token: %v", err)
 		}
-		tokenAuthentication := &models.LFSTokenResponse{
+		tokenAuthentication := &git_model.LFSTokenResponse{
 			Header: make(map[string]string),
 			Href:   url,
 		}

integrations/api_repo_lfs_test.go+11−11

@@ -12,7 +12,7 @@ import ( · 11 unmodified lines
12	"strings"	12	"strings"
13	"testing"	13	"testing"
14		14
15	"code.gitea.io/gitea/models"	15	git_model "code.gitea.io/gitea/models/git"
16	repo_model "code.gitea.io/gitea/models/repo"	16	repo_model "code.gitea.io/gitea/models/repo"
17	"code.gitea.io/gitea/models/unittest"	17	"code.gitea.io/gitea/models/unittest"
18	user_model "code.gitea.io/gitea/models/user"	18	user_model "code.gitea.io/gitea/models/user"
@@ -76,7 +76,7 @@ func TestAPILFSBatch(t *testing.T) { · 57 unmodified lines
76		76
77	content := []byte("dummy1")	77	content := []byte("dummy1")
78	oid := storeObjectInRepo(t, repo.ID, &content)	78	oid := storeObjectInRepo(t, repo.ID, &content)
79	defer models.RemoveLFSMetaObjectByOid(repo.ID, oid)	79	defer git_model.RemoveLFSMetaObjectByOid(repo.ID, oid)
80		80
81	session := loginUser(t, "user2")	81	session := loginUser(t, "user2")
82		82
@@ -260,9 +260,9 @@ func TestAPILFSBatch(t *testing.T) { · 177 unmodified lines
260	content := []byte("dummy0")	260	content := []byte("dummy0")
261	storeObjectInRepo(t, repo2.ID, &content)	261	storeObjectInRepo(t, repo2.ID, &content)
262		262
263	meta, err := models.GetLFSMetaObjectByOid(repo.ID, p.Oid)	263	meta, err := git_model.GetLFSMetaObjectByOid(repo.ID, p.Oid)
264	assert.Nil(t, meta)	264	assert.Nil(t, meta)
265	assert.Equal(t, models.ErrLFSObjectNotExist, err)	265	assert.Equal(t, git_model.ErrLFSObjectNotExist, err)
266		266
267	req := newRequest(t, &lfs.BatchRequest{	267	req := newRequest(t, &lfs.BatchRequest{
268	Operation: "upload",	268	Operation: "upload",
@@ -275,7 +275,7 @@ func TestAPILFSBatch(t *testing.T) { · 6 unmodified lines
275	assert.Nil(t, br.Objects[0].Error)	275	assert.Nil(t, br.Objects[0].Error)
276	assert.Empty(t, br.Objects[0].Actions)	276	assert.Empty(t, br.Objects[0].Actions)
277		277
278	meta, err = models.GetLFSMetaObjectByOid(repo.ID, p.Oid)	278	meta, err = git_model.GetLFSMetaObjectByOid(repo.ID, p.Oid)
279	assert.NoError(t, err)	279	assert.NoError(t, err)
280	assert.NotNil(t, meta)	280	assert.NotNil(t, meta)
281		281
@@ -336,7 +336,7 @@ func TestAPILFSUpload(t *testing.T) { · 54 unmodified lines
336		336
337	content := []byte("dummy3")	337	content := []byte("dummy3")
338	oid := storeObjectInRepo(t, repo.ID, &content)	338	oid := storeObjectInRepo(t, repo.ID, &content)
339	defer models.RemoveLFSMetaObjectByOid(repo.ID, oid)	339	defer git_model.RemoveLFSMetaObjectByOid(repo.ID, oid)
340		340
341	session := loginUser(t, "user2")	341	session := loginUser(t, "user2")
342		342
@@ -365,9 +365,9 @@ func TestAPILFSUpload(t *testing.T) { · 22 unmodified lines
365	err = contentStore.Put(p, bytes.NewReader([]byte("dummy5")))	365	err = contentStore.Put(p, bytes.NewReader([]byte("dummy5")))
366	assert.NoError(t, err)	366	assert.NoError(t, err)
367		367
368	meta, err := models.GetLFSMetaObjectByOid(repo.ID, p.Oid)	368	meta, err := git_model.GetLFSMetaObjectByOid(repo.ID, p.Oid)
369	assert.Nil(t, meta)	369	assert.Nil(t, meta)
370	assert.Equal(t, models.ErrLFSObjectNotExist, err)	370	assert.Equal(t, git_model.ErrLFSObjectNotExist, err)
371		371
372	t.Run("InvalidAccess", func(t *testing.T) {	372	t.Run("InvalidAccess", func(t *testing.T) {
373	req := newRequest(t, p, "invalid")	373	req := newRequest(t, p, "invalid")
@@ -378,7 +378,7 @@ func TestAPILFSUpload(t *testing.T) { · 4 unmodified lines
378	req := newRequest(t, p, "dummy5")	378	req := newRequest(t, p, "dummy5")
379		379
380	session.MakeRequest(t, req, http.StatusOK)	380	session.MakeRequest(t, req, http.StatusOK)
381	meta, err = models.GetLFSMetaObjectByOid(repo.ID, p.Oid)	381	meta, err = git_model.GetLFSMetaObjectByOid(repo.ID, p.Oid)
382	assert.NoError(t, err)	382	assert.NoError(t, err)
383	assert.NotNil(t, meta)	383	assert.NotNil(t, meta)
384	})	384	})
@@ -426,7 +426,7 @@ func TestAPILFSUpload(t *testing.T) { · 41 unmodified lines
426	assert.NoError(t, err)	426	assert.NoError(t, err)
427	assert.True(t, exist)	427	assert.True(t, exist)
428		428
429	meta, err := models.GetLFSMetaObjectByOid(repo.ID, p.Oid)	429	meta, err := git_model.GetLFSMetaObjectByOid(repo.ID, p.Oid)
430	assert.NoError(t, err)	430	assert.NoError(t, err)
431	assert.NotNil(t, meta)	431	assert.NotNil(t, meta)
432	})	432	})
@@ -441,7 +441,7 @@ func TestAPILFSVerify(t *testing.T) { · 8 unmodified lines
441		441
442	content := []byte("dummy3")	442	content := []byte("dummy3")
443	oid := storeObjectInRepo(t, repo.ID, &content)	443	oid := storeObjectInRepo(t, repo.ID, &content)
444	defer models.RemoveLFSMetaObjectByOid(repo.ID, oid)	444	defer git_model.RemoveLFSMetaObjectByOid(repo.ID, oid)
445		445
446	session := loginUser(t, "user2")	446	session := loginUser(t, "user2")
447		447

integrations/lfs_getobject_test.go+3−3

@@ -12,7 +12,7 @@ import ( · 11 unmodified lines
12	"net/http/httptest"	12	"net/http/httptest"
13	"testing"	13	"testing"
14		14
15	"code.gitea.io/gitea/models"	15	git_model "code.gitea.io/gitea/models/git"
16	repo_model "code.gitea.io/gitea/models/repo"	16	repo_model "code.gitea.io/gitea/models/repo"
17	"code.gitea.io/gitea/modules/git"	17	"code.gitea.io/gitea/modules/git"
18	"code.gitea.io/gitea/modules/json"	18	"code.gitea.io/gitea/modules/json"
@@ -28,7 +28,7 @@ func storeObjectInRepo(t testing.T, repositoryID int64, content []byte) string · 9 unmodified lines
28	pointer, err := lfs.GeneratePointer(bytes.NewReader(*content))	28	pointer, err := lfs.GeneratePointer(bytes.NewReader(*content))
29	assert.NoError(t, err)	29	assert.NoError(t, err)
30		30
31	_, err = models.NewLFSMetaObject(&models.LFSMetaObject{Pointer: pointer, RepositoryID: repositoryID})	31	_, err = git_model.NewLFSMetaObject(&git_model.LFSMetaObject{Pointer: pointer, RepositoryID: repositoryID})
32	assert.NoError(t, err)	32	assert.NoError(t, err)
33	contentStore := lfs.NewContentStore()	33	contentStore := lfs.NewContentStore()
34	exist, err := contentStore.Exists(pointer)	34	exist, err := contentStore.Exists(pointer)
@@ -44,7 +44,7 @@ func storeAndGetLfs(t testing.T, content []byte, extraHeader *http.Header, exp · 9 unmodified lines
44	repo, err := repo_model.GetRepositoryByOwnerAndName("user2", "repo1")	44	repo, err := repo_model.GetRepositoryByOwnerAndName("user2", "repo1")
45	assert.NoError(t, err)	45	assert.NoError(t, err)
46	oid := storeObjectInRepo(t, repo.ID, content)	46	oid := storeObjectInRepo(t, repo.ID, content)
47	defer models.RemoveLFSMetaObjectByOid(repo.ID, oid)	47	defer git_model.RemoveLFSMetaObjectByOid(repo.ID, oid)
48		48
49	session := loginUser(t, "user2")	49	session := loginUser(t, "user2")
50		50

integrations/repo_tag_test.go+5−4

 	"testing"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unittest"
 	user_model "code.gitea.io/gitea/models/user"
 		err := release.CreateNewTag(git.DefaultContext, owner, repo, "master", "v-1", "first tag")
 		assert.NoError(t, err)
-		err = models.InsertProtectedTag(&models.ProtectedTag{
+		err = git_model.InsertProtectedTag(&git_model.ProtectedTag{
 			RepoID:      repo.ID,
 			NamePattern: "v-*",
 		})
 		assert.NoError(t, err)
-		err = models.InsertProtectedTag(&models.ProtectedTag{
+		err = git_model.InsertProtectedTag(&git_model.ProtectedTag{
 			RepoID:           repo.ID,
 			NamePattern:      "v-1.1",
 			AllowlistUserIDs: []int64{repo.OwnerID},
 		assert.NoError(t, err)
 	}
-	protectedTags, err := models.GetProtectedTags(repo.ID)
+	protectedTags, err := git_model.GetProtectedTags(repo.ID)
 	assert.NoError(t, err)
 	for _, protectedTag := range protectedTags {
-		err = models.DeleteProtectedTag(protectedTag)
+		err = git_model.DeleteProtectedTag(protectedTag)
 		assert.NoError(t, err)
 	}
 }

models/branch.go+80−0

@@ -0,0 +1,80 @@
	1	// Copyright 2022 The Gitea Authors. All rights reserved.
	2	// Use of this source code is governed by a MIT-style
	3	// license that can be found in the LICENSE file.
	4
	5	package models
	6
	7	import (
	8	"context"
	9
	10	"code.gitea.io/gitea/models/db"
	11	git_model "code.gitea.io/gitea/models/git"
	12	"code.gitea.io/gitea/modules/log"
	13	)
	14
	15	// HasEnoughApprovals returns true if pr has enough granted approvals.
	16	func HasEnoughApprovals(ctx context.Context, protectBranch git_model.ProtectedBranch, pr PullRequest) bool {
	17	if protectBranch.RequiredApprovals == 0 {
	18	return true
	19	}
	20	return GetGrantedApprovalsCount(ctx, protectBranch, pr) >= protectBranch.RequiredApprovals
	21	}
	22
	23	// GetGrantedApprovalsCount returns the number of granted approvals for pr. A granted approval must be authored by a user in an approval whitelist.
	24	func GetGrantedApprovalsCount(ctx context.Context, protectBranch git_model.ProtectedBranch, pr PullRequest) int64 {
	25	sess := db.GetEngine(ctx).Where("issue_id = ?", pr.IssueID).
	26	And("type = ?", ReviewTypeApprove).
	27	And("official = ?", true).
	28	And("dismissed = ?", false)
	29	if protectBranch.DismissStaleApprovals {
	30	sess = sess.And("stale = ?", false)
	31	}
	32	approvals, err := sess.Count(new(Review))
	33	if err != nil {
	34	log.Error("GetGrantedApprovalsCount: %v", err)
	35	return 0
	36	}
	37
	38	return approvals
	39	}
	40
	41	// MergeBlockedByRejectedReview returns true if merge is blocked by rejected reviews
	42	func MergeBlockedByRejectedReview(ctx context.Context, protectBranch git_model.ProtectedBranch, pr PullRequest) bool {
	43	if !protectBranch.BlockOnRejectedReviews {
	44	return false
	45	}
	46	rejectExist, err := db.GetEngine(ctx).Where("issue_id = ?", pr.IssueID).
	47	And("type = ?", ReviewTypeReject).
	48	And("official = ?", true).
	49	And("dismissed = ?", false).
	50	Exist(new(Review))
	51	if err != nil {
	52	log.Error("MergeBlockedByRejectedReview: %v", err)
	53	return true
	54	}
	55
	56	return rejectExist
	57	}
	58
	59	// MergeBlockedByOfficialReviewRequests block merge because of some review request to official reviewer
	60	// of from official review
	61	func MergeBlockedByOfficialReviewRequests(ctx context.Context, protectBranch git_model.ProtectedBranch, pr PullRequest) bool {
	62	if !protectBranch.BlockOnOfficialReviewRequests {
	63	return false
	64	}
	65	has, err := db.GetEngine(ctx).Where("issue_id = ?", pr.IssueID).
	66	And("type = ?", ReviewTypeRequest).
	67	And("official = ?", true).
	68	Exist(new(Review))
	69	if err != nil {
	70	log.Error("MergeBlockedByOfficialReviewRequests: %v", err)
	71	return true
	72	}
	73
	74	return has
	75	}
	76
	77	// MergeBlockedByOutdatedBranch returns true if merge is blocked by an outdated head branch
	78	func MergeBlockedByOutdatedBranch(protectBranch git_model.ProtectedBranch, pr PullRequest) bool {
	79	return protectBranch.BlockOnOutdatedBranch && pr.CommitsBehind > 0
	80	}

models/commit.go+0−26

@@ -1,26 +0,0 @@
1	// Copyright 2021 Gitea. All rights reserved.
2	// Use of this source code is governed by a MIT-style
3	// license that can be found in the LICENSE file.
4
5	package models
6
7	import (
8	asymkey_model "code.gitea.io/gitea/models/asymkey"
9	repo_model "code.gitea.io/gitea/models/repo"
10	user_model "code.gitea.io/gitea/models/user"
11	"code.gitea.io/gitea/modules/git"
12	)
13
14	// ConvertFromGitCommit converts git commits into SignCommitWithStatuses
15	func ConvertFromGitCommit(commits []git.Commit, repo repo_model.Repository) []*SignCommitWithStatuses {
16	return ParseCommitsWithStatus(
17	asymkey_model.ParseCommitsWithSignature(
18	user_model.ValidateCommitsWithEmails(commits),
19	repo.GetTrustModel(),
20	func(user *user_model.User) (bool, error) {
21	return IsOwnerMemberCollaborator(repo, user.ID)
22	},
23	),
24	repo,
25	)
26	}

models/error.go+0−78

@@ -8,7 +8,6 @@ package models · 7 unmodified lines
8	import (	8	import (
9	"fmt"	9	"fmt"
10		10
11	"code.gitea.io/gitea/models/perm"
12	repo_model "code.gitea.io/gitea/models/repo"	11	repo_model "code.gitea.io/gitea/models/repo"
13	"code.gitea.io/gitea/modules/git"	12	"code.gitea.io/gitea/modules/git"
14	)	13	)
@@ -145,83 +144,6 @@ func (err ErrAccessTokenEmpty) Error() string { · 130 unmodified lines
145	return "access token is empty"	144	return "access token is empty"
146	}	145	}
147		146
148	//.____ ____________________
149	//\| \| \_ _____/ _____/
150	//\| \| \| __) \_____ \
151	//\| \|___\| \ / \
152	//\|_______ \___ / /_______ /
153	// \/ \/ \/
154
155	// ErrLFSLockNotExist represents a "LFSLockNotExist" kind of error.
156	type ErrLFSLockNotExist struct {
157	ID int64
158	RepoID int64
159	Path string
160	}
161
162	// IsErrLFSLockNotExist checks if an error is a ErrLFSLockNotExist.
163	func IsErrLFSLockNotExist(err error) bool {
164	_, ok := err.(ErrLFSLockNotExist)
165	return ok
166	}
167
168	func (err ErrLFSLockNotExist) Error() string {
169	return fmt.Sprintf("lfs lock does not exist [id: %d, rid: %d, path: %s]", err.ID, err.RepoID, err.Path)
170	}
171
172	// ErrLFSUnauthorizedAction represents a "LFSUnauthorizedAction" kind of error.
173	type ErrLFSUnauthorizedAction struct {
174	RepoID int64
175	UserName string
176	Mode perm.AccessMode
177	}
178
179	// IsErrLFSUnauthorizedAction checks if an error is a ErrLFSUnauthorizedAction.
180	func IsErrLFSUnauthorizedAction(err error) bool {
181	_, ok := err.(ErrLFSUnauthorizedAction)
182	return ok
183	}
184
185	func (err ErrLFSUnauthorizedAction) Error() string {
186	if err.Mode == perm.AccessModeWrite {
187	return fmt.Sprintf("User %s doesn't have write access for lfs lock [rid: %d]", err.UserName, err.RepoID)
188	}
189	return fmt.Sprintf("User %s doesn't have read access for lfs lock [rid: %d]", err.UserName, err.RepoID)
190	}
191
192	// ErrLFSLockAlreadyExist represents a "LFSLockAlreadyExist" kind of error.
193	type ErrLFSLockAlreadyExist struct {
194	RepoID int64
195	Path string
196	}
197
198	// IsErrLFSLockAlreadyExist checks if an error is a ErrLFSLockAlreadyExist.
199	func IsErrLFSLockAlreadyExist(err error) bool {
200	_, ok := err.(ErrLFSLockAlreadyExist)
201	return ok
202	}
203
204	func (err ErrLFSLockAlreadyExist) Error() string {
205	return fmt.Sprintf("lfs lock already exists [rid: %d, path: %s]", err.RepoID, err.Path)
206	}
207
208	// ErrLFSFileLocked represents a "LFSFileLocked" kind of error.
209	type ErrLFSFileLocked struct {
210	RepoID int64
211	Path string
212	UserName string
213	}
214
215	// IsErrLFSFileLocked checks if an error is a ErrLFSFileLocked.
216	func IsErrLFSFileLocked(err error) bool {
217	_, ok := err.(ErrLFSFileLocked)
218	return ok
219	}
220
221	func (err ErrLFSFileLocked) Error() string {
222	return fmt.Sprintf("File is lfs locked [repo: %d, locked by: %s, path: %s]", err.RepoID, err.UserName, err.Path)
223	}
224
225	// ErrNoPendingRepoTransfer is an error type for repositories without a pending	147	// ErrNoPendingRepoTransfer is an error type for repositories without a pending
226	// transfer request	148	// transfer request
227	type ErrNoPendingRepoTransfer struct {	149	type ErrNoPendingRepoTransfer struct {

models/git/branches.gorenamed from models/branches.go+7−73

@@ -2,7 +2,7 @@ · 1 unmodified line
2	// Use of this source code is governed by a MIT-style	2	// Use of this source code is governed by a MIT-style
3	// license that can be found in the LICENSE file.	3	// license that can be found in the LICENSE file.
4		4
5	package models	5	package git
6		6
7	import (	7	import (
8	"context"	8	"context"
@@ -129,10 +129,11 @@ func IsUserMergeWhitelisted(ctx context.Context, protectBranch *ProtectedBranch, · 120 unmodified lines
129		129
130	// IsUserOfficialReviewer check if user is official reviewer for the branch (counts towards required approvals)	130	// IsUserOfficialReviewer check if user is official reviewer for the branch (counts towards required approvals)
131	func IsUserOfficialReviewer(protectBranch ProtectedBranch, user user_model.User) (bool, error) {	131	func IsUserOfficialReviewer(protectBranch ProtectedBranch, user user_model.User) (bool, error) {
132	return isUserOfficialReviewer(db.DefaultContext, protectBranch, user)	132	return IsUserOfficialReviewerCtx(db.DefaultContext, protectBranch, user)
133	}	133	}
134		134
135	func isUserOfficialReviewer(ctx context.Context, protectBranch ProtectedBranch, user user_model.User) (bool, error) {	135	// IsUserOfficialReviewerCtx check if user is official reviewer for the branch (counts towards required approvals)
		136	func IsUserOfficialReviewerCtx(ctx context.Context, protectBranch ProtectedBranch, user user_model.User) (bool, error) {
136	repo, err := repo_model.GetRepositoryByIDCtx(ctx, protectBranch.RepoID)	137	repo, err := repo_model.GetRepositoryByIDCtx(ctx, protectBranch.RepoID)
137	if err != nil {	138	if err != nil {
138	return false, err	139	return false, err
@@ -159,73 +160,6 @@ func isUserOfficialReviewer(ctx context.Context, protectBranch *ProtectedBranch, · 20 unmodified lines
159	return inTeam, nil	160	return inTeam, nil
160	}	161	}
161		162
162	// HasEnoughApprovals returns true if pr has enough granted approvals.
163	func (protectBranch ProtectedBranch) HasEnoughApprovals(ctx context.Context, pr PullRequest) bool {
164	if protectBranch.RequiredApprovals == 0 {
165	return true
166	}
167	return protectBranch.GetGrantedApprovalsCount(ctx, pr) >= protectBranch.RequiredApprovals
168	}
169
170	// GetGrantedApprovalsCount returns the number of granted approvals for pr. A granted approval must be authored by a user in an approval whitelist.
171	func (protectBranch ProtectedBranch) GetGrantedApprovalsCount(ctx context.Context, pr PullRequest) int64 {
172	sess := db.GetEngine(ctx).Where("issue_id = ?", pr.IssueID).
173	And("type = ?", ReviewTypeApprove).
174	And("official = ?", true).
175	And("dismissed = ?", false)
176	if protectBranch.DismissStaleApprovals {
177	sess = sess.And("stale = ?", false)
178	}
179	approvals, err := sess.Count(new(Review))
180	if err != nil {
181	log.Error("GetGrantedApprovalsCount: %v", err)
182	return 0
183	}
184
185	return approvals
186	}
187
188	// MergeBlockedByRejectedReview returns true if merge is blocked by rejected reviews
189	func (protectBranch ProtectedBranch) MergeBlockedByRejectedReview(ctx context.Context, pr PullRequest) bool {
190	if !protectBranch.BlockOnRejectedReviews {
191	return false
192	}
193	rejectExist, err := db.GetEngine(ctx).Where("issue_id = ?", pr.IssueID).
194	And("type = ?", ReviewTypeReject).
195	And("official = ?", true).
196	And("dismissed = ?", false).
197	Exist(new(Review))
198	if err != nil {
199	log.Error("MergeBlockedByRejectedReview: %v", err)
200	return true
201	}
202
203	return rejectExist
204	}
205
206	// MergeBlockedByOfficialReviewRequests block merge because of some review request to official reviewer
207	// of from official review
208	func (protectBranch ProtectedBranch) MergeBlockedByOfficialReviewRequests(ctx context.Context, pr PullRequest) bool {
209	if !protectBranch.BlockOnOfficialReviewRequests {
210	return false
211	}
212	has, err := db.GetEngine(ctx).Where("issue_id = ?", pr.IssueID).
213	And("type = ?", ReviewTypeRequest).
214	And("official = ?", true).
215	Exist(new(Review))
216	if err != nil {
217	log.Error("MergeBlockedByOfficialReviewRequests: %v", err)
218	return true
219	}
220
221	return has
222	}
223
224	// MergeBlockedByOutdatedBranch returns true if merge is blocked by an outdated head branch
225	func (protectBranch ProtectedBranch) MergeBlockedByOutdatedBranch(pr PullRequest) bool {
226	return protectBranch.BlockOnOutdatedBranch && pr.CommitsBehind > 0
227	}
228
229	// GetProtectedFilePatterns parses a semicolon separated list of protected file patterns and returns a glob.Glob slice	163	// GetProtectedFilePatterns parses a semicolon separated list of protected file patterns and returns a glob.Glob slice
230	func (protectBranch *ProtectedBranch) GetProtectedFilePatterns() []glob.Glob {	164	func (protectBranch *ProtectedBranch) GetProtectedFilePatterns() []glob.Glob {
231	return getFilePatterns(protectBranch.ProtectedFilePatterns)	165	return getFilePatterns(protectBranch.ProtectedFilePatterns)
@@ -252,13 +186,13 @@ func getFilePatterns(filePatterns string) []glob.Glob { · 20 unmodified lines
252	}	186	}
253		187
254	// MergeBlockedByProtectedFiles returns true if merge is blocked by protected files change	188	// MergeBlockedByProtectedFiles returns true if merge is blocked by protected files change
255	func (protectBranch ProtectedBranch) MergeBlockedByProtectedFiles(pr PullRequest) bool {	189	func (protectBranch *ProtectedBranch) MergeBlockedByProtectedFiles(changedProtectedFiles []string) bool {
256	glob := protectBranch.GetProtectedFilePatterns()	190	glob := protectBranch.GetProtectedFilePatterns()
257	if len(glob) == 0 {	191	if len(glob) == 0 {
258	return false	192	return false
259	}	193	}
260		194
261	return len(pr.ChangedProtectedFiles) > 0	195	return len(changedProtectedFiles) > 0
262	}	196	}
263		197
264	// IsProtectedFile return if path is protected	198	// IsProtectedFile return if path is protected
@@ -642,7 +576,7 @@ func RenameBranch(repo *repo_model.Repository, from, to string, gitAction func(i · 377 unmodified lines
642	}	576	}
643		577
644	// 3. Update all not merged pull request base branch name	578	// 3. Update all not merged pull request base branch name
645	_, err = sess.Table(new(PullRequest)).Where("base_repo_id=? AND base_branch=? AND has_merged=?",	579	_, err = sess.Table("pull_request").Where("base_repo_id=? AND base_branch=? AND has_merged=?",
646	repo.ID, from, false).	580	repo.ID, from, false).
647	Update(map[string]interface{}{"base_branch": to})	581	Update(map[string]interface{}{"base_branch": to})
648	if err != nil {	582	if err != nil {

models/git/branches_test.gorenamed from models/branches_test.go+26−24

 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
-package models
+package git_test
 import (
 	"testing"
+	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unittest"
 func TestAddDeletedBranch(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1}).(*repo_model.Repository)
-	firstBranch := unittest.AssertExistsAndLoadBean(t, &DeletedBranch{ID: 1}).(*DeletedBranch)
+	firstBranch := unittest.AssertExistsAndLoadBean(t, &git_model.DeletedBranch{ID: 1}).(*git_model.DeletedBranch)
-	assert.Error(t, AddDeletedBranch(repo.ID, firstBranch.Name, firstBranch.Commit, firstBranch.DeletedByID))
+	assert.Error(t, git_model.AddDeletedBranch(repo.ID, firstBranch.Name, firstBranch.Commit, firstBranch.DeletedByID))
-	assert.NoError(t, AddDeletedBranch(repo.ID, "test", "5655464564554545466464656", int64(1)))
+	assert.NoError(t, git_model.AddDeletedBranch(repo.ID, "test", "5655464564554545466464656", int64(1)))
 }
 func TestGetDeletedBranches(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1}).(*repo_model.Repository)
-	branches, err := GetDeletedBranches(repo.ID)
+	branches, err := git_model.GetDeletedBranches(repo.ID)
 	assert.NoError(t, err)
 	assert.Len(t, branches, 2)
 }
 func TestGetDeletedBranch(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	firstBranch := unittest.AssertExistsAndLoadBean(t, &DeletedBranch{ID: 1}).(*DeletedBranch)
+	firstBranch := unittest.AssertExistsAndLoadBean(t, &git_model.DeletedBranch{ID: 1}).(*git_model.DeletedBranch)
 	assert.NotNil(t, getDeletedBranch(t, firstBranch))
 }
 func TestDeletedBranchLoadUser(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	firstBranch := unittest.AssertExistsAndLoadBean(t, &DeletedBranch{ID: 1}).(*DeletedBranch)
+	firstBranch := unittest.AssertExistsAndLoadBean(t, &git_model.DeletedBranch{ID: 1}).(*git_model.DeletedBranch)
-	secondBranch := unittest.AssertExistsAndLoadBean(t, &DeletedBranch{ID: 2}).(*DeletedBranch)
+	secondBranch := unittest.AssertExistsAndLoadBean(t, &git_model.DeletedBranch{ID: 2}).(*git_model.DeletedBranch)
 	branch := getDeletedBranch(t, firstBranch)
 	assert.Nil(t, branch.DeletedBy)
 	assert.NoError(t, unittest.PrepareTestDatabase())
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1}).(*repo_model.Repository)
-	firstBranch := unittest.AssertExistsAndLoadBean(t, &DeletedBranch{ID: 1}).(*DeletedBranch)
+	firstBranch := unittest.AssertExistsAndLoadBean(t, &git_model.DeletedBranch{ID: 1}).(*git_model.DeletedBranch)
-	err := RemoveDeletedBranchByID(repo.ID, 1)
+	err := git_model.RemoveDeletedBranchByID(repo.ID, 1)
 	assert.NoError(t, err)
 	unittest.AssertNotExistsBean(t, firstBranch)
-	unittest.AssertExistsAndLoadBean(t, &DeletedBranch{ID: 2})
+	unittest.AssertExistsAndLoadBean(t, &git_model.DeletedBranch{ID: 2})
 }
-func getDeletedBranch(t *testing.T, branch *DeletedBranch) *DeletedBranch {
+func getDeletedBranch(t *testing.T, branch *git_model.DeletedBranch) *git_model.DeletedBranch {
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1}).(*repo_model.Repository)
-	deletedBranch, err := GetDeletedBranchByID(repo.ID, branch.ID)
+	deletedBranch, err := git_model.GetDeletedBranchByID(repo.ID, branch.ID)
 	assert.NoError(t, err)
 	assert.Equal(t, branch.ID, deletedBranch.ID)
 	assert.Equal(t, branch.Name, deletedBranch.Name)
 func TestFindRenamedBranch(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	branch, exist, err := FindRenamedBranch(1, "dev")
+	branch, exist, err := git_model.FindRenamedBranch(1, "dev")
 	assert.NoError(t, err)
 	assert.Equal(t, true, exist)
 	assert.Equal(t, "master", branch.To)
-	_, exist, err = FindRenamedBranch(1, "unknow")
+	_, exist, err = git_model.FindRenamedBranch(1, "unknow")
 	assert.NoError(t, err)
 	assert.Equal(t, false, exist)
 }
 	ctx, committer, err := db.TxContext()
 	defer committer.Close()
 	assert.NoError(t, err)
-	assert.NoError(t, UpdateProtectBranch(ctx, repo1, &ProtectedBranch{
+	assert.NoError(t, git_model.UpdateProtectBranch(ctx, repo1, &git_model.ProtectedBranch{
 		RepoID:     repo1.ID,
 		BranchName: "master",
-	}, WhitelistOptions{}))
+	}, git_model.WhitelistOptions{}))
 	assert.NoError(t, committer.Commit())
-	assert.NoError(t, RenameBranch(repo1, "master", "main", func(isDefault bool) error {
+	assert.NoError(t, git_model.RenameBranch(repo1, "master", "main", func(isDefault bool) error {
 		_isDefault = isDefault
 		return nil
 	}))
 	repo1 = unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1}).(*repo_model.Repository)
 	assert.Equal(t, "main", repo1.DefaultBranch)
-	pull := unittest.AssertExistsAndLoadBean(t, &PullRequest{ID: 1}).(*PullRequest) // merged
+	pull := unittest.AssertExistsAndLoadBean(t, &models.PullRequest{ID: 1}).(*models.PullRequest) // merged
 	assert.Equal(t, "master", pull.BaseBranch)
-	pull = unittest.AssertExistsAndLoadBean(t, &PullRequest{ID: 2}).(*PullRequest) // open
+	pull = unittest.AssertExistsAndLoadBean(t, &models.PullRequest{ID: 2}).(*models.PullRequest) // open
 	assert.Equal(t, "main", pull.BaseBranch)
-	renamedBranch := unittest.AssertExistsAndLoadBean(t, &RenamedBranch{ID: 2}).(*RenamedBranch)
+	renamedBranch := unittest.AssertExistsAndLoadBean(t, &git_model.RenamedBranch{ID: 2}).(*git_model.RenamedBranch)
 	assert.Equal(t, "master", renamedBranch.From)
 	assert.Equal(t, "main", renamedBranch.To)
 	assert.Equal(t, int64(1), renamedBranch.RepoID)
-	unittest.AssertExistsAndLoadBean(t, &ProtectedBranch{
+	unittest.AssertExistsAndLoadBean(t, &git_model.ProtectedBranch{
 		RepoID:     repo1.ID,
 		BranchName: "main",
 	})
 	// is actually on repo with ID 1.
 	repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2}).(*repo_model.Repository)
-	deletedBranch, err := GetDeletedBranchByID(repo2.ID, 1)
+	deletedBranch, err := git_model.GetDeletedBranchByID(repo2.ID, 1)
 	// Expect no error, and the returned branch is nil.
 	assert.NoError(t, err)
 	// This should return the deletedBranch.
 	repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1}).(*repo_model.Repository)
-	deletedBranch, err = GetDeletedBranchByID(repo1.ID, 1)
+	deletedBranch, err = git_model.GetDeletedBranchByID(repo1.ID, 1)
 	// Expect no error, and the returned branch to be not nil.
 	assert.NoError(t, err)

models/git/commit_status.gorenamed from models/commit_status.go+17−2

 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
-package models
+package git
 import (
 	"context"
 	"code.gitea.io/gitea/models/db"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
+	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
 	api "code.gitea.io/gitea/modules/structs"
 		opts.Page = 1
 	}
 	if opts.PageSize <= 0 {
-		opts.Page = ItemsPerPage
+		opts.Page = setting.ItemsPerPage
 	}
 	countSession := listCommitStatusesStatement(repo, sha, opts)
 func hashCommitStatusContext(context string) string {
 	return fmt.Sprintf("%x", sha1.Sum([]byte(context)))
 }
+// ConvertFromGitCommit converts git commits into SignCommitWithStatuses
+func ConvertFromGitCommit(commits []*git.Commit, repo *repo_model.Repository) []*SignCommitWithStatuses {
+	return ParseCommitsWithStatus(
+		asymkey_model.ParseCommitsWithSignature(
+			user_model.ValidateCommitsWithEmails(commits),
+			repo.GetTrustModel(),
+			func(user *user_model.User) (bool, error) {
+				return repo_model.IsOwnerMemberCollaborator(repo, user.ID)
+			},
+		),
+		repo,
+	)
+}

models/git/commit_status_test.gorenamed from models/commit_status_test.go+3−2

 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
-package models
+package git_test
 import (
 	"testing"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unittest"
 	"code.gitea.io/gitea/modules/structs"
 	sha1 := "1234123412341234123412341234123412341234"
-	statuses, maxResults, err := GetCommitStatuses(repo1, sha1, &CommitStatusOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 50}})
+	statuses, maxResults, err := git_model.GetCommitStatuses(repo1, sha1, &git_model.CommitStatusOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 50}})
 	assert.NoError(t, err)
 	assert.Equal(t, int(maxResults), 5)
 	assert.Len(t, statuses, 5)

models/git/lfs.gorenamed from models/lfs.go+73−2

@@ -2,7 +2,7 @@ · 1 unmodified line
2	// Use of this source code is governed by a MIT-style	2	// Use of this source code is governed by a MIT-style
3	// license that can be found in the LICENSE file.	3	// license that can be found in the LICENSE file.
4		4
5	package models	5	package git
6		6
7	import (	7	import (
8	"context"	8	"context"
@@ -10,6 +10,7 @@ import ( · 1 unmodified line
10	"fmt"	10	"fmt"
11		11
12	"code.gitea.io/gitea/models/db"	12	"code.gitea.io/gitea/models/db"
		13	"code.gitea.io/gitea/models/perm"
13	repo_model "code.gitea.io/gitea/models/repo"	14	repo_model "code.gitea.io/gitea/models/repo"
14	user_model "code.gitea.io/gitea/models/user"	15	user_model "code.gitea.io/gitea/models/user"
15	"code.gitea.io/gitea/modules/lfs"	16	"code.gitea.io/gitea/modules/lfs"
@@ -19,6 +20,76 @@ import ( · 3 unmodified lines
19	"xorm.io/builder"	20	"xorm.io/builder"
20	)	21	)
21		22
		23	// ErrLFSLockNotExist represents a "LFSLockNotExist" kind of error.
		24	type ErrLFSLockNotExist struct {
		25	ID int64
		26	RepoID int64
		27	Path string
		28	}
		29
		30	// IsErrLFSLockNotExist checks if an error is a ErrLFSLockNotExist.
		31	func IsErrLFSLockNotExist(err error) bool {
		32	_, ok := err.(ErrLFSLockNotExist)
		33	return ok
		34	}
		35
		36	func (err ErrLFSLockNotExist) Error() string {
		37	return fmt.Sprintf("lfs lock does not exist [id: %d, rid: %d, path: %s]", err.ID, err.RepoID, err.Path)
		38	}
		39
		40	// ErrLFSUnauthorizedAction represents a "LFSUnauthorizedAction" kind of error.
		41	type ErrLFSUnauthorizedAction struct {
		42	RepoID int64
		43	UserName string
		44	Mode perm.AccessMode
		45	}
		46
		47	// IsErrLFSUnauthorizedAction checks if an error is a ErrLFSUnauthorizedAction.
		48	func IsErrLFSUnauthorizedAction(err error) bool {
		49	_, ok := err.(ErrLFSUnauthorizedAction)
		50	return ok
		51	}
		52
		53	func (err ErrLFSUnauthorizedAction) Error() string {
		54	if err.Mode == perm.AccessModeWrite {
		55	return fmt.Sprintf("User %s doesn't have write access for lfs lock [rid: %d]", err.UserName, err.RepoID)
		56	}
		57	return fmt.Sprintf("User %s doesn't have read access for lfs lock [rid: %d]", err.UserName, err.RepoID)
		58	}
		59
		60	// ErrLFSLockAlreadyExist represents a "LFSLockAlreadyExist" kind of error.
		61	type ErrLFSLockAlreadyExist struct {
		62	RepoID int64
		63	Path string
		64	}
		65
		66	// IsErrLFSLockAlreadyExist checks if an error is a ErrLFSLockAlreadyExist.
		67	func IsErrLFSLockAlreadyExist(err error) bool {
		68	_, ok := err.(ErrLFSLockAlreadyExist)
		69	return ok
		70	}
		71
		72	func (err ErrLFSLockAlreadyExist) Error() string {
		73	return fmt.Sprintf("lfs lock already exists [rid: %d, path: %s]", err.RepoID, err.Path)
		74	}
		75
		76	// ErrLFSFileLocked represents a "LFSFileLocked" kind of error.
		77	type ErrLFSFileLocked struct {
		78	RepoID int64
		79	Path string
		80	UserName string
		81	}
		82
		83	// IsErrLFSFileLocked checks if an error is a ErrLFSFileLocked.
		84	func IsErrLFSFileLocked(err error) bool {
		85	_, ok := err.(ErrLFSFileLocked)
		86	return ok
		87	}
		88
		89	func (err ErrLFSFileLocked) Error() string {
		90	return fmt.Sprintf("File is lfs locked [repo: %d, locked by: %s, path: %s]", err.RepoID, err.UserName, err.Path)
		91	}
		92
22	// LFSMetaObject stores metadata for LFS tracked files.	93	// LFSMetaObject stores metadata for LFS tracked files.
23	type LFSMetaObject struct {	94	type LFSMetaObject struct {
24	ID int64 `xorm:"pk autoincr"`	95	ID int64 `xorm:"pk autoincr"`
@@ -239,7 +310,7 @@ func CopyLFS(ctx context.Context, newRepo, oldRepo *repo_model.Repository) error · 214 unmodified lines
239	for _, v := range lfsObjects {	310	for _, v := range lfsObjects {
240	v.ID = 0	311	v.ID = 0
241	v.RepositoryID = newRepo.ID	312	v.RepositoryID = newRepo.ID
242	if _, err := db.GetEngine(ctx).Insert(v); err != nil {	313	if err := db.Insert(ctx, v); err != nil {
243	return err	314	return err
244	}	315	}
245	}	316	}

models/git/lfs_lock.gorenamed from models/lfs_lock.go+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	// Use of this source code is governed by a MIT-style	2	// Use of this source code is governed by a MIT-style
3	// license that can be found in the LICENSE file.	3	// license that can be found in the LICENSE file.
4		4
5	package models	5	package git
6		6
7	import (	7	import (
8	"context"	8	"context"

models/git/main_test.go+18−0

@@ -0,0 +1,18 @@
	1	// Copyright 2020 The Gitea Authors. All rights reserved.
	2	// Use of this source code is governed by a MIT-style
	3	// license that can be found in the LICENSE file.
	4
	5	package git_test
	6
	7	import (
	8	"path/filepath"
	9	"testing"
	10
	11	"code.gitea.io/gitea/models/unittest"
	12	)
	13
	14	func TestMain(m *testing.M) {
	15	unittest.MainTest(m, &unittest.TestOptions{
	16	GiteaRootPath: filepath.Join("..", ".."),
	17	})
	18	}

models/git/protected_tag.gorenamed from models/protected_tag.go+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2	// Use of this source code is governed by a MIT-style	2	// Use of this source code is governed by a MIT-style
3	// license that can be found in the LICENSE file.	3	// license that can be found in the LICENSE file.
4		4
5	package models	5	package git
6		6
7	import (	7	import (
8	"regexp"	8	"regexp"

models/git/protected_tag_test.gorenamed from models/protected_tag_test.go+17−16

 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
-package models
+package git_test
 import (
 	"testing"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/unittest"
 	"github.com/stretchr/testify/assert"
 func TestIsUserAllowed(t *testing.T) {
 	assert.NoError(t, unittest.PrepareTestDatabase())
-	pt := &ProtectedTag{}
+	pt := &git_model.ProtectedTag{}
-	allowed, err := IsUserAllowedModifyTag(pt, 1)
+	allowed, err := git_model.IsUserAllowedModifyTag(pt, 1)
 	assert.NoError(t, err)
 	assert.False(t, allowed)
-	pt = &ProtectedTag{
+	pt = &git_model.ProtectedTag{
 		AllowlistUserIDs: []int64{1},
 	}
-	allowed, err = IsUserAllowedModifyTag(pt, 1)
+	allowed, err = git_model.IsUserAllowedModifyTag(pt, 1)
 	assert.NoError(t, err)
 	assert.True(t, allowed)
-	allowed, err = IsUserAllowedModifyTag(pt, 2)
+	allowed, err = git_model.IsUserAllowedModifyTag(pt, 2)
 	assert.NoError(t, err)
 	assert.False(t, allowed)
-	pt = &ProtectedTag{
+	pt = &git_model.ProtectedTag{
 		AllowlistTeamIDs: []int64{1},
 	}
-	allowed, err = IsUserAllowedModifyTag(pt, 1)
+	allowed, err = git_model.IsUserAllowedModifyTag(pt, 1)
 	assert.NoError(t, err)
 	assert.False(t, allowed)
-	allowed, err = IsUserAllowedModifyTag(pt, 2)
+	allowed, err = git_model.IsUserAllowedModifyTag(pt, 2)
 	assert.NoError(t, err)
 	assert.True(t, allowed)
-	pt = &ProtectedTag{
+	pt = &git_model.ProtectedTag{
 		AllowlistUserIDs: []int64{1},
 		AllowlistTeamIDs: []int64{1},
 	}
-	allowed, err = IsUserAllowedModifyTag(pt, 1)
+	allowed, err = git_model.IsUserAllowedModifyTag(pt, 1)
 	assert.NoError(t, err)
 	assert.True(t, allowed)
-	allowed, err = IsUserAllowedModifyTag(pt, 2)
+	allowed, err = git_model.IsUserAllowedModifyTag(pt, 2)
 	assert.NoError(t, err)
 	assert.True(t, allowed)
 }
 	}
 	t.Run("Glob", func(t *testing.T) {
-		protectedTags := []*ProtectedTag{
+		protectedTags := []*git_model.ProtectedTag{
 			{
 				NamePattern:      `*gitea`,
 				AllowlistUserIDs: []int64{1},
 		}
 		for n, c := range cases {
-			isAllowed, err := IsUserAllowedToControlTag(protectedTags, c.name, c.userid)
+			isAllowed, err := git_model.IsUserAllowedToControlTag(protectedTags, c.name, c.userid)
 			assert.NoError(t, err)
 			assert.Equal(t, c.allowed, isAllowed, "case %d: error should match", n)
 		}
 	})
 	t.Run("Regex", func(t *testing.T) {
-		protectedTags := []*ProtectedTag{
+		protectedTags := []*git_model.ProtectedTag{
 			{
 				NamePattern:      `/gitea\z/`,
 				AllowlistUserIDs: []int64{1},
 		}
 		for n, c := range cases {
-			isAllowed, err := IsUserAllowedToControlTag(protectedTags, c.name, c.userid)
+			isAllowed, err := git_model.IsUserAllowedToControlTag(protectedTags, c.name, c.userid)
 			assert.NoError(t, err)
 			assert.Equal(t, c.allowed, isAllowed, "case %d: error should match", n)
 		}

models/issue_comment.go+7−6

 	"unicode/utf8"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	issues_model "code.gitea.io/gitea/models/issues"
 	"code.gitea.io/gitea/models/organization"
 	project_model "code.gitea.io/gitea/models/project"
 	RefIssue   *Issue                 `xorm:"-"`
 	RefComment *Comment               `xorm:"-"`
-	Commits     []*SignCommitWithStatuses `xorm:"-"`
+	Commits     []*git_model.SignCommitWithStatuses `xorm:"-"`
-	OldCommit   string                    `xorm:"-"`
+	OldCommit   string                              `xorm:"-"`
-	NewCommit   string                    `xorm:"-"`
+	NewCommit   string                              `xorm:"-"`
-	CommitsNum  int64                     `xorm:"-"`
+	CommitsNum  int64                               `xorm:"-"`
-	IsForcePush bool                      `xorm:"-"`
+	IsForcePush bool                                `xorm:"-"`
 }
 func init() {
 		}
 		defer closer.Close()
-		c.Commits = ConvertFromGitCommit(gitRepo.GetCommitsFromIDs(data.CommitIDs), c.Issue.Repo)
+		c.Commits = git_model.ConvertFromGitCommit(gitRepo.GetCommitsFromIDs(data.CommitIDs), c.Issue.Repo)
 		c.CommitsNum = int64(len(c.Commits))
 	}

models/org_team.go+2−1

 	"strings"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/organization"
 	access_model "code.gitea.io/gitea/models/perm/access"
 	repo_model "code.gitea.io/gitea/models/repo"
 	// update branch protections
 	{
-		protections := make([]*ProtectedBranch, 0, 10)
+		protections := make([]*git_model.ProtectedBranch, 0, 10)
 		err := sess.In("repo_id",
 			builder.Select("id").From("repository").Where(builder.Eq{"owner_id": t.OrgID})).
 			Find(&protections)

models/pull.go+5−4

 	"strings"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	pull_model "code.gitea.io/gitea/models/pull"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	HeadBranch          string
 	HeadCommitID        string `xorm:"-"`
 	BaseBranch          string
-	ProtectedBranch     *ProtectedBranch `xorm:"-"`
+	ProtectedBranch     *git_model.ProtectedBranch `xorm:"-"`
-	MergeBase           string           `xorm:"VARCHAR(40)"`
+	MergeBase           string                     `xorm:"VARCHAR(40)"`
-	AllowMaintainerEdit bool             `xorm:"NOT NULL DEFAULT false"`
+	AllowMaintainerEdit bool                       `xorm:"NOT NULL DEFAULT false"`
 	HasMerged      bool               `xorm:"INDEX"`
 	MergedCommitID string             `xorm:"VARCHAR(40)"`
 				return
 			}
 		}
-		pr.ProtectedBranch, err = GetProtectedBranchBy(ctx, pr.BaseRepo.ID, pr.BaseBranch)
+		pr.ProtectedBranch, err = git_model.GetProtectedBranchBy(ctx, pr.BaseRepo.ID, pr.BaseBranch)
 	}
 	return
 }

models/repo.go+9−11

 	admin_model "code.gitea.io/gitea/models/admin"
 	asymkey_model "code.gitea.io/gitea/models/asymkey"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	issues_model "code.gitea.io/gitea/models/issues"
 	"code.gitea.io/gitea/models/organization"
 	"code.gitea.io/gitea/models/perm"
 	"xorm.io/builder"
 )
-// ItemsPerPage maximum items per page in forks, watchers and stars of a repo
-var ItemsPerPage = 40
 // NewRepoContext creates a new repository context
 func NewRepoContext() {
 	unit.LoadUnitConfig()
 		&Action{RepoID: repo.ID},
 		&repo_model.Collaboration{RepoID: repoID},
 		&Comment{RefRepoID: repoID},
-		&CommitStatus{RepoID: repoID},
+		&git_model.CommitStatus{RepoID: repoID},
-		&DeletedBranch{RepoID: repoID},
+		&git_model.DeletedBranch{RepoID: repoID},
 		&webhook.HookTask{RepoID: repoID},
-		&LFSLock{RepoID: repoID},
+		&git_model.LFSLock{RepoID: repoID},
 		&repo_model.LanguageStat{RepoID: repoID},
 		&issues_model.Milestone{RepoID: repoID},
 		&repo_model.Mirror{RepoID: repoID},
 		&Notification{RepoID: repoID},
-		&ProtectedBranch{RepoID: repoID},
+		&git_model.ProtectedBranch{RepoID: repoID},
-		&ProtectedTag{RepoID: repoID},
+		&git_model.ProtectedTag{RepoID: repoID},
 		&repo_model.PushMirror{RepoID: repoID},
 		&Release{RepoID: repoID},
 		&repo_model.RepoIndexerStatus{RepoID: repoID},
 	}
 	// Remove LFS objects
-	var lfsObjects []*LFSMetaObject
+	var lfsObjects []*git_model.LFSMetaObject
 	if err = sess.Where("repository_id=?", repoID).Find(&lfsObjects); err != nil {
 		return err
 	}
 	lfsPaths := make([]string, 0, len(lfsObjects))
 	for _, v := range lfsObjects {
-		count, err := db.CountByBean(ctx, &LFSMetaObject{Pointer: lfs.Pointer{Oid: v.Oid}})
+		count, err := db.CountByBean(ctx, &git_model.LFSMetaObject{Pointer: lfs.Pointer{Oid: v.Oid}})
 		if err != nil {
 			return err
 		}
 		lfsPaths = append(lfsPaths, v.RelativePath())
 	}
-	if _, err := db.DeleteByBean(ctx, &LFSMetaObject{RepositoryID: repoID}); err != nil {
+	if _, err := db.DeleteByBean(ctx, &git_model.LFSMetaObject{RepositoryID: repoID}); err != nil {
 		return err
 	}

models/repo/collaboration.go+21−0

@@ -10,6 +10,7 @@ import ( · 9 unmodified lines
10		10
11	"code.gitea.io/gitea/models/db"	11	"code.gitea.io/gitea/models/db"
12	"code.gitea.io/gitea/models/perm"	12	"code.gitea.io/gitea/models/perm"
		13	"code.gitea.io/gitea/models/unit"
13	user_model "code.gitea.io/gitea/models/user"	14	user_model "code.gitea.io/gitea/models/user"
14	"code.gitea.io/gitea/modules/log"	15	"code.gitea.io/gitea/modules/log"
15	"code.gitea.io/gitea/modules/timeutil"	16	"code.gitea.io/gitea/modules/timeutil"
@@ -149,3 +150,23 @@ func ChangeCollaborationAccessMode(repo *Repository, uid int64, mode perm.Access · 133 unmodified lines
149		150
150	return committer.Commit()	151	return committer.Commit()
151	}	152	}
		153
		154	// IsOwnerMemberCollaborator checks if a provided user is the owner, a collaborator or a member of a team in a repository
		155	func IsOwnerMemberCollaborator(repo *Repository, userID int64) (bool, error) {
		156	if repo.OwnerID == userID {
		157	return true, nil
		158	}
		159	teamMember, err := db.GetEngine(db.DefaultContext).Join("INNER", "team_repo", "team_repo.team_id = team_user.team_id").
		160	Join("INNER", "team_unit", "team_unit.team_id = team_user.team_id").
		161	Where("team_repo.repo_id = ?", repo.ID).
		162	And("team_unit.`type` = ?", unit.TypeCode).
		163	And("team_user.uid = ?", userID).Table("team_user").Exist()
		164	if err != nil {
		165	return false, err
		166	}
		167	if teamMember {
		168	return true, nil
		169	}
		170
		171	return db.GetEngine(db.DefaultContext).Get(&Collaboration{RepoID: repo.ID, UserID: userID})
		172	}

models/repo_collaboration.go+0−22

@@ -10,11 +10,9 @@ import ( · 9 unmodified lines
10	"fmt"	10	"fmt"
11		11
12	"code.gitea.io/gitea/models/db"	12	"code.gitea.io/gitea/models/db"
13	"code.gitea.io/gitea/models/organization"
14	"code.gitea.io/gitea/models/perm"	13	"code.gitea.io/gitea/models/perm"
15	access_model "code.gitea.io/gitea/models/perm/access"	14	access_model "code.gitea.io/gitea/models/perm/access"
16	repo_model "code.gitea.io/gitea/models/repo"	15	repo_model "code.gitea.io/gitea/models/repo"
17	"code.gitea.io/gitea/models/unit"
18	user_model "code.gitea.io/gitea/models/user"	16	user_model "code.gitea.io/gitea/models/user"
19		17
20	"xorm.io/builder"	18	"xorm.io/builder"
@@ -120,23 +118,3 @@ func reconsiderWatches(ctx context.Context, repo *repo_model.Repository, uid int · 99 unmodified lines
120	// Remove all IssueWatches a user has subscribed to in the repository	118	// Remove all IssueWatches a user has subscribed to in the repository
121	return removeIssueWatchersByRepoID(ctx, uid, repo.ID)	119	return removeIssueWatchersByRepoID(ctx, uid, repo.ID)
122	}	120	}
123
124	// IsOwnerMemberCollaborator checks if a provided user is the owner, a collaborator or a member of a team in a repository
125	func IsOwnerMemberCollaborator(repo *repo_model.Repository, userID int64) (bool, error) {
126	if repo.OwnerID == userID {
127	return true, nil
128	}
129	teamMember, err := db.GetEngine(db.DefaultContext).Join("INNER", "team_repo", "team_repo.team_id = team_user.team_id").
130	Join("INNER", "team_unit", "team_unit.team_id = team_user.team_id").
131	Where("team_repo.repo_id = ?", repo.ID).
132	And("team_unit.`type` = ?", unit.TypeCode).
133	And("team_user.uid = ?", userID).Table("team_user").Exist(&organization.TeamUser{})
134	if err != nil {
135	return false, err
136	}
137	if teamMember {
138	return true, nil
139	}
140
141	return db.GetEngine(db.DefaultContext).Get(&repo_model.Collaboration{RepoID: repo.ID, UserID: userID})
142	}

models/review.go+2−1

 	"strings"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/organization"
 	"code.gitea.io/gitea/models/perm"
 	access_model "code.gitea.io/gitea/models/perm/access"
 	}
 	for _, reviewer := range reviewers {
-		official, err := isUserOfficialReviewer(ctx, pr.ProtectedBranch, reviewer)
+		official, err := git_model.IsUserOfficialReviewerCtx(ctx, pr.ProtectedBranch, reviewer)
 		if official || err != nil {
 			return official, err
 		}

models/user.go+2−1

 	asymkey_model "code.gitea.io/gitea/models/asymkey"
 	auth_model "code.gitea.io/gitea/models/auth"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/issues"
 	"code.gitea.io/gitea/models/organization"
 	access_model "code.gitea.io/gitea/models/perm/access"
 	{
 		const batchSize = 50
 		for start := 0; ; start += batchSize {
-			protections := make([]*ProtectedBranch, 0, batchSize)
+			protections := make([]*git_model.ProtectedBranch, 0, batchSize)
 			// @perf: We can't filter on DB side by u.ID, as those IDs are serialized as JSON strings.
 			//   We could filter down with `WHERE repo_id IN (reposWithPushPermission(u))`,
 			//   though that query will be quite complex and tricky to maintain (compare `getRepoAssignees()`).

modules/context/repo.go+3−2

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	access_model "code.gitea.io/gitea/models/perm/access"
 	repo_model "code.gitea.io/gitea/models/repo"
 	unit_model "code.gitea.io/gitea/models/unit"
 // CanCommitToBranch returns true if repository is editable and user has proper access level
 //   and branch is not protected for push
 func (r *Repository) CanCommitToBranch(ctx context.Context, doer *user_model.User) (CanCommitToBranchResults, error) {
-	protectedBranch, err := models.GetProtectedBranchBy(ctx, r.Repository.ID, r.BranchName)
+	protectedBranch, err := git_model.GetProtectedBranchBy(ctx, r.Repository.ID, r.BranchName)
 	if err != nil {
 		return CanCommitToBranchResults{}, err
 	}
 		if len(ref) == 0 {
 			// maybe it's a renamed branch
 			return getRefNameFromPath(ctx, path, func(s string) bool {
-				b, exist, err := models.FindRenamedBranch(ctx.Repo.Repository.ID, s)
+				b, exist, err := git_model.FindRenamedBranch(ctx.Repo.Repository.ID, s)
 				if err != nil {
 					log.Error("FindRenamedBranch", err)
 					return false

modules/convert/convert.go+5−4

 	asymkey_model "code.gitea.io/gitea/models/asymkey"
 	"code.gitea.io/gitea/models/auth"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/organization"
 	"code.gitea.io/gitea/models/perm"
 	access_model "code.gitea.io/gitea/models/perm/access"
 }
 // ToBranch convert a git.Commit and git.Branch to an api.Branch
-func ToBranch(repo *repo_model.Repository, b *git.Branch, c *git.Commit, bp *models.ProtectedBranch, user *user_model.User, isRepoAdmin bool) (*api.Branch, error) {
+func ToBranch(repo *repo_model.Repository, b *git.Branch, c *git.Commit, bp *git_model.ProtectedBranch, user *user_model.User, isRepoAdmin bool) (*api.Branch, error) {
 	if bp == nil {
 		var hasPerm bool
 		var canPush bool
 			return nil, err
 		}
 		branch.UserCanPush = bp.CanUserPush(user.ID)
-		branch.UserCanMerge = models.IsUserMergeWhitelisted(db.DefaultContext, bp, user.ID, permission)
+		branch.UserCanMerge = git_model.IsUserMergeWhitelisted(db.DefaultContext, bp, user.ID, permission)
 	}
 	return branch, nil
 }
 // ToBranchProtection convert a ProtectedBranch to api.BranchProtection
-func ToBranchProtection(bp *models.ProtectedBranch) *api.BranchProtection {
+func ToBranchProtection(bp *git_model.ProtectedBranch) *api.BranchProtection {
 	pushWhitelistUsernames, err := user_model.GetUserNamesByIDs(bp.WhitelistUserIDs)
 	if err != nil {
 		log.Error("GetUserNamesByIDs (WhitelistUserIDs): %v", err)
 }
 // ToLFSLock convert a LFSLock to api.LFSLock
-func ToLFSLock(l *models.LFSLock) *api.LFSLock {
+func ToLFSLock(l *git_model.LFSLock) *api.LFSLock {
 	u, err := user_model.GetUserByID(l.OwnerID)
 	if err != nil {
 		return nil

modules/convert/status.go+4−4

@@ -5,13 +5,13 @@ · 4 unmodified lines
5	package convert	5	package convert
6		6
7	import (	7	import (
8	"code.gitea.io/gitea/models"	8	git_model "code.gitea.io/gitea/models/git"
9	user_model "code.gitea.io/gitea/models/user"	9	user_model "code.gitea.io/gitea/models/user"
10	api "code.gitea.io/gitea/modules/structs"	10	api "code.gitea.io/gitea/modules/structs"
11	)	11	)
12		12
13	// ToCommitStatus converts models.CommitStatus to api.CommitStatus	13	// ToCommitStatus converts git_model.CommitStatus to api.CommitStatus
14	func ToCommitStatus(status models.CommitStatus) api.CommitStatus {	14	func ToCommitStatus(status git_model.CommitStatus) api.CommitStatus {
15	apiStatus := &api.CommitStatus{	15	apiStatus := &api.CommitStatus{
16	Created: status.CreatedUnix.AsTime(),	16	Created: status.CreatedUnix.AsTime(),
17	Updated: status.CreatedUnix.AsTime(),	17	Updated: status.CreatedUnix.AsTime(),
@@ -32,7 +32,7 @@ func ToCommitStatus(status models.CommitStatus) api.CommitStatus { · 14 unmodified lines
32	}	32	}
33		33
34	// ToCombinedStatus converts List of CommitStatus to a CombinedStatus	34	// ToCombinedStatus converts List of CommitStatus to a CombinedStatus
35	func ToCombinedStatus(statuses []models.CommitStatus, repo api.Repository) *api.CombinedStatus {	35	func ToCombinedStatus(statuses []git_model.CommitStatus, repo api.Repository) *api.CombinedStatus {
36	if len(statuses) == 0 {	36	if len(statuses) == 0 {
37	return nil	37	return nil
38	}	38	}

modules/gitgraph/graph_models.go+5−5

 	"fmt"
 	"strings"
-	"code.gitea.io/gitea/models"
 	asymkey_model "code.gitea.io/gitea/models/asymkey"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 		c.Verification = asymkey_model.ParseCommitWithSignature(c.Commit)
 		_ = asymkey_model.CalculateTrustStatus(c.Verification, repository.GetTrustModel(), func(user *user_model.User) (bool, error) {
-			return models.IsOwnerMemberCollaborator(repository, user.ID)
+			return repo_model.IsOwnerMemberCollaborator(repository, user.ID)
 		}, &keyMap)
-		statuses, _, err := models.GetLatestCommitStatus(db.DefaultContext, repository.ID, c.Commit.ID.String(), db.ListOptions{})
+		statuses, _, err := git_model.GetLatestCommitStatus(db.DefaultContext, repository.ID, c.Commit.ID.String(), db.ListOptions{})
 		if err != nil {
 			log.Error("GetLatestCommitStatus: %v", err)
 		} else {
-			c.Status = models.CalcCommitStatus(statuses)
+			c.Status = git_model.CalcCommitStatus(statuses)
 		}
 	}
 	return nil
 	Commit       *git.Commit
 	User         *user_model.User
 	Verification *asymkey_model.CommitVerification
-	Status       *models.CommitStatus
+	Status       *git_model.CommitStatus
 	Flow         int64
 	Row          int
 	Column       int

modules/lfs/content_store.go+1−1

@@ -113,7 +113,7 @@ func (s *ContentStore) Verify(pointer Pointer) (bool, error) { · 112 unmodified lines
113	return true, nil	113	return true, nil
114	}	114	}
115		115
116	// ReadMetaObject will read a models.LFSMetaObject and return a reader	116	// ReadMetaObject will read a git_model.LFSMetaObject and return a reader
117	func ReadMetaObject(pointer Pointer) (io.ReadCloser, error) {	117	func ReadMetaObject(pointer Pointer) (io.ReadCloser, error) {
118	contentStore := NewContentStore()	118	contentStore := NewContentStore()
119	return contentStore.Get(pointer)	119	return contentStore.Get(pointer)

modules/repository/create.go+2−1

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	access_model "code.gitea.io/gitea/models/perm/access"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 		return fmt.Errorf("updateSize: %v", err)
 	}
-	lfsSize, err := models.GetRepoLFSSize(ctx, repo.ID)
+	lfsSize, err := git_model.GetRepoLFSSize(ctx, repo.ID)
 	if err != nil {
 		return fmt.Errorf("updateSize: GetLFSMetaObjects: %v", err)
 	}

modules/repository/generate.go+2−1

 	"time"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 		return fmt.Errorf("failed to update size for repository: %v", err)
 	}
-	if err := models.CopyLFS(ctx, generateRepo, templateRepo); err != nil {
+	if err := git_model.CopyLFS(ctx, generateRepo, templateRepo); err != nil {
 		return fmt.Errorf("failed to copy LFS: %v", err)
 	}
 	return nil

modules/repository/repo.go+6−5

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/organization"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 			defer content.Close()
-			_, err := models.NewLFSMetaObject(&models.LFSMetaObject{Pointer: p, RepositoryID: repo.ID})
+			_, err := git_model.NewLFSMetaObject(&git_model.LFSMetaObject{Pointer: p, RepositoryID: repo.ID})
 			if err != nil {
 				log.Error("Repo[%-v]: Error creating LFS meta object %-v: %v", repo, p, err)
 				return err
 			if err := contentStore.Put(p, content); err != nil {
 				log.Error("Repo[%-v]: Error storing content for LFS meta object %-v: %v", repo, p, err)
-				if _, err2 := models.RemoveLFSMetaObjectByOid(repo.ID, p.Oid); err2 != nil {
+				if _, err2 := git_model.RemoveLFSMetaObjectByOid(repo.ID, p.Oid); err2 != nil {
 					log.Error("Repo[%-v]: Error removing LFS meta object %-v: %v", repo, p, err2)
 				}
 				return err
 	var batch []lfs.Pointer
 	for pointerBlob := range pointerChan {
-		meta, err := models.GetLFSMetaObjectByOid(repo.ID, pointerBlob.Oid)
+		meta, err := git_model.GetLFSMetaObjectByOid(repo.ID, pointerBlob.Oid)
-		if err != nil && err != models.ErrLFSObjectNotExist {
+		if err != nil && err != git_model.ErrLFSObjectNotExist {
 			log.Error("Repo[%-v]: Error querying LFS meta object %-v: %v", repo, pointerBlob.Pointer, err)
 			return err
 		}
 		if exist {
 			log.Trace("Repo[%-v]: LFS object %-v already present; creating meta object", repo, pointerBlob.Pointer)
-			_, err := models.NewLFSMetaObject(&models.LFSMetaObject{Pointer: pointerBlob.Pointer, RepositoryID: repo.ID})
+			_, err := git_model.NewLFSMetaObject(&git_model.LFSMetaObject{Pointer: pointerBlob.Pointer, RepositoryID: repo.ID})
 			if err != nil {
 				log.Error("Repo[%-v]: Error creating LFS meta object %-v: %v", repo, pointerBlob.Pointer, err)
 				return err

modules/setting/repository.go+3−0

@@ -20,6 +20,9 @@ const ( · 19 unmodified lines
20	RepoCreatingPublic = "public"	20	RepoCreatingPublic = "public"
21	)	21	)
22		22
		23	// ItemsPerPage maximum items per page in forks, watchers and stars of a repo
		24	const ItemsPerPage = 40
		25
23	// Repository settings	26	// Repository settings
24	var (	27	var (
25	Repository = struct {	28	Repository = struct {

routers/api/v1/repo/branch.go+15−14

 	"net/http"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/organization"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/context"
 		return
 	}
-	branchProtection, err := models.GetProtectedBranchBy(ctx, ctx.Repo.Repository.ID, branchName)
+	branchProtection, err := git_model.GetProtectedBranchBy(ctx, ctx.Repo.Repository.ID, branchName)
 	if err != nil {
 		ctx.Error(http.StatusInternalServerError, "GetBranchProtection", err)
 		return
 		return
 	}
-	branchProtection, err := models.GetProtectedBranchBy(ctx, ctx.Repo.Repository.ID, branch.Name)
+	branchProtection, err := git_model.GetProtectedBranchBy(ctx, ctx.Repo.Repository.ID, branch.Name)
 	if err != nil {
 		ctx.Error(http.StatusInternalServerError, "GetBranchProtection", err)
 		return
 			ctx.Error(http.StatusInternalServerError, "GetCommit", err)
 			return
 		}
-		branchProtection, err := models.GetProtectedBranchBy(ctx, ctx.Repo.Repository.ID, branches[i].Name)
+		branchProtection, err := git_model.GetProtectedBranchBy(ctx, ctx.Repo.Repository.ID, branches[i].Name)
 		if err != nil {
 			ctx.Error(http.StatusInternalServerError, "GetBranchProtection", err)
 			return
 	repo := ctx.Repo.Repository
 	bpName := ctx.Params(":name")
-	bp, err := models.GetProtectedBranchBy(ctx, repo.ID, bpName)
+	bp, err := git_model.GetProtectedBranchBy(ctx, repo.ID, bpName)
 	if err != nil {
 		ctx.Error(http.StatusInternalServerError, "GetProtectedBranchByID", err)
 		return
 	//     "$ref": "#/responses/BranchProtectionList"
 	repo := ctx.Repo.Repository
-	bps, err := models.GetProtectedBranches(repo.ID)
+	bps, err := git_model.GetProtectedBranches(repo.ID)
 	if err != nil {
 		ctx.Error(http.StatusInternalServerError, "GetProtectedBranches", err)
 		return
 		return
 	}
-	protectBranch, err := models.GetProtectedBranchBy(ctx, repo.ID, form.BranchName)
+	protectBranch, err := git_model.GetProtectedBranchBy(ctx, repo.ID, form.BranchName)
 	if err != nil {
 		ctx.Error(http.StatusInternalServerError, "GetProtectBranchOfRepoByName", err)
 		return
 		}
 	}
-	protectBranch = &models.ProtectedBranch{
+	protectBranch = &git_model.ProtectedBranch{
 		RepoID:                        ctx.Repo.Repository.ID,
 		BranchName:                    form.BranchName,
 		CanPush:                       form.EnablePush,
 		BlockOnOutdatedBranch:         form.BlockOnOutdatedBranch,
 	}
-	err = models.UpdateProtectBranch(ctx, ctx.Repo.Repository, protectBranch, models.WhitelistOptions{
+	err = git_model.UpdateProtectBranch(ctx, ctx.Repo.Repository, protectBranch, git_model.WhitelistOptions{
 		UserIDs:          whitelistUsers,
 		TeamIDs:          whitelistTeams,
 		MergeUserIDs:     mergeWhitelistUsers,
 	}
 	// Reload from db to get all whitelists
-	bp, err := models.GetProtectedBranchBy(ctx, ctx.Repo.Repository.ID, form.BranchName)
+	bp, err := git_model.GetProtectedBranchBy(ctx, ctx.Repo.Repository.ID, form.BranchName)
 	if err != nil {
 		ctx.Error(http.StatusInternalServerError, "GetProtectedBranchByID", err)
 		return
 	form := web.GetForm(ctx).(*api.EditBranchProtectionOption)
 	repo := ctx.Repo.Repository
 	bpName := ctx.Params(":name")
-	protectBranch, err := models.GetProtectedBranchBy(ctx, repo.ID, bpName)
+	protectBranch, err := git_model.GetProtectedBranchBy(ctx, repo.ID, bpName)
 	if err != nil {
 		ctx.Error(http.StatusInternalServerError, "GetProtectedBranchByID", err)
 		return
 		}
 	}
-	err = models.UpdateProtectBranch(ctx, ctx.Repo.Repository, protectBranch, models.WhitelistOptions{
+	err = git_model.UpdateProtectBranch(ctx, ctx.Repo.Repository, protectBranch, git_model.WhitelistOptions{
 		UserIDs:          whitelistUsers,
 		TeamIDs:          whitelistTeams,
 		MergeUserIDs:     mergeWhitelistUsers,
 	}
 	// Reload from db to ensure get all whitelists
-	bp, err := models.GetProtectedBranchBy(ctx, repo.ID, bpName)
+	bp, err := git_model.GetProtectedBranchBy(ctx, repo.ID, bpName)
 	if err != nil {
 		ctx.Error(http.StatusInternalServerError, "GetProtectedBranchBy", err)
 		return
 	repo := ctx.Repo.Repository
 	bpName := ctx.Params(":name")
-	bp, err := models.GetProtectedBranchBy(ctx, repo.ID, bpName)
+	bp, err := git_model.GetProtectedBranchBy(ctx, repo.ID, bpName)
 	if err != nil {
 		ctx.Error(http.StatusInternalServerError, "GetProtectedBranchByID", err)
 		return
 		return
 	}
-	if err := models.DeleteProtectedBranch(ctx.Repo.Repository.ID, bp.ID); err != nil {
+	if err := git_model.DeleteProtectedBranch(ctx.Repo.Repository.ID, bp.ID); err != nil {
 		ctx.Error(http.StatusInternalServerError, "DeleteProtectedBranch", err)
 		return
 	}

routers/api/v1/repo/file.go+3−2

 	"time"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unit"
 	"code.gitea.io/gitea/modules/cache"
 	}
 	// Now check if there is a meta object for this pointer
-	meta, err := models.GetLFSMetaObjectByOid(ctx.Repo.Repository.ID, pointer.Oid)
+	meta, err := git_model.GetLFSMetaObjectByOid(ctx.Repo.Repository.ID, pointer.Oid)
 	// If there isn't one just serve the data directly
-	if err == models.ErrLFSObjectNotExist {
+	if err == git_model.ErrLFSObjectNotExist {
 		// Handle caching for the blob SHA (not the LFS object OID)
 		if httpcache.HandleGenericETagTimeCache(ctx.Req, ctx.Resp, `"`+blob.ID.String()+`"`, lastModified) {
 			return

routers/api/v1/repo/status.go+4−4

@@ -8,7 +8,7 @@ import ( · 7 unmodified lines
8	"fmt"	8	"fmt"
9	"net/http"	9	"net/http"
10		10
11	"code.gitea.io/gitea/models"	11	git_model "code.gitea.io/gitea/models/git"
12	"code.gitea.io/gitea/modules/context"	12	"code.gitea.io/gitea/modules/context"
13	"code.gitea.io/gitea/modules/convert"	13	"code.gitea.io/gitea/modules/convert"
14	api "code.gitea.io/gitea/modules/structs"	14	api "code.gitea.io/gitea/modules/structs"
@@ -56,7 +56,7 @@ func NewCommitStatus(ctx *context.APIContext) { · 41 unmodified lines
56	ctx.Error(http.StatusBadRequest, "sha not given", nil)	56	ctx.Error(http.StatusBadRequest, "sha not given", nil)
57	return	57	return
58	}	58	}
59	status := &models.CommitStatus{	59	status := &git_model.CommitStatus{
60	State: api.CommitStatusState(form.State),	60	State: api.CommitStatusState(form.State),
61	TargetURL: form.TargetURL,	61	TargetURL: form.TargetURL,
62	Description: form.Description,	62	Description: form.Description,
@@ -188,7 +188,7 @@ func getCommitStatuses(ctx *context.APIContext, sha string) { · 125 unmodified lines
188		188
189	listOptions := utils.GetListOptions(ctx)	189	listOptions := utils.GetListOptions(ctx)
190		190
191	statuses, maxResults, err := models.GetCommitStatuses(repo, sha, &models.CommitStatusOptions{	191	statuses, maxResults, err := git_model.GetCommitStatuses(repo, sha, &git_model.CommitStatusOptions{
192	ListOptions: listOptions,	192	ListOptions: listOptions,
193	SortType: ctx.FormTrim("sort"),	193	SortType: ctx.FormTrim("sort"),
194	State: ctx.FormTrim("state"),	194	State: ctx.FormTrim("state"),
@@ -253,7 +253,7 @@ func GetCombinedCommitStatusByRef(ctx *context.APIContext) { · 58 unmodified lines
253		253
254	repo := ctx.Repo.Repository	254	repo := ctx.Repo.Repository
255		255
256	statuses, count, err := models.GetLatestCommitStatus(ctx, repo.ID, sha, utils.GetListOptions(ctx))	256	statuses, count, err := git_model.GetLatestCommitStatus(ctx, repo.ID, sha, utils.GetListOptions(ctx))
257	if err != nil {	257	if err != nil {
258	ctx.Error(http.StatusInternalServerError, "GetLatestCommitStatus", fmt.Errorf("GetLatestCommitStatus[%s, %s]: %v", repo.FullName(), sha, err))	258	ctx.Error(http.StatusInternalServerError, "GetLatestCommitStatus", fmt.Errorf("GetLatestCommitStatus[%s, %s]: %v", repo.FullName(), sha, err))
259	return	259	return

routers/private/hook_pre_receive.go+5−4

 	"code.gitea.io/gitea/models"
 	asymkey_model "code.gitea.io/gitea/models/asymkey"
+	git_model "code.gitea.io/gitea/models/git"
 	perm_model "code.gitea.io/gitea/models/perm"
 	access_model "code.gitea.io/gitea/models/perm/access"
 	"code.gitea.io/gitea/models/unit"
 	canWriteCode        bool
 	checkedCanWriteCode bool
-	protectedTags    []*models.ProtectedTag
+	protectedTags    []*git_model.ProtectedTag
 	gotProtectedTags bool
 	env []string
 		return
 	}
-	protectBranch, err := models.GetProtectedBranchBy(ctx, repo.ID, branchName)
+	protectBranch, err := git_model.GetProtectedBranchBy(ctx, repo.ID, branchName)
 	if err != nil {
 		log.Error("Unable to get protected branch: %s in %-v Error: %v", branchName, repo, err)
 		ctx.JSON(http.StatusInternalServerError, private.Response{
 	if !ctx.gotProtectedTags {
 		var err error
-		ctx.protectedTags, err = models.GetProtectedTags(ctx.Repo.Repository.ID)
+		ctx.protectedTags, err = git_model.GetProtectedTags(ctx.Repo.Repository.ID)
 		if err != nil {
 			log.Error("Unable to get protected tags for %-v Error: %v", ctx.Repo.Repository, err)
 			ctx.JSON(http.StatusInternalServerError, private.Response{
 		ctx.gotProtectedTags = true
 	}
-	isAllowed, err := models.IsUserAllowedToControlTag(ctx.protectedTags, tagName, ctx.opts.UserID)
+	isAllowed, err := git_model.IsUserAllowedToControlTag(ctx.protectedTags, tagName, ctx.opts.UserID)
 	if err != nil {
 		ctx.JSON(http.StatusInternalServerError, private.Response{
 			Err: err.Error(),

routers/web/repo/branch.go+6−5

 	"strings"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unit"
 	"code.gitea.io/gitea/modules/base"
 	IsProtected       bool
 	IsDeleted         bool
 	IsIncluded        bool
-	DeletedBranch     *models.DeletedBranch
+	DeletedBranch     *git_model.DeletedBranch
 	CommitsAhead      int
 	CommitsBehind     int
 	LatestPullRequest *models.PullRequest
 	branchID := ctx.FormInt64("branch_id")
 	branchName := ctx.FormString("name")
-	deletedBranch, err := models.GetDeletedBranchByID(ctx.Repo.Repository.ID, branchID)
+	deletedBranch, err := git_model.GetDeletedBranchByID(ctx.Repo.Repository.ID, branchID)
 	if err != nil {
 		log.Error("GetDeletedBranchByID: %v", err)
 		ctx.Flash.Error(ctx.Tr("repo.branch.restore_failed", branchName))
 		return nil, nil, 0
 	}
-	protectedBranches, err := models.GetProtectedBranches(ctx.Repo.Repository.ID)
+	protectedBranches, err := git_model.GetProtectedBranches(ctx.Repo.Repository.ID)
 	if err != nil {
 		ctx.ServerError("GetProtectedBranches", err)
 		return nil, nil, 0
 	return defaultBranchBranch, branches, totalNumOfBranches
 }
-func loadOneBranch(ctx *context.Context, rawBranch, defaultBranch *git.Branch, protectedBranches []*models.ProtectedBranch,
+func loadOneBranch(ctx *context.Context, rawBranch, defaultBranch *git.Branch, protectedBranches []*git_model.ProtectedBranch,
 	repoIDToRepo map[int64]*repo_model.Repository,
 	repoIDToGitRepo map[int64]*git.Repository,
 ) *Branch {
 func getDeletedBranches(ctx *context.Context) ([]*Branch, error) {
 	branches := []*Branch{}
-	deletedBranches, err := models.GetDeletedBranches(ctx.Repo.Repository.ID)
+	deletedBranches, err := git_model.GetDeletedBranches(ctx.Repo.Repository.ID)
 	if err != nil {
 		return branches, err
 	}

routers/web/repo/commit.go+8−7

 	"net/http"
 	"strings"
-	"code.gitea.io/gitea/models"
 	asymkey_model "code.gitea.io/gitea/models/asymkey"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
+	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/base"
 	"code.gitea.io/gitea/modules/charset"
 		ctx.ServerError("CommitsByRange", err)
 		return
 	}
-	ctx.Data["Commits"] = models.ConvertFromGitCommit(commits, ctx.Repo.Repository)
+	ctx.Data["Commits"] = git_model.ConvertFromGitCommit(commits, ctx.Repo.Repository)
 	ctx.Data["Username"] = ctx.Repo.Owner.Name
 	ctx.Data["Reponame"] = ctx.Repo.Repository.Name
 		return
 	}
 	ctx.Data["CommitCount"] = len(commits)
-	ctx.Data["Commits"] = models.ConvertFromGitCommit(commits, ctx.Repo.Repository)
+	ctx.Data["Commits"] = git_model.ConvertFromGitCommit(commits, ctx.Repo.Repository)
 	ctx.Data["Keyword"] = query
 	if all {
 		ctx.ServerError("CommitsByFileAndRange", err)
 		return
 	}
-	ctx.Data["Commits"] = models.ConvertFromGitCommit(commits, ctx.Repo.Repository)
+	ctx.Data["Commits"] = git_model.ConvertFromGitCommit(commits, ctx.Repo.Repository)
 	ctx.Data["Username"] = ctx.Repo.Owner.Name
 	ctx.Data["Reponame"] = ctx.Repo.Repository.Name
 	ctx.Data["Commit"] = commit
 	ctx.Data["Diff"] = diff
-	statuses, _, err := models.GetLatestCommitStatus(ctx, ctx.Repo.Repository.ID, commitID, db.ListOptions{})
+	statuses, _, err := git_model.GetLatestCommitStatus(ctx, ctx.Repo.Repository.ID, commitID, db.ListOptions{})
 	if err != nil {
 		log.Error("GetLatestCommitStatus: %v", err)
 	}
-	ctx.Data["CommitStatus"] = models.CalcCommitStatus(statuses)
+	ctx.Data["CommitStatus"] = git_model.CalcCommitStatus(statuses)
 	ctx.Data["CommitStatuses"] = statuses
 	verification := asymkey_model.ParseCommitWithSignature(commit)
 	ctx.Data["DiffNotAvailable"] = diff.NumFiles == 0
 	if err := asymkey_model.CalculateTrustStatus(verification, ctx.Repo.Repository.GetTrustModel(), func(user *user_model.User) (bool, error) {
-		return models.IsOwnerMemberCollaborator(ctx.Repo.Repository, user.ID)
+		return repo_model.IsOwnerMemberCollaborator(ctx.Repo.Repository, user.ID)
 	}, nil); err != nil {
 		ctx.ServerError("CalculateTrustStatus", err)
 		return

routers/web/repo/compare.go+2−1

 	"strings"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	access_model "code.gitea.io/gitea/models/perm/access"
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unit"
 		return false
 	}
-	commits := models.ConvertFromGitCommit(ci.CompareInfo.Commits, ci.HeadRepo)
+	commits := git_model.ConvertFromGitCommit(ci.CompareInfo.Commits, ci.HeadRepo)
 	ctx.Data["Commits"] = commits
 	ctx.Data["CommitCount"] = len(commits)

routers/web/repo/download.go+2−2

@@ -9,7 +9,7 @@ import ( · 8 unmodified lines
9	"path"	9	"path"
10	"time"	10	"time"
11		11
12	"code.gitea.io/gitea/models"	12	git_model "code.gitea.io/gitea/models/git"
13	"code.gitea.io/gitea/modules/cache"	13	"code.gitea.io/gitea/modules/cache"
14	"code.gitea.io/gitea/modules/context"	14	"code.gitea.io/gitea/modules/context"
15	"code.gitea.io/gitea/modules/git"	15	"code.gitea.io/gitea/modules/git"
@@ -43,7 +43,7 @@ func ServeBlobOrLFS(ctx context.Context, blob git.Blob, lastModified time.Time · 27 unmodified lines
43		43
44	pointer, _ := lfs.ReadPointer(dataRc)	44	pointer, _ := lfs.ReadPointer(dataRc)
45	if pointer.IsValid() {	45	if pointer.IsValid() {
46	meta, _ := models.GetLFSMetaObjectByOid(ctx.Repo.Repository.ID, pointer.Oid)	46	meta, _ := git_model.GetLFSMetaObjectByOid(ctx.Repo.Repository.ID, pointer.Oid)
47	if meta == nil {	47	if meta == nil {
48	if err = dataRc.Close(); err != nil {	48	if err = dataRc.Close(); err != nil {
49	log.Error("ServeBlobOrLFS: Close: %v", err)	49	log.Error("ServeBlobOrLFS: Close: %v", err)

routers/web/repo/editor.go+5−4

 	"strings"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/unit"
 	"code.gitea.io/gitea/modules/base"
 	"code.gitea.io/gitea/modules/charset"
 		// This is where we handle all the errors thrown by files_service.CreateOrUpdateRepoFile
 		if git.IsErrNotExist(err) {
 			ctx.RenderWithErr(ctx.Tr("repo.editor.file_editing_no_longer_exists", ctx.Repo.TreePath), tplEditFile, &form)
-		} else if models.IsErrLFSFileLocked(err) {
+		} else if git_model.IsErrLFSFileLocked(err) {
 			ctx.Data["Err_TreePath"] = true
-			ctx.RenderWithErr(ctx.Tr("repo.editor.upload_file_is_locked", err.(models.ErrLFSFileLocked).Path, err.(models.ErrLFSFileLocked).UserName), tplEditFile, &form)
+			ctx.RenderWithErr(ctx.Tr("repo.editor.upload_file_is_locked", err.(git_model.ErrLFSFileLocked).Path, err.(git_model.ErrLFSFileLocked).UserName), tplEditFile, &form)
 		} else if models.IsErrFilenameInvalid(err) {
 			ctx.Data["Err_TreePath"] = true
 			ctx.RenderWithErr(ctx.Tr("repo.editor.filename_is_invalid", form.TreePath), tplEditFile, &form)
 		Files:        form.Files,
 		Signoff:      form.Signoff,
 	}); err != nil {
-		if models.IsErrLFSFileLocked(err) {
+		if git_model.IsErrLFSFileLocked(err) {
 			ctx.Data["Err_TreePath"] = true
-			ctx.RenderWithErr(ctx.Tr("repo.editor.upload_file_is_locked", err.(models.ErrLFSFileLocked).Path, err.(models.ErrLFSFileLocked).UserName), tplUploadFile, &form)
+			ctx.RenderWithErr(ctx.Tr("repo.editor.upload_file_is_locked", err.(git_model.ErrLFSFileLocked).Path, err.(git_model.ErrLFSFileLocked).UserName), tplUploadFile, &form)
 		} else if models.IsErrFilenameInvalid(err) {
 			ctx.Data["Err_TreePath"] = true
 			ctx.RenderWithErr(ctx.Tr("repo.editor.filename_is_invalid", form.TreePath), tplUploadFile, &form)

routers/web/repo/issue.go+7−6

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	issues_model "code.gitea.io/gitea/models/issues"
 	"code.gitea.io/gitea/models/organization"
 	access_model "code.gitea.io/gitea/models/perm/access"
 				if perm.CanWrite(unit.TypeCode) {
 					// Check if branch is not protected
 					if pull.HeadBranch != pull.HeadRepo.DefaultBranch {
-						if protected, err := models.IsProtectedBranch(pull.HeadRepo.ID, pull.HeadBranch); err != nil {
+						if protected, err := git_model.IsProtectedBranch(pull.HeadRepo.ID, pull.HeadBranch); err != nil {
 							log.Error("IsProtectedBranch: %v", err)
 						} else if !protected {
 							canDelete = true
 			if ctx.Doer != nil {
 				showMergeInstructions = pull.ProtectedBranch.CanUserPush(ctx.Doer.ID)
 			}
-			ctx.Data["IsBlockedByApprovals"] = !pull.ProtectedBranch.HasEnoughApprovals(ctx, pull)
+			ctx.Data["IsBlockedByApprovals"] = !models.HasEnoughApprovals(ctx, pull.ProtectedBranch, pull)
-			ctx.Data["IsBlockedByRejection"] = pull.ProtectedBranch.MergeBlockedByRejectedReview(ctx, pull)
+			ctx.Data["IsBlockedByRejection"] = models.MergeBlockedByRejectedReview(ctx, pull.ProtectedBranch, pull)
-			ctx.Data["IsBlockedByOfficialReviewRequests"] = pull.ProtectedBranch.MergeBlockedByOfficialReviewRequests(ctx, pull)
+			ctx.Data["IsBlockedByOfficialReviewRequests"] = models.MergeBlockedByOfficialReviewRequests(ctx, pull.ProtectedBranch, pull)
-			ctx.Data["IsBlockedByOutdatedBranch"] = pull.ProtectedBranch.MergeBlockedByOutdatedBranch(pull)
+			ctx.Data["IsBlockedByOutdatedBranch"] = models.MergeBlockedByOutdatedBranch(pull.ProtectedBranch, pull)
-			ctx.Data["GrantedApprovals"] = pull.ProtectedBranch.GetGrantedApprovalsCount(ctx, pull)
+			ctx.Data["GrantedApprovals"] = models.GetGrantedApprovalsCount(ctx, pull.ProtectedBranch, pull)
 			ctx.Data["RequireSigned"] = pull.ProtectedBranch.RequireSignedCommits
 			ctx.Data["ChangedProtectedFiles"] = pull.ChangedProtectedFiles
 			ctx.Data["IsBlockedByChangedProtectedFiles"] = len(pull.ChangedProtectedFiles) != 0

routers/web/repo/lfs.go+18−18

@@ -15,7 +15,7 @@ import ( · 14 unmodified lines
15	"strconv"	15	"strconv"
16	"strings"	16	"strings"
17		17
18	"code.gitea.io/gitea/models"	18	git_model "code.gitea.io/gitea/models/git"
19	"code.gitea.io/gitea/modules/base"	19	"code.gitea.io/gitea/modules/base"
20	"code.gitea.io/gitea/modules/charset"	20	"code.gitea.io/gitea/modules/charset"
21	"code.gitea.io/gitea/modules/context"	21	"code.gitea.io/gitea/modules/context"
@@ -48,7 +48,7 @@ func LFSFiles(ctx *context.Context) { · 26 unmodified lines
48	if page <= 1 {	48	if page <= 1 {
49	page = 1	49	page = 1
50	}	50	}
51	total, err := models.CountLFSMetaObjects(ctx.Repo.Repository.ID)	51	total, err := git_model.CountLFSMetaObjects(ctx.Repo.Repository.ID)
52	if err != nil {	52	if err != nil {
53	ctx.ServerError("LFSFiles", err)	53	ctx.ServerError("LFSFiles", err)
54	return	54	return
@@ -58,7 +58,7 @@ func LFSFiles(ctx *context.Context) { · 3 unmodified lines
58	pager := context.NewPagination(int(total), setting.UI.ExplorePagingNum, page, 5)	58	pager := context.NewPagination(int(total), setting.UI.ExplorePagingNum, page, 5)
59	ctx.Data["Title"] = ctx.Tr("repo.settings.lfs")	59	ctx.Data["Title"] = ctx.Tr("repo.settings.lfs")
60	ctx.Data["PageIsSettingsLFS"] = true	60	ctx.Data["PageIsSettingsLFS"] = true
61	lfsMetaObjects, err := models.GetLFSMetaObjects(ctx.Repo.Repository.ID, pager.Paginater.Current(), setting.UI.ExplorePagingNum)	61	lfsMetaObjects, err := git_model.GetLFSMetaObjects(ctx.Repo.Repository.ID, pager.Paginater.Current(), setting.UI.ExplorePagingNum)
62	if err != nil {	62	if err != nil {
63	ctx.ServerError("LFSFiles", err)	63	ctx.ServerError("LFSFiles", err)
64	return	64	return
@@ -80,7 +80,7 @@ func LFSLocks(ctx *context.Context) { · 15 unmodified lines
80	if page <= 1 {	80	if page <= 1 {
81	page = 1	81	page = 1
82	}	82	}
83	total, err := models.CountLFSLockByRepoID(ctx.Repo.Repository.ID)	83	total, err := git_model.CountLFSLockByRepoID(ctx.Repo.Repository.ID)
84	if err != nil {	84	if err != nil {
85	ctx.ServerError("LFSLocks", err)	85	ctx.ServerError("LFSLocks", err)
86	return	86	return
@@ -90,7 +90,7 @@ func LFSLocks(ctx *context.Context) { · 3 unmodified lines
90	pager := context.NewPagination(int(total), setting.UI.ExplorePagingNum, page, 5)	90	pager := context.NewPagination(int(total), setting.UI.ExplorePagingNum, page, 5)
91	ctx.Data["Title"] = ctx.Tr("repo.settings.lfs_locks")	91	ctx.Data["Title"] = ctx.Tr("repo.settings.lfs_locks")
92	ctx.Data["PageIsSettingsLFS"] = true	92	ctx.Data["PageIsSettingsLFS"] = true
93	lfsLocks, err := models.GetLFSLockByRepoID(ctx.Repo.Repository.ID, pager.Paginater.Current(), setting.UI.ExplorePagingNum)	93	lfsLocks, err := git_model.GetLFSLockByRepoID(ctx.Repo.Repository.ID, pager.Paginater.Current(), setting.UI.ExplorePagingNum)
94	if err != nil {	94	if err != nil {
95	ctx.ServerError("LFSLocks", err)	95	ctx.ServerError("LFSLocks", err)
96	return	96	return
@@ -216,12 +216,12 @@ func LFSLockFile(ctx *context.Context) { · 119 unmodified lines
216	return	216	return
217	}	217	}
218		218
219	_, err := models.CreateLFSLock(ctx.Repo.Repository, &models.LFSLock{	219	_, err := git_model.CreateLFSLock(ctx.Repo.Repository, &git_model.LFSLock{
220	Path: lockPath,	220	Path: lockPath,
221	OwnerID: ctx.Doer.ID,	221	OwnerID: ctx.Doer.ID,
222	})	222	})
223	if err != nil {	223	if err != nil {
224	if models.IsErrLFSLockAlreadyExist(err) {	224	if git_model.IsErrLFSLockAlreadyExist(err) {
225	ctx.Flash.Error(ctx.Tr("repo.settings.lfs_lock_already_exists", originalPath))	225	ctx.Flash.Error(ctx.Tr("repo.settings.lfs_lock_already_exists", originalPath))
226	ctx.Redirect(ctx.Repo.RepoLink + "/settings/lfs/locks")	226	ctx.Redirect(ctx.Repo.RepoLink + "/settings/lfs/locks")
227	return	227	return
@@ -238,7 +238,7 @@ func LFSUnlock(ctx *context.Context) { · 10 unmodified lines
238	ctx.NotFound("LFSUnlock", nil)	238	ctx.NotFound("LFSUnlock", nil)
239	return	239	return
240	}	240	}
241	_, err := models.DeleteLFSLockByID(ctx.ParamsInt64("lid"), ctx.Repo.Repository, ctx.Doer, true)	241	_, err := git_model.DeleteLFSLockByID(ctx.ParamsInt64("lid"), ctx.Repo.Repository, ctx.Doer, true)
242	if err != nil {	242	if err != nil {
243	ctx.ServerError("LFSUnlock", err)	243	ctx.ServerError("LFSUnlock", err)
244	return	244	return
@@ -263,9 +263,9 @@ func LFSFileGet(ctx *context.Context) { · 18 unmodified lines
263		263
264	ctx.Data["Title"] = oid	264	ctx.Data["Title"] = oid
265	ctx.Data["PageIsSettingsLFS"] = true	265	ctx.Data["PageIsSettingsLFS"] = true
266	meta, err := models.GetLFSMetaObjectByOid(ctx.Repo.Repository.ID, oid)	266	meta, err := git_model.GetLFSMetaObjectByOid(ctx.Repo.Repository.ID, oid)
267	if err != nil {	267	if err != nil {
268	if err == models.ErrLFSObjectNotExist {	268	if err == git_model.ErrLFSObjectNotExist {
269	ctx.NotFound("LFSFileGet", nil)	269	ctx.NotFound("LFSFileGet", nil)
270	return	270	return
271	}	271	}
@@ -357,7 +357,7 @@ func LFSDelete(ctx *context.Context) { · 85 unmodified lines
357	return	357	return
358	}	358	}
359		359
360	count, err := models.RemoveLFSMetaObjectByOid(ctx.Repo.Repository.ID, oid)	360	count, err := git_model.RemoveLFSMetaObjectByOid(ctx.Repo.Repository.ID, oid)
361	if err != nil {	361	if err != nil {
362	ctx.ServerError("LFSDelete", err)	362	ctx.ServerError("LFSDelete", err)
363	return	363	return
@@ -456,8 +456,8 @@ func LFSPointerFiles(ctx *context.Context) { · 92 unmodified lines
456	Size: pointerBlob.Size,	456	Size: pointerBlob.Size,
457	}	457	}
458		458
459	if _, err := models.GetLFSMetaObjectByOid(repo.ID, pointerBlob.Oid); err != nil {	459	if _, err := git_model.GetLFSMetaObjectByOid(repo.ID, pointerBlob.Oid); err != nil {
460	if err != models.ErrLFSObjectNotExist {	460	if err != git_model.ErrLFSObjectNotExist {
461	return err	461	return err
462	}	462	}
463	} else {	463	} else {
@@ -474,12 +474,12 @@ func LFSPointerFiles(ctx *context.Context) { · 10 unmodified lines
474	// Can we fix?	474	// Can we fix?
475	// OK well that's "simple"	475	// OK well that's "simple"
476	// - we need to check whether current user has access to a repo that has access to the file	476	// - we need to check whether current user has access to a repo that has access to the file
477	result.Associatable, err = models.LFSObjectAccessible(ctx.Doer, pointerBlob.Oid)	477	result.Associatable, err = git_model.LFSObjectAccessible(ctx.Doer, pointerBlob.Oid)
478	if err != nil {	478	if err != nil {
479	return err	479	return err
480	}	480	}
481	if !result.Associatable {	481	if !result.Associatable {
482	associated, err := models.LFSObjectIsAssociated(pointerBlob.Oid)	482	associated, err := git_model.LFSObjectIsAssociated(pointerBlob.Oid)
483	if err != nil {	483	if err != nil {
484	return err	484	return err
485	}	485	}
@@ -532,7 +532,7 @@ func LFSAutoAssociate(ctx *context.Context) { · 46 unmodified lines
532	return	532	return
533	}	533	}
534	oids := ctx.FormStrings("oid")	534	oids := ctx.FormStrings("oid")
535	metas := make([]*models.LFSMetaObject, len(oids))	535	metas := make([]*git_model.LFSMetaObject, len(oids))
536	for i, oid := range oids {	536	for i, oid := range oids {
537	idx := strings.IndexRune(oid, ' ')	537	idx := strings.IndexRune(oid, ' ')
538	if idx < 0 \|\| idx+1 > len(oid) {	538	if idx < 0 \|\| idx+1 > len(oid) {
@@ -540,7 +540,7 @@ func LFSAutoAssociate(ctx *context.Context) { · 1 unmodified line
540	return	540	return
541	}	541	}
542	var err error	542	var err error
543	metas[i] = &models.LFSMetaObject{}	543	metas[i] = &git_model.LFSMetaObject{}
544	metas[i].Size, err = strconv.ParseInt(oid[idx+1:], 10, 64)	544	metas[i].Size, err = strconv.ParseInt(oid[idx+1:], 10, 64)
545	if err != nil {	545	if err != nil {
546	ctx.ServerError("LFSAutoAssociate", fmt.Errorf("illegal oid input: %s %v", oid, err))	546	ctx.ServerError("LFSAutoAssociate", fmt.Errorf("illegal oid input: %s %v", oid, err))
@@ -549,7 +549,7 @@ func LFSAutoAssociate(ctx *context.Context) { · 2 unmodified lines
549	metas[i].Oid = oid[:idx]	549	metas[i].Oid = oid[:idx]
550	// metas[i].RepositoryID = ctx.Repo.Repository.ID	550	// metas[i].RepositoryID = ctx.Repo.Repository.ID
551	}	551	}
552	if err := models.LFSAutoAssociate(metas, ctx.Doer, ctx.Repo.Repository.ID); err != nil {	552	if err := git_model.LFSAutoAssociate(metas, ctx.Doer, ctx.Repo.Repository.ID); err != nil {
553	ctx.ServerError("LFSAutoAssociate", err)	553	ctx.ServerError("LFSAutoAssociate", err)
554	return	554	return
555	}	555	}

routers/web/repo/pull.go+8−7

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/organization"
 	access_model "code.gitea.io/gitea/models/perm/access"
 	pull_model "code.gitea.io/gitea/models/pull"
 	if len(compareInfo.Commits) != 0 {
 		sha := compareInfo.Commits[0].ID.String()
-		commitStatuses, _, err := models.GetLatestCommitStatus(ctx, ctx.Repo.Repository.ID, sha, db.ListOptions{})
+		commitStatuses, _, err := git_model.GetLatestCommitStatus(ctx, ctx.Repo.Repository.ID, sha, db.ListOptions{})
 		if err != nil {
 			ctx.ServerError("GetLatestCommitStatus", err)
 			return nil
 		}
 		if len(commitStatuses) != 0 {
 			ctx.Data["LatestCommitStatuses"] = commitStatuses
-			ctx.Data["LatestCommitStatus"] = models.CalcCommitStatus(commitStatuses)
+			ctx.Data["LatestCommitStatus"] = git_model.CalcCommitStatus(commitStatuses)
 		}
 	}
 			ctx.ServerError(fmt.Sprintf("GetRefCommitID(%s)", pull.GetGitRefName()), err)
 			return nil
 		}
-		commitStatuses, _, err := models.GetLatestCommitStatus(ctx, repo.ID, sha, db.ListOptions{})
+		commitStatuses, _, err := git_model.GetLatestCommitStatus(ctx, repo.ID, sha, db.ListOptions{})
 		if err != nil {
 			ctx.ServerError("GetLatestCommitStatus", err)
 			return nil
 		}
 		if len(commitStatuses) > 0 {
 			ctx.Data["LatestCommitStatuses"] = commitStatuses
-			ctx.Data["LatestCommitStatus"] = models.CalcCommitStatus(commitStatuses)
+			ctx.Data["LatestCommitStatus"] = git_model.CalcCommitStatus(commitStatuses)
 		}
 		compareInfo, err := baseGitRepo.GetCompareInfo(pull.BaseRepo.RepoPath(),
 		return nil
 	}
-	commitStatuses, _, err := models.GetLatestCommitStatus(ctx, repo.ID, sha, db.ListOptions{})
+	commitStatuses, _, err := git_model.GetLatestCommitStatus(ctx, repo.ID, sha, db.ListOptions{})
 	if err != nil {
 		ctx.ServerError("GetLatestCommitStatus", err)
 		return nil
 	}
 	if len(commitStatuses) > 0 {
 		ctx.Data["LatestCommitStatuses"] = commitStatuses
-		ctx.Data["LatestCommitStatus"] = models.CalcCommitStatus(commitStatuses)
+		ctx.Data["LatestCommitStatus"] = git_model.CalcCommitStatus(commitStatuses)
 	}
 	if pull.ProtectedBranch != nil && pull.ProtectedBranch.EnableStatusCheck {
 	ctx.Data["Username"] = ctx.Repo.Owner.Name
 	ctx.Data["Reponame"] = ctx.Repo.Repository.Name
-	commits := models.ConvertFromGitCommit(prInfo.Commits, ctx.Repo.Repository)
+	commits := git_model.ConvertFromGitCommit(prInfo.Commits, ctx.Repo.Repository)
 	ctx.Data["Commits"] = commits
 	ctx.Data["CommitCount"] = len(commits)

routers/web/repo/setting_protected_branch.go+9−9

@@ -10,7 +10,7 @@ import ( · 9 unmodified lines
10	"strings"	10	"strings"
11	"time"	11	"time"
12		12
13	"code.gitea.io/gitea/models"	13	git_model "code.gitea.io/gitea/models/git"
14	"code.gitea.io/gitea/models/organization"	14	"code.gitea.io/gitea/models/organization"
15	"code.gitea.io/gitea/models/perm"	15	"code.gitea.io/gitea/models/perm"
16	access_model "code.gitea.io/gitea/models/perm/access"	16	access_model "code.gitea.io/gitea/models/perm/access"
@@ -32,7 +32,7 @@ func ProtectedBranch(ctx *context.Context) { · 15 unmodified lines
32	ctx.Data["Title"] = ctx.Tr("repo.settings")	32	ctx.Data["Title"] = ctx.Tr("repo.settings")
33	ctx.Data["PageIsSettingsBranches"] = true	33	ctx.Data["PageIsSettingsBranches"] = true
34		34
35	protectedBranches, err := models.GetProtectedBranches(ctx.Repo.Repository.ID)	35	protectedBranches, err := git_model.GetProtectedBranches(ctx.Repo.Repository.ID)
36	if err != nil {	36	if err != nil {
37	ctx.ServerError("GetProtectedBranches", err)	37	ctx.ServerError("GetProtectedBranches", err)
38	return	38	return
@@ -111,7 +111,7 @@ func SettingsProtectedBranch(c *context.Context) { · 72 unmodified lines
111	c.Data["Title"] = c.Tr("repo.settings.protected_branch") + " - " + branch	111	c.Data["Title"] = c.Tr("repo.settings.protected_branch") + " - " + branch
112	c.Data["PageIsSettingsBranches"] = true	112	c.Data["PageIsSettingsBranches"] = true
113		113
114	protectBranch, err := models.GetProtectedBranchBy(c, c.Repo.Repository.ID, branch)	114	protectBranch, err := git_model.GetProtectedBranchBy(c, c.Repo.Repository.ID, branch)
115	if err != nil {	115	if err != nil {
116	if !git.IsErrBranchNotExist(err) {	116	if !git.IsErrBranchNotExist(err) {
117	c.ServerError("GetProtectBranchOfRepoByName", err)	117	c.ServerError("GetProtectBranchOfRepoByName", err)
@@ -121,7 +121,7 @@ func SettingsProtectedBranch(c *context.Context) { · 3 unmodified lines
121		121
122	if protectBranch == nil {	122	if protectBranch == nil {
123	// No options found, create defaults.	123	// No options found, create defaults.
124	protectBranch = &models.ProtectedBranch{	124	protectBranch = &git_model.ProtectedBranch{
125	BranchName: branch,	125	BranchName: branch,
126	}	126	}
127	}	127	}
@@ -135,7 +135,7 @@ func SettingsProtectedBranch(c *context.Context) { · 7 unmodified lines
135	c.Data["whitelist_users"] = strings.Join(base.Int64sToStrings(protectBranch.WhitelistUserIDs), ",")	135	c.Data["whitelist_users"] = strings.Join(base.Int64sToStrings(protectBranch.WhitelistUserIDs), ",")
136	c.Data["merge_whitelist_users"] = strings.Join(base.Int64sToStrings(protectBranch.MergeWhitelistUserIDs), ",")	136	c.Data["merge_whitelist_users"] = strings.Join(base.Int64sToStrings(protectBranch.MergeWhitelistUserIDs), ",")
137	c.Data["approvals_whitelist_users"] = strings.Join(base.Int64sToStrings(protectBranch.ApprovalsWhitelistUserIDs), ",")	137	c.Data["approvals_whitelist_users"] = strings.Join(base.Int64sToStrings(protectBranch.ApprovalsWhitelistUserIDs), ",")
138	contexts, _ := models.FindRepoRecentCommitStatusContexts(c.Repo.Repository.ID, 724time.Hour) // Find last week status check contexts	138	contexts, _ := git_model.FindRepoRecentCommitStatusContexts(c.Repo.Repository.ID, 724time.Hour) // Find last week status check contexts
139	for _, ctx := range protectBranch.StatusCheckContexts {	139	for _, ctx := range protectBranch.StatusCheckContexts {
140	var found bool	140	var found bool
141	for i := range contexts {	141	for i := range contexts {
@@ -184,7 +184,7 @@ func SettingsProtectedBranchPost(ctx *context.Context) { · 42 unmodified lines
184	return	184	return
185	}	185	}
186		186
187	protectBranch, err := models.GetProtectedBranchBy(ctx, ctx.Repo.Repository.ID, branch)	187	protectBranch, err := git_model.GetProtectedBranchBy(ctx, ctx.Repo.Repository.ID, branch)
188	if err != nil {	188	if err != nil {
189	if !git.IsErrBranchNotExist(err) {	189	if !git.IsErrBranchNotExist(err) {
190	ctx.ServerError("GetProtectBranchOfRepoByName", err)	190	ctx.ServerError("GetProtectBranchOfRepoByName", err)
@@ -195,7 +195,7 @@ func SettingsProtectedBranchPost(ctx *context.Context) { · 4 unmodified lines
195	if f.Protected {	195	if f.Protected {
196	if protectBranch == nil {	196	if protectBranch == nil {
197	// No options found, create defaults.	197	// No options found, create defaults.
198	protectBranch = &models.ProtectedBranch{	198	protectBranch = &git_model.ProtectedBranch{
199	RepoID: ctx.Repo.Repository.ID,	199	RepoID: ctx.Repo.Repository.ID,
200	BranchName: branch,	200	BranchName: branch,
201	}	201	}
@@ -262,7 +262,7 @@ func SettingsProtectedBranchPost(ctx *context.Context) { · 60 unmodified lines
262	protectBranch.UnprotectedFilePatterns = f.UnprotectedFilePatterns	262	protectBranch.UnprotectedFilePatterns = f.UnprotectedFilePatterns
263	protectBranch.BlockOnOutdatedBranch = f.BlockOnOutdatedBranch	263	protectBranch.BlockOnOutdatedBranch = f.BlockOnOutdatedBranch
264		264
265	err = models.UpdateProtectBranch(ctx, ctx.Repo.Repository, protectBranch, models.WhitelistOptions{	265	err = git_model.UpdateProtectBranch(ctx, ctx.Repo.Repository, protectBranch, git_model.WhitelistOptions{
266	UserIDs: whitelistUsers,	266	UserIDs: whitelistUsers,
267	TeamIDs: whitelistTeams,	267	TeamIDs: whitelistTeams,
268	MergeUserIDs: mergeWhitelistUsers,	268	MergeUserIDs: mergeWhitelistUsers,
@@ -282,7 +282,7 @@ func SettingsProtectedBranchPost(ctx *context.Context) { · 13 unmodified lines
282	ctx.Redirect(fmt.Sprintf("%s/settings/branches/%s", ctx.Repo.RepoLink, util.PathEscapeSegments(branch)))	282	ctx.Redirect(fmt.Sprintf("%s/settings/branches/%s", ctx.Repo.RepoLink, util.PathEscapeSegments(branch)))
283	} else {	283	} else {
284	if protectBranch != nil {	284	if protectBranch != nil {
285	if err := models.DeleteProtectedBranch(ctx.Repo.Repository.ID, protectBranch.ID); err != nil {	285	if err := git_model.DeleteProtectedBranch(ctx.Repo.Repository.ID, protectBranch.ID); err != nil {
286	ctx.ServerError("DeleteProtectedBranch", err)	286	ctx.ServerError("DeleteProtectedBranch", err)
287	return	287	return
288	}	288	}

routers/web/repo/tag.go+8−8

@@ -9,7 +9,7 @@ import ( · 8 unmodified lines
9	"net/http"	9	"net/http"
10	"strings"	10	"strings"
11		11
12	"code.gitea.io/gitea/models"	12	git_model "code.gitea.io/gitea/models/git"
13	"code.gitea.io/gitea/models/organization"	13	"code.gitea.io/gitea/models/organization"
14	"code.gitea.io/gitea/models/perm"	14	"code.gitea.io/gitea/models/perm"
15	access_model "code.gitea.io/gitea/models/perm/access"	15	access_model "code.gitea.io/gitea/models/perm/access"
@@ -43,7 +43,7 @@ func NewProtectedTagPost(ctx *context.Context) { · 27 unmodified lines
43	repo := ctx.Repo.Repository	43	repo := ctx.Repo.Repository
44	form := web.GetForm(ctx).(*forms.ProtectTagForm)	44	form := web.GetForm(ctx).(*forms.ProtectTagForm)
45		45
46	pt := &models.ProtectedTag{	46	pt := &git_model.ProtectedTag{
47	RepoID: repo.ID,	47	RepoID: repo.ID,
48	NamePattern: strings.TrimSpace(form.NamePattern),	48	NamePattern: strings.TrimSpace(form.NamePattern),
49	}	49	}
@@ -55,7 +55,7 @@ func NewProtectedTagPost(ctx *context.Context) { · 5 unmodified lines
55	pt.AllowlistTeamIDs, _ = base.StringsToInt64s(strings.Split(form.AllowlistTeams, ","))	55	pt.AllowlistTeamIDs, _ = base.StringsToInt64s(strings.Split(form.AllowlistTeams, ","))
56	}	56	}
57		57
58	if err := models.InsertProtectedTag(pt); err != nil {	58	if err := git_model.InsertProtectedTag(pt); err != nil {
59	ctx.ServerError("InsertProtectedTag", err)	59	ctx.ServerError("InsertProtectedTag", err)
60	return	60	return
61	}	61	}
@@ -108,7 +108,7 @@ func EditProtectedTagPost(ctx *context.Context) { · 46 unmodified lines
108	pt.AllowlistUserIDs, _ = base.StringsToInt64s(strings.Split(form.AllowlistUsers, ","))	108	pt.AllowlistUserIDs, _ = base.StringsToInt64s(strings.Split(form.AllowlistUsers, ","))
109	pt.AllowlistTeamIDs, _ = base.StringsToInt64s(strings.Split(form.AllowlistTeams, ","))	109	pt.AllowlistTeamIDs, _ = base.StringsToInt64s(strings.Split(form.AllowlistTeams, ","))
110		110
111	if err := models.UpdateProtectedTag(pt); err != nil {	111	if err := git_model.UpdateProtectedTag(pt); err != nil {
112	ctx.ServerError("UpdateProtectedTag", err)	112	ctx.ServerError("UpdateProtectedTag", err)
113	return	113	return
114	}	114	}
@@ -124,7 +124,7 @@ func DeleteProtectedTagPost(ctx *context.Context) { · 9 unmodified lines
124	return	124	return
125	}	125	}
126		126
127	if err := models.DeleteProtectedTag(pt); err != nil {	127	if err := git_model.DeleteProtectedTag(pt); err != nil {
128	ctx.ServerError("DeleteProtectedTag", err)	128	ctx.ServerError("DeleteProtectedTag", err)
129	return	129	return
130	}	130	}
@@ -137,7 +137,7 @@ func setTagsContext(ctx *context.Context) error { · 6 unmodified lines
137	ctx.Data["Title"] = ctx.Tr("repo.settings")	137	ctx.Data["Title"] = ctx.Tr("repo.settings")
138	ctx.Data["PageIsSettingsTags"] = true	138	ctx.Data["PageIsSettingsTags"] = true
139		139
140	protectedTags, err := models.GetProtectedTags(ctx.Repo.Repository.ID)	140	protectedTags, err := git_model.GetProtectedTags(ctx.Repo.Repository.ID)
141	if err != nil {	141	if err != nil {
142	ctx.ServerError("GetProtectedTags", err)	142	ctx.ServerError("GetProtectedTags", err)
143	return err	143	return err
@@ -163,13 +163,13 @@ func setTagsContext(ctx *context.Context) error { · 19 unmodified lines
163	return nil	163	return nil
164	}	164	}
165		165
166	func selectProtectedTagByContext(ctx context.Context) models.ProtectedTag {	166	func selectProtectedTagByContext(ctx context.Context) git_model.ProtectedTag {
167	id := ctx.FormInt64("id")	167	id := ctx.FormInt64("id")
168	if id == 0 {	168	if id == 0 {
169	id = ctx.ParamsInt64(":id")	169	id = ctx.ParamsInt64(":id")
170	}	170	}
171		171
172	tag, err := models.GetProtectedTagByID(id)	172	tag, err := git_model.GetProtectedTagByID(id)
173	if err != nil {	173	if err != nil {
174	ctx.ServerError("GetProtectedTagByID", err)	174	ctx.ServerError("GetProtectedTagByID", err)
175	return nil	175	return nil

routers/web/repo/view.go+13−12

 	"code.gitea.io/gitea/models"
 	asymkey_model "code.gitea.io/gitea/models/asymkey"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	unit_model "code.gitea.io/gitea/models/unit"
 	user_model "code.gitea.io/gitea/models/user"
 	if isTextFile && setting.LFS.StartServer {
 		pointer, _ := lfs.ReadPointerFromBuffer(buf)
 		if pointer.IsValid() {
-			meta, err := models.GetLFSMetaObjectByOid(ctx.Repo.Repository.ID, pointer.Oid)
+			meta, err := git_model.GetLFSMetaObjectByOid(ctx.Repo.Repository.ID, pointer.Oid)
-			if err != nil && err != models.ErrLFSObjectNotExist {
+			if err != nil && err != git_model.ErrLFSObjectNotExist {
 				ctx.ServerError("GetLFSMetaObject", err)
 				return
 			}
 	if isTextFile && setting.LFS.StartServer {
 		pointer, _ := lfs.ReadPointerFromBuffer(buf)
 		if pointer.IsValid() {
-			meta, err := models.GetLFSMetaObjectByOid(ctx.Repo.Repository.ID, pointer.Oid)
+			meta, err := git_model.GetLFSMetaObjectByOid(ctx.Repo.Repository.ID, pointer.Oid)
-			if err != nil && err != models.ErrLFSObjectNotExist {
+			if err != nil && err != git_model.ErrLFSObjectNotExist {
 				ctx.ServerError("GetLFSMetaObject", err)
 				return
 			}
 	ctx.Data["IsTextSource"] = isTextFile || isDisplayingSource
 	// Check LFS Lock
-	lfsLock, err := models.GetTreePathLock(ctx.Repo.Repository.ID, ctx.Repo.TreePath)
+	lfsLock, err := git_model.GetTreePathLock(ctx.Repo.Repository.ID, ctx.Repo.TreePath)
 	ctx.Data["LFSLock"] = lfsLock
 	if err != nil {
 		ctx.ServerError("GetTreePathLock", err)
 		verification := asymkey_model.ParseCommitWithSignature(latestCommit)
 		if err := asymkey_model.CalculateTrustStatus(verification, ctx.Repo.Repository.GetTrustModel(), func(user *user_model.User) (bool, error) {
-			return models.IsOwnerMemberCollaborator(ctx.Repo.Repository, user.ID)
+			return repo_model.IsOwnerMemberCollaborator(ctx.Repo.Repository, user.ID)
 		}, nil); err != nil {
 			ctx.ServerError("CalculateTrustStatus", err)
 			return nil
 		ctx.Data["LatestCommitUser"] = user_model.ValidateCommitWithEmail(latestCommit)
 	}
-	statuses, _, err := models.GetLatestCommitStatus(ctx, ctx.Repo.Repository.ID, ctx.Repo.Commit.ID.String(), db.ListOptions{})
+	statuses, _, err := git_model.GetLatestCommitStatus(ctx, ctx.Repo.Repository.ID, ctx.Repo.Commit.ID.String(), db.ListOptions{})
 	if err != nil {
 		log.Error("GetLatestCommitStatus: %v", err)
 	}
-	ctx.Data["LatestCommitStatus"] = models.CalcCommitStatus(statuses)
+	ctx.Data["LatestCommitStatus"] = git_model.CalcCommitStatus(statuses)
 	ctx.Data["LatestCommitStatuses"] = statuses
 	branchLink := ctx.Repo.RepoLink + "/src/" + ctx.Repo.BranchNameSubURL()
 	if page <= 0 {
 		page = 1
 	}
-	pager := context.NewPagination(total, models.ItemsPerPage, page, 5)
+	pager := context.NewPagination(total, setting.ItemsPerPage, page, 5)
 	ctx.Data["Page"] = pager
 	items, err := getter(db.ListOptions{
 		Page:     pager.Paginater.Current(),
-		PageSize: models.ItemsPerPage,
+		PageSize: setting.ItemsPerPage,
 	})
 	if err != nil {
 		ctx.ServerError("getter", err)
 		page = 1
 	}
-	pager := context.NewPagination(ctx.Repo.Repository.NumForks, models.ItemsPerPage, page, 5)
+	pager := context.NewPagination(ctx.Repo.Repository.NumForks, setting.ItemsPerPage, page, 5)
 	ctx.Data["Page"] = pager
 	forks, err := repo_model.GetForks(ctx.Repo.Repository, db.ListOptions{
 		Page:     pager.Paginater.Current(),
-		PageSize: models.ItemsPerPage,
+		PageSize: setting.ItemsPerPage,
 	})
 	if err != nil {
 		ctx.ServerError("GetForks", err)

routers/web/repo/wiki.go+2−1

 	"time"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/models/unit"
 	"code.gitea.io/gitea/modules/base"
 	"code.gitea.io/gitea/modules/charset"
 		ctx.ServerError("CommitsByFileAndRangeNoFollow", err)
 		return nil, nil
 	}
-	ctx.Data["Commits"] = models.ConvertFromGitCommit(commitsHistory, ctx.Repo.Repository)
+	ctx.Data["Commits"] = git_model.ConvertFromGitCommit(commitsHistory, ctx.Repo.Repository)
 	pager := context.NewPagination(int(commitsCount), setting.Git.CommitsRangeSize, page, 5)
 	pager.SetDefaultParams(ctx)

services/asymkey/sign.go+3−2

 	asymkey_model "code.gitea.io/gitea/models/asymkey"
 	"code.gitea.io/gitea/models/auth"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/log"
 				return false, "", nil, &ErrWontSign{twofa}
 			}
 		case approved:
-			protectedBranch, err := models.GetProtectedBranchBy(ctx, repo.ID, pr.BaseBranch)
+			protectedBranch, err := git_model.GetProtectedBranchBy(ctx, repo.ID, pr.BaseBranch)
 			if err != nil {
 				return false, "", nil, err
 			}
 			if protectedBranch == nil {
 				return false, "", nil, &ErrWontSign{approved}
 			}
-			if protectedBranch.GetGrantedApprovalsCount(ctx, pr) < 1 {
+			if models.GetGrantedApprovalsCount(ctx, protectedBranch, pr) < 1 {
 				return false, "", nil, &ErrWontSign{approved}
 			}
 		case baseSigned:

services/cron/tasks_basic.go+2−1

 	"time"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/models/webhook"
 	"code.gitea.io/gitea/modules/setting"
 		OlderThan: 24 * time.Hour,
 	}, func(ctx context.Context, _ *user_model.User, config Config) error {
 		realConfig := config.(*OlderThanConfig)
-		models.RemoveOldDeletedBranches(ctx, realConfig.OlderThan)
+		git_model.RemoveOldDeletedBranches(ctx, realConfig.OlderThan)
 		return nil
 	})
 }

services/gitdiff/gitdiff.go+2−1

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	pull_model "code.gitea.io/gitea/models/pull"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/analyze"
 		} else if curFileLFSPrefix && strings.HasPrefix(line[1:], lfs.MetaFileOidPrefix) {
 			oid := strings.TrimPrefix(line[1:], lfs.MetaFileOidPrefix)
 			if len(oid) == 64 {
-				m := &models.LFSMetaObject{Pointer: lfs.Pointer{Oid: oid}}
+				m := &git_model.LFSMetaObject{Pointer: lfs.Pointer{Oid: oid}}
 				count, err := db.CountByBean(db.DefaultContext, m)
 				if err == nil && count > 0 {

services/lfs/locks.go+14−14

@@ -9,7 +9,7 @@ import ( · 8 unmodified lines
9	"strconv"	9	"strconv"
10	"strings"	10	"strings"
11		11
12	"code.gitea.io/gitea/models"	12	git_model "code.gitea.io/gitea/models/git"
13	repo_model "code.gitea.io/gitea/models/repo"	13	repo_model "code.gitea.io/gitea/models/repo"
14	"code.gitea.io/gitea/modules/context"	14	"code.gitea.io/gitea/modules/context"
15	"code.gitea.io/gitea/modules/convert"	15	"code.gitea.io/gitea/modules/convert"
@@ -20,9 +20,9 @@ import ( · 4 unmodified lines
20	api "code.gitea.io/gitea/modules/structs"	20	api "code.gitea.io/gitea/modules/structs"
21	)	21	)
22		22
23	func handleLockListOut(ctx context.Context, repo repo_model.Repository, lock *models.LFSLock, err error) {	23	func handleLockListOut(ctx context.Context, repo repo_model.Repository, lock *git_model.LFSLock, err error) {
24	if err != nil {	24	if err != nil {
25	if models.IsErrLFSLockNotExist(err) {	25	if git_model.IsErrLFSLockNotExist(err) {
26	ctx.JSON(http.StatusOK, api.LFSLockList{	26	ctx.JSON(http.StatusOK, api.LFSLockList{
27	Locks: []*api.LFSLock{},	27	Locks: []*api.LFSLock{},
28	})	28	})
@@ -88,8 +88,8 @@ func GetListLockHandler(ctx *context.Context) { · 59 unmodified lines
88	})	88	})
89	return	89	return
90	}	90	}
91	lock, err := models.GetLFSLockByID(ctx, v)	91	lock, err := git_model.GetLFSLockByID(ctx, v)
92	if err != nil && !models.IsErrLFSLockNotExist(err) {	92	if err != nil && !git_model.IsErrLFSLockNotExist(err) {
93	log.Error("Unable to get lock with ID[%s]: Error: %v", v, err)	93	log.Error("Unable to get lock with ID[%s]: Error: %v", v, err)
94	}	94	}
95	handleLockListOut(ctx, repository, lock, err)	95	handleLockListOut(ctx, repository, lock, err)
@@ -98,8 +98,8 @@ func GetListLockHandler(ctx *context.Context) { · 2 unmodified lines
98		98
99	path := ctx.FormString("path")	99	path := ctx.FormString("path")
100	if path != "" { // Case where we request a specific id	100	if path != "" { // Case where we request a specific id
101	lock, err := models.GetLFSLock(ctx, repository, path)	101	lock, err := git_model.GetLFSLock(ctx, repository, path)
102	if err != nil && !models.IsErrLFSLockNotExist(err) {	102	if err != nil && !git_model.IsErrLFSLockNotExist(err) {
103	log.Error("Unable to get lock for repository %-v with path %s: Error: %v", repository, path, err)	103	log.Error("Unable to get lock for repository %-v with path %s: Error: %v", repository, path, err)
104	}	104	}
105	handleLockListOut(ctx, repository, lock, err)	105	handleLockListOut(ctx, repository, lock, err)
@@ -107,7 +107,7 @@ func GetListLockHandler(ctx *context.Context) { · 1 unmodified line
107	}	107	}
108		108
109	// If no query params path or id	109	// If no query params path or id
110	lockList, err := models.GetLFSLockByRepoID(repository.ID, cursor, limit)	110	lockList, err := git_model.GetLFSLockByRepoID(repository.ID, cursor, limit)
111	if err != nil {	111	if err != nil {
112	log.Error("Unable to list locks for repository ID[%d]: Error: %v", repository.ID, err)	112	log.Error("Unable to list locks for repository ID[%d]: Error: %v", repository.ID, err)
113	ctx.JSON(http.StatusInternalServerError, api.LFSLockError{	113	ctx.JSON(http.StatusInternalServerError, api.LFSLockError{
@@ -168,19 +168,19 @@ func PostLockHandler(ctx *context.Context) { · 54 unmodified lines
168	return	168	return
169	}	169	}
170		170
171	lock, err := models.CreateLFSLock(repository, &models.LFSLock{	171	lock, err := git_model.CreateLFSLock(repository, &git_model.LFSLock{
172	Path: req.Path,	172	Path: req.Path,
173	OwnerID: ctx.Doer.ID,	173	OwnerID: ctx.Doer.ID,
174	})	174	})
175	if err != nil {	175	if err != nil {
176	if models.IsErrLFSLockAlreadyExist(err) {	176	if git_model.IsErrLFSLockAlreadyExist(err) {
177	ctx.JSON(http.StatusConflict, api.LFSLockError{	177	ctx.JSON(http.StatusConflict, api.LFSLockError{
178	Lock: convert.ToLFSLock(lock),	178	Lock: convert.ToLFSLock(lock),
179	Message: "already created lock",	179	Message: "already created lock",
180	})	180	})
181	return	181	return
182	}	182	}
183	if models.IsErrLFSUnauthorizedAction(err) {	183	if git_model.IsErrLFSUnauthorizedAction(err) {
184	ctx.Resp.Header().Set("WWW-Authenticate", "Basic realm=gitea-lfs")	184	ctx.Resp.Header().Set("WWW-Authenticate", "Basic realm=gitea-lfs")
185	ctx.JSON(http.StatusUnauthorized, api.LFSLockError{	185	ctx.JSON(http.StatusUnauthorized, api.LFSLockError{
186	Message: "You must have push access to create locks : " + err.Error(),	186	Message: "You must have push access to create locks : " + err.Error(),
@@ -234,7 +234,7 @@ func VerifyLockHandler(ctx *context.Context) { · 47 unmodified lines
234	} else if limit < 0 {	234	} else if limit < 0 {
235	limit = 0	235	limit = 0
236	}	236	}
237	lockList, err := models.GetLFSLockByRepoID(repository.ID, cursor, limit)	237	lockList, err := git_model.GetLFSLockByRepoID(repository.ID, cursor, limit)
238	if err != nil {	238	if err != nil {
239	log.Error("Unable to list locks for repository ID[%d]: Error: %v", repository.ID, err)	239	log.Error("Unable to list locks for repository ID[%d]: Error: %v", repository.ID, err)
240	ctx.JSON(http.StatusInternalServerError, api.LFSLockError{	240	ctx.JSON(http.StatusInternalServerError, api.LFSLockError{
@@ -301,9 +301,9 @@ func UnLockHandler(ctx *context.Context) { · 60 unmodified lines
301	return	301	return
302	}	302	}
303		303
304	lock, err := models.DeleteLFSLockByID(ctx.ParamsInt64("lid"), repository, ctx.Doer, req.Force)	304	lock, err := git_model.DeleteLFSLockByID(ctx.ParamsInt64("lid"), repository, ctx.Doer, req.Force)
305	if err != nil {	305	if err != nil {
306	if models.IsErrLFSUnauthorizedAction(err) {	306	if git_model.IsErrLFSUnauthorizedAction(err) {
307	ctx.Resp.Header().Set("WWW-Authenticate", "Basic realm=gitea-lfs")	307	ctx.Resp.Header().Set("WWW-Authenticate", "Basic realm=gitea-lfs")
308	ctx.JSON(http.StatusUnauthorized, api.LFSLockError{	308	ctx.JSON(http.StatusUnauthorized, api.LFSLockError{
309	Message: "You must have push access to delete locks : " + err.Error(),	309	Message: "You must have push access to delete locks : " + err.Error(),

services/lfs/server.go+10−10

@@ -18,7 +18,7 @@ import ( · 17 unmodified lines
18	"strconv"	18	"strconv"
19	"strings"	19	"strings"
20		20
21	"code.gitea.io/gitea/models"	21	git_model "code.gitea.io/gitea/models/git"
22	"code.gitea.io/gitea/models/perm"	22	"code.gitea.io/gitea/models/perm"
23	access_model "code.gitea.io/gitea/models/perm/access"	23	access_model "code.gitea.io/gitea/models/perm/access"
24	repo_model "code.gitea.io/gitea/models/repo"	24	repo_model "code.gitea.io/gitea/models/repo"
@@ -197,8 +197,8 @@ func BatchHandler(ctx *context.Context) { · 172 unmodified lines
197	return	197	return
198	}	198	}
199		199
200	meta, err := models.GetLFSMetaObjectByOid(repository.ID, p.Oid)	200	meta, err := git_model.GetLFSMetaObjectByOid(repository.ID, p.Oid)
201	if err != nil && err != models.ErrLFSObjectNotExist {	201	if err != nil && err != git_model.ErrLFSObjectNotExist {
202	log.Error("Unable to get LFS MetaObject [%s] for %s/%s. Error: %v", p.Oid, rc.User, rc.Repo, err)	202	log.Error("Unable to get LFS MetaObject [%s] for %s/%s. Error: %v", p.Oid, rc.User, rc.Repo, err)
203	writeStatus(ctx, http.StatusInternalServerError)	203	writeStatus(ctx, http.StatusInternalServerError)
204	return	204	return
@@ -223,14 +223,14 @@ func BatchHandler(ctx *context.Context) { · 18 unmodified lines
223	}	223	}
224		224
225	if exists && meta == nil {	225	if exists && meta == nil {
226	accessible, err := models.LFSObjectAccessible(ctx.Doer, p.Oid)	226	accessible, err := git_model.LFSObjectAccessible(ctx.Doer, p.Oid)
227	if err != nil {	227	if err != nil {
228	log.Error("Unable to check if LFS MetaObject [%s] is accessible. Error: %v", p.Oid, err)	228	log.Error("Unable to check if LFS MetaObject [%s] is accessible. Error: %v", p.Oid, err)
229	writeStatus(ctx, http.StatusInternalServerError)	229	writeStatus(ctx, http.StatusInternalServerError)
230	return	230	return
231	}	231	}
232	if accessible {	232	if accessible {
233	_, err := models.NewLFSMetaObject(&models.LFSMetaObject{Pointer: p, RepositoryID: repository.ID})	233	_, err := git_model.NewLFSMetaObject(&git_model.LFSMetaObject{Pointer: p, RepositoryID: repository.ID})
234	if err != nil {	234	if err != nil {
235	log.Error("Unable to create LFS MetaObject [%s] for %s/%s. Error: %v", p.Oid, rc.User, rc.Repo, err)	235	log.Error("Unable to create LFS MetaObject [%s] for %s/%s. Error: %v", p.Oid, rc.User, rc.Repo, err)
236	writeStatus(ctx, http.StatusInternalServerError)	236	writeStatus(ctx, http.StatusInternalServerError)
@@ -297,7 +297,7 @@ func UploadHandler(ctx *context.Context) { · 60 unmodified lines
297		297
298	uploadOrVerify := func() error {	298	uploadOrVerify := func() error {
299	if exists {	299	if exists {
300	accessible, err := models.LFSObjectAccessible(ctx.Doer, p.Oid)	300	accessible, err := git_model.LFSObjectAccessible(ctx.Doer, p.Oid)
301	if err != nil {	301	if err != nil {
302	log.Error("Unable to check if LFS MetaObject [%s] is accessible. Error: %v", p.Oid, err)	302	log.Error("Unable to check if LFS MetaObject [%s] is accessible. Error: %v", p.Oid, err)
303	return err	303	return err
@@ -323,7 +323,7 @@ func UploadHandler(ctx *context.Context) { · 19 unmodified lines
323	log.Error("Error putting LFS MetaObject [%s] into content store. Error: %v", p.Oid, err)	323	log.Error("Error putting LFS MetaObject [%s] into content store. Error: %v", p.Oid, err)
324	return err	324	return err
325	}	325	}
326	_, err := models.NewLFSMetaObject(&models.LFSMetaObject{Pointer: p, RepositoryID: repository.ID})	326	_, err := git_model.NewLFSMetaObject(&git_model.LFSMetaObject{Pointer: p, RepositoryID: repository.ID})
327	return err	327	return err
328	}	328	}
329		329
@@ -335,7 +335,7 @@ func UploadHandler(ctx *context.Context) { · 5 unmodified lines
335	} else {	335	} else {
336	writeStatus(ctx, http.StatusInternalServerError)	336	writeStatus(ctx, http.StatusInternalServerError)
337	}	337	}
338	if _, err = models.RemoveLFSMetaObjectByOid(repository.ID, p.Oid); err != nil {	338	if _, err = git_model.RemoveLFSMetaObjectByOid(repository.ID, p.Oid); err != nil {
339	log.Error("Error whilst removing metaobject for LFS OID[%s]: %v", p.Oid, err)	339	log.Error("Error whilst removing metaobject for LFS OID[%s]: %v", p.Oid, err)
340	}	340	}
341	return	341	return
@@ -386,7 +386,7 @@ func getRequestContext(ctx context.Context) requestContext { · 44 unmodified lines
386	}	386	}
387	}	387	}
388		388
389	func getAuthenticatedMeta(ctx context.Context, rc requestContext, p lfs_module.Pointer, requireWrite bool) *models.LFSMetaObject {	389	func getAuthenticatedMeta(ctx context.Context, rc requestContext, p lfs_module.Pointer, requireWrite bool) *git_model.LFSMetaObject {
390	if !p.IsValid() {	390	if !p.IsValid() {
391	log.Info("Attempt to access invalid LFS OID[%s] in %s/%s", p.Oid, rc.User, rc.Repo)	391	log.Info("Attempt to access invalid LFS OID[%s] in %s/%s", p.Oid, rc.User, rc.Repo)
392	writeStatusMessage(ctx, http.StatusUnprocessableEntity, "Oid or size are invalid")	392	writeStatusMessage(ctx, http.StatusUnprocessableEntity, "Oid or size are invalid")
@@ -398,7 +398,7 @@ func getAuthenticatedMeta(ctx context.Context, rc requestContext, p lfs_module · 5 unmodified lines
398	return nil	398	return nil
399	}	399	}
400		400
401	meta, err := models.GetLFSMetaObjectByOid(repository.ID, p.Oid)	401	meta, err := git_model.GetLFSMetaObjectByOid(repository.ID, p.Oid)
402	if err != nil {	402	if err != nil {
403	log.Error("Unable to get LFS OID[%s] Error: %v", p.Oid, err)	403	log.Error("Unable to get LFS OID[%s] Error: %v", p.Oid, err)
404	writeStatus(ctx, http.StatusNotFound)	404	writeStatus(ctx, http.StatusNotFound)

services/pull/commit_status.go+7−6

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/modules/git"
 	"code.gitea.io/gitea/modules/structs"
 )
 // MergeRequiredContextsCommitStatus returns a commit status state for given required contexts
-func MergeRequiredContextsCommitStatus(commitStatuses []*models.CommitStatus, requiredContexts []string) structs.CommitStatusState {
+func MergeRequiredContextsCommitStatus(commitStatuses []*git_model.CommitStatus, requiredContexts []string) structs.CommitStatusState {
 	if len(requiredContexts) == 0 {
-		status := models.CalcCommitStatus(commitStatuses)
+		status := git_model.CalcCommitStatus(commitStatuses)
 		if status != nil {
 			return status.State
 		}
 		if targetStatus == "" {
 			targetStatus = structs.CommitStatusPending
-			commitStatuses = append(commitStatuses, &models.CommitStatus{
+			commitStatuses = append(commitStatuses, &git_model.CommitStatus{
 				State:       targetStatus,
 				Context:     ctx,
 				Description: "Pending",
 }
 // IsCommitStatusContextSuccess returns true if all required status check contexts succeed.
-func IsCommitStatusContextSuccess(commitStatuses []*models.CommitStatus, requiredContexts []string) bool {
+func IsCommitStatusContextSuccess(commitStatuses []*git_model.CommitStatus, requiredContexts []string) bool {
 	// If no specific context is required, require that last commit status is a success
 	if len(requiredContexts) == 0 {
-		status := models.CalcCommitStatus(commitStatuses)
+		status := git_model.CalcCommitStatus(commitStatuses)
 		if status == nil || status.State != structs.CommitStatusSuccess {
 			return false
 		}
 		return "", errors.Wrap(err, "LoadBaseRepo")
 	}
-	commitStatuses, _, err := models.GetLatestCommitStatus(ctx, pr.BaseRepo.ID, sha, db.ListOptions{})
+	commitStatuses, _, err := git_model.GetLatestCommitStatus(ctx, pr.BaseRepo.ID, sha, db.ListOptions{})
 	if err != nil {
 		return "", errors.Wrap(err, "GetLatestCommitStatus")
 	}

services/pull/lfs.go+5−4

 	"sync"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	"code.gitea.io/gitea/modules/git/pipeline"
 	"code.gitea.io/gitea/modules/lfs"
 	"code.gitea.io/gitea/modules/log"
 		}
 		// Then we need to check that this pointer is in the db
-		if _, err := models.GetLFSMetaObjectByOid(pr.HeadRepo.ID, pointer.Oid); err != nil {
+		if _, err := git_model.GetLFSMetaObjectByOid(pr.HeadRepo.ID, pointer.Oid); err != nil {
-			if err == models.ErrLFSObjectNotExist {
+			if err == git_model.ErrLFSObjectNotExist {
 				log.Warn("During merge of: %d in %-v, there is a pointer to LFS Oid: %s which although present in the LFS store is not associated with the head repo %-v", pr.Index, pr.BaseRepo, pointer.Oid, pr.HeadRepo)
 				continue
 			}
 		// OK we have a pointer that is associated with the head repo
 		// and is actually a file in the LFS
 		// Therefore it should be associated with the base repo
-		meta := &models.LFSMetaObject{Pointer: pointer}
+		meta := &git_model.LFSMetaObject{Pointer: pointer}
 		meta.RepositoryID = pr.BaseRepoID
-		if _, err := models.NewLFSMetaObject(meta); err != nil {
+		if _, err := git_model.NewLFSMetaObject(meta); err != nil {
 			_ = catFileBatchReader.CloseWithError(err)
 			break
 		}

services/pull/merge.go+7−6

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	access_model "code.gitea.io/gitea/models/perm/access"
 	pull_model "code.gitea.io/gitea/models/pull"
 	repo_model "code.gitea.io/gitea/models/repo"
 		return false, err
 	}
-	if (p.CanWrite(unit.TypeCode) && pr.ProtectedBranch == nil) || (pr.ProtectedBranch != nil && models.IsUserMergeWhitelisted(ctx, pr.ProtectedBranch, user.ID, p)) {
+	if (p.CanWrite(unit.TypeCode) && pr.ProtectedBranch == nil) || (pr.ProtectedBranch != nil && git_model.IsUserMergeWhitelisted(ctx, pr.ProtectedBranch, user.ID, p)) {
 		return true, nil
 	}
 		}
 	}
-	if !pr.ProtectedBranch.HasEnoughApprovals(ctx, pr) {
+	if !models.HasEnoughApprovals(ctx, pr.ProtectedBranch, pr) {
 		return models.ErrDisallowedToMerge{
 			Reason: "Does not have enough approvals",
 		}
 	}
-	if pr.ProtectedBranch.MergeBlockedByRejectedReview(ctx, pr) {
+	if models.MergeBlockedByRejectedReview(ctx, pr.ProtectedBranch, pr) {
 		return models.ErrDisallowedToMerge{
 			Reason: "There are requested changes",
 		}
 	}
-	if pr.ProtectedBranch.MergeBlockedByOfficialReviewRequests(ctx, pr) {
+	if models.MergeBlockedByOfficialReviewRequests(ctx, pr.ProtectedBranch, pr) {
 		return models.ErrDisallowedToMerge{
 			Reason: "There are official review requests",
 		}
 	}
-	if pr.ProtectedBranch.MergeBlockedByOutdatedBranch(pr) {
+	if models.MergeBlockedByOutdatedBranch(pr.ProtectedBranch, pr) {
 		return models.ErrDisallowedToMerge{
 			Reason: "The head branch is behind the base branch",
 		}
 		return nil
 	}
-	if pr.ProtectedBranch.MergeBlockedByProtectedFiles(pr) {
+	if pr.ProtectedBranch.MergeBlockedByProtectedFiles(pr.ChangedProtectedFiles) {
 		return models.ErrDisallowedToMerge{
 			Reason: "Changed protected files",
 		}

services/pull/pull.go+8−7

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 }
 // GetIssuesLastCommitStatus returns a map of issue ID to the most recent commit's latest status
-func GetIssuesLastCommitStatus(ctx context.Context, issues models.IssueList) (map[int64]*models.CommitStatus, error) {
+func GetIssuesLastCommitStatus(ctx context.Context, issues models.IssueList) (map[int64]*git_model.CommitStatus, error) {
 	_, lastStatus, err := GetIssuesAllCommitStatus(ctx, issues)
 	return lastStatus, err
 }
 // GetIssuesAllCommitStatus returns a map of issue ID to a list of all statuses for the most recent commit as well as a map of issue ID to only the commit's latest status
-func GetIssuesAllCommitStatus(ctx context.Context, issues models.IssueList) (map[int64][]*models.CommitStatus, map[int64]*models.CommitStatus, error) {
+func GetIssuesAllCommitStatus(ctx context.Context, issues models.IssueList) (map[int64][]*git_model.CommitStatus, map[int64]*git_model.CommitStatus, error) {
 	if err := issues.LoadPullRequests(); err != nil {
 		return nil, nil, err
 	}
 	var (
 		gitRepos = make(map[int64]*git.Repository)
-		res      = make(map[int64][]*models.CommitStatus)
+		res      = make(map[int64][]*git_model.CommitStatus)
-		lastRes  = make(map[int64]*models.CommitStatus)
+		lastRes  = make(map[int64]*git_model.CommitStatus)
 		err      error
 	)
 	defer func() {
 }
 // getAllCommitStatus get pr's commit statuses.
-func getAllCommitStatus(gitRepo *git.Repository, pr *models.PullRequest) (statuses []*models.CommitStatus, lastStatus *models.CommitStatus, err error) {
+func getAllCommitStatus(gitRepo *git.Repository, pr *models.PullRequest) (statuses []*git_model.CommitStatus, lastStatus *git_model.CommitStatus, err error) {
 	sha, shaErr := gitRepo.GetRefCommitID(pr.GetGitRefName())
 	if shaErr != nil {
 		return nil, nil, shaErr
 	}
-	statuses, _, err = models.GetLatestCommitStatus(db.DefaultContext, pr.BaseRepo.ID, sha, db.ListOptions{})
+	statuses, _, err = git_model.GetLatestCommitStatus(db.DefaultContext, pr.BaseRepo.ID, sha, db.ListOptions{})
-	lastStatus = models.CalcCommitStatus(statuses)
+	lastStatus = git_model.CalcCommitStatus(statuses)
 	return statuses, lastStatus, err
 }

services/release/release.go+3−2

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 				return false, err
 			}
-			protectedTags, err := models.GetProtectedTags(rel.Repo.ID)
+			protectedTags, err := git_model.GetProtectedTags(rel.Repo.ID)
 			if err != nil {
 				return false, fmt.Errorf("GetProtectedTags: %v", err)
 			}
-			isAllowed, err := models.IsUserAllowedToControlTag(protectedTags, rel.TagName, rel.PublisherID)
+			isAllowed, err := git_model.IsUserAllowedToControlTag(protectedTags, rel.TagName, rel.PublisherID)
 			if err != nil {
 				return false, err
 			}

services/repository/branch.go+4−3

 	"strings"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 		return "from_not_exist", nil
 	}
-	if err := models.RenameBranch(repo, from, to, func(isDefault bool) error {
+	if err := git_model.RenameBranch(repo, from, to, func(isDefault bool) error {
 		err2 := gitRepo.RenameBranch(from, to)
 		if err2 != nil {
 			return err2
 		return ErrBranchIsDefault
 	}
-	isProtected, err := models.IsProtectedBranch(repo.ID, branchName)
+	isProtected, err := git_model.IsProtectedBranch(repo.ID, branchName)
 	if err != nil {
 		return err
 	}
 		log.Error("Update: %v", err)
 	}
-	if err := models.AddDeletedBranch(repo.ID, branchName, commit.ID.String(), doer.ID); err != nil {
+	if err := git_model.AddDeletedBranch(repo.ID, branchName, commit.ID.String(), doer.ID); err != nil {
 		log.Warn("AddDeletedBranch: %v", err)
 	}

services/repository/files/commit.go+3−3

 	"context"
 	"fmt"
-	"code.gitea.io/gitea/models"
 	asymkey_model "code.gitea.io/gitea/models/asymkey"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 // CreateCommitStatus creates a new CommitStatus given a bunch of parameters
 // NOTE: All text-values will be trimmed from whitespaces.
 // Requires: Repo, Creator, SHA
-func CreateCommitStatus(ctx context.Context, repo *repo_model.Repository, creator *user_model.User, sha string, status *models.CommitStatus) error {
+func CreateCommitStatus(ctx context.Context, repo *repo_model.Repository, creator *user_model.User, sha string, status *git_model.CommitStatus) error {
 	repoPath := repo.RepoPath()
 	// confirm that commit is exist
 	}
 	gitRepo.Close()
-	if err := models.NewCommitStatus(models.NewCommitStatusOptions{
+	if err := git_model.NewCommitStatus(git_model.NewCommitStatusOptions{
 		Repo:         repo,
 		Creator:      creator,
 		SHA:          sha,

services/repository/files/patch.go+2−1

 	"strings"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 			return err
 		}
 	} else {
-		protectedBranch, err := models.GetProtectedBranchBy(ctx, repo.ID, opts.OldBranch)
+		protectedBranch, err := git_model.GetProtectedBranchBy(ctx, repo.ID, opts.OldBranch)
 		if err != nil {
 			return err
 		}

services/repository/files/update.go+8−7

 	"time"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/charset"
 	if setting.LFS.StartServer {
 		pointer, _ := lfs.ReadPointerFromBuffer(buf)
 		if pointer.IsValid() {
-			meta, err := models.GetLFSMetaObjectByOid(repo.ID, pointer.Oid)
+			meta, err := git_model.GetLFSMetaObjectByOid(repo.ID, pointer.Oid)
-			if err != nil && err != models.ErrLFSObjectNotExist {
+			if err != nil && err != git_model.ErrLFSObjectNotExist {
 				// return default
 				return "UTF-8", false
 			}
 	}
 	// Reset the opts.Content to our adjusted content to ensure that LFS gets the correct content
 	opts.Content = content
-	var lfsMetaObject *models.LFSMetaObject
+	var lfsMetaObject *git_model.LFSMetaObject
 	if setting.LFS.StartServer && hasOldBranch {
 		// Check there is no way this can return multiple infos
 			if err != nil {
 				return nil, err
 			}
-			lfsMetaObject = &models.LFSMetaObject{Pointer: pointer, RepositoryID: repo.ID}
+			lfsMetaObject = &git_model.LFSMetaObject{Pointer: pointer, RepositoryID: repo.ID}
 			content = pointer.StringContent()
 		}
 	}
 	if lfsMetaObject != nil {
 		// We have an LFS object - create it
-		lfsMetaObject, err = models.NewLFSMetaObject(lfsMetaObject)
+		lfsMetaObject, err = git_model.NewLFSMetaObject(lfsMetaObject)
 		if err != nil {
 			return nil, err
 		}
 		}
 		if !exist {
 			if err := contentStore.Put(lfsMetaObject.Pointer, strings.NewReader(opts.Content)); err != nil {
-				if _, err2 := models.RemoveLFSMetaObjectByOid(repo.ID, lfsMetaObject.Oid); err2 != nil {
+				if _, err2 := git_model.RemoveLFSMetaObjectByOid(repo.ID, lfsMetaObject.Oid); err2 != nil {
 					return nil, fmt.Errorf("Error whilst removing failed inserted LFS object %s: %v (Prev Error: %v)", lfsMetaObject.Oid, err2, err)
 				}
 				return nil, err
 // VerifyBranchProtection verify the branch protection for modifying the given treePath on the given branch
 func VerifyBranchProtection(ctx context.Context, repo *repo_model.Repository, doer *user_model.User, branchName, treePath string) error {
-	protectedBranch, err := models.GetProtectedBranchBy(ctx, repo.ID, branchName)
+	protectedBranch, err := git_model.GetProtectedBranchBy(ctx, repo.ID, branchName)
 	if err != nil {
 		return err
 	}

services/repository/files/upload.go+7−6

 	"strings"
 	"code.gitea.io/gitea/models"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 type uploadInfo struct {
 	upload        *models.Upload
-	lfsMetaObject *models.LFSMetaObject
+	lfsMetaObject *git_model.LFSMetaObject
 }
 func cleanUpAfterFailure(infos *[]uploadInfo, t *TemporaryUploadRepository, original error) error {
 			continue
 		}
 		if !info.lfsMetaObject.Existing {
-			if _, err := models.RemoveLFSMetaObjectByOid(t.repo.ID, info.lfsMetaObject.Oid); err != nil {
+			if _, err := git_model.RemoveLFSMetaObjectByOid(t.repo.ID, info.lfsMetaObject.Oid); err != nil {
 				original = fmt.Errorf("%v, %v", original, err)
 			}
 		}
 	for i, upload := range uploads {
 		// Check file is not lfs locked, will return nil if lock setting not enabled
 		filepath := path.Join(opts.TreePath, upload.Name)
-		lfsLock, err := models.GetTreePathLock(repo.ID, filepath)
+		lfsLock, err := git_model.GetTreePathLock(repo.ID, filepath)
 		if err != nil {
 			return err
 		}
 			if err != nil {
 				return err
 			}
-			return models.ErrLFSFileLocked{RepoID: repo.ID, Path: filepath, UserName: u.Name}
+			return git_model.ErrLFSFileLocked{RepoID: repo.ID, Path: filepath, UserName: u.Name}
 		}
 		names[i] = upload.Name
 		if infos[i].lfsMetaObject == nil {
 			continue
 		}
-		infos[i].lfsMetaObject, err = models.NewLFSMetaObject(infos[i].lfsMetaObject)
+		infos[i].lfsMetaObject, err = git_model.NewLFSMetaObject(infos[i].lfsMetaObject)
 		if err != nil {
 			// OK Now we need to cleanup
 			return cleanUpAfterFailure(&infos, t, err)
 			return err
 		}
-		info.lfsMetaObject = &models.LFSMetaObject{Pointer: pointer, RepositoryID: t.repo.ID}
+		info.lfsMetaObject = &git_model.LFSMetaObject{Pointer: pointer, RepositoryID: t.repo.ID}
 		if objectHash, err = t.HashObject(strings.NewReader(pointer.StringContent())); err != nil {
 			return err

services/repository/fork.go+2−1

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
 		}
 		// copy lfs files failure should not be ignored
-		if err = models.CopyLFS(txCtx, repo, opts.BaseRepo); err != nil {
+		if err = git_model.CopyLFS(txCtx, repo, opts.BaseRepo); err != nil {
 			return err
 		}

services/repository/push.go+2−1

 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
+	git_model "code.gitea.io/gitea/models/git"
 	repo_model "code.gitea.io/gitea/models/repo"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/cache"
 				notification.NotifyPushCommits(pusher, repo, opts, commits)
-				if err = models.RemoveDeletedBranchByName(repo.ID, branch); err != nil {
+				if err = git_model.RemoveDeletedBranchByName(repo.ID, branch); err != nil {
 					log.Error("models.RemoveDeletedBranch %s/%s failed: %v", repo.ID, branch, err)
 				}