mirror of
https://codeberg.org/forgejo/forgejo
synced 2024-12-05 02:54:46 +01:00
5ca8851224
user, topic, project, label, milestone, repository, pull_request, release, asset, comment, reaction, review providers Signed-off-by: Earl Warren <contact@earl-warren.org> Preserve file size when creating attachments Introduced inc6f5029708
repoList.LoadAttributes has a ctx argument now Rename `repo.GetOwner` to `repo.LoadOwner`bd66fa586a
upgrade to the latest gof3 (cherry picked from commitc770713656
) [F3] ID remapping logic is in place, remove workaround (cherry picked from commitd0fee30167
) [F3] it is experimental, do not enable by default (cherry picked from commitde325b21d0
) (cherry picked from commit547e7b3c40
) (cherry picked from commit820df3a56b
) (cherry picked from commiteaba87689b
) (cherry picked from commit1b86896b3b
) (cherry picked from commit0046aac1c6
) (cherry picked from commitf14220df8f
) (cherry picked from commit559b731001
) (cherry picked from commit801f7d600d
) (cherry picked from commit6aa76e9bcf
) (cherry picked from commita8757dcb07
) [F3] promote F3 users to matching OAuth2 users on first sign-in (cherry picked from commitbd7fef7496
) (cherry picked from commit07412698e8
) (cherry picked from commitd143e5b2a3
) [F3] upgrade to gof3 50a6e740ac04 Add new methods GetIDString() & SetIDString() & ToFormatInterface() Change the prototype of the fixture function (cherry picked from commitd7b263ff8b
) (cherry picked from commitb3eaf2249d
) (cherry picked from commitd492ddd9bb
) [F3] add GetLocalMatchingRemote with a default implementation (cherry picked from commit0a22015039
) (cherry picked from commitf1310c38fb
) (cherry picked from commitdeb68552f2
) [F3] GetLocalMatchingRemote for user (cherry picked from commite73cb837f5
) (cherry picked from commita24bc0b85e
) (cherry picked from commit846a522ecc
) [F3] GetAdminUser now has a ctx argument (cherry picked from commit37357a92af
) (cherry picked from commit660bc1673c
) (cherry picked from commit72d692a767
) [F3] introduce UserTypeF3 To avoid conflicts should UserTypeRemoteUser be used differently by Gitea (cherry picked from commit6de2701bb3
) [F3] user.Put: idempotency (cherry picked from commit821e38573c
) (cherry picked from commitf7638f5414
) [F3] upgrade to urfave v2 (cherry picked from commitcc3dbdfd1d
) [F3] update gof3 (cherry picked from commit2eee960751
) [F3] move f3 under forgejo-cli * simplify the tests by re-using the forgejo-cli helpers to capture the output * unify CmdF3 to be structured in the same way CmdActions is (cherry picked from commit4c9fe58b74
) [F3] replace f3 with forgejo-cli f3 (cherry picked from commit7ba7ceef1b
) [F3] s/ListOptions/Paginator/ [F3] user: add unit tests [F3] user comparison of F3 managed users is on content [F3] issue: add unit tests [F3] gof3 now has one more argument to Put() [F3] re-use gof3 unit tests for the driver (cherry picked from commitaf7ee6200c
) Conflicts: tests/integration/integration_test.go because of some code removed in forgejo-development, trivial context conflict resolution [F3] more idempotent tests (#1275) Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/1275 Co-authored-by: Loïc Dachary <loic@dachary.org> Co-committed-by: Loïc Dachary <loic@dachary.org> [F3] tests: do SQL update if nothing changes [F3] tests comment idempotence [F3] tests milestone idempotence [F3] tests pull_request idempotence [F3] tests release idempotence [F3] tests asset idempotence [F3] tests project idempotence [F3] tests review idempotence (cherry picked from commit91038bb4e8
) (cherry picked from commita7d2a65214
) (cherry picked from commit59a17e5a34
) [F3] sub command of forgejo-cli (cherry picked from commit4d098e9b83
) [F3] implement --quiet, --debug, --verbose (cherry picked from commit82e2e17b45
) [F3] fix off by one error when importing repositories (cherry picked from commit31689b1397
) [F3] upgrade gof3 (cherry picked from commit87b8cfe5a1
) [F3] set the logger for all drivers The logger is set for the local Forgejo driver only. Even when --debug is specified, the other drivers do not display debug information. Use the gof3 context to set the logger for all of them at once. (cherry picked from commit8aa7de8ba0
) [F3] the closed date of an issue may be nil (cherry picked from commit93d3eaf0b5
) [F3] update gof3 to support system users there now is a workaround to hardcode system users when they are not supported by the API (cherry picked from commit915484daa7
) (cherry picked from commitb47ac73b8a
) [F3] upgrade gof3 with a version that can deal with system users When they are missing from what the API returns, it will replace the missing user with the Ghost user instead of leaving it be a null pointer. (cherry picked from commit9eeeab7f8e
) [F3] tests do not need a running Forgejo server (cherry picked from commitb2b9749ac9
) [F3] upgrade gof3 to correctly fetch PRs from forks (cherry picked from commitd2448de302
) [F3] upgrade gof3 to resolve incorrect object ID mappings (cherry picked from commitaf8c9de89f
) [F3] mirroring a repository needs --mirror instead of --bare (cherry picked from commit9941131920
) [F3] PR create the pull/N/head from the original PR head It is incorrect to assume they are identical because: * the IDs of a PR may be remapped and pull/N/head will become pull/M/head * the head of a remote fork is a branch named after the fork (cherry picked from commit9c220bf23e
) [F3] gof3 upgrade with non overlapping PR references (cherry picked from commitf1b2f82e7e
) [F3] refactor issue insertion to preserve the creation date issues_model.NewIssue() is convenient but will override the creation date. Update the database instead. (cherry picked from commit729f4be1e4
) [F3] gof3 upgrade to get performance improvements (cherry picked from commit996ac35d4d
) (cherry picked from commit906e9eb3f5
) (cherry picked from commitc340e22197
) (cherry picked from commitbb0ed72e08
) (cherry picked from commit500e640d6d
) [F3] TestForgeMethods needs to populate the database (cherry picked from commite6da71229f
) (cherry picked from commite3bd088895
) (cherry picked from commit2255136187
) (cherry picked from commit69584b1baf
) (cherry picked from commitbc37771dc3
) (cherry picked from commit90592146c6
) (cherry picked from commit6160eb38d9
) (cherry picked from commit4ed79ea8eb
) (cherry picked from commit8cb9c266ab
) (cherry picked from commit7b346e7bb2
) (cherry picked from commit0345dd562d
) (cherry picked from commit0f8821c1b1
) [F3] resolve (cherry picked from commit2acd211536
) (cherry picked from commit704317c24e
) (cherry picked from commitb127296da6
) (cherry picked from commit000b6f823e
) (cherry picked from commit7bd1b35139
) (cherry picked from commit6ba434bf2f
) (cherry picked from commit5c0826c529
) (cherry picked from commit00f7d12512
) (cherry picked from commit13550cb0b5
) (cherry picked from commit3b16d9e114
) (cherry picked from commit1b0db139d6
) [F3] licenses (cherry picked from commit2bccd8c1ef
) (cherry picked from commita92c48c8c2
)
404 lines
10 KiB
Go
404 lines
10 KiB
Go
// Copyright 2018 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package repo
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"code.gitea.io/gitea/models/db"
|
|
"code.gitea.io/gitea/modules/container"
|
|
"code.gitea.io/gitea/modules/timeutil"
|
|
"code.gitea.io/gitea/modules/util"
|
|
|
|
"xorm.io/builder"
|
|
)
|
|
|
|
func init() {
|
|
db.RegisterModel(new(Topic))
|
|
db.RegisterModel(new(RepoTopic))
|
|
}
|
|
|
|
var topicPattern = regexp.MustCompile(`^[a-z0-9][-.a-z0-9]*$`)
|
|
|
|
// Topic represents a topic of repositories
|
|
type Topic struct {
|
|
ID int64 `xorm:"pk autoincr"`
|
|
Name string `xorm:"UNIQUE VARCHAR(50)"`
|
|
RepoCount int
|
|
CreatedUnix timeutil.TimeStamp `xorm:"INDEX created"`
|
|
UpdatedUnix timeutil.TimeStamp `xorm:"INDEX updated"`
|
|
}
|
|
|
|
// RepoTopic represents associated repositories and topics
|
|
type RepoTopic struct { //revive:disable-line:exported
|
|
RepoID int64 `xorm:"pk"`
|
|
TopicID int64 `xorm:"pk"`
|
|
}
|
|
|
|
// ErrTopicNotExist represents an error that a topic is not exist
|
|
type ErrTopicNotExist struct {
|
|
Name string
|
|
}
|
|
|
|
// IsErrTopicNotExist checks if an error is an ErrTopicNotExist.
|
|
func IsErrTopicNotExist(err error) bool {
|
|
_, ok := err.(ErrTopicNotExist)
|
|
return ok
|
|
}
|
|
|
|
// Error implements error interface
|
|
func (err ErrTopicNotExist) Error() string {
|
|
return fmt.Sprintf("topic is not exist [name: %s]", err.Name)
|
|
}
|
|
|
|
func (err ErrTopicNotExist) Unwrap() error {
|
|
return util.ErrNotExist
|
|
}
|
|
|
|
// ValidateTopic checks a topic by length and match pattern rules
|
|
func ValidateTopic(topic string) bool {
|
|
return len(topic) <= 35 && topicPattern.MatchString(topic)
|
|
}
|
|
|
|
// SanitizeAndValidateTopics sanitizes and checks an array or topics
|
|
func SanitizeAndValidateTopics(topics []string) (validTopics, invalidTopics []string) {
|
|
validTopics = make([]string, 0)
|
|
mValidTopics := make(container.Set[string])
|
|
invalidTopics = make([]string, 0)
|
|
|
|
for _, topic := range topics {
|
|
topic = strings.TrimSpace(strings.ToLower(topic))
|
|
// ignore empty string
|
|
if len(topic) == 0 {
|
|
continue
|
|
}
|
|
// ignore same topic twice
|
|
if mValidTopics.Contains(topic) {
|
|
continue
|
|
}
|
|
if ValidateTopic(topic) {
|
|
validTopics = append(validTopics, topic)
|
|
mValidTopics.Add(topic)
|
|
} else {
|
|
invalidTopics = append(invalidTopics, topic)
|
|
}
|
|
}
|
|
|
|
return validTopics, invalidTopics
|
|
}
|
|
|
|
// GetTopicByName retrieves topic by name
|
|
func GetTopicByName(ctx context.Context, name string) (*Topic, error) {
|
|
var topic Topic
|
|
if has, err := db.GetEngine(ctx).Where("name = ?", name).Get(&topic); err != nil {
|
|
return nil, err
|
|
} else if !has {
|
|
return nil, ErrTopicNotExist{name}
|
|
}
|
|
return &topic, nil
|
|
}
|
|
|
|
// addTopicByNameToRepo adds a topic name to a repo and increments the topic count.
|
|
// Returns topic after the addition
|
|
func addTopicByNameToRepo(ctx context.Context, repoID int64, topicName string) (*Topic, error) {
|
|
var topic Topic
|
|
e := db.GetEngine(ctx)
|
|
has, err := e.Where("name = ?", topicName).Get(&topic)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !has {
|
|
topic.Name = topicName
|
|
topic.RepoCount = 1
|
|
if err := db.Insert(ctx, &topic); err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
topic.RepoCount++
|
|
if _, err := e.ID(topic.ID).Cols("repo_count").Update(&topic); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if err := db.Insert(ctx, &RepoTopic{
|
|
RepoID: repoID,
|
|
TopicID: topic.ID,
|
|
}); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &topic, nil
|
|
}
|
|
|
|
// removeTopicFromRepo remove a topic from a repo and decrements the topic repo count
|
|
func removeTopicFromRepo(ctx context.Context, repoID int64, topic *Topic) error {
|
|
topic.RepoCount--
|
|
e := db.GetEngine(ctx)
|
|
if _, err := e.ID(topic.ID).Cols("repo_count").Update(topic); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := e.Delete(&RepoTopic{
|
|
RepoID: repoID,
|
|
TopicID: topic.ID,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// RemoveTopicsFromRepo remove all topics from the repo and decrements respective topics repo count
|
|
func RemoveTopicsFromRepo(ctx context.Context, repoID int64) error {
|
|
e := db.GetEngine(ctx)
|
|
_, err := e.Where(
|
|
builder.In("id",
|
|
builder.Select("topic_id").From("repo_topic").Where(builder.Eq{"repo_id": repoID}),
|
|
),
|
|
).Cols("repo_count").SetExpr("repo_count", "repo_count-1").Update(&Topic{})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err = e.Delete(&RepoTopic{RepoID: repoID}); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// FindTopicOptions represents the options when fdin topics
|
|
type FindTopicOptions struct {
|
|
db.ListOptions
|
|
RepoID int64
|
|
Keyword string
|
|
}
|
|
|
|
func (opts *FindTopicOptions) toConds() builder.Cond {
|
|
cond := builder.NewCond()
|
|
if opts.RepoID > 0 {
|
|
cond = cond.And(builder.Eq{"repo_topic.repo_id": opts.RepoID})
|
|
}
|
|
|
|
if opts.Keyword != "" {
|
|
cond = cond.And(builder.Like{"topic.name", opts.Keyword})
|
|
}
|
|
|
|
return cond
|
|
}
|
|
|
|
// FindTopics retrieves the topics via FindTopicOptions
|
|
func FindTopics(ctx context.Context, opts *FindTopicOptions) ([]*Topic, int64, error) {
|
|
sess := db.GetEngine(ctx).Select("topic.*").Where(opts.toConds())
|
|
orderBy := "topic.repo_count DESC"
|
|
if opts.RepoID > 0 {
|
|
sess.Join("INNER", "repo_topic", "repo_topic.topic_id = topic.id")
|
|
orderBy = "topic.name" // when render topics for a repo, it's better to sort them by name, to get consistent result
|
|
}
|
|
if opts.PageSize != 0 && opts.Page != 0 {
|
|
sess = db.SetSessionPagination(sess, opts)
|
|
}
|
|
topics := make([]*Topic, 0, 10)
|
|
total, err := sess.OrderBy(orderBy).FindAndCount(&topics)
|
|
return topics, total, err
|
|
}
|
|
|
|
// CountTopics counts the number of topics matching the FindTopicOptions
|
|
func CountTopics(ctx context.Context, opts *FindTopicOptions) (int64, error) {
|
|
sess := db.GetEngine(ctx).Where(opts.toConds())
|
|
if opts.RepoID > 0 {
|
|
sess.Join("INNER", "repo_topic", "repo_topic.topic_id = topic.id")
|
|
}
|
|
return sess.Count(new(Topic))
|
|
}
|
|
|
|
// GetRepoTopicByName retrieves topic from name for a repo if it exist
|
|
func GetRepoTopicByName(ctx context.Context, repoID int64, topicName string) (*Topic, error) {
|
|
cond := builder.NewCond()
|
|
var topic Topic
|
|
cond = cond.And(builder.Eq{"repo_topic.repo_id": repoID}).And(builder.Eq{"topic.name": topicName})
|
|
sess := db.GetEngine(ctx).Table("topic").Where(cond)
|
|
sess.Join("INNER", "repo_topic", "repo_topic.topic_id = topic.id")
|
|
has, err := sess.Select("topic.*").Get(&topic)
|
|
if has {
|
|
return &topic, err
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// GetRepoTopicByID retrieves topic from ID for a repo if it exist
|
|
func GetRepoTopicByID(ctx context.Context, repoID, topicID int64) (*Topic, error) {
|
|
cond := builder.NewCond()
|
|
var topic Topic
|
|
cond = cond.And(builder.Eq{"repo_topic.repo_id": repoID}).And(builder.Eq{"topic.id": topicID})
|
|
sess := db.GetEngine(ctx).Table("topic").Where(cond)
|
|
sess.Join("INNER", "repo_topic", "repo_topic.topic_id = topic.id")
|
|
if has, err := sess.Select("topic.*").Get(&topic); err != nil {
|
|
return nil, err
|
|
} else if !has {
|
|
return nil, ErrTopicNotExist{""}
|
|
}
|
|
return &topic, nil
|
|
}
|
|
|
|
// AddTopic adds a topic name to a repository (if it does not already have it)
|
|
func AddTopic(ctx context.Context, repoID int64, topicName string) (*Topic, error) {
|
|
ctx, committer, err := db.TxContext(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer committer.Close()
|
|
sess := db.GetEngine(ctx)
|
|
|
|
topic, err := GetRepoTopicByName(ctx, repoID, topicName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if topic != nil {
|
|
// Repo already have topic
|
|
return topic, nil
|
|
}
|
|
|
|
topic, err = addTopicByNameToRepo(ctx, repoID, topicName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err = syncTopicsInRepository(sess, repoID); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return topic, committer.Commit()
|
|
}
|
|
|
|
// DeleteTopic removes a topic name from a repository (if it has it)
|
|
func DeleteTopic(ctx context.Context, repoID int64, topicName string) (*Topic, error) {
|
|
topic, err := GetRepoTopicByName(ctx, repoID, topicName)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if topic == nil {
|
|
// Repo doesn't have topic, can't be removed
|
|
return nil, nil
|
|
}
|
|
|
|
err = removeTopicFromRepo(ctx, repoID, topic)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = syncTopicsInRepository(db.GetEngine(ctx), repoID)
|
|
|
|
return topic, err
|
|
}
|
|
|
|
// SaveTopics save topics to a repository
|
|
func SaveTopics(ctx context.Context, repoID int64, topicNames ...string) error {
|
|
topics, _, err := FindTopics(ctx, &FindTopicOptions{
|
|
RepoID: repoID,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
ctx, committer, err := db.TxContext(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer committer.Close()
|
|
sess := db.GetEngine(ctx)
|
|
|
|
var addedTopicNames []string
|
|
for _, topicName := range topicNames {
|
|
if strings.TrimSpace(topicName) == "" {
|
|
continue
|
|
}
|
|
|
|
var found bool
|
|
for _, t := range topics {
|
|
if strings.EqualFold(topicName, t.Name) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
addedTopicNames = append(addedTopicNames, topicName)
|
|
}
|
|
}
|
|
|
|
var removeTopics []*Topic
|
|
for _, t := range topics {
|
|
var found bool
|
|
for _, topicName := range topicNames {
|
|
if strings.EqualFold(topicName, t.Name) {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
removeTopics = append(removeTopics, t)
|
|
}
|
|
}
|
|
|
|
for _, topicName := range addedTopicNames {
|
|
_, err := addTopicByNameToRepo(ctx, repoID, topicName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for _, topic := range removeTopics {
|
|
err := removeTopicFromRepo(ctx, repoID, topic)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if err := syncTopicsInRepository(sess, repoID); err != nil {
|
|
return err
|
|
}
|
|
|
|
return committer.Commit()
|
|
}
|
|
|
|
// GenerateTopics generates topics from a template repository
|
|
func GenerateTopics(ctx context.Context, templateRepo, generateRepo *Repository) error {
|
|
for _, topic := range templateRepo.Topics {
|
|
if _, err := addTopicByNameToRepo(ctx, generateRepo.ID, topic); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return syncTopicsInRepository(db.GetEngine(ctx), generateRepo.ID)
|
|
}
|
|
|
|
// syncTopicsInRepository makes sure topics in the topics table are copied into the topics field of the repository
|
|
func syncTopicsInRepository(sess db.Engine, repoID int64) error {
|
|
topicNames := make([]string, 0, 25)
|
|
if err := sess.Table("topic").Cols("name").
|
|
Join("INNER", "repo_topic", "repo_topic.topic_id = topic.id").
|
|
Where("repo_topic.repo_id = ?", repoID).Desc("topic.repo_count").Find(&topicNames); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := sess.ID(repoID).Cols("topics").Update(&Repository{
|
|
Topics: topicNames,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CountOrphanedAttachments returns the number of topics that don't belong to any repository.
|
|
func CountOrphanedTopics(ctx context.Context) (int64, error) {
|
|
return db.GetEngine(ctx).Where("repo_count = 0").Count(new(Topic))
|
|
}
|
|
|
|
// DeleteOrphanedAttachments delete all topics that don't belong to any repository.
|
|
func DeleteOrphanedTopics(ctx context.Context) (int64, error) {
|
|
return db.GetEngine(ctx).Where("repo_count = 0").Delete(new(Topic))
|
|
}
|