Fix invalid issues in project boards

models/issues/issue_project.go

@@ -135,8 +135,26 @@ func addUpdateIssueProject(ctx context.Context, issue *Issue, doer *user_model.U
 		if err != nil {
 			return err
 		}
-		if newProject.RepoID != issue.RepoID && newProject.OwnerID != issue.Repo.OwnerID {
-			return fmt.Errorf("issue's repository is not the same as project's repository")
+
+		switch newProject.Type {
+		case project_model.TypeRepository:
+			if newProject.RepoID != issue.RepoID && newProject.OwnerID != issue.Repo.OwnerID {
+				return fmt.Errorf("issue's repository is not the same as project's repository")
+			}
+			break
+		case project_model.TypeOrganization:
+			// TODO: org team permission check
+			if newProject.OwnerID != issue.Repo.OwnerID {
+				return fmt.Errorf("issue's repository's owner is not the same as project's repository's owner")
+			}
+			break
+		case project_model.TypeIndividual:
+			if newProject.OwnerID != doer.ID {
+				return fmt.Errorf("user does not have the project [id: %d]", newProjectID)
+			}
+			break
+		default:
+			return fmt.Errorf("unknown project type: %d", newProject.Type)
 		}
 	}
 

models/project/project.go

@@ -33,6 +33,9 @@ type (
 
 	// Type is used to identify the type of project in question and ownership
 	Type uint8
+
+	// ProjectList is used to identify a list of projects
+	ProjectList []*Project
 )
 
 const (
@@ -85,6 +88,25 @@ func (err ErrProjectBoardNotExist) Unwrap() error {
 	return util.ErrNotExist
 }
 
+// ErrUserType represents a "ErrUserType" kind of error.
+type ErrUserType struct {
+	UserType user_model.UserType
+}
+
+// IsErrUserType checks if an error is a ErrUserType
+func IsErrUserType(err error) bool {
+	_, ok := err.(ErrUserType)
+	return ok
+}
+
+func (err ErrUserType) Error() string {
+	return fmt.Sprintf("projects does not support user type: %d", err.UserType)
+}
+
+func (err ErrUserType) Unwrap() error {
+	return util.ErrNotExist
+}
+
 // Project represents a project board
 type Project struct {
 	ID          int64                  `xorm:"pk autoincr"`
@@ -115,6 +137,18 @@ func (p *Project) LoadOwner(ctx context.Context) (err error) {
 	return err
 }
 
+func (pl ProjectList) LoadOwners(ctx context.Context) (err error) {
+	for _, p := range pl {
+		if p.Owner != nil {
+			continue
+		}
+		if p.Owner, err = user_model.GetUserByID(ctx, p.OwnerID); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (p *Project) LoadRepo(ctx context.Context) (err error) {
 	if p.RepoID == 0 || p.Repo != nil {
 		return nil
@@ -123,19 +157,29 @@ func (p *Project) LoadRepo(ctx context.Context) (err error) {
 	return err
 }
 
+func (pl ProjectList) LoadRepos(ctx context.Context) (err error) {
+	for _, p := range pl {
+		if p.RepoID == 0 || p.Repo != nil {
+			continue
+		}
+		if p.Repo, err = repo_model.GetRepositoryByID(ctx, p.RepoID); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 // Link returns the project's relative URL.
 func (p *Project) Link() string {
 	if p.OwnerID > 0 {
-		err := p.LoadOwner(db.DefaultContext)
-		if err != nil {
+		if err := p.LoadOwner(db.DefaultContext); err != nil {
 			log.Error("LoadOwner: %v", err)
 			return ""
 		}
 		return fmt.Sprintf("%s/-/projects/%d", p.Owner.HomeLink(), p.ID)
 	}
 	if p.RepoID > 0 {
-		err := p.LoadRepo(db.DefaultContext)
-		if err != nil {
+		if err := p.LoadRepo(db.DefaultContext); err != nil {
 			log.Error("LoadRepo: %v", err)
 			return ""
 		}
@@ -144,10 +188,46 @@ func (p *Project) Link() string {
 	return ""
 }
 
+// Name return the project's name which is combined with owner/repo/project's name
+func (p *Project) Name() string {
+	if p.OwnerID > 0 {
+		if err := p.LoadOwner(db.DefaultContext); err != nil {
+			log.Error("LoadOwner: %v", err)
+			return ""
+		}
+		return fmt.Sprintf("%s/-/%s", p.Owner.Name, p.Title)
+	}
+	if p.RepoID > 0 {
+		if err := p.LoadRepo(db.DefaultContext); err != nil {
+			log.Error("LoadRepo: %v", err)
+			return ""
+		}
+
+		return fmt.Sprintf("%s/%s/%s", p.Repo.OwnerName, p.Repo.Name, p.Title)
+	}
+	return ""
+}
+
 func (p *Project) IsOrganizationProject() bool {
 	return p.Type == TypeOrganization
 }
 
+func (p *Project) IsIndividualProject() bool {
+	return p.Type == TypeIndividual
+}
+
+// GetProjectTypeByUser retrieves the type of a project by user's type
+func GetProjectTypeByUser(user *user_model.User) (Type, error) {
+	switch user.Type {
+	case user_model.UserTypeIndividual:
+		return TypeIndividual, nil
+	case user_model.UserTypeOrganization:
+		return TypeOrganization, nil
+	default:
+		return 0, ErrUserType{UserType: user.Type}
+	}
+}
+
 func init() {
 	db.RegisterModel(new(Project))
 }
@@ -172,7 +252,7 @@ func GetCardConfig() []CardConfig {
 // IsTypeValid checks if a project type is valid
 func IsTypeValid(p Type) bool {
 	switch p {
-	case TypeRepository, TypeOrganization:
+	case TypeIndividual, TypeRepository, TypeOrganization:
 		return true
 	default:
 		return false
@@ -216,9 +296,9 @@ func CountProjects(ctx context.Context, opts SearchOptions) (int64, error) {
 }
 
 // FindProjects returns a list of all projects that have been created in the repository
-func FindProjects(ctx context.Context, opts SearchOptions) ([]*Project, int64, error) {
+func FindProjects(ctx context.Context, opts SearchOptions) (ProjectList, int64, error) {
 	e := db.GetEngine(ctx)
-	projects := make([]*Project, 0, setting.UI.IssuePagingNum)
+	projects := make(ProjectList, 0, setting.UI.IssuePagingNum)
 	cond := opts.toConds()
 
 	count, err := e.Where(cond).Count(new(Project))

models/user/user.go

@@ -460,6 +460,11 @@ func (u *User) IsOrganization() bool {
 	return u.Type == UserTypeOrganization
 }
 
+// IsIndividual returns true if user is actually a individual user.
+func (u *User) IsIndividual() bool {
+	return u.Type == UserTypeIndividual
+}
+
 // DisplayName returns full name if it's not empty,
 // returns username otherwise.
 func (u *User) DisplayName() string {

modules/context/org.go

@@ -37,13 +37,26 @@ func (org *Organization) CanWriteUnit(ctx *Context, unitType unit.Type) bool {
 	return org.UnitPermission(ctx, ctx.Doer.ID, unitType) >= perm.AccessModeWrite
 }
 
+func (org *Organization) CanAccessUnit(ctx *Context, unitType unit.Type) bool {
+	if ctx.Doer == nil {
+		return false
+	}
+	return org.UnitPermission(ctx, ctx.Doer.ID, unitType) >= perm.AccessModeRead
+}
+
 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 err := teams.LoadUnits(ctx); err != nil {
+			log.Error("LoadUnits: %v", err)
+			return perm.AccessModeNone
+		}
+
 		if len(teams) > 0 {
 			return teams.UnitMaxAccess(unitType)
 		}
@@ -56,6 +69,29 @@ func (org *Organization) UnitPermission(ctx *Context, doerID int64, unitType uni
 	return perm.AccessModeNone
 }
 
+func GetOrganizationByParams(ctx *Context) {
+	orgName := ctx.Params(":org")
+
+	var err error
+
+	ctx.Org.Organization, err = organization.GetOrgByName(ctx, orgName)
+	if err != nil {
+		if organization.IsErrOrgNotExist(err) {
+			redirectUserID, err := user_model.LookupUserRedirect(orgName)
+			if err == nil {
+				RedirectToUser(ctx, orgName, redirectUserID)
+			} else if user_model.IsErrUserRedirectNotExist(err) {
+				ctx.NotFound("GetUserByName", err)
+			} else {
+				ctx.ServerError("LookupUserRedirect", err)
+			}
+		} else {
+			ctx.ServerError("GetUserByName", err)
+		}
+		return
+	}
+}
+
 // HandleOrgAssignment handles organization assignment
 func HandleOrgAssignment(ctx *Context, args ...bool) {
 	var (
@@ -77,25 +113,17 @@ func HandleOrgAssignment(ctx *Context, args ...bool) {
 		requireTeamAdmin = args[3]
 	}
 
-	orgName := ctx.Params(":org")
-
 	var err error
-	ctx.Org.Organization, err = organization.GetOrgByName(ctx, orgName)
-	if err != nil {
-		if organization.IsErrOrgNotExist(err) {
-			redirectUserID, err := user_model.LookupUserRedirect(orgName)
-			if err == nil {
-				RedirectToUser(ctx, orgName, redirectUserID)
-			} else if user_model.IsErrUserRedirectNotExist(err) {
-				ctx.NotFound("GetUserByName", err)
-			} else {
-				ctx.ServerError("LookupUserRedirect", err)
-			}
-		} else {
-			ctx.ServerError("GetUserByName", err)
+
+	// if Organization is not defined, get it from params
+	if ctx.Org.Organization == nil {
+		GetOrganizationByParams(ctx)
+
+		if ctx.Written() {
+			return
 		}
-		return
 	}
+
 	org := ctx.Org.Organization
 
 	// Handle Visibility
@@ -231,6 +259,10 @@ func HandleOrgAssignment(ctx *Context, args ...bool) {
 			return
 		}
 	}
+
+	ctx.Data["CanAccessProjects"] = ctx.Org.CanAccessUnit(ctx, unit.TypeProjects)
+	ctx.Data["CanAccessPackages"] = ctx.Org.CanAccessUnit(ctx, unit.TypePackages)
+	ctx.Data["CanAccessCode"] = ctx.Org.CanAccessUnit(ctx, unit.TypeCode)
 }
 
 // OrgAssignment returns a middleware to handle organization assignment