[need-help] Add pinned mod for repo

models/error.go

@@ -282,6 +282,38 @@ func (err ErrReachLimitOfRepo) Error() string {
 	return fmt.Sprintf("user has reached maximum limit of repositories [limit: %d]", err.Limit)
 }
 
+// ErrUserPinnedRepoAlreadyExist represents a "UserPinnedRepo already exist" kind of error.
+type ErrUserPinnedRepoAlreadyExist struct {
+	UID    int64
+	RepoID int64
+}
+
+// IsErrUserPinnedRepoAlreadyExist checks if an error is a ErrUserPinnedRepoAlreadyExist.
+func IsErrUserPinnedRepoAlreadyExist(err error) bool {
+	_, ok := err.(ErrUserPinnedRepoAlreadyExist)
+	return ok
+}
+
+func (err ErrUserPinnedRepoAlreadyExist) Error() string {
+	return fmt.Sprintf("user has pinned this repo [uid: %d, repo_id: %d]", err.UID, err.RepoID)
+}
+
+// ErrUserPinnedRepoNotExist represents a "UserPinnedRepo not exist" kind of error.
+type ErrUserPinnedRepoNotExist struct {
+	UID    int64
+	RepoID int64
+}
+
+// IsErrUserPinnedRepoNotExist checks if an error is a ErrUserPinnedRepoNotExist.
+func IsErrUserPinnedRepoNotExist(err error) bool {
+	_, ok := err.(ErrUserPinnedRepoNotExist)
+	return ok
+}
+
+func (err ErrUserPinnedRepoNotExist) Error() string {
+	return fmt.Sprintf("user hasn't pinned this repo [uid: %d, repo_id: %d]", err.UID, err.RepoID)
+}
+
 //  __      __.__ __   .__
 // /  \    /  \__|  | _|__|
 // \   \/\/   /  |  |/ /  |

models/fixtures/user_pinned_repo.yml

@@ -0,0 +1,15 @@
+-
+  uid: 2
+  repo_id: 1
+
+-
+  uid: 6
+  repo_id: 1
+
+-
+  uid: 2
+  repo_id: 4
+
+-
+  uid: 2
+  repo_id: 16

models/migrations/migrations.go

@@ -254,6 +254,8 @@ var migrations = []Migration{
 	NewMigration("code comment replies should have the commitID of the review they are replying to", updateCodeCommentReplies),
 	// v159 -> v160
 	NewMigration("update reactions constraint", updateReactionConstraint),
+	// v160 -> v161
+	NewMigration("Add user_pinned_repo table", addUserPinnedRepoTable),
 }
 
 // GetCurrentDBVersion returns the current db version

models/migrations/v160.go

@@ -0,0 +1,19 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package migrations
+
+import (
+	"xorm.io/xorm"
+)
+
+func addUserPinnedRepoTable(x *xorm.Engine) error {
+
+	type UserPinnedRepo struct {
+		UID    int64 `xorm:"pk INDEX NOT NULL"`
+		RepoID int64 `xorm:"pk NOT NULL"`
+	}
+
+	return x.Sync2(new(UserPinnedRepo))
+}

models/models.go

@@ -131,6 +131,7 @@ func init() {
 		new(Project),
 		new(ProjectBoard),
 		new(ProjectIssue),
+		new(UserPinnedRepo),
 	)
 
 	gonicNames := []string{"SSL", "UID"}

models/repo.go

@@ -241,6 +241,8 @@ type Repository struct {
 	// Avatar: ID(10-20)-md5(32) - must fit into 64 symbols
 	Avatar string `xorm:"VARCHAR(64)"`
 
+	IsPinned bool `xorm:"-"`
+
 	CreatedUnix timeutil.TimeStamp `xorm:"INDEX created"`
 	UpdatedUnix timeutil.TimeStamp `xorm:"INDEX updated"`
 }
@@ -1696,6 +1698,7 @@ func DeleteRepository(doer *User, uid, repoID int64) error {
 		&LanguageStat{RepoID: repoID},
 		&Comment{RefRepoID: repoID},
 		&Task{RepoID: repoID},
+		&UserPinnedRepo{RepoID: repoID},
 	); err != nil {
 		return fmt.Errorf("deleteBeans: %v", err)
 	}

models/user.go

@@ -1082,6 +1082,7 @@ func deleteUser(e *xorm.Session, u *User) error {
 		&TeamUser{UID: u.ID},
 		&Collaboration{UserID: u.ID},
 		&Stopwatch{UserID: u.ID},
+		&UserPinnedRepo{UID: u.ID},
 	); err != nil {
 		return fmt.Errorf("deleteBeans: %v", err)
 	}

models/user_pinnedrepo.go

