remove util.OptionalBool and related functions (#29513)

+8 -5

models/actions/runner.go

··· 13 13 repo_model "code.gitea.io/gitea/models/repo" 14 14 "code.gitea.io/gitea/models/shared/types" 15 15 user_model "code.gitea.io/gitea/models/user" 16 + "code.gitea.io/gitea/modules/optional" 16 17 "code.gitea.io/gitea/modules/timeutil" 17 18 "code.gitea.io/gitea/modules/translation" 18 19 "code.gitea.io/gitea/modules/util" ··· 159 160 OwnerID int64 160 161 Sort string 161 162 Filter string 162 - IsOnline util.OptionalBool 163 + IsOnline optional.Option[bool] 163 164 WithAvailable bool // not only runners belong to, but also runners can be used 164 165 } 165 166 ··· 186 187 cond = cond.And(builder.Like{"name", opts.Filter}) 187 188 } 188 189 189 - if opts.IsOnline.IsTrue() { 190 - cond = cond.And(builder.Gt{"last_online": time.Now().Add(-RunnerOfflineTime).Unix()}) 191 - } else if opts.IsOnline.IsFalse() { 192 - cond = cond.And(builder.Lte{"last_online": time.Now().Add(-RunnerOfflineTime).Unix()}) 190 + if opts.IsOnline.Has() { 191 + if opts.IsOnline.Value() { 192 + cond = cond.And(builder.Gt{"last_online": time.Now().Add(-RunnerOfflineTime).Unix()}) 193 + } else { 194 + cond = cond.And(builder.Lte{"last_online": time.Now().Add(-RunnerOfflineTime).Unix()}) 195 + } 193 196 } 194 197 return cond 195 198 }

+5 -4

models/auth/source.go

··· 11 11 12 12 "code.gitea.io/gitea/models/db" 13 13 "code.gitea.io/gitea/modules/log" 14 + "code.gitea.io/gitea/modules/optional" 14 15 "code.gitea.io/gitea/modules/timeutil" 15 16 "code.gitea.io/gitea/modules/util" 16 17 ··· 243 244 244 245 type FindSourcesOptions struct { 245 246 db.ListOptions 246 - IsActive util.OptionalBool 247 + IsActive optional.Option[bool] 247 248 LoginType Type 248 249 } 249 250 250 251 func (opts FindSourcesOptions) ToConds() builder.Cond { 251 252 conds := builder.NewCond() 252 - if !opts.IsActive.IsNone() { 253 - conds = conds.And(builder.Eq{"is_active": opts.IsActive.IsTrue()}) 253 + if opts.IsActive.Has() { 254 + conds = conds.And(builder.Eq{"is_active": opts.IsActive.Value()}) 254 255 } 255 256 if opts.LoginType != NoType { 256 257 conds = conds.And(builder.Eq{"`type`": opts.LoginType}) ··· 262 263 // source of type LoginSSPI 263 264 func IsSSPIEnabled(ctx context.Context) bool { 264 265 exist, err := db.Exist[Source](ctx, FindSourcesOptions{ 265 - IsActive: util.OptionalBoolTrue, 266 + IsActive: optional.Some(true), 266 267 LoginType: SSPI, 267 268 }.ToConds()) 268 269 if err != nil {

+8 -7

models/issues/comment.go

··· 22 22 "code.gitea.io/gitea/modules/gitrepo" 23 23 "code.gitea.io/gitea/modules/json" 24 24 "code.gitea.io/gitea/modules/log" 25 + "code.gitea.io/gitea/modules/optional" 25 26 "code.gitea.io/gitea/modules/references" 26 27 "code.gitea.io/gitea/modules/structs" 27 28 "code.gitea.io/gitea/modules/timeutil" ··· 1044 1045 TreePath string 1045 1046 Type CommentType 1046 1047 IssueIDs []int64 1047 - Invalidated util.OptionalBool 1048 - IsPull util.OptionalBool 1048 + Invalidated optional.Option[bool] 1049 + IsPull optional.Option[bool] 1049 1050 } 1050 1051 1051 1052 // ToConds implements FindOptions interface ··· 1077 1078 if len(opts.TreePath) > 0 { 1078 1079 cond = cond.And(builder.Eq{"comment.tree_path": opts.TreePath}) 1079 1080 } 1080 - if !opts.Invalidated.IsNone() { 1081 - cond = cond.And(builder.Eq{"comment.invalidated": opts.Invalidated.IsTrue()}) 1081 + if opts.Invalidated.Has() { 1082 + cond = cond.And(builder.Eq{"comment.invalidated": opts.Invalidated.Value()}) 1082 1083 } 1083 - if opts.IsPull != util.OptionalBoolNone { 1084 - cond = cond.And(builder.Eq{"issue.is_pull": opts.IsPull.IsTrue()}) 1084 + if opts.IsPull.Has() { 1085 + cond = cond.And(builder.Eq{"issue.is_pull": opts.IsPull.Value()}) 1085 1086 } 1086 1087 return cond 1087 1088 } ··· 1090 1091 func FindComments(ctx context.Context, opts *FindCommentsOptions) (CommentList, error) { 1091 1092 comments := make([]*Comment, 0, 10) 1092 1093 sess := db.GetEngine(ctx).Where(opts.ToConds()) 1093 - if opts.RepoID > 0 || opts.IsPull != util.OptionalBoolNone { 1094 + if opts.RepoID > 0 || opts.IsPull.Has() { 1094 1095 sess.Join("INNER", "issue", "issue.id = comment.issue_id") 1095 1096 } 1096 1097

+11 -14

models/issues/issue_search.go

··· 13 13 repo_model "code.gitea.io/gitea/models/repo" 14 14 "code.gitea.io/gitea/models/unit" 15 15 user_model "code.gitea.io/gitea/models/user" 16 - "code.gitea.io/gitea/modules/util" 16 + "code.gitea.io/gitea/modules/optional" 17 17 18 18 "xorm.io/builder" 19 19 "xorm.io/xorm" ··· 34 34 MilestoneIDs []int64 35 35 ProjectID int64 36 36 ProjectBoardID int64 37 - IsClosed util.OptionalBool 38 - IsPull util.OptionalBool 37 + IsClosed optional.Option[bool] 38 + IsPull optional.Option[bool] 39 39 LabelIDs []int64 40 40 IncludedLabelNames []string 41 41 ExcludedLabelNames []string ··· 46 46 UpdatedBeforeUnix int64 47 47 // prioritize issues from this repo 48 48 PriorityRepoID int64 49 - IsArchived util.OptionalBool 49 + IsArchived optional.Option[bool] 50 50 Org *organization.Organization // issues permission scope 51 51 Team *organization.Team // issues permission scope 52 52 User *user_model.User // issues permission scope ··· 217 217 218 218 applyRepoConditions(sess, opts) 219 219 220 - if !opts.IsClosed.IsNone() { 221 - sess.And("issue.is_closed=?", opts.IsClosed.IsTrue()) 220 + if opts.IsClosed.Has() { 221 + sess.And("issue.is_closed=?", opts.IsClosed.Value()) 222 222 } 223 223 224 224 if opts.AssigneeID > 0 { ··· 260 260 261 261 applyProjectBoardCondition(sess, opts) 262 262 263 - switch opts.IsPull { 264 - case util.OptionalBoolTrue: 265 - sess.And("issue.is_pull=?", true) 266 - case util.OptionalBoolFalse: 267 - sess.And("issue.is_pull=?", false) 263 + if opts.IsPull.Has() { 264 + sess.And("issue.is_pull=?", opts.IsPull.Value()) 268 265 } 269 266 270 - if opts.IsArchived != util.OptionalBoolNone { 271 - sess.And(builder.Eq{"repository.is_archived": opts.IsArchived.IsTrue()}) 267 + if opts.IsArchived.Has() { 268 + sess.And(builder.Eq{"repository.is_archived": opts.IsArchived.Value()}) 272 269 } 273 270 274 271 applyLabelsCondition(sess, opts) 275 272 276 273 if opts.User != nil { 277 - sess.And(issuePullAccessibleRepoCond("issue.repo_id", opts.User.ID, opts.Org, opts.Team, opts.IsPull.IsTrue())) 274 + sess.And(issuePullAccessibleRepoCond("issue.repo_id", opts.User.ID, opts.Org, opts.Team, opts.IsPull.Value())) 278 275 } 279 276 280 277 return sess

+2 -6

models/issues/issue_stats.go

··· 8 8 "fmt" 9 9 10 10 "code.gitea.io/gitea/models/db" 11 - "code.gitea.io/gitea/modules/util" 12 11 13 12 "xorm.io/builder" 14 13 "xorm.io/xorm" ··· 170 169 applyReviewedCondition(sess, opts.ReviewedID) 171 170 } 172 171 173 - switch opts.IsPull { 174 - case util.OptionalBoolTrue: 175 - sess.And("issue.is_pull=?", true) 176 - case util.OptionalBoolFalse: 177 - sess.And("issue.is_pull=?", false) 172 + if opts.IsPull.Has() { 173 + sess.And("issue.is_pull=?", opts.IsPull.Value()) 178 174 } 179 175 180 176 return sess

+2 -1

models/issues/label.go

··· 12 12 13 13 "code.gitea.io/gitea/models/db" 14 14 "code.gitea.io/gitea/modules/label" 15 + "code.gitea.io/gitea/modules/optional" 15 16 "code.gitea.io/gitea/modules/timeutil" 16 17 "code.gitea.io/gitea/modules/util" 17 18 ··· 126 127 counts, _ := CountIssuesByRepo(ctx, &IssuesOptions{ 127 128 RepoIDs: []int64{repoID}, 128 129 LabelIDs: []int64{labelID}, 129 - IsClosed: util.OptionalBoolFalse, 130 + IsClosed: optional.Some(false), 130 131 }) 131 132 132 133 for _, count := range counts {

+2 -1

models/issues/milestone.go

··· 11 11 12 12 "code.gitea.io/gitea/models/db" 13 13 repo_model "code.gitea.io/gitea/models/repo" 14 + "code.gitea.io/gitea/modules/optional" 14 15 api "code.gitea.io/gitea/modules/structs" 15 16 "code.gitea.io/gitea/modules/timeutil" 16 17 "code.gitea.io/gitea/modules/util" ··· 314 315 } 315 316 numClosedMilestones, err := db.Count[Milestone](ctx, FindMilestoneOptions{ 316 317 RepoID: repo.ID, 317 - IsClosed: util.OptionalBoolTrue, 318 + IsClosed: optional.Some(true), 318 319 }) 319 320 if err != nil { 320 321 return err

+4 -4

models/issues/milestone_list.go

··· 8 8 "strings" 9 9 10 10 "code.gitea.io/gitea/models/db" 11 - "code.gitea.io/gitea/modules/util" 11 + "code.gitea.io/gitea/modules/optional" 12 12 13 13 "xorm.io/builder" 14 14 ) ··· 28 28 type FindMilestoneOptions struct { 29 29 db.ListOptions 30 30 RepoID int64 31 - IsClosed util.OptionalBool 31 + IsClosed optional.Option[bool] 32 32 Name string 33 33 SortType string 34 34 RepoCond builder.Cond ··· 40 40 if opts.RepoID != 0 { 41 41 cond = cond.And(builder.Eq{"repo_id": opts.RepoID}) 42 42 } 43 - if opts.IsClosed != util.OptionalBoolNone { 44 - cond = cond.And(builder.Eq{"is_closed": opts.IsClosed.IsTrue()}) 43 + if opts.IsClosed.Has() { 44 + cond = cond.And(builder.Eq{"is_closed": opts.IsClosed.Value()}) 45 45 } 46 46 if opts.RepoCond != nil && opts.RepoCond.IsValid() { 47 47 cond = cond.And(builder.In("repo_id", builder.Select("id").From("repository").Where(opts.RepoCond)))

+12 -12

models/issues/milestone_test.go

··· 11 11 issues_model "code.gitea.io/gitea/models/issues" 12 12 repo_model "code.gitea.io/gitea/models/repo" 13 13 "code.gitea.io/gitea/models/unittest" 14 + "code.gitea.io/gitea/modules/optional" 14 15 "code.gitea.io/gitea/modules/setting" 15 16 api "code.gitea.io/gitea/modules/structs" 16 17 "code.gitea.io/gitea/modules/timeutil" 17 - "code.gitea.io/gitea/modules/util" 18 18 19 19 "github.com/stretchr/testify/assert" 20 20 ) ··· 39 39 func TestGetMilestonesByRepoID(t *testing.T) { 40 40 assert.NoError(t, unittest.PrepareTestDatabase()) 41 41 test := func(repoID int64, state api.StateType) { 42 - var isClosed util.OptionalBool 42 + var isClosed optional.Option[bool] 43 43 switch state { 44 44 case api.StateClosed, api.StateOpen: 45 - isClosed = util.OptionalBoolOf(state == api.StateClosed) 45 + isClosed = optional.Some(state == api.StateClosed) 46 46 } 47 47 repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID}) 48 48 milestones, err := db.Find[issues_model.Milestone](db.DefaultContext, issues_model.FindMilestoneOptions{ ··· 84 84 85 85 milestones, err := db.Find[issues_model.Milestone](db.DefaultContext, issues_model.FindMilestoneOptions{ 86 86 RepoID: unittest.NonexistentID, 87 - IsClosed: util.OptionalBoolFalse, 87 + IsClosed: optional.Some(false), 88 88 }) 89 89 assert.NoError(t, err) 90 90 assert.Len(t, milestones, 0) ··· 101 101 PageSize: setting.UI.IssuePagingNum, 102 102 }, 103 103 RepoID: repo.ID, 104 - IsClosed: util.OptionalBoolFalse, 104 + IsClosed: optional.Some(false), 105 105 SortType: sortType, 106 106 }) 107 107 assert.NoError(t, err) ··· 118 118 PageSize: setting.UI.IssuePagingNum, 119 119 }, 120 120 RepoID: repo.ID, 121 - IsClosed: util.OptionalBoolTrue, 121 + IsClosed: optional.Some(true), 122 122 Name: "", 123 123 SortType: sortType, 124 124 }) ··· 178 178 repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: repoID}) 179 179 count, err := db.Count[issues_model.Milestone](db.DefaultContext, issues_model.FindMilestoneOptions{ 180 180 RepoID: repoID, 181 - IsClosed: util.OptionalBoolTrue, 181 + IsClosed: optional.Some(true), 182 182 }) 183 183 assert.NoError(t, err) 184 184 assert.EqualValues(t, repo.NumClosedMilestones, count) ··· 189 189 190 190 count, err := db.Count[issues_model.Milestone](db.DefaultContext, issues_model.FindMilestoneOptions{ 191 191 RepoID: unittest.NonexistentID, 192 - IsClosed: util.OptionalBoolTrue, 192 + IsClosed: optional.Some(true), 193 193 }) 194 194 assert.NoError(t, err) 195 195 assert.EqualValues(t, 0, count) ··· 206 206 207 207 openCounts, err := issues_model.CountMilestonesMap(db.DefaultContext, issues_model.FindMilestoneOptions{ 208 208 RepoIDs: []int64{1, 2}, 209 - IsClosed: util.OptionalBoolFalse, 209 + IsClosed: optional.Some(false), 210 210 }) 211 211 assert.NoError(t, err) 212 212 assert.EqualValues(t, repo1OpenCount, openCounts[1]) ··· 215 215 closedCounts, err := issues_model.CountMilestonesMap(db.DefaultContext, 216 216 issues_model.FindMilestoneOptions{ 217 217 RepoIDs: []int64{1, 2}, 218 - IsClosed: util.OptionalBoolTrue, 218 + IsClosed: optional.Some(true), 219 219 }) 220 220 assert.NoError(t, err) 221 221 assert.EqualValues(t, repo1ClosedCount, closedCounts[1]) ··· 234 234 PageSize: setting.UI.IssuePagingNum, 235 235 }, 236 236 RepoIDs: []int64{repo1.ID, repo2.ID}, 237 - IsClosed: util.OptionalBoolFalse, 237 + IsClosed: optional.Some(false), 238 238 SortType: sortType, 239 239 }) 240 240 assert.NoError(t, err) ··· 252 252 PageSize: setting.UI.IssuePagingNum, 253 253 }, 254 254 RepoIDs: []int64{repo1.ID, repo2.ID}, 255 - IsClosed: util.OptionalBoolTrue, 255 + IsClosed: optional.Some(true), 256 256 SortType: sortType, 257 257 }) 258 258 assert.NoError(t, err)

