+func Exist[T any](ctx context.Context, cond builder.Cond) (bool, error) {

+ if !cond.IsValid() {

+ return false, ErrConditionRequired{}

+ }

+

+ var bean T

+ return GetEngine(ctx).Where(cond).NoAutoCondition().Exist(&bean)

+}

+

+

+// ErrConditionRequired represents an error which require condition.

+type ErrConditionRequired struct{}

+

+// IsErrConditionRequired checks if an error is an ErrConditionRequired

+func IsErrConditionRequired(err error) bool {

+ _, ok := err.(ErrConditionRequired)

+ return ok

+}

+

+func (err ErrConditionRequired) Error() string {

+ return "condition is required"

+}

+

+// Unwrap unwraps this as a ErrNotExist err

+func (err ErrConditionRequired) Unwrap() error {

+ return util.ErrInvalidArgument

+}

+// UpdateBranch updates the branch information in the database.

+func UpdateBranch(ctx context.Context, repoID, pusherID int64, branchName string, commit *git.Commit) (int64, error) {

+ return db.GetEngine(ctx).Where("repo_id=? AND name=?", repoID, branchName).

+ var branch Branch

+ exist, err := db.GetEngine(ctx).Where("repo_id=? AND name=?", repo.ID, from).Get(&branch)

+ if err != nil {

+ return err

+ } else if !exist || branch.IsDeleted {

+ return ErrBranchNotExist{

+ RepoID: repo.ID,

+ BranchName: from,

+ }

+ }

+

+func (opts FindBranchOptions) ToConds() builder.Cond {

+ return db.GetEngine(ctx).Where(opts.ToConds()).Count(&Branch{})

+ sess := db.GetEngine(ctx).Where(opts.ToConds())

+ sess := db.GetEngine(ctx).Select("name").Where(opts.ToConds())

+ _, err := git_model.UpdateBranch(db.DefaultContext, repo.ID, secondBranch.PusherID, secondBranch.Name, commit)

+type ErrRepoIsArchived struct {

+ Repo *Repository

+}

+

+func (err ErrRepoIsArchived) Error() string {

+ return fmt.Sprintf("%s is archived", err.Repo.LogString())

+}

+

+// MustNotBeArchived returns ErrRepoIsArchived if the repo is archived

+func (repo *Repository) MustNotBeArchived() error {

+ if repo.IsArchived {

+ return ErrRepoIsArchived{Repo: repo}

+ }

+ return nil

+}

+

+ err = repo_service.CreateNewBranchFromCommit(ctx, ctx.Doer, ctx.Repo.Repository, ctx.Repo.GitRepo, oldCommit.ID.String(), opt.BranchName)

+ } else if models.IsErrTagAlreadyExists(err) {

+ err = repo_service.CreateNewBranch(ctx, ctx.Doer, ctx.Repo.Repository, ctx.Repo.GitRepo, ctx.Repo.BranchName, form.NewBranchName)

+ err = repo_service.CreateNewBranchFromCommit(ctx, ctx.Doer, ctx.Repo.Repository, ctx.Repo.GitRepo, ctx.Repo.CommitID, form.NewBranchName)

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

+func CreateNewBranch(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, gitRepo *git.Repository, oldBranchName, branchName string) (err error) {

+ branch, err := git_model.GetBranch(ctx, repo.ID, oldBranchName)

+ if err != nil {

+ return CreateNewBranchFromCommit(ctx, doer, repo, gitRepo, branch.CommitID, branchName)

+// syncBranchToDB sync the branch information in the database. It will try to update the branch first,

+// if updated success with affect records > 0, then all are done. Because that means the branch has been in the database.

+// If no record is affected, that means the branch does not exist in database. So there are two possibilities.

+// One is this is a new branch, then we just need to insert the record. Another is the branches haven't been synced,

+// then we need to sync all the branches into database.

+func syncBranchToDB(ctx context.Context, repoID, pusherID int64, branchName string, commit *git.Commit) error {

+ cnt, err := git_model.UpdateBranch(ctx, repoID, pusherID, branchName, commit)

+ if err != nil {

+ return fmt.Errorf("git_model.UpdateBranch %d:%s failed: %v", repoID, branchName, err)

+ }

+ if cnt > 0 { // This means branch does exist, so it's a normal update. It also means the branch has been synced.

+ return nil

+ }

+

+ // if user haven't visit UI but directly push to a branch after upgrading from 1.20 -> 1.21,

+ // we cannot simply insert the branch but need to check we have branches or not

+ hasBranch, err := db.Exist[git_model.Branch](ctx, git_model.FindBranchOptions{

+ RepoID: repoID,

+ IsDeletedBranch: util.OptionalBoolFalse,

+ }.ToConds())

+ if err != nil {

+ return err

+ }

+ if !hasBranch {

+ if _, err = repo_module.SyncRepoBranches(ctx, repoID, pusherID); err != nil {

+ return fmt.Errorf("repo_module.SyncRepoBranches %d:%s failed: %v", repoID, branchName, err)

+ }

+ return nil

+ }

+

+ // if database have branches but not this branch, it means this is a new branch

+ return db.Insert(ctx, &git_model.Branch{

+ RepoID: repoID,

+ Name: branchName,

+ CommitID: commit.ID.String(),

+ CommitMessage: commit.Summary(),

+ PusherID: pusherID,

+ CommitTime: timeutil.TimeStamp(commit.Committer.When.Unix()),

+ })

+}

+

+func CreateNewBranchFromCommit(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, gitRepo *git.Repository, commitID, branchName string) (err error) {

+ err = repo.MustNotBeArchived()

+ if err != nil {

+ return err

+ }

+

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

+ commit, err := gitRepo.GetCommit(commitID)

+ if err != nil {

+ return err

+ }

+ // database operation should be done before git operation so that we can rollback if git operation failed

+ if err := syncBranchToDB(ctx, repo.ID, doer.ID, branchName, commit); err != nil {

+ if err := git.Push(ctx, repo.RepoPath(), git.PushOptions{

+ Remote: repo.RepoPath(),

+ Branch: fmt.Sprintf("%s:%s%s", commitID, git.BranchPrefix, branchName),

+ Env: repo_module.PushingEnvironment(doer, repo),

+ }); err != nil {

+ if git.IsErrPushOutOfDate(err) || git.IsErrPushRejected(err) {

+ return err

+ }

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

+ }

+ return nil

+ })

+ if err = syncBranchToDB(ctx, repo.ID, opts.PusherID, branch, newCommit); err != nil {

+ // Make a new branch in repo1

+ newBranch := "test_branch"

+ err = repo_service.CreateNewBranch(git.DefaultContext, user2, repo1, gitRepo, repo1.DefaultBranch, newBranch)

+ assert.NoError(t, err)

+

+ // Make a new branch in repo1

+ newBranch := "test_branch"

+ err = repo_service.CreateNewBranch(git.DefaultContext, user2, repo1, gitRepo, repo1.DefaultBranch, newBranch)

+ assert.NoError(t, err)

+