@@ -0,0 +1,82 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package models
+
+import (
+	"code.gitea.io/gitea/modules/structs"
+
+	"xorm.io/builder"
+)
+
+// UserPinnedRepo represents a pinned repo by an user or org.
+type UserPinnedRepo struct {
+	UID    int64 `xorm:"pk INDEX NOT NULL"`
+	RepoID int64 `xorm:"pk NOT NULL"`
+}
+
+// AddPinnedRepo add a pinned repo
+func (u *User) AddPinnedRepo(repo *Repository) (err error) {
+	exist := false
+	if exist, err = u.IsPinnedRepoExist(repo.ID); err != nil {
+		return
+	}
+
+	if exist {
+		return ErrUserPinnedRepoAlreadyExist{UID: u.ID, RepoID: repo.ID}
+	}
+
+	r := &UserPinnedRepo{
+		UID:    u.ID,
+		RepoID: repo.ID,
+	}
+
+	_, err = x.Insert(r)
+	return
+}
+
+// RemovePinnedRepo remove a pinned repo
+func (u *User) RemovePinnedRepo(repoID int64) (err error) {
+	exist := false
+	if exist, err = u.IsPinnedRepoExist(repoID); err != nil {
+		return
+	}
+
+	if !exist {
+		return ErrUserPinnedRepoNotExist{UID: u.ID, RepoID: repoID}
+	}
+
+	_, err = x.Delete(&UserPinnedRepo{UID: u.ID, RepoID: repoID})
+	return
+}
+
+// IsPinnedRepoExist check if this repo is pinned
+func (u *User) IsPinnedRepoExist(repoID int64) (isExist bool, err error) {
+	return x.Exist(&UserPinnedRepo{UID: u.ID, RepoID: repoID})
+}
+
+// GetPinnedRepoIDs get repos id
+func (u *User) GetPinnedRepoIDs(actor *User) (results []int64, err error) {
+	var cond = builder.NewCond()
+	results = make([]int64, 0, 10)
+
+	if actor == nil {
+		if u.IsOrganization() && u.Visibility != structs.VisibleTypePublic {
+			return
+		}
+		cond = cond.And(builder.Eq{"is_private": false})
+	} else if actor.ID != u.ID && !actor.IsAdmin {
+		// OK we're in the context of a User
+		cond = cond.And(accessibleRepositoryCondition(actor))
+	}
+
+	idBuilder := builder.Select("repo_id").
+		From("user_pinned_repo").
+		Where(builder.Eq{"uid": u.ID})
+
+	cond = cond.And(builder.In("id", idBuilder))
+
+	err = x.Table("repository").Cols("id").Where(cond).Find(&results)
+	return
+}

models/user_pinnedrepo_test.go

@@ -0,0 +1,64 @@
+// Copyright 2017 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package models
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAddPinnedRepo(t *testing.T) {
+	assert.NoError(t, PrepareTestDatabase())
+
+	user2 := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
+	repo1 := AssertExistsAndLoadBean(t, &Repository{ID: 1}).(*Repository)
+	repo10 := AssertExistsAndLoadBean(t, &Repository{ID: 10}).(*Repository)
+
+	assert.NoError(t, user2.AddPinnedRepo(repo10))
+	AssertExistsAndLoadBean(t, &UserPinnedRepo{UID: user2.ID, RepoID: repo10.ID})
+
+	assert.EqualError(t, user2.AddPinnedRepo(repo1),
+		ErrUserPinnedRepoAlreadyExist{UID: user2.ID, RepoID: repo1.ID}.Error())
+}
+
+func TestRemovePinnedRepo(t *testing.T) {
+	assert.NoError(t, PrepareTestDatabase())
+
+	user2 := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
+
+	assert.NoError(t, user2.RemovePinnedRepo(1))
+
+	assert.EqualError(t, user2.RemovePinnedRepo(3),
+		ErrUserPinnedRepoNotExist{UID: user2.ID, RepoID: 3}.Error())
+}
+
+func TestIsPinnedRepoExist(t *testing.T) {
+	assert.NoError(t, PrepareTestDatabase())
+
+	user2 := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
+
+	exist, err := user2.IsPinnedRepoExist(1)
+	assert.NoError(t, err)
+	assert.Equal(t, true, exist)
+
+	exist, err = user2.IsPinnedRepoExist(5)
+	assert.NoError(t, err)
+	assert.Equal(t, false, exist)
+}
+
+func TestGetPinnedRepos(t *testing.T) {
+	assert.NoError(t, PrepareTestDatabase())
+
+	user2 := AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
+
+	repoIDs, err := user2.GetPinnedRepoIDs(user2)
+	assert.NoError(t, err)
+	assert.Equal(t, []int64{1, 4, 16}, repoIDs)
+
+	repoIDs, err = user2.GetPinnedRepoIDs(nil)
+	assert.NoError(t, err)
+	assert.Equal(t, []int64{1, 4}, repoIDs)
+}

modules/auth/user_form.go

