初始提交: Gitea 项目代码

services/convert/action_test.go

@@ -0,0 +1,179 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	actions_model "gitea.dev/models/actions"
+	db "gitea.dev/models/db"
+	repo_model "gitea.dev/models/repo"
+	"gitea.dev/models/unit"
+	"gitea.dev/models/unittest"
+	"gitea.dev/modules/git"
+	"gitea.dev/modules/git/gitcmd"
+	"gitea.dev/modules/util"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// buildWorkflowTestRepo creates a temporary git repository for testing GetActionWorkflow.
+// The default branch "main" has no workflow files; "feature" and "release-v1" each add their own workflow file.
+func buildWorkflowTestRepo(t *testing.T) string {
+	t.Helper()
+	ctx := t.Context()
+	tmpDir := t.TempDir()
+
+	_, _, err := gitcmd.NewCommand("init").WithDir(tmpDir).RunStdString(ctx)
+	require.NoError(t, err)
+
+	readme := "readme"
+	featureWF := "on: [push]\njobs:\n  test:\n    runs-on: ubuntu-latest\n    steps:\n      - run: echo test\n"
+	releaseWF := "on: [push]\njobs:\n  release:\n    runs-on: ubuntu-latest\n    steps:\n      - run: echo release\n"
+
+	// Build a git fast-import stream:
+	//   :4 = initial commit on main (README.md only)
+	//   :5 = feature branch commit (adds feature workflow)
+	//   :6 = release commit from :4 (adds release workflow, tagged release-v1, not on main)
+	var sb strings.Builder
+	fmt.Fprintf(&sb, "blob\nmark :1\ndata %d\n%s\n", len(readme), readme)
+	fmt.Fprintf(&sb, "blob\nmark :2\ndata %d\n%s\n", len(featureWF), featureWF)
+	fmt.Fprintf(&sb, "blob\nmark :3\ndata %d\n%s\n", len(releaseWF), releaseWF)
+	fmt.Fprintf(&sb, "commit refs/heads/main\nmark :4\nauthor Test <test@gitea.com> 1000000000 +0000\ncommitter Test <test@gitea.com> 1000000000 +0000\ndata 14\ninitial commit\nM 100644 :1 README.md\n\n")
+	fmt.Fprintf(&sb, "commit refs/heads/feature\nmark :5\nauthor Test <test@gitea.com> 1000000001 +0000\ncommitter Test <test@gitea.com> 1000000001 +0000\ndata 12\nadd workflow\nfrom :4\nM 100644 :2 .gitea/workflows/my-workflow.yml\n\n")
+	fmt.Fprintf(&sb, "reset refs/pull/42/merge\nfrom :5\n\n")
+	fmt.Fprintf(&sb, "commit refs/heads/main\nmark :6\nauthor Test <test@gitea.com> 1000000002 +0000\ncommitter Test <test@gitea.com> 1000000002 +0000\ndata 16\nrelease workflow\nfrom :4\nM 100644 :3 .gitea/workflows/my-workflow.yml\n\n")
+	fmt.Fprintf(&sb, "reset refs/tags/release-v1\nfrom :6\n\n")
+	fmt.Fprintf(&sb, "reset refs/heads/main\nfrom :4\n\n")
+	fmt.Fprintf(&sb, "done\n")
+
+	_, _, err = gitcmd.NewCommand("fast-import").WithDir(tmpDir).WithStdinBytes([]byte(sb.String())).RunStdString(ctx)
+	require.NoError(t, err)
+
+	return tmpDir
+}
+
+func TestGetActionWorkflow_FallbackRef(t *testing.T) {
+	ctx := t.Context()
+
+	repoDir := buildWorkflowTestRepo(t)
+
+	gitRepo, err := git.OpenRepository(ctx, repoDir)
+	require.NoError(t, err)
+	defer gitRepo.Close()
+
+	repo := &repo_model.Repository{
+		DefaultBranch: "main",
+		OwnerName:     "test-owner",
+		Name:          "test-repo",
+		Units: []*repo_model.RepoUnit{
+			{
+				Type:   unit.TypeActions,
+				Config: &repo_model.ActionsConfig{},
+			},
+		},
+	}
+
+	t.Run("returns error when workflow only on non-default branch", func(t *testing.T) {
+		_, err := GetActionWorkflow(ctx, gitRepo, repo, "my-workflow.yml")
+		require.Error(t, err)
+		assert.ErrorIs(t, err, util.ErrNotExist)
+	})
+
+	t.Run("returns workflow when found via ref", func(t *testing.T) {
+		wf, err := GetActionWorkflowByRef(ctx, gitRepo, repo, "my-workflow.yml", git.RefName("refs/heads/feature"))
+		require.NoError(t, err)
+		assert.Equal(t, "my-workflow.yml", wf.ID)
+	})
+
+	t.Run("returns workflow when found via pull ref", func(t *testing.T) {
+		wf, err := GetActionWorkflowByRef(ctx, gitRepo, repo, "my-workflow.yml", git.RefName("refs/pull/42/merge"))
+		require.NoError(t, err)
+		assert.Equal(t, "my-workflow.yml", wf.ID)
+		assert.Contains(t, wf.HTMLURL, "/src/commit/")
+	})
+
+	t.Run("returns workflow with tag link when found via tag ref", func(t *testing.T) {
+		wf, err := GetActionWorkflowByRef(ctx, gitRepo, repo, "my-workflow.yml", git.RefName("refs/tags/release-v1"))
+		require.NoError(t, err)
+		assert.Equal(t, "my-workflow.yml", wf.ID)
+		assert.Contains(t, wf.HTMLURL, "/src/tag/release-v1/")
+	})
+
+	t.Run("returns error when workflow missing from ref", func(t *testing.T) {
+		_, err := GetActionWorkflowByRef(ctx, gitRepo, repo, "nonexistent.yml", git.RefName("refs/heads/feature"))
+		require.Error(t, err)
+		assert.ErrorIs(t, err, util.ErrNotExist)
+	})
+}
+
+func TestToActionWorkflowRun_UsesTriggerEvent(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+
+	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2})
+	run := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: 803})
+	run.Repo = repo
+	// Scheduled runs keep Event as the registration event (push) and use TriggerEvent as the real trigger.
+	run.Event = "push"
+	run.TriggerEvent = "schedule"
+
+	apiRun, err := ToActionWorkflowRun(t.Context(), run, nil)
+	require.NoError(t, err)
+	assert.Equal(t, "schedule", apiRun.Event)
+}
+
+func TestToActionWorkflowJob_StepStatusIsIndependentOfJobStatus(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+	ctx := t.Context()
+
+	run := &actions_model.ActionRun{
+		ID:            9001,
+		RepoID:        2,
+		TriggerUserID: 1,
+		WorkflowID:    "test.yaml",
+		Index:         12345,
+		Ref:           "refs/heads/main",
+		Status:        actions_model.StatusFailure,
+	}
+	require.NoError(t, db.Insert(ctx, run))
+
+	task := &actions_model.ActionTask{
+		ID:     900102,
+		JobID:  9001,
+		RepoID: 2,
+		Status: actions_model.StatusFailure,
+	}
+	require.NoError(t, db.Insert(ctx, task))
+
+	job := &actions_model.ActionRunJob{
+		ID:      90010203,
+		RunID:   9001,
+		TaskID:  900102,
+		RepoID:  2,
+		Name:    "test-job-name",
+		Attempt: 1,
+		JobID:   "test-job-id",
+		Status:  actions_model.StatusFailure,
+	}
+	require.NoError(t, db.Insert(ctx, job))
+
+	require.NoError(t, db.Insert(ctx,
+		&actions_model.ActionTaskStep{TaskID: task.ID, RepoID: 2, Index: 0, Name: "step-success", Status: actions_model.StatusSuccess},
+		&actions_model.ActionTaskStep{TaskID: task.ID, RepoID: 2, Index: 1, Name: "step-failure", Status: actions_model.StatusFailure},
+	))
+
+	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2})
+
+	apiJob, err := ToActionWorkflowJob(ctx, repo, task, job)
+	require.NoError(t, err)
+	require.Len(t, apiJob.Steps, 2)
+
+	assert.Equal(t, "completed", apiJob.Steps[0].Status, "step 0 status")
+	assert.Equal(t, "success", apiJob.Steps[0].Conclusion, "step 0 conclusion (succeeded before the failure)")
+	assert.Equal(t, "completed", apiJob.Steps[1].Status, "step 1 status")
+	assert.Equal(t, "failure", apiJob.Steps[1].Conclusion, "step 1 conclusion")
+}

services/convert/activity.go

@@ -0,0 +1,52 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+
+	activities_model "gitea.dev/models/activities"
+	perm_model "gitea.dev/models/perm"
+	access_model "gitea.dev/models/perm/access"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/log"
+	api "gitea.dev/modules/structs"
+)
+
+func ToActivity(ctx context.Context, ac *activities_model.Action, doer *user_model.User) *api.Activity {
+	p, err := access_model.GetDoerRepoPermission(ctx, ac.Repo, doer)
+	if err != nil {
+		log.Error("GetDoerRepoPermission[%d]: %v", ac.RepoID, err)
+		p.AccessMode = perm_model.AccessModeNone
+	}
+
+	result := &api.Activity{
+		ID:        ac.ID,
+		UserID:    ac.UserID,
+		OpType:    ac.OpType.String(),
+		ActUserID: ac.ActUserID,
+		ActUser:   ToUser(ctx, ac.ActUser, doer),
+		RepoID:    ac.RepoID,
+		Repo:      ToRepo(ctx, ac.Repo, p),
+		RefName:   ac.RefName,
+		IsPrivate: ac.IsPrivate,
+		Content:   ac.Content,
+		Created:   ac.CreatedUnix.AsTime(),
+	}
+
+	if ac.Comment != nil {
+		result.CommentID = ac.CommentID
+		result.Comment = ToAPIComment(ctx, ac.Repo, ac.Comment)
+	}
+
+	return result
+}
+
+func ToActivities(ctx context.Context, al activities_model.ActionList, doer *user_model.User) []*api.Activity {
+	result := make([]*api.Activity, 0, len(al))
+	for _, ac := range al {
+		result = append(result, ToActivity(ctx, ac, doer))
+	}
+	return result
+}

services/convert/attachment.go

@@ -0,0 +1,52 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	repo_model "gitea.dev/models/repo"
+	api "gitea.dev/modules/structs"
+)
+
+func WebAssetDownloadURL(repo *repo_model.Repository, attach *repo_model.Attachment) string {
+	return attach.DownloadURL()
+}
+
+func APIAssetDownloadURL(repo *repo_model.Repository, attach *repo_model.Attachment) string {
+	return attach.DownloadURL()
+}
+
+// ToAttachment converts models.Attachment to api.Attachment for API usage
+func ToAttachment(repo *repo_model.Repository, a *repo_model.Attachment) *api.Attachment {
+	return toAttachment(repo, a, WebAssetDownloadURL)
+}
+
+// ToAPIAttachment converts models.Attachment to api.Attachment for API usage
+func ToAPIAttachment(repo *repo_model.Repository, a *repo_model.Attachment) *api.Attachment {
+	return toAttachment(repo, a, APIAssetDownloadURL)
+}
+
+// toAttachment converts models.Attachment to api.Attachment for API usage
+func toAttachment(repo *repo_model.Repository, a *repo_model.Attachment, getDownloadURL func(repo *repo_model.Repository, attach *repo_model.Attachment) string) *api.Attachment {
+	return &api.Attachment{
+		ID:            a.ID,
+		Name:          a.Name,
+		Created:       a.CreatedUnix.AsTime(),
+		DownloadCount: a.DownloadCount,
+		Size:          a.Size,
+		UUID:          a.UUID,
+		DownloadURL:   getDownloadURL(repo, a), // for web request json and api request json, return different download urls
+	}
+}
+
+func ToAPIAttachments(repo *repo_model.Repository, attachments []*repo_model.Attachment) []*api.Attachment {
+	return toAttachments(repo, attachments, APIAssetDownloadURL)
+}
+
+func toAttachments(repo *repo_model.Repository, attachments []*repo_model.Attachment, getDownloadURL func(repo *repo_model.Repository, attach *repo_model.Attachment) string) []*api.Attachment {
+	converted := make([]*api.Attachment, 0, len(attachments))
+	for _, attachment := range attachments {
+		converted = append(converted, toAttachment(repo, attachment, getDownloadURL))
+	}
+	return converted
+}

services/convert/convert.go

