[MI-2360] Updated APIs to create/delete subscriptions and subscription card for "Build" and "Release" events

server/constants/routes.go

@@ -16,8 +16,6 @@ const (
 	PathGetSubscriptions                    = "/subscriptions/{team_id:[A-Za-z0-9]+}"
 	PathSubscriptionNotifications           = "/notification"
 	PathGetUserChannelsForTeam              = "/channels/{team_id:[A-Za-z0-9]+}"
-	PathGetGitRepositories                  = "/{organization:[A-Za-z0-9-/ ]+}/{project:[A-Za-z0-9-/ ]+}/repositories"
-	PathGetGitRepositoryBranches            = "/{organization:[A-Za-z0-9-/ ]+}/{project:[A-Za-z0-9-/ ]+}/repositories/{repository:[A-Za-z0-9-/]+}/branches"
 	PathGetSubscriptionFilterPossibleValues = "/subscriptions/filters"
 
 	// Azure API paths

server/plugin/api.go

@@ -50,8 +50,6 @@ func (p *Plugin) InitRoutes() {
 	s.HandleFunc(constants.PathSubscriptionNotifications, p.handleSubscriptionNotifications).Methods(http.MethodPost)
 	s.HandleFunc(constants.PathSubscriptions, p.handleAuthRequired(p.checkOAuth(p.handleDeleteSubscriptions))).Methods(http.MethodDelete)
 	s.HandleFunc(constants.PathGetUserChannelsForTeam, p.handleAuthRequired(p.getUserChannelsForTeam)).Methods(http.MethodGet)
-	s.HandleFunc(constants.PathGetGitRepositories, p.handleAuthRequired(p.checkOAuth(p.handleGetGitRepositories))).Methods(http.MethodGet)
-	s.HandleFunc(constants.PathGetGitRepositoryBranches, p.handleAuthRequired(p.checkOAuth(p.handleGetGitRepositoryBranches))).Methods(http.MethodGet)
 	s.HandleFunc(constants.PathGetSubscriptionFilterPossibleValues, p.handleAuthRequired(p.checkOAuth(p.handleGetSubscriptionFilterPossibleValues))).Methods(http.MethodPost)
 }
 
@@ -297,6 +295,13 @@ func (p *Plugin) handleCreateSubscription(w http.ResponseWriter, r *http.Request
 		MergeResult:                  body.MergeResult,
 		NotificationType:             body.NotificationType,
 		AreaPath:                     body.AreaPath,
+		BuildStatus:                  body.BuildStatus,
+		BuildPipeline:                body.BuildPipeline,
+		StageName:                    body.StageName,
+		ReleasePipeline:              body.ReleasePipeline,
+		ReleaseStatus:                body.ReleaseStatus,
+		ApprovalType:                 body.ApprovalType,
+		ApprovalStatus:               body.ApprovalStatus,
 	}); isSubscriptionPresent {
 		p.API.LogError(constants.SubscriptionAlreadyPresent, "Error")
 		p.handleError(w, r, &serializers.Error{Code: http.StatusBadRequest, Message: constants.SubscriptionAlreadyPresent})
@@ -354,6 +359,19 @@ func (p *Plugin) handleCreateSubscription(w http.ResponseWriter, r *http.Request
 		NotificationType:                 body.NotificationType,
 		NotificationTypeName:             body.NotificationTypeName,
 		AreaPath:                         body.AreaPath,
+		BuildStatus:                      body.BuildStatus,
+		BuildPipeline:                    body.BuildPipeline,
+		StageName:                        body.StageName,
+		ReleasePipeline:                  body.ReleasePipeline,
+		ReleaseStatus:                    body.ReleaseStatus,
+		ApprovalType:                     body.ApprovalType,
+		ApprovalStatus:                   body.ApprovalStatus,
+		BuildStatusName:                  body.BuildStatusName,
+		StageNameValue:                   body.StageNameValue,
+		ReleasePipelineName:              body.ReleasePipelineName,
+		ReleaseStatusName:                body.ReleaseStatusName,
+		ApprovalTypeName:                 body.ApprovalTypeName,
+		ApprovalStatusName:               body.ApprovalStatusName,
 	}); storeErr != nil {
 		p.API.LogError("Error in creating a subscription", "Error", storeErr.Error())
 		p.handleError(w, r, &serializers.Error{Code: http.StatusInternalServerError, Message: storeErr.Error()})
@@ -437,7 +455,14 @@ func (p *Plugin) handleGetSubscriptions(w http.ResponseWriter, r *http.Request)
 				subscriptionByProject[i].PushedByName+
 				subscriptionByProject[i].MergeResultName+
 				subscriptionByProject[i].NotificationTypeName+
-				subscriptionByProject[i].AreaPath <
+				subscriptionByProject[i].AreaPath+
+				subscriptionByProject[i].ReleasePipelineName+
+				subscriptionByProject[i].BuildPipeline+
+				subscriptionByProject[i].BuildStatusName+
+				subscriptionByProject[i].ApprovalStatusName+
+				subscriptionByProject[i].ApprovalTypeName+
+				subscriptionByProject[i].StageNameValue+
+				subscriptionByProject[i].ReleaseStatusName <
 				subscriptionByProject[j].ChannelName+
 					subscriptionByProject[j].EventType+
 					subscriptionByProject[j].TargetBranch+
@@ -446,7 +471,14 @@ func (p *Plugin) handleGetSubscriptions(w http.ResponseWriter, r *http.Request)
 					subscriptionByProject[j].PushedByName+
 					subscriptionByProject[j].MergeResultName+
 					subscriptionByProject[j].NotificationTypeName+
-					subscriptionByProject[j].AreaPath
+					subscriptionByProject[j].AreaPath+
+					subscriptionByProject[i].ReleasePipelineName+
+					subscriptionByProject[i].BuildPipeline+
+					subscriptionByProject[i].BuildStatusName+
+					subscriptionByProject[i].ApprovalStatusName+
+					subscriptionByProject[i].ApprovalTypeName+
+					subscriptionByProject[i].StageNameValue+
+					subscriptionByProject[i].ReleaseStatusName
 		})
 
 		filteredSubscriptionList, filteredSubscriptionErr := p.GetSubscriptionsForAccessibleChannelsOrProjects(subscriptionByProject, teamID, mattermostUserID)
