[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

@@ -413,6 +413,26 @@ func (p *Plugin) handleGetSubscriptions(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
+	projectList, err := p.Store.GetAllProjects(mattermostUserID)
+	if err != nil {
+		p.API.LogError(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)
@@ -432,7 +452,6 @@ 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 {
@@ -500,10 +519,8 @@ func (p *Plugin) handleGetSubscriptions(w http.ResponseWriter, r *http.Request)
 			}
 		}
 
-		subscriptionList = paginatedSubscriptions
+		p.writeJSON(w, paginatedSubscriptions)
 	}
-
-	p.writeJSON(w, subscriptionList)
 }
 
 func (p *Plugin) getReviewersListString(reviewersList []serializers.Reviewer) string {

server/plugin/api_test.go

@@ -704,60 +704,58 @@ 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
+			})
 
 			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 +766,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;