@@ -0,0 +1,889 @@
+// Copyright 2015 The Gogs Authors. All rights reserved.
+// Copyright 2018 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net/url"
+	"path"
+	"strconv"
+	"time"
+
+	runnerv1 "gitea.dev/actions-proto-go/runner/v1"
+	actions_model "gitea.dev/models/actions"
+	asymkey_model "gitea.dev/models/asymkey"
+	"gitea.dev/models/auth"
+	"gitea.dev/models/db"
+	git_model "gitea.dev/models/git"
+	issues_model "gitea.dev/models/issues"
+	"gitea.dev/models/organization"
+	"gitea.dev/models/perm"
+	access_model "gitea.dev/models/perm/access"
+	repo_model "gitea.dev/models/repo"
+	"gitea.dev/models/unit"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/actions"
+	"gitea.dev/modules/container"
+	"gitea.dev/modules/git"
+	"gitea.dev/modules/httplib"
+	"gitea.dev/modules/log"
+	"gitea.dev/modules/setting"
+	api "gitea.dev/modules/structs"
+	"gitea.dev/modules/util"
+	asymkey_service "gitea.dev/services/asymkey"
+	"gitea.dev/services/gitdiff"
+
+	"gitea.com/gitea/runner/act/model"
+)
+
+// ToEmail convert models.EmailAddress to api.Email
+func ToEmail(email *user_model.EmailAddress) *api.Email {
+	return &api.Email{
+		Email:    email.Email,
+		Verified: email.IsActivated,
+		Primary:  email.IsPrimary,
+	}
+}
+
+// ToEmail convert models.EmailAddress to api.Email
+func ToEmailSearch(email *user_model.SearchEmailResult) *api.Email {
+	return &api.Email{
+		Email:    email.Email,
+		Verified: email.IsActivated,
+		Primary:  email.IsPrimary,
+		UserID:   email.UID,
+		UserName: email.Name,
+	}
+}
+
+// ToBranch convert a git.Commit and git.Branch to an api.Branch
+func ToBranch(ctx context.Context, repo *repo_model.Repository, branchName string, c *git.Commit, bp *git_model.ProtectedBranch, user *user_model.User, isRepoAdmin bool) (*api.Branch, error) {
+	if bp == nil {
+		var hasPerm bool
+		var canPush bool
+		var err error
+		if user != nil {
+			hasPerm, err = access_model.HasAccessUnit(ctx, user, repo, unit.TypeCode, perm.AccessModeWrite)
+			if err != nil {
+				return nil, err
+			}
+
+			perms, err := access_model.GetIndividualUserRepoPermission(ctx, repo, user)
+			if err != nil {
+				return nil, err
+			}
+			canPush = issues_model.CanMaintainerWriteToBranch(ctx, perms, branchName, user)
+		}
+
+		return &api.Branch{
+			Name:                branchName,
+			Commit:              ToPayloadCommit(ctx, repo, c),
+			Protected:           false,
+			RequiredApprovals:   0,
+			EnableStatusCheck:   false,
+			StatusCheckContexts: []string{},
+			UserCanPush:         canPush,
+			UserCanMerge:        hasPerm,
+		}, nil
+	}
+
+	branch := &api.Branch{
+		Name:                branchName,
+		Commit:              ToPayloadCommit(ctx, repo, c),
+		Protected:           true,
+		RequiredApprovals:   bp.RequiredApprovals,
+		EnableStatusCheck:   bp.EnableStatusCheck,
+		StatusCheckContexts: bp.StatusCheckContexts,
+	}
+
+	if isRepoAdmin {
+		branch.EffectiveBranchProtectionName = bp.RuleName
+	}
+
+	if user != nil {
+		permission, err := access_model.GetIndividualUserRepoPermission(ctx, repo, user)
+		if err != nil {
+			return nil, err
+		}
+		bp.Repo = repo
+		branch.UserCanPush = bp.CanUserPush(ctx, user)
+		branch.UserCanMerge = git_model.IsUserMergeWhitelisted(ctx, bp, user.ID, permission)
+	}
+
+	return branch, nil
+}
+
+// getWhitelistEntities returns the names of the entities that are in the whitelist
+func getWhitelistEntities[T *user_model.User | *organization.Team](entities []T, whitelistIDs []int64) []string {
+	whitelistUserIDsSet := container.SetOf(whitelistIDs...)
+	whitelistNames := make([]string, 0)
+	for _, entity := range entities {
+		switch v := any(entity).(type) {
+		case *user_model.User:
+			if whitelistUserIDsSet.Contains(v.ID) {
+				whitelistNames = append(whitelistNames, v.Name)
+			}
+		case *organization.Team:
+			if whitelistUserIDsSet.Contains(v.ID) {
+				whitelistNames = append(whitelistNames, v.Name)
+			}
+		}
+	}
+
+	return whitelistNames
+}
+
+// ToBranchProtection convert a ProtectedBranch to api.BranchProtection
+func ToBranchProtection(ctx context.Context, bp *git_model.ProtectedBranch, repo *repo_model.Repository) *api.BranchProtection {
+	readers, err := access_model.GetUsersWithUnitAccess(ctx, repo, perm.AccessModeRead, unit.TypePullRequests)
+	if err != nil {
+		log.Error("GetRepoReaders: %v", err)
+	}
+
+	pushWhitelistUsernames := getWhitelistEntities(readers, bp.WhitelistUserIDs)
+	forcePushAllowlistUsernames := getWhitelistEntities(readers, bp.ForcePushAllowlistUserIDs)
+	mergeWhitelistUsernames := getWhitelistEntities(readers, bp.MergeWhitelistUserIDs)
+	approvalsWhitelistUsernames := getWhitelistEntities(readers, bp.ApprovalsWhitelistUserIDs)
+	bypassAllowlistUsernames := getWhitelistEntities(readers, bp.BypassAllowlistUserIDs)
+
+	teamReaders, err := organization.GetTeamsWithAccessToAnyRepoUnit(ctx, repo.Owner.ID, repo.ID, perm.AccessModeRead, unit.TypeCode, unit.TypePullRequests)
+	if err != nil {
+		log.Error("Repo.Owner.TeamsWithAccessToRepo: %v", err)
+	}
+
+	pushWhitelistTeams := getWhitelistEntities(teamReaders, bp.WhitelistTeamIDs)
+	forcePushAllowlistTeams := getWhitelistEntities(teamReaders, bp.ForcePushAllowlistTeamIDs)
+	mergeWhitelistTeams := getWhitelistEntities(teamReaders, bp.MergeWhitelistTeamIDs)
+	approvalsWhitelistTeams := getWhitelistEntities(teamReaders, bp.ApprovalsWhitelistTeamIDs)
+	bypassAllowlistTeams := getWhitelistEntities(teamReaders, bp.BypassAllowlistTeamIDs)
+
+	branchName := ""
+	if !git_model.IsRuleNameSpecial(bp.RuleName) {
+		branchName = bp.RuleName
+	}
+
+	return &api.BranchProtection{
+		BranchName:                    branchName,
+		RuleName:                      bp.RuleName,
+		Priority:                      bp.Priority,
+		EnablePush:                    bp.CanPush,
+		EnablePushWhitelist:           bp.EnableWhitelist,
+		PushWhitelistUsernames:        pushWhitelistUsernames,
+		PushWhitelistTeams:            pushWhitelistTeams,
+		PushWhitelistDeployKeys:       bp.WhitelistDeployKeys,
+		EnableForcePush:               bp.CanForcePush,
+		EnableForcePushAllowlist:      bp.EnableForcePushAllowlist,
+		ForcePushAllowlistUsernames:   forcePushAllowlistUsernames,
+		ForcePushAllowlistTeams:       forcePushAllowlistTeams,
+		ForcePushAllowlistDeployKeys:  bp.ForcePushAllowlistDeployKeys,
+		EnableMergeWhitelist:          bp.EnableMergeWhitelist,
+		MergeWhitelistUsernames:       mergeWhitelistUsernames,
+		MergeWhitelistTeams:           mergeWhitelistTeams,
+		EnableBypassAllowlist:         bp.EnableBypassAllowlist,
+		BypassAllowlistUsernames:      bypassAllowlistUsernames,
+		BypassAllowlistTeams:          bypassAllowlistTeams,
+		EnableStatusCheck:             bp.EnableStatusCheck,
+		StatusCheckContexts:           bp.StatusCheckContexts,
+		RequiredApprovals:             bp.RequiredApprovals,
+		EnableApprovalsWhitelist:      bp.EnableApprovalsWhitelist,
+		ApprovalsWhitelistUsernames:   approvalsWhitelistUsernames,
+		ApprovalsWhitelistTeams:       approvalsWhitelistTeams,
+		BlockOnRejectedReviews:        bp.BlockOnRejectedReviews,
+		BlockOnOfficialReviewRequests: bp.BlockOnOfficialReviewRequests,
+		BlockOnOutdatedBranch:         bp.BlockOnOutdatedBranch,
+		DismissStaleApprovals:         bp.DismissStaleApprovals,
+		IgnoreStaleApprovals:          bp.IgnoreStaleApprovals,
+		RequireSignedCommits:          bp.RequireSignedCommits,
+		ProtectedFilePatterns:         bp.ProtectedFilePatterns,
+		UnprotectedFilePatterns:       bp.UnprotectedFilePatterns,
+		BlockAdminMergeOverride:       bp.BlockAdminMergeOverride,
+		Created:                       bp.CreatedUnix.AsTime(),
+		Updated:                       bp.UpdatedUnix.AsTime(),
+	}
+}
+
+// ToTag convert a git.Tag to an api.Tag
+func ToTag(repo *repo_model.Repository, t *git.Tag) *api.Tag {
+	tarballURL := repo.HTMLURL() + "/archive/" + url.PathEscape(t.Name+".tar.gz")
+	zipballURL := repo.HTMLURL() + "/archive/" + url.PathEscape(t.Name+".zip")
+
+	// Archive URLs are "" if the download feature is disabled
+	if setting.Repository.DisableDownloadSourceArchives {
+		tarballURL = ""
+		zipballURL = ""
+	}
+
+	return &api.Tag{
+		Name:       t.Name,
+		Message:    t.MessageUTF8(),
+		ID:         t.ID.String(),
+		Commit:     ToCommitMeta(repo, t),
+		ZipballURL: zipballURL,
+		TarballURL: tarballURL,
+	}
+}
+
+// ToActionTask convert an actions_model.ActionTask to an api.ActionTask
+func ToActionTask(ctx context.Context, t *actions_model.ActionTask) (*api.ActionTask, error) {
+	// don't need Steps here, only need to load job and its run
+	if err := t.LoadJob(ctx); err != nil {
+		return nil, err
+	}
+	if err := t.Job.LoadRun(ctx); err != nil {
+		return nil, err
+	}
+	if err := t.Job.Run.LoadRepo(ctx); err != nil {
+		return nil, err
+	}
+	return &api.ActionTask{
+		ID:           t.ID,
+		Name:         t.Job.Name,
+		HeadBranch:   t.Job.Run.PrettyRef(),
+		HeadSHA:      t.Job.CommitSHA,
+		RunNumber:    t.Job.Run.Index,
+		Event:        t.Job.Run.TriggerEvent,
+		DisplayTitle: t.Job.Run.Title,
+		Status:       t.Status.String(),
+		WorkflowID:   t.Job.Run.WorkflowID,
+		URL:          httplib.MakeAbsoluteURL(ctx, t.Job.Run.Link()),
+		CreatedAt:    t.Created.AsLocalTime(),
+		UpdatedAt:    t.Updated.AsLocalTime(),
+		RunStartedAt: t.Started.AsLocalTime(),
+	}, nil
+}
+
+func ToActionWorkflowRun(ctx context.Context, run *actions_model.ActionRun, attempt *actions_model.ActionRunAttempt) (_ *api.ActionWorkflowRun, err error) {
+	if err := run.LoadRepo(ctx); err != nil {
+		return nil, err
+	}
+	if err := run.LoadTriggerUser(ctx); err != nil {
+		return nil, err
+	}
+
+	if attempt == nil {
+		attempt, _, err = run.GetLatestAttempt(ctx)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	runAttempt := int64(0)
+	status, conclusion := ToActionsStatus(run.Status)
+	startedAt := run.Started.AsLocalTime()
+	completedAt := run.Stopped.AsLocalTime()
+	actor := run.TriggerUser       // The username of the user that triggered the initial workflow run.
+	triggerUser := run.TriggerUser // The username of the user that initiated the workflow run. If the workflow run is a re-run, this value may differ from actor.
+
+	// previousAttemptURL is the value of ActionWorkflowRun.PreviousAttemptURL, which is declared as *string without `omitempty` on purpose:
+	// a nil value must still appear in the JSON body as `"previous_attempt_url": null`, matching GitHub's Actions API.
+	var previousAttemptURL *string
+
+	if attempt != nil {
+		attempt.Run = run
+		if err := attempt.LoadAttributes(ctx); err != nil {
+			return nil, err
+		}
+		runAttempt = attempt.Attempt
+		status, conclusion = ToActionsStatus(attempt.Status)
+		startedAt = attempt.Started.AsLocalTime()
+		completedAt = attempt.Stopped.AsLocalTime()
+		triggerUser = attempt.TriggerUser
+		if attempt.Attempt > 1 {
+			previousAttemptURL = new(fmt.Sprintf("%s/actions/runs/%d/attempts/%d", run.Repo.APIURL(ctx), run.ID, attempt.Attempt-1))
+		}
+	}
+
+	return &api.ActionWorkflowRun{
+		ID:                 run.ID,
+		URL:                fmt.Sprintf("%s/actions/runs/%d", run.Repo.APIURL(ctx), run.ID),
+		PreviousAttemptURL: previousAttemptURL,
+		HTMLURL:            run.HTMLURL(ctx),
+		RunNumber:          run.Index,
+		RunAttempt:         runAttempt,
+		StartedAt:          startedAt,
+		CompletedAt:        completedAt,
+		Event:              run.TriggerEvent,
+		DisplayTitle:       run.Title,
+		HeadBranch:         git.RefName(run.Ref).BranchName(),
+		HeadSha:            run.CommitSHA,
+		Status:             status,
+		Conclusion:         conclusion,
+		Path:               fmt.Sprintf("%s@%s", run.WorkflowID, run.Ref),
+		Repository:         ToRepo(ctx, run.Repo, access_model.Permission{AccessMode: perm.AccessModeNone}),
+		TriggerActor:       ToUser(ctx, triggerUser, nil),
+		Actor:              ToUser(ctx, actor, nil),
+	}, nil
+}
+
+func ToWorkflowRunAction(status actions_model.Status) (action string) {
+	switch status {
+	case actions_model.StatusWaiting, actions_model.StatusBlocked:
+		action = "requested"
+	case actions_model.StatusRunning:
+		action = "in_progress"
+	default:
+		if status.IsDone() {
+			action = "completed"
+		} else {
+			setting.PanicInDevOrTesting("unknown action status: %v", status)
+		}
+	}
+	return action
+}
+
+func ToActionsStatus(status actions_model.Status) (action, conclusion string) {
+	switch status {
+	case actions_model.StatusWaiting:
+		action = "queued" // "waiting" is a naming conflict of the webhook between Gitea and GitHub Actions
+	case actions_model.StatusBlocked:
+		action = "waiting" // naming conflict (as above)
+	case actions_model.StatusRunning:
+		action = "in_progress"
+	default:
+		action = "completed"
+		switch status {
+		case actions_model.StatusSuccess:
+			conclusion = "success"
+		case actions_model.StatusCancelled:
+			conclusion = "cancelled"
+		case actions_model.StatusFailure:
+			conclusion = "failure"
+		case actions_model.StatusSkipped:
+			conclusion = "skipped"
+		default:
+			setting.PanicInDevOrTesting("unknown action status: %v", status)
+		}
+	}
+	return action, conclusion
+}
+
+// ToActionWorkflowJob convert a actions_model.ActionRunJob to an api.ActionWorkflowJob
+// task is optional and can be nil
+func ToActionWorkflowJob(ctx context.Context, repo *repo_model.Repository, task *actions_model.ActionTask, job *actions_model.ActionRunJob) (*api.ActionWorkflowJob, error) {
+	err := job.LoadAttributes(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	status, conclusion := ToActionsStatus(job.Status)
+	var runnerID int64
+	var runnerName string
+	var steps []*api.ActionWorkflowStep
+
+	if effectiveTaskID := job.EffectiveTaskID(); effectiveTaskID != 0 {
+		if task == nil {
+			task, _, err = db.GetByID[actions_model.ActionTask](ctx, effectiveTaskID)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		if task != nil {
+			if task.Steps == nil {
+				task.Steps, err = actions_model.GetTaskStepsByTaskID(ctx, task.ID)
+				if err != nil {
+					return nil, err
+				}
+				task.Steps = util.SliceNilAsEmpty(task.Steps)
+			}
+			runnerID = task.RunnerID
+			if runner, ok, _ := db.GetByID[actions_model.ActionRunner](ctx, runnerID); ok {
+				runnerName = runner.Name
+			}
+			for i, step := range task.Steps {
+				stepStatus, stepConclusion := ToActionsStatus(step.Status)
+				steps = append(steps, &api.ActionWorkflowStep{
+					Name:        step.Name,
+					Number:      int64(i),
+					Status:      stepStatus,
+					Conclusion:  stepConclusion,
+					StartedAt:   step.Started.AsTime().UTC(),
+					CompletedAt: step.Stopped.AsTime().UTC(),
+				})
+			}
+		}
+	}
+
+	return &api.ActionWorkflowJob{
+		ID: job.ID,
+		// missing api endpoint for this location
+		URL:     fmt.Sprintf("%s/actions/jobs/%d", repo.APIURL(ctx), job.ID),
+		HTMLURL: fmt.Sprintf("%s/jobs/%d", job.Run.HTMLURL(ctx), job.ID),
+		RunID:   job.RunID,
+		// Missing api endpoint for this location, artifacts are available under a nested url
+		RunURL:      fmt.Sprintf("%s/actions/runs/%d", repo.APIURL(ctx), job.RunID),
+		Name:        job.Name,
+		Labels:      job.RunsOn,
+		RunAttempt:  job.Attempt,
+		HeadSha:     job.Run.CommitSHA,
+		HeadBranch:  git.RefName(job.Run.Ref).BranchName(),
+		Status:      status,
+		Conclusion:  conclusion,
+		RunnerID:    runnerID,
+		RunnerName:  runnerName,
+		Steps:       util.SliceNilAsEmpty(steps),
+		CreatedAt:   job.Created.AsTime().UTC(),
+		StartedAt:   job.Started.AsTime().UTC(),
+		CompletedAt: job.Stopped.AsTime().UTC(),
+	}, nil
+}
+
+func getActionWorkflowEntry(ctx context.Context, repo *repo_model.Repository, commit *git.Commit, refName git.RefName, folder string, entry *git.TreeEntry) *api.ActionWorkflow {
+	cfgUnit := repo.MustGetUnit(ctx, unit.TypeActions)
+	cfg := cfgUnit.ActionsConfig()
+
+	workflowURL := fmt.Sprintf("%s/actions/workflows/%s", repo.APIURL(), util.PathEscapeSegments(entry.Name()))
+	workflowRepoURL := fmt.Sprintf("%s/src/commit/%s/%s/%s", repo.HTMLURL(ctx), commit.ID.String(), util.PathEscapeSegments(folder), util.PathEscapeSegments(entry.Name()))
+	if refWebLinkPath := refName.RefWebLinkPath(); refWebLinkPath != "" {
+		workflowRepoURL = fmt.Sprintf("%s/src/%s/%s/%s", repo.HTMLURL(ctx), refWebLinkPath, util.PathEscapeSegments(folder), util.PathEscapeSegments(entry.Name()))
+	}
+	badgeURL := fmt.Sprintf("%s/actions/workflows/%s/badge.svg?branch=%s", repo.HTMLURL(ctx), util.PathEscapeSegments(entry.Name()), url.QueryEscape(repo.DefaultBranch))
+
+	// See https://docs.github.com/en/rest/actions/workflows?apiVersion=2022-11-28#get-a-workflow
+	// State types:
+	// - active
+	// - deleted
+	// - disabled_fork
+	// - disabled_inactivity
+	// - disabled_manually
+	state := "active"
+	if cfg.IsWorkflowDisabled(entry.Name()) {
+		state = "disabled_manually"
+	}
+
+	// The CreatedAt and UpdatedAt fields currently reflect the timestamp of the latest commit, which can later be refined
+	// by retrieving the first and last commits for the file history. The first commit would indicate the creation date,
+	// while the last commit would represent the modification date. The DeletedAt could be determined by identifying
+	// the last commit where the file existed. However, this implementation has not been done here yet, as it would likely
+	// cause a significant performance degradation.
+	createdAt := commit.Author.When
+	updatedAt := commit.Author.When
+
+	content, err := actions.GetContentFromEntry(entry)
+	name := entry.Name()
+	if err == nil {
+		workflow, err := model.ReadWorkflow(bytes.NewReader(content))
+		if err == nil {
+			// Only use the name when specified in the workflow file
+			if workflow.Name != "" {
+				name = workflow.Name
+			}
+		} else {
+			log.Error("getActionWorkflowEntry: Failed to parse workflow: %v", err)
+		}
+	} else {
+		log.Error("getActionWorkflowEntry: Failed to get content from entry: %v", err)
+	}
+
+	return &api.ActionWorkflow{
+		ID:        entry.Name(),
+		Name:      name,
+		Path:      path.Join(folder, entry.Name()),
+		State:     state,
+		CreatedAt: createdAt,
+		UpdatedAt: updatedAt,
+		URL:       workflowURL,
+		HTMLURL:   workflowRepoURL,
+		BadgeURL:  badgeURL,
+	}
+}
+
+func ListActionWorkflows(ctx context.Context, gitrepo *git.Repository, repo *repo_model.Repository) ([]*api.ActionWorkflow, error) {
+	defaultBranchCommit, err := gitrepo.GetBranchCommit(repo.DefaultBranch)
+	if err != nil {
+		return nil, err
+	}
+
+	folder, entries, err := actions.ListWorkflows(defaultBranchCommit)
+	if err != nil {
+		return nil, err
+	}
+
+	workflows := make([]*api.ActionWorkflow, len(entries))
+	for i, entry := range entries {
+		workflows[i] = getActionWorkflowEntry(ctx, repo, defaultBranchCommit, git.RefNameFromBranch(repo.DefaultBranch), folder, entry)
+	}
+
+	return workflows, nil
+}
+
+func GetActionWorkflow(ctx context.Context, gitrepo *git.Repository, repo *repo_model.Repository, workflowID string) (*api.ActionWorkflow, error) {
+	defaultBranchCommit, err := gitrepo.GetBranchCommit(repo.DefaultBranch)
+	if err != nil {
+		return nil, err
+	}
+
+	return getActionWorkflowFromCommit(ctx, repo, defaultBranchCommit, git.RefNameFromBranch(repo.DefaultBranch), workflowID)
+}
+
+func GetActionWorkflowByRef(ctx context.Context, gitrepo *git.Repository, repo *repo_model.Repository, workflowID string, ref git.RefName) (*api.ActionWorkflow, error) {
+	if ref == "" {
+		return nil, util.NewNotExistErrorf("workflow %q not found", workflowID)
+	}
+
+	refCommitID, err := gitrepo.GetRefCommitID(ref.String())
+	if err != nil {
+		return nil, err
+	}
+	refCommit, err := gitrepo.GetCommit(refCommitID)
+	if err != nil {
+		return nil, err
+	}
+
+	return getActionWorkflowFromCommit(ctx, repo, refCommit, ref, workflowID)
+}
+
+func getActionWorkflowFromCommit(ctx context.Context, repo *repo_model.Repository, commit *git.Commit, refName git.RefName, workflowID string) (*api.ActionWorkflow, error) {
+	folder, entries, err := actions.ListWorkflows(commit)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, entry := range entries {
+		if entry.Name() == workflowID {
+			return getActionWorkflowEntry(ctx, repo, commit, refName, folder, entry), nil
+		}
+	}
+
+	return nil, util.NewNotExistErrorf("workflow %q not found", workflowID)
+}
+
+// ToActionArtifact convert a actions_model.ActionArtifact to an api.ActionArtifact
+func ToActionArtifact(repo *repo_model.Repository, art *actions_model.ActionArtifact) (*api.ActionArtifact, error) {
+	url := fmt.Sprintf("%s/actions/artifacts/%d", repo.APIURL(), art.ID)
+
+	return &api.ActionArtifact{
+		ID:                 art.ID,
+		Name:               art.ArtifactName,
+		SizeInBytes:        art.FileSize,
+		Expired:            art.Status == actions_model.ArtifactStatusExpired,
+		URL:                url,
+		ArchiveDownloadURL: url + "/zip",
+		CreatedAt:          art.CreatedUnix.AsLocalTime(),
+		UpdatedAt:          art.UpdatedUnix.AsLocalTime(),
+		ExpiresAt:          art.ExpiredUnix.AsLocalTime(),
+		WorkflowRun: &api.ActionWorkflowRun{
+			ID:           art.RunID,
+			RepositoryID: art.RepoID,
+			HeadSha:      art.CommitSHA,
+		},
+	}, nil
+}
+
+func ToActionRunner(ctx context.Context, runner *actions_model.ActionRunner) *api.ActionRunner {
+	status := runner.Status()
+	apiStatus := "offline"
+	if runner.IsOnline() {
+		apiStatus = "online"
+	}
+	labels := make([]*api.ActionRunnerLabel, len(runner.AgentLabels))
+	for i, label := range runner.AgentLabels {
+		labels[i] = &api.ActionRunnerLabel{
+			ID:   int64(i),
+			Name: label,
+			Type: "custom",
+		}
+	}
+	return &api.ActionRunner{
+		ID:        runner.ID,
+		Name:      runner.Name,
+		Status:    apiStatus,
+		Busy:      status == runnerv1.RunnerStatus_RUNNER_STATUS_ACTIVE,
+		Disabled:  runner.IsDisabled,
+		Ephemeral: runner.Ephemeral,
+		Labels:    labels,
+	}
+}
+
+// ToVerification convert a git.Commit.Signature to an api.PayloadCommitVerification
+func ToVerification(ctx context.Context, c *git.Commit) *api.PayloadCommitVerification {
+	verif := asymkey_service.ParseCommitWithSignature(ctx, c)
+	commitVerification := &api.PayloadCommitVerification{
+		Verified: verif.Verified,
+		Reason:   verif.Reason,
+	}
+	if c.Signature != nil {
+		commitVerification.Signature = c.Signature.Signature
+		commitVerification.Payload = c.Signature.Payload
+	}
+	if verif.SigningUser != nil {
+		commitVerification.Signer = &api.PayloadUser{
+			UserName: verif.SigningUser.Name,
+			Name:     verif.SigningUser.DisplayName(),
+			Email:    verif.SigningEmail, // Use the email from the signature, not from the user profile
+		}
+	}
+	return commitVerification
+}
+
+// ToPublicKey convert asymkey_model.PublicKey to api.PublicKey
+func ToPublicKey(apiLink string, key *asymkey_model.PublicKey) *api.PublicKey {
+	return &api.PublicKey{
+		ID:          key.ID,
+		Key:         key.Content,
+		URL:         fmt.Sprintf("%s%d", apiLink, key.ID),
+		Title:       key.Name,
+		Fingerprint: key.Fingerprint,
+		Created:     key.CreatedUnix.AsTime(),
+		Updated:     key.UpdatedUnix.AsTime(),
+	}
+}
+
+// ToGPGKey converts models.GPGKey to api.GPGKey
+func ToGPGKey(key *asymkey_model.GPGKey) *api.GPGKey {
+	subkeys := make([]*api.GPGKey, len(key.SubsKey))
+	for id, k := range key.SubsKey {
+		subkeys[id] = &api.GPGKey{
+			ID:                k.ID,
+			PrimaryKeyID:      k.PrimaryKeyID,
+			KeyID:             k.KeyID,
+			PublicKey:         k.Content,
+			Created:           k.CreatedUnix.AsTime(),
+			Expires:           k.ExpiredUnix.AsTime(),
+			CanSign:           k.CanSign,
+			CanEncryptComms:   k.CanEncryptComms,
+			CanEncryptStorage: k.CanEncryptStorage,
+			CanCertify:        k.CanSign,
+			Verified:          k.Verified,
+		}
+	}
+	emails := make([]*api.GPGKeyEmail, len(key.Emails))
+	for i, e := range key.Emails {
+		emails[i] = ToGPGKeyEmail(e)
+	}
+	return &api.GPGKey{
+		ID:                key.ID,
+		PrimaryKeyID:      key.PrimaryKeyID,
+		KeyID:             key.KeyID,
+		PublicKey:         key.Content,
+		Created:           key.CreatedUnix.AsTime(),
+		Expires:           key.ExpiredUnix.AsTime(),
+		Emails:            emails,
+		SubsKey:           subkeys,
+		CanSign:           key.CanSign,
+		CanEncryptComms:   key.CanEncryptComms,
+		CanEncryptStorage: key.CanEncryptStorage,
+		CanCertify:        key.CanSign,
+		Verified:          key.Verified,
+	}
+}
+
+// ToGPGKeyEmail convert models.EmailAddress to api.GPGKeyEmail
+func ToGPGKeyEmail(email *user_model.EmailAddress) *api.GPGKeyEmail {
+	return &api.GPGKeyEmail{
+		Email:    email.Email,
+		Verified: email.IsActivated,
+	}
+}
+
+// ToGitHook convert git.Hook to api.GitHook
+func ToGitHook(h *git.Hook) *api.GitHook {
+	return &api.GitHook{
+		Name:     h.Name(),
+		IsActive: h.IsActive,
+		Content:  h.Content,
+	}
+}
+
+// ToDeployKey convert asymkey_model.DeployKey to api.DeployKey
+func ToDeployKey(apiLink string, key *asymkey_model.DeployKey) *api.DeployKey {
+	return &api.DeployKey{
+		ID:          key.ID,
+		KeyID:       key.KeyID,
+		Key:         key.Content,
+		Fingerprint: key.Fingerprint,
+		URL:         fmt.Sprintf("%s%d", apiLink, key.ID),
+		Title:       key.Name,
+		Created:     key.CreatedUnix.AsTime(),
+		ReadOnly:    key.Mode == perm.AccessModeRead, // All deploy keys are read-only.
+	}
+}
+
+// ToOrganization convert user_model.User to api.Organization
+func ToOrganization(ctx context.Context, org *organization.Organization) *api.Organization {
+	return &api.Organization{
+		ID:                        org.ID,
+		AvatarURL:                 org.AsUser().AvatarLink(ctx),
+		Name:                      org.Name,
+		UserName:                  org.Name,
+		FullName:                  org.FullName,
+		Email:                     org.Email,
+		Description:               org.Description,
+		Website:                   org.Website,
+		Location:                  org.Location,
+		Visibility:                api.UserVisibility(org.Visibility.String()),
+		RepoAdminChangeTeamAccess: org.RepoAdminChangeTeamAccess,
+	}
+}
+
+// ToTeam convert models.Team to api.Team
+func ToTeam(ctx context.Context, team *organization.Team, loadOrg ...bool) (*api.Team, error) {
+	teams, err := ToTeams(ctx, []*organization.Team{team}, len(loadOrg) != 0 && loadOrg[0])
+	if err != nil || len(teams) == 0 {
+		return nil, err
+	}
+	return teams[0], nil
+}
+
+// ToTeams convert models.Team list to api.Team list
+func ToTeams(ctx context.Context, teams []*organization.Team, loadOrgs bool) ([]*api.Team, error) {
+	cache := make(map[int64]*api.Organization)
+	apiTeams := make([]*api.Team, 0, len(teams))
+	for _, t := range teams {
+		if err := t.LoadUnits(ctx); err != nil {
+			return nil, err
+		}
+
+		apiTeam := &api.Team{
+			ID:                      t.ID,
+			Name:                    t.Name,
+			Description:             t.Description,
+			IncludesAllRepositories: t.IncludesAllRepositories,
+			CanCreateOrgRepo:        t.CanCreateOrgRepo,
+			Permission:              api.AccessLevelName(t.AccessMode.ToString()),
+			Units:                   t.GetUnitNames(),
+			UnitsMap:                t.GetUnitsMap(),
+		}
+
+		if loadOrgs {
+			apiOrg, ok := cache[t.OrgID]
+			if !ok {
+				org, err := organization.GetOrgByID(ctx, t.OrgID)
+				if err != nil {
+					return nil, err
+				}
+				apiOrg = ToOrganization(ctx, org)
+				cache[t.OrgID] = apiOrg
+			}
+			apiTeam.Organization = apiOrg
+		}
+
+		apiTeams = append(apiTeams, apiTeam)
+	}
+	return apiTeams, nil
+}
+
+// ToAnnotatedTag convert git.Tag to api.AnnotatedTag
+func ToAnnotatedTag(ctx context.Context, repo *repo_model.Repository, t *git.Tag, c *git.Commit) *api.AnnotatedTag {
+	return &api.AnnotatedTag{
+		Tag:          t.Name,
+		SHA:          t.ID.String(),
+		Object:       ToAnnotatedTagObject(repo, c),
+		Message:      t.MessageUTF8(),
+		URL:          repo.APIURL() + "/git/tags/" + t.ID.String(),
+		Tagger:       ToCommitUser(t.Tagger),
+		Verification: ToVerification(ctx, c),
+	}
+}
+
+// ToAnnotatedTagObject convert a git.Commit to an api.AnnotatedTagObject
+func ToAnnotatedTagObject(repo *repo_model.Repository, commit *git.Commit) *api.AnnotatedTagObject {
+	return &api.AnnotatedTagObject{
+		SHA:  commit.ID.String(),
+		Type: string(git.ObjectCommit),
+		URL:  repo.APIURL() + "/git/commits/" + commit.ID.String(),
+	}
+}
+
+// ToTagProtection convert a git.ProtectedTag to an api.TagProtection
+func ToTagProtection(ctx context.Context, pt *git_model.ProtectedTag, repo *repo_model.Repository) *api.TagProtection {
+	readers, err := access_model.GetUsersWithUnitAccess(ctx, repo, perm.AccessModeRead, unit.TypePullRequests)
+	if err != nil {
+		log.Error("GetRepoReaders: %v", err)
+	}
+
+	whitelistUsernames := getWhitelistEntities(readers, pt.AllowlistUserIDs)
+
+	teamReaders, err := organization.GetTeamsWithAccessToAnyRepoUnit(ctx, repo.Owner.ID, repo.ID, perm.AccessModeRead, unit.TypeCode, unit.TypePullRequests)
+	if err != nil {
+		log.Error("Repo.Owner.TeamsWithAccessToRepo: %v", err)
+	}
+
+	whitelistTeams := getWhitelistEntities(teamReaders, pt.AllowlistTeamIDs)
+
+	return &api.TagProtection{
+		ID:                 pt.ID,
+		NamePattern:        pt.NamePattern,
+		WhitelistUsernames: whitelistUsernames,
+		WhitelistTeams:     whitelistTeams,
+		Created:            pt.CreatedUnix.AsTime(),
+		Updated:            pt.UpdatedUnix.AsTime(),
+	}
+}
+
+// ToTopicResponse convert from models.Topic to api.TopicResponse
+func ToTopicResponse(topic *repo_model.Topic) *api.TopicResponse {
+	return &api.TopicResponse{
+		ID:        topic.ID,
+		Name:      topic.Name,
+		RepoCount: topic.RepoCount,
+		Created:   topic.CreatedUnix.AsTime(),
+		Updated:   topic.UpdatedUnix.AsTime(),
+	}
+}
+
+// ToOAuth2Application convert from auth.OAuth2Application to api.OAuth2Application
+func ToOAuth2Application(app *auth.OAuth2Application) *api.OAuth2Application {
+	return &api.OAuth2Application{
+		ID:                         app.ID,
+		Name:                       app.Name,
+		ClientID:                   app.ClientID,
+		ClientSecret:               app.ClientSecret,
+		ConfidentialClient:         app.ConfidentialClient,
+		SkipSecondaryAuthorization: app.SkipSecondaryAuthorization,
+		RedirectURIs:               app.RedirectURIs,
+		Created:                    app.CreatedUnix.AsTime(),
+	}
+}
+
+// ToLFSLock convert a LFSLock to api.LFSLock
+func ToLFSLock(ctx context.Context, l *git_model.LFSLock) *api.LFSLock {
+	_, u, err := user_model.GetPossibleUserByID(ctx, l.OwnerID)
+	if err != nil {
+		return nil
+	}
+	return &api.LFSLock{
+		ID:       strconv.FormatInt(l.ID, 10),
+		Path:     l.Path,
+		LockedAt: l.Created.Round(time.Second),
+		Owner: &api.LFSLockOwner{
+			Name: u.Name,
+		},
+	}
+}
+
+// ToChangedFile convert a gitdiff.DiffFile to api.ChangedFile
+func ToChangedFile(f *gitdiff.DiffFile, repo *repo_model.Repository, commit string) *api.ChangedFile {
+	status := "changed"
+	previousFilename := ""
+	if f.IsDeleted {
+		status = "deleted"
+	} else if f.IsCreated {
+		status = "added"
+	} else if f.IsRenamed && f.Type == gitdiff.DiffFileCopy {
+		status = "copied"
+	} else if f.IsRenamed && f.Type == gitdiff.DiffFileRename {
+		status = "renamed"
+		previousFilename = f.OldName
+	} else if f.Addition == 0 && f.Deletion == 0 {
+		status = "unchanged"
+	}
+
+	file := &api.ChangedFile{
+		Filename:         f.GetDiffFileName(),
+		Status:           status,
+		Additions:        f.Addition,
+		Deletions:        f.Deletion,
+		Changes:          f.Addition + f.Deletion,
+		PreviousFilename: previousFilename,
+		HTMLURL:          fmt.Sprint(repo.HTMLURL(), "/src/commit/", commit, "/", util.PathEscapeSegments(f.GetDiffFileName())),
+		ContentsURL:      fmt.Sprint(repo.APIURL(), "/contents/", util.PathEscapeSegments(f.GetDiffFileName()), "?ref=", commit),
+		RawURL:           fmt.Sprint(repo.HTMLURL(), "/raw/commit/", commit, "/", util.PathEscapeSegments(f.GetDiffFileName())),
+	}
+
+	return file
+}

services/convert/git_commit.go

@@ -0,0 +1,226 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+	"net/url"
+	"time"
+
+	repo_model "gitea.dev/models/repo"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/git"
+	"gitea.dev/modules/gitrepo"
+	"gitea.dev/modules/log"
+	api "gitea.dev/modules/structs"
+	ctx "gitea.dev/services/context"
+	"gitea.dev/services/gitdiff"
+)
+
+// ToCommitUser convert a git.Signature to an api.CommitUser
+func ToCommitUser(sig *git.Signature) *api.CommitUser {
+	return &api.CommitUser{
+		Identity: api.Identity{
+			Name:  sig.Name,
+			Email: sig.Email,
+		},
+		Date: sig.When.UTC().Format(time.RFC3339),
+	}
+}
+
+// ToCommitMeta convert a git.Tag to an api.CommitMeta
+func ToCommitMeta(repo *repo_model.Repository, tag *git.Tag) *api.CommitMeta {
+	return &api.CommitMeta{
+		SHA:     tag.Object.String(),
+		URL:     repo.APIURL() + "/git/commits/" + tag.ID.String(),
+		Created: tag.Tagger.When,
+	}
+}
+
+// ToPayloadCommit convert a git.Commit to api.PayloadCommit
+func ToPayloadCommit(ctx context.Context, repo *repo_model.Repository, c *git.Commit) *api.PayloadCommit {
+	authorUsername := ""
+	if author, err := user_model.GetUserByEmail(ctx, c.Author.Email); err == nil {
+		authorUsername = author.Name
+	} else if !user_model.IsErrUserNotExist(err) {
+		log.Error("GetUserByEmail: %v", err)
+	}
+
+	committerUsername := ""
+	if committer, err := user_model.GetUserByEmail(ctx, c.Committer.Email); err == nil {
+		committerUsername = committer.Name
+	} else if !user_model.IsErrUserNotExist(err) {
+		log.Error("GetUserByEmail: %v", err)
+	}
+
+	return &api.PayloadCommit{
+		ID:      c.ID.String(),
+		Message: c.MessageUTF8(),
+		URL:     repo.HTMLURL() + "/commit/" + c.ID.String(),
+		Author: &api.PayloadUser{
+			Name:     c.Author.Name,
+			Email:    c.Author.Email,
+			UserName: authorUsername,
+		},
+		Committer: &api.PayloadUser{
+			Name:     c.Committer.Name,
+			Email:    c.Committer.Email,
+			UserName: committerUsername,
+		},
+		Timestamp:    c.Author.When,
+		Verification: ToVerification(ctx, c),
+	}
+}
+
+type ToCommitOptions struct {
+	Stat         bool
+	Verification bool
+	Files        bool
+}
+
+func ParseCommitOptions(ctx *ctx.APIContext) ToCommitOptions {
+	return ToCommitOptions{
+		Stat:         ctx.FormString("stat") == "" || ctx.FormBool("stat"),
+		Files:        ctx.FormString("files") == "" || ctx.FormBool("files"),
+		Verification: ctx.FormString("verification") == "" || ctx.FormBool("verification"),
+	}
+}
+
+// ToCommit convert a git.Commit to api.Commit
+func ToCommit(ctx context.Context, repo *repo_model.Repository, gitRepo *git.Repository, commit *git.Commit, userCache map[string]*user_model.User, opts ToCommitOptions) (*api.Commit, error) {
+	var apiAuthor, apiCommitter *api.User
+
+	// Retrieve author and committer information
+
+	var cacheAuthor *user_model.User
+	var ok bool
+	if userCache == nil {
+		cacheAuthor = (*user_model.User)(nil)
+		ok = false
+	} else {
+		cacheAuthor, ok = userCache[commit.Author.Email]
+	}
+
+	if ok {
+		apiAuthor = ToUser(ctx, cacheAuthor, nil)
+	} else {
+		author, err := user_model.GetUserByEmail(ctx, commit.Author.Email)
+		if err != nil && !user_model.IsErrUserNotExist(err) {
+			return nil, err
+		} else if err == nil {
+			apiAuthor = ToUser(ctx, author, nil)
+			if userCache != nil {
+				userCache[commit.Author.Email] = author
+			}
+		}
+	}
+
+	var cacheCommitter *user_model.User
+	if userCache == nil {
+		cacheCommitter = (*user_model.User)(nil)
+		ok = false
+	} else {
+		cacheCommitter, ok = userCache[commit.Committer.Email]
+	}
+
+	if ok {
+		apiCommitter = ToUser(ctx, cacheCommitter, nil)
+	} else {
+		committer, err := user_model.GetUserByEmail(ctx, commit.Committer.Email)
+		if err != nil && !user_model.IsErrUserNotExist(err) {
+			return nil, err
+		} else if err == nil {
+			apiCommitter = ToUser(ctx, committer, nil)
+			if userCache != nil {
+				userCache[commit.Committer.Email] = committer
+			}
+		}
+	}
+
+	// Retrieve parent(s) of the commit
+	apiParents := make([]*api.CommitMeta, commit.ParentCount())
+	for i := 0; i < commit.ParentCount(); i++ {
+		sha, _ := commit.ParentID(i)
+		apiParents[i] = &api.CommitMeta{
+			URL: repo.APIURL() + "/git/commits/" + url.PathEscape(sha.String()),
+			SHA: sha.String(),
+		}
+	}
+
+	res := &api.Commit{
+		CommitMeta: &api.CommitMeta{
+			URL:     repo.APIURL() + "/git/commits/" + url.PathEscape(commit.ID.String()),
+			SHA:     commit.ID.String(),
+			Created: commit.Committer.When,
+		},
+		HTMLURL: repo.HTMLURL() + "/commit/" + url.PathEscape(commit.ID.String()),
+		RepoCommit: &api.RepoCommit{
+			URL: repo.APIURL() + "/git/commits/" + url.PathEscape(commit.ID.String()),
+			Author: &api.CommitUser{
+				Identity: api.Identity{
+					Name:  commit.Author.Name,
+					Email: commit.Author.Email,
+				},
+				Date: commit.Author.When.Format(time.RFC3339),
+			},
+			Committer: &api.CommitUser{
+				Identity: api.Identity{
+					Name:  commit.Committer.Name,
+					Email: commit.Committer.Email,
+				},
+				Date: commit.Committer.When.Format(time.RFC3339),
+			},
+			Message: commit.MessageUTF8(),
+			Tree: &api.CommitMeta{
+				URL:     repo.APIURL() + "/git/trees/" + url.PathEscape(commit.ID.String()),
+				SHA:     commit.ID.String(),
+				Created: commit.Committer.When,
+			},
+		},
+		Author:    apiAuthor,
+		Committer: apiCommitter,
+		Parents:   apiParents,
+	}
+
+	// Retrieve verification for commit
+	if opts.Verification {
+		res.RepoCommit.Verification = ToVerification(ctx, commit)
+	}
+
+	// Retrieve files affected by the commit
+	if opts.Files {
+		fileStatus, err := gitrepo.GetCommitFileStatus(ctx, repo, commit.ID.String())
+		if err != nil {
+			return nil, err
+		}
+
+		affectedFileList := make([]*api.CommitAffectedFiles, 0, len(fileStatus.Added)+len(fileStatus.Removed)+len(fileStatus.Modified))
+		for filestatus, files := range map[string][]string{"added": fileStatus.Added, "removed": fileStatus.Removed, "modified": fileStatus.Modified} {
+			for _, filename := range files {
+				affectedFileList = append(affectedFileList, &api.CommitAffectedFiles{
+					Filename: filename,
+					Status:   filestatus,
+				})
+			}
+		}
+
+		res.Files = affectedFileList
+	}
+
+	// Get diff stats for commit
+	if opts.Stat {
+		diffShortStat, err := gitdiff.GetDiffShortStat(ctx, repo, gitRepo, "", commit.ID.String())
+		if err != nil {
+			return nil, err
+		}
+
+		res.Stats = &api.CommitStats{
+			Total:     diffShortStat.TotalAddition + diffShortStat.TotalDeletion,
+			Additions: diffShortStat.TotalAddition,
+			Deletions: diffShortStat.TotalDeletion,
+		}
+	}
+
+	return res, nil
+}

services/convert/git_commit_test.go

@@ -0,0 +1,40 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"testing"
+	"time"
+
+	repo_model "gitea.dev/models/repo"
+	"gitea.dev/models/unittest"
+	"gitea.dev/modules/git"
+	api "gitea.dev/modules/structs"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestToCommitMeta(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+	headRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
+	sha1 := git.Sha1ObjectFormat
+	signature := &git.Signature{Name: "Test Signature", Email: "test@email.com", When: time.Unix(0, 0)}
+	tag := &git.Tag{
+		Name:          "Test Tag",
+		ID:            sha1.EmptyObjectID(),
+		Object:        sha1.EmptyObjectID(),
+		Type:          "Test Type",
+		Tagger:        signature,
+		CommitMessage: git.CommitMessage{MessageRaw: "Test Message"},
+	}
+
+	commitMeta := ToCommitMeta(headRepo, tag)
+
+	assert.NotNil(t, commitMeta)
+	assert.Equal(t, &api.CommitMeta{
+		SHA:     sha1.EmptyObjectID().String(),
+		URL:     headRepo.APIURL() + "/git/commits/" + sha1.EmptyObjectID().String(),
+		Created: time.Unix(0, 0),
+	}, commitMeta)
+}

services/convert/issue.go

@@ -0,0 +1,338 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+
+	issues_model "gitea.dev/models/issues"
+	access_model "gitea.dev/models/perm/access"
+	repo_model "gitea.dev/models/repo"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/cache"
+	"gitea.dev/modules/label"
+	"gitea.dev/modules/log"
+	"gitea.dev/modules/setting"
+	api "gitea.dev/modules/structs"
+	"gitea.dev/modules/util"
+)
+
+func ToIssue(ctx context.Context, doer *user_model.User, issue *issues_model.Issue) *api.Issue {
+	return toIssue(ctx, doer, issue, WebAssetDownloadURL)
+}
+
+// ToAPIIssue converts an Issue to API format
+// it assumes some fields assigned with values:
+// Required - Poster, Labels,
+// Optional - Milestone, Assignee, PullRequest
+func ToAPIIssue(ctx context.Context, doer *user_model.User, issue *issues_model.Issue) *api.Issue {
+	return toIssue(ctx, doer, issue, APIAssetDownloadURL)
+}
+
+func toIssue(ctx context.Context, doer *user_model.User, issue *issues_model.Issue, getDownloadURL func(repo *repo_model.Repository, attach *repo_model.Attachment) string) *api.Issue {
+	if err := issue.LoadPoster(ctx); err != nil {
+		return &api.Issue{}
+	}
+	if err := issue.LoadRepo(ctx); err != nil {
+		return &api.Issue{}
+	}
+	if err := issue.LoadAttachments(ctx); err != nil {
+		return &api.Issue{}
+	}
+	if err := issue.LoadPinOrder(ctx); err != nil {
+		return &api.Issue{}
+	}
+
+	apiIssue := &api.Issue{
+		ID:          issue.ID,
+		Index:       issue.Index,
+		Poster:      ToUser(ctx, issue.Poster, doer),
+		Title:       issue.Title,
+		Body:        issue.Content,
+		Attachments: toAttachments(issue.Repo, issue.Attachments, getDownloadURL),
+		Ref:         issue.Ref,
+		State:       issue.State(),
+		IsLocked:    issue.IsLocked,
+		Comments:    issue.NumComments,
+		Created:     issue.CreatedUnix.AsTime(),
+		Updated:     issue.UpdatedUnix.AsTime(),
+		PinOrder:    util.Iif(issue.PinOrder == -1, 0, issue.PinOrder), // -1 means loaded with no pin order
+
+		TimeEstimate:   issue.TimeEstimate,
+		ContentVersion: issue.ContentVersion,
+	}
+
+	if issue.Repo != nil {
+		if err := issue.Repo.LoadOwner(ctx); err != nil {
+			return &api.Issue{}
+		}
+		apiIssue.URL = issue.APIURL(ctx)
+		apiIssue.HTMLURL = issue.HTMLURL(ctx)
+		if err := issue.LoadLabels(ctx); err != nil {
+			return &api.Issue{}
+		}
+		apiIssue.Labels = util.SliceNilAsEmpty(ToLabelList(issue.Labels, issue.Repo, issue.Repo.Owner))
+		apiIssue.Repo = &api.RepositoryMeta{
+			ID:       issue.Repo.ID,
+			Name:     issue.Repo.Name,
+			Owner:    issue.Repo.OwnerName,
+			FullName: issue.Repo.FullName(),
+		}
+	}
+
+	if issue.ClosedUnix != 0 {
+		apiIssue.Closed = issue.ClosedUnix.AsTimePtr()
+	}
+
+	if err := issue.LoadMilestone(ctx); err != nil {
+		return &api.Issue{}
+	}
+	if issue.Milestone != nil {
+		apiIssue.Milestone = ToAPIMilestone(issue.Milestone)
+	}
+
+	if err := issue.LoadProjects(ctx); err != nil {
+		return &api.Issue{}
+	}
+	if len(issue.Projects) > 0 {
+		apiIssue.Projects = ToAPIProjectList(issue.Projects)
+	}
+
+	if err := issue.LoadAssignees(ctx); err != nil {
+		return &api.Issue{}
+	}
+	if len(issue.Assignees) > 0 {
+		for _, assignee := range issue.Assignees {
+			apiIssue.Assignees = append(apiIssue.Assignees, ToUser(ctx, assignee, nil))
+		}
+		apiIssue.Assignee = ToUser(ctx, issue.Assignees[0], nil) // For compatibility, we're keeping the first assignee as `apiIssue.Assignee`
+	}
+	if issue.IsPull {
+		if err := issue.LoadPullRequest(ctx); err != nil {
+			return &api.Issue{}
+		}
+		if issue.PullRequest != nil {
+			apiIssue.PullRequest = &api.PullRequestMeta{
+				HasMerged:        issue.PullRequest.HasMerged,
+				IsWorkInProgress: issue.PullRequest.IsWorkInProgress(ctx),
+			}
+			if issue.PullRequest.HasMerged {
+				apiIssue.PullRequest.Merged = issue.PullRequest.MergedUnix.AsTimePtr()
+			}
+			// Add pr's html url
+			apiIssue.PullRequest.HTMLURL = issue.HTMLURL(ctx)
+		}
+	}
+	if issue.DeadlineUnix != 0 {
+		apiIssue.Deadline = issue.DeadlineUnix.AsTimePtr()
+	}
+
+	return apiIssue
+}
+
+// ToIssueList converts an IssueList to API format
+func ToIssueList(ctx context.Context, doer *user_model.User, il issues_model.IssueList) []*api.Issue {
+	result := make([]*api.Issue, len(il))
+	_ = il.LoadPinOrder(ctx)
+	for i := range il {
+		result[i] = ToIssue(ctx, doer, il[i])
+	}
+	return result
+}
+
+// ToAPIIssueList converts an IssueList to API format
+func ToAPIIssueList(ctx context.Context, doer *user_model.User, il issues_model.IssueList) []*api.Issue {
+	result := make([]*api.Issue, len(il))
+	_ = il.LoadPinOrder(ctx)
+	for i := range il {
+		result[i] = ToAPIIssue(ctx, doer, il[i])
+	}
+	return result
+}
+
+// ToTrackedTime converts TrackedTime to API format
+func ToTrackedTime(ctx context.Context, doer *user_model.User, t *issues_model.TrackedTime) (apiT *api.TrackedTime) {
+	apiT = &api.TrackedTime{
+		ID:      t.ID,
+		IssueID: t.IssueID,
+		UserID:  t.UserID,
+		Time:    t.Time,
+		Created: t.Created,
+	}
+	if t.Issue != nil {
+		apiT.Issue = ToAPIIssue(ctx, doer, t.Issue)
+	}
+	if t.User != nil {
+		apiT.UserName = t.User.Name
+	}
+	return apiT
+}
+
+// ToStopWatches convert Stopwatch list to api.StopWatches
+func ToStopWatches(ctx context.Context, doer *user_model.User, sws []*issues_model.Stopwatch) (api.StopWatches, error) {
+	result := api.StopWatches(make([]api.StopWatch, 0, len(sws)))
+
+	issueCache := make(map[int64]*issues_model.Issue)
+	repoCache := make(map[int64]*repo_model.Repository)
+	permCache := make(map[int64]access_model.Permission)
+	var (
+		issue *issues_model.Issue
+		repo  *repo_model.Repository
+		ok    bool
+		err   error
+	)
+
+	for _, sw := range sws {
+		issue, ok = issueCache[sw.IssueID]
+		if !ok {
+			issue, err = issues_model.GetIssueByID(ctx, sw.IssueID)
+			if err != nil {
+				return nil, err
+			}
+			issueCache[sw.IssueID] = issue
+		}
+		repo, ok = repoCache[issue.RepoID]
+		if !ok {
+			repo, err = repo_model.GetRepositoryByID(ctx, issue.RepoID)
+			if err != nil {
+				log.Error("GetRepositoryByID(%d): %v", issue.RepoID, err)
+				continue
+			}
+			repoCache[issue.RepoID] = repo
+		}
+
+		// ADD: Check user permissions
+		perm, ok := permCache[repo.ID]
+		if !ok {
+			perm, err = access_model.GetDoerRepoPermission(ctx, repo, doer)
+			if err != nil {
+				continue
+			}
+			permCache[repo.ID] = perm
+		}
+
+		if !perm.CanReadIssuesOrPulls(issue.IsPull) {
+			continue
+		}
+
+		result = append(result, api.StopWatch{
+			Created:       sw.CreatedUnix.AsTime(),
+			Seconds:       sw.Seconds(),
+			Duration:      util.SecToHours(sw.Seconds()),
+			IssueIndex:    issue.Index,
+			IssueTitle:    issue.Title,
+			RepoOwnerName: repo.OwnerName,
+			RepoName:      repo.Name,
+		})
+	}
+	return result, nil
+}
+
+// ToTrackedTimeList converts TrackedTimeList to API format
+func ToTrackedTimeList(ctx context.Context, doer *user_model.User, tl issues_model.TrackedTimeList) api.TrackedTimeList {
+	result := make([]*api.TrackedTime, 0, len(tl))
+	permCache := cache.NewEphemeralCache()
+	for _, t := range tl {
+		// If the issue is not loaded, conservatively skip this entry to avoid bypassing permission checks.
+		if t.Issue == nil || t.Issue.Repo == nil {
+			continue
+		}
+		perm, err := cache.GetWithEphemeralCache(ctx, permCache, "repo-perm", t.Issue.RepoID, func(ctx context.Context, repoID int64) (access_model.Permission, error) {
+			return access_model.GetDoerRepoPermission(ctx, t.Issue.Repo, doer)
+		})
+		if err != nil {
+			continue
+		}
+		if !perm.CanReadIssuesOrPulls(t.Issue.IsPull) {
+			continue
+		}
+		result = append(result, ToTrackedTime(ctx, doer, t))
+	}
+	return result
+}
+
+// ToLabel converts Label to API format
+func ToLabel(label *issues_model.Label, repo *repo_model.Repository, org *user_model.User) *api.Label {
+	result := &api.Label{
+		ID:          label.ID,
+		Name:        label.Name,
+		Exclusive:   label.Exclusive,
+		Color:       strings.TrimLeft(label.Color, "#"),
+		Description: label.Description,
+		IsArchived:  label.IsArchived(),
+	}
+
+	labelBelongsToRepo := label.BelongsToRepo()
+
+	// calculate URL
+	if labelBelongsToRepo && repo != nil {
+		result.URL = fmt.Sprintf("%s/labels/%d", repo.APIURL(), label.ID)
+	} else { // BelongsToOrg
+		if org != nil {
+			result.URL = fmt.Sprintf("%sapi/v1/orgs/%s/labels/%d", setting.AppURL, url.PathEscape(org.Name), label.ID)
+		} else {
+			log.Error("ToLabel did not get org to calculate url for label with id '%d'", label.ID)
+		}
+	}
+
+	if labelBelongsToRepo && repo == nil {
+		log.Error("ToLabel did not get repo to calculate url for label with id '%d'", label.ID)
+	}
+
+	return result
+}
+
+// ToLabelList converts list of Label to API format
+func ToLabelList(labels []*issues_model.Label, repo *repo_model.Repository, org *user_model.User) []*api.Label {
+	result := make([]*api.Label, len(labels))
+	for i := range labels {
+		result[i] = ToLabel(labels[i], repo, org)
+	}
+	return result
+}
+
+// ToAPIMilestone converts Milestone into API Format
+func ToAPIMilestone(m *issues_model.Milestone) *api.Milestone {
+	apiMilestone := &api.Milestone{
+		ID:           m.ID,
+		State:        m.State(),
+		Title:        m.Name,
+		Description:  m.Content,
+		OpenIssues:   m.NumOpenIssues,
+		ClosedIssues: m.NumClosedIssues,
+		Created:      m.CreatedUnix.AsTime(),
+		Updated:      m.UpdatedUnix.AsTimePtr(),
+	}
+	if m.IsClosed {
+		apiMilestone.Closed = m.ClosedDateUnix.AsTimePtr()
+	}
+	if m.DeadlineUnix > 0 {
+		apiMilestone.Deadline = m.DeadlineUnix.AsTimePtr()
+	}
+	return apiMilestone
+}
+
+// ToLabelTemplate converts Label to API format
+func ToLabelTemplate(label *label.Label) *api.LabelTemplate {
+	result := &api.LabelTemplate{
+		Name:        label.Name,
+		Exclusive:   label.Exclusive,
+		Color:       strings.TrimLeft(label.Color, "#"),
+		Description: label.Description,
+	}
+
+	return result
+}
+
+// ToLabelTemplateList converts list of Label to API format
+func ToLabelTemplateList(labels []*label.Label) []*api.LabelTemplate {
+	result := make([]*api.LabelTemplate, len(labels))
+	for i := range labels {
+		result[i] = ToLabelTemplate(labels[i])
+	}
+	return result
+}

services/convert/issue_comment.go

@@ -0,0 +1,192 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+
+	issues_model "gitea.dev/models/issues"
+	repo_model "gitea.dev/models/repo"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/log"
+	api "gitea.dev/modules/structs"
+	"gitea.dev/modules/util"
+)
+
+// ToAPIComment converts a issues_model.Comment to the api.Comment format for API usage
+func ToAPIComment(ctx context.Context, repo *repo_model.Repository, c *issues_model.Comment) *api.Comment {
+	return &api.Comment{
+		ID:          c.ID,
+		Poster:      ToUser(ctx, c.Poster, nil),
+		HTMLURL:     c.HTMLURL(ctx),
+		IssueURL:    c.IssueURL(ctx),
+		PRURL:       c.PRURL(ctx),
+		Body:        c.Content,
+		Attachments: ToAPIAttachments(repo, c.Attachments),
+		Created:     c.CreatedUnix.AsTime(),
+		Updated:     c.UpdatedUnix.AsTime(),
+	}
+}
+
+// ToTimelineComment converts a issues_model.Comment to the api.TimelineComment format
+func ToTimelineComment(ctx context.Context, repo *repo_model.Repository, c *issues_model.Comment, doer *user_model.User) *api.TimelineComment {
+	err := c.LoadMilestone(ctx)
+	if err != nil {
+		log.Error("LoadMilestone: %v", err)
+		return nil
+	}
+
+	err = c.LoadAssigneeUserAndTeam(ctx)
+	if err != nil {
+		log.Error("LoadAssigneeUserAndTeam: %v", err)
+		return nil
+	}
+
+	err = c.LoadResolveDoer(ctx)
+	if err != nil {
+		log.Error("LoadResolveDoer: %v", err)
+		return nil
+	}
+
+	err = c.LoadDepIssueDetails(ctx)
+	if err != nil {
+		log.Error("LoadDepIssueDetails: %v", err)
+		return nil
+	}
+
+	err = c.LoadTime(ctx)
+	if err != nil {
+		log.Error("LoadTime: %v", err)
+		return nil
+	}
+
+	err = c.LoadLabel(ctx)
+	if err != nil {
+		log.Error("LoadLabel: %v", err)
+		return nil
+	}
+
+	if c.Content != "" {
+		if (c.Type == issues_model.CommentTypeAddTimeManual ||
+			c.Type == issues_model.CommentTypeStopTracking ||
+			c.Type == issues_model.CommentTypeDeleteTimeManual) &&
+			c.Content[0] == '|' {
+			// TimeTracking Comments from v1.21 on store the seconds instead of an formatted string
+			// so we check for the "|" delimiter and convert new to legacy format on demand
+			c.Content = util.SecToHours(c.Content[1:])
+		}
+
+		if c.Type == issues_model.CommentTypeChangeTimeEstimate {
+			timeSec, _ := util.ToInt64(c.Content)
+			c.Content = util.TimeEstimateString(timeSec)
+		}
+	}
+
+	comment := &api.TimelineComment{
+		ID:       c.ID,
+		Type:     c.Type.String(),
+		Poster:   ToUser(ctx, c.Poster, nil),
+		HTMLURL:  c.HTMLURL(ctx),
+		IssueURL: c.IssueURL(ctx),
+		PRURL:    c.PRURL(ctx),
+		Body:     c.Content,
+		Created:  c.CreatedUnix.AsTime(),
+		Updated:  c.UpdatedUnix.AsTime(),
+
+		OldProjectID: c.OldProjectID,
+		ProjectID:    c.ProjectID,
+
+		OldTitle: c.OldTitle,
+		NewTitle: c.NewTitle,
+
+		OldRef: c.OldRef,
+		NewRef: c.NewRef,
+
+		RefAction:    c.RefAction.String(),
+		RefCommitSHA: c.CommitSHA,
+
+		ReviewID: c.ReviewID,
+
+		RemovedAssignee: c.RemovedAssignee,
+	}
+
+	if c.OldMilestone != nil {
+		comment.OldMilestone = ToAPIMilestone(c.OldMilestone)
+	}
+	if c.Milestone != nil {
+		comment.Milestone = ToAPIMilestone(c.Milestone)
+	}
+
+	if c.Time != nil {
+		err = c.Time.LoadAttributes(ctx)
+		if err != nil {
+			log.Error("Time.LoadAttributes: %v", err)
+			return nil
+		}
+
+		comment.TrackedTime = ToTrackedTime(ctx, doer, c.Time)
+	}
+
+	if c.RefIssueID != 0 {
+		issue, err := issues_model.GetIssueByID(ctx, c.RefIssueID)
+		if err != nil {
+			log.Error("GetIssueByID(%d): %v", c.RefIssueID, err)
+			return nil
+		}
+		comment.RefIssue = ToAPIIssue(ctx, doer, issue)
+	}
+
+	if c.RefCommentID != 0 {
+		com, err := issues_model.GetCommentByID(ctx, c.RefCommentID)
+		if err != nil {
+			log.Error("GetCommentByID(%d): %v", c.RefCommentID, err)
+			return nil
+		}
+		err = com.LoadPoster(ctx)
+		if err != nil {
+			log.Error("LoadPoster: %v", err)
+			return nil
+		}
+		comment.RefComment = ToAPIComment(ctx, repo, com)
+	}
+
+	if c.Label != nil {
+		var org *user_model.User
+		var repo *repo_model.Repository
+		if c.Label.BelongsToOrg() {
+			var err error
+			org, err = user_model.GetUserByID(ctx, c.Label.OrgID)
+			if err != nil {
+				log.Error("GetUserByID(%d): %v", c.Label.OrgID, err)
+				return nil
+			}
+		}
+		if c.Label.BelongsToRepo() {
+			var err error
+			repo, err = repo_model.GetRepositoryByID(ctx, c.Label.RepoID)
+			if err != nil {
+				log.Error("GetRepositoryByID(%d): %v", c.Label.RepoID, err)
+				return nil
+			}
+		}
+		comment.Label = ToLabel(c.Label, repo, org)
+	}
+
+	if c.Assignee != nil {
+		comment.Assignee = ToUser(ctx, c.Assignee, nil)
+	}
+	if c.AssigneeTeam != nil {
+		comment.AssigneeTeam, _ = ToTeam(ctx, c.AssigneeTeam)
+	}
+
+	if c.ResolveDoer != nil {
+		comment.ResolveDoer = ToUser(ctx, c.ResolveDoer, nil)
+	}
+
+	if c.DependentIssue != nil {
+		comment.DependentIssue = ToAPIIssue(ctx, doer, c.DependentIssue)
+	}
+
+	return comment
+}