+4 -4

models/issues/review_list.go

··· 9 9 "code.gitea.io/gitea/models/db" 10 10 user_model "code.gitea.io/gitea/models/user" 11 11 "code.gitea.io/gitea/modules/container" 12 - "code.gitea.io/gitea/modules/util" 12 + "code.gitea.io/gitea/modules/optional" 13 13 14 14 "xorm.io/builder" 15 15 ) ··· 68 68 IssueID int64 69 69 ReviewerID int64 70 70 OfficialOnly bool 71 - Dismissed util.OptionalBool 71 + Dismissed optional.Option[bool] 72 72 } 73 73 74 74 func (opts *FindReviewOptions) toCond() builder.Cond { ··· 85 85 if opts.OfficialOnly { 86 86 cond = cond.And(builder.Eq{"official": true}) 87 87 } 88 - if !opts.Dismissed.IsNone() { 89 - cond = cond.And(builder.Eq{"dismissed": opts.Dismissed.IsTrue()}) 88 + if opts.Dismissed.Has() { 89 + cond = cond.And(builder.Eq{"dismissed": opts.Dismissed.Value()}) 90 90 } 91 91 return cond 92 92 }

+5 -4

models/issues/tracked_time.go

··· 11 11 12 12 "code.gitea.io/gitea/models/db" 13 13 user_model "code.gitea.io/gitea/models/user" 14 + "code.gitea.io/gitea/modules/optional" 14 15 "code.gitea.io/gitea/modules/setting" 15 16 "code.gitea.io/gitea/modules/util" 16 17 ··· 340 341 } 341 342 342 343 // GetIssueTotalTrackedTime returns the total tracked time for issues by given conditions. 343 - func GetIssueTotalTrackedTime(ctx context.Context, opts *IssuesOptions, isClosed util.OptionalBool) (int64, error) { 344 + func GetIssueTotalTrackedTime(ctx context.Context, opts *IssuesOptions, isClosed optional.Option[bool]) (int64, error) { 344 345 if len(opts.IssueIDs) <= MaxQueryParameters { 345 346 return getIssueTotalTrackedTimeChunk(ctx, opts, isClosed, opts.IssueIDs) 346 347 } ··· 363 364 return accum, nil 364 365 } 365 366 366 - func getIssueTotalTrackedTimeChunk(ctx context.Context, opts *IssuesOptions, isClosed util.OptionalBool, issueIDs []int64) (int64, error) { 367 + func getIssueTotalTrackedTimeChunk(ctx context.Context, opts *IssuesOptions, isClosed optional.Option[bool], issueIDs []int64) (int64, error) { 367 368 sumSession := func(opts *IssuesOptions, issueIDs []int64) *xorm.Session { 368 369 sess := db.GetEngine(ctx). 369 370 Table("tracked_time"). ··· 378 379 } 379 380 380 381 session := sumSession(opts, issueIDs) 381 - if !isClosed.IsNone() { 382 - session = session.And("issue.is_closed = ?", isClosed.IsTrue()) 382 + if isClosed.Has() { 383 + session = session.And("issue.is_closed = ?", isClosed.Value()) 383 384 } 384 385 return session.SumInt(new(trackedTime), "tracked_time.time") 385 386 }

+4 -4

models/issues/tracked_time_test.go

··· 11 11 issues_model "code.gitea.io/gitea/models/issues" 12 12 "code.gitea.io/gitea/models/unittest" 13 13 user_model "code.gitea.io/gitea/models/user" 14 - "code.gitea.io/gitea/modules/util" 14 + "code.gitea.io/gitea/modules/optional" 15 15 16 16 "github.com/stretchr/testify/assert" 17 17 ) ··· 120 120 func TestGetIssueTotalTrackedTime(t *testing.T) { 121 121 assert.NoError(t, unittest.PrepareTestDatabase()) 122 122 123 - ttt, err := issues_model.GetIssueTotalTrackedTime(db.DefaultContext, &issues_model.IssuesOptions{MilestoneIDs: []int64{1}}, util.OptionalBoolFalse) 123 + ttt, err := issues_model.GetIssueTotalTrackedTime(db.DefaultContext, &issues_model.IssuesOptions{MilestoneIDs: []int64{1}}, optional.Some(false)) 124 124 assert.NoError(t, err) 125 125 assert.EqualValues(t, 3682, ttt) 126 126 127 - ttt, err = issues_model.GetIssueTotalTrackedTime(db.DefaultContext, &issues_model.IssuesOptions{MilestoneIDs: []int64{1}}, util.OptionalBoolTrue) 127 + ttt, err = issues_model.GetIssueTotalTrackedTime(db.DefaultContext, &issues_model.IssuesOptions{MilestoneIDs: []int64{1}}, optional.Some(true)) 128 128 assert.NoError(t, err) 129 129 assert.EqualValues(t, 0, ttt) 130 130 131 - ttt, err = issues_model.GetIssueTotalTrackedTime(db.DefaultContext, &issues_model.IssuesOptions{MilestoneIDs: []int64{1}}, util.OptionalBoolNone) 131 + ttt, err = issues_model.GetIssueTotalTrackedTime(db.DefaultContext, &issues_model.IssuesOptions{MilestoneIDs: []int64{1}}, optional.None[bool]()) 132 132 assert.NoError(t, err) 133 133 assert.EqualValues(t, 3682, ttt) 134 134 }

+1 -1

models/packages/nuget/search.go

··· 55 55 56 56 func toConds(opts *packages_model.PackageSearchOptions) builder.Cond { 57 57 var cond builder.Cond = builder.Eq{ 58 - "package.is_internal": opts.IsInternal.IsTrue(), 58 + "package.is_internal": opts.IsInternal.Value(), 59 59 "package.owner_id": opts.OwnerID, 60 60 "package.type": packages_model.TypeNuGet, 61 61 }

+13 -12

models/packages/package_version.go

··· 9 9 "strings" 10 10 11 11 "code.gitea.io/gitea/models/db" 12 + "code.gitea.io/gitea/modules/optional" 12 13 "code.gitea.io/gitea/modules/timeutil" 13 14 "code.gitea.io/gitea/modules/util" 14 15 ··· 105 106 ExactMatch: true, 106 107 Value: version, 107 108 }, 108 - IsInternal: util.OptionalBoolOf(isInternal), 109 + IsInternal: optional.Some(isInternal), 109 110 Paginator: db.NewAbsoluteListOptions(0, 1), 110 111 }) 111 112 if err != nil { ··· 122 123 pvs, _, err := SearchVersions(ctx, &PackageSearchOptions{ 123 124 OwnerID: ownerID, 124 125 Type: packageType, 125 - IsInternal: util.OptionalBoolFalse, 126 + IsInternal: optional.Some(false), 126 127 }) 127 128 return pvs, err 128 129 } ··· 136 137 ExactMatch: true, 137 138 Value: name, 138 139 }, 139 - IsInternal: util.OptionalBoolFalse, 140 + IsInternal: optional.Some(false), 140 141 }) 141 142 return pvs, err 142 143 } ··· 182 183 Name SearchValue // only results with the specific name are found 183 184 Version SearchValue // only results with the specific version are found 184 185 Properties map[string]string // only results are found which contain all listed version properties with the specific value 185 - IsInternal util.OptionalBool 186 - HasFileWithName string // only results are found which are associated with a file with the specific name 187 - HasFiles util.OptionalBool // only results are found which have associated files 186 + IsInternal optional.Option[bool] 187 + HasFileWithName string // only results are found which are associated with a file with the specific name 188 + HasFiles optional.Option[bool] // only results are found which have associated files 188 189 Sort VersionSort 189 190 db.Paginator 190 191 } 191 192 192 193 func (opts *PackageSearchOptions) ToConds() builder.Cond { 193 194 cond := builder.NewCond() 194 - if !opts.IsInternal.IsNone() { 195 + if opts.IsInternal.Has() { 195 196 cond = builder.Eq{ 196 - "package_version.is_internal": opts.IsInternal.IsTrue(), 197 + "package_version.is_internal": opts.IsInternal.Value(), 197 198 } 198 199 } 199 200 ··· 250 251 cond = cond.And(builder.Exists(builder.Select("package_file.id").From("package_file").Where(fileCond))) 251 252 } 252 253 253 - if !opts.HasFiles.IsNone() { 254 + if opts.HasFiles.Has() { 254 255 filesCond := builder.Exists(builder.Select("package_file.id").From("package_file").Where(builder.Expr("package_file.version_id = package_version.id"))) 255 256 256 - if opts.HasFiles.IsFalse() { 257 + if !opts.HasFiles.Value() { 257 258 filesCond = builder.Not{filesCond} 258 259 } 259 260 ··· 307 308 And(builder.Expr("pv2.id IS NULL")) 308 309 309 310 joinCond := builder.Expr("package_version.package_id = pv2.package_id AND (package_version.created_unix < pv2.created_unix OR (package_version.created_unix = pv2.created_unix AND package_version.id < pv2.id))") 310 - if !opts.IsInternal.IsNone() { 311 - joinCond = joinCond.And(builder.Eq{"pv2.is_internal": opts.IsInternal.IsTrue()}) 311 + if opts.IsInternal.Has() { 312 + joinCond = joinCond.And(builder.Eq{"pv2.is_internal": opts.IsInternal.Value()}) 312 313 } 313 314 314 315 sess := db.GetEngine(ctx).

+4 -6

models/project/project.go

