Allow searching for jira issues (#1)

Author: matera-bs

models/matera/jira/issue.go

@@ -0,0 +1,115 @@
+package jira
+
+import (
+	"code.gitea.io/gitea/models/db"
+	"code.gitea.io/gitea/models/repo"
+	"code.gitea.io/gitea/models/user"
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/timeutil"
+	gitea_context "code.gitea.io/gitea/services/context"
+	"xorm.io/builder"
+)
+
+type JiraIssueRelatedCommit struct {
+	ID          int64              `xorm:"pk autoincr"`
+	RepoID      int64              `xorm:"not null index(jira_issue_ticket) index(jira_issue_repo)"`
+	Ticket      string             `xorm:"not null index(jira_issue_ticket)"`
+	SHA         string             `xorm:"varchar(64) not null"`
+	CreatedUnix timeutil.TimeStamp `xorm:"not null index(jira_issue_ticket)"`
+}
+
+type JiraIssueRelatedCommitKey struct {
+	SHA    string
+	Ticket string
+}
+
+type FindJiraIssueRelatedCommitOptions struct {
+	db.ListOptions
+	RepoID int64
+}
+
+type FindJiraIssueRelatedCommitByTicketOptions struct {
+	db.ListOptions
+	Ticket string
+	Doer   *user.User
+}
+
+func (opts FindJiraIssueRelatedCommitOptions) ToConds() builder.Cond {
+	var cond builder.Cond = builder.Eq{"repo_id": opts.RepoID}
+	return cond
+}
+
+func (opts FindJiraIssueRelatedCommitOptions) ToOrders() string {
+	return "created_unix DESC, id DESC"
+}
+
+func (opts FindJiraIssueRelatedCommitByTicketOptions) ToConds() builder.Cond {
+	cond := builder.Eq{"ticket": opts.Ticket}
+	return cond.And(builder.In("repo_id", opts.accessibleRepos()))
+}
+
+func (opts FindJiraIssueRelatedCommitByTicketOptions) ToOrders() string {
+	return "repo_id, created_unix asc"
+}
+
+func (opts FindJiraIssueRelatedCommitByTicketOptions) accessibleRepos() *builder.Builder {
+	searchOpts := repo.SearchRepoOptions{
+		Actor:      opts.Doer,
+		OwnerID:    opts.Doer.ID,
+		Private:    true,
+		AllPublic:  true,
+		AllLimited: true,
+	}
+
+	return builder.Select("id").From("repository").Where(repo.SearchRepositoryCondition(&searchOpts))
+}
+
+type JiraIssue struct {
+	TicketId     string
+	TotalCommits int
+	Commits      []*JiraIssueRelatedCommit
+}
+
+func GetJiraIssueByTicket(ctx *gitea_context.Context, criterion FindJiraIssueRelatedCommitByTicketOptions) (*JiraIssue, error) {
+	commits := make([]*JiraIssueRelatedCommit, 0, 10)
+
+	count, err := db.GetEngine(ctx).Where(criterion.ToConds()).Count(new(JiraIssueRelatedCommit))
+
+	if err != nil {
+		log.Error("Error while trying to count JiraIssueRelatedCommit: %v", err)
+		return nil, err
+	}
+
+	if count == 0 {
+		return &JiraIssue{TicketId: criterion.Ticket, Commits: commits, TotalCommits: int(count)}, nil
+	}
+
+	offset, limit := criterion.GetSkipTake()
+
+	if err = db.GetEngine(ctx).Where(criterion.ToConds()).OrderBy(criterion.ToOrders()).Limit(limit, offset).Find(&commits); err != nil {
+		log.Error("Error while trying to fetch JiraIssueRelatedCommit: %v", err)
+		return nil, err
+	}
+
+	return &JiraIssue{TicketId: criterion.Ticket, Commits: commits, TotalCommits: int(count)}, nil
+}
+
+func (issues *JiraIssue) CommitsByRepo() map[int64][]*JiraIssueRelatedCommit {
+	result := make(map[int64][]*JiraIssueRelatedCommit)
+
+	for _, commit := range issues.Commits {
+		if _, ok := result[commit.RepoID]; !ok {
+			result[commit.RepoID] = []*JiraIssueRelatedCommit{}
+		}
+		result[commit.RepoID] = append(result[commit.RepoID], commit)
+	}
+
+	return result
+}
+
+func (commit JiraIssueRelatedCommit) GetKey() JiraIssueRelatedCommitKey {
+	return JiraIssueRelatedCommitKey{
+		Ticket: commit.Ticket,
+		SHA:    commit.SHA,
+	}
+}

models/migrations/matera/v_1_22/v300.go

@@ -0,0 +1,27 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package v1_22 //nolint
+
+import (
+	"fmt"
+
+	"code.gitea.io/gitea/modules/timeutil"
+	"xorm.io/xorm"
+)
+
+func CreateJiraIssueRelatedCommitTable(x *xorm.Engine) error {
+	type JiraIssueRelatedCommit struct {
+		ID          int64              `xorm:"pk autoincr"`
+		Ticket      string             `xorm:"varchar(64) not null index(jira_issue_ticket) index(jira_issue_repo)"`
+		RepoID      int64              `xorm:"not null index(jira_issue_ticket)"`
+		SHA         string             `xorm:"varchar(64) not null`
+		CreatedUnix timeutil.TimeStamp `xorm:"not null index(jira_issue_ticket)"`
+	}
+
+	if error := x.Sync(new(JiraIssueRelatedCommit)); error != nil {
+		return fmt.Errorf("Error creating jira_issue_related_commit table: %w", error)
+	} else {
+		return nil
+	}
+}

models/migrations/migrations.go

@@ -8,6 +8,7 @@ import (
 	"context"
 	"fmt"
 
+	matera_v_1_22 "code.gitea.io/gitea/models/migrations/matera/v_1_22"
 	"code.gitea.io/gitea/models/migrations/v1_10"
 	"code.gitea.io/gitea/models/migrations/v1_11"
 	"code.gitea.io/gitea/models/migrations/v1_12"
@@ -587,6 +588,13 @@ var migrations = []Migration{
 	NewMigration("Drop wrongly created table o_auth2_application", v1_22.DropWronglyCreatedTable),
 
 	// Gitea 1.22.0-rc1 ends at 299
+
+	// Start matera extra migrations
+
+	// v299 -> v300
+	NewMigration("Create jira relate issues table", matera_v_1_22.CreateJiraIssueRelatedCommitTable),
+
+	// End matera migrations
 }
 
 // GetCurrentDBVersion returns the current db version

modules/matera/git/repo_issue.go

@@ -0,0 +1,138 @@
+package git
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"io"
+	"regexp"
+	"strconv"
+	"strings"
+
+	jira_issue_models "code.gitea.io/gitea/models/matera/jira"
+	git_module "code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/timeutil"
+	"code.gitea.io/gitea/modules/util"
+)
+
+var issueRegex = regexp.MustCompile("^([A-Z]*-\\d+)")
+
+type Parser struct {
+	scanner *bufio.Scanner
+}
+
+func GetIssueRelateCommits(repo *git_module.Repository, page int, pageSize int) ([]*jira_issue_models.JiraIssueRelatedCommit, int, error) {
+	stdoutReader, stdoutWriter := io.Pipe()
+	defer stdoutReader.Close()
+	defer stdoutWriter.Close()
+	stderr := strings.Builder{}
+
+	rc := &git_module.RunOpts{Dir: repo.Path, Stdout: stdoutWriter, Stderr: &stderr}
+
+	go func() {
+		err := git_module.NewCommand(repo.Ctx, "log").
+			AddOptionFormat("--pretty=format:%s", "%H %at %s").
+			AddArguments("--all").Run(rc)
+		if err != nil {
+			_ = stdoutWriter.CloseWithError(git_module.ConcatenateError(err, stderr.String()))
+		} else {
+			_ = stdoutWriter.Close()
+		}
+	}()
+
+	parser := NewParser(stdoutReader)
+	commits, err := parser.ParseCommits()
+
+	if err != nil {
+		return nil, 0, err
+	}
+
+	//sortTagsByTime(tags)
+	commitsTotal := len(commits)
+	if page != 0 {
+		commits = util.PaginateSlice(commits, page, pageSize).([]*jira_issue_models.JiraIssueRelatedCommit)
+	}
+
+	return commits, commitsTotal, nil
+}
+
+func NewParser(r io.Reader) *Parser {
+	scanner := bufio.NewScanner(r)
+	scanner.Buffer(make([]byte, 0, 1024*1024), 1024*1024)
+
+	refDelim := make([]byte, 0, 1)
+	refDelim = append(refDelim, '\n')
+
+	// Split input into delimiter-separated "reference blocks".
+	scanner.Split(
+		func(data []byte, atEOF bool) (advance int, token []byte, err error) {
+			// Scan until delimiter, marking end of reference.
+			delimIdx := bytes.Index(data, refDelim)
+			if delimIdx >= 0 {
+				token := data[:delimIdx]
+				advance := delimIdx + len(refDelim)
+				return advance, token, nil
+			}
+			// If we're at EOF, we have a final, non-terminated reference. Return it.
+			if atEOF {
+				return len(data), data, nil
+			}
+			// Not yet a full field. Request more data.
+			return 0, nil, nil
+		})
+
+	return &Parser{
+		scanner: scanner,
+	}
+}
+
+func (parser *Parser) ParseCommits() ([]*jira_issue_models.JiraIssueRelatedCommit, error) {
+	var commits []*jira_issue_models.JiraIssueRelatedCommit
+	for {
+		commit, hasNext, err := parser.next()
+		if err != nil {
+			return nil, fmt.Errorf("GetIssueRelateCommits: parse commit: %w", err)
+		} else if commit != nil {
+			commits = append(commits, commit)
+		}
+		if !hasNext {
+			return commits, nil
+		}
+	}
+}
+
+func (parser *Parser) next() (*jira_issue_models.JiraIssueRelatedCommit, bool, error) {
+	if !parser.scanner.Scan() {
+		return nil, false, nil
+	}
+	line := parser.scanner.Text()
+	if line == "" {
+		return nil, false, nil
+	} else {
+		parts := strings.SplitN(line, " ", 3)
+		ticket := issueRegex.FindString(parts[2])
+		if ticket == "" {
+			return nil, true, nil
+		} else {
+			timestamp, err := parser.toTimestamp(parts[1])
+			if err != nil {
+				return nil, false, err
+			}
+
+			return &jira_issue_models.JiraIssueRelatedCommit{
+				Ticket:      ticket,
+				SHA:         parts[0],
+				CreatedUnix: timestamp,
+			}, true, nil
+		}
+	}
+}
+
+func (parser *Parser) toTimestamp(value string) (timeutil.TimeStamp, error) {
+	asInt, err := strconv.ParseInt(value, 10, 64)
+	if err != nil {
+		return timeutil.TimeStampNow(), err
+	} else {
+		return timeutil.TimeStamp(asInt), nil
+	}
+}