services/convert/issue_test.go

@@ -0,0 +1,126 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"gitea.dev/models/db"
+	issues_model "gitea.dev/models/issues"
+	repo_model "gitea.dev/models/repo"
+	"gitea.dev/models/unittest"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/setting"
+	api "gitea.dev/modules/structs"
+	"gitea.dev/modules/timeutil"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestLabel_ToLabel(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+	label := unittest.AssertExistsAndLoadBean(t, &issues_model.Label{ID: 1})
+	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: label.RepoID})
+	assert.Equal(t, &api.Label{
+		ID:    label.ID,
+		Name:  label.Name,
+		Color: "abcdef",
+		URL:   fmt.Sprintf("%sapi/v1/repos/user2/repo1/labels/%d", setting.AppURL, label.ID),
+	}, ToLabel(label, repo, nil))
+}
+
+func TestMilestone_APIFormat(t *testing.T) {
+	milestone := &issues_model.Milestone{
+		ID:              3,
+		RepoID:          4,
+		Name:            "milestoneName",
+		Content:         "milestoneContent",
+		IsClosed:        false,
+		NumOpenIssues:   5,
+		NumClosedIssues: 6,
+		CreatedUnix:     timeutil.TimeStamp(time.Date(1999, time.January, 1, 0, 0, 0, 0, time.UTC).Unix()),
+		UpdatedUnix:     timeutil.TimeStamp(time.Date(1999, time.March, 1, 0, 0, 0, 0, time.UTC).Unix()),
+		DeadlineUnix:    timeutil.TimeStamp(time.Date(2000, time.January, 1, 0, 0, 0, 0, time.UTC).Unix()),
+	}
+	assert.Equal(t, api.Milestone{
+		ID:           milestone.ID,
+		State:        api.StateOpen,
+		Title:        milestone.Name,
+		Description:  milestone.Content,
+		OpenIssues:   milestone.NumOpenIssues,
+		ClosedIssues: milestone.NumClosedIssues,
+		Created:      milestone.CreatedUnix.AsTime(),
+		Updated:      milestone.UpdatedUnix.AsTimePtr(),
+		Deadline:     milestone.DeadlineUnix.AsTimePtr(),
+	}, *ToAPIMilestone(milestone))
+}
+
+func TestToStopWatchesRespectsPermissions(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+
+	ctx := t.Context()
+	publicSW := unittest.AssertExistsAndLoadBean(t, &issues_model.Stopwatch{ID: 1})
+	privateIssue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{RepoID: 3})
+	privateSW := &issues_model.Stopwatch{IssueID: privateIssue.ID, UserID: 5}
+	assert.NoError(t, db.Insert(ctx, privateSW))
+	assert.NotZero(t, privateSW.ID)
+
+	regularUser := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 5})
+	adminUser := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
+
+	sws := []*issues_model.Stopwatch{publicSW, privateSW}
+
+	visible, err := ToStopWatches(ctx, regularUser, sws)
+	assert.NoError(t, err)
+	assert.Len(t, visible, 1)
+	assert.Equal(t, "repo1", visible[0].RepoName)
+
+	visibleAdmin, err := ToStopWatches(ctx, adminUser, sws)
+	assert.NoError(t, err)
+	assert.Len(t, visibleAdmin, 2)
+	assert.ElementsMatch(t, []string{"repo1", "repo3"}, []string{visibleAdmin[0].RepoName, visibleAdmin[1].RepoName})
+}
+
+func TestToTrackedTime(t *testing.T) {
+	require.NoError(t, unittest.PrepareTestDatabase())
+
+	ctx := t.Context()
+	publicIssue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{RepoID: 1})
+	privateIssue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{RepoID: 3})
+	regularUser := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 5})
+	adminUser := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
+
+	publicTrackedTime := &issues_model.TrackedTime{IssueID: publicIssue.ID, UserID: regularUser.ID, Time: 3600}
+	privateTrackedTime := &issues_model.TrackedTime{IssueID: privateIssue.ID, UserID: regularUser.ID, Time: 1800}
+	require.NoError(t, db.Insert(ctx, publicTrackedTime))
+	require.NoError(t, db.Insert(ctx, privateTrackedTime))
+
+	t.Run("NilIssues", func(t *testing.T) {
+		list := ToTrackedTimeList(ctx, regularUser, issues_model.TrackedTimeList{publicTrackedTime, privateTrackedTime})
+		assert.Empty(t, list)
+	})
+
+	t.Run("NilRepo", func(t *testing.T) {
+		badTrackedTime := &issues_model.TrackedTime{Issue: &issues_model.Issue{RepoID: 999999}}
+		visible := ToTrackedTimeList(ctx, regularUser, issues_model.TrackedTimeList{badTrackedTime})
+		assert.Empty(t, visible)
+	})
+
+	trackedTimes := issues_model.TrackedTimeList{publicTrackedTime, privateTrackedTime}
+	require.NoError(t, trackedTimes.LoadAttributes(ctx))
+
+	t.Run("ToRegularUser", func(t *testing.T) {
+		list := ToTrackedTimeList(ctx, regularUser, trackedTimes)
+		require.Len(t, list, 1)
+		assert.Equal(t, "repo1", list[0].Issue.Repo.Name)
+	})
+	t.Run("ToAdminUser", func(t *testing.T) {
+		list := ToTrackedTimeList(ctx, adminUser, trackedTimes)
+		require.Len(t, list, 2)
+		assert.ElementsMatch(t, []string{"repo1", "repo3"}, []string{list[0].Issue.Repo.Name, list[1].Issue.Repo.Name})
+	})
+}