··· 12 12 repo_model "code.gitea.io/gitea/models/repo" 13 13 user_model "code.gitea.io/gitea/models/user" 14 14 "code.gitea.io/gitea/modules/log" 15 + "code.gitea.io/gitea/modules/optional" 15 16 "code.gitea.io/gitea/modules/setting" 16 17 "code.gitea.io/gitea/modules/timeutil" 17 18 "code.gitea.io/gitea/modules/util" ··· 196 197 db.ListOptions 197 198 OwnerID int64 198 199 RepoID int64 199 - IsClosed util.OptionalBool 200 + IsClosed optional.Option[bool] 200 201 OrderBy db.SearchOrderBy 201 202 Type Type 202 203 Title string ··· 207 208 if opts.RepoID > 0 { 208 209 cond = cond.And(builder.Eq{"repo_id": opts.RepoID}) 209 210 } 210 - switch opts.IsClosed { 211 - case util.OptionalBoolTrue: 212 - cond = cond.And(builder.Eq{"is_closed": true}) 213 - case util.OptionalBoolFalse: 214 - cond = cond.And(builder.Eq{"is_closed": false}) 211 + if opts.IsClosed.Has() { 212 + cond = cond.And(builder.Eq{"is_closed": opts.IsClosed.Value()}) 215 213 } 216 214 217 215 if opts.Type > 0 {

+4 -3

models/repo/repo.go

··· 20 20 "code.gitea.io/gitea/modules/git" 21 21 "code.gitea.io/gitea/modules/log" 22 22 "code.gitea.io/gitea/modules/markup" 23 + "code.gitea.io/gitea/modules/optional" 23 24 "code.gitea.io/gitea/modules/setting" 24 25 api "code.gitea.io/gitea/modules/structs" 25 26 "code.gitea.io/gitea/modules/timeutil" ··· 873 874 874 875 type CountRepositoryOptions struct { 875 876 OwnerID int64 876 - Private util.OptionalBool 877 + Private optional.Option[bool] 877 878 } 878 879 879 880 // CountRepositories returns number of repositories. ··· 885 886 if opts.OwnerID > 0 { 886 887 sess.And("owner_id = ?", opts.OwnerID) 887 888 } 888 - if !opts.Private.IsNone() { 889 - sess.And("is_private=?", opts.Private.IsTrue()) 889 + if opts.Private.Has() { 890 + sess.And("is_private=?", opts.Private.Value()) 890 891 } 891 892 892 893 count, err := sess.Count(new(Repository))

+3 -3

models/repo/repo_test.go

··· 12 12 "code.gitea.io/gitea/models/unittest" 13 13 user_model "code.gitea.io/gitea/models/user" 14 14 "code.gitea.io/gitea/modules/markup" 15 + "code.gitea.io/gitea/modules/optional" 15 16 "code.gitea.io/gitea/modules/setting" 16 17 "code.gitea.io/gitea/modules/test" 17 - "code.gitea.io/gitea/modules/util" 18 18 19 19 "github.com/stretchr/testify/assert" 20 20 ) 21 21 22 22 var ( 23 23 countRepospts = repo_model.CountRepositoryOptions{OwnerID: 10} 24 - countReposptsPublic = repo_model.CountRepositoryOptions{OwnerID: 10, Private: util.OptionalBoolFalse} 25 - countReposptsPrivate = repo_model.CountRepositoryOptions{OwnerID: 10, Private: util.OptionalBoolTrue} 24 + countReposptsPublic = repo_model.CountRepositoryOptions{OwnerID: 10, Private: optional.Some(false)} 25 + countReposptsPrivate = repo_model.CountRepositoryOptions{OwnerID: 10, Private: optional.Some(true)} 26 26 ) 27 27 28 28 func TestGetRepositoryCount(t *testing.T) {

+4 -4

models/user/user.go

··· 727 727 728 728 // IsLastAdminUser check whether user is the last admin 729 729 func IsLastAdminUser(ctx context.Context, user *User) bool { 730 - if user.IsAdmin && CountUsers(ctx, &CountUserFilter{IsAdmin: util.OptionalBoolTrue}) <= 1 { 730 + if user.IsAdmin && CountUsers(ctx, &CountUserFilter{IsAdmin: optional.Some(true)}) <= 1 { 731 731 return true 732 732 } 733 733 return false ··· 736 736 // CountUserFilter represent optional filters for CountUsers 737 737 type CountUserFilter struct { 738 738 LastLoginSince *int64 739 - IsAdmin util.OptionalBool 739 + IsAdmin optional.Option[bool] 740 740 } 741 741 742 742 // CountUsers returns number of users. ··· 754 754 cond = cond.And(builder.Gte{"last_login_unix": *opts.LastLoginSince}) 755 755 } 756 756 757 - if !opts.IsAdmin.IsNone() { 758 - cond = cond.And(builder.Eq{"is_admin": opts.IsAdmin.IsTrue()}) 757 + if opts.IsAdmin.Has() { 758 + cond = cond.And(builder.Eq{"is_admin": opts.IsAdmin.Value()}) 759 759 } 760 760 } 761 761

+4 -3

models/webhook/webhook.go

··· 12 12 "code.gitea.io/gitea/models/db" 13 13 "code.gitea.io/gitea/modules/json" 14 14 "code.gitea.io/gitea/modules/log" 15 + "code.gitea.io/gitea/modules/optional" 15 16 "code.gitea.io/gitea/modules/secret" 16 17 "code.gitea.io/gitea/modules/setting" 17 18 "code.gitea.io/gitea/modules/timeutil" ··· 433 434 db.ListOptions 434 435 RepoID int64 435 436 OwnerID int64 436 - IsActive util.OptionalBool 437 + IsActive optional.Option[bool] 437 438 } 438 439 439 440 func (opts ListWebhookOptions) ToConds() builder.Cond { ··· 444 445 if opts.OwnerID != 0 { 445 446 cond = cond.And(builder.Eq{"webhook.owner_id": opts.OwnerID}) 446 447 } 447 - if !opts.IsActive.IsNone() { 448 - cond = cond.And(builder.Eq{"webhook.is_active": opts.IsActive.IsTrue()}) 448 + if opts.IsActive.Has() { 449 + cond = cond.And(builder.Eq{"webhook.is_active": opts.IsActive.Value()}) 449 450 } 450 451 return cond 451 452 }

+4 -4

models/webhook/webhook_system.go

··· 8 8 "fmt" 9 9 10 10 "code.gitea.io/gitea/models/db" 11 - "code.gitea.io/gitea/modules/util" 11 + "code.gitea.io/gitea/modules/optional" 12 12 ) 13 13 14 14 // GetDefaultWebhooks returns all admin-default webhooks. ··· 34 34 } 35 35 36 36 // GetSystemWebhooks returns all admin system webhooks. 37 - func GetSystemWebhooks(ctx context.Context, isActive util.OptionalBool) ([]*Webhook, error) { 37 + func GetSystemWebhooks(ctx context.Context, isActive optional.Option[bool]) ([]*Webhook, error) { 38 38 webhooks := make([]*Webhook, 0, 5) 39 - if isActive.IsNone() { 39 + if !isActive.Has() { 40 40 return webhooks, db.GetEngine(ctx). 41 41 Where("repo_id=? AND owner_id=? AND is_system_webhook=?", 0, 0, true). 42 42 Find(&webhooks) 43 43 } 44 44 return webhooks, db.GetEngine(ctx). 45 - Where("repo_id=? AND owner_id=? AND is_system_webhook=? AND is_active = ?", 0, 0, true, isActive.IsTrue()). 45 + Where("repo_id=? AND owner_id=? AND is_system_webhook=? AND is_active = ?", 0, 0, true, isActive.Value()). 46 46 Find(&webhooks) 47 47 } 48 48

+3 -3

models/webhook/webhook_test.go

··· 11 11 "code.gitea.io/gitea/models/db" 12 12 "code.gitea.io/gitea/models/unittest" 13 13 "code.gitea.io/gitea/modules/json" 14 + "code.gitea.io/gitea/modules/optional" 14 15 api "code.gitea.io/gitea/modules/structs" 15 16 "code.gitea.io/gitea/modules/timeutil" 16 - "code.gitea.io/gitea/modules/util" 17 17 webhook_module "code.gitea.io/gitea/modules/webhook" 18 18 19 19 "github.com/stretchr/testify/assert" ··· 123 123 124 124 func TestGetActiveWebhooksByRepoID(t *testing.T) { 125 125 assert.NoError(t, unittest.PrepareTestDatabase()) 126 - hooks, err := db.Find[Webhook](db.DefaultContext, ListWebhookOptions{RepoID: 1, IsActive: util.OptionalBoolTrue}) 126 + hooks, err := db.Find[Webhook](db.DefaultContext, ListWebhookOptions{RepoID: 1, IsActive: optional.Some(true)}) 127 127 assert.NoError(t, err) 128 128 if assert.Len(t, hooks, 1) { 129 129 assert.Equal(t, int64(1), hooks[0].ID) ··· 143 143 144 144 func TestGetActiveWebhooksByOwnerID(t *testing.T) { 145 145 assert.NoError(t, unittest.PrepareTestDatabase()) 146 - hooks, err := db.Find[Webhook](db.DefaultContext, ListWebhookOptions{OwnerID: 3, IsActive: util.OptionalBoolTrue}) 146 + hooks, err := db.Find[Webhook](db.DefaultContext, ListWebhookOptions{OwnerID: 3, IsActive: optional.Some(true)}) 147 147 assert.NoError(t, err) 148 148 if assert.Len(t, hooks, 1) { 149 149 assert.Equal(t, int64(3), hooks[0].ID)

+4 -4

modules/indexer/issues/bleve/bleve.go

··· 175 175 queries = append(queries, bleve.NewDisjunctionQuery(repoQueries...)) 176 176 } 177 177 178 - if !options.IsPull.IsNone() { 179 - queries = append(queries, inner_bleve.BoolFieldQuery(options.IsPull.IsTrue(), "is_pull")) 178 + if options.IsPull.Has() { 179 + queries = append(queries, inner_bleve.BoolFieldQuery(options.IsPull.Value(), "is_pull")) 180 180 } 181 - if !options.IsClosed.IsNone() { 182 - queries = append(queries, inner_bleve.BoolFieldQuery(options.IsClosed.IsTrue(), "is_closed")) 181 + if options.IsClosed.Has() { 182 + queries = append(queries, inner_bleve.BoolFieldQuery(options.IsClosed.Value(), "is_closed")) 183 183 } 184 184 185 185 if options.NoLabelOnly {

+2 -1

modules/indexer/issues/db/options.go

··· 11 11 issue_model "code.gitea.io/gitea/models/issues" 12 12 "code.gitea.io/gitea/modules/container" 13 13 "code.gitea.io/gitea/modules/indexer/issues/internal" 14 + "code.gitea.io/gitea/modules/optional" 14 15 ) 15 16 16 17 func ToDBOptions(ctx context.Context, options *internal.SearchOptions) (*issue_model.IssuesOptions, error) { ··· 75 76 UpdatedAfterUnix: convertInt64(options.UpdatedAfterUnix), 76 77 UpdatedBeforeUnix: convertInt64(options.UpdatedBeforeUnix), 77 78 PriorityRepoID: 0, 78 - IsArchived: 0, 79 + IsArchived: optional.None[bool](), 79 80 Org: nil, 80 81 Team: nil, 81 82 User: nil,

+4 -4

modules/indexer/issues/elasticsearch/elasticsearch.go

··· 153 153 query.Must(q) 154 154 } 155 155 156 - if !options.IsPull.IsNone() { 157 - query.Must(elastic.NewTermQuery("is_pull", options.IsPull.IsTrue())) 156 + if options.IsPull.Has() { 157 + query.Must(elastic.NewTermQuery("is_pull", options.IsPull.Value())) 158 158 } 159 - if !options.IsClosed.IsNone() { 160 - query.Must(elastic.NewTermQuery("is_closed", options.IsClosed.IsTrue())) 159 + if options.IsClosed.Has() { 160 + query.Must(elastic.NewTermQuery("is_closed", options.IsClosed.Value())) 161 161 } 162 162 163 163 if options.NoLabelOnly {

+5 -5

modules/indexer/issues/indexer_test.go

··· 10 10 "code.gitea.io/gitea/models/db" 11 11 "code.gitea.io/gitea/models/unittest" 12 12 "code.gitea.io/gitea/modules/indexer/issues/internal" 13 + "code.gitea.io/gitea/modules/optional" 13 14 "code.gitea.io/gitea/modules/setting" 14 - "code.gitea.io/gitea/modules/util" 15 15 16 16 _ "code.gitea.io/gitea/models" 17 17 _ "code.gitea.io/gitea/models/actions" ··· 210 210 }{ 211 211 { 212 212 SearchOptions{ 213 - IsPull: util.OptionalBoolFalse, 213 + IsPull: optional.Some(false), 214 214 }, 215 215 []int64{17, 16, 15, 14, 13, 6, 5, 18, 10, 7, 4, 1}, 216 216 }, 217 217 { 218 218 SearchOptions{ 219 - IsPull: util.OptionalBoolTrue, 219 + IsPull: optional.Some(true), 220 220 }, 221 221 []int64{22, 21, 12, 11, 20, 19, 9, 8, 3, 2}, 222 222 }, ··· 237 237 }{ 238 238 { 239 239 SearchOptions{ 240 - IsClosed: util.OptionalBoolFalse, 240 + IsClosed: optional.Some(false), 241 241 }, 242 242 []int64{22, 21, 17, 16, 15, 14, 13, 12, 11, 20, 6, 19, 18, 10, 7, 9, 8, 3, 2, 1}, 243 243 }, 244 244 { 245 245 SearchOptions{ 246 - IsClosed: util.OptionalBoolTrue, 246 + IsClosed: optional.Some(true), 247 247 }, 248 248 []int64{5, 4}, 249 249 },

+3 -3

modules/indexer/issues/internal/model.go

··· 5 5 6 6 import ( 7 7 "code.gitea.io/gitea/models/db" 8 + "code.gitea.io/gitea/modules/optional" 8 9 "code.gitea.io/gitea/modules/timeutil" 9 - "code.gitea.io/gitea/modules/util" 10 10 ) 11 11 12 12 // IndexerData data stored in the issue indexer ··· 77 77 RepoIDs []int64 // repository IDs which the issues belong to 78 78 AllPublic bool // if include all public repositories 79 79 80 - IsPull util.OptionalBool // if the issues is a pull request 81 - IsClosed util.OptionalBool // if the issues is closed 80 + IsPull optional.Option[bool] // if the issues is a pull request 81 + IsClosed optional.Option[bool] // if the issues is closed 82 82 83 83 IncludedLabelIDs []int64 // labels the issues have 84 84 ExcludedLabelIDs []int64 // labels the issues don't have

+5 -5

modules/indexer/issues/internal/tests/tests.go

··· 16 16 17 17 "code.gitea.io/gitea/models/db" 18 18 "code.gitea.io/gitea/modules/indexer/issues/internal" 19 + "code.gitea.io/gitea/modules/optional" 19 20 "code.gitea.io/gitea/modules/timeutil" 20 - "code.gitea.io/gitea/modules/util" 21 21 22 22 "github.com/stretchr/testify/assert" 23 23 "github.com/stretchr/testify/require" ··· 166 166 Paginator: &db.ListOptions{ 167 167 PageSize: 5, 168 168 }, 169 - IsPull: util.OptionalBoolFalse, 169 + IsPull: optional.Some(false), 170 170 }, 171 171 Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) { 172 172 assert.Equal(t, 5, len(result.Hits)) ··· 182 182 Paginator: &db.ListOptions{ 183 183 PageSize: 5, 184 184 }, 185 - IsPull: util.OptionalBoolTrue, 185 + IsPull: optional.Some(true), 186 186 }, 187 187 Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) { 188 188 assert.Equal(t, 5, len(result.Hits)) ··· 198 198 Paginator: &db.ListOptions{ 199 199 PageSize: 5, 200 200 }, 201 - IsClosed: util.OptionalBoolFalse, 201 + IsClosed: optional.Some(false), 202 202 }, 203 203 Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) { 204 204 assert.Equal(t, 5, len(result.Hits)) ··· 214 214 Paginator: &db.ListOptions{ 215 215 PageSize: 5, 216 216 }, 217 - IsClosed: util.OptionalBoolTrue, 217 + IsClosed: optional.Some(true), 218 218 }, 219 219 Expected: func(t *testing.T, data map[int64]*internal.IndexerData, result *internal.SearchResult) { 220 220 assert.Equal(t, 5, len(result.Hits))

+4 -4

modules/indexer/issues/meilisearch/meilisearch.go

··· 131 131 query.And(q) 132 132 } 133 133 134 - if !options.IsPull.IsNone() { 135 - query.And(inner_meilisearch.NewFilterEq("is_pull", options.IsPull.IsTrue())) 134 + if options.IsPull.Has() { 135 + query.And(inner_meilisearch.NewFilterEq("is_pull", options.IsPull.Value())) 136 136 } 137 - if !options.IsClosed.IsNone() { 138 - query.And(inner_meilisearch.NewFilterEq("is_closed", options.IsClosed.IsTrue())) 137 + if options.IsClosed.Has() { 138 + query.And(inner_meilisearch.NewFilterEq("is_closed", options.IsClosed.Value())) 139 139 } 140 140 141 141 if options.NoLabelOnly {

-51

modules/util/util.go

··· 17 17 "golang.org/x/text/language" 18 18 ) 19 19 20 - // OptionalBool a boolean that can be "null" 21 - type OptionalBool byte 22 - 23 - const ( 24 - // OptionalBoolNone a "null" boolean value 25 - OptionalBoolNone OptionalBool = iota 26 - // OptionalBoolTrue a "true" boolean value 27 - OptionalBoolTrue 28 - // OptionalBoolFalse a "false" boolean value 29 - OptionalBoolFalse 30 - ) 31 - 32 - // IsTrue return true if equal to OptionalBoolTrue 33 - func (o OptionalBool) IsTrue() bool { 34 - return o == OptionalBoolTrue 35 - } 36 - 37 - // IsFalse return true if equal to OptionalBoolFalse 38 - func (o OptionalBool) IsFalse() bool { 39 - return o == OptionalBoolFalse 40 - } 41 - 42 - // IsNone return true if equal to OptionalBoolNone 43 - func (o OptionalBool) IsNone() bool { 44 - return o == OptionalBoolNone 45 - } 46 - 47 - // ToGeneric converts OptionalBool to optional.Option[bool] 48 - func (o OptionalBool) ToGeneric() optional.Option[bool] { 49 - if o.IsNone() { 50 - return optional.None[bool]() 51 - } 52 - return optional.Some[bool](o.IsTrue()) 53 - } 54 - 55 - // OptionalBoolFromGeneric converts optional.Option[bool] to OptionalBool 56 - func OptionalBoolFromGeneric(o optional.Option[bool]) OptionalBool { 57 - if o.Has() { 58 - return OptionalBoolOf(o.Value()) 59 - } 60 - return OptionalBoolNone 61 - } 62 - 63 - // OptionalBoolOf get the corresponding OptionalBool of a bool 64 - func OptionalBoolOf(b bool) OptionalBool { 65 - if b { 66 - return OptionalBoolTrue 67 - } 68 - return OptionalBoolFalse 69 - } 70 - 71 20 // OptionalBoolParse get the corresponding optional.Option[bool] of a string using strconv.ParseBool 72 21 func OptionalBoolParse(s string) optional.Option[bool] { 73 22 v, e := strconv.ParseBool(s)

+2 -1

routers/api/packages/cargo/cargo.go

··· 13 13 "code.gitea.io/gitea/models/db" 14 14 packages_model "code.gitea.io/gitea/models/packages" 15 15 "code.gitea.io/gitea/modules/log" 16 + "code.gitea.io/gitea/modules/optional" 16 17 packages_module "code.gitea.io/gitea/modules/packages" 17 18 cargo_module "code.gitea.io/gitea/modules/packages/cargo" 18 19 "code.gitea.io/gitea/modules/setting" ··· 110 111 OwnerID: ctx.Package.Owner.ID, 111 112 Type: packages_model.TypeCargo, 112 113 Name: packages_model.SearchValue{Value: ctx.FormTrim("q")}, 113 - IsInternal: util.OptionalBoolFalse, 114 + IsInternal: optional.Some(false), 114 115 Paginator: &paginator, 115 116 }, 116 117 )

+3 -2

routers/api/packages/chef/chef.go

··· 15 15 16 16 "code.gitea.io/gitea/models/db" 17 17 packages_model "code.gitea.io/gitea/models/packages" 18 + "code.gitea.io/gitea/modules/optional" 18 19 packages_module "code.gitea.io/gitea/modules/packages" 19 20 chef_module "code.gitea.io/gitea/modules/packages/chef" 20 21 "code.gitea.io/gitea/modules/setting" ··· 40 41 pvs, _, err := packages_model.SearchVersions(ctx, &packages_model.PackageSearchOptions{ 41 42 OwnerID: ctx.Package.Owner.ID, 42 43 Type: packages_model.TypeChef, 43 - IsInternal: util.OptionalBoolFalse, 44 + IsInternal: optional.Some(false), 44 45 }) 45 46 if err != nil { 46 47 apiError(ctx, http.StatusInternalServerError, err) ··· 85 86 OwnerID: ctx.Package.Owner.ID, 86 87 Type: packages_model.TypeChef, 87 88 Name: packages_model.SearchValue{Value: ctx.FormTrim("q")}, 88 - IsInternal: util.OptionalBoolFalse, 89 + IsInternal: optional.Some(false), 89 90 Paginator: db.NewAbsoluteListOptions( 90 91 ctx.FormInt("start"), 91 92 ctx.FormInt("items"),

+2 -1

routers/api/packages/composer/composer.go

··· 14 14 15 15 "code.gitea.io/gitea/models/db" 16 16 packages_model "code.gitea.io/gitea/models/packages" 17 + "code.gitea.io/gitea/modules/optional" 17 18 packages_module "code.gitea.io/gitea/modules/packages" 18 19 composer_module "code.gitea.io/gitea/modules/packages/composer" 19 20 "code.gitea.io/gitea/modules/setting" ··· 66 67 OwnerID: ctx.Package.Owner.ID, 67 68 Type: packages_model.TypeComposer, 68 69 Name: packages_model.SearchValue{Value: ctx.FormTrim("q")}, 69 - IsInternal: util.OptionalBoolFalse, 70 + IsInternal: optional.Some(false), 70 71 Paginator: &paginator, 71 72 } 72 73 if ctx.FormTrim("type") != "" {

+2 -1

routers/api/packages/goproxy/goproxy.go

··· 12 12 "time" 13 13 14 14 packages_model "code.gitea.io/gitea/models/packages" 15 + "code.gitea.io/gitea/modules/optional" 15 16 packages_module "code.gitea.io/gitea/modules/packages" 16 17 goproxy_module "code.gitea.io/gitea/modules/packages/goproxy" 17 18 "code.gitea.io/gitea/modules/util" ··· 129 130 Value: name, 130 131 ExactMatch: true, 131 132 }, 132 - IsInternal: util.OptionalBoolFalse, 133 + IsInternal: optional.Some(false), 133 134 Sort: packages_model.SortCreatedDesc, 134 135 }) 135 136 if err != nil {

+3 -2

routers/api/packages/helm/helm.go

··· 15 15 packages_model "code.gitea.io/gitea/models/packages" 16 16 "code.gitea.io/gitea/modules/json" 17 17 "code.gitea.io/gitea/modules/log" 18 + "code.gitea.io/gitea/modules/optional" 18 19 packages_module "code.gitea.io/gitea/modules/packages" 19 20 helm_module "code.gitea.io/gitea/modules/packages/helm" 20 21 "code.gitea.io/gitea/modules/setting" ··· 42 43 pvs, _, err := packages_model.SearchVersions(ctx, &packages_model.PackageSearchOptions{ 43 44 OwnerID: ctx.Package.Owner.ID, 44 45 Type: packages_model.TypeHelm, 45 - IsInternal: util.OptionalBoolFalse, 46 + IsInternal: optional.Some(false), 46 47 }) 47 48 if err != nil { 48 49 apiError(ctx, http.StatusInternalServerError, err) ··· 110 111 Value: ctx.Params("package"), 111 112 }, 112 113 HasFileWithName: filename, 113 - IsInternal: util.OptionalBoolFalse, 114 + IsInternal: optional.Some(false), 114 115 }) 115 116 if err != nil { 116 117 apiError(ctx, http.StatusInternalServerError, err)

+4 -3

routers/api/packages/npm/npm.go

··· 17 17 access_model "code.gitea.io/gitea/models/perm/access" 18 18 repo_model "code.gitea.io/gitea/models/repo" 19 19 "code.gitea.io/gitea/models/unit" 20 + "code.gitea.io/gitea/modules/optional" 20 21 packages_module "code.gitea.io/gitea/modules/packages" 21 22 npm_module "code.gitea.io/gitea/modules/packages/npm" 22 23 "code.gitea.io/gitea/modules/setting" ··· 120 121 Value: packageNameFromParams(ctx), 121 122 }, 122 123 HasFileWithName: filename, 123 - IsInternal: util.OptionalBoolFalse, 124 + IsInternal: optional.Some(false), 124 125 }) 125 126 if err != nil { 126 127 apiError(ctx, http.StatusInternalServerError, err) ··· 395 396 Properties: map[string]string{ 396 397 npm_module.TagProperty: tag, 397 398 }, 398 - IsInternal: util.OptionalBoolFalse, 399 + IsInternal: optional.Some(false), 399 400 }) 400 401 if err != nil { 401 402 return err ··· 431 432 pvs, total, err := packages_model.SearchLatestVersions(ctx, &packages_model.PackageSearchOptions{ 432 433 OwnerID: ctx.Package.Owner.ID, 433 434 Type: packages_model.TypeNpm, 434 - IsInternal: util.OptionalBoolFalse, 435 + IsInternal: optional.Some(false), 435 436 Name: packages_model.SearchValue{ 436 437 ExactMatch: false, 437 438 Value: ctx.FormTrim("text"),

+6 -5

routers/api/packages/nuget/nuget.go

··· 18 18 packages_model "code.gitea.io/gitea/models/packages" 19 19 nuget_model "code.gitea.io/gitea/models/packages/nuget" 20 20 "code.gitea.io/gitea/modules/log" 21 + "code.gitea.io/gitea/modules/optional" 21 22 packages_module "code.gitea.io/gitea/modules/packages" 22 23 nuget_module "code.gitea.io/gitea/modules/packages/nuget" 23 24 "code.gitea.io/gitea/modules/setting" ··· 122 123 Name: packages_model.SearchValue{ 123 124 Value: getSearchTerm(ctx), 124 125 }, 125 - IsInternal: util.OptionalBoolFalse, 126 + IsInternal: optional.Some(false), 126 127 Paginator: paginator, 127 128 }) 128 129 if err != nil { ··· 172 173 Name: packages_model.SearchValue{ 173 174 Value: getSearchTerm(ctx), 174 175 }, 175 - IsInternal: util.OptionalBoolFalse, 176 + IsInternal: optional.Some(false), 176 177 }) 177 178 if err != nil { 178 179 apiError(ctx, http.StatusInternalServerError, err) ··· 187 188 pvs, count, err := nuget_model.SearchVersions(ctx, &packages_model.PackageSearchOptions{ 188 189 OwnerID: ctx.Package.Owner.ID, 189 190 Name: packages_model.SearchValue{Value: ctx.FormTrim("q")}, 190 - IsInternal: util.OptionalBoolFalse, 191 + IsInternal: optional.Some(false), 191 192 Paginator: db.NewAbsoluteListOptions( 192 193 ctx.FormInt("skip"), 193 194 ctx.FormInt("take"), ··· 313 314 ExactMatch: true, 314 315 Value: packageName, 315 316 }, 316 - IsInternal: util.OptionalBoolFalse, 317 + IsInternal: optional.Some(false), 317 318 Paginator: paginator, 318 319 }) 319 320 if err != nil { ··· 358 359 ExactMatch: true, 359 360 Value: strings.Trim(ctx.FormTrim("id"), "'"), 360 361 }, 361 - IsInternal: util.OptionalBoolFalse, 362 + IsInternal: optional.Some(false), 362 363 }) 363 364 if err != nil { 364 365 apiError(ctx, http.StatusInternalServerError, err)

+3 -2

routers/api/packages/rubygems/rubygems.go

··· 13 13 "strings" 14 14 15 15 packages_model "code.gitea.io/gitea/models/packages" 16 + "code.gitea.io/gitea/modules/optional" 16 17 packages_module "code.gitea.io/gitea/modules/packages" 17 18 rubygems_module "code.gitea.io/gitea/modules/packages/rubygems" 18 19 "code.gitea.io/gitea/modules/util" ··· 43 44 pvs, _, err := packages_model.SearchLatestVersions(ctx, &packages_model.PackageSearchOptions{ 44 45 OwnerID: ctx.Package.Owner.ID, 45 46 Type: packages_model.TypeRubyGems, 46 - IsInternal: util.OptionalBoolFalse, 47 + IsInternal: optional.Some(false), 47 48 }) 48 49 if err != nil { 49 50 apiError(ctx, http.StatusInternalServerError, err) ··· 304 305 OwnerID: ctx.Package.Owner.ID, 305 306 Type: packages_model.TypeRubyGems, 306 307 HasFileWithName: filename, 307 - IsInternal: util.OptionalBoolFalse, 308 + IsInternal: optional.Some(false), 308 309 }) 309 310 return pvs, err 310 311 }

