2014-08-14 15:12:21 +09:00
|
|
|
// Copyright 2014 The Gogs Authors. All rights reserved.
|
2020-01-25 04:00:29 +09:00
|
|
|
// Copyright 2020 The Gitea Authors.
|
2022-11-28 03:20:29 +09:00
|
|
|
// SPDX-License-Identifier: MIT
|
2014-08-14 15:12:21 +09:00
|
|
|
|
2016-03-12 01:56:52 +09:00
|
|
|
package context
|
2014-08-14 15:12:21 +09:00
|
|
|
|
|
|
|
import (
|
2016-01-31 22:28:42 +09:00
|
|
|
"strings"
|
|
|
|
|
2022-03-29 15:29:02 +09:00
|
|
|
"code.gitea.io/gitea/models/organization"
|
2021-11-28 20:58:28 +09:00
|
|
|
"code.gitea.io/gitea/models/perm"
|
2023-01-20 20:42:33 +09:00
|
|
|
"code.gitea.io/gitea/models/unit"
|
2021-11-11 16:03:30 +09:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2023-01-20 20:42:33 +09:00
|
|
|
"code.gitea.io/gitea/modules/log"
|
2022-04-01 02:31:53 +09:00
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2022-07-15 23:21:54 +09:00
|
|
|
"code.gitea.io/gitea/modules/structs"
|
2014-08-14 15:12:21 +09:00
|
|
|
)
|
|
|
|
|
2016-11-25 15:51:01 +09:00
|
|
|
// Organization contains organization context
|
2016-03-14 06:37:44 +09:00
|
|
|
type Organization struct {
|
2019-11-20 20:27:49 +09:00
|
|
|
IsOwner bool
|
|
|
|
IsMember bool
|
|
|
|
IsTeamMember bool // Is member of team.
|
|
|
|
IsTeamAdmin bool // In owner team or team that has admin permission level.
|
2022-03-29 15:29:02 +09:00
|
|
|
Organization *organization.Organization
|
2019-11-20 20:27:49 +09:00
|
|
|
OrgLink string
|
|
|
|
CanCreateOrgRepo bool
|
2016-03-14 06:37:44 +09:00
|
|
|
|
2022-03-29 15:29:02 +09:00
|
|
|
Team *organization.Team
|
|
|
|
Teams []*organization.Team
|
2016-03-14 06:37:44 +09:00
|
|
|
}
|
|
|
|
|
2023-01-20 20:42:33 +09:00
|
|
|
func (org *Organization) CanWriteUnit(ctx *Context, unitType unit.Type) bool {
|
|
|
|
if ctx.Doer == nil {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
return org.UnitPermission(ctx, ctx.Doer.ID, unitType) >= perm.AccessModeWrite
|
|
|
|
}
|
|
|
|
|
|
|
|
func (org *Organization) UnitPermission(ctx *Context, doerID int64, unitType unit.Type) perm.AccessMode {
|
|
|
|
if doerID > 0 {
|
|
|
|
teams, err := organization.GetUserOrgTeams(ctx, org.Organization.ID, doerID)
|
|
|
|
if err != nil {
|
|
|
|
log.Error("GetUserOrgTeams: %v", err)
|
|
|
|
return perm.AccessModeNone
|
|
|
|
}
|
|
|
|
if len(teams) > 0 {
|
|
|
|
return teams.UnitMaxAccess(unitType)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if org.Organization.Visibility == structs.VisibleTypePublic {
|
|
|
|
return perm.AccessModeRead
|
|
|
|
}
|
|
|
|
|
|
|
|
return perm.AccessModeNone
|
|
|
|
}
|
|
|
|
|
2016-11-25 15:51:01 +09:00
|
|
|
// HandleOrgAssignment handles organization assignment
|
2015-11-25 09:14:00 +09:00
|
|
|
func HandleOrgAssignment(ctx *Context, args ...bool) {
|
|
|
|
var (
|
2016-01-31 22:28:42 +09:00
|
|
|
requireMember bool
|
|
|
|
requireOwner bool
|
|
|
|
requireTeamMember bool
|
2016-02-01 00:18:28 +09:00
|
|
|
requireTeamAdmin bool
|
2015-11-25 09:14:00 +09:00
|
|
|
)
|
|
|
|
if len(args) >= 1 {
|
|
|
|
requireMember = args[0]
|
|
|
|
}
|
|
|
|
if len(args) >= 2 {
|
|
|
|
requireOwner = args[1]
|
|
|
|
}
|
|
|
|
if len(args) >= 3 {
|
2016-01-31 22:28:42 +09:00
|
|
|
requireTeamMember = args[2]
|
|
|
|
}
|
|
|
|
if len(args) >= 4 {
|
2016-02-01 00:18:28 +09:00
|
|
|
requireTeamAdmin = args[3]
|
2015-11-25 09:14:00 +09:00
|
|
|
}
|
2014-08-14 15:12:21 +09:00
|
|
|
|
2015-11-25 09:14:00 +09:00
|
|
|
orgName := ctx.Params(":org")
|
2014-08-14 15:12:21 +09:00
|
|
|
|
2015-11-25 09:14:00 +09:00
|
|
|
var err error
|
2022-03-29 15:29:02 +09:00
|
|
|
ctx.Org.Organization, err = organization.GetOrgByName(orgName)
|
2015-11-25 09:14:00 +09:00
|
|
|
if err != nil {
|
2022-03-29 15:29:02 +09:00
|
|
|
if organization.IsErrOrgNotExist(err) {
|
2021-11-11 16:03:30 +09:00
|
|
|
redirectUserID, err := user_model.LookupUserRedirect(orgName)
|
2021-01-25 00:23:05 +09:00
|
|
|
if err == nil {
|
|
|
|
RedirectToUser(ctx, orgName, redirectUserID)
|
2021-11-11 16:03:30 +09:00
|
|
|
} else if user_model.IsErrUserRedirectNotExist(err) {
|
2021-01-25 00:23:05 +09:00
|
|
|
ctx.NotFound("GetUserByName", err)
|
|
|
|
} else {
|
|
|
|
ctx.ServerError("LookupUserRedirect", err)
|
|
|
|
}
|
2015-11-25 09:14:00 +09:00
|
|
|
} else {
|
2018-01-11 06:34:17 +09:00
|
|
|
ctx.ServerError("GetUserByName", err)
|
2014-08-14 15:12:21 +09:00
|
|
|
}
|
2015-11-25 09:14:00 +09:00
|
|
|
return
|
|
|
|
}
|
|
|
|
org := ctx.Org.Organization
|
2022-07-15 23:21:54 +09:00
|
|
|
|
|
|
|
// Handle Visibility
|
|
|
|
if org.Visibility != structs.VisibleTypePublic && !ctx.IsSigned {
|
|
|
|
// We must be signed in to see limited or private organizations
|
|
|
|
ctx.NotFound("OrgAssignment", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if org.Visibility == structs.VisibleTypePrivate {
|
|
|
|
requireMember = true
|
|
|
|
} else if ctx.IsSigned && ctx.Doer.IsRestricted {
|
|
|
|
requireMember = true
|
|
|
|
}
|
|
|
|
|
2022-03-26 18:04:22 +09:00
|
|
|
ctx.ContextUser = org.AsUser()
|
2015-11-25 09:14:00 +09:00
|
|
|
ctx.Data["Org"] = org
|
2014-08-14 15:12:21 +09:00
|
|
|
|
2015-11-29 06:31:06 +09:00
|
|
|
// Admin has super access.
|
2022-03-22 16:03:22 +09:00
|
|
|
if ctx.IsSigned && ctx.Doer.IsAdmin {
|
2015-11-29 06:31:06 +09:00
|
|
|
ctx.Org.IsOwner = true
|
|
|
|
ctx.Org.IsMember = true
|
2016-01-31 22:28:42 +09:00
|
|
|
ctx.Org.IsTeamMember = true
|
2016-02-01 00:18:28 +09:00
|
|
|
ctx.Org.IsTeamAdmin = true
|
2019-11-20 20:27:49 +09:00
|
|
|
ctx.Org.CanCreateOrgRepo = true
|
2015-11-29 06:31:06 +09:00
|
|
|
} else if ctx.IsSigned {
|
2022-03-22 16:03:22 +09:00
|
|
|
ctx.Org.IsOwner, err = org.IsOwnedBy(ctx.Doer.ID)
|
2017-12-21 16:43:26 +09:00
|
|
|
if err != nil {
|
2018-01-11 06:34:17 +09:00
|
|
|
ctx.ServerError("IsOwnedBy", err)
|
2017-12-21 16:43:26 +09:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-11-25 09:14:00 +09:00
|
|
|
if ctx.Org.IsOwner {
|
|
|
|
ctx.Org.IsMember = true
|
2016-01-31 22:28:42 +09:00
|
|
|
ctx.Org.IsTeamMember = true
|
2016-02-01 00:18:28 +09:00
|
|
|
ctx.Org.IsTeamAdmin = true
|
2019-11-20 20:27:49 +09:00
|
|
|
ctx.Org.CanCreateOrgRepo = true
|
2015-11-25 09:14:00 +09:00
|
|
|
} else {
|
2022-03-22 16:03:22 +09:00
|
|
|
ctx.Org.IsMember, err = org.IsOrgMember(ctx.Doer.ID)
|
2017-12-21 16:43:26 +09:00
|
|
|
if err != nil {
|
2018-01-11 06:34:17 +09:00
|
|
|
ctx.ServerError("IsOrgMember", err)
|
2017-12-21 16:43:26 +09:00
|
|
|
return
|
2014-08-14 15:12:21 +09:00
|
|
|
}
|
2022-03-22 16:03:22 +09:00
|
|
|
ctx.Org.CanCreateOrgRepo, err = org.CanCreateOrgRepo(ctx.Doer.ID)
|
2019-11-20 20:27:49 +09:00
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("CanCreateOrgRepo", err)
|
|
|
|
return
|
|
|
|
}
|
2014-08-14 15:12:21 +09:00
|
|
|
}
|
2015-11-25 09:14:00 +09:00
|
|
|
} else {
|
|
|
|
// Fake data.
|
2021-11-24 18:49:20 +09:00
|
|
|
ctx.Data["SignedUser"] = &user_model.User{}
|
2015-11-25 09:14:00 +09:00
|
|
|
}
|
|
|
|
if (requireMember && !ctx.Org.IsMember) ||
|
|
|
|
(requireOwner && !ctx.Org.IsOwner) {
|
2018-01-11 06:34:17 +09:00
|
|
|
ctx.NotFound("OrgAssignment", err)
|
2015-11-25 09:14:00 +09:00
|
|
|
return
|
|
|
|
}
|
|
|
|
ctx.Data["IsOrganizationOwner"] = ctx.Org.IsOwner
|
2015-11-29 06:31:06 +09:00
|
|
|
ctx.Data["IsOrganizationMember"] = ctx.Org.IsMember
|
2022-04-01 02:31:53 +09:00
|
|
|
ctx.Data["IsPackageEnabled"] = setting.Packages.Enabled
|
2022-10-11 08:12:03 +09:00
|
|
|
ctx.Data["IsRepoIndexerEnabled"] = setting.Indexer.RepoIndexerEnabled
|
2021-11-23 00:21:55 +09:00
|
|
|
ctx.Data["IsPublicMember"] = func(uid int64) bool {
|
2022-03-29 15:29:02 +09:00
|
|
|
is, _ := organization.IsPublicMembership(ctx.Org.Organization.ID, uid)
|
2021-11-23 00:21:55 +09:00
|
|
|
return is
|
|
|
|
}
|
2019-11-20 20:27:49 +09:00
|
|
|
ctx.Data["CanCreateOrgRepo"] = ctx.Org.CanCreateOrgRepo
|
2014-08-15 19:29:41 +09:00
|
|
|
|
2021-11-19 20:41:40 +09:00
|
|
|
ctx.Org.OrgLink = org.AsUser().OrganisationLink()
|
2015-11-25 09:14:00 +09:00
|
|
|
ctx.Data["OrgLink"] = ctx.Org.OrgLink
|
2014-08-16 17:21:17 +09:00
|
|
|
|
2015-11-25 09:14:00 +09:00
|
|
|
// Team.
|
2016-01-31 22:28:42 +09:00
|
|
|
if ctx.Org.IsMember {
|
2022-02-27 05:12:01 +09:00
|
|
|
shouldSeeAllTeams := false
|
2016-02-01 01:13:31 +09:00
|
|
|
if ctx.Org.IsOwner {
|
2022-02-27 05:12:01 +09:00
|
|
|
shouldSeeAllTeams = true
|
|
|
|
} else {
|
2022-03-22 16:03:22 +09:00
|
|
|
teams, err := org.GetUserTeams(ctx.Doer.ID)
|
2022-02-27 05:12:01 +09:00
|
|
|
if err != nil {
|
|
|
|
ctx.ServerError("GetUserTeams", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
for _, team := range teams {
|
|
|
|
if team.IncludesAllRepositories && team.AccessMode >= perm.AccessModeAdmin {
|
|
|
|
shouldSeeAllTeams = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if shouldSeeAllTeams {
|
2021-11-19 20:41:40 +09:00
|
|
|
ctx.Org.Teams, err = org.LoadTeams()
|
|
|
|
if err != nil {
|
2021-08-12 21:43:08 +09:00
|
|
|
ctx.ServerError("LoadTeams", err)
|
2016-02-01 01:13:31 +09:00
|
|
|
return
|
|
|
|
}
|
|
|
|
} else {
|
2022-03-22 16:03:22 +09:00
|
|
|
ctx.Org.Teams, err = org.GetUserTeams(ctx.Doer.ID)
|
2016-07-24 19:09:45 +09:00
|
|
|
if err != nil {
|
2018-01-11 06:34:17 +09:00
|
|
|
ctx.ServerError("GetUserTeams", err)
|
2016-02-01 01:13:31 +09:00
|
|
|
return
|
|
|
|
}
|
2016-01-31 22:28:42 +09:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-25 09:14:00 +09:00
|
|
|
teamName := ctx.Params(":team")
|
|
|
|
if len(teamName) > 0 {
|
2016-01-31 22:28:42 +09:00
|
|
|
teamExists := false
|
2021-11-19 20:41:40 +09:00
|
|
|
for _, team := range ctx.Org.Teams {
|
2016-02-05 03:03:34 +09:00
|
|
|
if team.LowerName == strings.ToLower(teamName) {
|
2016-01-31 22:28:42 +09:00
|
|
|
teamExists = true
|
|
|
|
ctx.Org.Team = team
|
|
|
|
ctx.Org.IsTeamMember = true
|
|
|
|
ctx.Data["Team"] = ctx.Org.Team
|
|
|
|
break
|
2014-08-16 17:21:17 +09:00
|
|
|
}
|
2016-01-31 22:28:42 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
if !teamExists {
|
2018-01-11 06:34:17 +09:00
|
|
|
ctx.NotFound("OrgAssignment", err)
|
2016-01-31 22:28:42 +09:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx.Data["IsTeamMember"] = ctx.Org.IsTeamMember
|
|
|
|
if requireTeamMember && !ctx.Org.IsTeamMember {
|
2018-01-11 06:34:17 +09:00
|
|
|
ctx.NotFound("OrgAssignment", err)
|
2014-08-24 22:09:05 +09:00
|
|
|
return
|
2014-08-16 17:21:17 +09:00
|
|
|
}
|
2016-01-31 22:28:42 +09:00
|
|
|
|
2022-01-05 12:37:00 +09:00
|
|
|
ctx.Org.IsTeamAdmin = ctx.Org.Team.IsOwnerTeam() || ctx.Org.Team.AccessMode >= perm.AccessModeAdmin
|
2016-02-01 00:18:28 +09:00
|
|
|
ctx.Data["IsTeamAdmin"] = ctx.Org.IsTeamAdmin
|
|
|
|
if requireTeamAdmin && !ctx.Org.IsTeamAdmin {
|
2018-01-11 06:34:17 +09:00
|
|
|
ctx.NotFound("OrgAssignment", err)
|
2016-01-31 22:28:42 +09:00
|
|
|
return
|
|
|
|
}
|
2015-11-25 09:14:00 +09:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:35:30 +09:00
|
|
|
// OrgAssignment returns a middleware to handle organization assignment
|
2021-01-27 00:36:53 +09:00
|
|
|
func OrgAssignment(args ...bool) func(ctx *Context) {
|
2015-11-25 09:14:00 +09:00
|
|
|
return func(ctx *Context) {
|
|
|
|
HandleOrgAssignment(ctx, args...)
|
2014-08-14 15:12:21 +09:00
|
|
|
}
|
|
|
|
}
|