services/convert/main_test.go

@@ -0,0 +1,16 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"testing"
+
+	"gitea.dev/models/unittest"
+
+	_ "gitea.dev/models/actions"
+)
+
+func TestMain(m *testing.M) {
+	unittest.MainTest(m)
+}

services/convert/mirror.go

@@ -0,0 +1,26 @@
+// Copyright 2022 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+
+	repo_model "gitea.dev/models/repo"
+	api "gitea.dev/modules/structs"
+)
+
+// ToPushMirror convert from repo_model.PushMirror and remoteAddress to api.TopicResponse
+func ToPushMirror(ctx context.Context, pm *repo_model.PushMirror) (*api.PushMirror, error) {
+	repo := pm.GetRepository(ctx)
+	return &api.PushMirror{
+		RepoName:       repo.Name,
+		RemoteName:     pm.RemoteName,
+		RemoteAddress:  pm.RemoteAddress,
+		CreatedUnix:    pm.CreatedUnix.AsTime(),
+		LastUpdateUnix: pm.LastUpdateUnix.AsTimePtr(),
+		LastError:      pm.LastError,
+		Interval:       pm.Interval.String(),
+		SyncOnCommit:   pm.SyncOnCommit,
+	}, nil
+}

services/convert/notification.go

@@ -0,0 +1,104 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+	"net/url"
+
+	activities_model "gitea.dev/models/activities"
+	access_model "gitea.dev/models/perm/access"
+	"gitea.dev/modules/log"
+	api "gitea.dev/modules/structs"
+)
+
+// ToNotificationThread convert a Notification to api.NotificationThread
+func ToNotificationThread(ctx context.Context, n *activities_model.Notification) *api.NotificationThread {
+	result := &api.NotificationThread{
+		ID:        n.ID,
+		Unread:    !(n.Status == activities_model.NotificationStatusRead || n.Status == activities_model.NotificationStatusPinned),
+		Pinned:    n.Status == activities_model.NotificationStatusPinned,
+		UpdatedAt: n.UpdatedUnix.AsTime(),
+		URL:       n.APIURL(),
+	}
+
+	// since user only get notifications when he has access to use minimal access mode
+	if n.Repository != nil {
+		perm, err := access_model.GetIndividualUserRepoPermission(ctx, n.Repository, n.User)
+		if err != nil {
+			log.Error("GetIndividualUserRepoPermission failed: %v", err)
+			return result
+		}
+		if perm.HasAnyUnitAccessOrPublicAccess() { // if user has been revoked access to repo, do not show repo info
+			result.Repository = ToRepo(ctx, n.Repository, perm)
+			// This permission is not correct and we should not be reporting it
+			for repository := result.Repository; repository != nil; repository = repository.Parent {
+				repository.Permissions = nil
+			}
+		}
+	}
+
+	// handle Subject
+	switch n.Source {
+	case activities_model.NotificationSourceIssue:
+		result.Subject = &api.NotificationSubject{Type: api.NotifySubjectIssue}
+		if n.Issue != nil {
+			result.Subject.Title = n.Issue.Title
+			result.Subject.URL = n.Issue.APIURL(ctx)
+			result.Subject.HTMLURL = n.Issue.HTMLURL(ctx)
+			result.Subject.State = api.NotifySubjectStateType(n.Issue.State())
+			comment, err := n.Issue.GetLastComment(ctx)
+			if err == nil && comment != nil {
+				result.Subject.LatestCommentURL = comment.APIURL(ctx)
+				result.Subject.LatestCommentHTMLURL = comment.HTMLURL(ctx)
+			}
+		}
+	case activities_model.NotificationSourcePullRequest:
+		result.Subject = &api.NotificationSubject{Type: api.NotifySubjectPull}
+		if n.Issue != nil {
+			result.Subject.Title = n.Issue.Title
+			result.Subject.URL = n.Issue.APIURL(ctx)
+			result.Subject.HTMLURL = n.Issue.HTMLURL(ctx)
+			result.Subject.State = api.NotifySubjectStateType(n.Issue.State())
+			comment, err := n.Issue.GetLastComment(ctx)
+			if err == nil && comment != nil {
+				result.Subject.LatestCommentURL = comment.APIURL(ctx)
+				result.Subject.LatestCommentHTMLURL = comment.HTMLURL(ctx)
+			}
+
+			if err := n.Issue.LoadPullRequest(ctx); err == nil &&
+				n.Issue.PullRequest != nil &&
+				n.Issue.PullRequest.HasMerged {
+				result.Subject.State = api.NotifySubjectStateMerged
+			}
+		}
+	case activities_model.NotificationSourceCommit:
+		url := n.Repository.HTMLURL() + "/commit/" + url.PathEscape(n.CommitID)
+		result.Subject = &api.NotificationSubject{
+			Type:    api.NotifySubjectCommit,
+			Title:   n.CommitID,
+			URL:     url,
+			HTMLURL: url,
+		}
+	case activities_model.NotificationSourceRepository:
+		result.Subject = &api.NotificationSubject{
+			Type:  api.NotifySubjectRepository,
+			Title: n.Repository.FullName(),
+			// FIXME: this is a relative URL, rather useless and inconsistent, but keeping for backwards compat
+			URL:     n.Repository.Link(),
+			HTMLURL: n.Repository.HTMLURL(),
+		}
+	}
+
+	return result
+}
+
+// ToNotifications convert list of Notification to api.NotificationThread list
+func ToNotifications(ctx context.Context, nl activities_model.NotificationList) []*api.NotificationThread {
+	result := make([]*api.NotificationThread, 0, len(nl))
+	for _, n := range nl {
+		result = append(result, ToNotificationThread(ctx, n))
+	}
+	return result
+}

