+ assert.NotEmpty(t, token)

+ assert.NotEmpty(t, token)

+ "code.gitea.io/gitea/models/db"

+

+ "xorm.io/builder"

+// Cleanup removes expired actions logs, data, artifacts and used ephemeral runners

+ // clean up old ephemeral runners

+ if err := CleanupEphemeralRunners(ctx); err != nil {

+ return fmt.Errorf("cleanup old ephemeral runners: %w", err)

+ }

+

+ // go on

+ log.Info("Artifact %d is deleted (due to expiration)", artifact.ID)

+ // go on

+ log.Info("Artifact %d is deleted (due to pending deletion)", artifact.ID)

+ // do not return error here, go on

+

+// CleanupEphemeralRunners removes used ephemeral runners which are no longer able to process jobs

+func CleanupEphemeralRunners(ctx context.Context) error {

+ subQuery := builder.Select("`action_runner`.id").

+ From(builder.Select("*").From("`action_runner`"), "`action_runner`"). // mysql needs this redundant subquery

+ Join("INNER", "`action_task`", "`action_task`.`runner_id` = `action_runner`.`id`").

+ Where(builder.Eq{"`action_runner`.`ephemeral`": true}).

+ And(builder.NotIn("`action_task`.`status`", actions_model.StatusWaiting, actions_model.StatusRunning, actions_model.StatusBlocked))

+ b := builder.Delete(builder.In("id", subQuery)).From("`action_runner`")

+ res, err := db.GetEngine(ctx).Exec(b)

+ if err != nil {

+ return fmt.Errorf("find runners: %w", err)

+ }

+ affected, _ := res.RowsAffected()

+ log.Info("Removed %d runners", affected)

+ return nil

+}

+ repo_model "code.gitea.io/gitea/models/repo"

+ webhook_module "code.gitea.io/gitea/modules/webhook"

+ notify_service "code.gitea.io/gitea/services/notify"

+func notifyWorkflowJobStatusUpdate(ctx context.Context, jobs []*actions_model.ActionRunJob) {

+ if len(jobs) > 0 {

+ CreateCommitStatus(ctx, jobs...)

+ for _, job := range jobs {

+ _ = job.LoadAttributes(ctx)

+ notify_service.WorkflowJobStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job, nil)

+ }

+ }

+}

+

+func CancelPreviousJobs(ctx context.Context, repoID int64, ref, workflowID string, event webhook_module.HookEventType) error {

+ jobs, err := actions_model.CancelPreviousJobs(ctx, repoID, ref, workflowID, event)

+ notifyWorkflowJobStatusUpdate(ctx, jobs)

+ return err

+}

+

+func CleanRepoScheduleTasks(ctx context.Context, repo *repo_model.Repository) error {

+ jobs, err := actions_model.CleanRepoScheduleTasks(ctx, repo)

+ notifyWorkflowJobStatusUpdate(ctx, jobs)

+ return err

+}

+

+ notifyWorkflowJobStatusUpdate(ctx, jobs)

+ updated := false

+ n, err := actions_model.UpdateRunJob(ctx, job, nil, "status", "stopped")

+ updated = err == nil && n > 0

+ if updated {

+ _ = job.LoadAttributes(ctx)

+ notify_service.WorkflowJobStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job, nil)

+ }

+ ret, err := FindTaskNeeds(t.Context(), job)

+ notify_service "code.gitea.io/gitea/services/notify"

+ var updatedjobs []*actions_model.ActionRunJob

+ updatedjobs = append(updatedjobs, job)

+ for _, job := range updatedjobs {

+ _ = job.LoadAttributes(ctx)

+ notify_service.WorkflowJobStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job, nil)

+ }

+ apiCommits, apiHeadCommit, err := commits.ToAPIPayloadCommits(ctx, repo)

+ apiCommits, apiHeadCommit, err := commits.ToAPIPayloadCommits(ctx, repo)

+ notify_service "code.gitea.io/gitea/services/notify"

