2019-04-20 06:15:19 +02:00
|
|
|
// Copyright 2019 The Gitea Authors. All rights reserved.
|
2022-11-27 19:20:29 +01:00
|
|
|
// SPDX-License-Identifier: MIT
|
2019-04-20 06:15:19 +02:00
|
|
|
|
2016-12-30 19:49:54 +01:00
|
|
|
package user
|
|
|
|
|
|
|
|
import (
|
2022-05-25 02:51:53 +02:00
|
|
|
goctx "context"
|
2017-01-12 05:27:09 +01:00
|
|
|
"errors"
|
2016-12-30 19:49:54 +01:00
|
|
|
"fmt"
|
2020-04-24 05:57:38 +02:00
|
|
|
"net/http"
|
2021-10-16 05:34:07 +02:00
|
|
|
"net/url"
|
2017-01-02 19:31:50 +01:00
|
|
|
"strings"
|
2016-12-30 19:49:54 +01:00
|
|
|
|
2022-08-25 04:31:57 +02:00
|
|
|
activities_model "code.gitea.io/gitea/models/activities"
|
2022-09-29 21:09:14 +02:00
|
|
|
"code.gitea.io/gitea/models/db"
|
|
|
|
issues_model "code.gitea.io/gitea/models/issues"
|
|
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
2016-12-30 19:49:54 +01:00
|
|
|
"code.gitea.io/gitea/modules/base"
|
2022-05-25 02:51:53 +02:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
2024-02-29 19:52:49 +01:00
|
|
|
"code.gitea.io/gitea/modules/optional"
|
2017-01-12 05:27:09 +01:00
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2022-05-03 23:38:34 +02:00
|
|
|
"code.gitea.io/gitea/modules/structs"
|
2022-09-29 21:09:14 +02:00
|
|
|
"code.gitea.io/gitea/modules/util"
|
2024-02-27 08:12:22 +01:00
|
|
|
"code.gitea.io/gitea/services/context"
|
2022-09-29 21:09:14 +02:00
|
|
|
issue_service "code.gitea.io/gitea/services/issue"
|
|
|
|
pull_service "code.gitea.io/gitea/services/pull"
|
2016-12-30 19:49:54 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
2022-09-29 21:09:14 +02:00
|
|
|
tplNotification base.TplName = "user/notification/notification"
|
|
|
|
tplNotificationDiv base.TplName = "user/notification/notification_div"
|
|
|
|
tplNotificationSubscriptions base.TplName = "user/notification/notification_subscriptions"
|
2016-12-30 19:49:54 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
// GetNotificationCount is the middleware that sets the notification count in the context
|
2022-11-19 09:12:33 +01:00
|
|
|
func GetNotificationCount(ctx *context.Context) {
|
|
|
|
if strings.HasPrefix(ctx.Req.URL.Path, "/api") {
|
2017-01-02 19:31:50 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
if !ctx.IsSigned {
|
2016-12-30 19:49:54 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["NotificationUnreadCount"] = func() int64 {
|
2023-11-24 04:49:41 +01:00
|
|
|
count, err := db.Count[activities_model.Notification](ctx, activities_model.FindNotificationOptions{
|
|
|
|
UserID: ctx.Doer.ID,
|
|
|
|
Status: []activities_model.NotificationStatus{activities_model.NotificationStatusUnread},
|
|
|
|
})
|
2020-04-24 05:57:38 +02:00
|
|
|
if err != nil {
|
2022-05-25 02:51:53 +02:00
|
|
|
if err != goctx.Canceled {
|
2022-11-19 09:12:33 +01:00
|
|
|
log.Error("Unable to GetNotificationCount for user:%-v: %v", ctx.Doer, err)
|
2022-05-25 02:51:53 +02:00
|
|
|
}
|
2020-04-24 05:57:38 +02:00
|
|
|
return -1
|
|
|
|
}
|
2016-12-30 19:49:54 +01:00
|
|
|
|
2020-04-24 05:57:38 +02:00
|
|
|
return count
|
|
|
|
}
|
2016-12-30 19:49:54 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Notifications is the notifications page
|
2022-11-19 09:12:33 +01:00
|
|
|
func Notifications(ctx *context.Context) {
|
|
|
|
getNotifications(ctx)
|
|
|
|
if ctx.Written() {
|
2020-04-24 05:57:38 +02:00
|
|
|
return
|
|
|
|
}
|
2022-11-19 09:12:33 +01:00
|
|
|
if ctx.FormBool("div-only") {
|
|
|
|
ctx.Data["SequenceNumber"] = ctx.FormString("sequence-number")
|
|
|
|
ctx.HTML(http.StatusOK, tplNotificationDiv)
|
2020-04-24 05:57:38 +02:00
|
|
|
return
|
|
|
|
}
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.HTML(http.StatusOK, tplNotification)
|
2020-04-24 05:57:38 +02:00
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
func getNotifications(ctx *context.Context) {
|
2017-01-03 20:09:36 +01:00
|
|
|
var (
|
2022-11-19 09:12:33 +01:00
|
|
|
keyword = ctx.FormTrim("q")
|
2022-08-25 04:31:57 +02:00
|
|
|
status activities_model.NotificationStatus
|
2022-11-19 09:12:33 +01:00
|
|
|
page = ctx.FormInt("page")
|
|
|
|
perPage = ctx.FormInt("perPage")
|
2017-01-03 20:09:36 +01:00
|
|
|
)
|
|
|
|
if page < 1 {
|
|
|
|
page = 1
|
|
|
|
}
|
|
|
|
if perPage < 1 {
|
|
|
|
perPage = 20
|
|
|
|
}
|
|
|
|
|
|
|
|
switch keyword {
|
2016-12-30 19:49:54 +01:00
|
|
|
case "read":
|
2022-08-25 04:31:57 +02:00
|
|
|
status = activities_model.NotificationStatusRead
|
2016-12-30 19:49:54 +01:00
|
|
|
default:
|
2022-08-25 04:31:57 +02:00
|
|
|
status = activities_model.NotificationStatusUnread
|
2016-12-30 19:49:54 +01:00
|
|
|
}
|
|
|
|
|
2023-11-24 04:49:41 +01:00
|
|
|
total, err := db.Count[activities_model.Notification](ctx, activities_model.FindNotificationOptions{
|
|
|
|
UserID: ctx.Doer.ID,
|
|
|
|
Status: []activities_model.NotificationStatus{status},
|
|
|
|
})
|
2020-01-17 19:31:26 +01:00
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("ErrGetNotificationCount", err)
|
2020-01-17 19:31:26 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// redirect to last page if request page is more than total pages
|
|
|
|
pager := context.NewPagination(int(total), perPage, page, 5)
|
|
|
|
if pager.Paginater.Current() < page {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Redirect(fmt.Sprintf("%s/notifications?q=%s&page=%d", setting.AppSubURL, url.QueryEscape(ctx.FormString("q")), pager.Paginater.Current()))
|
2020-01-17 19:31:26 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-08-25 04:31:57 +02:00
|
|
|
statuses := []activities_model.NotificationStatus{status, activities_model.NotificationStatusPinned}
|
2023-11-24 04:49:41 +01:00
|
|
|
nls, err := db.Find[activities_model.Notification](ctx, activities_model.FindNotificationOptions{
|
|
|
|
ListOptions: db.ListOptions{
|
|
|
|
PageSize: perPage,
|
|
|
|
Page: page,
|
|
|
|
},
|
|
|
|
UserID: ctx.Doer.ID,
|
|
|
|
Status: statuses,
|
|
|
|
})
|
2016-12-30 19:49:54 +01:00
|
|
|
if err != nil {
|
2023-11-24 04:49:41 +01:00
|
|
|
ctx.ServerError("db.Find[activities_model.Notification]", err)
|
2016-12-30 19:49:54 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-11-24 04:49:41 +01:00
|
|
|
notifications := activities_model.NotificationList(nls)
|
|
|
|
|
2020-03-29 21:51:14 +02:00
|
|
|
failCount := 0
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
repos, failures, err := notifications.LoadRepos(ctx)
|
2019-11-12 09:33:34 +01:00
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("LoadRepos", err)
|
2019-11-12 09:33:34 +01:00
|
|
|
return
|
|
|
|
}
|
2020-03-29 21:51:14 +02:00
|
|
|
notifications = notifications.Without(failures)
|
2023-03-13 12:31:41 +01:00
|
|
|
if err := repos.LoadAttributes(ctx); err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("LoadAttributes", err)
|
2019-11-12 09:33:34 +01:00
|
|
|
return
|
|
|
|
}
|
2020-03-29 21:51:14 +02:00
|
|
|
failCount += len(failures)
|
2019-11-12 09:33:34 +01:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
failures, err = notifications.LoadIssues(ctx)
|
2020-03-29 21:51:14 +02:00
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("LoadIssues", err)
|
2019-11-12 09:33:34 +01:00
|
|
|
return
|
|
|
|
}
|
2020-03-29 21:51:14 +02:00
|
|
|
notifications = notifications.Without(failures)
|
|
|
|
failCount += len(failures)
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
failures, err = notifications.LoadComments(ctx)
|
2020-03-29 21:51:14 +02:00
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("LoadComments", err)
|
2019-11-12 09:33:34 +01:00
|
|
|
return
|
|
|
|
}
|
2020-03-29 21:51:14 +02:00
|
|
|
notifications = notifications.Without(failures)
|
|
|
|
failCount += len(failures)
|
|
|
|
|
|
|
|
if failCount > 0 {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Flash.Error(fmt.Sprintf("ERROR: %d notifications were removed due to missing parts - check the logs", failCount))
|
2020-03-29 21:51:14 +02:00
|
|
|
}
|
2019-11-12 09:33:34 +01:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["Title"] = ctx.Tr("notifications")
|
|
|
|
ctx.Data["Keyword"] = keyword
|
|
|
|
ctx.Data["Status"] = status
|
|
|
|
ctx.Data["Notifications"] = notifications
|
2019-04-20 06:15:19 +02:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
pager.SetDefaultParams(ctx)
|
|
|
|
ctx.Data["Page"] = pager
|
2016-12-30 19:49:54 +01:00
|
|
|
}
|
2017-01-12 05:27:09 +01:00
|
|
|
|
|
|
|
// NotificationStatusPost is a route for changing the status of a notification
|
2022-11-19 09:12:33 +01:00
|
|
|
func NotificationStatusPost(ctx *context.Context) {
|
2017-01-12 05:27:09 +01:00
|
|
|
var (
|
2022-11-19 09:12:33 +01:00
|
|
|
notificationID = ctx.FormInt64("notification_id")
|
|
|
|
statusStr = ctx.FormString("status")
|
2022-08-25 04:31:57 +02:00
|
|
|
status activities_model.NotificationStatus
|
2017-01-12 05:27:09 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
switch statusStr {
|
|
|
|
case "read":
|
2022-08-25 04:31:57 +02:00
|
|
|
status = activities_model.NotificationStatusRead
|
2017-01-12 05:27:09 +01:00
|
|
|
case "unread":
|
2022-08-25 04:31:57 +02:00
|
|
|
status = activities_model.NotificationStatusUnread
|
2017-01-12 05:27:09 +01:00
|
|
|
case "pinned":
|
2022-08-25 04:31:57 +02:00
|
|
|
status = activities_model.NotificationStatusPinned
|
2017-01-12 05:27:09 +01:00
|
|
|
default:
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("InvalidNotificationStatus", errors.New("Invalid notification status"))
|
2017-01-12 05:27:09 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
if _, err := activities_model.SetNotificationStatus(ctx, notificationID, ctx.Doer, status); err != nil {
|
|
|
|
ctx.ServerError("SetNotificationStatus", err)
|
2017-01-12 05:27:09 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
if !ctx.FormBool("noredirect") {
|
|
|
|
url := fmt.Sprintf("%s/notifications?page=%s", setting.AppSubURL, url.QueryEscape(ctx.FormString("page")))
|
|
|
|
ctx.Redirect(url, http.StatusSeeOther)
|
2020-04-24 05:57:38 +02:00
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
getNotifications(ctx)
|
|
|
|
if ctx.Written() {
|
2020-04-24 05:57:38 +02:00
|
|
|
return
|
|
|
|
}
|
2023-07-09 20:42:31 +02:00
|
|
|
ctx.Data["Link"] = setting.AppSubURL + "/notifications"
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["SequenceNumber"] = ctx.Req.PostFormValue("sequence-number")
|
2020-04-24 05:57:38 +02:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.HTML(http.StatusOK, tplNotificationDiv)
|
2017-01-12 05:27:09 +01:00
|
|
|
}
|
2017-12-07 06:52:57 +01:00
|
|
|
|
|
|
|
// NotificationPurgePost is a route for 'purging' the list of notifications - marking all unread as read
|
2022-11-19 09:12:33 +01:00
|
|
|
func NotificationPurgePost(ctx *context.Context) {
|
|
|
|
err := activities_model.UpdateNotificationStatuses(ctx, ctx.Doer, activities_model.NotificationStatusUnread, activities_model.NotificationStatusRead)
|
2017-12-07 06:52:57 +01:00
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("UpdateNotificationStatuses", err)
|
2017-12-07 06:52:57 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Redirect(setting.AppSubURL+"/notifications", http.StatusSeeOther)
|
2017-12-07 06:52:57 +01:00
|
|
|
}
|
2022-04-07 20:59:56 +02:00
|
|
|
|
2022-09-29 21:09:14 +02:00
|
|
|
// NotificationSubscriptions returns the list of subscribed issues
|
2022-11-19 09:12:33 +01:00
|
|
|
func NotificationSubscriptions(ctx *context.Context) {
|
|
|
|
page := ctx.FormInt("page")
|
2022-09-29 21:09:14 +02:00
|
|
|
if page < 1 {
|
|
|
|
page = 1
|
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
sortType := ctx.FormString("sort")
|
|
|
|
ctx.Data["SortType"] = sortType
|
2022-09-29 21:09:14 +02:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
state := ctx.FormString("state")
|
Improve utils of slices (#22379)
- Move the file `compare.go` and `slice.go` to `slice.go`.
- Fix `ExistsInSlice`, it's buggy
- It uses `sort.Search`, so it assumes that the input slice is sorted.
- It passes `func(i int) bool { return slice[i] == target })` to
`sort.Search`, that's incorrect, check the doc of `sort.Search`.
- Conbine `IsInt64InSlice(int64, []int64)` and `ExistsInSlice(string,
[]string)` to `SliceContains[T]([]T, T)`.
- Conbine `IsSliceInt64Eq([]int64, []int64)` and `IsEqualSlice([]string,
[]string)` to `SliceSortedEqual[T]([]T, T)`.
- Add `SliceEqual[T]([]T, T)` as a distinction from
`SliceSortedEqual[T]([]T, T)`.
- Redesign `RemoveIDFromList([]int64, int64) ([]int64, bool)` to
`SliceRemoveAll[T]([]T, T) []T`.
- Add `SliceContainsFunc[T]([]T, func(T) bool)` and
`SliceRemoveAllFunc[T]([]T, func(T) bool)` for general use.
- Add comments to explain why not `golang.org/x/exp/slices`.
- Add unit tests.
2023-01-11 06:31:16 +01:00
|
|
|
if !util.SliceContainsString([]string{"all", "open", "closed"}, state, true) {
|
2022-09-29 21:09:14 +02:00
|
|
|
state = "all"
|
|
|
|
}
|
2024-03-02 16:42:31 +01:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["State"] = state
|
2024-03-02 16:42:31 +01:00
|
|
|
// default state filter is "all"
|
|
|
|
showClosed := optional.None[bool]()
|
2022-09-29 21:09:14 +02:00
|
|
|
switch state {
|
|
|
|
case "closed":
|
2024-03-02 16:42:31 +01:00
|
|
|
showClosed = optional.Some(true)
|
2022-09-29 21:09:14 +02:00
|
|
|
case "open":
|
2024-03-02 16:42:31 +01:00
|
|
|
showClosed = optional.Some(false)
|
2022-09-29 21:09:14 +02:00
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
issueType := ctx.FormString("issueType")
|
2024-03-02 16:42:31 +01:00
|
|
|
// default issue type is no filter
|
|
|
|
issueTypeBool := optional.None[bool]()
|
2022-09-29 21:09:14 +02:00
|
|
|
switch issueType {
|
|
|
|
case "issues":
|
2024-03-02 16:42:31 +01:00
|
|
|
issueTypeBool = optional.Some(false)
|
2022-09-29 21:09:14 +02:00
|
|
|
case "pulls":
|
2024-03-02 16:42:31 +01:00
|
|
|
issueTypeBool = optional.Some(true)
|
2022-09-29 21:09:14 +02:00
|
|
|
}
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["IssueType"] = issueType
|
2022-09-29 21:09:14 +02:00
|
|
|
|
|
|
|
var labelIDs []int64
|
2022-11-19 09:12:33 +01:00
|
|
|
selectedLabels := ctx.FormString("labels")
|
|
|
|
ctx.Data["Labels"] = selectedLabels
|
2022-09-29 21:09:14 +02:00
|
|
|
if len(selectedLabels) > 0 && selectedLabels != "0" {
|
|
|
|
var err error
|
|
|
|
labelIDs, err = base.StringsToInt64s(strings.Split(selectedLabels, ","))
|
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("StringsToInt64s", err)
|
2022-09-29 21:09:14 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
count, err := issues_model.CountIssues(ctx, &issues_model.IssuesOptions{
|
|
|
|
SubscriberID: ctx.Doer.ID,
|
2022-09-29 21:09:14 +02:00
|
|
|
IsClosed: showClosed,
|
|
|
|
IsPull: issueTypeBool,
|
|
|
|
LabelIDs: labelIDs,
|
|
|
|
})
|
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("CountIssues", err)
|
2022-09-29 21:09:14 +02:00
|
|
|
return
|
|
|
|
}
|
2022-11-19 09:12:33 +01:00
|
|
|
issues, err := issues_model.Issues(ctx, &issues_model.IssuesOptions{
|
Refactor and enhance issue indexer to support both searching, filtering and paging (#26012)
Fix #24662.
Replace #24822 and #25708 (although it has been merged)
## Background
In the past, Gitea supported issue searching with a keyword and
conditions in a less efficient way. It worked by searching for issues
with the keyword and obtaining limited IDs (as it is heavy to get all)
on the indexer (bleve/elasticsearch/meilisearch), and then querying with
conditions on the database to find a subset of the found IDs. This is
why the results could be incomplete.
To solve this issue, we need to store all fields that could be used as
conditions in the indexer and support both keyword and additional
conditions when searching with the indexer.
## Major changes
- Redefine `IndexerData` to include all fields that could be used as
filter conditions.
- Refactor `Search(ctx context.Context, kw string, repoIDs []int64,
limit, start int, state string)` to `Search(ctx context.Context, options
*SearchOptions)`, so it supports more conditions now.
- Change the data type stored in `issueIndexerQueue`. Use
`IndexerMetadata` instead of `IndexerData` in case the data has been
updated while it is in the queue. This also reduces the storage size of
the queue.
- Enhance searching with Bleve/Elasticsearch/Meilisearch, make them
fully support `SearchOptions`. Also, update the data versions.
- Keep most logic of database indexer, but remove
`issues.SearchIssueIDsByKeyword` in `models` to avoid confusion where is
the entry point to search issues.
- Start a Meilisearch instance to test it in unit tests.
- Add unit tests with almost full coverage to test
Bleve/Elasticsearch/Meilisearch indexer.
---------
Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com>
2023-07-31 08:28:53 +02:00
|
|
|
Paginator: &db.ListOptions{
|
2022-09-29 21:09:14 +02:00
|
|
|
PageSize: setting.UI.IssuePagingNum,
|
|
|
|
Page: page,
|
|
|
|
},
|
2022-11-19 09:12:33 +01:00
|
|
|
SubscriberID: ctx.Doer.ID,
|
2022-09-29 21:09:14 +02:00
|
|
|
SortType: sortType,
|
|
|
|
IsClosed: showClosed,
|
|
|
|
IsPull: issueTypeBool,
|
|
|
|
LabelIDs: labelIDs,
|
|
|
|
})
|
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("Issues", err)
|
2022-09-29 21:09:14 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
commitStatuses, lastStatus, err := pull_service.GetIssuesAllCommitStatus(ctx, issues)
|
2022-09-29 21:09:14 +02:00
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("GetIssuesAllCommitStatus", err)
|
2022-09-29 21:09:14 +02:00
|
|
|
return
|
|
|
|
}
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["CommitLastStatus"] = lastStatus
|
|
|
|
ctx.Data["CommitStatuses"] = commitStatuses
|
|
|
|
ctx.Data["Issues"] = issues
|
2022-09-29 21:09:14 +02:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["IssueRefEndNames"], ctx.Data["IssueRefURLs"] = issue_service.GetRefEndNamesAndURLs(issues, "")
|
2022-09-29 21:09:14 +02:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
commitStatus, err := pull_service.GetIssuesLastCommitStatus(ctx, issues)
|
2022-09-29 21:09:14 +02:00
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("GetIssuesLastCommitStatus", err)
|
2022-09-29 21:09:14 +02:00
|
|
|
return
|
|
|
|
}
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["CommitStatus"] = commitStatus
|
2022-09-29 21:09:14 +02:00
|
|
|
|
2023-08-07 21:26:40 +02:00
|
|
|
approvalCounts, err := issues.GetApprovalCounts(ctx)
|
2022-09-29 21:09:14 +02:00
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("ApprovalCounts", err)
|
2022-09-29 21:09:14 +02:00
|
|
|
return
|
|
|
|
}
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["ApprovalCounts"] = func(issueID int64, typ string) int64 {
|
2022-09-29 21:09:14 +02:00
|
|
|
counts, ok := approvalCounts[issueID]
|
|
|
|
if !ok || len(counts) == 0 {
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
reviewTyp := issues_model.ReviewTypeApprove
|
|
|
|
if typ == "reject" {
|
|
|
|
reviewTyp = issues_model.ReviewTypeReject
|
|
|
|
} else if typ == "waiting" {
|
|
|
|
reviewTyp = issues_model.ReviewTypeRequest
|
|
|
|
}
|
|
|
|
for _, count := range counts {
|
|
|
|
if count.Type == reviewTyp {
|
|
|
|
return count.Count
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["Status"] = 1
|
|
|
|
ctx.Data["Title"] = ctx.Tr("notification.subscriptions")
|
2022-09-29 21:09:14 +02:00
|
|
|
|
|
|
|
// redirect to last page if request page is more than total pages
|
|
|
|
pager := context.NewPagination(int(count), setting.UI.IssuePagingNum, page, 5)
|
|
|
|
if pager.Paginater.Current() < page {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Redirect(fmt.Sprintf("/notifications/subscriptions?page=%d", pager.Paginater.Current()))
|
2022-09-29 21:09:14 +02:00
|
|
|
return
|
|
|
|
}
|
2024-03-16 13:07:56 +01:00
|
|
|
pager.AddParamString("sort", sortType)
|
|
|
|
pager.AddParamString("state", state)
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["Page"] = pager
|
2022-09-29 21:09:14 +02:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.HTML(http.StatusOK, tplNotificationSubscriptions)
|
2022-09-29 21:09:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// NotificationWatching returns the list of watching repos
|
2022-11-19 09:12:33 +01:00
|
|
|
func NotificationWatching(ctx *context.Context) {
|
|
|
|
page := ctx.FormInt("page")
|
2022-09-29 21:09:14 +02:00
|
|
|
if page < 1 {
|
|
|
|
page = 1
|
|
|
|
}
|
|
|
|
|
2023-03-21 02:07:14 +01:00
|
|
|
keyword := ctx.FormTrim("q")
|
|
|
|
ctx.Data["Keyword"] = keyword
|
|
|
|
|
2022-09-29 21:09:14 +02:00
|
|
|
var orderBy db.SearchOrderBy
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["SortType"] = ctx.FormString("sort")
|
|
|
|
switch ctx.FormString("sort") {
|
2022-09-29 21:09:14 +02:00
|
|
|
case "newest":
|
|
|
|
orderBy = db.SearchOrderByNewest
|
|
|
|
case "oldest":
|
|
|
|
orderBy = db.SearchOrderByOldest
|
|
|
|
case "recentupdate":
|
|
|
|
orderBy = db.SearchOrderByRecentUpdated
|
|
|
|
case "leastupdate":
|
|
|
|
orderBy = db.SearchOrderByLeastUpdated
|
|
|
|
case "reversealphabetically":
|
|
|
|
orderBy = db.SearchOrderByAlphabeticallyReverse
|
|
|
|
case "alphabetically":
|
|
|
|
orderBy = db.SearchOrderByAlphabetically
|
|
|
|
case "moststars":
|
|
|
|
orderBy = db.SearchOrderByStarsReverse
|
|
|
|
case "feweststars":
|
|
|
|
orderBy = db.SearchOrderByStars
|
|
|
|
case "mostforks":
|
|
|
|
orderBy = db.SearchOrderByForksReverse
|
|
|
|
case "fewestforks":
|
|
|
|
orderBy = db.SearchOrderByForks
|
|
|
|
default:
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["SortType"] = "recentupdate"
|
2022-09-29 21:09:14 +02:00
|
|
|
orderBy = db.SearchOrderByRecentUpdated
|
|
|
|
}
|
|
|
|
|
2024-03-03 11:18:34 +01:00
|
|
|
archived := ctx.FormOptionalBool("archived")
|
|
|
|
ctx.Data["IsArchived"] = archived
|
|
|
|
|
|
|
|
fork := ctx.FormOptionalBool("fork")
|
|
|
|
ctx.Data["IsFork"] = fork
|
|
|
|
|
|
|
|
mirror := ctx.FormOptionalBool("mirror")
|
|
|
|
ctx.Data["IsMirror"] = mirror
|
|
|
|
|
|
|
|
template := ctx.FormOptionalBool("template")
|
|
|
|
ctx.Data["IsTemplate"] = template
|
|
|
|
|
|
|
|
private := ctx.FormOptionalBool("private")
|
|
|
|
ctx.Data["IsPrivate"] = private
|
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
repos, count, err := repo_model.SearchRepository(ctx, &repo_model.SearchRepoOptions{
|
2022-09-29 21:09:14 +02:00
|
|
|
ListOptions: db.ListOptions{
|
|
|
|
PageSize: setting.UI.User.RepoPagingNum,
|
|
|
|
Page: page,
|
|
|
|
},
|
2022-11-19 09:12:33 +01:00
|
|
|
Actor: ctx.Doer,
|
2023-03-21 02:07:14 +01:00
|
|
|
Keyword: keyword,
|
2022-09-29 21:09:14 +02:00
|
|
|
OrderBy: orderBy,
|
2022-11-19 09:12:33 +01:00
|
|
|
Private: ctx.IsSigned,
|
|
|
|
WatchedByID: ctx.Doer.ID,
|
2024-02-29 19:52:49 +01:00
|
|
|
Collaborate: optional.Some(false),
|
2022-11-19 09:12:33 +01:00
|
|
|
TopicOnly: ctx.FormBool("topic"),
|
2022-09-29 21:09:14 +02:00
|
|
|
IncludeDescription: setting.UI.SearchRepoDescription,
|
2024-03-03 11:18:34 +01:00
|
|
|
Archived: archived,
|
|
|
|
Fork: fork,
|
|
|
|
Mirror: mirror,
|
|
|
|
Template: template,
|
|
|
|
IsPrivate: private,
|
2022-09-29 21:09:14 +02:00
|
|
|
})
|
|
|
|
if err != nil {
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.ServerError("SearchRepository", err)
|
2022-09-29 21:09:14 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
total := int(count)
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["Total"] = total
|
|
|
|
ctx.Data["Repos"] = repos
|
2022-09-29 21:09:14 +02:00
|
|
|
|
|
|
|
// redirect to last page if request page is more than total pages
|
|
|
|
pager := context.NewPagination(total, setting.UI.User.RepoPagingNum, page, 5)
|
2022-11-19 09:12:33 +01:00
|
|
|
pager.SetDefaultParams(ctx)
|
|
|
|
ctx.Data["Page"] = pager
|
2022-09-29 21:09:14 +02:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.Data["Status"] = 2
|
|
|
|
ctx.Data["Title"] = ctx.Tr("notification.watching")
|
2022-09-29 21:09:14 +02:00
|
|
|
|
2022-11-19 09:12:33 +01:00
|
|
|
ctx.HTML(http.StatusOK, tplNotificationSubscriptions)
|
2022-09-29 21:09:14 +02:00
|
|
|
}
|
|
|
|
|
2022-04-07 20:59:56 +02:00
|
|
|
// NewAvailable returns the notification counts
|
2022-05-03 23:38:34 +02:00
|
|
|
func NewAvailable(ctx *context.Context) {
|
2023-11-24 04:49:41 +01:00
|
|
|
total, err := db.Count[activities_model.Notification](ctx, activities_model.FindNotificationOptions{
|
|
|
|
UserID: ctx.Doer.ID,
|
|
|
|
Status: []activities_model.NotificationStatus{activities_model.NotificationStatusUnread},
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
log.Error("db.Count[activities_model.Notification]", err)
|
|
|
|
ctx.JSON(http.StatusOK, structs.NotificationCount{New: 0})
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.JSON(http.StatusOK, structs.NotificationCount{New: total})
|
2022-04-07 20:59:56 +02:00
|
|
|
}
|