services/convert/notification_test.go

@@ -0,0 +1,132 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"testing"
+
+	activities_model "gitea.dev/models/activities"
+	issues_model "gitea.dev/models/issues"
+	repo_model "gitea.dev/models/repo"
+	"gitea.dev/models/unittest"
+	user_model "gitea.dev/models/user"
+	api "gitea.dev/modules/structs"
+	"gitea.dev/modules/timeutil"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestToNotificationThreadIncludesRepoForAccessibleUser(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+
+	n := newRepoNotification(t, 1, 4)
+	thread := ToNotificationThread(t.Context(), n)
+
+	if assert.NotNil(t, thread.Repository) {
+		assert.Equal(t, n.Repository.FullName(), thread.Repository.FullName)
+		assert.Nil(t, thread.Repository.Permissions)
+	}
+}
+
+func TestToNotificationThreadOmitsRepoWhenAccessRevoked(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+
+	n := newRepoNotification(t, 2, 4)
+	thread := ToNotificationThread(t.Context(), n)
+
+	assert.Nil(t, thread.Repository)
+}
+
+func TestToNotificationThread(t *testing.T) {
+	require.NoError(t, unittest.PrepareTestDatabase())
+
+	t.Run("issue notification", func(t *testing.T) {
+		// Notification 1: source=issue, issue_id=1, status=unread
+		n := unittest.AssertExistsAndLoadBean(t, &activities_model.Notification{ID: 1})
+		require.NoError(t, n.LoadAttributes(t.Context()))
+
+		thread := ToNotificationThread(t.Context(), n)
+		assert.Equal(t, int64(1), thread.ID)
+		assert.True(t, thread.Unread)
+		assert.False(t, thread.Pinned)
+		require.NotNil(t, thread.Subject)
+		assert.Equal(t, api.NotifySubjectIssue, thread.Subject.Type)
+		assert.Equal(t, api.NotifySubjectStateOpen, thread.Subject.State)
+	})
+
+	t.Run("pinned notification", func(t *testing.T) {
+		// Notification 3: status=pinned
+		n := unittest.AssertExistsAndLoadBean(t, &activities_model.Notification{ID: 3})
+		require.NoError(t, n.LoadAttributes(t.Context()))
+
+		thread := ToNotificationThread(t.Context(), n)
+		assert.False(t, thread.Unread)
+		assert.True(t, thread.Pinned)
+	})
+
+	t.Run("merged pull request returns merged state", func(t *testing.T) {
+		// Issue 2 is a pull request; pull_request 1 has has_merged=true.
+		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 2})
+		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issue.RepoID})
+
+		n := &activities_model.Notification{
+			ID:         999,
+			UserID:     2,
+			RepoID:     repo.ID,
+			Status:     activities_model.NotificationStatusUnread,
+			Source:     activities_model.NotificationSourcePullRequest,
+			IssueID:    issue.ID,
+			Issue:      issue,
+			Repository: repo,
+		}
+
+		thread := ToNotificationThread(t.Context(), n)
+		require.NotNil(t, thread.Subject)
+		assert.Equal(t, api.NotifySubjectPull, thread.Subject.Type)
+		assert.Equal(t, api.NotifySubjectStateMerged, thread.Subject.State)
+	})
+
+	t.Run("open pull request returns open state", func(t *testing.T) {
+		// Issue 3 is a pull request; pull_request 2 has has_merged=false.
+		issue := unittest.AssertExistsAndLoadBean(t, &issues_model.Issue{ID: 3})
+		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: issue.RepoID})
+
+		n := &activities_model.Notification{
+			ID:         998,
+			UserID:     2,
+			RepoID:     repo.ID,
+			Status:     activities_model.NotificationStatusUnread,
+			Source:     activities_model.NotificationSourcePullRequest,
+			IssueID:    issue.ID,
+			Issue:      issue,
+			Repository: repo,
+		}
+
+		thread := ToNotificationThread(t.Context(), n)
+		require.NotNil(t, thread.Subject)
+		assert.Equal(t, api.NotifySubjectPull, thread.Subject.Type)
+		assert.Equal(t, api.NotifySubjectStateOpen, thread.Subject.State)
+	})
+}
+
+func newRepoNotification(t *testing.T, repoID, userID int64) *activities_model.Notification {
+	t.Helper()
+
+	ctx := t.Context()
+	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID})
+	assert.NoError(t, repo.LoadOwner(ctx))
+	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: userID})
+
+	return &activities_model.Notification{
+		ID:          repoID*1000 + userID,
+		UserID:      user.ID,
+		RepoID:      repo.ID,
+		Status:      activities_model.NotificationStatusUnread,
+		Source:      activities_model.NotificationSourceRepository,
+		UpdatedUnix: timeutil.TimeStampNow(),
+		Repository:  repo,
+		User:        user,
+	}
+}

services/convert/package.go