+2 -1

routers/api/packages/swift/swift.go

··· 15 15 packages_model "code.gitea.io/gitea/models/packages" 16 16 "code.gitea.io/gitea/modules/json" 17 17 "code.gitea.io/gitea/modules/log" 18 + "code.gitea.io/gitea/modules/optional" 18 19 packages_module "code.gitea.io/gitea/modules/packages" 19 20 swift_module "code.gitea.io/gitea/modules/packages/swift" 20 21 "code.gitea.io/gitea/modules/setting" ··· 433 434 Properties: map[string]string{ 434 435 swift_module.PropertyRepositoryURL: url, 435 436 }, 436 - IsInternal: util.OptionalBoolFalse, 437 + IsInternal: optional.Some(false), 437 438 }) 438 439 if err != nil { 439 440 apiError(ctx, http.StatusInternalServerError, err)

+2 -1

routers/api/v1/admin/hooks.go

··· 8 8 "net/http" 9 9 10 10 "code.gitea.io/gitea/models/webhook" 11 + "code.gitea.io/gitea/modules/optional" 11 12 "code.gitea.io/gitea/modules/setting" 12 13 api "code.gitea.io/gitea/modules/structs" 13 14 "code.gitea.io/gitea/modules/util" ··· 37 38 // "200": 38 39 // "$ref": "#/responses/HookList" 39 40 40 - sysHooks, err := webhook.GetSystemWebhooks(ctx, util.OptionalBoolNone) 41 + sysHooks, err := webhook.GetSystemWebhooks(ctx, optional.None[bool]()) 41 42 if err != nil { 42 43 ctx.Error(http.StatusInternalServerError, "GetSystemWebhooks", err) 43 44 return

+2 -2

routers/api/v1/packages/package.go

··· 7 7 "net/http" 8 8 9 9 "code.gitea.io/gitea/models/packages" 10 + "code.gitea.io/gitea/modules/optional" 10 11 api "code.gitea.io/gitea/modules/structs" 11 - "code.gitea.io/gitea/modules/util" 12 12 "code.gitea.io/gitea/routers/api/v1/utils" 13 13 "code.gitea.io/gitea/services/context" 14 14 "code.gitea.io/gitea/services/convert" ··· 60 60 OwnerID: ctx.Package.Owner.ID, 61 61 Type: packages.Type(packageType), 62 62 Name: packages.SearchValue{Value: query}, 63 - IsInternal: util.OptionalBoolFalse, 63 + IsInternal: optional.Some(false), 64 64 Paginator: &listOptions, 65 65 }) 66 66 if err != nil {

+19 -22

routers/api/v1/repo/issue.go

··· 24 24 "code.gitea.io/gitea/modules/setting" 25 25 api "code.gitea.io/gitea/modules/structs" 26 26 "code.gitea.io/gitea/modules/timeutil" 27 - "code.gitea.io/gitea/modules/util" 28 27 "code.gitea.io/gitea/modules/web" 29 28 "code.gitea.io/gitea/routers/api/v1/utils" 30 29 "code.gitea.io/gitea/services/context" ··· 124 123 return 125 124 } 126 125 127 - var isClosed util.OptionalBool 126 + var isClosed optional.Option[bool] 128 127 switch ctx.FormString("state") { 129 128 case "closed": 130 - isClosed = util.OptionalBoolTrue 129 + isClosed = optional.Some(true) 131 130 case "all": 132 - isClosed = util.OptionalBoolNone 131 + isClosed = optional.None[bool]() 133 132 default: 134 - isClosed = util.OptionalBoolFalse 133 + isClosed = optional.Some(false) 135 134 } 136 135 137 136 var ( ··· 206 205 keyword = "" 207 206 } 208 207 209 - var isPull util.OptionalBool 208 + var isPull optional.Option[bool] 210 209 switch ctx.FormString("type") { 211 210 case "pulls": 212 - isPull = util.OptionalBoolTrue 211 + isPull = optional.Some(true) 213 212 case "issues": 214 - isPull = util.OptionalBoolFalse 213 + isPull = optional.Some(false) 215 214 default: 216 - isPull = util.OptionalBoolNone 215 + isPull = optional.None[bool]() 217 216 } 218 217 219 218 var includedAnyLabels []int64 ··· 398 397 return 399 398 } 400 399 401 - var isClosed util.OptionalBool 400 + var isClosed optional.Option[bool] 402 401 switch ctx.FormString("state") { 403 402 case "closed": 404 - isClosed = util.OptionalBoolTrue 403 + isClosed = optional.Some(true) 405 404 case "all": 406 - isClosed = util.OptionalBoolNone 405 + isClosed = optional.None[bool]() 407 406 default: 408 - isClosed = util.OptionalBoolFalse 407 + isClosed = optional.Some(false) 409 408 } 410 409 411 410 keyword := ctx.FormTrim("q") ··· 454 453 455 454 listOptions := utils.GetListOptions(ctx) 456 455 457 - var isPull util.OptionalBool 456 + isPull := optional.None[bool]() 458 457 switch ctx.FormString("type") { 459 458 case "pulls": 460 - isPull = util.OptionalBoolTrue 459 + isPull = optional.Some(true) 461 460 case "issues": 462 - isPull = util.OptionalBoolFalse 463 - default: 464 - isPull = util.OptionalBoolNone 461 + isPull = optional.Some(false) 465 462 } 466 463 467 - if isPull != util.OptionalBoolNone && !ctx.Repo.CanReadIssuesOrPulls(isPull.IsTrue()) { 464 + if isPull.Has() && !ctx.Repo.CanReadIssuesOrPulls(isPull.Value()) { 468 465 ctx.NotFound() 469 466 return 470 467 } 471 468 472 - if isPull == util.OptionalBoolNone { 469 + if !isPull.Has() { 473 470 canReadIssues := ctx.Repo.CanRead(unit.TypeIssues) 474 471 canReadPulls := ctx.Repo.CanRead(unit.TypePullRequests) 475 472 if !canReadIssues && !canReadPulls { 476 473 ctx.NotFound() 477 474 return 478 475 } else if !canReadIssues { 479 - isPull = util.OptionalBoolTrue 476 + isPull = optional.Some(true) 480 477 } else if !canReadPulls { 481 - isPull = util.OptionalBoolFalse 478 + isPull = optional.Some(false) 482 479 } 483 480 } 484 481

+5 -5

routers/api/v1/repo/issue_comment.go

··· 14 14 repo_model "code.gitea.io/gitea/models/repo" 15 15 "code.gitea.io/gitea/models/unit" 16 16 user_model "code.gitea.io/gitea/models/user" 17 + "code.gitea.io/gitea/modules/optional" 17 18 api "code.gitea.io/gitea/modules/structs" 18 - "code.gitea.io/gitea/modules/util" 19 19 "code.gitea.io/gitea/modules/web" 20 20 "code.gitea.io/gitea/routers/api/v1/utils" 21 21 "code.gitea.io/gitea/services/context" ··· 278 278 return 279 279 } 280 280 281 - var isPull util.OptionalBool 281 + var isPull optional.Option[bool] 282 282 canReadIssue := ctx.Repo.CanRead(unit.TypeIssues) 283 283 canReadPull := ctx.Repo.CanRead(unit.TypePullRequests) 284 284 if canReadIssue && canReadPull { 285 - isPull = util.OptionalBoolNone 285 + isPull = optional.None[bool]() 286 286 } else if canReadIssue { 287 - isPull = util.OptionalBoolFalse 287 + isPull = optional.Some(false) 288 288 } else if canReadPull { 289 - isPull = util.OptionalBoolTrue 289 + isPull = optional.Some(true) 290 290 } else { 291 291 ctx.NotFound() 292 292 return

+3 -3

routers/api/v1/repo/milestone.go

··· 11 11 12 12 "code.gitea.io/gitea/models/db" 13 13 issues_model "code.gitea.io/gitea/models/issues" 14 + "code.gitea.io/gitea/modules/optional" 14 15 api "code.gitea.io/gitea/modules/structs" 15 16 "code.gitea.io/gitea/modules/timeutil" 16 - "code.gitea.io/gitea/modules/util" 17 17 "code.gitea.io/gitea/modules/web" 18 18 "code.gitea.io/gitea/routers/api/v1/utils" 19 19 "code.gitea.io/gitea/services/context" ··· 61 61 // "$ref": "#/responses/notFound" 62 62 63 63 state := api.StateType(ctx.FormString("state")) 64 - var isClosed util.OptionalBool 64 + var isClosed optional.Option[bool] 65 65 switch state { 66 66 case api.StateClosed, api.StateOpen: 67 - isClosed = util.OptionalBoolOf(state == api.StateClosed) 67 + isClosed = optional.Some(state == api.StateClosed) 68 68 } 69 69 70 70 milestones, total, err := db.FindAndCount[issues_model.Milestone](ctx, issues_model.FindMilestoneOptions{

+2 -2

routers/web/admin/hooks.go

··· 8 8 9 9 "code.gitea.io/gitea/models/webhook" 10 10 "code.gitea.io/gitea/modules/base" 11 + "code.gitea.io/gitea/modules/optional" 11 12 "code.gitea.io/gitea/modules/setting" 12 - "code.gitea.io/gitea/modules/util" 13 13 "code.gitea.io/gitea/services/context" 14 14 ) 15 15 ··· 35 35 36 36 sys["Title"] = ctx.Tr("admin.systemhooks") 37 37 sys["Description"] = ctx.Tr("admin.systemhooks.desc") 38 - sys["Webhooks"], err = webhook.GetSystemWebhooks(ctx, util.OptionalBoolNone) 38 + sys["Webhooks"], err = webhook.GetSystemWebhooks(ctx, optional.None[bool]()) 39 39 sys["BaseLink"] = setting.AppSubURL + "/admin/hooks" 40 40 sys["BaseLinkNew"] = setting.AppSubURL + "/admin/system-hooks" 41 41 if err != nil {

+2 -2

routers/web/admin/packages.go

··· 11 11 "code.gitea.io/gitea/models/db" 12 12 packages_model "code.gitea.io/gitea/models/packages" 13 13 "code.gitea.io/gitea/modules/base" 14 + "code.gitea.io/gitea/modules/optional" 14 15 "code.gitea.io/gitea/modules/setting" 15 - "code.gitea.io/gitea/modules/util" 16 16 "code.gitea.io/gitea/services/context" 17 17 packages_service "code.gitea.io/gitea/services/packages" 18 18 packages_cleanup_service "code.gitea.io/gitea/services/packages/cleanup" ··· 36 36 Type: packages_model.Type(packageType), 37 37 Name: packages_model.SearchValue{Value: query}, 38 38 Sort: sort, 39 - IsInternal: util.OptionalBoolFalse, 39 + IsInternal: optional.Some(false), 40 40 Paginator: &db.ListOptions{ 41 41 PageSize: setting.UI.PackagesPagingNum, 42 42 Page: page,

+2 -2

routers/web/admin/users.go

··· 96 96 ctx.Data["login_type"] = "0-0" 97 97 98 98 sources, err := db.Find[auth.Source](ctx, auth.FindSourcesOptions{ 99 - IsActive: util.OptionalBoolTrue, 99 + IsActive: optional.Some(true), 100 100 }) 101 101 if err != nil { 102 102 ctx.ServerError("auth.Sources", err) ··· 117 117 ctx.Data["AllowedUserVisibilityModes"] = setting.Service.AllowedUserVisibilityModesSlice.ToVisibleTypeSlice() 118 118 119 119 sources, err := db.Find[auth.Source](ctx, auth.FindSourcesOptions{ 120 - IsActive: util.OptionalBoolTrue, 120 + IsActive: optional.Some(true), 121 121 }) 122 122 if err != nil { 123 123 ctx.ServerError("auth.Sources", err)

+4 -4

routers/web/auth/auth.go

··· 171 171 return 172 172 } 173 173 174 - oauth2Providers, err := oauth2.GetOAuth2Providers(ctx, util.OptionalBoolTrue) 174 + oauth2Providers, err := oauth2.GetOAuth2Providers(ctx, optional.Some(true)) 175 175 if err != nil { 176 176 ctx.ServerError("UserSignIn", err) 177 177 return ··· 194 194 func SignInPost(ctx *context.Context) { 195 195 ctx.Data["Title"] = ctx.Tr("sign_in") 196 196 197 - oauth2Providers, err := oauth2.GetOAuth2Providers(ctx, util.OptionalBoolTrue) 197 + oauth2Providers, err := oauth2.GetOAuth2Providers(ctx, optional.Some(true)) 198 198 if err != nil { 199 199 ctx.ServerError("UserSignIn", err) 200 200 return ··· 414 414 415 415 ctx.Data["SignUpLink"] = setting.AppSubURL + "/user/sign_up" 416 416 417 - oauth2Providers, err := oauth2.GetOAuth2Providers(ctx, util.OptionalBoolTrue) 417 + oauth2Providers, err := oauth2.GetOAuth2Providers(ctx, optional.Some(true)) 418 418 if err != nil { 419 419 ctx.ServerError("UserSignUp", err) 420 420 return ··· 443 443 444 444 ctx.Data["SignUpLink"] = setting.AppSubURL + "/user/sign_up" 445 445 446 - oauth2Providers, err := oauth2.GetOAuth2Providers(ctx, util.OptionalBoolTrue) 446 + oauth2Providers, err := oauth2.GetOAuth2Providers(ctx, optional.Some(true)) 447 447 if err != nil { 448 448 ctx.ServerError("UserSignUp", err) 449 449 return

+4 -4

routers/web/org/projects.go

··· 18 18 "code.gitea.io/gitea/models/unit" 19 19 "code.gitea.io/gitea/modules/base" 20 20 "code.gitea.io/gitea/modules/json" 21 + "code.gitea.io/gitea/modules/optional" 21 22 "code.gitea.io/gitea/modules/setting" 22 23 "code.gitea.io/gitea/modules/templates" 23 - "code.gitea.io/gitea/modules/util" 24 24 "code.gitea.io/gitea/modules/web" 25 25 shared_user "code.gitea.io/gitea/routers/web/shared/user" 26 26 "code.gitea.io/gitea/services/context" ··· 67 67 PageSize: setting.UI.IssuePagingNum, 68 68 }, 69 69 OwnerID: ctx.ContextUser.ID, 70 - IsClosed: util.OptionalBoolOf(isShowClosed), 70 + IsClosed: optional.Some(isShowClosed), 71 71 OrderBy: project_model.GetSearchOrderByBySortType(sortType), 72 72 Type: projectType, 73 73 Title: keyword, ··· 79 79 80 80 opTotal, err := db.Count[project_model.Project](ctx, project_model.SearchOptions{ 81 81 OwnerID: ctx.ContextUser.ID, 82 - IsClosed: util.OptionalBoolOf(!isShowClosed), 82 + IsClosed: optional.Some(!isShowClosed), 83 83 Type: projectType, 84 84 }) 85 85 if err != nil { ··· 388 388 if len(referencedIDs) > 0 { 389 389 if linkedPrs, err := issues_model.Issues(ctx, &issues_model.IssuesOptions{ 390 390 IssueIDs: referencedIDs, 391 - IsPull: util.OptionalBoolTrue, 391 + IsPull: optional.Some(true), 392 392 }); err == nil { 393 393 linkedPrsMap[issue.ID] = linkedPrs 394 394 }

+2 -2

routers/web/repo/actions/actions.go

··· 16 16 "code.gitea.io/gitea/modules/base" 17 17 "code.gitea.io/gitea/modules/container" 18 18 "code.gitea.io/gitea/modules/git" 19 + "code.gitea.io/gitea/modules/optional" 19 20 "code.gitea.io/gitea/modules/setting" 20 - "code.gitea.io/gitea/modules/util" 21 21 "code.gitea.io/gitea/routers/web/repo" 22 22 "code.gitea.io/gitea/services/context" 23 23 "code.gitea.io/gitea/services/convert" ··· 78 78 // Get all runner labels 79 79 runners, err := db.Find[actions_model.ActionRunner](ctx, actions_model.FindRunnerOptions{ 80 80 RepoID: ctx.Repo.Repository.ID, 81 - IsOnline: util.OptionalBoolTrue, 81 + IsOnline: optional.Some(true), 82 82 WithAvailable: true, 83 83 }) 84 84 if err != nil {

+2 -1

routers/web/repo/branch.go

··· 18 18 "code.gitea.io/gitea/modules/base" 19 19 "code.gitea.io/gitea/modules/git" 20 20 "code.gitea.io/gitea/modules/log" 21 + "code.gitea.io/gitea/modules/optional" 21 22 repo_module "code.gitea.io/gitea/modules/repository" 22 23 "code.gitea.io/gitea/modules/setting" 23 24 "code.gitea.io/gitea/modules/util" ··· 53 54 54 55 kw := ctx.FormString("q") 55 56 56 - defaultBranch, branches, branchesCount, err := repo_service.LoadBranches(ctx, ctx.Repo.Repository, ctx.Repo.GitRepo, util.OptionalBoolNone, kw, page, pageSize) 57 + defaultBranch, branches, branchesCount, err := repo_service.LoadBranches(ctx, ctx.Repo.Repository, ctx.Repo.GitRepo, optional.None[bool](), kw, page, pageSize) 57 58 if err != nil { 58 59 ctx.ServerError("LoadBranches", err) 59 60 return

+34 -38

routers/web/repo/issue.go

··· 146 146 } 147 147 } 148 148 149 - func issues(ctx *context.Context, milestoneID, projectID int64, isPullOption util.OptionalBool) { 149 + func issues(ctx *context.Context, milestoneID, projectID int64, isPullOption optional.Option[bool]) { 150 150 var err error 151 151 viewType := ctx.FormString("type") 152 152 sortType := ctx.FormString("sort") ··· 247 247 } 248 248 } 249 249 250 - var isShowClosed util.OptionalBool 250 + var isShowClosed optional.Option[bool] 251 251 switch ctx.FormString("state") { 252 252 case "closed": 253 - isShowClosed = util.OptionalBoolTrue 253 + isShowClosed = optional.Some(true) 254 254 case "all": 255 - isShowClosed = util.OptionalBoolNone 255 + isShowClosed = optional.None[bool]() 256 256 default: 257 - isShowClosed = util.OptionalBoolFalse 257 + isShowClosed = optional.Some(false) 258 258 } 259 259 // if there are closed issues and no open issues, default to showing all issues 260 260 if len(ctx.FormString("state")) == 0 && issueStats.OpenCount == 0 && issueStats.ClosedCount != 0 { 261 - isShowClosed = util.OptionalBoolNone 261 + isShowClosed = optional.None[bool]() 262 262 } 263 263 264 264 if repo.IsTimetrackerEnabled(ctx) { ··· 278 278 } 279 279 280 280 var total int 281 - switch isShowClosed { 282 - case util.OptionalBoolTrue: 281 + switch { 282 + case isShowClosed.Value(): 283 283 total = int(issueStats.ClosedCount) 284 - case util.OptionalBoolNone: 284 + case !isShowClosed.Has(): 285 285 total = int(issueStats.OpenCount + issueStats.ClosedCount) 286 286 default: 287 287 total = int(issueStats.OpenCount) ··· 437 437 return 438 438 } 439 439 440 - pinned, err := issues_model.GetPinnedIssues(ctx, repo.ID, isPullOption.IsTrue()) 440 + pinned, err := issues_model.GetPinnedIssues(ctx, repo.ID, isPullOption.Value()) 441 441 if err != nil { 442 442 ctx.ServerError("GetPinnedIssues", err) 443 443 return ··· 467 467 ctx.Data["AssigneeID"] = assigneeID 468 468 ctx.Data["PosterID"] = posterID 469 469 ctx.Data["Keyword"] = keyword 470 - switch isShowClosed { 471 - case util.OptionalBoolTrue: 470 + switch { 471 + case isShowClosed.Value(): 472 472 ctx.Data["State"] = "closed" 473 - case util.OptionalBoolNone: 473 + case !isShowClosed.Has(): 474 474 ctx.Data["State"] = "all" 475 475 default: 476 476 ctx.Data["State"] = "open" ··· 519 519 ctx.Data["NewIssueChooseTemplate"] = issue_service.HasTemplatesOrContactLinks(ctx.Repo.Repository, ctx.Repo.GitRepo) 520 520 } 521 521 522 - issues(ctx, ctx.FormInt64("milestone"), ctx.FormInt64("project"), util.OptionalBoolOf(isPullList)) 522 + issues(ctx, ctx.FormInt64("milestone"), ctx.FormInt64("project"), optional.Some(isPullList)) 523 523 if ctx.Written() { 524 524 return 525 525 } ··· 561 561 var err error 562 562 ctx.Data["OpenMilestones"], err = db.Find[issues_model.Milestone](ctx, issues_model.FindMilestoneOptions{ 563 563 RepoID: repo.ID, 564 - IsClosed: util.OptionalBoolFalse, 564 + IsClosed: optional.Some(false), 565 565 }) 566 566 if err != nil { 567 567 ctx.ServerError("GetMilestones", err) ··· 569 569 } 570 570 ctx.Data["ClosedMilestones"], err = db.Find[issues_model.Milestone](ctx, issues_model.FindMilestoneOptions{ 571 571 RepoID: repo.ID, 572 - IsClosed: util.OptionalBoolTrue, 572 + IsClosed: optional.Some(true), 573 573 }) 574 574 if err != nil { 575 575 ctx.ServerError("GetMilestones", err) ··· 597 597 projects, err := db.Find[project_model.Project](ctx, project_model.SearchOptions{ 598 598 ListOptions: db.ListOptionsAll, 599 599 RepoID: repo.ID, 600 - IsClosed: util.OptionalBoolFalse, 600 + IsClosed: optional.Some(false), 601 601 Type: project_model.TypeRepository, 602 602 }) 603 603 if err != nil { ··· 607 607 projects2, err := db.Find[project_model.Project](ctx, project_model.SearchOptions{ 608 608 ListOptions: db.ListOptionsAll, 609 609 OwnerID: repo.OwnerID, 610 - IsClosed: util.OptionalBoolFalse, 610 + IsClosed: optional.Some(false), 611 611 Type: repoOwnerType, 612 612 }) 613 613 if err != nil { ··· 620 620 projects, err = db.Find[project_model.Project](ctx, project_model.SearchOptions{ 621 621 ListOptions: db.ListOptionsAll, 622 622 RepoID: repo.ID, 623 - IsClosed: util.OptionalBoolTrue, 623 + IsClosed: optional.Some(true), 624 624 Type: project_model.TypeRepository, 625 625 }) 626 626 if err != nil { ··· 630 630 projects2, err = db.Find[project_model.Project](ctx, project_model.SearchOptions{ 631 631 ListOptions: db.ListOptionsAll, 632 632 OwnerID: repo.OwnerID, 633 - IsClosed: util.OptionalBoolTrue, 633 + IsClosed: optional.Some(true), 634 634 Type: repoOwnerType, 635 635 }) 636 636 if err != nil { ··· 2512 2512 return 2513 2513 } 2514 2514 2515 - var isClosed util.OptionalBool 2515 + var isClosed optional.Option[bool] 2516 2516 switch ctx.FormString("state") { 2517 2517 case "closed": 2518 - isClosed = util.OptionalBoolTrue 2518 + isClosed = optional.Some(true) 2519 2519 case "all": 2520 - isClosed = util.OptionalBoolNone 2520 + isClosed = optional.None[bool]() 2521 2521 default: 2522 - isClosed = util.OptionalBoolFalse 2522 + isClosed = optional.Some(false) 2523 2523 } 2524 2524 2525 2525 var ( ··· 2597 2597 keyword = "" 2598 2598 } 2599 2599 2600 - var isPull util.OptionalBool 2600 + isPull := optional.None[bool]() 2601 2601 switch ctx.FormString("type") { 2602 2602 case "pulls": 2603 - isPull = util.OptionalBoolTrue 2603 + isPull = optional.Some(true) 2604 2604 case "issues": 2605 - isPull = util.OptionalBoolFalse 2606 - default: 2607 - isPull = util.OptionalBoolNone 2605 + isPull = optional.Some(false) 2608 2606 } 2609 2607 2610 2608 var includedAnyLabels []int64 ··· 2743 2741 return 2744 2742 } 2745 2743 2746 - var isClosed util.OptionalBool 2744 + var isClosed optional.Option[bool] 2747 2745 switch ctx.FormString("state") { 2748 2746 case "closed": 2749 - isClosed = util.OptionalBoolTrue 2747 + isClosed = optional.Some(true) 2750 2748 case "all": 2751 - isClosed = util.OptionalBoolNone 2749 + isClosed = optional.None[bool]() 2752 2750 default: 2753 - isClosed = util.OptionalBoolFalse 2751 + isClosed = optional.Some(false) 2754 2752 } 2755 2753 2756 2754 keyword := ctx.FormTrim("q") ··· 2802 2800 projectID = &v 2803 2801 } 2804 2802 2805 - var isPull util.OptionalBool 2803 + isPull := optional.None[bool]() 2806 2804 switch ctx.FormString("type") { 2807 2805 case "pulls": 2808 - isPull = util.OptionalBoolTrue 2806 + isPull = optional.Some(true) 2809 2807 case "issues": 2810 - isPull = util.OptionalBoolFalse 2811 - default: 2812 - isPull = util.OptionalBoolNone 2808 + isPull = optional.Some(false) 2813 2809 } 2814 2810 2815 2811 // FIXME: we should be more efficient here

+3 -3

routers/web/repo/milestone.go

··· 14 14 "code.gitea.io/gitea/modules/base" 15 15 "code.gitea.io/gitea/modules/markup" 16 16 "code.gitea.io/gitea/modules/markup/markdown" 17 + "code.gitea.io/gitea/modules/optional" 17 18 "code.gitea.io/gitea/modules/setting" 18 19 "code.gitea.io/gitea/modules/timeutil" 19 - "code.gitea.io/gitea/modules/util" 20 20 "code.gitea.io/gitea/modules/web" 21 21 "code.gitea.io/gitea/services/context" 22 22 "code.gitea.io/gitea/services/forms" ··· 51 51 PageSize: setting.UI.IssuePagingNum, 52 52 }, 53 53 RepoID: ctx.Repo.Repository.ID, 54 - IsClosed: util.OptionalBoolOf(isShowClosed), 54 + IsClosed: optional.Some(isShowClosed), 55 55 SortType: sortType, 56 56 Name: keyword, 57 57 }) ··· 292 292 ctx.Data["Title"] = milestone.Name 293 293 ctx.Data["Milestone"] = milestone 294 294 295 - issues(ctx, milestoneID, projectID, util.OptionalBoolNone) 295 + issues(ctx, milestoneID, projectID, optional.None[bool]()) 296 296 297 297 ret, _ := issue.GetTemplatesFromDefaultBranch(ctx.Repo.Repository, ctx.Repo.GitRepo) 298 298 ctx.Data["NewIssueChooseTemplate"] = len(ret) > 0

+2 -2

routers/web/repo/packages.go

··· 10 10 "code.gitea.io/gitea/models/packages" 11 11 "code.gitea.io/gitea/models/unit" 12 12 "code.gitea.io/gitea/modules/base" 13 + "code.gitea.io/gitea/modules/optional" 13 14 "code.gitea.io/gitea/modules/setting" 14 - "code.gitea.io/gitea/modules/util" 15 15 "code.gitea.io/gitea/services/context" 16 16 ) 17 17 ··· 37 37 RepoID: ctx.Repo.Repository.ID, 38 38 Type: packages.Type(packageType), 39 39 Name: packages.SearchValue{Value: query}, 40 - IsInternal: util.OptionalBoolFalse, 40 + IsInternal: optional.Some(false), 41 41 }) 42 42 if err != nil { 43 43 ctx.ServerError("SearchLatestVersions", err)

+3 -3

routers/web/repo/projects.go

··· 20 20 "code.gitea.io/gitea/modules/json" 21 21 "code.gitea.io/gitea/modules/markup" 22 22 "code.gitea.io/gitea/modules/markup/markdown" 23 + "code.gitea.io/gitea/modules/optional" 23 24 "code.gitea.io/gitea/modules/setting" 24 - "code.gitea.io/gitea/modules/util" 25 25 "code.gitea.io/gitea/modules/web" 26 26 "code.gitea.io/gitea/services/context" 27 27 "code.gitea.io/gitea/services/forms" ··· 78 78 Page: page, 79 79 }, 80 80 RepoID: repo.ID, 81 - IsClosed: util.OptionalBoolOf(isShowClosed), 81 + IsClosed: optional.Some(isShowClosed), 82 82 OrderBy: project_model.GetSearchOrderByBySortType(sortType), 83 83 Type: project_model.TypeRepository, 84 84 Title: keyword, ··· 349 349 if len(referencedIDs) > 0 { 350 350 if linkedPrs, err := issues_model.Issues(ctx, &issues_model.IssuesOptions{ 351 351 IssueIDs: referencedIDs, 352 - IsPull: util.OptionalBoolTrue, 352 + IsPull: optional.Some(true), 353 353 }); err == nil { 354 354 linkedPrsMap[issue.ID] = linkedPrs 355 355 }

+2 -2

routers/web/shared/packages/packages.go

··· 13 13 user_model "code.gitea.io/gitea/models/user" 14 14 "code.gitea.io/gitea/modules/base" 15 15 "code.gitea.io/gitea/modules/log" 16 - "code.gitea.io/gitea/modules/util" 16 + "code.gitea.io/gitea/modules/optional" 17 17 "code.gitea.io/gitea/modules/web" 18 18 "code.gitea.io/gitea/services/context" 19 19 "code.gitea.io/gitea/services/forms" ··· 157 157 for _, p := range packages { 158 158 pvs, _, err := packages_model.SearchVersions(ctx, &packages_model.PackageSearchOptions{ 159 159 PackageID: p.ID, 160 - IsInternal: util.OptionalBoolFalse, 160 + IsInternal: optional.Some(false), 161 161 Sort: packages_model.SortCreatedDesc, 162 162 Paginator: db.NewAbsoluteListOptions(pcr.KeepCount, 200), 163 163 })

+1 -2

routers/web/shared/user/header.go

··· 18 18 "code.gitea.io/gitea/modules/log" 19 19 "code.gitea.io/gitea/modules/optional" 20 20 "code.gitea.io/gitea/modules/setting" 21 - "code.gitea.io/gitea/modules/util" 22 21 "code.gitea.io/gitea/services/context" 23 22 ) 24 23 ··· 132 131 } 133 132 projectCount, err := db.Count[project_model.Project](ctx, project_model.SearchOptions{ 134 133 OwnerID: ctx.ContextUser.ID, 135 - IsClosed: util.OptionalBoolOf(false), 134 + IsClosed: optional.Some(false), 136 135 Type: projectType, 137 136 }) 138 137 if err != nil {

+7 -8

routers/web/user/home.go

··· 30 30 "code.gitea.io/gitea/modules/markup/markdown" 31 31 "code.gitea.io/gitea/modules/optional" 32 32 "code.gitea.io/gitea/modules/setting" 33 - "code.gitea.io/gitea/modules/util" 34 33 "code.gitea.io/gitea/routers/web/feed" 35 34 "code.gitea.io/gitea/services/context" 36 35 issue_service "code.gitea.io/gitea/services/issue" ··· 215 214 counts, err := issues_model.CountMilestonesMap(ctx, issues_model.FindMilestoneOptions{ 216 215 RepoCond: userRepoCond, 217 216 Name: keyword, 218 - IsClosed: util.OptionalBoolOf(isShowClosed), 217 + IsClosed: optional.Some(isShowClosed), 219 218 }) 220 219 if err != nil { 221 220 ctx.ServerError("CountMilestonesByRepoIDs", err) ··· 228 227 PageSize: setting.UI.IssuePagingNum, 229 228 }, 230 229 RepoCond: repoCond, 231 - IsClosed: util.OptionalBoolOf(isShowClosed), 230 + IsClosed: optional.Some(isShowClosed), 232 231 SortType: sortType, 233 232 Name: keyword, 234 233 }) ··· 440 439 441 440 isPullList := unitType == unit.TypePullRequests 442 441 opts := &issues_model.IssuesOptions{ 443 - IsPull: util.OptionalBoolOf(isPullList), 442 + IsPull: optional.Some(isPullList), 444 443 SortType: sortType, 445 - IsArchived: util.OptionalBoolFalse, 444 + IsArchived: optional.Some(false), 446 445 Org: org, 447 446 Team: team, 448 447 User: ctx.Doer, ··· 516 515 517 516 // Educated guess: Do or don't show closed issues. 518 517 isShowClosed := ctx.FormString("state") == "closed" 519 - opts.IsClosed = util.OptionalBoolOf(isShowClosed) 518 + opts.IsClosed = optional.Some(isShowClosed) 520 519 521 520 // Make sure page number is at least 1. Will be posted to ctx.Data. 522 521 page := ctx.FormInt("page") ··· 803 802 case issues_model.FilterModeReviewed: 804 803 openClosedOpts.ReviewedID = &doerID 805 804 } 806 - openClosedOpts.IsClosed = util.OptionalBoolFalse 805 + openClosedOpts.IsClosed = optional.Some(false) 807 806 ret.OpenCount, err = issue_indexer.CountIssues(ctx, openClosedOpts) 808 807 if err != nil { 809 808 return nil, err 810 809 } 811 - openClosedOpts.IsClosed = util.OptionalBoolTrue 810 + openClosedOpts.IsClosed = optional.Some(true) 812 811 ret.ClosedCount, err = issue_indexer.CountIssues(ctx, openClosedOpts) 813 812 if err != nil { 814 813 return nil, err

+9 -10

routers/web/user/notification.go

··· 233 233 if !util.SliceContainsString([]string{"all", "open", "closed"}, state, true) { 234 234 state = "all" 235 235 } 236 + 236 237 ctx.Data["State"] = state 237 - var showClosed util.OptionalBool 238 + // default state filter is "all" 239 + showClosed := optional.None[bool]() 238 240 switch state { 239 - case "all": 240 - showClosed = util.OptionalBoolNone 241 241 case "closed": 242 - showClosed = util.OptionalBoolTrue 242 + showClosed = optional.Some(true) 243 243 case "open": 244 - showClosed = util.OptionalBoolFalse 244 + showClosed = optional.Some(false) 245 245 } 246 246 247 - var issueTypeBool util.OptionalBool 248 247 issueType := ctx.FormString("issueType") 248 + // default issue type is no filter 249 + issueTypeBool := optional.None[bool]() 249 250 switch issueType { 250 251 case "issues": 251 - issueTypeBool = util.OptionalBoolFalse 252 + issueTypeBool = optional.Some(false) 252 253 case "pulls": 253 - issueTypeBool = util.OptionalBoolTrue 254 - default: 255 - issueTypeBool = util.OptionalBoolNone 254 + issueTypeBool = optional.Some(true) 256 255 } 257 256 ctx.Data["IssueType"] = issueType 258 257

+6 -5

routers/web/user/package.go

··· 16 16 "code.gitea.io/gitea/modules/base" 17 17 "code.gitea.io/gitea/modules/container" 18 18 "code.gitea.io/gitea/modules/log" 19 + "code.gitea.io/gitea/modules/optional" 19 20 alpine_module "code.gitea.io/gitea/modules/packages/alpine" 20 21 debian_module "code.gitea.io/gitea/modules/packages/debian" 21 22 rpm_module "code.gitea.io/gitea/modules/packages/rpm" ··· 54 55 OwnerID: ctx.ContextUser.ID, 55 56 Type: packages_model.Type(packageType), 56 57 Name: packages_model.SearchValue{Value: query}, 57 - IsInternal: util.OptionalBoolFalse, 58 + IsInternal: optional.Some(false), 58 59 }) 59 60 if err != nil { 60 61 ctx.ServerError("SearchLatestVersions", err) ··· 145 146 146 147 pvs, _, err := packages_model.SearchLatestVersions(ctx, &packages_model.PackageSearchOptions{ 147 148 PackageID: p.ID, 148 - IsInternal: util.OptionalBoolFalse, 149 + IsInternal: optional.Some(false), 149 150 }) 150 151 if err != nil { 151 152 ctx.ServerError("GetPackageByName", err) ··· 255 256 pvs, total, err = packages_model.SearchVersions(ctx, &packages_model.PackageSearchOptions{ 256 257 Paginator: db.NewAbsoluteListOptions(0, 5), 257 258 PackageID: pd.Package.ID, 258 - IsInternal: util.OptionalBoolFalse, 259 + IsInternal: optional.Some(false), 259 260 }) 260 261 } 261 262 if err != nil { ··· 359 360 ExactMatch: false, 360 361 Value: query, 361 362 }, 362 - IsInternal: util.OptionalBoolFalse, 363 + IsInternal: optional.Some(false), 363 364 Sort: sort, 364 365 }) 365 366 if err != nil { ··· 467 468 468 469 redirectURL := ctx.Package.Owner.HomeLink() + "/-/packages" 469 470 // redirect to the package if there are still versions available 470 - if has, _ := packages_model.ExistVersion(ctx, &packages_model.PackageSearchOptions{PackageID: ctx.Package.Descriptor.Package.ID, IsInternal: util.OptionalBoolFalse}); has { 471 + if has, _ := packages_model.ExistVersion(ctx, &packages_model.PackageSearchOptions{PackageID: ctx.Package.Descriptor.Package.ID, IsInternal: optional.Some(false)}); has { 471 472 redirectURL = ctx.Package.Descriptor.PackageWebLink() 472 473 } 473 474

+2 -2

routers/web/user/setting/security/security.go

··· 12 12 "code.gitea.io/gitea/models/db" 13 13 user_model "code.gitea.io/gitea/models/user" 14 14 "code.gitea.io/gitea/modules/base" 15 + "code.gitea.io/gitea/modules/optional" 15 16 "code.gitea.io/gitea/modules/setting" 16 - "code.gitea.io/gitea/modules/util" 17 17 "code.gitea.io/gitea/services/auth/source/oauth2" 18 18 "code.gitea.io/gitea/services/context" 19 19 ) ··· 112 112 ctx.Data["AccountLinks"] = sources 113 113 114 114 authSources, err := db.Find[auth_model.Source](ctx, auth_model.FindSourcesOptions{ 115 - IsActive: util.OptionalBoolNone, 115 + IsActive: optional.None[bool](), 116 116 LoginType: auth_model.OAuth2, 117 117 }) 118 118 if err != nil {

+2 -2

services/auth/signin.go

······

+2 -2

services/auth/source/oauth2/init.go

··· 12 12 "code.gitea.io/gitea/models/auth" 13 13 "code.gitea.io/gitea/models/db" 14 14 "code.gitea.io/gitea/modules/log" 15 + "code.gitea.io/gitea/modules/optional" 15 16 "code.gitea.io/gitea/modules/setting" 16 - "code.gitea.io/gitea/modules/util" 17 17 18 18 "github.com/google/uuid" 19 19 "github.com/gorilla/sessions" ··· 66 66 // initOAuth2Sources is used to load and register all active OAuth2 providers 67 67 func initOAuth2Sources(ctx context.Context) error { 68 68 authSources, err := db.Find[auth.Source](ctx, auth.FindSourcesOptions{ 69 - IsActive: util.OptionalBoolTrue, 69 + IsActive: optional.Some(true), 70 70 LoginType: auth.OAuth2, 71 71 }) 72 72 if err != nil {

+2 -2

services/auth/source/oauth2/providers.go

··· 15 15 "code.gitea.io/gitea/models/auth" 16 16 "code.gitea.io/gitea/models/db" 17 17 "code.gitea.io/gitea/modules/log" 18 + "code.gitea.io/gitea/modules/optional" 18 19 "code.gitea.io/gitea/modules/setting" 19 - "code.gitea.io/gitea/modules/util" 20 20 21 21 "github.com/markbates/goth" 22 22 ) ··· 107 107 } 108 108 109 109 // GetOAuth2Providers returns the list of configured OAuth2 providers 110 - func GetOAuth2Providers(ctx context.Context, isActive util.OptionalBool) ([]Provider, error) { 110 + func GetOAuth2Providers(ctx context.Context, isActive optional.Option[bool]) ([]Provider, error) { 111 111 authSources, err := db.Find[auth.Source](ctx, auth.FindSourcesOptions{ 112 112 IsActive: isActive, 113 113 LoginType: auth.OAuth2,