@@ -881,6 +913,13 @@ func (p *Plugin) handleDeleteSubscriptions(w http.ResponseWriter, r *http.Reques
 		MergeResult:                  body.MergeResult,
 		NotificationType:             body.NotificationType,
 		AreaPath:                     body.AreaPath,
+		BuildStatus:                  body.BuildStatus,
+		BuildPipeline:                body.BuildPipeline,
+		StageName:                    body.StageName,
+		ReleasePipeline:              body.ReleasePipeline,
+		ReleaseStatus:                body.ReleaseStatus,
+		ApprovalType:                 body.ApprovalType,
+		ApprovalStatus:               body.ApprovalStatus,
 	})
 	if !isSubscriptionPresent {
 		p.API.LogError(constants.SubscriptionNotFound)
@@ -1039,60 +1078,6 @@ func (p *Plugin) handleGetUserAccountDetails(w http.ResponseWriter, r *http.Requ
 	p.writeJSON(w, &userDetails)
 }
 
-func (p *Plugin) handleGetGitRepositories(w http.ResponseWriter, r *http.Request) {
-	mattermostUserID := r.Header.Get(constants.HeaderMattermostUserID)
-
-	pathParams := mux.Vars(r)
-	organization := pathParams[constants.PathParamOrganization]
-	project := pathParams[constants.PathParamProject]
-
-	if len(strings.TrimSpace(organization)) == 0 || len(strings.TrimSpace(project)) == 0 {
-		p.API.LogError(constants.ErrorOrganizationOrProjectQueryParam)
-		p.handleError(w, r, &serializers.Error{Code: http.StatusBadRequest, Message: constants.ErrorOrganizationOrProjectQueryParam})
-		return
-	}
-
-	response, statusCode, err := p.Client.GetGitRepositories(organization, project, mattermostUserID)
-	if err != nil {
-		p.API.LogError("Error in fetching git repositories", err.Error())
-		p.handleError(w, r, &serializers.Error{Code: statusCode, Message: err.Error()})
-		return
-	}
-
-	p.writeJSON(w, response.Value)
-}
-
-func (p *Plugin) handleGetGitRepositoryBranches(w http.ResponseWriter, r *http.Request) {
-	mattermostUserID := r.Header.Get(constants.HeaderMattermostUserID)
-
-	pathParams := mux.Vars(r)
-	organization := strings.TrimSpace(pathParams[constants.PathParamOrganization])
-	project := strings.TrimSpace(pathParams[constants.PathParamProject])
-	repository := strings.TrimSpace(pathParams[constants.PathParamRepository])
-
-	if len(organization) == 0 || len(project) == 0 || len(repository) == 0 {
-		p.API.LogError(constants.ErrorRepositoryPathParam)
-		p.handleError(w, r, &serializers.Error{Code: http.StatusBadRequest, Message: constants.ErrorRepositoryPathParam})
-		return
-	}
-
-	response, statusCode, err := p.Client.GetGitRepositoryBranches(organization, project, repository, mattermostUserID)
-	if err != nil {
-		p.API.LogError("Error in fetching git repository branches", err.Error())
-		p.handleError(w, r, &serializers.Error{Code: statusCode, Message: err.Error()})
-		return
-	}
-
-	// Azure DevOps returns branch name as "refs/heads/<branch-name>", but we need to use only "<branch-name>" so, remove unused part from the name
-	for _, value := range response.Value {
-		if strings.Contains(value.Name, "refs/heads/") && len(value.Name) > 11 {
-			value.Name = value.Name[11:]
-		}
-	}
-
-	p.writeJSON(w, response.Value)
-}
-
 func (p *Plugin) handleGetSubscriptionFilterPossibleValues(w http.ResponseWriter, r *http.Request) {
 	mattermostUserID := r.Header.Get(constants.HeaderMattermostUserID)
 

server/plugin/api_test.go

@@ -23,7 +23,6 @@ import (
 	"github.com/mattermost/mattermost-plugin-azure-devops/mocks"
 	"github.com/mattermost/mattermost-plugin-azure-devops/server/constants"
 	"github.com/mattermost/mattermost-plugin-azure-devops/server/serializers"
-	"github.com/mattermost/mattermost-plugin-azure-devops/server/testutils"
 )
 
 type panicHandler struct {
@@ -961,154 +960,3 @@ func TestGetUserChannelsForTeam(t *testing.T) {
 		})
 	}
 }