@@ -0,0 +1,53 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+
+	"gitea.dev/models/packages"
+	access_model "gitea.dev/models/perm/access"
+	user_model "gitea.dev/models/user"
+	api "gitea.dev/modules/structs"
+)
+
+// ToPackage convert a packages.PackageDescriptor to api.Package
+func ToPackage(ctx context.Context, pd *packages.PackageDescriptor, doer *user_model.User) (*api.Package, error) {
+	var repo *api.Repository
+	if pd.Repository != nil {
+		permission, err := access_model.GetDoerRepoPermission(ctx, pd.Repository, doer)
+		if err != nil {
+			return nil, err
+		}
+
+		if permission.HasAnyUnitAccess() {
+			repo = ToRepo(ctx, pd.Repository, permission)
+		}
+	}
+
+	return &api.Package{
+		ID:         pd.Version.ID,
+		Owner:      ToUser(ctx, pd.Owner, doer),
+		Repository: repo,
+		Creator:    ToUser(ctx, pd.Creator, doer),
+		Type:       string(pd.Package.Type),
+		Name:       pd.Package.Name,
+		Version:    pd.Version.Version,
+		CreatedAt:  pd.Version.CreatedUnix.AsTime(),
+		HTMLURL:    pd.VersionHTMLURL(ctx),
+	}, nil
+}
+
+// ToPackageFile converts packages.PackageFileDescriptor to api.PackageFile
+func ToPackageFile(pfd *packages.PackageFileDescriptor) *api.PackageFile {
+	return &api.PackageFile{
+		ID:         pfd.File.ID,
+		Size:       pfd.Blob.Size,
+		Name:       pfd.File.Name,
+		HashMD5:    pfd.Blob.HashMD5,
+		HashSHA1:   pfd.Blob.HashSHA1,
+		HashSHA256: pfd.Blob.HashSHA256,
+		HashSHA512: pfd.Blob.HashSHA512,
+	}
+}

services/convert/project.go

@@ -0,0 +1,37 @@
+// Copyright 2026 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	project_model "gitea.dev/models/project"
+	api "gitea.dev/modules/structs"
+)
+
+// ToAPIProject converts a Project to API format
+func ToAPIProject(p *project_model.Project) *api.Project {
+	apiProject := &api.Project{
+		ID:          p.ID,
+		Title:       p.Title,
+		Description: p.Description,
+		OwnerID:     p.OwnerID,
+		RepoID:      p.RepoID,
+		CreatorID:   p.CreatorID,
+		IsClosed:    p.IsClosed,
+		Created:     p.CreatedUnix.AsTime(),
+		Updated:     p.UpdatedUnix.AsTime(),
+	}
+	if p.IsClosed && p.ClosedDateUnix > 0 {
+		apiProject.Closed = p.ClosedDateUnix.AsTimePtr()
+	}
+	return apiProject
+}
+
+// ToAPIProjectList converts a list of Projects to API format
+func ToAPIProjectList(projects []*project_model.Project) []*api.Project {
+	result := make([]*api.Project, len(projects))
+	for i := range projects {
+		result[i] = ToAPIProject(projects[i])
+	}
+	return result
+}

services/convert/pull.go

@@ -0,0 +1,488 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+	"fmt"
+
+	git_model "gitea.dev/models/git"
+	issues_model "gitea.dev/models/issues"
+	"gitea.dev/models/perm"
+	access_model "gitea.dev/models/perm/access"
+	repo_model "gitea.dev/models/repo"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/cache"
+	"gitea.dev/modules/cachegroup"
+	"gitea.dev/modules/git"
+	"gitea.dev/modules/gitrepo"
+	"gitea.dev/modules/log"
+	"gitea.dev/modules/setting"
+	api "gitea.dev/modules/structs"
+	"gitea.dev/modules/util"
+	"gitea.dev/services/gitdiff"
+)
+
+// ToAPIPullRequest assumes following fields have been assigned with valid values:
+// Required - Issue
+// Optional - Merger
+func ToAPIPullRequest(ctx context.Context, pr *issues_model.PullRequest, doer *user_model.User) *api.PullRequest {
+	var (
+		baseBranch string
+		headBranch string
+		baseCommit *git.Commit
+		err        error
+	)
+
+	if err = pr.LoadIssue(ctx); err != nil {
+		log.Error("pr.LoadIssue[%d]: %v", pr.ID, err)
+		return nil
+	}
+
+	if err = pr.Issue.LoadRepo(ctx); err != nil {
+		log.Error("pr.Issue.LoadRepo[%d]: %v", pr.ID, err)
+		return nil
+	}
+
+	apiIssue := ToAPIIssue(ctx, doer, pr.Issue)
+	if err := pr.LoadBaseRepo(ctx); err != nil {
+		log.Error("GetRepositoryById[%d]: %v", pr.ID, err)
+		return nil
+	}
+
+	if err := pr.LoadHeadRepo(ctx); err != nil {
+		log.Error("GetRepositoryById[%d]: %v", pr.ID, err)
+		return nil
+	}
+
+	var doerID int64
+	if doer != nil {
+		doerID = doer.ID
+	}
+
+	repoUserPerm, err := cache.GetWithContextCache(ctx, cachegroup.RepoUserPermission, fmt.Sprintf("%d-%d", pr.BaseRepoID, doerID),
+		func(ctx context.Context, _ string) (access_model.Permission, error) {
+			return access_model.GetDoerRepoPermission(ctx, pr.BaseRepo, doer)
+		},
+	)
+	if err != nil {
+		log.Error("GetDoerRepoPermission[%d]: %v", pr.BaseRepoID, err)
+		repoUserPerm.AccessMode = perm.AccessModeNone
+	}
+
+	apiPullRequest := &api.PullRequest{
+		ID:             pr.ID,
+		URL:            pr.Issue.HTMLURL(ctx),
+		Index:          pr.Index,
+		Poster:         apiIssue.Poster,
+		Title:          apiIssue.Title,
+		Body:           apiIssue.Body,
+		Labels:         apiIssue.Labels,
+		Milestone:      apiIssue.Milestone,
+		Assignee:       apiIssue.Assignee,
+		Assignees:      util.SliceNilAsEmpty(apiIssue.Assignees),
+		State:          apiIssue.State,
+		Draft:          pr.IsWorkInProgress(ctx),
+		IsLocked:       apiIssue.IsLocked,
+		Comments:       apiIssue.Comments,
+		ReviewComments: pr.GetReviewCommentsCount(ctx),
+		HTMLURL:        pr.Issue.HTMLURL(ctx),
+		DiffURL:        pr.Issue.DiffURL(),
+		PatchURL:       pr.Issue.PatchURL(),
+		HasMerged:      pr.HasMerged,
+		MergeBase:      pr.MergeBase,
+		Mergeable:      pr.Mergeable(ctx),
+		Deadline:       apiIssue.Deadline,
+		Created:        pr.Issue.CreatedUnix.AsTimePtr(),
+		Updated:        pr.Issue.UpdatedUnix.AsTimePtr(),
+		PinOrder:       util.Iif(apiIssue.PinOrder == -1, 0, apiIssue.PinOrder),
+		ContentVersion: apiIssue.ContentVersion,
+
+		// output "[]" rather than null to align to github outputs
+		RequestedReviewers:      []*api.User{},
+		RequestedReviewersTeams: []*api.Team{},
+
+		AllowMaintainerEdit: pr.AllowMaintainerEdit,
+
+		Base: &api.PRBranchInfo{
+			Name:       pr.BaseBranch,
+			Ref:        pr.BaseBranch,
+			RepoID:     pr.BaseRepoID,
+			Repository: ToRepo(ctx, pr.BaseRepo, repoUserPerm),
+		},
+		Head: &api.PRBranchInfo{
+			Name:   pr.HeadBranch,
+			Ref:    pr.GetGitHeadRefName(),
+			RepoID: -1,
+		},
+	}
+
+	if err = pr.LoadRequestedReviewers(ctx); err != nil {
+		log.Error("LoadRequestedReviewers[%d]: %v", pr.ID, err)
+		return nil
+	}
+	if err = pr.LoadRequestedReviewersTeams(ctx); err != nil {
+		log.Error("LoadRequestedReviewersTeams[%d]: %v", pr.ID, err)
+		return nil
+	}
+
+	for _, reviewer := range pr.RequestedReviewers {
+		apiPullRequest.RequestedReviewers = append(apiPullRequest.RequestedReviewers, ToUser(ctx, reviewer, nil))
+	}
+
+	for _, reviewerTeam := range pr.RequestedReviewersTeams {
+		convertedTeam, err := ToTeam(ctx, reviewerTeam, true)
+		if err != nil {
+			log.Error("LoadRequestedReviewersTeams[%d]: %v", pr.ID, err)
+			return nil
+		}
+
+		apiPullRequest.RequestedReviewersTeams = append(apiPullRequest.RequestedReviewersTeams, convertedTeam)
+	}
+
+	if pr.Issue.ClosedUnix != 0 {
+		apiPullRequest.Closed = pr.Issue.ClosedUnix.AsTimePtr()
+	}
+
+	gitRepo, err := gitrepo.OpenRepository(ctx, pr.BaseRepo)
+	if err != nil {
+		log.Error("OpenRepository[%s]: %v", pr.BaseRepo.RelativePath(), err)
+		return nil
+	}
+	defer gitRepo.Close()
+
+	exist, err := git_model.IsBranchExist(ctx, pr.BaseRepoID, pr.BaseBranch)
+	if err != nil {
+		log.Error("GetBranch[%s]: %v", pr.BaseBranch, err)
+		return nil
+	}
+
+	if exist {
+		baseCommit, err = gitRepo.GetBranchCommit(pr.BaseBranch)
+		if err != nil && !git.IsErrNotExist(err) {
+			log.Error("GetCommit[%s]: %v", baseBranch, err)
+			return nil
+		}
+
+		if err == nil {
+			apiPullRequest.Base.Sha = baseCommit.ID.String()
+		}
+	}
+
+	if pr.Flow == issues_model.PullRequestFlowAGit {
+		apiPullRequest.Head.Sha, err = gitRepo.GetRefCommitID(pr.GetGitHeadRefName())
+		if err != nil {
+			log.Error("GetRefCommitID[%s]: %v", pr.GetGitHeadRefName(), err)
+			return nil
+		}
+		apiPullRequest.Head.RepoID = pr.BaseRepoID
+		apiPullRequest.Head.Repository = apiPullRequest.Base.Repository
+		apiPullRequest.Head.Name = ""
+	}
+
+	if pr.HeadRepo != nil && pr.Flow == issues_model.PullRequestFlowGithub {
+		p, err := access_model.GetDoerRepoPermission(ctx, pr.HeadRepo, doer)
+		if err != nil {
+			log.Error("GetDoerRepoPermission[%d]: %v", pr.HeadRepoID, err)
+			p.AccessMode = perm.AccessModeNone
+		}
+
+		apiPullRequest.Head.RepoID = pr.HeadRepo.ID
+		apiPullRequest.Head.Repository = ToRepo(ctx, pr.HeadRepo, p)
+
+		headGitRepo, err := gitrepo.OpenRepository(ctx, pr.HeadRepo)
+		if err != nil {
+			log.Error("OpenRepository[%s]: %v", pr.HeadRepo.RelativePath(), err)
+			return nil
+		}
+		defer headGitRepo.Close()
+
+		exist, err = git_model.IsBranchExist(ctx, pr.HeadRepoID, pr.HeadBranch)
+		if err != nil {
+			log.Error("GetBranch[%s]: %v", pr.HeadBranch, err)
+			return nil
+		}
+
+		// Outer scope variables to be used in diff calculation
+		var (
+			startCommitID string
+			endCommitID   string
+		)
+
+		if !exist {
+			headCommitID, err := headGitRepo.GetRefCommitID(apiPullRequest.Head.Ref)
+			if err != nil && !git.IsErrNotExist(err) {
+				log.Error("GetCommit[%s]: %v", pr.HeadBranch, err)
+				return nil
+			}
+			if err == nil {
+				apiPullRequest.Head.Sha = headCommitID
+				endCommitID = headCommitID
+			}
+		} else {
+			commit, err := headGitRepo.GetBranchCommit(pr.HeadBranch)
+			if err != nil && !git.IsErrNotExist(err) {
+				log.Error("GetCommit[%s]: %v", headBranch, err)
+				return nil
+			}
+			if err == nil {
+				apiPullRequest.Head.Ref = pr.HeadBranch
+				apiPullRequest.Head.Sha = commit.ID.String()
+				endCommitID = commit.ID.String()
+			}
+		}
+
+		// Calculate diff
+		startCommitID = pr.MergeBase
+
+		diffShortStats, err := gitdiff.GetDiffShortStat(ctx, pr.BaseRepo, gitRepo, startCommitID, endCommitID)
+		if err != nil {
+			log.Error("GetDiffShortStat: %v", err)
+		} else {
+			apiPullRequest.ChangedFiles = &diffShortStats.NumFiles
+			apiPullRequest.Additions = &diffShortStats.TotalAddition
+			apiPullRequest.Deletions = &diffShortStats.TotalDeletion
+		}
+	}
+
+	if len(apiPullRequest.Head.Sha) == 0 && len(apiPullRequest.Head.Ref) != 0 {
+		baseGitRepo, err := gitrepo.OpenRepository(ctx, pr.BaseRepo)
+		if err != nil {
+			log.Error("OpenRepository[%s]: %v", pr.BaseRepo.RelativePath(), err)
+			return nil
+		}
+		defer baseGitRepo.Close()
+		refs, err := baseGitRepo.GetRefsFiltered(apiPullRequest.Head.Ref)
+		if err != nil {
+			log.Error("GetRefsFiltered[%s]: %v", apiPullRequest.Head.Ref, err)
+			return nil
+		} else if len(refs) == 0 {
+			log.Error("unable to resolve PR head ref")
+		} else {
+			apiPullRequest.Head.Sha = refs[0].Object.String()
+		}
+	}
+
+	if pr.HasMerged {
+		apiPullRequest.Merged = pr.MergedUnix.AsTimePtr()
+		apiPullRequest.MergedCommitID = &pr.MergedCommitID
+		apiPullRequest.MergedBy = ToUser(ctx, pr.Merger, nil)
+	}
+
+	return apiPullRequest
+}
+
+func ToAPIPullRequests(ctx context.Context, baseRepo *repo_model.Repository, prs issues_model.PullRequestList, doer *user_model.User) ([]*api.PullRequest, error) {
+	for _, pr := range prs {
+		pr.BaseRepo = baseRepo
+		if pr.BaseRepoID == pr.HeadRepoID {
+			pr.HeadRepo = baseRepo
+		}
+	}
+
+	// NOTE: load head repositories
+	if err := prs.LoadRepositories(ctx); err != nil {
+		return nil, err
+	}
+	issueList, err := prs.LoadIssues(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := issueList.LoadLabels(ctx); err != nil {
+		return nil, err
+	}
+	if err := issueList.LoadPosters(ctx); err != nil {
+		return nil, err
+	}
+	if err := issueList.LoadAttachments(ctx); err != nil {
+		return nil, err
+	}
+	if err := issueList.LoadMilestones(ctx); err != nil {
+		return nil, err
+	}
+	if err := issueList.LoadAssignees(ctx); err != nil {
+		return nil, err
+	}
+	if err = issueList.LoadPinOrder(ctx); err != nil {
+		return nil, err
+	}
+
+	reviews, err := prs.LoadReviews(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if err = reviews.LoadReviewers(ctx); err != nil {
+		return nil, err
+	}
+
+	reviewersMap := make(map[int64][]*user_model.User)
+	for _, review := range reviews {
+		if review.Reviewer != nil {
+			reviewersMap[review.IssueID] = append(reviewersMap[review.IssueID], review.Reviewer)
+		}
+	}
+
+	reviewCounts, err := prs.LoadReviewCommentsCounts(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	gitRepo, err := gitrepo.OpenRepository(ctx, baseRepo)
+	if err != nil {
+		return nil, err
+	}
+	defer gitRepo.Close()
+
+	baseRepoPerm, err := access_model.GetDoerRepoPermission(ctx, baseRepo, doer)
+	if err != nil {
+		log.Error("GetDoerRepoPermission[%d]: %v", baseRepo.ID, err)
+		baseRepoPerm.AccessMode = perm.AccessModeNone
+	}
+
+	apiRepo := ToRepo(ctx, baseRepo, baseRepoPerm)
+	baseBranchCache := make(map[string]*git_model.Branch)
+	apiPullRequests := make([]*api.PullRequest, 0, len(prs))
+	for _, pr := range prs {
+		apiIssue := ToAPIIssue(ctx, doer, pr.Issue)
+
+		apiPullRequest := &api.PullRequest{
+			ID:             pr.ID,
+			URL:            pr.Issue.HTMLURL(ctx),
+			Index:          pr.Index,
+			Poster:         apiIssue.Poster,
+			Title:          apiIssue.Title,
+			Body:           apiIssue.Body,
+			Labels:         apiIssue.Labels,
+			Milestone:      apiIssue.Milestone,
+			Assignee:       apiIssue.Assignee,
+			Assignees:      apiIssue.Assignees,
+			State:          apiIssue.State,
+			Draft:          pr.IsWorkInProgress(ctx),
+			IsLocked:       apiIssue.IsLocked,
+			Comments:       apiIssue.Comments,
+			ReviewComments: reviewCounts[pr.IssueID],
+			HTMLURL:        pr.Issue.HTMLURL(ctx),
+			DiffURL:        pr.Issue.DiffURL(),
+			PatchURL:       pr.Issue.PatchURL(),
+			HasMerged:      pr.HasMerged,
+			MergeBase:      pr.MergeBase,
+			Mergeable:      pr.Mergeable(ctx),
+			Deadline:       apiIssue.Deadline,
+			Created:        pr.Issue.CreatedUnix.AsTimePtr(),
+			Updated:        pr.Issue.UpdatedUnix.AsTimePtr(),
+			PinOrder:       util.Iif(apiIssue.PinOrder == -1, 0, apiIssue.PinOrder),
+			ContentVersion: apiIssue.ContentVersion,
+
+			AllowMaintainerEdit: pr.AllowMaintainerEdit,
+
+			Base: &api.PRBranchInfo{
+				Name:       pr.BaseBranch,
+				Ref:        pr.BaseBranch,
+				RepoID:     pr.BaseRepoID,
+				Repository: apiRepo,
+			},
+			Head: &api.PRBranchInfo{
+				Name:   pr.HeadBranch,
+				Ref:    pr.GetGitHeadRefName(),
+				RepoID: -1,
+			},
+		}
+
+		pr.RequestedReviewers = reviewersMap[pr.IssueID]
+		for _, reviewer := range pr.RequestedReviewers {
+			apiPullRequest.RequestedReviewers = append(apiPullRequest.RequestedReviewers, ToUser(ctx, reviewer, nil))
+		}
+
+		for _, reviewerTeam := range pr.RequestedReviewersTeams {
+			convertedTeam, err := ToTeam(ctx, reviewerTeam, true)
+			if err != nil {
+				log.Error("LoadRequestedReviewersTeams[%d]: %v", pr.ID, err)
+				return nil, err
+			}
+
+			apiPullRequest.RequestedReviewersTeams = append(apiPullRequest.RequestedReviewersTeams, convertedTeam)
+		}
+
+		if pr.Issue.ClosedUnix != 0 {
+			apiPullRequest.Closed = pr.Issue.ClosedUnix.AsTimePtr()
+		}
+
+		baseBranch, ok := baseBranchCache[pr.BaseBranch]
+		if !ok {
+			baseBranch, err = git_model.GetBranch(ctx, baseRepo.ID, pr.BaseBranch)
+			if err == nil {
+				baseBranchCache[pr.BaseBranch] = baseBranch
+			} else if !git_model.IsErrBranchNotExist(err) {
+				return nil, err
+			}
+		}
+		if baseBranch != nil {
+			apiPullRequest.Base.Sha = baseBranch.CommitID
+		}
+		if pr.HeadRepoID == pr.BaseRepoID {
+			apiPullRequest.Head.Repository = apiPullRequest.Base.Repository
+		}
+
+		// pull request head branch, both repository and branch could not exist
+		if pr.HeadRepo != nil {
+			apiPullRequest.Head.RepoID = pr.HeadRepo.ID
+			exist, err := git_model.IsBranchExist(ctx, pr.HeadRepo.ID, pr.HeadBranch)
+			if err != nil {
+				log.Error("IsBranchExist[%d]: %v", pr.HeadRepo.ID, err)
+				return nil, err
+			}
+			if exist {
+				apiPullRequest.Head.Ref = pr.HeadBranch
+			}
+			if pr.HeadRepoID != pr.BaseRepoID {
+				p, err := access_model.GetDoerRepoPermission(ctx, pr.HeadRepo, doer)
+				if err != nil {
+					log.Error("GetDoerRepoPermission[%d]: %v", pr.HeadRepoID, err)
+					p.AccessMode = perm.AccessModeNone
+				}
+				apiPullRequest.Head.Repository = ToRepo(ctx, pr.HeadRepo, p)
+			}
+		}
+		if apiPullRequest.Head.Ref == "" {
+			apiPullRequest.Head.Ref = pr.GetGitHeadRefName()
+		}
+
+		if pr.Flow == issues_model.PullRequestFlowAGit {
+			apiPullRequest.Head.Name = ""
+		}
+		apiPullRequest.Head.Sha, err = gitRepo.GetRefCommitID(pr.GetGitHeadRefName())
+		if err != nil {
+			log.Error("GetRefCommitID[%s]: %v", pr.GetGitHeadRefName(), err)
+		}
+
+		if len(apiPullRequest.Head.Sha) == 0 && len(apiPullRequest.Head.Ref) != 0 {
+			refs, err := gitRepo.GetRefsFiltered(apiPullRequest.Head.Ref)
+			if err != nil {
+				log.Error("GetRefsFiltered[%s]: %v", apiPullRequest.Head.Ref, err)
+				return nil, err
+			} else if len(refs) == 0 {
+				log.Error("unable to resolve PR head ref")
+			} else {
+				apiPullRequest.Head.Sha = refs[0].Object.String()
+			}
+		}
+
+		if pr.HasMerged {
+			apiPullRequest.Merged = pr.MergedUnix.AsTimePtr()
+			apiPullRequest.MergedCommitID = &pr.MergedCommitID
+			apiPullRequest.MergedBy = ToUser(ctx, pr.Merger, nil)
+		}
+
+		// Do not provide "ChangeFiles/Additions/Deletions" for the PR list, because the "diff" is quite slow
+		// If callers are interested in these values, they should do a separate request to get the PR details
+		if apiPullRequest.ChangedFiles != nil || apiPullRequest.Additions != nil || apiPullRequest.Deletions != nil {
+			setting.PanicInDevOrTesting("ChangedFiles/Additions/Deletions should not be set in PR list")
+		}
+
+		apiPullRequests = append(apiPullRequests, apiPullRequest)
+	}
+
+	return apiPullRequests, nil
+}

services/convert/pull_review.go

@@ -0,0 +1,135 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+	"strings"
+
+	issues_model "gitea.dev/models/issues"
+	user_model "gitea.dev/models/user"
+	api "gitea.dev/modules/structs"
+)
+
+// ToPullReview convert a review to api format
+func ToPullReview(ctx context.Context, r *issues_model.Review, doer *user_model.User) (*api.PullReview, error) {
+	if err := r.LoadAttributes(ctx); err != nil {
+		if !user_model.IsErrUserNotExist(err) {
+			return nil, err
+		}
+		r.Reviewer = user_model.NewGhostUser()
+	}
+
+	result := &api.PullReview{
+		ID:                r.ID,
+		Reviewer:          ToUser(ctx, r.Reviewer, doer),
+		State:             api.ReviewStateUnknown,
+		Body:              r.Content,
+		CommitID:          r.CommitID,
+		Stale:             r.Stale,
+		Official:          r.Official,
+		Dismissed:         r.Dismissed,
+		CodeCommentsCount: r.GetCodeCommentsCount(ctx),
+		Submitted:         r.CreatedUnix.AsTime(),
+		Updated:           r.UpdatedUnix.AsTime(),
+		HTMLURL:           r.HTMLURL(ctx),
+		HTMLPullURL:       r.Issue.HTMLURL(ctx),
+	}
+
+	if r.ReviewerTeam != nil {
+		var err error
+		result.ReviewerTeam, err = ToTeam(ctx, r.ReviewerTeam)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	switch r.Type {
+	case issues_model.ReviewTypeApprove:
+		result.State = api.ReviewStateApproved
+	case issues_model.ReviewTypeReject:
+		result.State = api.ReviewStateRequestChanges
+	case issues_model.ReviewTypeComment:
+		result.State = api.ReviewStateComment
+	case issues_model.ReviewTypePending:
+		result.State = api.ReviewStatePending
+	case issues_model.ReviewTypeRequest:
+		result.State = api.ReviewStateRequestReview
+	}
+
+	return result, nil
+}
+
+// ToPullReviewList convert a list of review to it's api format
+func ToPullReviewList(ctx context.Context, rl []*issues_model.Review, doer *user_model.User) ([]*api.PullReview, error) {
+	result := make([]*api.PullReview, 0, len(rl))
+	for i := range rl {
+		// show pending reviews only for the user who created them
+		if rl[i].Type == issues_model.ReviewTypePending && (doer == nil || (!doer.IsAdmin && doer.ID != rl[i].ReviewerID)) {
+			continue
+		}
+		r, err := ToPullReview(ctx, rl[i], doer)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, r)
+	}
+	return result, nil
+}
+
+// ToPullReviewCommentList convert the CodeComments of an review to it's api format
+func ToPullReviewCommentList(ctx context.Context, review *issues_model.Review, doer *user_model.User) ([]*api.PullReviewComment, error) {
+	if err := review.LoadAttributes(ctx); err != nil {
+		if !user_model.IsErrUserNotExist(err) {
+			return nil, err
+		}
+		review.Reviewer = user_model.NewGhostUser()
+	}
+
+	apiComments := make([]*api.PullReviewComment, 0, len(review.CodeComments))
+
+	for _, lines := range review.CodeComments {
+		for _, comments := range lines {
+			for _, comment := range comments {
+				apiComments = append(apiComments, ToPullReviewComment(ctx, comment, doer))
+			}
+		}
+	}
+	return apiComments, nil
+}
+
+// ToPullReviewComment convert a single code review comment to api format
+func ToPullReviewComment(ctx context.Context, comment *issues_model.Comment, doer *user_model.User) *api.PullReviewComment {
+	apiComment := &api.PullReviewComment{
+		ID:           comment.ID,
+		Body:         comment.Content,
+		Poster:       ToUser(ctx, comment.Poster, doer),
+		Resolver:     ToUser(ctx, comment.ResolveDoer, doer),
+		ReviewID:     comment.ReviewID,
+		Created:      comment.CreatedUnix.AsTime(),
+		Updated:      comment.UpdatedUnix.AsTime(),
+		Path:         comment.TreePath,
+		CommitID:     comment.CommitSHA,
+		OrigCommitID: comment.OldRef,
+		DiffHunk:     patch2diff(comment.Patch),
+		HTMLURL:      comment.HTMLURL(ctx),
+		HTMLPullURL:  comment.Issue.HTMLURL(ctx),
+	}
+
+	if comment.Line < 0 {
+		apiComment.OldLineNum = comment.UnsignedLine()
+	} else {
+		apiComment.LineNum = comment.UnsignedLine()
+	}
+
+	return apiComment
+}
+
+func patch2diff(patch string) string {
+	split := strings.Split(patch, "\n@@")
+	if len(split) == 2 {
+		return "@@" + split[1]
+	}
+	return ""
+}

services/convert/pull_review_test.go

@@ -0,0 +1,51 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"testing"
+
+	issues_model "gitea.dev/models/issues"
+	"gitea.dev/models/unittest"
+	user_model "gitea.dev/models/user"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_ToPullReview(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+
+	reviewer := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
+	review := unittest.AssertExistsAndLoadBean(t, &issues_model.Review{ID: 6})
+	assert.Equal(t, reviewer.ID, review.ReviewerID)
+	assert.Equal(t, issues_model.ReviewTypePending, review.Type)
+
+	reviewList := []*issues_model.Review{review}
+
+	t.Run("Anonymous User", func(t *testing.T) {
+		prList, err := ToPullReviewList(t.Context(), reviewList, nil)
+		assert.NoError(t, err)
+		assert.Empty(t, prList)
+	})
+
+	t.Run("Reviewer Himself", func(t *testing.T) {
+		prList, err := ToPullReviewList(t.Context(), reviewList, reviewer)
+		assert.NoError(t, err)
+		assert.Len(t, prList, 1)
+	})
+
+	t.Run("Other User", func(t *testing.T) {
+		user4 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 4})
+		prList, err := ToPullReviewList(t.Context(), reviewList, user4)
+		assert.NoError(t, err)
+		assert.Empty(t, prList)
+	})
+
+	t.Run("Admin User", func(t *testing.T) {
+		adminUser := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
+		prList, err := ToPullReviewList(t.Context(), reviewList, adminUser)
+		assert.NoError(t, err)
+		assert.Len(t, prList, 1)
+	})
+}

