[MI-2820]: Modified API endpoint to require a project to be provided

server/constants/routes.go

@@ -13,7 +13,7 @@ const (
 	PathCreateTasks                         = "/tasks"
 	PathLinkProject                         = "/link"
 	PathSubscriptions                       = "/subscriptions"
-	PathGetSubscriptions                    = "/subscriptions/{team_id:[A-Za-z0-9]+}"
+	PathGetSubscriptions                    = "/subscriptions/{team_id:[A-Za-z0-9]+}/{organization:[A-Za-z0-9-]+}/{project:.+}"
 	PathSubscriptionNotifications           = "/notification"
 	PathPipelineReleaseRequest              = "/pipeline-release-request"
 	PathPipelineRunRequest                  = "/pipeline-run-request"

server/plugin/api.go

@@ -408,11 +408,31 @@ func (p *Plugin) handleGetSubscriptions(w http.ResponseWriter, r *http.Request)
 	pathParams := mux.Vars(r)
 	teamID := pathParams[constants.PathParamTeamID]
 	if !model.IsValidId(teamID) {
-		p.API.LogError("Invalid team id")
+		p.API.LogWarn("Invalid team id")
 		http.Error(w, "Invalid team id", http.StatusBadRequest)
 		return
 	}
 
+	projectList, err := p.Store.GetAllProjects(mattermostUserID)
+	if err != nil {
+		p.API.LogWarn(constants.ErrorFetchProjectList, "Error", err.Error())
+		p.handleError(w, r, &serializers.Error{Code: http.StatusInternalServerError, Message: err.Error()})
+		return
+	}
+
+	organization := pathParams[constants.PathParamOrganization]
+	project := pathParams[constants.PathParamProject]
+	organizationName := strings.ToLower(organization)
+	projectName := cases.Title(language.Und).String(project)
+	if _, isProjectLinked := p.IsProjectLinked(projectList, serializers.ProjectDetails{
+		OrganizationName: organizationName,
+		ProjectName:      projectName,
+	}); !isProjectLinked {
+		p.API.LogWarn(fmt.Sprintf("Project %s is not linked", project))
+		p.handleError(w, r, &serializers.Error{Code: http.StatusBadRequest, Message: "requested project is not linked"})
+		return
+	}
+
 	var subscriptionList []*serializers.SubscriptionDetails
 	var subscriptionErr error
 	createdBy := r.URL.Query().Get(constants.QueryParamCreatedBy)
@@ -423,7 +443,7 @@ func (p *Plugin) handleGetSubscriptions(w http.ResponseWriter, r *http.Request)
 		subscriptionList, subscriptionErr = p.Store.GetAllSubscriptions("")
 	}
 	if subscriptionErr != nil {
-		p.API.LogError(constants.FetchSubscriptionListError, "Error", subscriptionErr.Error())
+		p.API.LogWarn(constants.FetchSubscriptionListError, "Error", subscriptionErr.Error())
 		p.handleError(w, r, &serializers.Error{Code: http.StatusInternalServerError, Message: subscriptionErr.Error()})
 		return
 	}
@@ -432,78 +452,74 @@ func (p *Plugin) handleGetSubscriptions(w http.ResponseWriter, r *http.Request)
 	channelID := r.URL.Query().Get(constants.QueryParamChannelID)
 	serviceType := r.URL.Query().Get(constants.QueryParamServiceType)
 	eventType := r.URL.Query().Get(constants.QueryParamEventType)