+ if err := CleanRepoScheduleTasks(ctx, input.Repo); err != nil {

+ if err := CancelPreviousJobs(

+ for _, job := range alljobs {

+ notify_service.WorkflowJobStatusUpdate(ctx, input.Repo, input.Doer, job, nil)

+ }

+ if err := CleanRepoScheduleTasks(ctx, input.Repo); err != nil {

+ notify_service "code.gitea.io/gitea/services/notify"

+ if err := CancelPreviousJobs(

+ allJobs, err := db.Find[actions_model.ActionRunJob](ctx, actions_model.FindRunJobOptions{RunID: run.ID})

+ if err != nil {

+ log.Error("FindRunJobs: %v", err)

+ }

+ err = run.LoadAttributes(ctx)

+ if err != nil {

+ log.Error("LoadAttributes: %v", err)

+ }

+ for _, job := range allJobs {

+ notify_service.WorkflowJobStatusUpdate(ctx, run.Repo, run.TriggerUser, job, nil)

+ }

+// Copyright 2022 The Gitea Authors. All rights reserved.

+// SPDX-License-Identifier: MIT

+

+package actions

+

+import (

+ "context"

+ "fmt"

+

+ actions_model "code.gitea.io/gitea/models/actions"

+ "code.gitea.io/gitea/models/db"

+ secret_model "code.gitea.io/gitea/models/secret"

+ notify_service "code.gitea.io/gitea/services/notify"

+

+ runnerv1 "code.gitea.io/actions-proto-go/runner/v1"

+ "google.golang.org/protobuf/types/known/structpb"

+)

+

+func PickTask(ctx context.Context, runner *actions_model.ActionRunner) (*runnerv1.Task, bool, error) {

+ var (

+ task *runnerv1.Task

+ job *actions_model.ActionRunJob

+ actionTask *actions_model.ActionTask

+ )

+

+ if runner.Ephemeral {

+ var task actions_model.ActionTask

+ has, err := db.GetEngine(ctx).Where("runner_id = ?", runner.ID).Get(&task)

+ // Let the runner retry the request, do not allow to proceed

+ if err != nil {

+ return nil, false, err

+ }

+ if has {

+ if task.Status == actions_model.StatusWaiting || task.Status == actions_model.StatusRunning || task.Status == actions_model.StatusBlocked {

+ return nil, false, nil

+ }

+ // task has been finished, remove it

+ _, err = db.DeleteByID[actions_model.ActionRunner](ctx, runner.ID)

+ if err != nil {

+ return nil, false, err

+ }

+ return nil, false, fmt.Errorf("runner has been removed")

+ }

+ }

+

+ if err := db.WithTx(ctx, func(ctx context.Context) error {

+ t, ok, err := actions_model.CreateTaskForRunner(ctx, runner)

+ if err != nil {

+ return fmt.Errorf("CreateTaskForRunner: %w", err)

+ }

+ if !ok {

+ return nil

+ }

+

+ if err := t.LoadAttributes(ctx); err != nil {

+ return fmt.Errorf("task LoadAttributes: %w", err)

+ }

+ job = t.Job

+ actionTask = t

+

+ secrets, err := secret_model.GetSecretsOfTask(ctx, t)

+ if err != nil {

+ return fmt.Errorf("GetSecretsOfTask: %w", err)

+ }

+

+ vars, err := actions_model.GetVariablesOfRun(ctx, t.Job.Run)

+ if err != nil {

+ return fmt.Errorf("GetVariablesOfRun: %w", err)

+ }

+

+ needs, err := findTaskNeeds(ctx, job)

+ if err != nil {

+ return fmt.Errorf("findTaskNeeds: %w", err)

+ }

+

+ taskContext, err := generateTaskContext(t)

+ if err != nil {

+ return fmt.Errorf("generateTaskContext: %w", err)

+ }

+

+ task = &runnerv1.Task{

+ Id: t.ID,

+ WorkflowPayload: t.Job.WorkflowPayload,

+ Context: taskContext,

+ Secrets: secrets,

+ Vars: vars,

+ Needs: needs,

+ }

+

+ return nil

+ }); err != nil {

+ return nil, false, err

+ }

+

+ if task == nil {

+ return nil, false, nil

+ }

+

+ CreateCommitStatus(ctx, job)

+ notify_service.WorkflowJobStatusUpdate(ctx, job.Run.Repo, job.Run.TriggerUser, job, actionTask)

+

+ return task, true, nil

+}

+

+func generateTaskContext(t *actions_model.ActionTask) (*structpb.Struct, error) {

+ giteaRuntimeToken, err := CreateAuthorizationToken(t.ID, t.Job.RunID, t.JobID)

+ if err != nil {

+ return nil, err

+ }

+

+ gitCtx := GenerateGiteaContext(t.Job.Run, t.Job)

+ gitCtx["token"] = t.Token

+ gitCtx["gitea_runtime_token"] = giteaRuntimeToken

+

+ return structpb.NewStruct(gitCtx)

+}

+

+func findTaskNeeds(ctx context.Context, taskJob *actions_model.ActionRunJob) (map[string]*runnerv1.TaskNeed, error) {

+ taskNeeds, err := FindTaskNeeds(ctx, taskJob)

+ if err != nil {

+ return nil, err

+ }

+ ret := make(map[string]*runnerv1.TaskNeed, len(taskNeeds))

+ for jobID, taskNeed := range taskNeeds {

+ ret[jobID] = &runnerv1.TaskNeed{

+ Outputs: taskNeed.Outputs,

+ Result: runnerv1.Result(taskNeed.Result),

+ }

+ }

+ return ret, nil

+}

+func CreateVariable(ctx context.Context, ownerID, repoID int64, name, data, description string) (*actions_model.ActionVariable, error) {

+ v, err := actions_model.InsertVariable(ctx, ownerID, repoID, name, util.ReserveLineBreakForTextarea(data), description)

+func UpdateVariableNameData(ctx context.Context, variable *actions_model.ActionVariable) (bool, error) {

+ if err := secret_service.ValidateName(variable.Name); err != nil {

+ if err := envNameCIRegexMatch(variable.Name); err != nil {

+ variable.Data = util.ReserveLineBreakForTextarea(variable.Data)

+

+ return actions_model.UpdateVariableCols(ctx, variable, "name", "data", "description")

+// Copyright 2024 The Gitea Authors. All rights reserved.

+// SPDX-License-Identifier: MIT

+

+package actions

+

+import (

+ "fmt"

+ "net/http"

+ "net/url"

+ "path"

+ "strings"

+

+ actions_model "code.gitea.io/gitea/models/actions"

+ "code.gitea.io/gitea/models/db"

+ "code.gitea.io/gitea/models/perm"

+ access_model "code.gitea.io/gitea/models/perm/access"

+ repo_model "code.gitea.io/gitea/models/repo"

+ "code.gitea.io/gitea/models/unit"

+ user_model "code.gitea.io/gitea/models/user"

+ "code.gitea.io/gitea/modules/actions"

+ "code.gitea.io/gitea/modules/git"

+ "code.gitea.io/gitea/modules/log"

+ "code.gitea.io/gitea/modules/reqctx"

+ api "code.gitea.io/gitea/modules/structs"

+ "code.gitea.io/gitea/modules/util"

+ "code.gitea.io/gitea/services/context"

+ "code.gitea.io/gitea/services/convert"

+ notify_service "code.gitea.io/gitea/services/notify"

+

+ "github.com/nektos/act/pkg/jobparser"

+ "github.com/nektos/act/pkg/model"

+)

+

+func getActionWorkflowPath(commit *git.Commit) string {

+ paths := []string{".gitea/workflows", ".github/workflows"}

+ for _, treePath := range paths {

+ if _, err := commit.SubTree(treePath); err == nil {

+ return treePath

+ }

+ }

+ return ""

+}

+

+func getActionWorkflowEntry(ctx *context.APIContext, commit *git.Commit, folder string, entry *git.TreeEntry) *api.ActionWorkflow {

+ cfgUnit := ctx.Repo.Repository.MustGetUnit(ctx, unit.TypeActions)

+ cfg := cfgUnit.ActionsConfig()

+

+ defaultBranch, _ := commit.GetBranchName()

+

+ workflowURL := fmt.Sprintf("%s/actions/workflows/%s", ctx.Repo.Repository.APIURL(), url.PathEscape(entry.Name()))

+ workflowRepoURL := fmt.Sprintf("%s/src/branch/%s/%s/%s", ctx.Repo.Repository.HTMLURL(ctx), util.PathEscapeSegments(defaultBranch), util.PathEscapeSegments(folder), url.PathEscape(entry.Name()))

+ badgeURL := fmt.Sprintf("%s/actions/workflows/%s/badge.svg?branch=%s", ctx.Repo.Repository.HTMLURL(ctx), url.PathEscape(entry.Name()), url.QueryEscape(ctx.Repo.Repository.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

+

+ return &api.ActionWorkflow{

+ ID: entry.Name(),

+ Name: entry.Name(),

+ Path: path.Join(folder, entry.Name()),

+ State: state,

+ CreatedAt: createdAt,

+ UpdatedAt: updatedAt,

+ URL: workflowURL,

+ HTMLURL: workflowRepoURL,

+ BadgeURL: badgeURL,

+ }

+}

+

+func EnableOrDisableWorkflow(ctx *context.APIContext, workflowID string, isEnable bool) error {

+ workflow, err := GetActionWorkflow(ctx, workflowID)

+ if err != nil {

+ return err

+ }

+

+ cfgUnit := ctx.Repo.Repository.MustGetUnit(ctx, unit.TypeActions)

+ cfg := cfgUnit.ActionsConfig()

+

+ if isEnable {

+ cfg.EnableWorkflow(workflow.ID)

+ } else {

+ cfg.DisableWorkflow(workflow.ID)

+ }

+

+ return repo_model.UpdateRepoUnit(ctx, cfgUnit)

+}

+

+func ListActionWorkflows(ctx *context.APIContext) ([]*api.ActionWorkflow, error) {

+ defaultBranchCommit, err := ctx.Repo.GitRepo.GetBranchCommit(ctx.Repo.Repository.DefaultBranch)

+ if err != nil {

+ ctx.APIErrorInternal(err)

+ return nil, err

+ }

+

+ entries, err := actions.ListWorkflows(defaultBranchCommit)

+ if err != nil {

+ ctx.APIError(http.StatusNotFound, err.Error())

+ return nil, err

+ }

+

+ folder := getActionWorkflowPath(defaultBranchCommit)

+

+ workflows := make([]*api.ActionWorkflow, len(entries))

+ for i, entry := range entries {

+ workflows[i] = getActionWorkflowEntry(ctx, defaultBranchCommit, folder, entry)

+ }

+

+ return workflows, nil

+}

+

+func GetActionWorkflow(ctx *context.APIContext, workflowID string) (*api.ActionWorkflow, error) {

+ entries, err := ListActionWorkflows(ctx)

+ if err != nil {

+ return nil, err

+ }

+

+ for _, entry := range entries {

+ if entry.Name == workflowID {

+ return entry, nil

+ }

+ }

+

+ return nil, util.NewNotExistErrorf("workflow %q not found", workflowID)

+}

+

+func DispatchActionWorkflow(ctx reqctx.RequestContext, doer *user_model.User, repo *repo_model.Repository, gitRepo *git.Repository, workflowID, ref string, processInputs func(model *model.WorkflowDispatch, inputs map[string]any) error) error {

+ if workflowID == "" {

+ return util.ErrorWrapLocale(

+ util.NewNotExistErrorf("workflowID is empty"),

+ "actions.workflow.not_found", workflowID,

+ )

+ }

+

+ if ref == "" {

+ return util.ErrorWrapLocale(

+ util.NewNotExistErrorf("ref is empty"),

+ "form.target_ref_not_exist", ref,

+ )

+ }

+

+ // can not rerun job when workflow is disabled

+ cfgUnit := repo.MustGetUnit(ctx, unit.TypeActions)

+ cfg := cfgUnit.ActionsConfig()

+ if cfg.IsWorkflowDisabled(workflowID) {

+ return util.ErrorWrapLocale(

+ util.NewPermissionDeniedErrorf("workflow is disabled"),

+ "actions.workflow.disabled",

+ )

+ }

+

+ // get target commit of run from specified ref

+ refName := git.RefName(ref)

+ var runTargetCommit *git.Commit

+ var err error

+ if refName.IsTag() {

+ runTargetCommit, err = gitRepo.GetTagCommit(refName.TagName())

+ } else if refName.IsBranch() {

+ runTargetCommit, err = gitRepo.GetBranchCommit(refName.BranchName())

+ } else {

+ refName = git.RefNameFromBranch(ref)

+ runTargetCommit, err = gitRepo.GetBranchCommit(ref)

+ }

+ if err != nil {

+ return util.ErrorWrapLocale(

+ util.NewNotExistErrorf("ref %q doesn't exist", ref),

+ "form.target_ref_not_exist", ref,

+ )

+ }

+

+ // get workflow entry from runTargetCommit

+ entries, err := actions.ListWorkflows(runTargetCommit)

+ if err != nil {

+ return err

+ }

+

+ // find workflow from commit

+ var workflows []*jobparser.SingleWorkflow

+ for _, entry := range entries {

+ if entry.Name() != workflowID {

+ continue

+ }

+

+ content, err := actions.GetContentFromEntry(entry)

+ if err != nil {

+ return err

+ }

+ workflows, err = jobparser.Parse(content)

+ if err != nil {

+ return err

+ }

+ break

+ }

+

+ if len(workflows) == 0 {

+ return util.ErrorWrapLocale(

+ util.NewNotExistErrorf("workflow %q doesn't exist", workflowID),

+ "actions.workflow.not_found", workflowID,

+ )

+ }

+

+ // get inputs from post

+ workflow := &model.Workflow{

+ RawOn: workflows[0].RawOn,

+ }

+ inputsWithDefaults := make(map[string]any)

+ if workflowDispatch := workflow.WorkflowDispatchConfig(); workflowDispatch != nil {

+ if err = processInputs(workflowDispatch, inputsWithDefaults); err != nil {

+ return err

+ }

+ }

+

+ // ctx.Req.PostForm -> WorkflowDispatchPayload.Inputs -> ActionRun.EventPayload -> runner: ghc.Event

+ // https://docs.github.com/en/actions/learn-github-actions/contexts#github-context

+ // https://docs.github.com/en/webhooks/webhook-events-and-payloads#workflow_dispatch

+ workflowDispatchPayload := &api.WorkflowDispatchPayload{

+ Workflow: workflowID,

+ Ref: ref,

+ Repository: convert.ToRepo(ctx, repo, access_model.Permission{AccessMode: perm.AccessModeNone}),

+ Inputs: inputsWithDefaults,

+ Sender: convert.ToUserWithAccessMode(ctx, doer, perm.AccessModeNone),

+ }

+ var eventPayload []byte

+ if eventPayload, err = workflowDispatchPayload.JSONPayload(); err != nil {

+ return fmt.Errorf("JSONPayload: %w", err)

+ }

+

+ run := &actions_model.ActionRun{

+ Title: strings.SplitN(runTargetCommit.CommitMessage, "\n", 2)[0],

+ RepoID: repo.ID,

+ OwnerID: repo.OwnerID,

+ WorkflowID: workflowID,

+ TriggerUserID: doer.ID,

+ Ref: string(refName),

+ CommitSHA: runTargetCommit.ID.String(),

+ IsForkPullRequest: false,

+ Event: "workflow_dispatch",

+ TriggerEvent: "workflow_dispatch",

+ EventPayload: string(eventPayload),

+ Status: actions_model.StatusWaiting,

+ }

+

+ // cancel running jobs of the same workflow

+ if err := CancelPreviousJobs(

+ ctx,

+ run.RepoID,

+ run.Ref,

+ run.WorkflowID,

+ run.Event,

+ ); err != nil {

+ log.Error("CancelRunningJobs: %v", err)

+ }

+

+ // Insert the action run and its associated jobs into the database

+ if err := actions_model.InsertRun(ctx, run, workflows); err != nil {

+ return fmt.Errorf("InsertRun: %w", err)

+ }

+

+ allJobs, err := db.Find[actions_model.ActionRunJob](ctx, actions_model.FindRunJobOptions{RunID: run.ID})

+ if err != nil {

+ log.Error("FindRunJobs: %v", err)

+ }

+ CreateCommitStatus(ctx, allJobs...)

+ for _, job := range allJobs {

+ notify_service.WorkflowJobStatusUpdate(ctx, repo, doer, job, nil)

+ }

+

+ return nil

+}

+ "code.gitea.io/gitea/modules/gitrepo"

+ if !gitrepo.IsBranchExist(ctx, repo, baseBranchName) {

+ if v == '/' && gitrepo.IsBranchExist(ctx, repo, baseBranchName[:p]) && p != len(baseBranchName)-1 {

+ output, _, err := git.NewCommand("rev-list", "--max-count=1").

+ RunStdString(ctx, &git.RunOpts{Dir: repo.RepoPath(), Env: os.Environ()})

+// Copyright 2025 The Gitea Authors. All rights reserved.

+// SPDX-License-Identifier: MIT

+

+package asymkey

+

+import (

+ "context"

+ "strings"

+

+ asymkey_model "code.gitea.io/gitea/models/asymkey"

+ "code.gitea.io/gitea/models/db"

+ user_model "code.gitea.io/gitea/models/user"

+ "code.gitea.io/gitea/modules/git"

+ "code.gitea.io/gitea/modules/log"

+ "code.gitea.io/gitea/modules/setting"

+

+ "github.com/ProtonMail/go-crypto/openpgp/packet"

+)

+

+// ParseCommitWithSignature check if signature is good against keystore.

+func ParseCommitWithSignature(ctx context.Context, c *git.Commit) *asymkey_model.CommitVerification {

+ var committer *user_model.User

+ if c.Committer != nil {

+ var err error

+ // Find Committer account

+ committer, err = user_model.GetUserByEmail(ctx, c.Committer.Email) // This finds the user by primary email or activated email so commit will not be valid if email is not

+ if err != nil { // Skipping not user for committer

+ committer = &user_model.User{

+ Name: c.Committer.Name,

+ Email: c.Committer.Email,

+ }

+ // We can expect this to often be an ErrUserNotExist. in the case

+ // it is not, however, it is important to log it.

+ if !user_model.IsErrUserNotExist(err) {

+ log.Error("GetUserByEmail: %v", err)

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Reason: "gpg.error.no_committer_account",

+ }

+ }

+ }

+ }

+

+ return ParseCommitWithSignatureCommitter(ctx, c, committer)

+}

+

+func ParseCommitWithSignatureCommitter(ctx context.Context, c *git.Commit, committer *user_model.User) *asymkey_model.CommitVerification {

+ // If no signature just report the committer

+ if c.Signature == nil {

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false, // Default value

+ Reason: "gpg.error.not_signed_commit", // Default value

+ }

+ }

+

+ // If this a SSH signature handle it differently

+ if strings.HasPrefix(c.Signature.Signature, "-----BEGIN SSH SIGNATURE-----") {

+ return asymkey_model.ParseCommitWithSSHSignature(ctx, c, committer)

+ }

+

+ // Parsing signature

+ sig, err := asymkey_model.ExtractSignature(c.Signature.Signature)

+ if err != nil { // Skipping failed to extract sign

+ log.Error("SignatureRead err: %v", err)

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Reason: "gpg.error.extract_sign",

+ }

+ }

+

+ keyID := asymkey_model.TryGetKeyIDFromSignature(sig)

+ defaultReason := asymkey_model.NoKeyFound

+

+ // First check if the sig has a keyID and if so just look at that

+ if commitVerification := HashAndVerifyForKeyID(

+ ctx,

+ sig,

+ c.Signature.Payload,

+ committer,

+ keyID,

+ setting.AppName,

+ ""); commitVerification != nil {

+ if commitVerification.Reason == asymkey_model.BadSignature {

+ defaultReason = asymkey_model.BadSignature

+ } else {

+ return commitVerification

+ }

+ }

+

+ // Now try to associate the signature with the committer, if present

+ if committer.ID != 0 {

+ keys, err := db.Find[asymkey_model.GPGKey](ctx, asymkey_model.FindGPGKeyOptions{

+ OwnerID: committer.ID,

+ })

+ if err != nil { // Skipping failed to get gpg keys of user

+ log.Error("ListGPGKeys: %v", err)

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Reason: "gpg.error.failed_retrieval_gpg_keys",

+ }

+ }

+

+ if err := asymkey_model.GPGKeyList(keys).LoadSubKeys(ctx); err != nil {

+ log.Error("LoadSubKeys: %v", err)

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Reason: "gpg.error.failed_retrieval_gpg_keys",

+ }

+ }

+

+ committerEmailAddresses, _ := user_model.GetEmailAddresses(ctx, committer.ID)

+ activated := false

+ for _, e := range committerEmailAddresses {

+ if e.IsActivated && strings.EqualFold(e.Email, c.Committer.Email) {

+ activated = true

+ break

+ }

+ }

+

+ for _, k := range keys {

+ // Pre-check (& optimization) that emails attached to key can be attached to the committer email and can validate

+ canValidate := false

+ email := ""

+ if k.Verified && activated {

+ canValidate = true

+ email = c.Committer.Email

+ }

+ if !canValidate {

+ for _, e := range k.Emails {

+ if e.IsActivated && strings.EqualFold(e.Email, c.Committer.Email) {

+ canValidate = true

+ email = e.Email

+ break

+ }

+ }

+ }

+ if !canValidate {

+ continue // Skip this key

+ }

+

+ commitVerification := asymkey_model.HashAndVerifyWithSubKeysCommitVerification(sig, c.Signature.Payload, k, committer, committer, email)

+ if commitVerification != nil {

+ return commitVerification

+ }

+ }

+ }

+

+ if setting.Repository.Signing.SigningKey != "" && setting.Repository.Signing.SigningKey != "default" && setting.Repository.Signing.SigningKey != "none" {

+ // OK we should try the default key

+ gpgSettings := git.GPGSettings{

+ Sign: true,

+ KeyID: setting.Repository.Signing.SigningKey,

+ Name: setting.Repository.Signing.SigningName,

+ Email: setting.Repository.Signing.SigningEmail,

+ }

+ if err := gpgSettings.LoadPublicKeyContent(); err != nil {

+ log.Error("Error getting default signing key: %s %v", gpgSettings.KeyID, err)

+ } else if commitVerification := VerifyWithGPGSettings(ctx, &gpgSettings, sig, c.Signature.Payload, committer, keyID); commitVerification != nil {

+ if commitVerification.Reason == asymkey_model.BadSignature {

+ defaultReason = asymkey_model.BadSignature

+ } else {

+ return commitVerification

+ }

+ }

+ }

+

+ defaultGPGSettings, err := c.GetRepositoryDefaultPublicGPGKey(false)

+ if err != nil {

+ log.Error("Error getting default public gpg key: %v", err)

+ } else if defaultGPGSettings == nil {

+ log.Warn("Unable to get defaultGPGSettings for unattached commit: %s", c.ID.String())

+ } else if defaultGPGSettings.Sign {

+ if commitVerification := VerifyWithGPGSettings(ctx, defaultGPGSettings, sig, c.Signature.Payload, committer, keyID); commitVerification != nil {

+ if commitVerification.Reason == asymkey_model.BadSignature {

+ defaultReason = asymkey_model.BadSignature

+ } else {

+ return commitVerification

+ }

+ }

+ }

+

+ return &asymkey_model.CommitVerification{ // Default at this stage

+ CommittingUser: committer,

+ Verified: false,

+ Warning: defaultReason != asymkey_model.NoKeyFound,

+ Reason: defaultReason,

+ SigningKey: &asymkey_model.GPGKey{

+ KeyID: keyID,

+ },

+ }

+}

+

+func checkKeyEmails(ctx context.Context, email string, keys ...*asymkey_model.GPGKey) (bool, string) {

+ uid := int64(0)

+ var userEmails []*user_model.EmailAddress

+ var user *user_model.User

+ for _, key := range keys {

+ for _, e := range key.Emails {

+ if e.IsActivated && (email == "" || strings.EqualFold(e.Email, email)) {

+ return true, e.Email

+ }

+ }

+ if key.Verified && key.OwnerID != 0 {

+ if uid != key.OwnerID {

+ userEmails, _ = user_model.GetEmailAddresses(ctx, key.OwnerID)

+ uid = key.OwnerID

+ user = &user_model.User{ID: uid}

+ _, _ = user_model.GetUser(ctx, user)

+ }

+ for _, e := range userEmails {

+ if e.IsActivated && (email == "" || strings.EqualFold(e.Email, email)) {

+ return true, e.Email

+ }

+ }

+ if user.KeepEmailPrivate && strings.EqualFold(email, user.GetEmail()) {

+ return true, user.GetEmail()

+ }

+ }

+ }

+ return false, email

+}

+

+func HashAndVerifyForKeyID(ctx context.Context, sig *packet.Signature, payload string, committer *user_model.User, keyID, name, email string) *asymkey_model.CommitVerification {

+ if keyID == "" {

+ return nil

+ }

+ keys, err := db.Find[asymkey_model.GPGKey](ctx, asymkey_model.FindGPGKeyOptions{

+ KeyID: keyID,

+ IncludeSubKeys: true,

+ })

+ if err != nil {

+ log.Error("GetGPGKeysByKeyID: %v", err)

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Reason: "gpg.error.failed_retrieval_gpg_keys",

+ }

+ }

+ if len(keys) == 0 {

+ return nil

+ }

+ for _, key := range keys {

+ var primaryKeys []*asymkey_model.GPGKey

+ if key.PrimaryKeyID != "" {

+ primaryKeys, err = db.Find[asymkey_model.GPGKey](ctx, asymkey_model.FindGPGKeyOptions{

+ KeyID: key.PrimaryKeyID,

+ IncludeSubKeys: true,

+ })

+ if err != nil {

+ log.Error("GetGPGKeysByKeyID: %v", err)

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Reason: "gpg.error.failed_retrieval_gpg_keys",

+ }

+ }

+ }

+

+ activated, email := checkKeyEmails(ctx, email, append([]*asymkey_model.GPGKey{key}, primaryKeys...)...)

+ if !activated {

+ continue

+ }

+

+ signer := &user_model.User{

+ Name: name,

+ Email: email,

+ }

+ if key.OwnerID != 0 {

+ owner, err := user_model.GetUserByID(ctx, key.OwnerID)

+ if err == nil {

+ signer = owner

+ } else if !user_model.IsErrUserNotExist(err) {

+ log.Error("Failed to user_model.GetUserByID: %d for key ID: %d (%s) %v", key.OwnerID, key.ID, key.KeyID, err)

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Reason: "gpg.error.no_committer_account",

+ }

+ }

+ }

+ commitVerification := asymkey_model.HashAndVerifyWithSubKeysCommitVerification(sig, payload, key, committer, signer, email)

+ if commitVerification != nil {

+ return commitVerification

+ }

+ }

+ // This is a bad situation ... We have a key id that is in our database but the signature doesn't match.

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Warning: true,

+ Reason: asymkey_model.BadSignature,

+ }

+}

+

+func VerifyWithGPGSettings(ctx context.Context, gpgSettings *git.GPGSettings, sig *packet.Signature, payload string, committer *user_model.User, keyID string) *asymkey_model.CommitVerification {

+ // First try to find the key in the db

+ if commitVerification := HashAndVerifyForKeyID(ctx, sig, payload, committer, gpgSettings.KeyID, gpgSettings.Name, gpgSettings.Email); commitVerification != nil {

+ return commitVerification

+ }

+

+ // Otherwise we have to parse the key

+ ekeys, err := asymkey_model.CheckArmoredGPGKeyString(gpgSettings.PublicKeyContent)

+ if err != nil {

+ log.Error("Unable to get default signing key: %v", err)

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Reason: "gpg.error.generate_hash",

+ }

+ }

+ for _, ekey := range ekeys {

+ pubkey := ekey.PrimaryKey

+ content, err := asymkey_model.Base64EncPubKey(pubkey)

+ if err != nil {

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Reason: "gpg.error.generate_hash",

+ }

+ }

+ k := &asymkey_model.GPGKey{

+ Content: content,

+ CanSign: pubkey.CanSign(),

+ KeyID: pubkey.KeyIdString(),

+ }

+ for _, subKey := range ekey.Subkeys {

+ content, err := asymkey_model.Base64EncPubKey(subKey.PublicKey)

+ if err != nil {

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Reason: "gpg.error.generate_hash",

+ }

+ }

+ k.SubsKey = append(k.SubsKey, &asymkey_model.GPGKey{

+ Content: content,

+ CanSign: subKey.PublicKey.CanSign(),

+ KeyID: subKey.PublicKey.KeyIdString(),

+ })

+ }

+ if commitVerification := asymkey_model.HashAndVerifyWithSubKeysCommitVerification(sig, payload, k, committer, &user_model.User{

+ Name: gpgSettings.Name,

+ Email: gpgSettings.Email,

+ }, gpgSettings.Email); commitVerification != nil {

+ return commitVerification

+ }

+ if keyID == k.KeyID {

+ // This is a bad situation ... We have a key id that matches our default key but the signature doesn't match.

+ return &asymkey_model.CommitVerification{

+ CommittingUser: committer,

+ Verified: false,

+ Warning: true,

+ Reason: asymkey_model.BadSignature,

+ }

+ }

+ }

+ return nil

+}