services/convert/pull_test.go

@@ -0,0 +1,54 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"testing"
+
+	issues_model "gitea.dev/models/issues"
+	"gitea.dev/models/perm"
+	access_model "gitea.dev/models/perm/access"
+	repo_model "gitea.dev/models/repo"
+	"gitea.dev/models/unittest"
+	"gitea.dev/modules/structs"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPullRequest_APIFormat(t *testing.T) {
+	// with HeadRepo
+	assert.NoError(t, unittest.PrepareTestDatabase())
+	headRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
+	pr := unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{ID: 1})
+	assert.NoError(t, pr.LoadAttributes(t.Context()))
+	assert.NoError(t, pr.LoadIssue(t.Context()))
+	apiPullRequest := ToAPIPullRequest(t.Context(), pr, nil)
+	assert.NotNil(t, apiPullRequest)
+	assert.Equal(t, &structs.PRBranchInfo{
+		Name:       "branch1",
+		Ref:        "refs/pull/2/head",
+		Sha:        "4a357436d925b5c974181ff12a994538ddc5a269",
+		RepoID:     1,
+		Repository: ToRepo(t.Context(), headRepo, access_model.Permission{AccessMode: perm.AccessModeRead}),
+	}, apiPullRequest.Head)
+
+	// withOut HeadRepo
+	pr = unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{ID: 1})
+	assert.NoError(t, pr.LoadIssue(t.Context()))
+	assert.NoError(t, pr.LoadAttributes(t.Context()))
+	// simulate fork deletion
+	pr.HeadRepo = nil
+	pr.HeadRepoID = 100000
+	apiPullRequest = ToAPIPullRequest(t.Context(), pr, nil)
+	assert.NotNil(t, apiPullRequest)
+	assert.Nil(t, apiPullRequest.Head.Repository)
+	assert.EqualValues(t, -1, apiPullRequest.Head.RepoID)
+
+	apiPullRequests, err := ToAPIPullRequests(t.Context(), pr.BaseRepo, []*issues_model.PullRequest{pr}, nil)
+	assert.NoError(t, err)
+	assert.Len(t, apiPullRequests, 1)
+	assert.NotNil(t, apiPullRequests[0])
+	assert.Nil(t, apiPullRequests[0].Head.Repository)
+	assert.EqualValues(t, -1, apiPullRequests[0].Head.RepoID)
+}

services/convert/release.go

@@ -0,0 +1,33 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+
+	repo_model "gitea.dev/models/repo"
+	api "gitea.dev/modules/structs"
+)
+
+// ToAPIRelease convert a repo_model.Release to api.Release
+func ToAPIRelease(ctx context.Context, repo *repo_model.Repository, r *repo_model.Release) *api.Release {
+	return &api.Release{
+		ID:           r.ID,
+		TagName:      r.TagName,
+		Target:       r.Target,
+		Title:        r.Title,
+		Note:         r.Note,
+		URL:          r.APIURL(),
+		HTMLURL:      r.HTMLURL(),
+		TarURL:       r.TarURL(),
+		ZipURL:       r.ZipURL(),
+		UploadURL:    r.APIUploadURL(),
+		IsDraft:      r.IsDraft,
+		IsPrerelease: r.IsPrerelease,
+		CreatedAt:    r.CreatedUnix.AsTime(),
+		PublishedAt:  r.CreatedUnix.AsTime(),
+		Publisher:    ToUser(ctx, r.Publisher, nil),
+		Attachments:  ToAPIAttachments(repo, r.Attachments),
+	}
+}

services/convert/release_test.go

@@ -0,0 +1,27 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"testing"
+
+	repo_model "gitea.dev/models/repo"
+	"gitea.dev/models/unittest"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRelease_ToRelease(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+
+	repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
+	release1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Release{ID: 1})
+	release1.LoadAttributes(t.Context())
+
+	apiRelease := ToAPIRelease(t.Context(), repo1, release1)
+	assert.NotNil(t, apiRelease)
+	assert.EqualValues(t, 1, apiRelease.ID)
+	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/releases/1", apiRelease.URL)
+	assert.Equal(t, "https://try.gitea.io/api/v1/repos/user2/repo1/releases/1/assets", apiRelease.UploadURL)
+}

services/convert/repository.go

