Merge pull request #510 from MeasureAuthoringTool/MAT-6006/addingUnus…

…edUsedAndFunctionsToQdmHighlightingTab

MAT-6006,6007,6008 added Used, Unused and Functions to QDM Highlighti…

src/api/useCqlParsingService.ts

@@ -2,6 +2,7 @@ import axios from "axios";
 import useServiceConfig from "./useServiceConfig";
 import { ServiceConfig } from "./ServiceContext";
 import { useOktaTokens } from "@madie/madie-util";
+import { CqlDefinitionExpression } from "../util/GroupCoverageHelpers";
 import { CqlDefinitionCallstack } from "../components/editTestCase/groupCoverage/QiCoreGroupCoverage";
 
 export class CqlParsingService {
@@ -25,6 +26,27 @@ export class CqlParsingService {
       throw new Error(message);
     }
   }
+
+  async getAllDefinitionsAndFunctions(
+    cql: string
+  ): Promise<CqlDefinitionExpression[]> {
+    try {
+      const response = await axios.put<string>(
+        `${this.baseUrl}/cql/definitions`,
+        cql,
+        {
+          headers: {
+            Authorization: `Bearer ${this.getAccessToken()}`,
+            "Content-Type": "text/plain",
+          },
+        }
+      );
+      return response.data as unknown as CqlDefinitionExpression[];
+    } catch (err) {
+      const message = `Unable to retrieve definition and function references`;
+      throw new Error(message);
+    }
+  }
 }
 
 const useCqlParsingService = (): CqlParsingService => {

src/components/editTestCase/groupCoverage/QdmGroupCoverage.tsx

@@ -6,8 +6,10 @@ import _, { isEmpty } from "lodash";
 import {
   MappedCql,
   Population,
+  QDMPopulationDefinition,
   getFirstPopulation,
   getPopulationAbbreviation,
+  isPopulation,
 } from "../../../util/GroupCoverageHelpers";
 import "twin.macro";
 import "styled-components/macro";
@@ -18,16 +20,24 @@ interface Props {
   testCaseGroups: GroupPopulation[];
   cqlPopulationDefinitions: MappedCql;
   measureGroups: Group[];
+  calculationResults;
 }
 
 type PopulationResult = Record<string, string>;
 
+const allDefinitions = [
+  { name: "Definitions" },
+  { name: "Functions" },
+  { name: "Unused" },
+];
+
 const populationCriteriaLabel = "Population Criteria";
 
 const QdmGroupCoverage = ({
   testCaseGroups,
   cqlPopulationDefinitions,
   measureGroups,
+  calculationResults,
 }: Props) => {
   const [selectedHighlightingTab, setSelectedHighlightingTab] =
     useState<Population>(getFirstPopulation(testCaseGroups[0]));
@@ -39,6 +49,8 @@ const QdmGroupCoverage = ({
     selectedPopulationDefinitionResults,
     setSelectedPopulationDefinitionResults,
   ] = useState<string>();
+  const [selectedAllDefinitions, setSelectedAllDefinitions] =
+    useState<QDMPopulationDefinition>();
 
   useEffect(() => {
     if (!isEmpty(testCaseGroups)) {
@@ -90,8 +102,111 @@ const QdmGroupCoverage = ({
     }
   };
 
+  const getDefintionCategoryFilteringCondition = (
+    statementResults,
+    definitionName,
+    definitionCategory
+  ) => {
+    if (definitionCategory === "Definitions") {
+      return statementResults[definitionName]?.relevance !== "NA";
+    }
+    if (definitionCategory === "Unused") {
+      return statementResults[definitionName]?.relevance === "NA";
+    }
+  };
+
+  const filterBasedOnDefinitionCategories = (
+    statementResults,
+    definitionCategory
+  ) => {
+    return Object.keys(statementResults)
+      .filter((definitionName) =>
+        getDefintionCategoryFilteringCondition(
+          statementResults,
+          definitionName,
+          definitionCategory
+        )
+      )
+      .reduce((result, definitionName) => {
+        result[definitionName] = statementResults[definitionName];
+        return result;
+      }, {});
+  };
+
+  const filterDefinitions = (
+    cqlPopulationDefinitions,
+    calculationResults,
+    definitionCategory
+  ): QDMPopulationDefinition => {
+    const statementResults =
+      calculationResults[Object.keys(calculationResults)[0]][selectedCriteria];
+
+    if (Object.keys(statementResults?.statement_results)) {
+      const filteredDefinitions = Object.keys(
+        statementResults?.statement_results
+      )
+        .map((definitionName) =>
+          filterBasedOnDefinitionCategories(
+            statementResults?.statement_results[definitionName],
+            definitionCategory
+          )
+        )
+        .reduce((result, statementResult) => {
+          Object.assign(result, statementResult);
+          return result;
+        }, {});
+
+      return Object.keys(
+        cqlPopulationDefinitions[selectedCriteria]?.definitions
+      )
+        .filter((definitionName) => filteredDefinitions[definitionName])
+        .reduce((result, definitionName) => {
+          result[definitionName] =
+            cqlPopulationDefinitions[selectedCriteria]?.definitions[
+              definitionName
+            ];
+          return result;
+        }, {});
+    }
+  };
+
+  const changeDefinitions = (population) => {
+    setSelectedHighlightingTab(population);
+    let resultDefinitions: QDMPopulationDefinition;
+
+    if (cqlPopulationDefinitions && calculationResults) {
+      if (population.name === "Functions") {
+        if (cqlPopulationDefinitions[selectedCriteria]?.functions) {
+          resultDefinitions =
+            cqlPopulationDefinitions[selectedCriteria].functions;
+        }
+      }
+      if (population.name === "Definitions") {
+        resultDefinitions = filterDefinitions(
+          cqlPopulationDefinitions,
+          calculationResults,
+          population.name
+        );
+      }
+      if (population.name === "Unused") {
+        resultDefinitions = filterDefinitions(
+          cqlPopulationDefinitions,
+          calculationResults,
+          population.name
+        );
+      }
+      setSelectedAllDefinitions(resultDefinitions);
+    }
+  };
+
   const onHighlightingNavTabClick = (selectedTab) => {
-    changePopulation(selectedTab);
+    if (isPopulation(selectedTab.name)) {
+      setSelectedAllDefinitions(null);
+      changePopulation(selectedTab);
+    } else {
+      setSelectedPopulationDefinitionResults(null);
+      changeDefinitions(selectedTab);
+    }
   };
 
   const getPopulationResults = (groupId: string) => {
@@ -108,6 +223,7 @@ const QdmGroupCoverage = ({
 
   const changeCriteria = (criteriaId: string) => {
     setSelectedCriteria(criteriaId);
+    setSelectedAllDefinitions(null);
     const populationResults = getPopulationResults(criteriaId);
     setPopulationResults(populationResults);
     const group = testCaseGroups.find((gp) => gp.groupId === criteriaId);
@@ -193,28 +309,63 @@ const QdmGroupCoverage = ({
           onChange={(e) => changeCriteria(e.target.value)}
         />
       </div>
-      <div tw="flex mt-5" key={selectedCriteria}>
+      <div
+        tw="flex mt-5"
+        key={selectedCriteria}
+        style={{ paddingBottom: "7px" }}
+      >
         <div tw="flex-none w-1/5">
           <GroupCoverageNav
             id={selectedCriteria}
             populations={getRelevantPopulations()}
             // used for definitions, functions and unused
-            allDefinitions={[]}
+            allDefinitions={allDefinitions}
             selectedHighlightingTab={selectedHighlightingTab}
             onClick={onHighlightingNavTabClick}
           />
         </div>
-        <div
-          tw="flex-auto p-3"
-          id={`${selectedHighlightingTab.abbreviation}-highlighting`}
-          data-testid={`${selectedHighlightingTab.abbreviation}-highlighting`}
-        >
-          {selectedPopulationDefinitionResults
-            ? parse(
-                `<pre><code>${selectedPopulationDefinitionResults}</code></pre>`
-              )
-            : "No results available"}
-        </div>
+
+        {!selectedAllDefinitions ? (
+          <div
+            tw="flex-auto p-3"
+            style={{ overflowX: "scroll" }}
+            id={`${selectedHighlightingTab.abbreviation}-highlighting`}
+            data-testid={`${selectedHighlightingTab.abbreviation}-highlighting`}
+          >
+            {selectedPopulationDefinitionResults
+              ? parse(
+                  `<pre><code>${selectedPopulationDefinitionResults}</code></pre>`
+                )
+              : "No results available"}
+          </div>
+        ) : (
+          <div>
+            {calculationResults &&
+            Object.keys(selectedAllDefinitions).length > 0 ? (
+              Object.values(selectedAllDefinitions)
+                .filter((definition: any) => !!definition.definitionLogic)
+                .map((definition: any, index) => {
+                  return (
+                    <div
+                      key={index}
+                      tw="flex-auto p-3"
+                      id={`${selectedHighlightingTab.name}-highlighting`}
+                      data-testid={`${_.camelCase(
+                        selectedHighlightingTab.name
+                      )}-highlighting`}
+                      style={{ borderBottomWidth: "4px" }}
+                    >
+                      {parse(
+                        `<pre><code>${definition?.definitionLogic}</code></pre>`
+                      )}
+                    </div>
+                  );
+                })
+            ) : (
+              <div tw="flex-auto p-3">No results available</div>
+            )}
+          </div>
+        )}
       </div>
     </>
   );

src/components/editTestCase/groupCoverage/QiCoreGroupCoverage.tsx

@@ -14,28 +14,13 @@ import { MappedCalculationResults } from "../qiCore/calculationResults/Calculati
 import { Relevance } from "fqm-execution/build/types/Enums";
 import GroupCoverageResultsSection from "./GroupCoverageResultsSection";
 import {
+  CqlDefinitionExpression,
   getFirstPopulation,
   getPopulationAbbreviation,
+  isPopulation,
 } from "../../../util/GroupCoverageHelpers";
 import "./QiCoreGroupCoverage.scss";
 
-export interface CqlDefinitionExpression {
-  id?: string;
-  definitionName: string;
-  definitionLogic: string;
-  context: string;
-  supplDataElement: boolean;
-  popDefinition: boolean;
-  commentString: string;
-  returnType: string | null;
-  parentLibrary: string | null;
-  libraryDisplayName: string | null;
-  libraryVersion: string | null;
-  function: boolean;
-  name: string;
-  logic: string;
-}
-
 export interface CqlDefinitionCallstack {
   [key: string]: Array<CqlDefinitionExpression>;
 }
@@ -237,10 +222,6 @@ const QiCoreGroupCoverage = ({
     );
   };
 
-  const isPopulation = (name: string) => {
-    return name !== "Functions" && name !== "Definitions" && name !== "Unused";
-  };
-
   const onHighlightingNavTabClick = (selectedTab) => {
     if (isPopulation(selectedTab.name)) {
       changePopulation(selectedTab);