-	project := r.URL.Query().Get(constants.QueryParamProject)
-	if project != "" {
-		subscriptionByProject := []*serializers.SubscriptionDetails{}
-		for _, subscription := range subscriptionList {
-			if subscription.ProjectName == project {
-				if channelID == "" || subscription.ChannelID == channelID {
-					switch serviceType {
+
+	subscriptionByProject := []*serializers.SubscriptionDetails{}
+	for _, subscription := range subscriptionList {
+		if subscription.ProjectName == project {
+			if channelID == "" || subscription.ChannelID == channelID {
+				switch serviceType {
+				case "", constants.FilterAll:
+					subscriptionByProject = append(subscriptionByProject, subscription)
+				case constants.FilterBoards:
+					switch eventType {
+					case "", constants.FilterAll:
+						if constants.ValidSubscriptionEventsForBoards[subscription.EventType] {
+							subscriptionByProject = append(subscriptionByProject, subscription)
+						}
+					default:
+						if subscription.EventType == eventType {
+							subscriptionByProject = append(subscriptionByProject, subscription)
+						}
+					}
+				case constants.FilterRepos:
+					switch eventType {
 					case "", constants.FilterAll:
-						subscriptionByProject = append(subscriptionByProject, subscription)
-					case constants.FilterBoards:
-						switch eventType {
-						case "", constants.FilterAll:
-							if constants.ValidSubscriptionEventsForBoards[subscription.EventType] {
-								subscriptionByProject = append(subscriptionByProject, subscription)
-							}
-						default:
-							if subscription.EventType == eventType {
-								subscriptionByProject = append(subscriptionByProject, subscription)
-							}
+						if constants.ValidSubscriptionEventsForRepos[subscription.EventType] {
+							subscriptionByProject = append(subscriptionByProject, subscription)
+						}
+					default:
+						if subscription.EventType == eventType {
+							subscriptionByProject = append(subscriptionByProject, subscription)
 						}
-					case constants.FilterRepos:
-						switch eventType {
-						case "", constants.FilterAll:
-							if constants.ValidSubscriptionEventsForRepos[subscription.EventType] {
-								subscriptionByProject = append(subscriptionByProject, subscription)
-							}
-						default:
-							if subscription.EventType == eventType {
-								subscriptionByProject = append(subscriptionByProject, subscription)
-							}
+					}
+				case constants.FilterPipelines:
+					switch eventType {
+					case "", constants.FilterAll:
+						if constants.ValidSubscriptionEventsForPipelines[subscription.EventType] {
+							subscriptionByProject = append(subscriptionByProject, subscription)
 						}
-					case constants.FilterPipelines:
-						switch eventType {
-						case "", constants.FilterAll:
-							if constants.ValidSubscriptionEventsForPipelines[subscription.EventType] {
-								subscriptionByProject = append(subscriptionByProject, subscription)
-							}
-						default:
-							if subscription.EventType == eventType {
-								subscriptionByProject = append(subscriptionByProject, subscription)
-							}
+					default:
+						if subscription.EventType == eventType {
+							subscriptionByProject = append(subscriptionByProject, subscription)
 						}
 					}
 				}
 			}
 		}
+	}
 
-		sort.Slice(subscriptionByProject, func(i, j int) bool {
-			return subscriptionByProject[i].CreatedAt.After(subscriptionByProject[j].CreatedAt)
-		})
+	sort.Slice(subscriptionByProject, func(i, j int) bool {
+		return subscriptionByProject[i].CreatedAt.After(subscriptionByProject[j].CreatedAt)
+	})
 
-		filteredSubscriptionList, filteredSubscriptionErr := p.GetSubscriptionsForAccessibleChannelsOrProjects(subscriptionByProject, teamID, mattermostUserID, constants.FilterCreatedByAnyone)
-		if filteredSubscriptionErr != nil {
-			p.API.LogError(constants.FetchFilteredSubscriptionListError, "Error", filteredSubscriptionErr.Error())
-			p.handleError(w, r, &serializers.Error{Code: http.StatusInternalServerError, Message: filteredSubscriptionErr.Error()})
-			return
-		}
+	filteredSubscriptionList, filteredSubscriptionErr := p.GetSubscriptionsForAccessibleChannelsOrProjects(subscriptionByProject, teamID, mattermostUserID, constants.FilterCreatedByAnyone)
+	if filteredSubscriptionErr != nil {
+		p.API.LogWarn(constants.FetchFilteredSubscriptionListError, "Error", filteredSubscriptionErr.Error())
+		p.handleError(w, r, &serializers.Error{Code: http.StatusInternalServerError, Message: filteredSubscriptionErr.Error()})
+		return
+	}
 
-		paginatedSubscriptions := []*serializers.SubscriptionDetails{}
-		for index, subscription := range filteredSubscriptionList {
-			if len(paginatedSubscriptions) == limit {
-				break
-			}
-			if index >= offset {
-				paginatedSubscriptions = append(paginatedSubscriptions, subscription)
-			}
+	paginatedSubscriptions := []*serializers.SubscriptionDetails{}
+	for index, subscription := range filteredSubscriptionList {
+		if len(paginatedSubscriptions) == limit {
+			break
+		}
+		if index >= offset {
+			paginatedSubscriptions = append(paginatedSubscriptions, subscription)
 		}
-
-		subscriptionList = paginatedSubscriptions
 	}
 
-	p.writeJSON(w, subscriptionList)
+	p.writeJSON(w, paginatedSubscriptions)
 }
 
 func (p *Plugin) getReviewersListString(reviewersList []serializers.Reviewer) string {

server/plugin/api_test.go

@@ -704,60 +704,62 @@ func TestHandleGetSubscriptions(t *testing.T) {
 	for _, testCase := range []struct {
 		description                                          string
 		subscriptionList                                     []*serializers.SubscriptionDetails
-		project                                              string
 		err                                                  error
 		marshalError                                         error
 		GetSubscriptionsForAccessibleChannelsOrProjectsError error
 		statusCode                                           int
 		isTeamIDValid                                        bool
+		isProjectLinked                                      bool
 	}{
 		{
 			description:      "HandleGetSubscriptions: valid",
 			subscriptionList: []*serializers.SubscriptionDetails{},
 			statusCode:       http.StatusOK,
 			isTeamIDValid:    true,
+			isProjectLinked:  true,
 		},
 		{
-			description:   "HandleGetSubscriptions: project as a query param",
-			project:       testutils.MockProjectName,
-			statusCode:    http.StatusOK,
-			isTeamIDValid: true,
-		},
-		{
-			description:   "HandleGetSubscriptions: error while fetching subscription list",
-			err:           errors.New("error while fetching subscription list"),
-			statusCode:    http.StatusInternalServerError,
-			isTeamIDValid: true,
-		},
-		{
-			description:   "HandleGetSubscriptions: empty subscription list",
-			statusCode:    http.StatusOK,
-			isTeamIDValid: true,
-		},
-		{
-			description:   "HandleGetSubscriptions: marshaling gives error",
-			marshalError:  errors.New("error while marshaling"),
-			statusCode:    http.StatusInternalServerError,
-			isTeamIDValid: true,
+			description:     "HandleGetSubscriptions: error while fetching subscription list",
+			err:             errors.New("error while fetching subscription list"),
+			statusCode:      http.StatusInternalServerError,
+			isTeamIDValid:   true,
+			isProjectLinked: true,
 		},
 		{
-			description: "HandleGetSubscriptions: GetSubscriptionsForAccessibleChannelsOrProjects gives error",
-			project:     testutils.MockProjectName,
-			GetSubscriptionsForAccessibleChannelsOrProjectsError: errors.New("error while getting subscriptions for accessible channels or projects"),
-			statusCode:    http.StatusInternalServerError,
-			isTeamIDValid: true,
+			description:     "HandleGetSubscriptions: empty subscription list",
+			statusCode:      http.StatusOK,
+			isTeamIDValid:   true,
+			isProjectLinked: true,
 		},
 		{
 			description:   "HandleGetSubscriptions: Team ID is invalid",
 			statusCode:    http.StatusBadRequest,
 			isTeamIDValid: false,
 		},
+		{
+			description:     "HandleGetSubscriptions: Project is not linked",
+			statusCode:      http.StatusBadRequest,
+			isTeamIDValid:   true,
+			isProjectLinked: false,
+		},
 	} {
 		t.Run(testCase.description, func(t *testing.T) {
 			mockAPI.On("LogError", testutils.GetMockArgumentsWithType("string", 3)...)
+			mockAPI.On("LogWarn", testutils.GetMockArgumentsWithType("string", 3)...)
+
+			monkey.PatchInstanceMethod(reflect.TypeOf(p), "IsProjectLinked", func(*Plugin, []serializers.ProjectDetails, serializers.ProjectDetails) (*serializers.ProjectDetails, bool) {
+				return &serializers.ProjectDetails{}, testCase.isProjectLinked
+			})
+
+			monkey.PatchInstanceMethod(reflect.TypeOf(p), "GetSubscriptionsForAccessibleChannelsOrProjects", func(_ *Plugin, _ []*serializers.SubscriptionDetails, _, _, _ string) ([]*serializers.SubscriptionDetails, error) {
+				return nil, testCase.GetSubscriptionsForAccessibleChannelsOrProjectsError
+			})
 
 			if testCase.isTeamIDValid {
-				mockedStore.EXPECT().GetAllSubscriptions(testutils.MockMattermostUserID).Return(testCase.subscriptionList, testCase.err)
+				if testCase.isProjectLinked {
+					mockedStore.EXPECT().GetAllSubscriptions(testutils.MockMattermostUserID).Return(testCase.subscriptionList, testCase.err)
+				}
+				mockedStore.EXPECT().GetAllProjects(testutils.MockMattermostUserID).Return([]serializers.ProjectDetails{}, nil)
 			}
 
 			monkey.Patch(json.Marshal, func(interface{}) ([]byte, error) {
@@ -768,11 +770,7 @@ func TestHandleGetSubscriptions(t *testing.T) {
 				return testCase.isTeamIDValid
 			})
 
-			monkey.PatchInstanceMethod(reflect.TypeOf(p), "GetSubscriptionsForAccessibleChannelsOrProjects", func(_ *Plugin, _ []*serializers.SubscriptionDetails, _, _, _ string) ([]*serializers.SubscriptionDetails, error) {
-				return nil, testCase.GetSubscriptionsForAccessibleChannelsOrProjectsError
-			})
-
-			req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("%s?project=%s", "/subscriptions", testCase.project), bytes.NewBufferString(`{}`))
+			req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/subscriptions/%s/%s/%s", testutils.MockTeamID, testutils.MockOrganization, testutils.MockProjectName), bytes.NewBufferString(`{}`))
 			req.Header.Add(constants.HeaderMattermostUserID, testutils.MockMattermostUserID)
 
 			w := httptest.NewRecorder()

server/testutils/mock.go

@@ -17,6 +17,7 @@ const (
 	MockServiceType       = "mockServiceType"
 	MockApproverID        = "mockApproverID"
 	MockAzureDevopsUserID = "mockAzureDevopsUserID"
+	MockTeamID            = "mockTeamID"
 )
 
 func GetMockArgumentsWithType(typeString string, num int) []interface{} {

webapp/src/containers/Rhs/projectDetails/index.tsx

@@ -50,6 +50,7 @@ const ProjectDetails = memo((projectDetails: ProjectDetails) => {
     const {makeApiRequestWithCompletionStatus, getApiState, state} = usePluginApi();
 
     const subscriptionListApiParams = useMemo<FetchSubscriptionList>(() => ({
+        organization: organizationName,
         project: projectName,
         channel_id: showAllSubscriptions ? '' : currentChannelId,
         page: paginationQueryParams.page,
@@ -58,7 +59,7 @@ const ProjectDetails = memo((projectDetails: ProjectDetails) => {
         service_type: filter.serviceType,
         event_type: filter.eventType,
         team_id: currentTeamId,
-    }), [projectName, currentChannelId, currentTeamId, showAllSubscriptions, paginationQueryParams, filter]);
+    }), [organizationName, projectName, currentChannelId, currentTeamId, showAllSubscriptions, paginationQueryParams, filter]);
 
     const {data, isLoading} = getApiState(pluginConstants.pluginApiServiceConfigs.getSubscriptionList.apiServiceName, subscriptionListApiParams);
     const subscriptionListReturnedByApi = data as SubscriptionDetails[] || [];

webapp/src/services/pluginApi.ts

@@ -60,7 +60,7 @@ export const azureDevOpsPluginApi = createApi({
         }),
         [Constants.pluginApiServiceConfigs.getSubscriptionList.apiServiceName]: builder.query<SubscriptionDetails[], FetchSubscriptionList>({
             query: (params) => ({
-                url: `${Constants.pluginApiServiceConfigs.getSubscriptionList.path}/${params.team_id}`,
+                url: `${Constants.pluginApiServiceConfigs.getSubscriptionList.path}/${params.team_id}/${params.organization}/${params.project}`,
                 method: Constants.pluginApiServiceConfigs.getSubscriptionList.method,
                 params: {...params},
             }),

webapp/src/types/common/index.d.ts

@@ -64,6 +64,7 @@ type FetchChannelParams = {
 }
 
 interface FetchSubscriptionList extends PaginationQueryParams {
+    organization: string;
     project: string;
     channel_id: string;
     created_by: string;