func getColumnID(gc githubClient, orgRepoName, projectName, columnName, issueURL 	return nil, fmt.Errorf("could not find project %s in org/repo %s", projectName, orgRepoName) } -func addPRToColumn(gc githubClient, columnID int, pe github.PullRequestEvent) error {+func addPRToColumn(gc githubClient, columnID int, e eventData) error {

 func getColumnID(gc githubClient, orgRepoName, projectName, columnName, issueURL 	return nil, fmt.Errorf("could not find project %s in org/repo %s", projectName, orgRepoName) } -func addPRToColumn(gc githubClient, columnID int, pe github.PullRequestEvent) error {+func addPRToColumn(gc githubClient, columnID int, e eventData) error {

 type githubClient interface { 	CreateProjectCard(columnID int, projectCard github.ProjectCard) (*github.ProjectCard, error) } -func handlePR(gc githubClient, projectManager plugins.ProjectManager, log *logrus.Entry, pe github.PullRequestEvent) error {-	// Only respond to label add or issue/PR open events-	if pe.Action != github.PullRequestActionOpened &&-		pe.Action != github.PullRequestActionReopened &&-		pe.Action != github.PullRequestActionLabeled {+type eventData struct {+	id     int+	number int+	isPR   bool+	org    string+	repo   string+	state  string+	labels []github.Label+	remove bool+}++type DuplicateCard struct {+	projectName string+	issueURL    string+}++func (m *DuplicateCard) Error() string {+	return fmt.Sprintf(issueAlreadyInProject, m.issueURL, m.projectName)+}++func handleIssueRequest(pc plugins.Agent, ie github.IssueEvent) error {

 type githubClient interface { 	CreateProjectCard(columnID int, projectCard github.ProjectCard) (*github.ProjectCard, error) } -func handlePR(gc githubClient, projectManager plugins.ProjectManager, log *logrus.Entry, pe github.PullRequestEvent) error {-	// Only respond to label add or issue/PR open events-	if pe.Action != github.PullRequestActionOpened &&-		pe.Action != github.PullRequestActionReopened &&-		pe.Action != github.PullRequestActionLabeled {+type eventData struct {+	id     int+	number int+	isPR   bool+	org    string+	repo   string+	state  string+	labels []github.Label+	remove bool+}++type DuplicateCard struct {+	projectName string+	issueURL    string+}++func (m *DuplicateCard) Error() string {+	return fmt.Sprintf(issueAlreadyInProject, m.issueURL, m.projectName)+}++func handleIssueRequest(pc plugins.Agent, ie github.IssueEvent) error {+	if !handleIssueActions[ie.Action] {+		return nil+	}+	eventData := eventData{ie.Issue.ID, ie.Issue.Number, false, ie.Repo.Owner.Login, ie.Repo.Name, ie.Issue.State, ie.Issue.Labels, false}+	if ie.Action == github.IssueActionUnlabeled {+		eventData.remove = true+	}++	return handle(pc.GitHubClient, pc.PluginConfig.ProjectManager, pc.Logger, eventData)+}++func handlePullRequest(pc plugins.Agent, pe github.PullRequestEvent) error {+	if !handlePRActions[pe.Action] { 		return nil 	}+	eventData := eventData{pe.PullRequest.ID, pe.Number, true, pe.Repo.Owner.Login, pe.Repo.Name, pe.PullRequest.State, []github.Label{}, false}+	if pe.Action == github.PullRequestActionUnlabeled {+		eventData.remove = true+	}++	return handle(pc.GitHubClient, pc.PluginConfig.ProjectManager, pc.Logger, eventData)+}++func handle(gc githubClient, projectManager plugins.ProjectManager, log *logrus.Entry, e eventData) error {+ 	// Get any ManagedProjects that match this PR-	matchedColumnIDs := getMatchingColumnIDs(gc, projectManager.OrgRepos, pe, log)+	matchedColumnIDs := getMatchingColumnIDs(gc, projectManager.OrgRepos, e, log)  	// For each ManagedColumn that matches this PR, add this PR to that Project Column 	// All the matchedColumnID are valid column ids and the checked to see if the project card 	// we are adding is not already part of the project and thus avoiding duplication. 	for _, matchedColumnID := range matchedColumnIDs {-		err := addPRToColumn(gc, matchedColumnID, pe)+		err := addPRToColumn(gc, matchedColumnID, e) 		if err != nil { 			log.WithError(err).WithFields(logrus.Fields{-				"pullRequestNumber": pe.Number,-				"matchedColumnID":   matchedColumnID,+				"issueNumber":     e.number,

 type githubClient interface { 	CreateProjectCard(columnID int, projectCard github.ProjectCard) (*github.ProjectCard, error) } -func handlePR(gc githubClient, projectManager plugins.ProjectManager, log *logrus.Entry, pe github.PullRequestEvent) error {-	// Only respond to label add or issue/PR open events-	if pe.Action != github.PullRequestActionOpened &&-		pe.Action != github.PullRequestActionReopened &&-		pe.Action != github.PullRequestActionLabeled {+type eventData struct {+	id     int+	number int+	isPR   bool+	org    string+	repo   string+	state  string+	labels []github.Label+	remove bool+}++type DuplicateCard struct {+	projectName string+	issueURL    string+}++func (m *DuplicateCard) Error() string {+	return fmt.Sprintf(issueAlreadyInProject, m.issueURL, m.projectName)+}++func handleIssueRequest(pc plugins.Agent, ie github.IssueEvent) error {+	if !handleIssueActions[ie.Action] {+		return nil+	}+	eventData := eventData{ie.Issue.ID, ie.Issue.Number, false, ie.Repo.Owner.Login, ie.Repo.Name, ie.Issue.State, ie.Issue.Labels, false}+	if ie.Action == github.IssueActionUnlabeled {+		eventData.remove = true

 type githubClient interface { 	CreateProjectCard(columnID int, projectCard github.ProjectCard) (*github.ProjectCard, error) } -func handlePR(gc githubClient, projectManager plugins.ProjectManager, log *logrus.Entry, pe github.PullRequestEvent) error {-	// Only respond to label add or issue/PR open events-	if pe.Action != github.PullRequestActionOpened &&-		pe.Action != github.PullRequestActionReopened &&-		pe.Action != github.PullRequestActionLabeled {+type eventData struct {+	id     int+	number int+	isPR   bool+	org    string+	repo   string+	state  string+	labels []github.Label+	remove bool+}++type DuplicateCard struct {+	projectName string+	issueURL    string+}++func (m *DuplicateCard) Error() string {+	return fmt.Sprintf(issueAlreadyInProject, m.issueURL, m.projectName)+}++func handleIssueRequest(pc plugins.Agent, ie github.IssueEvent) error {+	if !handleIssueActions[ie.Action] {+		return nil+	}+	eventData := eventData{ie.Issue.ID, ie.Issue.Number, false, ie.Repo.Owner.Login, ie.Repo.Name, ie.Issue.State, ie.Issue.Labels, false}+	if ie.Action == github.IssueActionUnlabeled {+		eventData.remove = true+	}++	return handle(pc.GitHubClient, pc.PluginConfig.ProjectManager, pc.Logger, eventData)+}++func handlePullRequest(pc plugins.Agent, pe github.PullRequestEvent) error {+	if !handlePRActions[pe.Action] { 		return nil 	}+	eventData := eventData{pe.PullRequest.ID, pe.Number, true, pe.Repo.Owner.Login, pe.Repo.Name, pe.PullRequest.State, []github.Label{}, false}

 func validateRequireMatchingLabel(rs []RequireMatchingLabel) error { 	return nil } +func validateProjectManager(pm ProjectManager) error {++	projectConfig := pm+	if len(projectConfig.OrgRepos) == 0 {+		return fmt.Errorf("The project-manager plugin configuration is empty")+	}++	for orgRepoName, managedOrgRepo := range pm.OrgRepos {+		if len(managedOrgRepo.Projects) == 0 {+			return fmt.Errorf("Org/repo: %s, has no projects configured", orgRepoName)+		}+		var labelSets [][]string+		for projectName, managedProject := range managedOrgRepo.Projects {+			if len(managedProject.Columns) == 0 {+				return fmt.Errorf("Org/repo: %s, project %s, has no columns configured", orgRepoName, projectName)+			}+			for _, managedColumn := range managedProject.Columns {+				if managedColumn.ID == nil && (len(managedColumn.Name) == 0) {+					return fmt.Errorf("Org/repo: %s, project %s, column %v, has no name/id configured", orgRepoName, projectName, managedColumn)+				}+				if len(managedColumn.Labels) == 0 {+					return fmt.Errorf("Org/repo: %s, project %s, column %s, has no labels configured", orgRepoName, projectName, managedColumn.Name)+				}+				if len(managedColumn.Org) == 0 {+					return fmt.Errorf("Org/repo: %s, project %s, column %s, has no org configured", orgRepoName, projectName, managedColumn.Name)

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Package projectmanager is a plugin to auto add pull requests to project boards based on specified conditions+package projectmanager++import (+	"errors"+	"fmt"+	"strings"++	"github.com/sirupsen/logrus"++	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/pluginhelp"+	"k8s.io/test-infra/prow/plugins"+)++const (+	pluginName = "project-manager"+)++var (+	failedToAddProjectCard = "Failed to add project card for the issue"+	issueAlreadyInProject  = "The issue %d already assigned to the project %s"+)++/* Sample projectmanager configuration+org/repos:+      org1/repo1:+        projects:+          test_project:+            columns:+              - id: 0+                name: triage+                state: open+                org:  org1+                labels:+                  - area/conformance+                    area/sig-testing+              - name: triage+                state: open+                org:  org1+                labels:+                - area/conformance+                  area/sig-testing+*/++// TODO Create a new handler for issues, look in hook/server.go+// TODO Handle Label deletion, pr/issue should be removed from the project when label criteria does  not meet+// TODO Pr/issue state change, pr/iisue is on project board only if its state is listed in the configuration+func init() {+	plugins.RegisterPullRequestHandler(pluginName, handlePullRequest, helpProvider)+}++func helpProvider(config *plugins.Configuration, enabledRepos []string) (*pluginhelp.PluginHelp, error) {+	projectConfig := config.ProjectManager+	if len(projectConfig.OrgRepos) == 0 {+		pluginHelp := &pluginhelp.PluginHelp{+			Description: "The project-manager plugin automatically adds Pull Requests to specified GitHub Project Columns, if the label on the PR matches with configured project and the column.",+			Config:      map[string]string{},+		}+		return pluginHelp, nil+	}++	configString := map[string]string{}+	repoDescr := ""+	for orgRepoName, managedOrgRepo := range config.ProjectManager.OrgRepos {+		for projectName, managedProject := range managedOrgRepo.Projects {+			for _, managedColumn := range managedProject.Columns {+				repoDescr = fmt.Sprintf("%s\nPR/Issues org: %s, with matching labels: %s will be added to the project: %s\n", repoDescr, managedColumn.Org, managedColumn.Labels, projectName)

 func validateRequireMatchingLabel(rs []RequireMatchingLabel) error { 	return nil } +func validateProjectManager(pm ProjectManager) error {++	projectConfig := pm+	if len(projectConfig.OrgRepos) == 0 {+		return fmt.Errorf("The project-manager plugin configuration is empty")+	}++	for orgRepoName, managedOrgRepo := range pm.OrgRepos {+		if len(managedOrgRepo.Projects) == 0 {+			return fmt.Errorf("Org/repo: %s, has no projects configured", orgRepoName)+		}+		var labelSets [][]string+		for projectName, managedProject := range managedOrgRepo.Projects {+			if len(managedProject.Columns) == 0 {+				return fmt.Errorf("Org/repo: %s, project %s, has no columns configured", orgRepoName, projectName)+			}+			for _, managedColumn := range managedProject.Columns {+				if managedColumn.ID == nil && (len(managedColumn.Name) == 0) {+					return fmt.Errorf("Org/repo: %s, project %s, column %v, has no name/id configured", orgRepoName, projectName, managedColumn)+				}+				if len(managedColumn.Labels) == 0 {+					return fmt.Errorf("Org/repo: %s, project %s, column %s, has no labels configured", orgRepoName, projectName, managedColumn.Name)+				}+				if len(managedColumn.Org) == 0 {+					return fmt.Errorf("Org/repo: %s, project %s, column %s, has no org configured", orgRepoName, projectName, managedColumn.Name)+				}+				s_set := sets.NewString(managedColumn.Labels...)+				for _, labels := range labelSets {+					if s_set.Equal(sets.NewString(labels...)) {+						return fmt.Errorf("Org/repo: %s, project %s, column %s has same labels configured as another column", orgRepoName, projectName, managedColumn.Name)

 func validateRequireMatchingLabel(rs []RequireMatchingLabel) error { 	return nil } +func validateProjectManager(pm ProjectManager) error {++	projectConfig := pm+	if len(projectConfig.OrgRepos) == 0 {+		return fmt.Errorf("The project-manager plugin configuration is empty")

 func HasLabel(label string, issueLabels []Label) bool { 	return false } +// hasLabels checks if all labels are in the github.label set "issueLabels"+func HasLabels(labels []string, issueLabels []Label) bool {+	for _, label := range labels {+		if HasLabel(label, issueLabels) {+			return true

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Package projectmanager is a plugin to auto add pull requests to project boards based on specified conditions+package projectmanager++import (+	"errors"+	"fmt"+	"strings"++	"github.com/sirupsen/logrus"++	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/pluginhelp"+	"k8s.io/test-infra/prow/plugins"+)++const (+	pluginName = "project-manager"+)++var (+	invalidOrgRepo         = "The provided org/repo format is invalid %s"+	mustHaveProject        = "Each org/repo should be configured with project and columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveColumns        = "Each project must be configured with columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveLabels         = "Each column should have associated labels to assign issues/PRs with the specified labels to that column"+	haveLabelConflicts     = "Same label cannot be specified under two columns in the same project, this causes conflict when adding the project card"+	needsColumnIDorName    = "Atleast ID or Name of the column must be supplied to identify the column"+	needsValidOrg          = "The issue or PR event owner's login should match the org specified here to make this configuration valid"+	issueAlreadyInProject  = "The issue %d already assigned to the project %s"+	failedToAddProjectCard = "Failed to add project card for the issue"+	emptyConfig            = "ProjectManager configuration is Empty, please use the following format to add project manager configuration"+	sampleConfig           = `+     	    org/repos: +              org1/repo1:+                projects:+                  test_project:+                    columns:+                      - id: 0+                        name: triage+                        state: open+                        org:  org1+                        labels: +                          - area/conformance+                            area/sig-testing+                      - name: triage+                        state: open+                        org:  org1+                        labels: +                        - area/conformance+                          area/sig-testing+         `+)++// TODO Create a new handler for issues, look in hook/server.go+// TODO Handle Label deletion, pr/issue should be removed from the project when label criteria does  not meet+// TODO Pr/issue state change, pr/iisue is on project board only if its state is listed in the configuration+func init() {+	plugins.RegisterPullRequestHandler(pluginName, handlePullRequest, helpProvider)+}++func isDup(label string, labels []string) bool {+	for _, l := range labels {+		if strings.ToLower(l) == strings.ToLower(label) {+			return true+		}+	}+	return false+}++func helpProvider(config *plugins.Configuration, enabledRepos []string) (*pluginhelp.PluginHelp, error) {+	projectConfig := config.ProjectManager+	if len(projectConfig.OrgRepos) == 0 {+		pluginHelp := &pluginhelp.PluginHelp{+			Description: "The project-manager plugin automatically adds Pull Requests to specified GitHub Project Columns, if the label on the PR matches with configured project and the column.",+			Config:      map[string]string{"Config": sampleConfig},+		}+		return pluginHelp, nil+	}++	configString := map[string]string{}+	configErr := ""+	for orgRepoName, managedOrgRepo := range config.ProjectManager.OrgRepos {+		orgRepoParts := strings.Split(orgRepoName, "/")+		if len(orgRepoParts) != 2 && len(orgRepoParts) != 1 {+			configString[orgRepoName] = fmt.Sprintf(invalidOrgRepo, orgRepoName)

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Package projectmanager is a plugin to auto add pull requests to project boards based on specified conditions+package projectmanager++import (+	"errors"+	"fmt"+	"strings"++	"github.com/sirupsen/logrus"++	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/pluginhelp"+	"k8s.io/test-infra/prow/plugins"+)++const (+	pluginName = "project-manager"+)++var (+	invalidOrgRepo         = "The provided org/repo format is invalid %s"+	mustHaveProject        = "Each org/repo should be configured with project and columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveColumns        = "Each project must be configured with columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveLabels         = "Each column should have associated labels to assign issues/PRs with the specified labels to that column"+	haveLabelConflicts     = "Same label cannot be specified under two columns in the same project, this causes conflict when adding the project card"+	needsColumnIDorName    = "Atleast ID or Name of the column must be supplied to identify the column"+	needsValidOrg          = "The issue or PR event owner's login should match the org specified here to make this configuration valid"+	issueAlreadyInProject  = "The issue %d already assigned to the project %s"+	failedToAddProjectCard = "Failed to add project card for the issue"+	emptyConfig            = "ProjectManager configuration is Empty, please use the following format to add project manager configuration"+	sampleConfig           = `+     	    org/repos: +              org1/repo1:+                projects:+                  test_project:+                    columns:+                      - id: 0+                        name: triage+                        state: open+                        org:  org1+                        labels: +                          - area/conformance+                            area/sig-testing+                      - name: triage+                        state: open+                        org:  org1+                        labels: +                        - area/conformance+                          area/sig-testing+         `+)++// TODO Create a new handler for issues, look in hook/server.go+// TODO Handle Label deletion, pr/issue should be removed from the project when label criteria does  not meet+// TODO Pr/issue state change, pr/iisue is on project board only if its state is listed in the configuration+func init() {+	plugins.RegisterPullRequestHandler(pluginName, handlePullRequest, helpProvider)+}++func isDup(label string, labels []string) bool {+	for _, l := range labels {+		if strings.ToLower(l) == strings.ToLower(label) {+			return true+		}+	}+	return false+}++func helpProvider(config *plugins.Configuration, enabledRepos []string) (*pluginhelp.PluginHelp, error) {+	projectConfig := config.ProjectManager+	if len(projectConfig.OrgRepos) == 0 {+		pluginHelp := &pluginhelp.PluginHelp{+			Description: "The project-manager plugin automatically adds Pull Requests to specified GitHub Project Columns, if the label on the PR matches with configured project and the column.",+			Config:      map[string]string{"Config": sampleConfig},

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Package projectmanager is a plugin to auto add pull requests to project boards based on specified conditions+package projectmanager++import (+	"errors"+	"fmt"+	"strings"++	"github.com/sirupsen/logrus"++	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/pluginhelp"+	"k8s.io/test-infra/prow/plugins"+)++const (+	pluginName = "project-manager"+)++var (+	invalidOrgRepo         = "The provided org/repo format is invalid %s"+	mustHaveProject        = "Each org/repo should be configured with project and columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveColumns        = "Each project must be configured with columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveLabels         = "Each column should have associated labels to assign issues/PRs with the specified labels to that column"+	haveLabelConflicts     = "Same label cannot be specified under two columns in the same project, this causes conflict when adding the project card"+	needsColumnIDorName    = "Atleast ID or Name of the column must be supplied to identify the column"+	needsValidOrg          = "The issue or PR event owner's login should match the org specified here to make this configuration valid"+	issueAlreadyInProject  = "The issue %d already assigned to the project %s"+	failedToAddProjectCard = "Failed to add project card for the issue"+	emptyConfig            = "ProjectManager configuration is Empty, please use the following format to add project manager configuration"+	sampleConfig           = `+     	    org/repos: +              org1/repo1:+                projects:+                  test_project:+                    columns:+                      - id: 0+                        name: triage+                        state: open+                        org:  org1+                        labels: +                          - area/conformance+                            area/sig-testing+                      - name: triage+                        state: open+                        org:  org1+                        labels: +                        - area/conformance+                          area/sig-testing+         `+)++// TODO Create a new handler for issues, look in hook/server.go+// TODO Handle Label deletion, pr/issue should be removed from the project when label criteria does  not meet+// TODO Pr/issue state change, pr/iisue is on project board only if its state is listed in the configuration+func init() {+	plugins.RegisterPullRequestHandler(pluginName, handlePullRequest, helpProvider)+}++func isDup(label string, labels []string) bool {+	for _, l := range labels {+		if strings.ToLower(l) == strings.ToLower(label) {+			return true+		}+	}+	return false+}++func helpProvider(config *plugins.Configuration, enabledRepos []string) (*pluginhelp.PluginHelp, error) {+	projectConfig := config.ProjectManager+	if len(projectConfig.OrgRepos) == 0 {+		pluginHelp := &pluginhelp.PluginHelp{+			Description: "The project-manager plugin automatically adds Pull Requests to specified GitHub Project Columns, if the label on the PR matches with configured project and the column.",+			Config:      map[string]string{"Config": sampleConfig},+		}+		return pluginHelp, nil+	}++	configString := map[string]string{}+	configErr := ""+	for orgRepoName, managedOrgRepo := range config.ProjectManager.OrgRepos {+		orgRepoParts := strings.Split(orgRepoName, "/")+		if len(orgRepoParts) != 2 && len(orgRepoParts) != 1 {+			configString[orgRepoName] = fmt.Sprintf(invalidOrgRepo, orgRepoName)+		}+		repoConfig := ""+		if len(managedOrgRepo.Projects) == 0 {+			configErr = mustHaveProject+		}+		for projectName, managedProject := range managedOrgRepo.Projects {+			if len(managedProject.Columns) == 0 {+				configErr = mustHaveColumns+				continue+			}+			repoConfig = fmt.Sprintf("projects: {%s %s: { columns: [", repoConfig, projectName)

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Package projectmanager is a plugin to auto add pull requests to project boards based on specified conditions+package projectmanager++import (+	"errors"+	"fmt"+	"strings"++	"github.com/sirupsen/logrus"++	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/pluginhelp"+	"k8s.io/test-infra/prow/plugins"+)++const (+	pluginName = "project-manager"+)++var (+	invalidOrgRepo         = "The provided org/repo format is invalid %s"+	mustHaveProject        = "Each org/repo should be configured with project and columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveColumns        = "Each project must be configured with columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveLabels         = "Each column should have associated labels to assign issues/PRs with the specified labels to that column"+	haveLabelConflicts     = "Same label cannot be specified under two columns in the same project, this causes conflict when adding the project card"+	needsColumnIDorName    = "Atleast ID or Name of the column must be supplied to identify the column"+	needsValidOrg          = "The issue or PR event owner's login should match the org specified here to make this configuration valid"+	issueAlreadyInProject  = "The issue %d already assigned to the project %s"+	failedToAddProjectCard = "Failed to add project card for the issue"+	emptyConfig            = "ProjectManager configuration is Empty, please use the following format to add project manager configuration"+	sampleConfig           = `+     	    org/repos: +              org1/repo1:+                projects:+                  test_project:+                    columns:+                      - id: 0+                        name: triage+                        state: open+                        org:  org1+                        labels: +                          - area/conformance+                            area/sig-testing+                      - name: triage+                        state: open+                        org:  org1+                        labels: +                        - area/conformance+                          area/sig-testing+         `+)++// TODO Create a new handler for issues, look in hook/server.go+// TODO Handle Label deletion, pr/issue should be removed from the project when label criteria does  not meet+// TODO Pr/issue state change, pr/iisue is on project board only if its state is listed in the configuration+func init() {+	plugins.RegisterPullRequestHandler(pluginName, handlePullRequest, helpProvider)+}++func isDup(label string, labels []string) bool {+	for _, l := range labels {+		if strings.ToLower(l) == strings.ToLower(label) {+			return true+		}+	}+	return false+}++func helpProvider(config *plugins.Configuration, enabledRepos []string) (*pluginhelp.PluginHelp, error) {+	projectConfig := config.ProjectManager+	if len(projectConfig.OrgRepos) == 0 {+		pluginHelp := &pluginhelp.PluginHelp{+			Description: "The project-manager plugin automatically adds Pull Requests to specified GitHub Project Columns, if the label on the PR matches with configured project and the column.",+			Config:      map[string]string{"Config": sampleConfig},+		}+		return pluginHelp, nil+	}++	configString := map[string]string{}+	configErr := ""+	for orgRepoName, managedOrgRepo := range config.ProjectManager.OrgRepos {+		orgRepoParts := strings.Split(orgRepoName, "/")+		if len(orgRepoParts) != 2 && len(orgRepoParts) != 1 {+			configString[orgRepoName] = fmt.Sprintf(invalidOrgRepo, orgRepoName)+		}+		repoConfig := ""+		if len(managedOrgRepo.Projects) == 0 {+			configErr = mustHaveProject+		}+		for projectName, managedProject := range managedOrgRepo.Projects {+			if len(managedProject.Columns) == 0 {+				configErr = mustHaveColumns+				continue+			}+			repoConfig = fmt.Sprintf("projects: {%s %s: { columns: [", repoConfig, projectName)+			usedLabels := []string{}+			for _, managedColumn := range managedProject.Columns {+				if len(managedColumn.Labels) == 0 {+					configErr = mustHaveLabels+					continue+				}+				if managedColumn.ID == nil && (len(managedColumn.Name) == 0) {+					configErr = needsColumnIDorName+					continue+				}+				if len(managedColumn.State) == 0 {+					managedColumn.State = "open"+				}+				if len(managedColumn.Org) == 0 {+					configErr = needsValidOrg+					continue+				}+				repoConfig = fmt.Sprintf("%s {id: \"%d\", name: \"%s\", state: \"%s\", org: \"%s\" labels: [", repoConfig, managedColumn.ID, managedColumn.Name, managedColumn.State, managedColumn.Org)+				for i, label := range managedColumn.Labels {+					if isDup(label, usedLabels) {+						configErr = haveLabelConflicts+					} else {+						usedLabels = append(usedLabels, label)+					}+					repoConfig = fmt.Sprintf("%s \"%s\"", repoConfig, label)+					if i+1 < len(managedColumn.Labels) {+						repoConfig = fmt.Sprintf("%s,", repoConfig)+					}+				}+				repoConfig = fmt.Sprintf("%s ] }", repoConfig)+			}+			repoConfig = fmt.Sprintf("%s ] }", repoConfig)+		}+		if len(configErr) > 0 {+			configString[orgRepoName] = configErr+		} else {+			configString[orgRepoName] = repoConfig+		}+	}++	pluginHelp := &pluginhelp.PluginHelp{+		Description: "The project-manager plugin automatically adds Pull Requests to specified GitHub Project Columns, if the label on the PR matches with configured project and the column.",+		Config:      configString,+	}+	return pluginHelp, nil+}++func handlePullRequest(pc plugins.Agent, pe github.PullRequestEvent) error {+	return handlePR(pc.GitHubClient, pc.PluginConfig.ProjectManager, pc.Logger, pe)+}++// Strict subset of *github.Client methods.+type githubClient interface {+	GetIssueLabels(org, repo string, number int) ([]github.Label, error)+	GetRepoProjects(owner, repo string) ([]github.Project, error)+	GetOrgProjects(org string) ([]github.Project, error)+	GetProjectColumns(projectID int) ([]github.ProjectColumn, error)+	GetColumnProjectCards(columnID int) ([]github.ProjectCard, error)+	CreateProjectCard(columnID int, projectCard github.ProjectCard) (*github.ProjectCard, error)+}++func handlePR(gc githubClient, projectManager plugins.ProjectManager, log *logrus.Entry, pe github.PullRequestEvent) error {+	// Only respond to label add or issue/PR open events+	if pe.Action != github.PullRequestActionOpened &&+		pe.Action != github.PullRequestActionReopened &&+		pe.Action != github.PullRequestActionLabeled {+		return nil+	}+	// Get any ManagedProjects that match this PR+	matchedColumnIDs := getMatchingColumnIDs(gc, projectManager.OrgRepos, pe, log)++	// For each ManagedColumn that matches this PR, add this PR to that Project Column+	// All the matchedColumnID are valid column ids and the checked to see if the project card+	// we are adding is not already part of the project and thus avoiding duplication.+	for _, matchedColumnID := range matchedColumnIDs {+		err := addPRToColumn(gc, matchedColumnID, pe)+		if err != nil {+			log.WithError(err).WithFields(logrus.Fields{+				"pullRequestNumber": pe.Number,+				"matchedColumnID":   matchedColumnID,+			}).Error(failedToAddProjectCard)+			return err+		}+	}+	return nil+}++func getMatchingColumnIDs(gc githubClient, orgRepos map[string]plugins.ManagedOrgRepo, pe github.PullRequestEvent, log *logrus.Entry) []int {+	var matchedColumnIDs []int+	// Don't use GetIssueLabels unless it's required and keep track of whether the labels have been fetched to avoid unnecessary API usage.+	var labels []github.Label+	// If labels are not yet fetched then get them as they are now required

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Package projectmanager is a plugin to auto add pull requests to project boards based on specified conditions+package projectmanager++import (+	"errors"+	"fmt"+	"strings"++	"github.com/sirupsen/logrus"++	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/pluginhelp"+	"k8s.io/test-infra/prow/plugins"+)++const (+	pluginName = "project-manager"+)++var (+	invalidOrgRepo         = "The provided org/repo format is invalid %s"+	mustHaveProject        = "Each org/repo should be configured with project and columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveColumns        = "Each project must be configured with columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveLabels         = "Each column should have associated labels to assign issues/PRs with the specified labels to that column"+	haveLabelConflicts     = "Same label cannot be specified under two columns in the same project, this causes conflict when adding the project card"+	needsColumnIDorName    = "Atleast ID or Name of the column must be supplied to identify the column"+	needsValidOrg          = "The issue or PR event owner's login should match the org specified here to make this configuration valid"+	issueAlreadyInProject  = "The issue %d already assigned to the project %s"+	failedToAddProjectCard = "Failed to add project card for the issue"+	emptyConfig            = "ProjectManager configuration is Empty, please use the following format to add project manager configuration"+	sampleConfig           = `+     	    org/repos: +              org1/repo1:+                projects:+                  test_project:+                    columns:+                      - id: 0+                        name: triage+                        state: open+                        org:  org1+                        labels: +                          - area/conformance+                            area/sig-testing+                      - name: triage+                        state: open+                        org:  org1+                        labels: +                        - area/conformance+                          area/sig-testing+         `+)++// TODO Create a new handler for issues, look in hook/server.go+// TODO Handle Label deletion, pr/issue should be removed from the project when label criteria does  not meet+// TODO Pr/issue state change, pr/iisue is on project board only if its state is listed in the configuration+func init() {+	plugins.RegisterPullRequestHandler(pluginName, handlePullRequest, helpProvider)+}++func isDup(label string, labels []string) bool {+	for _, l := range labels {+		if strings.ToLower(l) == strings.ToLower(label) {+			return true+		}+	}+	return false+}++func helpProvider(config *plugins.Configuration, enabledRepos []string) (*pluginhelp.PluginHelp, error) {+	projectConfig := config.ProjectManager+	if len(projectConfig.OrgRepos) == 0 {+		pluginHelp := &pluginhelp.PluginHelp{+			Description: "The project-manager plugin automatically adds Pull Requests to specified GitHub Project Columns, if the label on the PR matches with configured project and the column.",+			Config:      map[string]string{"Config": sampleConfig},+		}+		return pluginHelp, nil+	}++	configString := map[string]string{}+	configErr := ""+	for orgRepoName, managedOrgRepo := range config.ProjectManager.OrgRepos {+		orgRepoParts := strings.Split(orgRepoName, "/")+		if len(orgRepoParts) != 2 && len(orgRepoParts) != 1 {+			configString[orgRepoName] = fmt.Sprintf(invalidOrgRepo, orgRepoName)+		}+		repoConfig := ""+		if len(managedOrgRepo.Projects) == 0 {+			configErr = mustHaveProject+		}+		for projectName, managedProject := range managedOrgRepo.Projects {+			if len(managedProject.Columns) == 0 {+				configErr = mustHaveColumns+				continue+			}+			repoConfig = fmt.Sprintf("projects: {%s %s: { columns: [", repoConfig, projectName)+			usedLabels := []string{}+			for _, managedColumn := range managedProject.Columns {+				if len(managedColumn.Labels) == 0 {+					configErr = mustHaveLabels+					continue+				}+				if managedColumn.ID == nil && (len(managedColumn.Name) == 0) {+					configErr = needsColumnIDorName+					continue+				}+				if len(managedColumn.State) == 0 {+					managedColumn.State = "open"+				}+				if len(managedColumn.Org) == 0 {+					configErr = needsValidOrg+					continue+				}+				repoConfig = fmt.Sprintf("%s {id: \"%d\", name: \"%s\", state: \"%s\", org: \"%s\" labels: [", repoConfig, managedColumn.ID, managedColumn.Name, managedColumn.State, managedColumn.Org)+				for i, label := range managedColumn.Labels {+					if isDup(label, usedLabels) {+						configErr = haveLabelConflicts+					} else {+						usedLabels = append(usedLabels, label)+					}+					repoConfig = fmt.Sprintf("%s \"%s\"", repoConfig, label)+					if i+1 < len(managedColumn.Labels) {+						repoConfig = fmt.Sprintf("%s,", repoConfig)+					}+				}+				repoConfig = fmt.Sprintf("%s ] }", repoConfig)+			}+			repoConfig = fmt.Sprintf("%s ] }", repoConfig)+		}+		if len(configErr) > 0 {+			configString[orgRepoName] = configErr+		} else {+			configString[orgRepoName] = repoConfig+		}+	}++	pluginHelp := &pluginhelp.PluginHelp{+		Description: "The project-manager plugin automatically adds Pull Requests to specified GitHub Project Columns, if the label on the PR matches with configured project and the column.",+		Config:      configString,+	}+	return pluginHelp, nil+}++func handlePullRequest(pc plugins.Agent, pe github.PullRequestEvent) error {+	return handlePR(pc.GitHubClient, pc.PluginConfig.ProjectManager, pc.Logger, pe)+}++// Strict subset of *github.Client methods.+type githubClient interface {+	GetIssueLabels(org, repo string, number int) ([]github.Label, error)+	GetRepoProjects(owner, repo string) ([]github.Project, error)+	GetOrgProjects(org string) ([]github.Project, error)+	GetProjectColumns(projectID int) ([]github.ProjectColumn, error)+	GetColumnProjectCards(columnID int) ([]github.ProjectCard, error)+	CreateProjectCard(columnID int, projectCard github.ProjectCard) (*github.ProjectCard, error)+}++func handlePR(gc githubClient, projectManager plugins.ProjectManager, log *logrus.Entry, pe github.PullRequestEvent) error {+	// Only respond to label add or issue/PR open events+	if pe.Action != github.PullRequestActionOpened &&+		pe.Action != github.PullRequestActionReopened &&+		pe.Action != github.PullRequestActionLabeled {+		return nil+	}+	// Get any ManagedProjects that match this PR+	matchedColumnIDs := getMatchingColumnIDs(gc, projectManager.OrgRepos, pe, log)++	// For each ManagedColumn that matches this PR, add this PR to that Project Column+	// All the matchedColumnID are valid column ids and the checked to see if the project card+	// we are adding is not already part of the project and thus avoiding duplication.+	for _, matchedColumnID := range matchedColumnIDs {+		err := addPRToColumn(gc, matchedColumnID, pe)+		if err != nil {+			log.WithError(err).WithFields(logrus.Fields{+				"pullRequestNumber": pe.Number,+				"matchedColumnID":   matchedColumnID,+			}).Error(failedToAddProjectCard)+			return err+		}+	}+	return nil+}++func getMatchingColumnIDs(gc githubClient, orgRepos map[string]plugins.ManagedOrgRepo, pe github.PullRequestEvent, log *logrus.Entry) []int {+	var matchedColumnIDs []int+	// Don't use GetIssueLabels unless it's required and keep track of whether the labels have been fetched to avoid unnecessary API usage.+	var labels []github.Label+	// If labels are not yet fetched then get them as they are now required+	// GetIssueLabels works for PRs as they are considered issues in the API+	var err error+	labels, err = gc.GetIssueLabels(pe.Repo.Owner.Login, pe.Repo.Name, pe.Number)+	if err != nil {+		log.Infof("Error geting labels on the issue %d, ignoring processing the event", pe.Number)+		return nil+	}++	issueURL := fmt.Sprintf("https://api.github.com/repos/%s/%s/issues/%v", pe.Repo.Owner.Login, pe.Repo.Name, pe.Number)+	for orgRepoName, managedOrgRepo := range orgRepos {+		for projectName, managedProject := range managedOrgRepo.Projects {+			for _, managedColumn := range managedProject.Columns {+				if managedColumn.Org != "" && managedColumn.Org != pe.Repo.Owner.Login {+					continue+				}+				if managedColumn.State != "" && managedColumn.State != pe.PullRequest.State {+					continue+				}++				// if labels do not match we continue to the next project+				if !github.HasLabels(managedColumn.Labels, labels) {+					continue+				}++				columnID := managedColumn.ID+				// Currently this assumes columnID having a value if 0 means it is unset+				// While it's highly unlikely that an actual project would have an ID of 0, given that+				// these IDs are global across GitHub, this doesn't seem like an ideal solution.+				if columnID == nil {+					var err error+					columnID, err = getColumnID(gc, orgRepoName, projectName, managedColumn.Name, issueURL)+					if err != nil {+						log.Infof("Cannot add the issue: %d to the project: %s, column: %s, error: %s", pe.Number, projectName, managedColumn.Name, err)+						break+					}+				}+				matchedColumnIDs = append(matchedColumnIDs, *columnID)+				// if the configuration allows to match multiple columns within the same+				// project, we will only take the first column match from the list+				break+			}+		}+	}+	return matchedColumnIDs+}++// getColumnID returns a column id only if the issue if the project and column name provided are valid+// and the issue is not already in the project+func getColumnID(gc githubClient, orgRepoName, projectName, columnName, issueURL string) (*int, error) {+	var projects []github.Project+	var err error+	orgRepoParts := strings.Split(orgRepoName, "/")+	switch len(orgRepoParts) {+	case 2:+		projects, err = gc.GetRepoProjects(orgRepoParts[0], orgRepoParts[1])+	case 1:+		projects, err = gc.GetOrgProjects(orgRepoParts[0])+	default:+		return nil, fmt.Errorf("could not determine org or org/repo from %s", orgRepoName)+	}++	if err != nil {+		return nil, err+	}++	for _, project := range projects {+		if project.Name == projectName {+			columns, err := gc.GetProjectColumns(project.ID)+			if err != nil {+				return nil, err+			}++			for _, column := range columns {+				cards, err := gc.GetColumnProjectCards(column.ID)+				if err != nil {+					return nil, err+				}++				for _, card := range cards {+					if card.ContentURL == issueURL {+						return nil, errors.New(fmt.Sprintf(issueAlreadyInProject, issueURL, projectName))+					}+				}+			}+			for _, column := range columns {+				if column.Name == columnName {+					return &column.ID, nil+				}+			}+			return nil, fmt.Errorf("could not find column %s in project %s", columnName, projectName)+		}+	}+	return nil, fmt.Errorf("could not find project %s in org/repo %s", projectName, orgRepoName)+}++func addPRToColumn(gc githubClient, columnID int, pe github.PullRequestEvent) error {+	// Create project card and add this PR+	projectCard := github.ProjectCard{+		ContentType: "PullRequest",+		ContentID:   pe.PullRequest.ID,+	}+	_, err := gc.CreateProjectCard(columnID, projectCard)+	if err != nil {+		return err+	}+	return nil

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Package projectmanager is a plugin to auto add pull requests to project boards based on specified conditions+package projectmanager++import (+	"errors"+	"fmt"+	"strings"++	"github.com/sirupsen/logrus"++	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/pluginhelp"+	"k8s.io/test-infra/prow/plugins"+)++const (+	pluginName = "project-manager"+)++var (+	invalidOrgRepo         = "The provided org/repo format is invalid %s"+	mustHaveProject        = "Each org/repo should be configured with project and columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveColumns        = "Each project must be configured with columns with associated labels for plugin to assign issues/PRs with the specified labels to that column"+	mustHaveLabels         = "Each column should have associated labels to assign issues/PRs with the specified labels to that column"+	haveLabelConflicts     = "Same label cannot be specified under two columns in the same project, this causes conflict when adding the project card"+	needsColumnIDorName    = "Atleast ID or Name of the column must be supplied to identify the column"+	needsValidOrg          = "The issue or PR event owner's login should match the org specified here to make this configuration valid"+	issueAlreadyInProject  = "The issue %d already assigned to the project %s"+	failedToAddProjectCard = "Failed to add project card for the issue"+	emptyConfig            = "ProjectManager configuration is Empty, please use the following format to add project manager configuration"+	sampleConfig           = `+     	    org/repos: +              org1/repo1:+                projects:+                  test_project:+                    columns:+                      - id: 0+                        name: triage+                        state: open+                        org:  org1+                        labels: +                          - area/conformance+                            area/sig-testing+                      - name: triage+                        state: open+                        org:  org1+                        labels: +                        - area/conformance+                          area/sig-testing+         `+)++// TODO Create a new handler for issues, look in hook/server.go+// TODO Handle Label deletion, pr/issue should be removed from the project when label criteria does  not meet+// TODO Pr/issue state change, pr/iisue is on project board only if its state is listed in the configuration+func init() {+	plugins.RegisterPullRequestHandler(pluginName, handlePullRequest, helpProvider)+}++func isDup(label string, labels []string) bool {+	for _, l := range labels {+		if strings.ToLower(l) == strings.ToLower(label) {+			return true+		}+	}+	return false+}++func helpProvider(config *plugins.Configuration, enabledRepos []string) (*pluginhelp.PluginHelp, error) {+	projectConfig := config.ProjectManager+	if len(projectConfig.OrgRepos) == 0 {+		pluginHelp := &pluginhelp.PluginHelp{+			Description: "The project-manager plugin automatically adds Pull Requests to specified GitHub Project Columns, if the label on the PR matches with configured project and the column.",+			Config:      map[string]string{"Config": sampleConfig},+		}+		return pluginHelp, nil+	}++	configString := map[string]string{}+	configErr := ""+	for orgRepoName, managedOrgRepo := range config.ProjectManager.OrgRepos {+		orgRepoParts := strings.Split(orgRepoName, "/")+		if len(orgRepoParts) != 2 && len(orgRepoParts) != 1 {+			configString[orgRepoName] = fmt.Sprintf(invalidOrgRepo, orgRepoName)+		}+		repoConfig := ""+		if len(managedOrgRepo.Projects) == 0 {+			configErr = mustHaveProject+		}+		for projectName, managedProject := range managedOrgRepo.Projects {+			if len(managedProject.Columns) == 0 {+				configErr = mustHaveColumns+				continue+			}+			repoConfig = fmt.Sprintf("projects: {%s %s: { columns: [", repoConfig, projectName)+			usedLabels := []string{}+			for _, managedColumn := range managedProject.Columns {+				if len(managedColumn.Labels) == 0 {+					configErr = mustHaveLabels+					continue+				}+				if managedColumn.ID == nil && (len(managedColumn.Name) == 0) {+					configErr = needsColumnIDorName+					continue+				}+				if len(managedColumn.State) == 0 {+					managedColumn.State = "open"+				}+				if len(managedColumn.Org) == 0 {+					configErr = needsValidOrg+					continue+				}+				repoConfig = fmt.Sprintf("%s {id: \"%d\", name: \"%s\", state: \"%s\", org: \"%s\" labels: [", repoConfig, managedColumn.ID, managedColumn.Name, managedColumn.State, managedColumn.Org)+				for i, label := range managedColumn.Labels {+					if isDup(label, usedLabels) {+						configErr = haveLabelConflicts+					} else {+						usedLabels = append(usedLabels, label)+					}+					repoConfig = fmt.Sprintf("%s \"%s\"", repoConfig, label)+					if i+1 < len(managedColumn.Labels) {+						repoConfig = fmt.Sprintf("%s,", repoConfig)+					}+				}+				repoConfig = fmt.Sprintf("%s ] }", repoConfig)+			}+			repoConfig = fmt.Sprintf("%s ] }", repoConfig)+		}+		if len(configErr) > 0 {+			configString[orgRepoName] = configErr+		} else {+			configString[orgRepoName] = repoConfig+		}+	}++	pluginHelp := &pluginhelp.PluginHelp{+		Description: "The project-manager plugin automatically adds Pull Requests to specified GitHub Project Columns, if the label on the PR matches with configured project and the column.",+		Config:      configString,+	}+	return pluginHelp, nil+}++func handlePullRequest(pc plugins.Agent, pe github.PullRequestEvent) error {+	return handlePR(pc.GitHubClient, pc.PluginConfig.ProjectManager, pc.Logger, pe)+}++// Strict subset of *github.Client methods.+type githubClient interface {+	GetIssueLabels(org, repo string, number int) ([]github.Label, error)+	GetRepoProjects(owner, repo string) ([]github.Project, error)+	GetOrgProjects(org string) ([]github.Project, error)+	GetProjectColumns(projectID int) ([]github.ProjectColumn, error)+	GetColumnProjectCards(columnID int) ([]github.ProjectCard, error)+	CreateProjectCard(columnID int, projectCard github.ProjectCard) (*github.ProjectCard, error)+}++func handlePR(gc githubClient, projectManager plugins.ProjectManager, log *logrus.Entry, pe github.PullRequestEvent) error {+	// Only respond to label add or issue/PR open events+	if pe.Action != github.PullRequestActionOpened &&+		pe.Action != github.PullRequestActionReopened &&+		pe.Action != github.PullRequestActionLabeled {+		return nil+	}+	// Get any ManagedProjects that match this PR+	matchedColumnIDs := getMatchingColumnIDs(gc, projectManager.OrgRepos, pe, log)++	// For each ManagedColumn that matches this PR, add this PR to that Project Column+	// All the matchedColumnID are valid column ids and the checked to see if the project card+	// we are adding is not already part of the project and thus avoiding duplication.+	for _, matchedColumnID := range matchedColumnIDs {+		err := addPRToColumn(gc, matchedColumnID, pe)+		if err != nil {+			log.WithError(err).WithFields(logrus.Fields{+				"pullRequestNumber": pe.Number,+				"matchedColumnID":   matchedColumnID,+			}).Error(failedToAddProjectCard)+			return err+		}+	}+	return nil+}++func getMatchingColumnIDs(gc githubClient, orgRepos map[string]plugins.ManagedOrgRepo, pe github.PullRequestEvent, log *logrus.Entry) []int {+	var matchedColumnIDs []int+	// Don't use GetIssueLabels unless it's required and keep track of whether the labels have been fetched to avoid unnecessary API usage.+	var labels []github.Label+	// If labels are not yet fetched then get them as they are now required+	// GetIssueLabels works for PRs as they are considered issues in the API+	var err error+	labels, err = gc.GetIssueLabels(pe.Repo.Owner.Login, pe.Repo.Name, pe.Number)+	if err != nil {+		log.Infof("Error geting labels on the issue %d, ignoring processing the event", pe.Number)+		return nil+	}++	issueURL := fmt.Sprintf("https://api.github.com/repos/%s/%s/issues/%v", pe.Repo.Owner.Login, pe.Repo.Name, pe.Number)+	for orgRepoName, managedOrgRepo := range orgRepos {+		for projectName, managedProject := range managedOrgRepo.Projects {+			for _, managedColumn := range managedProject.Columns {+				if managedColumn.Org != "" && managedColumn.Org != pe.Repo.Owner.Login {+					continue+				}+				if managedColumn.State != "" && managedColumn.State != pe.PullRequest.State {+					continue+				}++				// if labels do not match we continue to the next project+				if !github.HasLabels(managedColumn.Labels, labels) {+					continue+				}++				columnID := managedColumn.ID+				// Currently this assumes columnID having a value if 0 means it is unset+				// While it's highly unlikely that an actual project would have an ID of 0, given that+				// these IDs are global across GitHub, this doesn't seem like an ideal solution.+				if columnID == nil {+					var err error+					columnID, err = getColumnID(gc, orgRepoName, projectName, managedColumn.Name, issueURL)+					if err != nil {+						log.Infof("Cannot add the issue: %d to the project: %s, column: %s, error: %s", pe.Number, projectName, managedColumn.Name, err)+						break+					}+				}+				matchedColumnIDs = append(matchedColumnIDs, *columnID)+				// if the configuration allows to match multiple columns within the same+				// project, we will only take the first column match from the list+				break+			}+		}+	}+	return matchedColumnIDs+}++// getColumnID returns a column id only if the issue if the project and column name provided are valid+// and the issue is not already in the project+func getColumnID(gc githubClient, orgRepoName, projectName, columnName, issueURL string) (*int, error) {+	var projects []github.Project+	var err error+	orgRepoParts := strings.Split(orgRepoName, "/")+	switch len(orgRepoParts) {+	case 2:+		projects, err = gc.GetRepoProjects(orgRepoParts[0], orgRepoParts[1])+	case 1:+		projects, err = gc.GetOrgProjects(orgRepoParts[0])+	default:+		return nil, fmt.Errorf("could not determine org or org/repo from %s", orgRepoName)+	}++	if err != nil {+		return nil, err+	}++	for _, project := range projects {+		if project.Name == projectName {+			columns, err := gc.GetProjectColumns(project.ID)+			if err != nil {+				return nil, err+			}++			for _, column := range columns {+				cards, err := gc.GetColumnProjectCards(column.ID)+				if err != nil {+					return nil, err+				}++				for _, card := range cards {+					if card.ContentURL == issueURL {+						return nil, errors.New(fmt.Sprintf(issueAlreadyInProject, issueURL, projectName))

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++// Package projectmanager is a plugin to auto add pull requests to project boards based on specified conditions+package projectmanager++import (+	"fmt"+	"strings"++	"github.com/sirupsen/logrus"++	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/pluginhelp"+	"k8s.io/test-infra/prow/plugins"+)++const (+	pluginName = "project-manager"+)++// TODO Create a new handler for issues, look in hook/server.go+// TODO Handle Label deletion, pr/issue should be removed from the project when label criteria does  not meet+// TODO Pr/issue state change, pr/iisue is on project board only if its state is listed in the configuration+func init() {+	plugins.RegisterPullRequestHandler(pluginName, handlePullRequest, helpProvider)+}++func helpProvider(config *plugins.Configuration, enabledRepos []string) (*pluginhelp.PluginHelp, error) {+	projectConfig := map[string]string{}+	var configString string+	for orgRepoName, managedOrgRepo := range config.ProjectManager.OrgRepos {+		configString = fmt.Sprintf("%s %s: { projects: {", configString, orgRepoName)+		for projectName, managedProject := range managedOrgRepo.Projects {+			configString := fmt.Sprintf("%s %s: { columns: [", configString, projectName)

 type ProjectRepoConfig struct { 	ProjectColumnMap map[string]string `json:"repo_default_column_map,omitempty"` } +// ProjectManager represents the config for the ProjectManager plugin, holding top+// level config options, configuration is a hierarchial structure with top level element+// being org/repo with the list of projects as its children

 func (f *FakeClient) CreateProjectCard(columnID int, projectCard github.ProjectC 	}  	for project, columnIDMap := range f.ColumnIDMap {+		for id := range columnIDMap {+			// Make sure that we behave same as github API+			// Create project will generate an error when the card already exist in the project+			if _, exists := columnIDMap[columnID]; exists {+				card, err := f.GetColumnProjectCard(id, projectCard.ContentURL)+				if err == nil && card != nil && *card == projectCard {

 func (f *FakeClient) CreateProjectCard(columnID int, projectCard github.ProjectC 	}  	for project, columnIDMap := range f.ColumnIDMap {+		for id := range columnIDMap {+			// Make sure that we behave same as github API+			// Create project will generate an error when the card already exist in the project+			if _, exists := columnIDMap[columnID]; exists {

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++package projectmanager++import (+	"fmt"+	"testing"++	"github.com/sirupsen/logrus"+	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/github/fakegithub"+	"k8s.io/test-infra/prow/plugins"+)++func TestHandlePR(t *testing.T) {+	columnID := new(int)+	*columnID = 1+	columnIDMap := map[string]map[int]string{+		"testProject": {+			00001: "testColumn",+			00002: "testColumn2",+		},+		"testProject2": {+			00003: "testColumn",+			00004: "testColumn2",+		},+	}+	labels := []string{"otherOrg/someRepo#1:label1", "otherOrg/someRepo#1:label2", "otherOrg/someRepo#2:label1", "otherOrg2/someRepo#1:label1"}+	cases := []struct {+		name                string+		gc                  *fakegithub.FakeClient+		projectManager      plugins.ProjectManager+		pe                  github.PullRequestEvent+		expectedColumnCards map[int][]github.ProjectCard+		expectedError       error+	}{+		{+			name: "add pull request to project column with no columnID",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn2",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				2: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "add pull request to project column with only columnID",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				// Note that repoProjects and ProjectColumns are empty so the columnID cannot be looked up using repo, project and column names+				// This means if the project_manager plugin is not using the columnID specified in the config this test will fail+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										ID:     columnID,+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				1: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "don't add pull request with incorrect labels",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+					},+					"testProject2": {+						{+							Name: "testColumn2",+							ID:   4,+						},+						{+							Name: "testColumn",+							ID:   3,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{},+			expectedError:       fmt.Errorf("could not find column %s in project %s", "testColumn", "testProject"),

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++package projectmanager++import (+	"fmt"+	"testing"++	"github.com/sirupsen/logrus"+	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/github/fakegithub"+	"k8s.io/test-infra/prow/plugins"+)++func TestHandlePR(t *testing.T) {+	columnID := new(int)+	*columnID = 1+	columnIDMap := map[string]map[int]string{+		"testProject": {+			00001: "testColumn",+			00002: "testColumn2",+		},+		"testProject2": {+			00003: "testColumn",+			00004: "testColumn2",+		},+	}+	labels := []string{"otherOrg/someRepo#1:label1", "otherOrg/someRepo#1:label2", "otherOrg/someRepo#2:label1", "otherOrg2/someRepo#1:label1"}+	cases := []struct {+		name                string+		gc                  *fakegithub.FakeClient+		projectManager      plugins.ProjectManager+		pe                  github.PullRequestEvent+		expectedColumnCards map[int][]github.ProjectCard+		expectedError       error+	}{+		{+			name: "add pull request to project column with no columnID",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn2",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				2: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "add pull request to project column with only columnID",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				// Note that repoProjects and ProjectColumns are empty so the columnID cannot be looked up using repo, project and column names+				// This means if the project_manager plugin is not using the columnID specified in the config this test will fail+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										ID:     columnID,+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				1: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "don't add pull request with incorrect labels",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+					},+					"testProject2": {+						{+							Name: "testColumn2",+							ID:   4,+						},+						{+							Name: "testColumn",+							ID:   3,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{},+			expectedError:       fmt.Errorf("could not find column %s in project %s", "testColumn", "testProject"),+		},+		{+			name: "add pull request using column name in multirepo",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+					"testOrg/testRepo2": {+						{+							Name: "testProject2",+							ID:   2,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+					"testProject2": {+						{+							Name: "testColumn2",+							ID:   4,+						},+						{+							Name: "testColumn",+							ID:   3,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+					"testOrg/testRepo2": {+						Projects: map[string]plugins.ManagedProject{+							"testProject2": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn2",+										State:  "open",+										Org:    "otherOrg2",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg2",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				4: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "add pull request using column name in multirepo to multiple projects",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+					"testOrg/testRepo2": {+						{+							Name: "testProject2",+							ID:   2,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+					"testProject2": {+						{+							Name: "testColumn2",+							ID:   4,+						},+						{+							Name: "testColumn",+							ID:   3,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1"},+									},+								},+							},+						},+					},+					"testOrg/testRepo2": {+						Projects: map[string]plugins.ManagedProject{+							"testProject2": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn2",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				4: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+				1: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "add pull request using column name to multiple columns in a project should fail",

+/*+Copyright 2019 The Kubernetes Authors.++Licensed under the Apache License, Version 2.0 (the "License");+you may not use this file except in compliance with the License.+You may obtain a copy of the License at++    http://www.apache.org/licenses/LICENSE-2.0++Unless required by applicable law or agreed to in writing, software+distributed under the License is distributed on an "AS IS" BASIS,+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+See the License for the specific language governing permissions and+limitations under the License.+*/++package projectmanager++import (+	"fmt"+	"testing"++	"github.com/sirupsen/logrus"+	"k8s.io/test-infra/prow/github"+	"k8s.io/test-infra/prow/github/fakegithub"+	"k8s.io/test-infra/prow/plugins"+)++func TestHandlePR(t *testing.T) {+	columnID := new(int)+	*columnID = 1+	columnIDMap := map[string]map[int]string{+		"testProject": {+			00001: "testColumn",+			00002: "testColumn2",+		},+		"testProject2": {+			00003: "testColumn",+			00004: "testColumn2",+		},+	}+	labels := []string{"otherOrg/someRepo#1:label1", "otherOrg/someRepo#1:label2", "otherOrg/someRepo#2:label1", "otherOrg2/someRepo#1:label1"}+	cases := []struct {+		name                string+		gc                  *fakegithub.FakeClient+		projectManager      plugins.ProjectManager+		pe                  github.PullRequestEvent+		expectedColumnCards map[int][]github.ProjectCard+		expectedError       error+	}{+		{+			name: "add pull request to project column with no columnID",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn2",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				2: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "add pull request to project column with only columnID",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				// Note that repoProjects and ProjectColumns are empty so the columnID cannot be looked up using repo, project and column names+				// This means if the project_manager plugin is not using the columnID specified in the config this test will fail+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										ID:     columnID,+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				1: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "don't add pull request with incorrect labels",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+					},+					"testProject2": {+						{+							Name: "testColumn2",+							ID:   4,+						},+						{+							Name: "testColumn",+							ID:   3,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{},+			expectedError:       fmt.Errorf("could not find column %s in project %s", "testColumn", "testProject"),+		},+		{+			name: "add pull request using column name in multirepo",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+					"testOrg/testRepo2": {+						{+							Name: "testProject2",+							ID:   2,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+					"testProject2": {+						{+							Name: "testColumn2",+							ID:   4,+						},+						{+							Name: "testColumn",+							ID:   3,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+					"testOrg/testRepo2": {+						Projects: map[string]plugins.ManagedProject{+							"testProject2": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn2",+										State:  "open",+										Org:    "otherOrg2",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg2",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				4: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "add pull request using column name in multirepo to multiple projects",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+					"testOrg/testRepo2": {+						{+							Name: "testProject2",+							ID:   2,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+					"testProject2": {+						{+							Name: "testColumn2",+							ID:   4,+						},+						{+							Name: "testColumn",+							ID:   3,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1"},+									},+								},+							},+						},+					},+					"testOrg/testRepo2": {+						Projects: map[string]plugins.ManagedProject{+							"testProject2": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn2",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				4: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+				1: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "add pull request using column name to multiple columns in a project should fail",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/testRepo": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg/testRepo": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+									{+										Name:   "testColumn2",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				1: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+		{+			name: "add pull request using column name into org and repo projects",+			gc: &fakegithub.FakeClient{+				IssueLabelsAdded:   labels,+				IssueLabelsRemoved: []string{},+				RepoProjects: map[string][]github.Project{+					"testOrg/*": {+						{+							Name: "testProject",+							ID:   1,+						},+					},+					"testOrg/testRepo2": {+						{+							Name: "testProject2",+							ID:   2,+						},+					},+				},+				OrgProjects: map[string][]github.Project{},+				ProjectColumnsMap: map[string][]github.ProjectColumn{+					"testProject": {+						{+							Name: "testColumn2",+							ID:   2,+						},+						{+							Name: "testColumn",+							ID:   1,+						},+					},+					"testProject2": {+						{+							Name: "testColumn2",+							ID:   4,+						},+						{+							Name: "testColumn",+							ID:   3,+						},+					},+				},+				ColumnCardsMap: map[int][]github.ProjectCard{},+				ColumnIDMap:    columnIDMap,+			},+			projectManager: plugins.ProjectManager{+				OrgRepos: map[string]plugins.ManagedOrgRepo{+					"testOrg": {+						Projects: map[string]plugins.ManagedProject{+							"testProject": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1"},+									},+								},+							},+						},+					},+					"testOrg/testRepo2": {+						Projects: map[string]plugins.ManagedProject{+							"testProject2": {+								Columns: []plugins.ManagedColumn{+									{+										Name:   "testColumn2",+										State:  "open",+										Org:    "otherOrg",+										Labels: []string{"label1", "label2"},+									},+								},+							},+						},+					},+				},+			},+			pe: github.PullRequestEvent{+				Action: github.PullRequestActionOpened,+				Number: 1,+				PullRequest: github.PullRequest{+					ID:    2,+					State: "open",+				},+				Repo: github.Repo{+					Name: "someRepo",+					Owner: github.User{+						Login: "otherOrg",+					},+				},+			},+			expectedColumnCards: map[int][]github.ProjectCard{+				4: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+				1: {+					{+						ContentID:   2,+						ContentType: "PullRequest",+					},+				},+			},+		},+	}+	for _, c := range cases {+		t.Run(c.name, func(t *testing.T) {+			err := handlePR(c.gc, c.projectManager, logrus.NewEntry(logrus.New()), c.pe)+			if err != nil {+				if c.expectedError != nil && c.expectedError.Error() == err.Error() {+					return+				}+				t.Fatalf("handlePR error: %v", err)+			}