[Refactor] Unify repo search order by logic

models/repo/repo_list.go

@@ -205,31 +205,6 @@ type SearchRepoOptions struct {
 	OnlyShowRelevant bool
 }
 
-// SearchOrderBy is used to sort the result
-type SearchOrderBy string
-
-func (s SearchOrderBy) String() string {
-	return string(s)
-}
-
-// Strings for sorting result
-const (
-	SearchOrderByAlphabetically        SearchOrderBy = "name ASC"
-	SearchOrderByAlphabeticallyReverse SearchOrderBy = "name DESC"
-	SearchOrderByLeastUpdated          SearchOrderBy = "updated_unix ASC"
-	SearchOrderByRecentUpdated         SearchOrderBy = "updated_unix DESC"
-	SearchOrderByOldest                SearchOrderBy = "created_unix ASC"
-	SearchOrderByNewest                SearchOrderBy = "created_unix DESC"
-	SearchOrderBySize                  SearchOrderBy = "size ASC"
-	SearchOrderBySizeReverse           SearchOrderBy = "size DESC"
-	SearchOrderByID                    SearchOrderBy = "id ASC"
-	SearchOrderByIDReverse             SearchOrderBy = "id DESC"
-	SearchOrderByStars                 SearchOrderBy = "num_stars ASC"
-	SearchOrderByStarsReverse          SearchOrderBy = "num_stars DESC"
-	SearchOrderByForks                 SearchOrderBy = "num_forks ASC"
-	SearchOrderByForksReverse          SearchOrderBy = "num_forks DESC"
-)
-
 // UserOwnedRepoCond returns user ownered repositories
 func UserOwnedRepoCond(userID int64) builder.Cond {
 	return builder.Eq{

models/repo/search.go

@@ -5,20 +5,70 @@ package repo
 
 import "code.gitea.io/gitea/models/db"
 
+// Strings for sorting result
+const (
+	SearchOrderByAlphabetically        db.SearchOrderBy = "owner_name ASC, name ASC"
+	SearchOrderByAlphabeticallyReverse db.SearchOrderBy = "owner_name DESC, name DESC"
+	SearchOrderByLeastUpdated          db.SearchOrderBy = db.SearchOrderByLeastUpdated
+	SearchOrderByRecentUpdated         db.SearchOrderBy = db.SearchOrderByRecentUpdated
+	SearchOrderByOldest                db.SearchOrderBy = db.SearchOrderByOldest
+	SearchOrderByNewest                db.SearchOrderBy = db.SearchOrderByNewest
+	SearchOrderBySize                  db.SearchOrderBy = db.SearchOrderBySize
+	SearchOrderBySizeReverse           db.SearchOrderBy = db.SearchOrderBySizeReverse
+	SearchOrderByID                    db.SearchOrderBy = db.SearchOrderByID
+	SearchOrderByIDReverse             db.SearchOrderBy = db.SearchOrderByIDReverse
+	SearchOrderByStars                 db.SearchOrderBy = db.SearchOrderByStars
+	SearchOrderByStarsReverse          db.SearchOrderBy = db.SearchOrderByStarsReverse
+	SearchOrderByForks                 db.SearchOrderBy = db.SearchOrderByForks
+	SearchOrderByForksReverse          db.SearchOrderBy = db.SearchOrderByForksReverse
+	SearchOrderByGitSize               db.SearchOrderBy = db.SearchOrderByGitSize
+	SearchOrderByGitSizeReverse        db.SearchOrderBy = db.SearchOrderByGitSizeReverse
+	SearchOrderByLFSSize               db.SearchOrderBy = db.SearchOrderByLFSSize
+	SearchOrderByLFSSizeReverse        db.SearchOrderBy = db.SearchOrderByLFSSizeReverse
+)
+
 // SearchOrderByMap represents all possible search order
 var SearchOrderByMap = map[string]map[string]db.SearchOrderBy{
 	"asc": {
-		"alpha":   "owner_name ASC, name ASC",
-		"created": db.SearchOrderByOldest,
-		"updated": db.SearchOrderByLeastUpdated,
-		"size":    db.SearchOrderBySize,
-		"id":      db.SearchOrderByID,
+		"alpha":     SearchOrderByAlphabetically,
+		"created":   SearchOrderByOldest,
+		"updated":   SearchOrderByLeastUpdated,
+		"size":      SearchOrderBySize,
+		"git_size":  SearchOrderByGitSize,
+		"lfs_size":  SearchOrderByLFSSize,
+		"id":        SearchOrderByID,
+		"num_stars": SearchOrderByStars,
+		"num_forks": SearchOrderByForks,
 	},
 	"desc": {
-		"alpha":   "owner_name DESC, name DESC",
-		"created": db.SearchOrderByNewest,
-		"updated": db.SearchOrderByRecentUpdated,
-		"size":    db.SearchOrderBySizeReverse,
-		"id":      db.SearchOrderByIDReverse,
+		"alpha":     SearchOrderByAlphabeticallyReverse,
+		"created":   SearchOrderByNewest,
+		"updated":   SearchOrderByRecentUpdated,
+		"size":      SearchOrderBySizeReverse,
+		"git_size":  SearchOrderByGitSizeReverse,
+		"lfs_size":  SearchOrderByLFSSizeReverse,
+		"id":        SearchOrderByIDReverse,
+		"num_stars": SearchOrderByStarsReverse,
+		"num_forks": SearchOrderByForksReverse,
 	},
 }
+
+// SearchOrderByFlatMap is similar to SearchOrderByMap but use human language keywords
+// to decide between asc and desc
+var SearchOrderByFlatMap = map[string]db.SearchOrderBy{
+	"newest":                SearchOrderByMap["desc"]["created"],
+	"oldest":                SearchOrderByMap["asc"]["created"],
+	"leastupdate":           SearchOrderByMap["asc"]["updated"],
+	"reversealphabetically": SearchOrderByMap["desc"]["alpha"],
+	"alphabetically":        SearchOrderByMap["asc"]["alpha"],
+	"reversesize":           SearchOrderByMap["desc"]["size"],
+	"size":                  SearchOrderByMap["asc"]["size"],
+	"reversegitsize":        SearchOrderByMap["desc"]["git_size"],
+	"gitsize":               SearchOrderByMap["asc"]["git_size"],
+	"reverselfssize":        SearchOrderByMap["desc"]["lfs_size"],
+	"lfssize":               SearchOrderByMap["asc"]["lfs_size"],
+	"moststars":             SearchOrderByMap["desc"]["num_stars"],
+	"feweststars":           SearchOrderByMap["asc"]["num_stars"],
+	"mostforks":             SearchOrderByMap["desc"]["num_forks"],
+	"fewestforks":           SearchOrderByMap["asc"]["num_forks"],
+}

routers/web/explore/repo.go

@@ -61,43 +61,14 @@ func RenderRepoSearch(ctx *context.Context, opts *RepoSearchOptions) {
 	if sortOrder == "" {
 		sortOrder = setting.UI.ExploreDefaultSort
 	}
-	ctx.Data["SortType"] = sortOrder
 
-	switch sortOrder {
-	case "newest":
-		orderBy = db.SearchOrderByNewest
-	case "oldest":
-		orderBy = db.SearchOrderByOldest
-	case "leastupdate":
-		orderBy = db.SearchOrderByLeastUpdated
-	case "reversealphabetically":
-		orderBy = db.SearchOrderByAlphabeticallyReverse
-	case "alphabetically":
-		orderBy = db.SearchOrderByAlphabetically
-	case "reversesize":
-		orderBy = db.SearchOrderBySizeReverse
-	case "size":
-		orderBy = db.SearchOrderBySize
-	case "reversegitsize":
-		orderBy = db.SearchOrderByGitSizeReverse
-	case "gitsize":
-		orderBy = db.SearchOrderByGitSize
-	case "reverselfssize":
-		orderBy = db.SearchOrderByLFSSizeReverse
-	case "lfssize":
-		orderBy = db.SearchOrderByLFSSize
-	case "moststars":
-		orderBy = db.SearchOrderByStarsReverse
-	case "feweststars":
-		orderBy = db.SearchOrderByStars
-	case "mostforks":
-		orderBy = db.SearchOrderByForksReverse
-	case "fewestforks":
-		orderBy = db.SearchOrderByForks
-	default:
-		ctx.Data["SortType"] = "recentupdate"
+	if order, ok := repo_model.SearchOrderByFlatMap[sortOrder]; ok {
+		orderBy = order
+	} else {
+		sortOrder = "recentupdate"
 		orderBy = db.SearchOrderByRecentUpdated
 	}
+	ctx.Data["SortType"] = sortOrder
 
 	keyword := ctx.FormTrim("q")