+ value, _, _ := git.NewCommand("config", "--get", "commit.gpgsign").RunStdString(ctx, &git.RunOpts{Dir: repoPath})

+ signingKey, _, _ := git.NewCommand("config", "--get", "user.signingkey").RunStdString(ctx, &git.RunOpts{Dir: repoPath})

+ signingName, _, _ := git.NewCommand("config", "--get", "user.name").RunStdString(ctx, &git.RunOpts{Dir: repoPath})

+ signingEmail, _, _ := git.NewCommand("config", "--get", "user.email").RunStdString(ctx, &git.RunOpts{Dir: repoPath})

+ gitRepo, err := gitrepo.OpenRepository(ctx, repo.WikiStorageRepo())

+ verification := ParseCommitWithSignature(ctx, commit)

+ verification := ParseCommitWithSignature(ctx, commit)

+ verification := ParseCommitWithSignature(ctx, commit)

+ verification := ParseCommitWithSignature(ctx, commit)

+ verification := ParseCommitWithSignature(ctx, commit)

+ verification := ParseCommitWithSignature(ctx, commit)

+ assert.Equal(t, user.ID, attachment.UploaderID)

+ if ctx := gitea_context.GetWebContext(req.Context()); ctx != nil {

+ uid := o.userIDFromToken(t.Context(), token, ds)

+ assert.Equal(t, user_model.ActionsUserID, uid)

+ actual := CheckTaskIsRunning(t.Context(), c.TaskID)

+ err := user_model.CreateUser(t.Context(), user, &user_model.Meta{}, &user_model.CreateUserOverwriteOptions{})

+ err = user_model.LinkExternalToUser(t.Context(), user, e)

+ err := source.refresh(t.Context(), provider, e)

+ ok, err := user_model.GetExternalLogin(t.Context(), e)

+ u, err := user_model.GetUserByID(t.Context(), user.ID)

+ err := source.refresh(t.Context(), provider, &user_model.ExternalLoginUser{

+ ok, err := user_model.GetExternalLogin(t.Context(), e)

+ assert.Empty(t, e.RefreshToken)

+ assert.Empty(t, e.AccessToken)

+ u, err := user_model.GetUserByID(t.Context(), user.ID)

+ gitea_context.GetWebContext(req.Context()).HTML(http.StatusUnauthorized, tplSignIn)

+ headBranchExist := pr.HeadRepo != nil && gitrepo.IsBranchExist(ctx, pr.HeadRepo, pr.HeadBranch)

+ if !headBranchExist {

+ headBranchExist := gitrepo.IsReferenceExist(ctx, pr.BaseRepo, pr.GetGitRefName())

+ lr.logger.Log(1, &log.Event{Level: log.INFO}, "%s", buf.String())

+func (t *testAccessLoggerMock) Log(skip int, event *log.Event, format string, v ...any) {

+ "errors"

+ "code.gitea.io/gitea/modules/util"

+// ATTENTION: This struct should never be manually constructed in routes/services,

+// it has many internal details which should be carefully prepared by the framework.

+// If it is abused, it would cause strange bugs like panic/resource-leak.

+// APIErrorInternal responds with error message, status is 500

+func (ctx *APIContext) APIErrorInternal(err error) {

+ ctx.apiErrorInternal(1, err)

+func (ctx *APIContext) apiErrorInternal(skip int, err error) {

+ log.ErrorWithSkip(skip+1, "InternalServerError: %v", err)

+

+ var message string

+ if !setting.IsProd || (ctx.Doer != nil && ctx.Doer.IsAdmin) {

+ message = err.Error()

+ }

+

+ ctx.JSON(http.StatusInternalServerError, APIError{

+ Message: message,

+ URL: setting.API.SwaggerURL,

+ })

+}

+

+// APIError responds with an error message to client with given obj as the message.

+func (ctx *APIContext) APIError(status int, obj any) {

+ log.ErrorWithSkip(1, "APIError: %s", message)

+// APIContexter returns APIContext middleware

+ ctx.APIErrorInternal(err)

+ httpcache.SetCacheControlInHeader(ctx.Resp.Header(), &httpcache.CacheControlOptions{NoTransform: true})

+// APIErrorNotFound handles 404s for APIContext

+func (ctx *APIContext) APIErrorNotFound(objs ...any) {

+ ctx.APIErrorInternal(err)

+ if ctx.Repo.Repository.IsEmpty {

+ ctx.APIErrorNotFound("repository is empty")

+ return

+ }

+

+ ctx.APIErrorInternal(fmt.Errorf("no open git repo"))

+ if gitrepo.IsBranchExist(ctx, ctx.Repo.Repository, refName) {

+ ctx.APIErrorInternal(err)

+ } else if gitrepo.IsTagExist(ctx, ctx.Repo.Repository, refName) {

+ ctx.APIErrorInternal(err)

+ ctx.APIErrorNotFound("GetCommit", err)

+ ctx.APIErrorNotFound(fmt.Errorf("not exist: '%s'", ctx.PathParam("*")))

+func (ctx *APIContext) NotFoundOrServerError(err error) {

+ if errors.Is(err, util.ErrNotExist) {

+ ctx.APIErrorInternal(err)

+// IsUserRepoWriter returns true if current user has "write" privilege in current repo

+ assert.Equal(t, links, response)

+// Base is the base context for all web handlers

+// ATTENTION: This struct should never be manually constructed in routes/services,

+// it has many internal details which should be carefully prepared by the framework.

+// If it is abused, it would cause strange bugs like panic/resource-leak.

+// HTTPError returned an error to web browser

+func (b *Base) HTTPError(status int, contents ...string) {

+// Context represents context of a web request.

+// ATTENTION: This struct should never be manually constructed in routes/services,

+// it has many internal details which should be carefully prepared by the framework.

+// If it is abused, it would cause strange bugs like panic/resource-leak.

+func GetWebContext(ctx context.Context) *Context {

+ webCtx, _ := ctx.Value(WebContextKey).(*Context)

+ return webCtx

+ ctx.SetContextValue(WebContextKey, ctx)

+ httpcache.SetCacheControlInHeader(ctx.Resp.Header(), &httpcache.CacheControlOptions{NoTransform: true})

+ hasErr, _ := ctx.Data["HasError"].(bool)

+ hasErr = hasErr || ctx.Flash.ErrorMsg != ""

+ if !hasErr {

+ if ctx.Flash.ErrorMsg == "" {

+ ctx.Flash.ErrorMsg = ctx.GetErrMsg()

+ }

+ return hasErr

+ ctx.HTTPError(http.StatusInternalServerError, "unable to get user")

+func (ctx *Context) NotFound(logErr error) {

+ ctx.notFoundInternal("", logErr)

+ ctx.NotFound(err)

+type OrgAssignmentOptions struct {

+ RequireMember bool

+ RequireOwner bool

+ RequireTeamMember bool

+ RequireTeamAdmin bool

+}

+// OrgAssignment returns a middleware to handle organization assignment

+func OrgAssignment(opts OrgAssignmentOptions) func(ctx *Context) {

+ return func(ctx *Context) {

+ var err error

+ if ctx.ContextUser == nil {

+ // if Organization is not defined, get it from params

+ if ctx.Org.Organization == nil {

+ GetOrganizationByParams(ctx)

+ if ctx.Written() {

+ return

+ }

+ } else if ctx.ContextUser.IsOrganization() {

+ ctx.Org.Organization = (*organization.Organization)(ctx.ContextUser)

+ } else {

+ // ContextUser is an individual User

+ return

+ org := ctx.Org.Organization

+ // Handle Visibility

+ if org.Visibility != structs.VisibleTypePublic && !ctx.IsSigned {

+ // We must be signed in to see limited or private organizations

+ ctx.NotFound(err)

+ if org.Visibility == structs.VisibleTypePrivate {

+ opts.RequireMember = true

+ } else if ctx.IsSigned && ctx.Doer.IsRestricted {

+ opts.RequireMember = true

+ }

+

+ ctx.ContextUser = org.AsUser()

+ ctx.Data["Org"] = org

+

+ // Admin has super access.

+ if ctx.IsSigned && ctx.Doer.IsAdmin {

+ ctx.Org.IsOwner = true

+ } else if ctx.IsSigned {

+ ctx.Org.IsOwner, err = org.IsOwnedBy(ctx, ctx.Doer.ID)

+ ctx.ServerError("IsOwnedBy", err)

+

+ if ctx.Org.IsOwner {

+ ctx.Org.IsMember = true

+ ctx.Org.IsTeamMember = true

+ ctx.Org.IsTeamAdmin = true

+ ctx.Org.CanCreateOrgRepo = true

+ } else {

+ ctx.Org.IsMember, err = org.IsOrgMember(ctx, ctx.Doer.ID)

+ if err != nil {

+ ctx.ServerError("IsOrgMember", err)

+ return

+ }

+ ctx.Org.CanCreateOrgRepo, err = org.CanCreateOrgRepo(ctx, ctx.Doer.ID)

+ if err != nil {

+ ctx.ServerError("CanCreateOrgRepo", err)

+ return

+ }

+ } else {

+ // Fake data.

+ ctx.Data["SignedUser"] = &user_model.User{}

+ if (opts.RequireMember && !ctx.Org.IsMember) || (opts.RequireOwner && !ctx.Org.IsOwner) {

+ ctx.NotFound(err)

+ return

+ }

+ ctx.Data["IsOrganizationOwner"] = ctx.Org.IsOwner

+ ctx.Data["IsOrganizationMember"] = ctx.Org.IsMember

+ ctx.Data["IsPackageEnabled"] = setting.Packages.Enabled

+ ctx.Data["IsRepoIndexerEnabled"] = setting.Indexer.RepoIndexerEnabled

+ ctx.Data["IsPublicMember"] = func(uid int64) bool {

+ is, _ := organization.IsPublicMembership(ctx, ctx.Org.Organization.ID, uid)

+ return is

+ }

+ ctx.Data["CanCreateOrgRepo"] = ctx.Org.CanCreateOrgRepo

+ ctx.Org.OrgLink = org.AsUser().OrganisationLink()

+ ctx.Data["OrgLink"] = ctx.Org.OrgLink

+ // Member

+ findMembersOpts := &organization.FindOrgMembersOpts{

+ Doer: ctx.Doer,

+ OrgID: org.ID,

+ IsDoerMember: ctx.Org.IsMember,

+ }

+ ctx.Data["NumMembers"], err = organization.CountOrgMembers(ctx, findMembersOpts)

+ if err != nil {

+ ctx.ServerError("CountOrgMembers", err)

+ return

+ }

+ // Team.

+ if ctx.Org.IsMember {

+ shouldSeeAllTeams := false

+ if ctx.Org.IsOwner {

+ shouldSeeAllTeams = true

+ } else {

+ teams, err := org.GetUserTeams(ctx, ctx.Doer.ID)

+ if err != nil {

+ ctx.ServerError("GetUserTeams", err)

+ return

+ }

+ for _, team := range teams {

+ if team.IncludesAllRepositories && team.AccessMode >= perm.AccessModeAdmin {

+ shouldSeeAllTeams = true

+ break

+ }

+ }

+ if shouldSeeAllTeams {

+ ctx.Org.Teams, err = org.LoadTeams(ctx)

+ if err != nil {

+ ctx.ServerError("LoadTeams", err)

+ return

+ }

+ } else {

+ ctx.Org.Teams, err = org.GetUserTeams(ctx, ctx.Doer.ID)

+ if err != nil {

+ ctx.ServerError("GetUserTeams", err)

+ return

+ ctx.Data["NumTeams"] = len(ctx.Org.Teams)

+

+ teamName := ctx.PathParam("team")

+ if len(teamName) > 0 {

+ teamExists := false

+ for _, team := range ctx.Org.Teams {

+ if team.LowerName == strings.ToLower(teamName) {

+ teamExists = true

+ ctx.Org.Team = team

+ ctx.Org.IsTeamMember = true

+ ctx.Data["Team"] = ctx.Org.Team

+ break

+ }

+

+ if !teamExists {

+ ctx.NotFound(err)

+ ctx.Data["IsTeamMember"] = ctx.Org.IsTeamMember

+ if opts.RequireTeamMember && !ctx.Org.IsTeamMember {

+ ctx.NotFound(err)

+ return

+ ctx.Org.IsTeamAdmin = ctx.Org.Team.IsOwnerTeam() || ctx.Org.Team.AccessMode >= perm.AccessModeAdmin

+ ctx.Data["IsTeamAdmin"] = ctx.Org.IsTeamAdmin

+ if opts.RequireTeamAdmin && !ctx.Org.IsTeamAdmin {

+ ctx.NotFound(err)

+ return

+ }

+ ctx.Data["ContextUser"] = ctx.ContextUser

+ ctx.Data["CanReadProjects"] = ctx.Org.CanReadUnit(ctx, unit.TypeProjects)

+ ctx.Data["CanReadPackages"] = ctx.Org.CanReadUnit(ctx, unit.TypePackages)

+ ctx.Data["CanReadCode"] = ctx.Org.CanReadUnit(ctx, unit.TypeCode)

+ ctx.Data["IsFollowing"] = ctx.Doer != nil && user_model.IsFollowing(ctx, ctx.Doer.ID, ctx.ContextUser.ID)

+ if len(ctx.ContextUser.Description) != 0 {

+ content, err := markdown.RenderString(markup.NewRenderContext(ctx), ctx.ContextUser.Description)

+ if err != nil {

+ ctx.ServerError("RenderString", err)

+ return

+ }

+ ctx.Data["RenderedDescription"] = content

+ errorFn := func(status int, obj any) {

+ ctx.NotFound(err)

+ ctx.ServerError("PackageAssignment", err)

+ ctx.Package = packageAssignment(paCtx, ctx.APIError)

+func packageAssignment(ctx *packageAssignmentCtx, errCb func(int, any)) *Package {

+ errCb(http.StatusInternalServerError, fmt.Errorf("determineAccessMode: %w", err))

+ errCb(http.StatusNotFound, fmt.Errorf("GetVersionByNameAndVersion: %w", err))

+ errCb(http.StatusInternalServerError, fmt.Errorf("GetVersionByNameAndVersion: %w", err))

+ errCb(http.StatusInternalServerError, fmt.Errorf("GetPackageDescriptor: %w", err))

+ if setting.Service.RequireSignInViewStrict && (doer == nil || doer.IsGhost()) {

+ // FIXME: web Context is still needed when rendering 500 page in a package handler

+ // It should be refactored to use new error handling mechanisms

+// total=-1 means only showing prev/next

+func (p *Pagination) WithCurRows(n int) *Pagination {

+ p.Paginater.SetCurRows(n)

+ return p

+}

+

+ ctx.NotFound(nil)

+ ctx.NotFound(nil)

+ ctx.NotFound(nil)

+ ctx.NotFound(nil)

+ ctx.HTTPError(http.StatusForbidden)

+ ctx.HTTPError(http.StatusForbidden)

+ ctx.NotFound(errors.New(ctx.Locale.TrString("repo.archive.title")))

+ ctx.HTTPError(http.StatusInternalServerError, "GetRepositoryByID")

+ // Git client needs a 301 redirect by default to follow the new location

+ // It's not documentated in git documentation, but it's the behavior of git client

+ ctx.Redirect(path.Join(setting.AppSubURL, redirectPath), http.StatusMovedPermanently)

+ if !ctx.Repo.Permission.HasAnyUnitAccessOrPublicAccess() && !canWriteAsMaintainer(ctx) {

+ ctx.NotFound(nil)

+ ctx.NotFound(nil)

+ ctx.NotFound(nil)

+ if !gitrepo.IsBranchExist(ctx, ctx.Repo.Repository, refShortName) {

+ if refType == git.RefTypeBranch && gitrepo.IsBranchExist(ctx, ctx.Repo.Repository, refShortName) {

+ } else if refType == git.RefTypeTag && gitrepo.IsTagExist(ctx, ctx.Repo.Repository, refShortName) {

+ ctx.NotFound(err)

+ ctx.NotFound(err)

+ ctx.NotFound(fmt.Errorf("branch or tag not exist: %s", refShortName))

+ ctx.NotFound(nil)

+ switch uploadType {

+ case "release":

+ case "comment":

+ case "repo":

+ errorFn := func(status int, obj any) {

+ ctx.NotFound(err)

+ ctx.ServerError("UserAssignmentWeb", err)

+ ctx.APIError(http.StatusNotFound, err)

+ ctx.APIErrorInternal(err)

+ ctx.ContextUser = userAssignment(ctx.Base, ctx.Doer, ctx.APIError)

+func userAssignment(ctx *Base, doer *user_model.User, errCb func(int, any)) (contextUser *user_model.User) {

+ errCb(http.StatusNotFound, err)

+ errCb(http.StatusInternalServerError, fmt.Errorf("LookupUserRedirect: %w", err))

+ errCb(http.StatusInternalServerError, fmt.Errorf("GetUserByName: %w", err))

+ git_module "code.gitea.io/gitea/modules/git"

+ "github.com/stretchr/testify/require"

+ ctx := &context.APIContext{Base: base, Repo: &context.Repository{}}

+ var repo *context.Repository

+ repo = ctx.Repo

+ repo = ctx.Repo

+ require.NoError(t, err)

+

+ if repo.RefFullName == "" {

+ repo.RefFullName = git_module.RefNameFromBranch(repo.Repository.DefaultBranch)

+ }

+ if repo.RefFullName.IsPull() {

+ repo.BranchName = repo.RefFullName.ShortName()

+ repo.Commit, err = gitRepo.GetCommit(repo.RefFullName.String())

+ require.NoError(t, err)

+ asymkey_service "code.gitea.io/gitea/services/asymkey"

+// 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

+}

+

+ verif := asymkey_service.ParseCommitWithSignature(ctx, c)

+ diffShortStat, err := gitdiff.GetDiffShortStat(gitRepo, "", commit.ID.String())

+ Total: diffShortStat.TotalAddition + diffShortStat.TotalDeletion,

+ Additions: diffShortStat.TotalAddition,

+ Deletions: diffShortStat.TotalDeletion,

+ assert.Equal(t, &api.CommitMeta{

+ if err := issue.LoadPinOrder(ctx); err != nil {

+ return &api.Issue{}

+ }

+ PinOrder: util.Iif(issue.PinOrder == -1, 0, issue.PinOrder), // -1 means loaded with no pin order

+ apiIssue.Labels = util.SliceNilAsEmpty(ToLabelList(issue.Labels, issue.Repo, issue.Repo.Owner))

+ _ = il.LoadPinOrder(ctx)

+ _ = il.LoadPinOrder(ctx)

+ "code.gitea.io/gitea/modules/setting"

+ "code.gitea.io/gitea/modules/util"

+ "code.gitea.io/gitea/services/gitdiff"

+ Assignees: util.SliceNilAsEmpty(apiIssue.Assignees),

+ PinOrder: util.Iif(apiIssue.PinOrder == -1, 0, apiIssue.PinOrder),

+

+ // output "[]" rather than null to align to github outputs

+ RequestedReviewers: []*api.User{},

+ RequestedReviewersTeams: []*api.Team{},

+ diffShortStats, err := gitdiff.GetDiffShortStat(gitRepo, startCommitID, endCommitID)

+ } else {

+ apiPullRequest.ChangedFiles = &diffShortStats.NumFiles

+ apiPullRequest.Additions = &diffShortStats.TotalAddition

+ apiPullRequest.Deletions = &diffShortStats.TotalDeletion

+ if err = issueList.LoadPinOrder(ctx); err != nil {

+ return nil, err

+ }

+ PinOrder: util.Iif(apiIssue.PinOrder == -1, 0, apiIssue.PinOrder),

+ Ref: pr.GetGitRefName(),

+ // 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)

+ log.Error("IsBranchExist[%d]: %v", pr.HeadRepo.ID, err)

+ if exist {

+ apiPullRequest.Head.Ref = pr.HeadBranch

+ }

+ if apiPullRequest.Head.Ref == "" {

+ apiPullRequest.Head.Ref = pr.GetGitRefName()

+ }

+ if pr.HeadRepoID == pr.BaseRepoID {

+ apiPullRequest.Head.Repository = apiPullRequest.Base.Repository

+ } else {

+ p, err := access_model.GetUserRepoPermission(ctx, pr.HeadRepo, doer)

+ log.Error("GetUserRepoPermission[%d]: %v", pr.HeadRepoID, err)

+ p.AccessMode = perm.AccessModeNone

+ apiPullRequest.Head.Repository = ToRepo(ctx, pr.HeadRepo, p)

+ }

+

+ if pr.Flow == issues_model.PullRequestFlowAGit {

+ apiPullRequest.Head.Name = ""

+ }

+ apiPullRequest.Head.Sha, err = gitRepo.GetRefCommitID(pr.GetGitRefName())

+ if err != nil {

+ log.Error("GetRefCommitID[%s]: %v", pr.GetGitRefName(), err)

+ // 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")

+ }

+

+ assert.Equal(t, reviewer.ID, review.ReviewerID)

+ assert.Equal(t, issues_model.ReviewTypePending, review.Type)

+ assert.Equal(t, &structs.PRBranchInfo{

+ 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)

+ "code.gitea.io/gitea/modules/util"

+ Topics: util.SliceNilAsEmpty(repo.Topics),

+ assert.Equal(t, api.VisibleTypePublic.String(), apiUser.Visibility)

+ assert.Equal(t, api.VisibleTypePrivate.String(), apiUser.Visibility)

+ assert.Equal(t, 30, ToCorrectPageSize(0))

+ assert.Equal(t, 30, ToCorrectPageSize(-10))

+ assert.Equal(t, 20, ToCorrectPageSize(20))

+ assert.Equal(t, 50, ToCorrectPageSize(100))

+ Timeout: time.Duration(setting.Git.Timeout.Default) * time.Second,

+ secret_model "code.gitea.io/gitea/models/secret"

+ {

+ Name: "Repository level Runners with non-zero owner_id",

+ Counter: actions_model.CountWrongRepoLevelRunners,

+ Fixer: actions_model.UpdateWrongRepoLevelRunners,

+ FixedMessage: "Corrected",

+ },

+ {

+ Name: "Repository level Variables with non-zero owner_id",

+ Counter: actions_model.CountWrongRepoLevelVariables,

+ Fixer: actions_model.UpdateWrongRepoLevelVariables,

+ FixedMessage: "Corrected",

+ },

+ {

+ Name: "Repository level Secrets with non-zero owner_id",

+ Counter: secret_model.CountWrongRepoLevelSecrets,

+ Fixer: secret_model.UpdateWrongRepoLevelSecrets,

+ FixedMessage: "Corrected",

+ },

+ "code.gitea.io/gitea/services/versioned_migration"

+ err = db.InitEngineWithMigration(ctx, versioned_migration.Migrate)

+func (d *doctorCheckLogger) Log(skip int, event *log.Event, format string, v ...any) {

+func (d *doctorCheckStepLogger) Log(skip int, event *log.Event, format string, v ...any) {

+ levelChar := fmt.Sprintf("[%s]", strings.ToUpper(event.Level.String()[0:1]))

+ levelArg = log.NewColoredValue(levelChar, event.Level.ColorAttributes()...)

+ assert.Equal(t, &tt.expected, cfg)

+ assert.Equal(t, &tt.expected, cfg)

+ _, _, defaultBranchErr := git.NewCommand("rev-parse").AddDashesAndList(repo.DefaultBranch).RunStdString(ctx, &git.RunOpts{Dir: repo.RepoPath()})

+ head, _, headErr := git.NewCommand("symbolic-ref", "--short", "HEAD").RunStdString(ctx, &git.RunOpts{Dir: repo.RepoPath()})

+ err := git.NewCommand("symbolic-ref").AddDashesAndList("HEAD", git.BranchPrefix+repo.DefaultBranch).Run(ctx, &git.RunOpts{Dir: repo.RepoPath()})

+ pr.MergeBase, _, err = git.NewCommand("merge-base").AddDashesAndList(pr.BaseBranch, pr.GetGitRefName()).RunStdString(ctx, &git.RunOpts{Dir: repoPath})

+ pr.MergeBase, _, err2 = git.NewCommand("rev-parse").AddDynamicArguments(git.BranchPrefix+pr.BaseBranch).RunStdString(ctx, &git.RunOpts{Dir: repoPath})

+ parentsString, _, err := git.NewCommand("rev-list", "--parents", "-n", "1").AddDynamicArguments(pr.MergedCommitID).RunStdString(ctx, &git.RunOpts{Dir: repoPath})

+ cmd := git.NewCommand("merge-base").AddDashesAndList(refs...)

+ pr.MergeBase, _, err = cmd.RunStdString(ctx, &git.RunOpts{Dir: repoPath})

+ "path/filepath"

+ results, err := gitrepo.CheckDelegateHooks(ctx, repo)

+ if err := gitrepo.CreateDelegateHooks(ctx, repo); err != nil {

+ _, _, err := git.NewCommand("config", "receive.advertisePushOptions", "true").RunStdString(ctx, &git.RunOpts{Dir: r.Path})

+ value, _, err := git.NewCommand("config", "receive.advertisePushOptions").RunStdString(ctx, &git.RunOpts{Dir: r.Path})

+ daemonExportFile := filepath.Join(repo.RepoPath(), `git-daemon-export-ok`)

+ commitGraphFile := filepath.Join(repo.RepoPath(), `objects/info/commit-graph`)

+ commitGraphsDir := filepath.Join(repo.RepoPath(), `objects/info/commit-graphs`)

+ oid := strings.ReplaceAll(strings.ReplaceAll(path, "\\", ""), "/", "")

+ "fmt"

+ "code.gitea.io/gitea/models/db"

+ access_model "code.gitea.io/gitea/models/perm/access"

+ repo_model "code.gitea.io/gitea/models/repo"

+ "code.gitea.io/gitea/models/unit"

+ user_model "code.gitea.io/gitea/models/user"

+ "code.gitea.io/gitea/modules/cache"

+ "code.gitea.io/gitea/modules/setting"

+ "code.gitea.io/gitea/modules/util"

+func userFeedCacheKey(userID int64) string {

+ return fmt.Sprintf("user_feed_%d", userID)

+}

+

+func GetFeedsForDashboard(ctx context.Context, opts activities_model.GetFeedsOptions) (activities_model.ActionList, int, error) {

+ opts.DontCount = opts.RequestedTeam == nil && opts.Date == ""

+ results, cnt, err := activities_model.GetFeeds(ctx, opts)

+ return results, util.Iif(opts.DontCount, -1, int(cnt)), err

+}

+

+

+// notifyWatchers creates batch of actions for every watcher.

+// It could insert duplicate actions for a repository action, like this:

+// * Original action: UserID=1 (the real actor), ActUserID=1

+// * Organization action: UserID=100 (the repo's org), ActUserID=1

+// * Watcher action: UserID=20 (a user who is watching a repo), ActUserID=1

+func notifyWatchers(ctx context.Context, act *activities_model.Action, watchers []*repo_model.Watch, permCode, permIssue, permPR []bool) error {

+ // Add feed for actioner.

+ act.UserID = act.ActUserID

+ if err := db.Insert(ctx, act); err != nil {

+ return fmt.Errorf("insert new actioner: %w", err)

+ }

+

+ // Add feed for organization

+ if act.Repo.Owner.IsOrganization() && act.ActUserID != act.Repo.Owner.ID {

+ act.ID = 0

+ act.UserID = act.Repo.Owner.ID

+ if err := db.Insert(ctx, act); err != nil {

+ return fmt.Errorf("insert new actioner: %w", err)

+ }

+ }

+

+ for i, watcher := range watchers {

+ if act.ActUserID == watcher.UserID {

+ continue

+ }

+ act.ID = 0

+ act.UserID = watcher.UserID

+ act.Repo.Units = nil

+

+ switch act.OpType {

+ case activities_model.ActionCommitRepo, activities_model.ActionPushTag, activities_model.ActionDeleteTag, activities_model.ActionPublishRelease, activities_model.ActionDeleteBranch:

+ if !permCode[i] {

+ continue

+ }

+ case activities_model.ActionCreateIssue, activities_model.ActionCommentIssue, activities_model.ActionCloseIssue, activities_model.ActionReopenIssue:

+ if !permIssue[i] {

+ continue

+ }

+ case activities_model.ActionCreatePullRequest, activities_model.ActionCommentPull, activities_model.ActionMergePullRequest, activities_model.ActionClosePullRequest, activities_model.ActionReopenPullRequest, activities_model.ActionAutoMergePullRequest:

+ if !permPR[i] {

+ continue

+ }

+ }

+

+ if err := db.Insert(ctx, act); err != nil {

+ return fmt.Errorf("insert new action: %w", err)

+ }

+

+ total, err := activities_model.CountUserFeeds(ctx, act.UserID)

+ if err != nil {

+ return fmt.Errorf("count user feeds: %w", err)

+ }

+

+ _ = cache.GetCache().Put(userFeedCacheKey(act.UserID), fmt.Sprintf("%d", total), setting.CacheService.TTLSeconds())

+ }

+

+ return nil

+}

+

+// NotifyWatchersActions creates batch of actions for every watcher.

+func NotifyWatchers(ctx context.Context, acts ...*activities_model.Action) error {

+ return db.WithTx(ctx, func(ctx context.Context) error {

+ if len(acts) == 0 {

+ return nil

+ }

+

+ repoID := acts[0].RepoID

+ if repoID == 0 {

+ setting.PanicInDevOrTesting("action should belong to a repo")

+ return nil

+ }

+ if err := acts[0].LoadRepo(ctx); err != nil {

+ return err

+ }

+ repo := acts[0].Repo

+ if err := repo.LoadOwner(ctx); err != nil {

+ return err

+ }

+

+ actUserID := acts[0].ActUserID

+

+ // Add feeds for user self and all watchers.

+ watchers, err := repo_model.GetWatchers(ctx, repoID)

+ if err != nil {

+ return fmt.Errorf("get watchers: %w", err)

+ }

+

+ permCode := make([]bool, len(watchers))

+ permIssue := make([]bool, len(watchers))

+ permPR := make([]bool, len(watchers))

+ for i, watcher := range watchers {

+ user, err := user_model.GetUserByID(ctx, watcher.UserID)

+ if err != nil {

+ permCode[i] = false

+ permIssue[i] = false

+ permPR[i] = false

+ continue

+ }

+ perm, err := access_model.GetUserRepoPermission(ctx, repo, user)

+ if err != nil {

+ permCode[i] = false

+ permIssue[i] = false

+ permPR[i] = false

+ continue

+ }

+ permCode[i] = perm.CanRead(unit.TypeCode)

+ permIssue[i] = perm.CanRead(unit.TypeIssues)

+ permPR[i] = perm.CanRead(unit.TypePullRequests)

+ }

+

+ for _, act := range acts {

+ if act.RepoID != repoID {

+ setting.PanicInDevOrTesting("action should belong to the same repo, expected[%d], got[%d] ", repoID, act.RepoID)

+ }

+ if act.ActUserID != actUserID {

+ setting.PanicInDevOrTesting("action should have the same actor, expected[%d], got[%d] ", actUserID, act.ActUserID)

+ }

+

+ act.Repo = repo

+ if err := notifyWatchers(ctx, act, watchers, permCode, permIssue, permPR); err != nil {

+ return err

+ }

+ }

+ return nil

+ })

+}

+ assert.Equal(t, user.ID, actions[0].UserID)

+ assert.Equal(t, org.ID, actions[0].UserID)

+

+func TestNotifyWatchers(t *testing.T) {

+ assert.NoError(t, unittest.PrepareTestDatabase())

+

+ action := &activities_model.Action{

+ ActUserID: 8,

+ RepoID: 1,

+ OpType: activities_model.ActionStarRepo,

+ }

+ assert.NoError(t, NotifyWatchers(db.DefaultContext, action))

+

+ // One watchers are inactive, thus action is only created for user 8, 1, 4, 11

+ unittest.AssertExistsAndLoadBean(t, &activities_model.Action{

+ ActUserID: action.ActUserID,

+ UserID: 8,

+ RepoID: action.RepoID,

+ OpType: action.OpType,

+ })

+ unittest.AssertExistsAndLoadBean(t, &activities_model.Action{

+ ActUserID: action.ActUserID,

+ UserID: 1,

+ RepoID: action.RepoID,

+ OpType: action.OpType,

+ })

+ unittest.AssertExistsAndLoadBean(t, &activities_model.Action{

+ ActUserID: action.ActUserID,

+ UserID: 4,

+ RepoID: action.RepoID,

+ OpType: action.OpType,

+ })

+ unittest.AssertExistsAndLoadBean(t, &activities_model.Action{

+ ActUserID: action.ActUserID,

+ UserID: 11,

+ RepoID: action.RepoID,

+ OpType: action.OpType,

+ })

+}

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, act); err != nil {

+ if err := NotifyWatchers(ctx, act); err != nil {

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, actions...); err != nil {

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err = NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ if err := NotifyWatchers(ctx, &activities_model.Action{

+ EnableCode bool

+ EnableWiki bool

+ EnableExternalWiki bool

+ DefaultWikiBranch string

+ ExternalWikiURL string

+ Status bool

+ WorkflowJob bool

+ Name string `binding:"Required;MaxSize(255)"`

+ Data string `binding:"Required;MaxSize(65535)"`

+ Description string `binding:"MaxSize(65535)"`

+ Name string `binding:"Required;MaxSize(255)"`

+ Data string `binding:"Required;MaxSize(65535)"`

+ Description string `binding:"MaxSize(65535)"`

+ Name string `binding:"Required;MaxSize(255)" locale:"settings.token_name"`

+// Copyright 2025 The Gitea Authors. All rights reserved.

+// SPDX-License-Identifier: MIT

+

+package git

+

+import (

+ "context"

+

+ asymkey_model "code.gitea.io/gitea/models/asymkey"

+ "code.gitea.io/gitea/models/db"

+ git_model "code.gitea.io/gitea/models/git"

+ repo_model "code.gitea.io/gitea/models/repo"

+ user_model "code.gitea.io/gitea/models/user"

+ "code.gitea.io/gitea/modules/container"

+ "code.gitea.io/gitea/modules/git"

+ asymkey_service "code.gitea.io/gitea/services/asymkey"

+)

+

+// ParseCommitsWithSignature checks if signaute of commits are corresponding to users gpg keys.

+func ParseCommitsWithSignature(ctx context.Context, oldCommits []*user_model.UserCommit, repoTrustModel repo_model.TrustModelType, isOwnerMemberCollaborator func(*user_model.User) (bool, error)) ([]*asymkey_model.SignCommit, error) {

+ newCommits := make([]*asymkey_model.SignCommit, 0, len(oldCommits))

+ keyMap := map[string]bool{}

+

+ emails := make(container.Set[string])

+ for _, c := range oldCommits {

+ if c.Committer != nil {

+ emails.Add(c.Committer.Email)

+ }

+ }

+

+ emailUsers, err := user_model.GetUsersByEmails(ctx, emails.Values())

+ if err != nil {

+ return nil, err

+ }

+

+ for _, c := range oldCommits {

+ committer, ok := emailUsers[c.Committer.Email]

+ if !ok && c.Committer != nil {

+ committer = &user_model.User{

+ Name: c.Committer.Name,

+ Email: c.Committer.Email,

+ }

+ }

+

+ signCommit := &asymkey_model.SignCommit{

+ UserCommit: c,

+ Verification: asymkey_service.ParseCommitWithSignatureCommitter(ctx, c.Commit, committer),

+ }

+

+ _ = asymkey_model.CalculateTrustStatus(signCommit.Verification, repoTrustModel, isOwnerMemberCollaborator, &keyMap)

+

+ newCommits = append(newCommits, signCommit)

+ }

+ return newCommits, nil

+}

+

+// ConvertFromGitCommit converts git commits into SignCommitWithStatuses

+func ConvertFromGitCommit(ctx context.Context, commits []*git.Commit, repo *repo_model.Repository) ([]*git_model.SignCommitWithStatuses, error) {

+ validatedCommits, err := user_model.ValidateCommitsWithEmails(ctx, commits)

+ if err != nil {

+ return nil, err

+ }

+ signedCommits, err := ParseCommitsWithSignature(

+ ctx,

+ validatedCommits,

+ repo.GetTrustModel(),

+ func(user *user_model.User) (bool, error) {

+ return repo_model.IsOwnerMemberCollaborator(ctx, repo, user.ID)

+ },

+ )

+ if err != nil {

+ return nil, err

+ }

+ return ParseCommitsWithStatus(ctx, signedCommits, repo)

+}

+

+// ParseCommitsWithStatus checks commits latest statuses and calculates its worst status state

+func ParseCommitsWithStatus(ctx context.Context, oldCommits []*asymkey_model.SignCommit, repo *repo_model.Repository) ([]*git_model.SignCommitWithStatuses, error) {

+ newCommits := make([]*git_model.SignCommitWithStatuses, 0, len(oldCommits))

+

+ for _, c := range oldCommits {

+ commit := &git_model.SignCommitWithStatuses{

+ SignCommit: c,

+ }

+ statuses, _, err := git_model.GetLatestCommitStatus(ctx, repo.ID, commit.ID.String(), db.ListOptions{})

+ if err != nil {

+ return nil, err

+ }

+

+ commit.Statuses = statuses

+ commit.Status = git_model.CalcCommitStatus(statuses)

+ newCommits = append(newCommits, commit)

+ }

+ return newCommits, nil

+}

+// Copyright 2025 The Gitea Authors. All rights reserved.

+// SPDX-License-Identifier: MIT

+

+package gitdiff

+

+import (

+ "bufio"

+ "context"

+ "fmt"

+ "io"

+ "strconv"

+ "strings"

+

+ "code.gitea.io/gitea/modules/git"

+ "code.gitea.io/gitea/modules/log"

+)

+

+type DiffTree struct {

+ Files []*DiffTreeRecord

+}

+

+type DiffTreeRecord struct {

+ // Status is one of 'added', 'deleted', 'modified', 'renamed', 'copied', 'typechanged', 'unmerged', 'unknown'

+ Status string

+

+ // For renames and copies, the percentage of similarity between the source and target of the move/rename.

+ Score uint8

+

+ HeadPath string

+ BasePath string

+ HeadMode git.EntryMode

+ BaseMode git.EntryMode

+ HeadBlobID string

+ BaseBlobID string

+}

+

+// GetDiffTree returns the list of path of the files that have changed between the two commits.

+// If useMergeBase is true, the diff will be calculated using the merge base of the two commits.

+// This is the same behavior as using a three-dot diff in git diff.

+func GetDiffTree(ctx context.Context, gitRepo *git.Repository, useMergeBase bool, baseSha, headSha string) (*DiffTree, error) {

+ gitDiffTreeRecords, err := runGitDiffTree(ctx, gitRepo, useMergeBase, baseSha, headSha)

+ if err != nil {

+ return nil, err

+ }

+

+ return &DiffTree{

+ Files: gitDiffTreeRecords,

+ }, nil

+}

+

+func runGitDiffTree(ctx context.Context, gitRepo *git.Repository, useMergeBase bool, baseSha, headSha string) ([]*DiffTreeRecord, error) {

+ useMergeBase, baseCommitID, headCommitID, err := validateGitDiffTreeArguments(gitRepo, useMergeBase, baseSha, headSha)

+ if err != nil {

+ return nil, err

+ }

+

+ cmd := git.NewCommand("diff-tree", "--raw", "-r", "--find-renames", "--root")

+ if useMergeBase {

+ cmd.AddArguments("--merge-base")

+ }

+ cmd.AddDynamicArguments(baseCommitID, headCommitID)

+ stdout, _, runErr := cmd.RunStdString(ctx, &git.RunOpts{Dir: gitRepo.Path})

+ if runErr != nil {

+ log.Warn("git diff-tree: %v", runErr)

+ return nil, runErr

+ }

+

+ return parseGitDiffTree(strings.NewReader(stdout))

+}

+

+func validateGitDiffTreeArguments(gitRepo *git.Repository, useMergeBase bool, baseSha, headSha string) (shouldUseMergeBase bool, resolvedBaseSha, resolvedHeadSha string, err error) {

+ // if the head is empty its an error

+ if headSha == "" {

+ return false, "", "", fmt.Errorf("headSha is empty")

+ }

+

+ // if the head commit doesn't exist its and error

+ headCommit, err := gitRepo.GetCommit(headSha)

+ if err != nil {

+ return false, "", "", fmt.Errorf("failed to get commit headSha: %v", err)

+ }

+ headCommitID := headCommit.ID.String()

+

+ // if the base is empty we should use the parent of the head commit

+ if baseSha == "" {

+ // if the headCommit has no parent we should use an empty commit

+ // this can happen when we are generating a diff against an orphaned commit

+ if headCommit.ParentCount() == 0 {

+ objectFormat, err := gitRepo.GetObjectFormat()

+ if err != nil {

+ return false, "", "", err

+ }

+

+ // We set use merge base to false because we have no base commit

+ return false, objectFormat.EmptyTree().String(), headCommitID, nil

+ }

+

+ baseCommit, err := headCommit.Parent(0)

+ if err != nil {

+ return false, "", "", fmt.Errorf("baseSha is '', attempted to use parent of commit %s, got error: %v", headCommit.ID.String(), err)

+ }

+ return useMergeBase, baseCommit.ID.String(), headCommitID, nil

+ }

+

+ // try and get the base commit

+ baseCommit, err := gitRepo.GetCommit(baseSha)

+ // propagate the error if we couldn't get the base commit

+ if err != nil {

+ return useMergeBase, "", "", fmt.Errorf("failed to get base commit %s: %v", baseSha, err)

+ }

+

+ return useMergeBase, baseCommit.ID.String(), headCommit.ID.String(), nil

+}

+

+func parseGitDiffTree(gitOutput io.Reader) ([]*DiffTreeRecord, error) {

+ /*

+ The output of `git diff-tree --raw -r --find-renames` is of the form:

+

+ :<old_mode> <new_mode> <old_sha> <new_sha> <status>\t<path>

+

+ or for renames:

+

+ :<old_mode> <new_mode> <old_sha> <new_sha> <status>\t<old_path>\t<new_path>

+

+ See: <https://git-scm.com/docs/git-diff-tree#_raw_output_format> for more details

+ */

+ results := make([]*DiffTreeRecord, 0)

+

+ lines := bufio.NewScanner(gitOutput)

+ for lines.Scan() {

+ line := lines.Text()

+

+ if len(line) == 0 {

+ continue

+ }

+

+ record, err := parseGitDiffTreeLine(line)

+ if err != nil {

+ return nil, err

+ }

+

+ results = append(results, record)

+ }

+

+ if err := lines.Err(); err != nil {

+ return nil, err

+ }

+

+ return results, nil

+}

+

+func parseGitDiffTreeLine(line string) (*DiffTreeRecord, error) {

+ line = strings.TrimPrefix(line, ":")

+ splitSections := strings.SplitN(line, "\t", 2)

+ if len(splitSections) < 2 {

+ return nil, fmt.Errorf("unparsable output for diff-tree --raw: `%s`)", line)

+ }

+

+ fields := strings.Fields(splitSections[0])

+ if len(fields) < 5 {

+ return nil, fmt.Errorf("unparsable output for diff-tree --raw: `%s`, expected 5 space delimited values got %d)", line, len(fields))

+ }

+

+ baseMode, err := git.ParseEntryMode(fields[0])

+ if err != nil {

+ return nil, err

+ }

+

+ headMode, err := git.ParseEntryMode(fields[1])

+ if err != nil {

+ return nil, err

+ }

+

+ baseBlobID := fields[2]

+ headBlobID := fields[3]

+

+ status, score, err := statusFromLetter(fields[4])

+ if err != nil {

+ return nil, fmt.Errorf("unparsable output for diff-tree --raw: %s, error: %s", line, err)

+ }

+

+ filePaths := strings.Split(splitSections[1], "\t")

+

+ var headPath, basePath string

+ if status == "renamed" {

+ if len(filePaths) != 2 {

+ return nil, fmt.Errorf("unparsable output for diff-tree --raw: `%s`, expected 2 paths found %d", line, len(filePaths))

+ }

+ basePath = filePaths[0]

+ headPath = filePaths[1]

+ } else {

+ basePath = filePaths[0]

+ headPath = filePaths[0]

+ }

+

+ return &DiffTreeRecord{

+ Status: status,

+ Score: score,

+ BaseMode: baseMode,

+ HeadMode: headMode,

+ BaseBlobID: baseBlobID,

+ HeadBlobID: headBlobID,

+ BasePath: basePath,

+ HeadPath: headPath,

+ }, nil

+}

+

+func statusFromLetter(rawStatus string) (status string, score uint8, err error) {

+ if len(rawStatus) < 1 {

+ return "", 0, fmt.Errorf("empty status letter")

+ }

+ switch rawStatus[0] {

+ case 'A':

+ return "added", 0, nil

+ case 'D':

+ return "deleted", 0, nil

+ case 'M':

+ return "modified", 0, nil

+ case 'R':

+ score, err = tryParseStatusScore(rawStatus)

+ return "renamed", score, err

+ case 'C':

+ score, err = tryParseStatusScore(rawStatus)

+ return "copied", score, err

+ case 'T':

+ return "typechanged", 0, nil

+ case 'U':

+ return "unmerged", 0, nil

+ case 'X':

+ return "unknown", 0, nil

+ default:

+ return "", 0, fmt.Errorf("unknown status letter: '%s'", rawStatus)

+ }

+}

+

+func tryParseStatusScore(rawStatus string) (uint8, error) {

+ if len(rawStatus) < 2 {

+ return 0, fmt.Errorf("status score missing")

+ }

+

+ score, err := strconv.ParseUint(rawStatus[1:], 10, 8)

+ if err != nil {

+ return 0, fmt.Errorf("failed to parse status score: %w", err)

+ } else if score > 100 {

+ return 0, fmt.Errorf("status score out of range: %d", score)

+ }

+

+ return uint8(score), nil

+}

+// Copyright 2025 The Gitea Authors. All rights reserved.

+// SPDX-License-Identifier: MIT

+

+package gitdiff

+

+import (

+ "strings"

+ "testing"

+

+ "code.gitea.io/gitea/models/db"

+ "code.gitea.io/gitea/modules/git"

+

+ "github.com/stretchr/testify/assert"

+ "github.com/stretchr/testify/require"

+)

+

+func TestGitDiffTree(t *testing.T) {

+ test := []struct {

+ Name string

+ RepoPath string

+ BaseSha string

+ HeadSha string

+ useMergeBase bool

+ Expected *DiffTree

+ }{

+ {

+ Name: "happy path",

+ RepoPath: "../../modules/git/tests/repos/repo5_pulls",

+ BaseSha: "72866af952e98d02a73003501836074b286a78f6",

+ HeadSha: "d8e0bbb45f200e67d9a784ce55bd90821af45ebd",

+ Expected: &DiffTree{

+ Files: []*DiffTreeRecord{

+ {

+ Status: "modified",

+ HeadPath: "LICENSE",

+ BasePath: "LICENSE",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "ee469963e76ae1bb7ee83d7510df2864e6c8c640",

+ BaseBlobID: "c996f4725be8fc8c1d1c776e58c97ddc5d03b336",

+ },

+ {

+ Status: "modified",

+ HeadPath: "README.md",

+ BasePath: "README.md",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "9dfc0a6257d8eff526f0cfaf6a8ea950f55a9dba",

+ BaseBlobID: "074e590b8e64898b02beef03ece83f962c94f54c",

+ },

+ },

+ },

+ },

+ {

+ Name: "first commit (no parent)",

+ RepoPath: "../../modules/git/tests/repos/repo5_pulls",

+ HeadSha: "72866af952e98d02a73003501836074b286a78f6",

+ Expected: &DiffTree{

+ Files: []*DiffTreeRecord{

+ {

+ Status: "added",

+ HeadPath: ".gitignore",

+ BasePath: ".gitignore",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeNoEntry,

+ HeadBlobID: "f1c181ec9c5c921245027c6b452ecfc1d3626364",

+ BaseBlobID: "0000000000000000000000000000000000000000",

+ },

+ {

+ Status: "added",

+ HeadPath: "LICENSE",

+ BasePath: "LICENSE",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeNoEntry,

+ HeadBlobID: "c996f4725be8fc8c1d1c776e58c97ddc5d03b336",

+ BaseBlobID: "0000000000000000000000000000000000000000",

+ },

+ {

+ Status: "added",

+ HeadPath: "README.md",

+ BasePath: "README.md",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeNoEntry,

+ HeadBlobID: "074e590b8e64898b02beef03ece83f962c94f54c",

+ BaseBlobID: "0000000000000000000000000000000000000000",

+ },

+ },

+ },

+ },

+ {

+ Name: "first commit (no parent), merge base = true",

+ RepoPath: "../../modules/git/tests/repos/repo5_pulls",

+ HeadSha: "72866af952e98d02a73003501836074b286a78f6",

+ useMergeBase: true,

+ Expected: &DiffTree{

+ Files: []*DiffTreeRecord{

+ {

+ Status: "added",

+ HeadPath: ".gitignore",

+ BasePath: ".gitignore",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeNoEntry,

+ HeadBlobID: "f1c181ec9c5c921245027c6b452ecfc1d3626364",

+ BaseBlobID: "0000000000000000000000000000000000000000",

+ },

+ {

+ Status: "added",

+ HeadPath: "LICENSE",

+ BasePath: "LICENSE",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeNoEntry,

+ HeadBlobID: "c996f4725be8fc8c1d1c776e58c97ddc5d03b336",

+ BaseBlobID: "0000000000000000000000000000000000000000",

+ },

+ {

+ Status: "added",

+ HeadPath: "README.md",

+ BasePath: "README.md",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeNoEntry,

+ HeadBlobID: "074e590b8e64898b02beef03ece83f962c94f54c",

+ BaseBlobID: "0000000000000000000000000000000000000000",

+ },

+ },

+ },

+ },

+ {

+ Name: "base and head same",

+ RepoPath: "../../modules/git/tests/repos/repo5_pulls",

+ BaseSha: "ed8f4d2fa5b2420706580d191f5dd50c4e491f3f",

+ HeadSha: "ed8f4d2fa5b2420706580d191f5dd50c4e491f3f",

+ Expected: &DiffTree{

+ Files: []*DiffTreeRecord{},

+ },

+ },

+ {

+ Name: "useMergeBase false",

+ RepoPath: "../../modules/git/tests/repos/repo5_pulls",

+ BaseSha: "ed8f4d2fa5b2420706580d191f5dd50c4e491f3f",

+ HeadSha: "111cac04bd7d20301964e27a93698aabb5781b80", // this commit can be found on the update-readme branch

+ useMergeBase: false,

+ Expected: &DiffTree{

+ Files: []*DiffTreeRecord{

+ {

+ Status: "modified",

+ HeadPath: "LICENSE",

+ BasePath: "LICENSE",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "c996f4725be8fc8c1d1c776e58c97ddc5d03b336",

+ BaseBlobID: "ed5119b3c1f45547b6785bc03eac7f87570fa17f",

+ },

+

+ {

+ Status: "modified",

+ HeadPath: "README.md",

+ BasePath: "README.md",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "fb39771a8865c9a67f2ab9b616c854805664553c",

+ BaseBlobID: "9dfc0a6257d8eff526f0cfaf6a8ea950f55a9dba",

+ },

+ },

+ },

+ },

+ {

+ Name: "useMergeBase true",

+ RepoPath: "../../modules/git/tests/repos/repo5_pulls",

+ BaseSha: "ed8f4d2fa5b2420706580d191f5dd50c4e491f3f",

+ HeadSha: "111cac04bd7d20301964e27a93698aabb5781b80", // this commit can be found on the update-readme branch

+ useMergeBase: true,

+ Expected: &DiffTree{

+ Files: []*DiffTreeRecord{

+ {

+ Status: "modified",

+ HeadPath: "README.md",

+ BasePath: "README.md",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "fb39771a8865c9a67f2ab9b616c854805664553c",

+ BaseBlobID: "9dfc0a6257d8eff526f0cfaf6a8ea950f55a9dba",

+ },

+ },

+ },

+ },

+ {

+ Name: "no base set",

+ RepoPath: "../../modules/git/tests/repos/repo5_pulls",

+ HeadSha: "d8e0bbb45f200e67d9a784ce55bd90821af45ebd", // this commit can be found on the update-readme branch

+ useMergeBase: false,

+ Expected: &DiffTree{

+ Files: []*DiffTreeRecord{

+ {

+ Status: "modified",

+ HeadPath: "LICENSE",

+ BasePath: "LICENSE",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "ee469963e76ae1bb7ee83d7510df2864e6c8c640",

+ BaseBlobID: "ed5119b3c1f45547b6785bc03eac7f87570fa17f",

+ },

+ },

+ },

+ },

+ }

+

+ for _, tt := range test {

+ t.Run(tt.Name, func(t *testing.T) {

+ gitRepo, err := git.OpenRepository(git.DefaultContext, tt.RepoPath)

+ assert.NoError(t, err)

+ defer gitRepo.Close()

+

+ diffPaths, err := GetDiffTree(db.DefaultContext, gitRepo, tt.useMergeBase, tt.BaseSha, tt.HeadSha)

+ require.NoError(t, err)

+

+ assert.Equal(t, tt.Expected, diffPaths)

+ })

+ }

+}

+

+func TestParseGitDiffTree(t *testing.T) {

+ test := []struct {

+ Name string

+ GitOutput string

+ Expected []*DiffTreeRecord

+ }{

+ {

+ Name: "file change",

+ GitOutput: ":100644 100644 64e43d23bcd08db12563a0a4d84309cadb437e1a 5dbc7792b5bb228647cfcc8dfe65fc649119dedc M\tResources/views/curriculum/edit.blade.php",

+ Expected: []*DiffTreeRecord{

+ {

+ Status: "modified",

+ HeadPath: "Resources/views/curriculum/edit.blade.php",

+ BasePath: "Resources/views/curriculum/edit.blade.php",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "5dbc7792b5bb228647cfcc8dfe65fc649119dedc",

+ BaseBlobID: "64e43d23bcd08db12563a0a4d84309cadb437e1a",

+ },

+ },

+ },

+ {

+ Name: "file added",

+ GitOutput: ":000000 100644 0000000000000000000000000000000000000000 0063162fb403db15ceb0517b34ab782e4e58b619 A\tResources/views/class/index.blade.php",

+ Expected: []*DiffTreeRecord{

+ {

+ Status: "added",

+ HeadPath: "Resources/views/class/index.blade.php",

+ BasePath: "Resources/views/class/index.blade.php",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeNoEntry,

+ HeadBlobID: "0063162fb403db15ceb0517b34ab782e4e58b619",

+ BaseBlobID: "0000000000000000000000000000000000000000",

+ },

+ },

+ },

+ {

+ Name: "file deleted",

+ GitOutput: ":100644 000000 bac4286303c8c0017ea2f0a48c561ddcc0330a14 0000000000000000000000000000000000000000 D\tResources/views/classes/index.blade.php",

+ Expected: []*DiffTreeRecord{

+ {

+ Status: "deleted",

+ HeadPath: "Resources/views/classes/index.blade.php",

+ BasePath: "Resources/views/classes/index.blade.php",

+ HeadMode: git.EntryModeNoEntry,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "0000000000000000000000000000000000000000",

+ BaseBlobID: "bac4286303c8c0017ea2f0a48c561ddcc0330a14",

+ },

+ },

+ },

+ {

+ Name: "file renamed",

+ GitOutput: ":100644 100644 c8a055cfb45cd39747292983ad1797ceab40f5b1 97248f79a90aaf81fe7fd74b33c1cb182dd41783 R087\tDatabase/Seeders/AdminDatabaseSeeder.php\tDatabase/Seeders/AcademicDatabaseSeeder.php",

+ Expected: []*DiffTreeRecord{

+ {

+ Status: "renamed",

+ Score: 87,

+ HeadPath: "Database/Seeders/AcademicDatabaseSeeder.php",

+ BasePath: "Database/Seeders/AdminDatabaseSeeder.php",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "97248f79a90aaf81fe7fd74b33c1cb182dd41783",

+ BaseBlobID: "c8a055cfb45cd39747292983ad1797ceab40f5b1",

+ },

+ },

+ },

+ {

+ Name: "no changes",

+ GitOutput: ``,

+ Expected: []*DiffTreeRecord{},

+ },

+ {

+ Name: "multiple changes",

+ GitOutput: ":000000 100644 0000000000000000000000000000000000000000 db736b44533a840981f1f17b7029d0f612b69550 A\tHttp/Controllers/ClassController.php\n" +

+ ":100644 000000 9a4d2344d4d0145db7c91b3f3e123c74367d4ef4 0000000000000000000000000000000000000000 D\tHttp/Controllers/ClassesController.php\n" +

+ ":100644 100644 f060d6aede65d423f49e7dc248dfa0d8835ef920 b82c8e39a3602dedadb44669956d6eb5b6a7cc86 M\tHttp/Controllers/ProgramDirectorController.php\n",

+ Expected: []*DiffTreeRecord{

+ {

+ Status: "added",

+ HeadPath: "Http/Controllers/ClassController.php",

+ BasePath: "Http/Controllers/ClassController.php",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeNoEntry,

+ HeadBlobID: "db736b44533a840981f1f17b7029d0f612b69550",

+ BaseBlobID: "0000000000000000000000000000000000000000",

+ },

+ {

+ Status: "deleted",

+ HeadPath: "Http/Controllers/ClassesController.php",

+ BasePath: "Http/Controllers/ClassesController.php",

+ HeadMode: git.EntryModeNoEntry,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "0000000000000000000000000000000000000000",

+ BaseBlobID: "9a4d2344d4d0145db7c91b3f3e123c74367d4ef4",

+ },

+ {

+ Status: "modified",

+ HeadPath: "Http/Controllers/ProgramDirectorController.php",

+ BasePath: "Http/Controllers/ProgramDirectorController.php",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "b82c8e39a3602dedadb44669956d6eb5b6a7cc86",

+ BaseBlobID: "f060d6aede65d423f49e7dc248dfa0d8835ef920",

+ },

+ },

+ },

+ {

+ Name: "spaces in file path",

+ GitOutput: ":000000 100644 0000000000000000000000000000000000000000 db736b44533a840981f1f17b7029d0f612b69550 A\tHttp /Controllers/Class Controller.php\n" +

+ ":100644 000000 9a4d2344d4d0145db7c91b3f3e123c74367d4ef4 0000000000000000000000000000000000000000 D\tHttp/Cont rollers/Classes Controller.php\n" +

+ ":100644 100644 f060d6aede65d423f49e7dc248dfa0d8835ef920 b82c8e39a3602dedadb44669956d6eb5b6a7cc86 R010\tHttp/Controllers/Program Director Controller.php\tHttp/Cont rollers/ProgramDirectorController.php\n",

+ Expected: []*DiffTreeRecord{

+ {

+ Status: "added",

+ HeadPath: "Http /Controllers/Class Controller.php",

+ BasePath: "Http /Controllers/Class Controller.php",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeNoEntry,

+ HeadBlobID: "db736b44533a840981f1f17b7029d0f612b69550",

+ BaseBlobID: "0000000000000000000000000000000000000000",

+ },

+ {

+ Status: "deleted",

+ HeadPath: "Http/Cont rollers/Classes Controller.php",

+ BasePath: "Http/Cont rollers/Classes Controller.php",

+ HeadMode: git.EntryModeNoEntry,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "0000000000000000000000000000000000000000",

+ BaseBlobID: "9a4d2344d4d0145db7c91b3f3e123c74367d4ef4",

+ },

+ {

+ Status: "renamed",

+ Score: 10,

+ HeadPath: "Http/Cont rollers/ProgramDirectorController.php",

+ BasePath: "Http/Controllers/Program Director Controller.php",

+ HeadMode: git.EntryModeBlob,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "b82c8e39a3602dedadb44669956d6eb5b6a7cc86",

+ BaseBlobID: "f060d6aede65d423f49e7dc248dfa0d8835ef920",

+ },

+ },

+ },

+ {

+ Name: "file type changed",

+ GitOutput: ":100644 120000 344e0ca8aa791cc4164fb0ea645f334fd40d00f0 a7c2973de00bfdc6ca51d315f401b5199fe01dc3 T\twebpack.mix.js",

+ Expected: []*DiffTreeRecord{

+ {

+ Status: "typechanged",

+ HeadPath: "webpack.mix.js",

+ BasePath: "webpack.mix.js",

+ HeadMode: git.EntryModeSymlink,

+ BaseMode: git.EntryModeBlob,

+ HeadBlobID: "a7c2973de00bfdc6ca51d315f401b5199fe01dc3",

+ BaseBlobID: "344e0ca8aa791cc4164fb0ea645f334fd40d00f0",

+ },

+ },

+ },

+ }

+

+ for _, tt := range test {

+ t.Run(tt.Name, func(t *testing.T) {

+ entries, err := parseGitDiffTree(strings.NewReader(tt.GitOutput))

+ assert.NoError(t, err)

+ assert.Equal(t, tt.Expected, entries)

+ })

+ }

+}

+

+func TestGitDiffTreeErrors(t *testing.T) {

+ test := []struct {

+ Name string

+ RepoPath string

+ BaseSha string

+ HeadSha string

+ }{

+ {

+ Name: "head doesn't exist",

+ RepoPath: "../../modules/git/tests/repos/repo5_pulls",

+ BaseSha: "f32b0a9dfd09a60f616f29158f772cedd89942d2",

+ HeadSha: "asdfasdfasdf",

+ },

+ {

+ Name: "base doesn't exist",

+ RepoPath: "../../modules/git/tests/repos/repo5_pulls",

+ BaseSha: "asdfasdfasdf",

+ HeadSha: "f32b0a9dfd09a60f616f29158f772cedd89942d2",

+ },

+ {

+ Name: "head not set",

+ RepoPath: "../../modules/git/tests/repos/repo5_pulls",

+ BaseSha: "f32b0a9dfd09a60f616f29158f772cedd89942d2",

+ },

+ }

+

+ for _, tt := range test {

+ t.Run(tt.Name, func(t *testing.T) {

+ gitRepo, err := git.OpenRepository(git.DefaultContext, tt.RepoPath)

+ assert.NoError(t, err)

+ defer gitRepo.Close()

+

+ diffPaths, err := GetDiffTree(db.DefaultContext, gitRepo, true, tt.BaseSha, tt.HeadSha)

+ assert.Error(t, err)

+ assert.Nil(t, diffPaths)

+ })

+ }

+}

+ "code.gitea.io/gitea/modules/util"

+ LeftIdx int // line number, 1-based

+ RightIdx int // line number, 1-based

+ Match int // the diff matched index. -1: no match. 0: plain and no need to match. >0: for add/del, "Lines" slice index of the other side

+ Comments issues_model.CommentList // related PR code comments

+// DiffHTMLOperation is the HTML version of diffmatchpatch.Diff

+type DiffHTMLOperation struct {

+ Type diffmatchpatch.Operation

+ HTML template.HTML

+}

+

+// MaxDiffHighlightEntireFileSize is the maximum file size that will be highlighted with "entire file diff"

+const MaxDiffHighlightEntireFileSize = 1 * 1024 * 1024

+

+ default:

+ return "same"

+func (diffSection *DiffSection) GetLine(idx int) *DiffLine {

+ if idx <= 0 {

+ return nil

+ return diffSection.Lines[idx]

+// This algorithm is not quite right.

+// Actually now we have "Match" field, it is always right, so use it instead in new GetLine

+func (diffSection *DiffSection) getLineLegacy(lineType DiffLineType, idx int) *DiffLine { //nolint:unused

+func defaultDiffMatchPatch() *diffmatchpatch.DiffMatchPatch {

+ dmp := diffmatchpatch.New()

+ dmp.DiffEditCost = 100

+ return dmp

+// DiffInlineWithUnicodeEscape makes a DiffInline with hidden Unicode characters escaped

+func (diffSection *DiffSection) getLineContentForRender(lineIdx int, diffLine *DiffLine, fileLanguage string, highlightLines map[int]template.HTML) template.HTML {

+ h, ok := highlightLines[lineIdx-1]

+ if ok {

+ return h

+ }

+ if diffLine.Content == "" {

+ return ""

+ }

+ return template.HTML(html.EscapeString(diffLine.Content[1:]))

+ h, _ = highlight.Code(diffSection.FileName, fileLanguage, diffLine.Content[1:])

+ return h

+}

+func (diffSection *DiffSection) getDiffLineForRender(diffLineType DiffLineType, leftLine, rightLine *DiffLine, locale translation.Locale) DiffInline {

+ var fileLanguage string

+ var highlightedLeftLines, highlightedRightLines map[int]template.HTML

+ // when a "diff section" is manually prepared by ExcerptBlob, it doesn't have "file" information

+ fileLanguage = diffSection.file.Language

+ highlightedLeftLines, highlightedRightLines = diffSection.file.highlightedLeftLines, diffSection.file.highlightedRightLines

+ var lineHTML template.HTML

+ hcd := newHighlightCodeDiff()

+ if diffLineType == DiffLinePlain {

+ // left and right are the same, no need to do line-level diff

+ if leftLine != nil {

+ lineHTML = diffSection.getLineContentForRender(leftLine.LeftIdx, leftLine, fileLanguage, highlightedLeftLines)

+ } else if rightLine != nil {

+ lineHTML = diffSection.getLineContentForRender(rightLine.RightIdx, rightLine, fileLanguage, highlightedRightLines)

+ }

+ } else {

+ var diff1, diff2 template.HTML

+ if leftLine != nil {

+ diff1 = diffSection.getLineContentForRender(leftLine.LeftIdx, leftLine, fileLanguage, highlightedLeftLines)

+ }

+ if rightLine != nil {

+ diff2 = diffSection.getLineContentForRender(rightLine.RightIdx, rightLine, fileLanguage, highlightedRightLines)

+ }

+ if diff1 != "" && diff2 != "" {

+ // if only some parts of a line are changed, highlight these changed parts as "deleted/added".

+ lineHTML = hcd.diffLineWithHighlight(diffLineType, diff1, diff2)

+ } else {

+ // if left is empty or right is empty (a line is fully deleted or added), then we do not need to diff anymore.

+ // the tmpl code already adds background colors for these cases.

+ lineHTML = util.Iif(diffLineType == DiffLineDel, diff1, diff2)

+ }

+ }

+ return DiffInlineWithUnicodeEscape(lineHTML, locale)

+}

+

+// GetComputedInlineDiffFor computes inline diff for the given line.

+func (diffSection *DiffSection) GetComputedInlineDiffFor(diffLine *DiffLine, locale translation.Locale) DiffInline {

+ compareDiffLine := diffSection.GetLine(diffLine.Match)

+ return diffSection.getDiffLineForRender(DiffLineAdd, compareDiffLine, diffLine, locale)

+ compareDiffLine := diffSection.GetLine(diffLine.Match)

+ return diffSection.getDiffLineForRender(DiffLineDel, diffLine, compareDiffLine, locale)

+ default: // Plain

+ // TODO: there was an "if" check: `if diffLine.Content >strings.IndexByte(" +-", diffLine.Content[0]) > -1 { ... } else { ... }`

+ // no idea why it needs that check, it seems that the "if" should be always true, so try to simplify the code

+ return diffSection.getDiffLineForRender(DiffLinePlain, nil, diffLine, locale)

+ // only used internally to parse Ambiguous filenames

+ isAmbiguous bool

+

+ // basic fields (parsed from diff result)

+ Name string

+ NameHash string

+ OldName string

+ Addition int

+ Deletion int

+ Type DiffFileType

+ Mode string

+ OldMode string

+ IsCreated bool

+ IsDeleted bool

+ IsBin bool

+ IsLFSFile bool

+ IsRenamed bool

+ IsSubmodule bool

+ // basic fields but for render purpose only

+ Sections []*DiffSection

+ IsIncomplete bool

+ IsIncompleteLineTooLong bool

+

+ // will be filled by the extra loop in GitDiffForRender

+ Language string