-
-func TestHandleGetGitRepositories(t *testing.T) {
-	defer monkey.UnpatchAll()
-	mockAPI := &plugintest.API{}
-	mockCtrl := gomock.NewController(t)
-	mockedClient := mocks.NewMockClient(mockCtrl)
-	p := setupMockPlugin(mockAPI, nil, mockedClient)
-	for _, testCase := range []struct {
-		description           string
-		organization          string
-		project               string
-		getGitRepositoriesErr error
-		statusCode            int
-	}{
-		{
-			description:  "HandleGetGitRepositories: valid",
-			organization: "mockOrganization",
-			project:      "mockProject",
-			statusCode:   http.StatusOK,
-		},
-		{
-			description:  "HandleGetGitRepositories: Invalid organization or project name",
-			organization: "mockOrganization",
-			statusCode:   http.StatusBadRequest,
-		},
-		{
-			description:           "HandleGetGitRepositories: GetGitRepositories returns error",
-			organization:          "mockOrganization",
-			project:               "mockProject",
-			getGitRepositoriesErr: errors.New("failed to get git repository branches"),
-			statusCode:            http.StatusInternalServerError,
-		},
-	} {
-		t.Run(testCase.description, func(t *testing.T) {
-			mockAPI.On("LogError", testutils.GetMockArgumentsWithType("string", 3)...)
-
-			if testCase.statusCode == http.StatusInternalServerError || testCase.statusCode == http.StatusOK {
-				mockedClient.EXPECT().GetGitRepositories(gomock.Any(), gomock.Any(), gomock.Any()).Return(&serializers.GitRepositoriesResponse{}, testCase.statusCode, testCase.getGitRepositoriesErr)
-			}
-
-			req := httptest.NewRequest(http.MethodGet, "/mockPath", bytes.NewBufferString(`{}`))
-			req.Header.Add(constants.HeaderMattermostUserID, "test-userID")
-
-			pathParams := map[string]string{
-				"organization": testCase.organization,
-				"project":      testCase.project,
-			}
-
-			req = mux.SetURLVars(req, pathParams)
-
-			w := httptest.NewRecorder()
-			p.handleGetGitRepositories(w, req)
-			resp := w.Result()
-			assert.Equal(t, testCase.statusCode, resp.StatusCode)
-		})
-	}
-}
-
-func TestHandleGetGitRepositoryBranches(t *testing.T) {
-	defer monkey.UnpatchAll()
-	mockAPI := &plugintest.API{}
-	mockCtrl := gomock.NewController(t)
-	mockedClient := mocks.NewMockClient(mockCtrl)
-	p := setupMockPlugin(mockAPI, nil, mockedClient)
-	for _, testCase := range []struct {
-		description                      string
-		organization                     string
-		repository                       string
-		project                          string
-		getGitRepositoryBranchesErr      error
-		statusCode                       int
-		getGitRepositoryBranchesResponse *serializers.GitBranchesResponse
-		expectedResponse                 []*serializers.GitBranch
-		expectedErrorResponse            interface{}
-	}{
-		{
-			description:  "HandleGetGitRepositoryBranches: valid",
-			organization: "mockOrganization",
-			project:      "mockProject",
-			repository:   "mockRepository",
-			statusCode:   http.StatusOK,
-			getGitRepositoryBranchesResponse: &serializers.GitBranchesResponse{
-				Value: testutils.GetGitBranchesPayload(),
-			},
-			expectedResponse: []*serializers.GitBranch{
-				{
-					ID:   "mockID-1",
-					Name: "mockName-1",
-				},
-				{
-					ID:   "mockID-2",
-					Name: "mockName-2",
-				},
-			},
-		},
-		{
-			description:           "HandleGetGitRepositoryBranches: Invalid organization, project or repository params",
-			organization:          "mockOrganization",
-			project:               "mockProject",
-			statusCode:            http.StatusBadRequest,
-			expectedErrorResponse: map[string]interface{}{"Error": constants.ErrorRepositoryPathParam},
-		},
-		{
-			description:                 "HandleGetGitRepositoryBranches: GetGitRepositoryBranches returns error",
-			organization:                "mockOrganization",
-			project:                     "mockProject",
-			repository:                  "mockRepository",
-			getGitRepositoryBranchesErr: errors.New("failed to get the git repository branches for a project"),
-			statusCode:                  http.StatusInternalServerError,
-			expectedErrorResponse:       map[string]interface{}{"Error": "failed to get the git repository branches for a project"},
-		},
-	} {
-		t.Run(testCase.description, func(t *testing.T) {
-			mockAPI.On("LogError", testutils.GetMockArgumentsWithType("string", 3)...)
-
-			if testCase.statusCode == http.StatusInternalServerError || testCase.statusCode == http.StatusOK {
-				mockedClient.EXPECT().GetGitRepositoryBranches(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(testCase.getGitRepositoryBranchesResponse, testCase.statusCode, testCase.getGitRepositoryBranchesErr)
-			}
-
-			req := httptest.NewRequest(http.MethodGet, "/mockPath", bytes.NewBufferString(`{}`))
-			req.Header.Add(constants.HeaderMattermostUserID, "mockUserID")
-
-			pathParams := map[string]string{
-				"organization": testCase.organization,
-				"project":      testCase.project,
-				"repository":   testCase.repository,
-			}
-
-			req = mux.SetURLVars(req, pathParams)
-
-			w := httptest.NewRecorder()
-			p.handleGetGitRepositoryBranches(w, req)
-			resp := w.Result()
-			assert.Equal(t, testCase.statusCode, resp.StatusCode)
-
-			if testCase.expectedErrorResponse != nil {
-				var actualResponse interface{}
-				err := json.NewDecoder(resp.Body).Decode(&actualResponse)
-				require.Nil(t, err)
-				assert.Equal(t, testCase.expectedErrorResponse, actualResponse)
-			}
-
-			if testCase.expectedResponse != nil {
-				var actualResponse []*serializers.GitBranch
-				err := json.NewDecoder(resp.Body).Decode(&actualResponse)
-				require.Nil(t, err)
-				assert.Equal(t, testCase.expectedResponse, actualResponse)
-			}
-		})
-	}
-}