@@ -360,3 +360,10 @@ type U2FDeleteForm struct {
 func (f *U2FDeleteForm) Validate(ctx *macaron.Context, errs binding.Errors) binding.Errors {
 	return validate(errs, ctx.Data, f, ctx.Locale)
 }
+
+// RepoPinnedForm form for changing repository pinned settings
+type RepoPinnedForm struct {
+	RepoFullName string `binding:"Required" form:"name"`
+	Status       string `binding:"Required;In(pinned,unpinned)"`
+	IsBtn        bool
+}

options/locale/locale_en-US.ini

@@ -228,6 +228,7 @@ issues.in_your_repos = In your repositories
 
 [explore]
 repos = Repositories
+pinned_repos = Pinned repositories
 users = Users
 organizations = Organizations
 search = Search
@@ -461,6 +462,13 @@ uploaded_avatar_not_a_image = The uploaded file is not an image.
 uploaded_avatar_is_too_big = The uploaded file has exceeded the maximum size.
 update_avatar_success = Your avatar has been updated.
 
+pinned_repo = pinned this repo
+unpinned_repo = unpinned this repo
+pinned_other_repo_des = Repo full name
+pinned_other_repo  = Pinned other repo
+pinned_btn = Pinned
+unpinned_btn = Unpinned
+
 change_password = Update Password
 old_password = Current Password
 new_password = New Password

routers/org/home.go

@@ -124,6 +124,54 @@ func Home(ctx *context.Context) {
 		return
 	}
 
+	pinnedRepos := make([]*models.Repository, 0, 10)
+	pinnedRepoIDs, err := ctx.Org.Organization.GetPinnedRepoIDs(ctx.User)
+	if err != nil {
+		ctx.ServerError("GetPinnedRepos", err)
+		return
+	}
+
+	pinnedRepos2 := make(models.RepositoryList, 0, 5)
+	for _, pinnedRepoID := range pinnedRepoIDs {
+		has := false
+		for _, repo := range repos {
+			if repo.ID == pinnedRepoID {
+				has = true
+				repo.IsPinned = true
+				pinnedRepos = append(pinnedRepos, repo)
+				break
+			}
+		}
+
+		if !has {
+			repo, err := models.GetRepositoryByID(pinnedRepoID)
+			if err != nil && !models.IsErrRepoNotExist(err) {
+				ctx.ServerError("GetRepositoryByID", err)
+				return
+			}
+
+			if repo != nil {
+				repo.IsPinned = true
+				pinnedRepos2 = append(pinnedRepos2, repo)
+			}
+		}
+	}
+
+	if len(pinnedRepos2) > 0 {
+		if err = pinnedRepos2.LoadAttributes(); err != nil {
+			ctx.ServerError("pinnedRepos2.LoadAttributes()", err)
+			return
+		}
+		pinnedRepos = append(pinnedRepos, pinnedRepos2...)
+	}
+
+	ctx.Data["PinnedRepos"] = pinnedRepos
+	ctx.Data["PinnedReposNum"] = len(pinnedRepos)
+	ctx.Data["CanConfigPinnedRepos"] = ctx.IsSigned && ctx.Org.IsOwner
+	if ctx.IsSigned && ctx.Org.IsOwner {
+		ctx.Data["ConfigPinnedReposLink"] = ctx.Org.OrgLink + "/settings/pinned_repo"
+	}
+
 	ctx.Data["Owner"] = org
 	ctx.Data["Repos"] = repos
 	ctx.Data["Total"] = count

routers/org/setting.go

@@ -206,3 +206,34 @@ func Labels(ctx *context.Context) {
 	ctx.Data["LabelTemplates"] = models.LabelTemplates
 	ctx.HTML(200, tplSettingsLabels)
 }
+
+// PinnedRepoPost response pinned repo settings
+func PinnedRepoPost(ctx *context.Context, form auth.RepoPinnedForm) {
+	repo, err := models.GetRepositoryByOwnerAndName(ctx.Org.Organization.Name, form.RepoFullName)
+	if err != nil {
+		if models.IsErrRepoNotExist(err) {
+			ctx.Status(404)
+			return
+		}
+
+		ctx.ServerError("models.GetRepositoryByOwnerAndName", err)
+		return
+	}
+
+	if form.Status == "unpinned" {
+		if err = ctx.Org.Organization.RemovePinnedRepo(repo.ID); err != nil && !models.IsErrUserPinnedRepoNotExist(err) {
+			ctx.ServerError("ctx.Org.Organization.RemovePinnedRepo", err)
+			return
+		}
+
+		ctx.Status(200)
+		return
+	}
+
+	if err = ctx.Org.Organization.AddPinnedRepo(repo); err != nil && !models.IsErrUserPinnedRepoAlreadyExist(err) {
+		ctx.ServerError("ctx.Org.Organization.AddPinnedRepo", err)
+		return
+	}
+
+	ctx.Status(200)
+}