mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-10-31 22:38:58 +00:00
ce8b30be13
- Add the ability to block a user via their profile page. - This will unstar their repositories and visa versa. - Blocked users cannot create issues or pull requests on your the doer's repositories (mind that this is not the case for organizations). - Blocked users cannot comment on the doer's opened issues or pull requests. - Blocked users cannot add reactions to doer's comments. - Blocked users cannot cause a notification trough mentioning the doer. Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/540 (cherry picked from commit687d852480
) (cherry picked from commit0c32a4fde5
) (cherry picked from commit1791130e3c
) (cherry picked from commit37858b7e8f
) (cherry picked from commita3e2bfd7e9
) (cherry picked from commit7009b9fe87
) Conflicts: https://codeberg.org/forgejo/forgejo/pulls/1014 routers/web/user/profile.go templates/user/profile.tmpl (cherry picked from commitb2aec34791
) (cherry picked from commite2f1b73752
) [MODERATION] organization blocking a user (#802) - Resolves #476 - Follow up for: #540 - Ensure that the doer and blocked person cannot follow each other. - Ensure that the block person cannot watch doer's repositories. - Add unblock button to the blocked user list. - Add blocked since information to the blocked user list. - Add extra testing to moderation code. - Blocked user will unwatch doer's owned repository upon blocking. - Add flash messages to let the user know the block/unblock action was successful. - Add "You haven't blocked any users" message. - Add organization blocking a user. Co-authored-by: Gusted <postmaster@gusted.xyz> Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/802 (cherry picked from commit0505a10421
) (cherry picked from commit37b4e6ef9b
) (cherry picked from commitc17c121f2c
) [MODERATION] organization blocking a user (#802) (squash) Changes to adapt to:6bbccdd177
Improve AJAX link and modal confirm dialog (#25210) Refs: https://codeberg.org/forgejo/forgejo/pulls/882/files#issuecomment-945962 Refs: https://codeberg.org/forgejo/forgejo/pulls/882#issue-330561 (cherry picked from commit523635f83c
) (cherry picked from commit4743eaa6a0
) (cherry picked from commiteff5b43d2e
) Conflicts: https://codeberg.org/forgejo/forgejo/pulls/1014 routers/web/user/profile.go (cherry picked from commit9d359be5ed
) (cherry picked from commitb1f3069a22
) [MODERATION] add user blocking API - Follow up for: #540, #802 - Add API routes for user blocking from user and organization perspective. - The new routes have integration testing. - The new model functions have unit tests. - Actually quite boring to write and to read this pull request. (cherry picked from commitf3afaf15c7
) (cherry picked from commit6d754db3e5
) (cherry picked from commit2a89ddc0ac
) (cherry picked from commit4a147bff7e
) Conflicts: routers/api/v1/api.go templates/swagger/v1_json.tmpl (cherry picked from commitbb8c339185
) (cherry picked from commit5a11569a01
) (cherry picked from commit2373c801ee
) [MODERATION] restore redirect on unblock ctx.RedirectToFirst(ctx.FormString("redirect_to"), ctx.ContextUser.HomeLink()) was replaced by ctx.JSONOK() in128d77a3a
Following up fixes for "Fix inconsistent user profile layout across tabs" (#25739) thus changing the behavior (nicely spotted by the tests). This restores it. (cherry picked from commit597c243707
) (cherry picked from commitcfa539e590
) [MODERATION] Add test case (squash) - Add an test case, to test an property of the function. (cherry picked from commit70dadb1916
) [MODERATION] Block adding collaborators - Ensure that the doer and blocked user cannot add each other as collaborators to repositories. - The Web UI gets an detailed message of the specific situation, the API gets an generic Forbidden code. - Unit tests has been added. - Integration testing for Web and API has been added. - This commit doesn't introduce removing each other as collaborators on the block action, due to the complexity of database calls that needs to be figured out. That deserves its own commit and test code. (cherry picked from commit747be949a1
) [MODERATION] move locale_en-US.ini strings to avoid conflicts Conflicts: web_src/css/org.css web_src/css/user.css https://codeberg.org/forgejo/forgejo/pulls/1180 (cherry picked from commite53f955c88
) Conflicts: services/issue/comments.go https://codeberg.org/forgejo/forgejo/pulls/1212 (cherry picked from commitb4a454b576
) Conflicts: models/forgejo_migrations/migrate.go options/locale/locale_en-US.ini services/pull/pull.go https://codeberg.org/forgejo/forgejo/pulls/1264 [MODERATION] Remove blocked user collaborations with doer - When the doer blocks an user, who is also an collaborator on an repository that the doer owns, remove that collaboration. - Added unit tests. - Refactor the unit test to be more organized. (cherry picked from commitec87016178
) (cherry picked from commit313e6174d8
) [MODERATION] QoL improvements (squash) - Ensure that organisations cannot be blocked. It currently has no effect, as all blocked operations cannot be executed from an organisation standpoint. - Refactored the API route to make use of the `UserAssignmentAPI` middleware. - Make more use of `t.Run` so that the test code is more clear about which block of code belongs to which test case. - Added more integration testing (to ensure the organisations cannot be blocked and some authorization/permission checks). (cherry picked from commite9d638d075
) [MODERATION] s/{{avatar/{{ctx.AvatarUtils.Avatar/
738 lines
22 KiB
Go
738 lines
22 KiB
Go
// Copyright 2014 The Gogs Authors. All rights reserved.
|
|
// Copyright 2019 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package activities
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/url"
|
|
"path"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"code.gitea.io/gitea/models/db"
|
|
issues_model "code.gitea.io/gitea/models/issues"
|
|
"code.gitea.io/gitea/models/organization"
|
|
access_model "code.gitea.io/gitea/models/perm/access"
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
|
"code.gitea.io/gitea/models/unit"
|
|
user_model "code.gitea.io/gitea/models/user"
|
|
"code.gitea.io/gitea/modules/base"
|
|
"code.gitea.io/gitea/modules/git"
|
|
"code.gitea.io/gitea/modules/log"
|
|
"code.gitea.io/gitea/modules/setting"
|
|
"code.gitea.io/gitea/modules/structs"
|
|
"code.gitea.io/gitea/modules/timeutil"
|
|
|
|
"xorm.io/builder"
|
|
"xorm.io/xorm/schemas"
|
|
)
|
|
|
|
// ActionType represents the type of an action.
|
|
type ActionType int
|
|
|
|
// Possible action types.
|
|
const (
|
|
ActionCreateRepo ActionType = iota + 1 // 1
|
|
ActionRenameRepo // 2
|
|
ActionStarRepo // 3
|
|
ActionWatchRepo // 4
|
|
ActionCommitRepo // 5
|
|
ActionCreateIssue // 6
|
|
ActionCreatePullRequest // 7
|
|
ActionTransferRepo // 8
|
|
ActionPushTag // 9
|
|
ActionCommentIssue // 10
|
|
ActionMergePullRequest // 11
|
|
ActionCloseIssue // 12
|
|
ActionReopenIssue // 13
|
|
ActionClosePullRequest // 14
|
|
ActionReopenPullRequest // 15
|
|
ActionDeleteTag // 16
|
|
ActionDeleteBranch // 17
|
|
ActionMirrorSyncPush // 18
|
|
ActionMirrorSyncCreate // 19
|
|
ActionMirrorSyncDelete // 20
|
|
ActionApprovePullRequest // 21
|
|
ActionRejectPullRequest // 22
|
|
ActionCommentPull // 23
|
|
ActionPublishRelease // 24
|
|
ActionPullReviewDismissed // 25
|
|
ActionPullRequestReadyForReview // 26
|
|
ActionAutoMergePullRequest // 27
|
|
)
|
|
|
|
func (at ActionType) String() string {
|
|
switch at {
|
|
case ActionCreateRepo:
|
|
return "create_repo"
|
|
case ActionRenameRepo:
|
|
return "rename_repo"
|
|
case ActionStarRepo:
|
|
return "star_repo"
|
|
case ActionWatchRepo:
|
|
return "watch_repo"
|
|
case ActionCommitRepo:
|
|
return "commit_repo"
|
|
case ActionCreateIssue:
|
|
return "create_issue"
|
|
case ActionCreatePullRequest:
|
|
return "create_pull_request"
|
|
case ActionTransferRepo:
|
|
return "transfer_repo"
|
|
case ActionPushTag:
|
|
return "push_tag"
|
|
case ActionCommentIssue:
|
|
return "comment_issue"
|
|
case ActionMergePullRequest:
|
|
return "merge_pull_request"
|
|
case ActionCloseIssue:
|
|
return "close_issue"
|
|
case ActionReopenIssue:
|
|
return "reopen_issue"
|
|
case ActionClosePullRequest:
|
|
return "close_pull_request"
|
|
case ActionReopenPullRequest:
|
|
return "reopen_pull_request"
|
|
case ActionDeleteTag:
|
|
return "delete_tag"
|
|
case ActionDeleteBranch:
|
|
return "delete_branch"
|
|
case ActionMirrorSyncPush:
|
|
return "mirror_sync_push"
|
|
case ActionMirrorSyncCreate:
|
|
return "mirror_sync_create"
|
|
case ActionMirrorSyncDelete:
|
|
return "mirror_sync_delete"
|
|
case ActionApprovePullRequest:
|
|
return "approve_pull_request"
|
|
case ActionRejectPullRequest:
|
|
return "reject_pull_request"
|
|
case ActionCommentPull:
|
|
return "comment_pull"
|
|
case ActionPublishRelease:
|
|
return "publish_release"
|
|
case ActionPullReviewDismissed:
|
|
return "pull_review_dismissed"
|
|
case ActionPullRequestReadyForReview:
|
|
return "pull_request_ready_for_review"
|
|
case ActionAutoMergePullRequest:
|
|
return "auto_merge_pull_request"
|
|
default:
|
|
return "action-" + strconv.Itoa(int(at))
|
|
}
|
|
}
|
|
|
|
// Action represents user operation type and other information to
|
|
// repository. It implemented interface base.Actioner so that can be
|
|
// used in template render.
|
|
type Action struct {
|
|
ID int64 `xorm:"pk autoincr"`
|
|
UserID int64 // Receiver user id.
|
|
OpType ActionType
|
|
ActUserID int64 // Action user id.
|
|
ActUser *user_model.User `xorm:"-"`
|
|
RepoID int64
|
|
Repo *repo_model.Repository `xorm:"-"`
|
|
CommentID int64 `xorm:"INDEX"`
|
|
Comment *issues_model.Comment `xorm:"-"`
|
|
IsDeleted bool `xorm:"NOT NULL DEFAULT false"`
|
|
RefName string
|
|
IsPrivate bool `xorm:"NOT NULL DEFAULT false"`
|
|
Content string `xorm:"TEXT"`
|
|
CreatedUnix timeutil.TimeStamp `xorm:"created"`
|
|
}
|
|
|
|
func init() {
|
|
db.RegisterModel(new(Action))
|
|
}
|
|
|
|
// TableIndices implements xorm's TableIndices interface
|
|
func (a *Action) TableIndices() []*schemas.Index {
|
|
repoIndex := schemas.NewIndex("r_u_d", schemas.IndexType)
|
|
repoIndex.AddColumn("repo_id", "user_id", "is_deleted")
|
|
|
|
actUserIndex := schemas.NewIndex("au_r_c_u_d", schemas.IndexType)
|
|
actUserIndex.AddColumn("act_user_id", "repo_id", "created_unix", "user_id", "is_deleted")
|
|
|
|
cudIndex := schemas.NewIndex("c_u_d", schemas.IndexType)
|
|
cudIndex.AddColumn("created_unix", "user_id", "is_deleted")
|
|
|
|
indices := []*schemas.Index{actUserIndex, repoIndex, cudIndex}
|
|
|
|
return indices
|
|
}
|
|
|
|
// GetOpType gets the ActionType of this action.
|
|
func (a *Action) GetOpType() ActionType {
|
|
return a.OpType
|
|
}
|
|
|
|
// LoadActUser loads a.ActUser
|
|
func (a *Action) LoadActUser(ctx context.Context) {
|
|
if a.ActUser != nil {
|
|
return
|
|
}
|
|
var err error
|
|
a.ActUser, err = user_model.GetUserByID(ctx, a.ActUserID)
|
|
if err == nil {
|
|
return
|
|
} else if user_model.IsErrUserNotExist(err) {
|
|
a.ActUser = user_model.NewGhostUser()
|
|
} else {
|
|
log.Error("GetUserByID(%d): %v", a.ActUserID, err)
|
|
}
|
|
}
|
|
|
|
func (a *Action) loadRepo(ctx context.Context) {
|
|
if a.Repo != nil {
|
|
return
|
|
}
|
|
var err error
|
|
a.Repo, err = repo_model.GetRepositoryByID(ctx, a.RepoID)
|
|
if err != nil {
|
|
log.Error("repo_model.GetRepositoryByID(%d): %v", a.RepoID, err)
|
|
}
|
|
}
|
|
|
|
// GetActFullName gets the action's user full name.
|
|
func (a *Action) GetActFullName() string {
|
|
a.LoadActUser(db.DefaultContext)
|
|
return a.ActUser.FullName
|
|
}
|
|
|
|
// GetActUserName gets the action's user name.
|
|
func (a *Action) GetActUserName() string {
|
|
a.LoadActUser(db.DefaultContext)
|
|
return a.ActUser.Name
|
|
}
|
|
|
|
// ShortActUserName gets the action's user name trimmed to max 20
|
|
// chars.
|
|
func (a *Action) ShortActUserName() string {
|
|
return base.EllipsisString(a.GetActUserName(), 20)
|
|
}
|
|
|
|
// GetDisplayName gets the action's display name based on DEFAULT_SHOW_FULL_NAME, or falls back to the username if it is blank.
|
|
func (a *Action) GetDisplayName() string {
|
|
if setting.UI.DefaultShowFullName {
|
|
trimmedFullName := strings.TrimSpace(a.GetActFullName())
|
|
if len(trimmedFullName) > 0 {
|
|
return trimmedFullName
|
|
}
|
|
}
|
|
return a.ShortActUserName()
|
|
}
|
|
|
|
// GetDisplayNameTitle gets the action's display name used for the title (tooltip) based on DEFAULT_SHOW_FULL_NAME
|
|
func (a *Action) GetDisplayNameTitle() string {
|
|
if setting.UI.DefaultShowFullName {
|
|
return a.ShortActUserName()
|
|
}
|
|
return a.GetActFullName()
|
|
}
|
|
|
|
// GetRepoUserName returns the name of the action repository owner.
|
|
func (a *Action) GetRepoUserName() string {
|
|
a.loadRepo(db.DefaultContext)
|
|
return a.Repo.OwnerName
|
|
}
|
|
|
|
// ShortRepoUserName returns the name of the action repository owner
|
|
// trimmed to max 20 chars.
|
|
func (a *Action) ShortRepoUserName() string {
|
|
return base.EllipsisString(a.GetRepoUserName(), 20)
|
|
}
|
|
|
|
// GetRepoName returns the name of the action repository.
|
|
func (a *Action) GetRepoName() string {
|
|
a.loadRepo(db.DefaultContext)
|
|
return a.Repo.Name
|
|
}
|
|
|
|
// ShortRepoName returns the name of the action repository
|
|
// trimmed to max 33 chars.
|
|
func (a *Action) ShortRepoName() string {
|
|
return base.EllipsisString(a.GetRepoName(), 33)
|
|
}
|
|
|
|
// GetRepoPath returns the virtual path to the action repository.
|
|
func (a *Action) GetRepoPath() string {
|
|
return path.Join(a.GetRepoUserName(), a.GetRepoName())
|
|
}
|
|
|
|
// ShortRepoPath returns the virtual path to the action repository
|
|
// trimmed to max 20 + 1 + 33 chars.
|
|
func (a *Action) ShortRepoPath() string {
|
|
return path.Join(a.ShortRepoUserName(), a.ShortRepoName())
|
|
}
|
|
|
|
// GetRepoLink returns relative link to action repository.
|
|
func (a *Action) GetRepoLink() string {
|
|
// path.Join will skip empty strings
|
|
return path.Join(setting.AppSubURL, "/", url.PathEscape(a.GetRepoUserName()), url.PathEscape(a.GetRepoName()))
|
|
}
|
|
|
|
// GetRepoAbsoluteLink returns the absolute link to action repository.
|
|
func (a *Action) GetRepoAbsoluteLink() string {
|
|
return setting.AppURL + url.PathEscape(a.GetRepoUserName()) + "/" + url.PathEscape(a.GetRepoName())
|
|
}
|
|
|
|
// GetCommentHTMLURL returns link to action comment.
|
|
func (a *Action) GetCommentHTMLURL() string {
|
|
return a.getCommentHTMLURL(db.DefaultContext)
|
|
}
|
|
|
|
func (a *Action) loadComment(ctx context.Context) (err error) {
|
|
if a.CommentID == 0 || a.Comment != nil {
|
|
return nil
|
|
}
|
|
a.Comment, err = issues_model.GetCommentByID(ctx, a.CommentID)
|
|
return err
|
|
}
|
|
|
|
func (a *Action) getCommentHTMLURL(ctx context.Context) string {
|
|
if a == nil {
|
|
return "#"
|
|
}
|
|
_ = a.loadComment(ctx)
|
|
if a.Comment != nil {
|
|
return a.Comment.HTMLURL()
|
|
}
|
|
if len(a.GetIssueInfos()) == 0 {
|
|
return "#"
|
|
}
|
|
// Return link to issue
|
|
issueIDString := a.GetIssueInfos()[0]
|
|
issueID, err := strconv.ParseInt(issueIDString, 10, 64)
|
|
if err != nil {
|
|
return "#"
|
|
}
|
|
|
|
issue, err := issues_model.GetIssueByID(ctx, issueID)
|
|
if err != nil {
|
|
return "#"
|
|
}
|
|
|
|
if err = issue.LoadRepo(ctx); err != nil {
|
|
return "#"
|
|
}
|
|
|
|
return issue.HTMLURL()
|
|
}
|
|
|
|
// GetCommentLink returns link to action comment.
|
|
func (a *Action) GetCommentLink() string {
|
|
return a.getCommentLink(db.DefaultContext)
|
|
}
|
|
|
|
func (a *Action) getCommentLink(ctx context.Context) string {
|
|
if a == nil {
|
|
return "#"
|
|
}
|
|
_ = a.loadComment(ctx)
|
|
if a.Comment != nil {
|
|
return a.Comment.Link()
|
|
}
|
|
if len(a.GetIssueInfos()) == 0 {
|
|
return "#"
|
|
}
|
|
// Return link to issue
|
|
issueIDString := a.GetIssueInfos()[0]
|
|
issueID, err := strconv.ParseInt(issueIDString, 10, 64)
|
|
if err != nil {
|
|
return "#"
|
|
}
|
|
|
|
issue, err := issues_model.GetIssueByID(ctx, issueID)
|
|
if err != nil {
|
|
return "#"
|
|
}
|
|
|
|
if err = issue.LoadRepo(ctx); err != nil {
|
|
return "#"
|
|
}
|
|
|
|
return issue.Link()
|
|
}
|
|
|
|
// GetBranch returns the action's repository branch.
|
|
func (a *Action) GetBranch() string {
|
|
return strings.TrimPrefix(a.RefName, git.BranchPrefix)
|
|
}
|
|
|
|
// GetRefLink returns the action's ref link.
|
|
func (a *Action) GetRefLink() string {
|
|
return git.RefURL(a.GetRepoLink(), a.RefName)
|
|
}
|
|
|
|
// GetTag returns the action's repository tag.
|
|
func (a *Action) GetTag() string {
|
|
return strings.TrimPrefix(a.RefName, git.TagPrefix)
|
|
}
|
|
|
|
// GetContent returns the action's content.
|
|
func (a *Action) GetContent() string {
|
|
return a.Content
|
|
}
|
|
|
|
// GetCreate returns the action creation time.
|
|
func (a *Action) GetCreate() time.Time {
|
|
return a.CreatedUnix.AsTime()
|
|
}
|
|
|
|
// GetIssueInfos returns a list of issues associated with
|
|
// the action.
|
|
func (a *Action) GetIssueInfos() []string {
|
|
return strings.SplitN(a.Content, "|", 3)
|
|
}
|
|
|
|
// GetIssueTitle returns the title of first issue associated
|
|
// with the action. This function will be invoked in template so keep db.DefaultContext here
|
|
func (a *Action) GetIssueTitle() string {
|
|
index, _ := strconv.ParseInt(a.GetIssueInfos()[0], 10, 64)
|
|
issue, err := issues_model.GetIssueByIndex(db.DefaultContext, a.RepoID, index)
|
|
if err != nil {
|
|
log.Error("GetIssueByIndex: %v", err)
|
|
return "500 when get issue"
|
|
}
|
|
return issue.Title
|
|
}
|
|
|
|
// GetIssueContent returns the content of first issue associated with
|
|
// this action.
|
|
func (a *Action) GetIssueContent(ctx context.Context) string {
|
|
index, _ := strconv.ParseInt(a.GetIssueInfos()[0], 10, 64)
|
|
issue, err := issues_model.GetIssueByIndex(ctx, a.RepoID, index)
|
|
if err != nil {
|
|
log.Error("GetIssueByIndex: %v", err)
|
|
return "500 when get issue"
|
|
}
|
|
return issue.Content
|
|
}
|
|
|
|
// GetFeedsOptions options for retrieving feeds
|
|
type GetFeedsOptions struct {
|
|
db.ListOptions
|
|
RequestedUser *user_model.User // the user we want activity for
|
|
RequestedTeam *organization.Team // the team we want activity for
|
|
RequestedRepo *repo_model.Repository // the repo we want activity for
|
|
Actor *user_model.User // the user viewing the activity
|
|
IncludePrivate bool // include private actions
|
|
OnlyPerformedBy bool // only actions performed by requested user
|
|
IncludeDeleted bool // include deleted actions
|
|
Date string // the day we want activity for: YYYY-MM-DD
|
|
}
|
|
|
|
// GetFeeds returns actions according to the provided options
|
|
func GetFeeds(ctx context.Context, opts GetFeedsOptions) (ActionList, int64, error) {
|
|
if opts.RequestedUser == nil && opts.RequestedTeam == nil && opts.RequestedRepo == nil {
|
|
return nil, 0, fmt.Errorf("need at least one of these filters: RequestedUser, RequestedTeam, RequestedRepo")
|
|
}
|
|
|
|
cond, err := activityQueryCondition(opts)
|
|
if err != nil {
|
|
return nil, 0, err
|
|
}
|
|
|
|
sess := db.GetEngine(ctx).Where(cond).
|
|
Select("`action`.*"). // this line will avoid select other joined table's columns
|
|
Join("INNER", "repository", "`repository`.id = `action`.repo_id")
|
|
|
|
opts.SetDefaultValues()
|
|
sess = db.SetSessionPagination(sess, &opts)
|
|
|
|
actions := make([]*Action, 0, opts.PageSize)
|
|
count, err := sess.Desc("`action`.created_unix").FindAndCount(&actions)
|
|
if err != nil {
|
|
return nil, 0, fmt.Errorf("FindAndCount: %w", err)
|
|
}
|
|
|
|
if err := ActionList(actions).loadAttributes(ctx); err != nil {
|
|
return nil, 0, fmt.Errorf("LoadAttributes: %w", err)
|
|
}
|
|
|
|
return actions, count, nil
|
|
}
|
|
|
|
// ActivityReadable return whether doer can read activities of user
|
|
func ActivityReadable(user, doer *user_model.User) bool {
|
|
return !user.KeepActivityPrivate ||
|
|
doer != nil && (doer.IsAdmin || user.ID == doer.ID)
|
|
}
|
|
|
|
func activityQueryCondition(opts GetFeedsOptions) (builder.Cond, error) {
|
|
cond := builder.NewCond()
|
|
|
|
if opts.RequestedTeam != nil && opts.RequestedUser == nil {
|
|
org, err := user_model.GetUserByID(db.DefaultContext, opts.RequestedTeam.OrgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
opts.RequestedUser = org
|
|
}
|
|
|
|
// check activity visibility for actor ( similar to activityReadable() )
|
|
if opts.Actor == nil {
|
|
cond = cond.And(builder.In("act_user_id",
|
|
builder.Select("`user`.id").Where(
|
|
builder.Eq{"keep_activity_private": false, "visibility": structs.VisibleTypePublic},
|
|
).From("`user`"),
|
|
))
|
|
} else if !opts.Actor.IsAdmin {
|
|
uidCond := builder.Select("`user`.id").From("`user`").Where(
|
|
builder.Eq{"keep_activity_private": false}.
|
|
And(builder.In("visibility", structs.VisibleTypePublic, structs.VisibleTypeLimited))).
|
|
Or(builder.Eq{"id": opts.Actor.ID})
|
|
|
|
if opts.RequestedUser != nil {
|
|
if opts.RequestedUser.IsOrganization() {
|
|
// An organization can always see the activities whose `act_user_id` is the same as its id.
|
|
uidCond = uidCond.Or(builder.Eq{"id": opts.RequestedUser.ID})
|
|
} else {
|
|
// A user can always see the activities of the organizations to which the user belongs.
|
|
uidCond = uidCond.Or(
|
|
builder.Eq{"type": user_model.UserTypeOrganization}.
|
|
And(builder.In("`user`.id", builder.Select("org_id").
|
|
Where(builder.Eq{"uid": opts.RequestedUser.ID}).
|
|
From("team_user"))),
|
|
)
|
|
}
|
|
}
|
|
|
|
cond = cond.And(builder.In("act_user_id", uidCond))
|
|
}
|
|
|
|
// check readable repositories by doer/actor
|
|
if opts.Actor == nil || !opts.Actor.IsAdmin {
|
|
cond = cond.And(builder.In("repo_id", repo_model.AccessibleRepoIDsQuery(opts.Actor)))
|
|
}
|
|
|
|
if opts.RequestedRepo != nil {
|
|
cond = cond.And(builder.Eq{"repo_id": opts.RequestedRepo.ID})
|
|
}
|
|
|
|
if opts.RequestedTeam != nil {
|
|
env := organization.OrgFromUser(opts.RequestedUser).AccessibleTeamReposEnv(opts.RequestedTeam)
|
|
teamRepoIDs, err := env.RepoIDs(1, opts.RequestedUser.NumRepos)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("GetTeamRepositories: %w", err)
|
|
}
|
|
cond = cond.And(builder.In("repo_id", teamRepoIDs))
|
|
}
|
|
|
|
if opts.RequestedUser != nil {
|
|
cond = cond.And(builder.Eq{"user_id": opts.RequestedUser.ID})
|
|
|
|
if opts.OnlyPerformedBy {
|
|
cond = cond.And(builder.Eq{"act_user_id": opts.RequestedUser.ID})
|
|
}
|
|
}
|
|
|
|
if !opts.IncludePrivate {
|
|
cond = cond.And(builder.Eq{"`action`.is_private": false})
|
|
}
|
|
if !opts.IncludeDeleted {
|
|
cond = cond.And(builder.Eq{"is_deleted": false})
|
|
}
|
|
|
|
if opts.Date != "" {
|
|
dateLow, err := time.ParseInLocation("2006-01-02", opts.Date, setting.DefaultUILocation)
|
|
if err != nil {
|
|
log.Warn("Unable to parse %s, filter not applied: %v", opts.Date, err)
|
|
} else {
|
|
dateHigh := dateLow.Add(86399000000000) // 23h59m59s
|
|
|
|
cond = cond.And(builder.Gte{"`action`.created_unix": dateLow.Unix()})
|
|
cond = cond.And(builder.Lte{"`action`.created_unix": dateHigh.Unix()})
|
|
}
|
|
}
|
|
|
|
return cond, nil
|
|
}
|
|
|
|
// DeleteOldActions deletes all old actions from database.
|
|
func DeleteOldActions(olderThan time.Duration) (err error) {
|
|
if olderThan <= 0 {
|
|
return nil
|
|
}
|
|
|
|
_, err = db.GetEngine(db.DefaultContext).Where("created_unix < ?", time.Now().Add(-olderThan).Unix()).Delete(&Action{})
|
|
return err
|
|
}
|
|
|
|
// NotifyWatchers creates batch of actions for every watcher.
|
|
func NotifyWatchers(ctx context.Context, actions ...*Action) error {
|
|
var watchers []*repo_model.Watch
|
|
var repo *repo_model.Repository
|
|
var err error
|
|
var permCode []bool
|
|
var permIssue []bool
|
|
var permPR []bool
|
|
|
|
e := db.GetEngine(ctx)
|
|
|
|
for _, act := range actions {
|
|
repoChanged := repo == nil || repo.ID != act.RepoID
|
|
|
|
if repoChanged {
|
|
// Add feeds for user self and all watchers.
|
|
watchers, err = repo_model.GetWatchersExcludeBlocked(ctx, act.RepoID, act.ActUserID)
|
|
if err != nil {
|
|
return fmt.Errorf("get watchers: %w", err)
|
|
}
|
|
}
|
|
|
|
// Add feed for actioner.
|
|
act.UserID = act.ActUserID
|
|
if _, err = e.Insert(act); err != nil {
|
|
return fmt.Errorf("insert new actioner: %w", err)
|
|
}
|
|
|
|
if repoChanged {
|
|
act.loadRepo(ctx)
|
|
repo = act.Repo
|
|
|
|
// check repo owner exist.
|
|
if err := act.Repo.LoadOwner(ctx); err != nil {
|
|
return fmt.Errorf("can't get repo owner: %w", err)
|
|
}
|
|
} else if act.Repo == nil {
|
|
act.Repo = repo
|
|
}
|
|
|
|
// Add feed for organization
|
|
if act.Repo.Owner.IsOrganization() && act.ActUserID != act.Repo.Owner.ID {
|
|
act.ID = 0
|
|
act.UserID = act.Repo.Owner.ID
|
|
if err = db.Insert(ctx, act); err != nil {
|
|
return fmt.Errorf("insert new actioner: %w", err)
|
|
}
|
|
}
|
|
|
|
if repoChanged {
|
|
permCode = make([]bool, len(watchers))
|
|
permIssue = make([]bool, len(watchers))
|
|
permPR = make([]bool, len(watchers))
|
|
for i, watcher := range watchers {
|
|
user, err := user_model.GetUserByID(ctx, watcher.UserID)
|
|
if err != nil {
|
|
permCode[i] = false
|
|
permIssue[i] = false
|
|
permPR[i] = false
|
|
continue
|
|
}
|
|
perm, err := access_model.GetUserRepoPermission(ctx, repo, user)
|
|
if err != nil {
|
|
permCode[i] = false
|
|
permIssue[i] = false
|
|
permPR[i] = false
|
|
continue
|
|
}
|
|
permCode[i] = perm.CanRead(unit.TypeCode)
|
|
permIssue[i] = perm.CanRead(unit.TypeIssues)
|
|
permPR[i] = perm.CanRead(unit.TypePullRequests)
|
|
}
|
|
}
|
|
|
|
for i, watcher := range watchers {
|
|
if act.ActUserID == watcher.UserID {
|
|
continue
|
|
}
|
|
act.ID = 0
|
|
act.UserID = watcher.UserID
|
|
act.Repo.Units = nil
|
|
|
|
switch act.OpType {
|
|
case ActionCommitRepo, ActionPushTag, ActionDeleteTag, ActionPublishRelease, ActionDeleteBranch:
|
|
if !permCode[i] {
|
|
continue
|
|
}
|
|
case ActionCreateIssue, ActionCommentIssue, ActionCloseIssue, ActionReopenIssue:
|
|
if !permIssue[i] {
|
|
continue
|
|
}
|
|
case ActionCreatePullRequest, ActionCommentPull, ActionMergePullRequest, ActionClosePullRequest, ActionReopenPullRequest, ActionAutoMergePullRequest:
|
|
if !permPR[i] {
|
|
continue
|
|
}
|
|
}
|
|
|
|
if err = db.Insert(ctx, act); err != nil {
|
|
return fmt.Errorf("insert new action: %w", err)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// NotifyWatchersActions creates batch of actions for every watcher.
|
|
func NotifyWatchersActions(acts []*Action) error {
|
|
ctx, committer, err := db.TxContext(db.DefaultContext)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer committer.Close()
|
|
for _, act := range acts {
|
|
if err := NotifyWatchers(ctx, act); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return committer.Commit()
|
|
}
|
|
|
|
// DeleteIssueActions delete all actions related with issueID
|
|
func DeleteIssueActions(ctx context.Context, repoID, issueID, issueIndex int64) error {
|
|
// delete actions assigned to this issue
|
|
e := db.GetEngine(ctx)
|
|
|
|
// MariaDB has a performance bug: https://jira.mariadb.org/browse/MDEV-16289
|
|
// so here it uses "DELETE ... WHERE IN" with pre-queried IDs.
|
|
var lastCommentID int64
|
|
commentIDs := make([]int64, 0, db.DefaultMaxInSize)
|
|
for {
|
|
commentIDs = commentIDs[:0]
|
|
err := e.Select("`id`").Table(&issues_model.Comment{}).
|
|
Where(builder.Eq{"issue_id": issueID}).And("`id` > ?", lastCommentID).
|
|
OrderBy("`id`").Limit(db.DefaultMaxInSize).
|
|
Find(&commentIDs)
|
|
if err != nil {
|
|
return err
|
|
} else if len(commentIDs) == 0 {
|
|
break
|
|
} else if _, err = db.GetEngine(ctx).In("comment_id", commentIDs).Delete(&Action{}); err != nil {
|
|
return err
|
|
} else {
|
|
lastCommentID = commentIDs[len(commentIDs)-1]
|
|
}
|
|
}
|
|
|
|
_, err := e.Where("repo_id = ?", repoID).
|
|
In("op_type", ActionCreateIssue, ActionCreatePullRequest).
|
|
Where("content LIKE ?", strconv.FormatInt(issueIndex, 10)+"|%"). // "IssueIndex|content..."
|
|
Delete(&Action{})
|
|
return err
|
|
}
|
|
|
|
// CountActionCreatedUnixString count actions where created_unix is an empty string
|
|
func CountActionCreatedUnixString(ctx context.Context) (int64, error) {
|
|
if setting.Database.Type.IsSQLite3() {
|
|
return db.GetEngine(ctx).Where(`created_unix = ""`).Count(new(Action))
|
|
}
|
|
return 0, nil
|
|
}
|
|
|
|
// FixActionCreatedUnixString set created_unix to zero if it is an empty string
|
|
func FixActionCreatedUnixString(ctx context.Context) (int64, error) {
|
|
if setting.Database.Type.IsSQLite3() {
|
|
res, err := db.GetEngine(ctx).Exec(`UPDATE action SET created_unix = 0 WHERE created_unix = ""`)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return res.RowsAffected()
|
|
}
|
|
return 0, nil
|
|
}
|