Pin Repositories on user page (Fixes #10375)

models/repo/repo.go

@@ -201,6 +201,20 @@ func (repo *Repository) IsBroken() bool {
 	return repo.Status == RepositoryBroken
 }
 
+// IsPinned indicates that repository is pinned
+func (repo *Repository) IsPinned() bool {
+	pinned, err := user_model.GetPinnedRepositoryIDs(repo.OwnerID)
+	if err != nil {
+		return false
+	}
+	for _, r := range pinned {
+		if r == repo.ID {
+			return true
+		}
+	}
+	return false
+}
+
 // AfterLoad is invoked from XORM after setting the values of all fields of this object.
 func (repo *Repository) AfterLoad() {
 	// FIXME: use models migration to solve all at once.

models/repo_list.go

@@ -6,6 +6,7 @@ package models
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"strings"
 
@@ -16,6 +17,7 @@ import (
 	"code.gitea.io/gitea/models/unit"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/container"
+	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/structs"
 	"code.gitea.io/gitea/modules/util"
 
@@ -146,6 +148,10 @@ type SearchRepoOptions struct {
 	// True -> include just archived
 	// False -> include just non-archived
 	Archived util.OptionalBool
+	// None -> include pinned AND non-pinned
+	// True -> include just pinned
+	// False -> include just non-pinned
+	Pinned util.OptionalBool
 	// only search topic name
 	TopicOnly bool
 	// only search repositories with specified primary language
@@ -381,6 +387,33 @@ func SearchRepositoryCondition(opts *SearchRepoOptions) builder.Cond {
 		cond = cond.And(builder.Eq{"is_private": opts.IsPrivate.IsTrue()})
 	}
 
+	if opts.Pinned != util.OptionalBoolNone {
+		pinnedstring, err := user_model.GetUserSetting(opts.OwnerID, "pinned")
+
+		var pinnedIds []int
+		validIds := true
+		if err == nil {
+			jsonerr := json.Unmarshal([]byte(pinnedstring), &pinnedIds)
+			if jsonerr != nil {
+				log.Error("Parsing stored pinned Repo IDs: %v", jsonerr)
+				validIds = false
+			}
+		}
+		pinargs := make([]interface{}, len(pinnedIds))
+		for i := range pinnedIds {
+			pinargs[i] = pinnedIds[i]
+		}
+
+		if validIds {
+			if opts.Pinned == util.OptionalBoolTrue {
+				cond = cond.And(builder.In("id", pinargs...))
+			} else {
+				cond = cond.And(builder.NotIn("id", pinargs...))
+			}
+		}
+
+	}
+
 	if opts.Template != util.OptionalBoolNone {
 		cond = cond.And(builder.Eq{"is_template": opts.Template == util.OptionalBoolTrue})
 	}

models/user/pin.go

@@ -0,0 +1,105 @@
+// Copyright 2016 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 user
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+const maxPinnedRepos = 3
+
+func GetPinnedRepositoryIDs(userID int64) ([]int64, error) {
+	pinnedstring, err := GetUserSetting(userID, PinnedRepositories)
+
+	if err != nil {
+		return nil, err
+	}
+
+	var parsedValues []int64
+	if pinnedstring == "" {
+		return parsedValues, nil
+	}
+
+	err = json.Unmarshal([]byte(pinnedstring), &parsedValues)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return parsedValues, nil
+}
+
+func setPinnedRepositories(userID int64, repos []int64) error {
+	stringed, err := json.Marshal(repos)
+
+	if err != nil {
+		return err
+	}
+
+	return SetUserSetting(userID, PinnedRepositories, string(stringed))
+
+}
+
+type TooManyPinnedReposError struct {
+	count int
+}
+
+func (e *TooManyPinnedReposError) Error() string {
+	return fmt.Sprintf("can pin at most %d repositories, %d pinned repositories is too much", maxPinnedRepos, e.count)
+}
+
+func PinRepos(ownerID int64, repoIDs ...int64) error {
+
+	repos, err := GetPinnedRepositoryIDs(ownerID)
+
+	if err != nil {
+		return err
+	}
+	newrepos := make([]int64, 0, len(repoIDs)+len(repos))
+
+	allrepos := append(repos, repoIDs...)
+
+	for _, toadd := range allrepos {
+		alreadypresent := false
+		for _, present := range newrepos {
+			if toadd == present {
+				alreadypresent = true
+				break
+			}
+		}
+		if !alreadypresent {
+			newrepos = append(newrepos, toadd)
+		}
+	}
+	if len(newrepos) > maxPinnedRepos {
+		return &TooManyPinnedReposError{count: len(newrepos)}
+	}
+	return setPinnedRepositories(ownerID, newrepos)
+}
+
+func UnpinRepos(ownerID int64, repoIDs ...int64) error {
+
+	prevRepos, err := GetPinnedRepositoryIDs(ownerID)
+	if err != nil {
+		return err
+	}
+	var nextRepos []int64
+
+	for _, r := range prevRepos {
+		keep := true
+		for _, unp := range repoIDs {
+			if r == unp {
+				keep = false
+				break
+			}
+		}
+		if keep {
+			nextRepos = append(nextRepos, r)
+		}
+	}
+
+	return setPinnedRepositories(ownerID, nextRepos)
+}

models/user/setting_keys.go

@@ -9,4 +9,5 @@ const (
 	SettingsKeyHiddenCommentTypes = "issue.hidden_comment_types"
 	// SettingsKeyDiffWhitespaceBehavior is the setting key for whitespace behavior of diff
 	SettingsKeyDiffWhitespaceBehavior = "diff.whitespace_behaviour"
+	PinnedRepositories                = "pinned_repos"
 )

routers/web/org/home.go

@@ -11,9 +11,12 @@ import (
 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/models/organization"
+	access "code.gitea.io/gitea/models/perm/access"
 	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/context"
+	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/markup"
 	"code.gitea.io/gitea/modules/markup/markdown"
 	"code.gitea.io/gitea/modules/setting"
@@ -150,8 +153,42 @@ func Home(ctx *context.Context) {
 		return
 	}
 
+	pinnedRepoIDs, err := user_model.GetPinnedRepositoryIDs(org.ID)
+	if err != nil {
+		ctx.ServerError("GetPinnedRepositoryIDs", err)
+		return
+	}
+	pinnedRepos := make([]*repo_model.Repository, 0, len(pinnedRepoIDs))
+	for _, id := range pinnedRepoIDs {
+		repo, err := repo_model.GetRepositoryByID(id)
+
+		if err != nil {
+			ctx.ServerError("GetRepositoryByID", err)
+			return
+		}
+		if err = repo.LoadAttributes(ctx); err != nil {
+			ctx.ServerError("LoadAttributes", err)
+			return
+		}
+		if repo.OwnerID != org.ID {
+			log.Warn("Ignoring pinned repo %v because it's not owned by %v", repo.FullName(), org.Name)
+		} else {
+			access, err := access.GetUserRepoPermission(ctx, repo, ctx.Doer)
+			if err != nil {
+				ctx.ServerError("GetUserRepoPermission", err)
+				return
+			}
+			if !access.HasAccess() {
+				log.Info("Ignoring pinned repo %v because it's not owned by %v", repo.FullName(), org.Name)
+			} else {
+				pinnedRepos = append(pinnedRepos, repo)
+			}
+		}
+	}
+
 	ctx.Data["Owner"] = org
 	ctx.Data["Repos"] = repos
+	ctx.Data["PinnedRepos"] = pinnedRepos
 	ctx.Data["Total"] = count
 	ctx.Data["MembersTotal"] = membersCount
 	ctx.Data["Members"] = members

routers/web/repo/repo.go

@@ -32,6 +32,7 @@ import (
 	"code.gitea.io/gitea/services/forms"
 	repo_service "code.gitea.io/gitea/services/repository"
 	archiver_service "code.gitea.io/gitea/services/repository/archiver"
+	user_service "code.gitea.io/gitea/services/user"
 )
 
 const (
@@ -292,6 +293,22 @@ func Action(ctx *context.Context) {
 		err = repo_model.StarRepo(ctx.Doer.ID, ctx.Repo.Repository.ID, true)
 	case "unstar":
 		err = repo_model.StarRepo(ctx.Doer.ID, ctx.Repo.Repository.ID, false)
+	case "pin":
+		if user_service.CanPin(ctx, ctx.Doer, ctx.Repo.Repository) {
+			err = user_model.PinRepos(ctx.Repo.Owner.ID, ctx.Repo.Repository.ID)
+			if _, ok := err.(*user_model.TooManyPinnedReposError); ok {
+				ctx.Error(http.StatusBadRequest, err.Error())
+				return
+			}
+		} else {
+			err = errors.New("user does not have permission to pin")
+		}
+	case "unpin":
+		if user_service.CanPin(ctx, ctx.Doer, ctx.Repo.Repository) {
+			err = user_model.UnpinRepos(ctx.Repo.Owner.ID, ctx.Repo.Repository.ID)
+		} else {
+			err = errors.New("user does not have permission to unpin")
+		}
 	case "accept_transfer":
 		err = acceptOrRejectRepoTransfer(ctx, true)
 	case "reject_transfer":

routers/web/user/profile.go

@@ -263,6 +263,7 @@ func Profile(ctx *context.Context) {
 			TopicOnly:          topicOnly,
 			Language:           language,
 			IncludeDescription: setting.UI.SearchRepoDescription,
+			Pinned:             util.OptionalBoolFalse,
 		})
 		if err != nil {
 			ctx.ServerError("SearchRepository", err)

services/user/user.go

@@ -18,6 +18,7 @@ import (
 	"code.gitea.io/gitea/models/db"
 	"code.gitea.io/gitea/models/organization"
 	packages_model "code.gitea.io/gitea/models/packages"
+	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"
 	"code.gitea.io/gitea/modules/avatar"
@@ -181,3 +182,8 @@ func DeleteAvatar(u *user_model.User) error {
 	}
 	return nil
 }
+
+func CanPin(ctx context.Context, u *user_model.User, r *repo_model.Repository) bool {
+	perm, err := access_model.GetUserRepoPermission(ctx, r, u)
+	return err == nil && perm.IsAdmin()
+}