+1 -2

services/auth/sspi.go

··· 17 17 "code.gitea.io/gitea/modules/log" 18 18 "code.gitea.io/gitea/modules/optional" 19 19 "code.gitea.io/gitea/modules/setting" 20 - "code.gitea.io/gitea/modules/util" 21 20 "code.gitea.io/gitea/modules/web/middleware" 22 21 "code.gitea.io/gitea/services/auth/source/sspi" 23 22 gitea_context "code.gitea.io/gitea/services/context" ··· 132 131 // getConfig retrieves the SSPI configuration from login sources 133 132 func (s *SSPI) getConfig(ctx context.Context) (*sspi.Source, error) { 134 133 sources, err := db.Find[auth.Source](ctx, auth.FindSourcesOptions{ 135 - IsActive: util.OptionalBoolTrue, 134 + IsActive: optional.Some(true), 136 135 LoginType: auth.SSPI, 137 136 }) 138 137 if err != nil {

+4 -4

services/migrations/gitea_uploader_test.go

··· 23 23 "code.gitea.io/gitea/modules/graceful" 24 24 "code.gitea.io/gitea/modules/log" 25 25 base "code.gitea.io/gitea/modules/migration" 26 + "code.gitea.io/gitea/modules/optional" 26 27 "code.gitea.io/gitea/modules/structs" 27 28 "code.gitea.io/gitea/modules/test" 28 - "code.gitea.io/gitea/modules/util" 29 29 30 30 "github.com/stretchr/testify/assert" 31 31 ) ··· 68 68 69 69 milestones, err := db.Find[issues_model.Milestone](db.DefaultContext, issues_model.FindMilestoneOptions{ 70 70 RepoID: repo.ID, 71 - IsClosed: util.OptionalBoolFalse, 71 + IsClosed: optional.Some(false), 72 72 }) 73 73 assert.NoError(t, err) 74 74 assert.Len(t, milestones, 1) 75 75 76 76 milestones, err = db.Find[issues_model.Milestone](db.DefaultContext, issues_model.FindMilestoneOptions{ 77 77 RepoID: repo.ID, 78 - IsClosed: util.OptionalBoolTrue, 78 + IsClosed: optional.Some(true), 79 79 }) 80 80 assert.NoError(t, err) 81 81 assert.Empty(t, milestones) ··· 108 108 109 109 issues, err := issues_model.Issues(db.DefaultContext, &issues_model.IssuesOptions{ 110 110 RepoIDs: []int64{repo.ID}, 111 - IsPull: util.OptionalBoolFalse, 111 + IsPull: optional.Some(false), 112 112 SortType: "oldest", 113 113 }) 114 114 assert.NoError(t, err)