@@ -0,0 +1,277 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+	"time"
+
+	"gitea.dev/models/db"
+	git_model "gitea.dev/models/git"
+	"gitea.dev/models/perm"
+	access_model "gitea.dev/models/perm/access"
+	repo_model "gitea.dev/models/repo"
+	unit_model "gitea.dev/models/unit"
+	"gitea.dev/modules/log"
+	api "gitea.dev/modules/structs"
+	"gitea.dev/modules/util"
+)
+
+// ToRepo converts a Repository to api.Repository
+func ToRepo(ctx context.Context, repo *repo_model.Repository, permissionInRepo access_model.Permission) *api.Repository {
+	return innerToRepo(ctx, repo, permissionInRepo, false)
+}
+
+func innerToRepo(ctx context.Context, repo *repo_model.Repository, permissionInRepo access_model.Permission, isParent bool) *api.Repository {
+	var parent *api.Repository
+
+	if !permissionInRepo.HasUnits() && permissionInRepo.AccessMode > perm.AccessModeNone {
+		// If units is empty, it means that it's a hard-coded permission, like access_model.Permission{AccessMode: perm.AccessModeAdmin}
+		// So we need to load units for the repo, otherwise UnitAccessMode will just return perm.AccessModeNone.
+		// TODO: this logic is still not right (because unit modes are not correctly prepared)
+		//   the caller should prepare a proper "permission" before calling this function.
+		_ = repo.LoadUnits(ctx) // the error is not important, so ignore it
+		permissionInRepo.SetUnitsWithDefaultAccessMode(repo.Units, permissionInRepo.AccessMode)
+	}
+
+	// TODO: ideally we should pass "doer" into "ToRepo" to make CloneLink could generate user-related links
+	// And passing "doer" in will also fix other FIXMEs in this file.
+	cloneLink := repo.CloneLinkGeneral(ctx) // no doer at the moment
+	permission := &api.Permission{
+		Admin: permissionInRepo.AccessMode >= perm.AccessModeAdmin,
+		Push:  permissionInRepo.UnitAccessMode(unit_model.TypeCode) >= perm.AccessModeWrite,
+		Pull:  permissionInRepo.UnitAccessMode(unit_model.TypeCode) >= perm.AccessModeRead,
+	}
+	if !isParent {
+		err := repo.GetBaseRepo(ctx)
+		if err != nil {
+			return nil
+		}
+		if repo.BaseRepo != nil {
+			// FIXME: The permission of the parent repo is not correct.
+			//        It's the permission of the current repo, so it's probably different from the parent repo.
+			//        But there isn't a good way to get the permission of the parent repo, because the doer is not passed in.
+			//        Use the permission of the current repo to keep the behavior consistent with the old API.
+			//        Maybe the right way is setting the permission of the parent repo to nil, empty is better than wrong.
+			parent = innerToRepo(ctx, repo.BaseRepo, permissionInRepo, true)
+		}
+	}
+
+	// check enabled/disabled units
+	hasIssues := false
+	var externalTracker *api.ExternalTracker
+	var internalTracker *api.InternalTracker
+	if unit, err := repo.GetUnit(ctx, unit_model.TypeIssues); err == nil {
+		config := unit.IssuesConfig()
+		hasIssues = true
+		internalTracker = &api.InternalTracker{
+			EnableTimeTracker:                config.EnableTimetracker,
+			AllowOnlyContributorsToTrackTime: config.AllowOnlyContributorsToTrackTime,
+			EnableIssueDependencies:          config.EnableDependencies,
+		}
+	} else if unit, err := repo.GetUnit(ctx, unit_model.TypeExternalTracker); err == nil {
+		config := unit.ExternalTrackerConfig()
+		hasIssues = true
+		externalTracker = &api.ExternalTracker{
+			ExternalTrackerURL:           config.ExternalTrackerURL,
+			ExternalTrackerFormat:        config.ExternalTrackerFormat,
+			ExternalTrackerStyle:         config.ExternalTrackerStyle,
+			ExternalTrackerRegexpPattern: config.ExternalTrackerRegexpPattern,
+		}
+	}
+	hasWiki := false
+	var externalWiki *api.ExternalWiki
+	if _, err := repo.GetUnit(ctx, unit_model.TypeWiki); err == nil {
+		hasWiki = true
+	} else if unit, err := repo.GetUnit(ctx, unit_model.TypeExternalWiki); err == nil {
+		hasWiki = true
+		config := unit.ExternalWikiConfig()
+		externalWiki = &api.ExternalWiki{
+			ExternalWikiURL: config.ExternalWikiURL,
+		}
+	}
+	hasPullRequests := false
+	ignoreWhitespaceConflicts := false
+	allowMerge := false
+	allowRebase := false
+	allowRebaseMerge := false
+	allowSquash := false
+	allowFastForwardOnly := false
+	allowMergeUpdate := false
+	allowRebaseUpdate := false
+	allowManualMerge := true
+	autodetectManualMerge := false
+	defaultDeleteBranchAfterMerge := false
+	defaultMergeStyle := repo_model.MergeStyleMerge
+	defaultUpdateStyle := repo_model.UpdateStyleMerge
+	defaultAllowMaintainerEdit := false
+	defaultTargetBranch := ""
+	if unit, err := repo.GetUnit(ctx, unit_model.TypePullRequests); err == nil {
+		config := unit.PullRequestsConfig()
+		hasPullRequests = true
+		ignoreWhitespaceConflicts = config.IgnoreWhitespaceConflicts
+		allowMerge = config.AllowMerge
+		allowRebase = config.AllowRebase
+		allowRebaseMerge = config.AllowRebaseMerge
+		allowSquash = config.AllowSquash
+		allowFastForwardOnly = config.AllowFastForwardOnly
+		allowMergeUpdate = config.AllowMergeUpdate
+		allowRebaseUpdate = config.AllowRebaseUpdate
+		allowManualMerge = config.AllowManualMerge
+		autodetectManualMerge = config.AutodetectManualMerge
+		defaultDeleteBranchAfterMerge = config.DefaultDeleteBranchAfterMerge
+		defaultMergeStyle = config.DefaultMergeStyle
+		defaultUpdateStyle = config.DefaultUpdateStyle
+		defaultAllowMaintainerEdit = config.DefaultAllowMaintainerEdit
+		defaultTargetBranch = config.DefaultTargetBranch
+	}
+	hasProjects := false
+	projectsMode := repo_model.ProjectsModeAll
+	if unit, err := repo.GetUnit(ctx, unit_model.TypeProjects); err == nil {
+		hasProjects = true
+		config := unit.ProjectsConfig()
+		projectsMode = config.ProjectsMode
+	}
+
+	hasCode := repo.UnitEnabled(ctx, unit_model.TypeCode)
+	hasReleases := repo.UnitEnabled(ctx, unit_model.TypeReleases)
+	hasPackages := repo.UnitEnabled(ctx, unit_model.TypePackages)
+	hasActions := repo.UnitEnabled(ctx, unit_model.TypeActions)
+
+	if err := repo.LoadOwner(ctx); err != nil {
+		return nil
+	}
+
+	numReleases, _ := db.Count[repo_model.Release](ctx, repo_model.FindReleasesOptions{
+		IncludeDrafts: false,
+		IncludeTags:   false,
+		RepoID:        repo.ID,
+	})
+
+	branchCount, err := git_model.CountBranches(ctx, repo.ID, false)
+	if err != nil {
+		log.Error("CountBranches [%d]: %v", repo.ID, err)
+	}
+
+	mirrorInterval := ""
+	var mirrorUpdated time.Time
+	var lastSync time.Time
+	if repo.IsMirror {
+		pullMirror, err := repo_model.GetMirrorByRepoID(ctx, repo.ID)
+		if err == nil {
+			mirrorInterval = pullMirror.Interval.String()
+			mirrorUpdated = pullMirror.UpdatedUnix.AsTime()
+			lastSync = pullMirror.LastSyncUnix.AsTime()
+		}
+	}
+
+	var transfer *api.RepoTransfer
+	if repo.Status == repo_model.RepositoryPendingTransfer {
+		t, err := repo_model.GetPendingRepositoryTransfer(ctx, repo)
+		if err != nil && !repo_model.IsErrNoPendingTransfer(err) {
+			log.Warn("GetPendingRepositoryTransfer: %v", err)
+		} else {
+			if err := t.LoadAttributes(ctx); err != nil {
+				log.Warn("LoadAttributes of RepoTransfer: %v", err)
+			} else {
+				transfer = ToRepoTransfer(ctx, t)
+			}
+		}
+	}
+
+	var language string
+	if repo.PrimaryLanguage != nil {
+		language = repo.PrimaryLanguage.Language
+	}
+
+	repoLicenses, err := repo_model.GetRepoLicenses(ctx, repo)
+	if err != nil {
+		return nil
+	}
+
+	repoAPIURL := repo.APIURL()
+
+	return &api.Repository{
+		ID:                            repo.ID,
+		Owner:                         ToUserWithAccessMode(ctx, repo.Owner, permissionInRepo.AccessMode),
+		Name:                          repo.Name,
+		FullName:                      repo.FullName(),
+		Description:                   repo.Description,
+		Private:                       repo.IsPrivate,
+		Template:                      repo.IsTemplate,
+		Empty:                         repo.IsEmpty,
+		Archived:                      repo.IsArchived,
+		Size:                          int(repo.Size / 1024),
+		Fork:                          repo.IsFork,
+		Parent:                        parent,
+		Mirror:                        repo.IsMirror,
+		HTMLURL:                       repo.HTMLURL(ctx),
+		URL:                           repoAPIURL,
+		SSHURL:                        cloneLink.SSH,
+		CloneURL:                      cloneLink.HTTPS,
+		OriginalURL:                   repo.SanitizedOriginalURL(),
+		Website:                       repo.Website,
+		Language:                      language,
+		LanguagesURL:                  repoAPIURL + "/languages",
+		Stars:                         repo.NumStars,
+		Forks:                         repo.NumForks,
+		Watchers:                      repo.NumWatches,
+		BranchCount:                   int(branchCount),
+		OpenIssues:                    repo.NumOpenIssues,
+		OpenPulls:                     repo.NumOpenPulls,
+		Releases:                      int(numReleases),
+		DefaultBranch:                 repo.DefaultBranch,
+		Created:                       repo.CreatedUnix.AsTime(),
+		Updated:                       repo.UpdatedUnix.AsTime(),
+		ArchivedAt:                    repo.ArchivedUnix.AsTime(),
+		Permissions:                   permission,
+		HasCode:                       hasCode,
+		HasIssues:                     hasIssues,
+		ExternalTracker:               externalTracker,
+		InternalTracker:               internalTracker,
+		HasWiki:                       hasWiki,
+		HasProjects:                   hasProjects,
+		ProjectsMode:                  string(projectsMode),
+		HasReleases:                   hasReleases,
+		HasPackages:                   hasPackages,
+		HasActions:                    hasActions,
+		ExternalWiki:                  externalWiki,
+		HasPullRequests:               hasPullRequests,
+		IgnoreWhitespaceConflicts:     ignoreWhitespaceConflicts,
+		AllowMerge:                    allowMerge,
+		AllowRebase:                   allowRebase,
+		AllowRebaseMerge:              allowRebaseMerge,
+		AllowSquash:                   allowSquash,
+		AllowFastForwardOnly:          allowFastForwardOnly,
+		AllowMergeUpdate:              allowMergeUpdate,
+		AllowRebaseUpdate:             allowRebaseUpdate,
+		AllowManualMerge:              allowManualMerge,
+		AutodetectManualMerge:         autodetectManualMerge,
+		DefaultDeleteBranchAfterMerge: defaultDeleteBranchAfterMerge,
+		DefaultMergeStyle:             string(defaultMergeStyle),
+		DefaultUpdateStyle:            string(defaultUpdateStyle),
+		DefaultAllowMaintainerEdit:    defaultAllowMaintainerEdit,
+		DefaultTargetBranch:           defaultTargetBranch,
+		AvatarURL:                     repo.AvatarLink(ctx),
+		Internal:                      !repo.IsPrivate && repo.Owner.Visibility == api.VisibleTypePrivate,
+		MirrorLastSyncAt:              lastSync,
+		MirrorInterval:                mirrorInterval,
+		MirrorUpdated:                 mirrorUpdated,
+		RepoTransfer:                  transfer,
+		Topics:                        util.SliceNilAsEmpty(repo.Topics),
+		ObjectFormatName:              api.ObjectFormatName(repo.ObjectFormatName),
+		Licenses:                      util.SliceNilAsEmpty(repoLicenses.StringList()),
+	}
+}
+
+// ToRepoTransfer convert a models.RepoTransfer to a structs.RepeTransfer
+func ToRepoTransfer(ctx context.Context, t *repo_model.RepoTransfer) *api.RepoTransfer {
+	teams, _ := ToTeams(ctx, t.Teams, false)
+
+	return &api.RepoTransfer{
+		Doer:      ToUser(ctx, t.Doer, nil),
+		Recipient: ToUser(ctx, t.Recipient, nil),
+		Teams:     teams,
+	}
+}

services/convert/status.go

@@ -0,0 +1,63 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+	"net/url"
+
+	git_model "gitea.dev/models/git"
+	user_model "gitea.dev/models/user"
+	"gitea.dev/modules/commitstatus"
+	api "gitea.dev/modules/structs"
+)
+
+// ToCommitStatus converts git_model.CommitStatus to api.CommitStatus
+func ToCommitStatus(ctx context.Context, status *git_model.CommitStatus) *api.CommitStatus {
+	apiStatus := &api.CommitStatus{
+		Created:     status.CreatedUnix.AsTime(),
+		Updated:     status.CreatedUnix.AsTime(),
+		State:       status.State,
+		TargetURL:   status.TargetURL,
+		Description: status.Description,
+		ID:          status.Index,
+		URL:         status.APIURL(ctx),
+		Context:     status.Context,
+	}
+
+	if status.CreatorID != 0 {
+		creator, _ := user_model.GetUserByID(ctx, status.CreatorID)
+		apiStatus.Creator = ToUser(ctx, creator, nil)
+	}
+
+	return apiStatus
+}
+
+func ToCommitStatuses(ctx context.Context, statuses []*git_model.CommitStatus) []*api.CommitStatus {
+	apiStatuses := make([]*api.CommitStatus, len(statuses))
+	for i, status := range statuses {
+		apiStatuses[i] = ToCommitStatus(ctx, status)
+	}
+	return apiStatuses
+}
+
+// ToCombinedStatus converts List of CommitStatus to a CombinedStatus
+func ToCombinedStatus(ctx context.Context, commitID string, statuses []*git_model.CommitStatus, repo *api.Repository) *api.CombinedStatus {
+	status := api.CombinedStatus{
+		SHA:        commitID,
+		TotalCount: len(statuses),
+		Repository: repo,
+		CommitURL:  repo.URL + "/commits/" + url.PathEscape(commitID),
+		URL:        repo.URL + "/commits/" + url.PathEscape(commitID) + "/status",
+	}
+
+	combinedStatus := git_model.CalcCommitStatus(statuses)
+	if combinedStatus != nil {
+		status.Statuses = ToCommitStatuses(ctx, statuses)
+		status.State = combinedStatus.State
+	} else {
+		status.State = commitstatus.CommitStatusPending
+	}
+	return &status
+}

services/convert/user.go

@@ -0,0 +1,110 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"context"
+
+	"gitea.dev/models/perm"
+	user_model "gitea.dev/models/user"
+	api "gitea.dev/modules/structs"
+)
+
+// ToUser convert user_model.User to api.User
+// if doer is set, private information is added if the doer has the permission to see it
+func ToUser(ctx context.Context, user, doer *user_model.User) *api.User {
+	if user == nil {
+		return nil
+	}
+	authed := false
+	signed := false
+	if doer != nil {
+		signed = true
+		authed = doer.ID == user.ID || doer.IsAdmin
+	}
+	return toUser(ctx, user, signed, authed)
+}
+
+// ToUsers convert list of user_model.User to list of api.User
+func ToUsers(ctx context.Context, doer *user_model.User, users []*user_model.User) []*api.User {
+	result := make([]*api.User, len(users))
+	for i := range users {
+		result[i] = ToUser(ctx, users[i], doer)
+	}
+	return result
+}
+
+// ToUserWithAccessMode convert user_model.User to api.User
+// AccessMode is not none show add some more information
+func ToUserWithAccessMode(ctx context.Context, user *user_model.User, accessMode perm.AccessMode) *api.User {
+	if user == nil {
+		return nil
+	}
+	return toUser(ctx, user, accessMode != perm.AccessModeNone, false)
+}
+
+// toUser convert user_model.User to api.User
+// signed shall only be set if requester is logged in. authed shall only be set if user is site admin or user himself
+func toUser(ctx context.Context, user *user_model.User, signed, authed bool) *api.User {
+	result := &api.User{
+		ID:          user.ID,
+		UserName:    user.Name,
+		FullName:    user.FullName,
+		Email:       user.GetPlaceholderEmail(),
+		AvatarURL:   user.AvatarLink(ctx),
+		HTMLURL:     user.HTMLURL(ctx),
+		Created:     user.CreatedUnix.AsTime(),
+		Restricted:  user.IsRestricted,
+		Location:    user.Location,
+		Website:     user.Website,
+		Description: user.Description,
+		// counter's
+		Followers:    user.NumFollowers,
+		Following:    user.NumFollowing,
+		StarredRepos: user.NumStars,
+	}
+
+	result.Visibility = api.UserVisibility(user.Visibility.String())
+
+	// hide primary email if API caller is anonymous or user keep email private
+	if signed && (!user.KeepEmailPrivate || authed) {
+		result.Email = user.Email
+	}
+
+	// only site admin will get these information and possibly user himself
+	if authed {
+		result.IsAdmin = user.IsAdmin
+		result.LoginName = user.LoginName
+		result.SourceID = user.LoginSource
+		result.LastLogin = user.LastLoginUnix.AsTime()
+		result.Language = user.Language
+		result.IsActive = user.IsActive
+		result.ProhibitLogin = user.ProhibitLogin
+	}
+	return result
+}
+
+// User2UserSettings return UserSettings based on a user
+func User2UserSettings(user *user_model.User) api.UserSettings {
+	return api.UserSettings{
+		FullName:      user.FullName,
+		Website:       user.Website,
+		Location:      user.Location,
+		Language:      user.Language,
+		Description:   user.Description,
+		Theme:         user.Theme,
+		HideEmail:     user.KeepEmailPrivate,
+		HideActivity:  user.KeepActivityPrivate,
+		DiffViewStyle: user.DiffViewStyle,
+	}
+}
+
+// ToUserAndPermission return User and its collaboration permission for a repository
+func ToUserAndPermission(ctx context.Context, user, doer *user_model.User, accessMode perm.AccessMode) api.RepoCollaboratorPermission {
+	return api.RepoCollaboratorPermission{
+		User:       ToUser(ctx, user, doer),
+		Permission: api.AccessLevelName(accessMode.ToString()),
+		RoleName:   accessMode.ToString(),
+	}
+}

services/convert/user_test.go

@@ -0,0 +1,39 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"testing"
+
+	"gitea.dev/models/unittest"
+	user_model "gitea.dev/models/user"
+	api "gitea.dev/modules/structs"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUser_ToUser(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+
+	user1 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1, IsAdmin: true})
+
+	apiUser := toUser(t.Context(), user1, true, true)
+	assert.True(t, apiUser.IsAdmin)
+	assert.Contains(t, apiUser.AvatarURL, "://")
+
+	user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2, IsAdmin: false})
+
+	apiUser = toUser(t.Context(), user2, true, true)
+	assert.False(t, apiUser.IsAdmin)
+
+	apiUser = toUser(t.Context(), user1, false, false)
+	assert.False(t, apiUser.IsAdmin)
+	assert.Equal(t, api.UserVisibilityPublic, apiUser.Visibility)
+
+	user31 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 31, IsAdmin: false, Visibility: api.VisibleTypePrivate})
+
+	apiUser = toUser(t.Context(), user31, true, true)
+	assert.False(t, apiUser.IsAdmin)
+	assert.Equal(t, api.UserVisibilityPrivate, apiUser.Visibility)
+}

services/convert/utils.go

@@ -0,0 +1,46 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Copyright 2016 The Gogs Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"strings"
+
+	"gitea.dev/modules/setting"
+	"gitea.dev/modules/structs"
+)
+
+// ToCorrectPageSize makes sure page size is in allowed range.
+func ToCorrectPageSize(size int) int {
+	if size <= 0 {
+		size = setting.API.DefaultPagingNum
+	} else if size > setting.API.MaxResponseItems {
+		size = setting.API.MaxResponseItems
+	}
+	return size
+}
+
+// ToGitServiceType return GitServiceType based on string
+func ToGitServiceType(value string) structs.GitServiceType {
+	switch strings.ToLower(value) {
+	case "github":
+		return structs.GithubService
+	case "gitea":
+		return structs.GiteaService
+	case "gitlab":
+		return structs.GitlabService
+	case "gogs":
+		return structs.GogsService
+	case "onedev":
+		return structs.OneDevService
+	case "gitbucket":
+		return structs.GitBucketService
+	case "codebase":
+		return structs.CodebaseService
+	case "codecommit":
+		return structs.CodeCommitService
+	default:
+		return structs.PlainGitService
+	}
+}

services/convert/utils_test.go

@@ -0,0 +1,45 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestToCorrectPageSize(t *testing.T) {
+	assert.Equal(t, 30, ToCorrectPageSize(0))
+	assert.Equal(t, 30, ToCorrectPageSize(-10))
+	assert.Equal(t, 20, ToCorrectPageSize(20))
+	assert.Equal(t, 50, ToCorrectPageSize(100))
+}
+
+func TestToGitServiceType(t *testing.T) {
+	tc := []struct {
+		typ  string
+		enum int
+	}{{
+		typ: "trash", enum: 1,
+	}, {
+		typ: "github", enum: 2,
+	}, {
+		typ: "gitea", enum: 3,
+	}, {
+		typ: "gitlab", enum: 4,
+	}, {
+		typ: "gogs", enum: 5,
+	}, {
+		typ: "onedev", enum: 6,
+	}, {
+		typ: "gitbucket", enum: 7,
+	}, {
+		typ: "codebase", enum: 8,
+	}, {
+		typ: "codecommit", enum: 9,
+	}}
+	for _, test := range tc {
+		assert.EqualValues(t, test.enum, ToGitServiceType(test.typ))
+	}
+}

services/convert/wiki.go

@@ -0,0 +1,45 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package convert
+
+import (
+	"time"
+
+	"gitea.dev/modules/git"
+	api "gitea.dev/modules/structs"
+)
+
+// ToWikiCommit convert a git commit into a WikiCommit
+func ToWikiCommit(commit *git.Commit) *api.WikiCommit {
+	return &api.WikiCommit{
+		ID: commit.ID.String(),
+		Author: &api.CommitUser{
+			Identity: api.Identity{
+				Name:  commit.Author.Name,
+				Email: commit.Author.Email,
+			},
+			Date: commit.Author.When.UTC().Format(time.RFC3339),
+		},
+		Committer: &api.CommitUser{
+			Identity: api.Identity{
+				Name:  commit.Committer.Name,
+				Email: commit.Committer.Email,
+			},
+			Date: commit.Committer.When.UTC().Format(time.RFC3339),
+		},
+		Message: commit.MessageUTF8(),
+	}
+}
+
+// ToWikiCommitList convert a list of git commits into a WikiCommitList
+func ToWikiCommitList(commits []*git.Commit, total int64) *api.WikiCommitList {
+	result := make([]*api.WikiCommit, len(commits))
+	for i := range commits {
+		result[i] = ToWikiCommit(commits[i])
+	}
+	return &api.WikiCommitList{
+		WikiCommits: result,
+		Count:       total,
+	}
+}