+2 -2

services/packages/cleanup/cleanup.go

··· 12 12 packages_model "code.gitea.io/gitea/models/packages" 13 13 user_model "code.gitea.io/gitea/models/user" 14 14 "code.gitea.io/gitea/modules/log" 15 + "code.gitea.io/gitea/modules/optional" 15 16 packages_module "code.gitea.io/gitea/modules/packages" 16 - "code.gitea.io/gitea/modules/util" 17 17 packages_service "code.gitea.io/gitea/services/packages" 18 18 alpine_service "code.gitea.io/gitea/services/packages/alpine" 19 19 cargo_service "code.gitea.io/gitea/services/packages/cargo" ··· 60 60 for _, p := range packages { 61 61 pvs, _, err := packages_model.SearchVersions(ctx, &packages_model.PackageSearchOptions{ 62 62 PackageID: p.ID, 63 - IsInternal: util.OptionalBoolFalse, 63 + IsInternal: optional.Some(false), 64 64 Sort: packages_model.SortCreatedDesc, 65 65 Paginator: db.NewAbsoluteListOptions(pcr.KeepCount, 200), 66 66 })

+3 -3

services/packages/container/cleanup.go

··· 9 9 10 10 packages_model "code.gitea.io/gitea/models/packages" 11 11 container_model "code.gitea.io/gitea/models/packages/container" 12 + "code.gitea.io/gitea/modules/optional" 12 13 container_module "code.gitea.io/gitea/modules/packages/container" 13 - "code.gitea.io/gitea/modules/util" 14 14 packages_service "code.gitea.io/gitea/services/packages" 15 15 16 16 digest "github.com/opencontainers/go-digest" ··· 59 59 ExactMatch: true, 60 60 Value: container_model.UploadVersion, 61 61 }, 62 - IsInternal: util.OptionalBoolTrue, 63 - HasFiles: util.OptionalBoolFalse, 62 + IsInternal: optional.Some(true), 63 + HasFiles: optional.Some(false), 64 64 }) 65 65 if err != nil { 66 66 return err

+3 -3

services/packages/packages.go

··· 18 18 user_model "code.gitea.io/gitea/models/user" 19 19 "code.gitea.io/gitea/modules/json" 20 20 "code.gitea.io/gitea/modules/log" 21 + "code.gitea.io/gitea/modules/optional" 21 22 packages_module "code.gitea.io/gitea/modules/packages" 22 23 "code.gitea.io/gitea/modules/setting" 23 24 "code.gitea.io/gitea/modules/storage" 24 - "code.gitea.io/gitea/modules/util" 25 25 notify_service "code.gitea.io/gitea/services/notify" 26 26 ) 27 27 ··· 330 330 if setting.Packages.LimitTotalOwnerCount > -1 { 331 331 totalCount, err := packages_model.CountVersions(ctx, &packages_model.PackageSearchOptions{ 332 332 OwnerID: owner.ID, 333 - IsInternal: util.OptionalBoolFalse, 333 + IsInternal: optional.Some(false), 334 334 }) 335 335 if err != nil { 336 336 log.Error("CountVersions failed: %v", err) ··· 640 640 Page: 1, 641 641 }, 642 642 OwnerID: userID, 643 - IsInternal: util.OptionalBoolNone, 643 + IsInternal: optional.None[bool](), 644 644 }) 645 645 if err != nil { 646 646 return count, fmt.Errorf("GetOwnedPackages[%d]: %w", userID, err)

+4 -4

services/pull/review.go

··· 18 18 "code.gitea.io/gitea/modules/git" 19 19 "code.gitea.io/gitea/modules/gitrepo" 20 20 "code.gitea.io/gitea/modules/log" 21 + "code.gitea.io/gitea/modules/optional" 21 22 "code.gitea.io/gitea/modules/setting" 22 - "code.gitea.io/gitea/modules/util" 23 23 notify_service "code.gitea.io/gitea/services/notify" 24 24 ) 25 25 ··· 56 56 ListAll: true, 57 57 }, 58 58 Type: issues_model.CommentTypeCode, 59 - Invalidated: util.OptionalBoolFalse, 59 + Invalidated: optional.Some(false), 60 60 IssueIDs: issueIDs, 61 61 }) 62 62 if err != nil { ··· 327 327 }, 328 328 IssueID: pull.IssueID, 329 329 Type: issues_model.ReviewTypeApprove, 330 - Dismissed: util.OptionalBoolFalse, 330 + Dismissed: optional.Some(false), 331 331 }) 332 332 if err != nil { 333 333 return err ··· 394 394 reviews, err := issues_model.FindReviews(ctx, issues_model.FindReviewOptions{ 395 395 IssueID: review.IssueID, 396 396 ReviewerID: review.ReviewerID, 397 - Dismissed: util.OptionalBoolFalse, 397 + Dismissed: optional.Some(false), 398 398 }) 399 399 if err != nil { 400 400 return nil, err

+2 -3

services/repository/branch.go

··· 23 23 "code.gitea.io/gitea/modules/queue" 24 24 repo_module "code.gitea.io/gitea/modules/repository" 25 25 "code.gitea.io/gitea/modules/timeutil" 26 - "code.gitea.io/gitea/modules/util" 27 26 notify_service "code.gitea.io/gitea/services/notify" 28 27 files_service "code.gitea.io/gitea/services/repository/files" 29 28 ··· 52 51 } 53 52 54 53 // LoadBranches loads branches from the repository limited by page & pageSize. 55 - func LoadBranches(ctx context.Context, repo *repo_model.Repository, gitRepo *git.Repository, isDeletedBranch util.OptionalBool, keyword string, page, pageSize int) (*Branch, []*Branch, int64, error) { 54 + func LoadBranches(ctx context.Context, repo *repo_model.Repository, gitRepo *git.Repository, isDeletedBranch optional.Option[bool], keyword string, page, pageSize int) (*Branch, []*Branch, int64, error) { 56 55 defaultDBBranch, err := git_model.GetBranch(ctx, repo.ID, repo.DefaultBranch) 57 56 if err != nil { 58 57 return nil, nil, 0, err ··· 60 59 61 60 branchOpts := git_model.FindBranchOptions{ 62 61 RepoID: repo.ID, 63 - IsDeletedBranch: isDeletedBranch.ToGeneric(), 62 + IsDeletedBranch: isDeletedBranch, 64 63 ListOptions: db.ListOptions{ 65 64 Page: page, 66 65 PageSize: pageSize,

+4 -3

services/webhook/webhook.go

··· 16 16 "code.gitea.io/gitea/modules/git" 17 17 "code.gitea.io/gitea/modules/graceful" 18 18 "code.gitea.io/gitea/modules/log" 19 + "code.gitea.io/gitea/modules/optional" 19 20 "code.gitea.io/gitea/modules/queue" 20 21 "code.gitea.io/gitea/modules/setting" 21 22 api "code.gitea.io/gitea/modules/structs" ··· 225 226 if source.Repository != nil { 226 227 repoHooks, err := db.Find[webhook_model.Webhook](ctx, webhook_model.ListWebhookOptions{ 227 228 RepoID: source.Repository.ID, 228 - IsActive: util.OptionalBoolTrue, 229 + IsActive: optional.Some(true), 229 230 }) 230 231 if err != nil { 231 232 return fmt.Errorf("ListWebhooksByOpts: %w", err) ··· 239 240 if owner != nil { 240 241 ownerHooks, err := db.Find[webhook_model.Webhook](ctx, webhook_model.ListWebhookOptions{ 241 242 OwnerID: owner.ID, 242 - IsActive: util.OptionalBoolTrue, 243 + IsActive: optional.Some(true), 243 244 }) 244 245 if err != nil { 245 246 return fmt.Errorf("ListWebhooksByOpts: %w", err) ··· 248 249 } 249 250 250 251 // Add any admin-defined system webhooks 251 - systemHooks, err := webhook_model.GetSystemWebhooks(ctx, util.OptionalBoolTrue) 252 + systemHooks, err := webhook_model.GetSystemWebhooks(ctx, optional.Some(true)) 252 253 if err != nil { 253 254 return fmt.Errorf("GetSystemWebhooks: %w", err) 254 255 }

Configure Feed

Configure Feed