@ampath/esm-laboratory-app 1.3.0-next.2 → 1.3.0-next.21

package/src/lab-tabs/modals/approval-lab-results-modal.component.tsx

@@ -1,8 +1,23 @@
-import React, { useState } from 'react';
+import React, { useCallback, useEffect, useState } from 'react';
 import { Button, ModalBody, ModalFooter, ModalHeader } from '@carbon/react';
-import { ExtensionSlot, showNotification, showSnackbar, useAbortController, type Order } from '@openmrs/esm-framework';
+import {
+  type Config,
+  ExtensionSlot,
+  showNotification,
+  showSnackbar,
+  useAbortController,
+  useConfig,
+  type Order,
+  showModal,
+} from '@openmrs/esm-framework';
 import { useTranslation } from 'react-i18next';
-import { setFulfillerStatus, useInvalidateLabOrders } from '../../laboratory.resource';
+import {
+  setFulfillerStatus,
+  updateObservationAndOrder,
+  useInvalidateLabOrders,
+  useMappedLabConcepts,
+} from '../../laboratory.resource';
+import styles from './approval-lab-results-modal.scss';
 
 interface ApproveLabResultsModal {
   closeModal: () => void;
@@ -14,31 +29,66 @@ const ApproveLabResultsModal: React.FC<ApproveLabResultsModal> = ({ order, close
   const [isSubmitting, setIsSubmitting] = useState(false);
   const abortController = useAbortController();
   const invalidateLabOrders = useInvalidateLabOrders();
+  const { laboratoryOrderTypeUuid } = useConfig<Config>();
+  const { completeLabResults, values, mutateResults } = useMappedLabConcepts(order);
 
   const handleApproval = () => {
     setIsSubmitting(true);
-    setFulfillerStatus(order.uuid, 'COMPLETED', abortController).then(
-      () => {
-        invalidateLabOrders();
-        setIsSubmitting(false);
-        closeModal();
-        showSnackbar({
-          isLowContrast: true,
-          title: t('resultsApproved', 'Results Approved'),
-          kind: 'success',
-          subtitle: t('labResultsApprovedSuccessfully', 'Lab results have been successfully approved and finalized'),
+    if (completeLabResults && completeLabResults.length > 0) {
+      updateObservationAndOrder(order, 'FINAL', 'COMPLETED', abortController, values, completeLabResults)
+        .then(() => {
+          invalidateLabOrders();
+          setIsSubmitting(false);
+          closeModal();
+          showSnackbar({
+            isLowContrast: true,
+            title: t('resultsApproved', 'Results Approved'),
+            kind: 'success',
+            subtitle: t('labResultsApprovedSuccessfully', 'Lab results have been successfully approved and finalized'),
+          });
+        })
+        .catch((error) => {
+          setIsSubmitting(false);
+          showNotification({
+            title: t('errorApprovingResults', 'Error approving results'),
+            kind: 'error',
+            critical: true,
+            description: error?.message,
+          });
         });
-      },
-      (error) => {
-        setIsSubmitting(false);
-        showNotification({
-          title: t('errorApprovingResults', 'Error approving results'),
-          kind: 'error',
-          critical: true,
-          description: error?.message,
-        });
-      },
-    );
+    }
+    // setFulfillerStatus(order.uuid, 'COMPLETED', abortController).then(
+    //   () => {
+    //     // invalidateLabOrders();
+    //     setIsSubmitting(false);
+    //     closeModal();
+    //     showSnackbar({
+    //       isLowContrast: true,
+    //       title: t('resultsApproved', 'Results Approved'),
+    //       kind: 'success',
+    //       subtitle: t('labResultsApprovedSuccessfully', 'Lab results have been successfully approved and finalized'),
+    //     });
+    //   },
+    //   (error) => {
+    //     setIsSubmitting(false);
+    //     showNotification({
+    //       title: t('errorApprovingResults', 'Error approving results'),
+    //       kind: 'error',
+    //       critical: true,
+    //       description: error?.message,
+    //     });
+    //   },
+    // );
+  };
+
+  const handleReject = () => {
+    closeModal();
+    setTimeout(() => {
+      const dispose = showModal('reject-lab-request-modal', {
+        closeModal: () => dispose(),
+        order,
+      });
+    }, 0);
   };
 
   return (
@@ -51,13 +101,13 @@ const ApproveLabResultsModal: React.FC<ApproveLabResultsModal> = ({ order, close
             'You are about to approve and finalize these lab results. Once approved, the results will be marked as complete and made available to clinicians. Are you sure you want to proceed?',
           )}
         </p>
-        <>
-          <ExtensionSlot state={{ order: order }} name="completed-lab-order-results-slot" />
-        </>
+        <div className={styles.resultsContainer}>
+          <ExtensionSlot state={{ order: order }} name="completed-lab-order-results-slot-1" />
+        </div>
       </ModalBody>
       <ModalFooter>
-        <Button kind="secondary" onClick={closeModal}>
-          {t('cancel', 'Cancel')}
+        <Button kind="danger" onClick={handleReject}>
+          {t('rejectLabResults', 'Reject lab results')}
         </Button>
         <Button type="submit" onClick={handleApproval} disabled={isSubmitting}>
           {t('approveResults', 'Approve Results')}

package/src/lab-tabs/modals/approval-lab-results-modal.scss

@@ -0,0 +1,9 @@
+.resultsContainer {
+  max-height: 500px;
+  overflow-y: auto;
+  overflow-x: hidden;
+  border: 1px solid #e0e0e0;
+  border-radius: 4px;
+  padding: 16px;
+  margin-top: 16px;
+}

package/src/lab-tiles/pending-review-lab-results-tile.component.tsx

@@ -6,7 +6,7 @@ import LabSummaryTile from '../components/summary-tile/lab-summary-tile.componen
 const PendingReviewLabRequestsTile = () => {
   const { t } = useTranslation();
   const { labOrders } = useLabOrders({
-    status: 'DRAFT',
+    status: 'ON_HOLD',
     excludeCanceled: false,
   });
 

package/src/laboratory.resource.ts

@@ -1,9 +1,28 @@
-import { useCallback } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import dayjs from 'dayjs';
 import useSWR, { mutate } from 'swr';
-import { openmrsFetch, type Order, restBaseUrl, useAppContext, useConfig } from '@openmrs/esm-framework';
-import type { DateFilterContext, FulfillerStatus } from './types';
+import {
+  openmrsFetch,
+  type Order,
+  restBaseUrl,
+  useAppContext,
+  useConfig,
+  useSession,
+  type FetchResponse,
+  showSnackbar,
+} from '@openmrs/esm-framework';
+import type {
+  DateFilterContext,
+  Encounter,
+  FulfillerStatus,
+  LabOrderConcept,
+  Observation,
+  ObservationStatus,
+  ObservationValue,
+  QueueEntryResult,
+} from './types';
 import { type Config } from './config-schema';
+import { getEtlBaseUrl } from './utils/utils';
 
 const useLabOrdersDefaultParams: UseLabOrdersParams = {
   status: null,
@@ -36,11 +55,12 @@ export function useLabOrders(params: Partial<UseLabOrdersParams> = useLabOrdersD
   const { dateRange } = useAppContext<DateFilterContext>('laboratory-date-filter') ?? {
     dateRange: [dayjs().startOf('day').toDate(), new Date()],
   };
+  const { sessionLocation } = useSession();
 
-  const { laboratoryOrderTypeUuid } = useConfig();
-  const customRepresentation = `custom:(uuid,orderNumber,patient:(uuid,display,person:(uuid,display,age,birthdate,gender)${
+  const { laboratoryOrderTypeUuid, filterByCurrentLocation } = useConfig<Config>();
+  const customRepresentation = `custom:(uuid,orderNumber,patient:(uuid,display,person:(uuid,display,age,birthdate,gender,attributes)${
     includePatientId ? ',identifiers' : ''
-  }),concept:(uuid,display),action,careSetting:(uuid,display,description,careSettingType,display),previousOrder,dateActivated,scheduledDate,dateStopped,autoExpireDate,encounter:(uuid,display),orderer:(uuid,display),orderReason,orderReasonNonCoded,orderType:(uuid,display,name,description,conceptClasses,parent),urgency,instructions,commentToFulfiller,display,fulfillerStatus,fulfillerComment,accessionNumber,specimenSource,laterality,clinicalHistory,frequency,numberOfRepeats)`;
+  }),concept:(uuid,display),action,careSetting:(uuid,display,description,careSettingType,display),previousOrder,dateActivated,scheduledDate,dateStopped,autoExpireDate,encounter:(uuid,display,location:(uuid)),orderer:(uuid,display),orderReason,orderReasonNonCoded,orderType:(uuid,display,name,description,conceptClasses,parent),urgency,instructions,commentToFulfiller,display,fulfillerStatus,fulfillerComment,accessionNumber,specimenSource,laterality,clinicalHistory,frequency,numberOfRepeats)`;
   let url = `${restBaseUrl}/order?orderTypes=${laboratoryOrderTypeUuid}&v=${customRepresentation}`;
   url = status ? url + `&fulfillerStatus=${status}` : url;
   url = excludeCanceled ? `${url}&excludeCanceledAndExpired=true&excludeDiscontinueOrders=true` : url;
@@ -54,9 +74,14 @@ export function useLabOrders(params: Partial<UseLabOrdersParams> = useLabOrdersD
     data: { results: Array<Order> };
   }>(`${url}`, openmrsFetch);
 
-  const filteredOrders = data?.data?.results?.filter(
+  let filteredOrders = data?.data?.results?.filter(
     (order) => !newOrdersOnly || (order?.action === 'NEW' && order?.fulfillerStatus === null),
   );
+
+  if (filterByCurrentLocation) {
+    filteredOrders = filteredOrders?.filter((order) => order.encounter?.location?.uuid === sessionLocation?.uuid);
+  }
+
   return {
     labOrders: filteredOrders ?? [],
     isLoading,
@@ -106,3 +131,361 @@ export function useInvalidateLabOrders() {
     );
   }, [laboratoryOrderTypeUuid]);
 }
+
+export function useQueueEntries(patientUuid: string = '') {
+  const [etlBaseUrl, setEtlBaseUrl] = useState('');
+  const { sessionLocation } = useSession();
+  const { serviceUuid } = useConfig<Config>();
+
+  useEffect(() => {
+    const fetchEtlBaseUrl = async () => {
+      const baseUrl = await getEtlBaseUrl();
+      setEtlBaseUrl(baseUrl);
+    };
+    fetchEtlBaseUrl();
+  }, []);
+
+  const url = `${etlBaseUrl}/queue-entry?locationUuid=${sessionLocation?.uuid}&serviceUuid=${serviceUuid}`;
+  const { data, error, mutate, isLoading, isValidating } = useSWR<{
+    data: { data: Array<QueueEntryResult> };
+  }>(etlBaseUrl ? `${url}` : null, openmrsFetch);
+
+  let filteredQueueEntries = data?.data?.data;
+
+  if (patientUuid) {
+    filteredQueueEntries = filteredQueueEntries?.filter((queueEntry) => queueEntry.patient_uuid === patientUuid);
+  }
+
+  return {
+    queueEntries: filteredQueueEntries ?? [],
+    isLoading,
+    isError: error,
+    mutate,
+    isValidating,
+  };
+}
+
+const labEncounterRepresentation =
+  'custom:(uuid,encounterDatetime,encounterType:(uuid,display),location:(uuid,name),patient:(uuid,display,person:(uuid,display,gender,age)),encounterProviders:(uuid,provider:(uuid,name)),obs:(uuid,obsDatetime,voided,groupMembers:(uuid,concept:(uuid,name:(uuid,name)),value:(uuid,display,name:(uuid,name),names:(uuid,conceptNameType,name)),interpretation),formFieldNamespace,formFieldPath,order:(uuid,display),concept:(uuid,name:(uuid,name)),value:(uuid,display,name:(uuid,name),names:(uuid,conceptNameType,name)),interpretation))';
+const labConceptRepresentation =
+  'custom:(uuid,display,name,datatype,set,answers,hiNormal,hiAbsolute,hiCritical,lowNormal,lowAbsolute,lowCritical,units,allowDecimal,' +
+  'setMembers:(uuid,display,answers,datatype,hiNormal,hiAbsolute,hiCritical,lowNormal,lowAbsolute,lowCritical,units,allowDecimal,set,setMembers:(uuid)))';
+const conceptObsRepresentation = 'custom:(uuid,display,concept:(uuid,display),groupMembers,value)';
+
+export function useLabEncounter(encounterUuid: string) {
+  const apiUrl = `${restBaseUrl}/encounter/${encounterUuid}?v=${labEncounterRepresentation}`;
+
+  const { data, error, isLoading, isValidating, mutate } = useSWR<FetchResponse<Encounter>, Error>(
+    apiUrl,
+    openmrsFetch,
+  );
+
+  return {
+    encounter: data?.data,
+    isLoading,
+    error: error,
+    isValidating,
+    mutate,
+  };
+}
+
+export function useObservation(obsUuid: string) {
+  const url = `${restBaseUrl}/obs/${obsUuid}?v=${conceptObsRepresentation}`;
+
+  const { data, error, isLoading, isValidating, mutate } = useSWR<{ data: Observation }, Error>(
+    obsUuid ? url : null,
+    openmrsFetch,
+  );
+  return {
+    data: data?.data,
+    isLoading,
+    error,
+    isValidating,
+    mutate,
+  };
+}
+
+export function useObservations(obsUuids: Array<string>) {
+  const fetchMultipleObservations = async (): Promise<Array<Observation>> => {
+    const results = await Promise.all(
+      obsUuids.map(async (uuid) => {
+        const url = `${restBaseUrl}/obs/${uuid}?v=${conceptObsRepresentation}`;
+        const res = await openmrsFetch(url);
+        return res.data;
+      }),
+    );
+
+    return results;
+  };
+
+  const { data, error, isLoading, isValidating, mutate } = useSWR<Observation[], Error>(
+    obsUuids && obsUuids.length > 0 ? ['observations', ...obsUuids] : null,
+    fetchMultipleObservations,
+  );
+
+  return {
+    data: data ?? [],
+    isLoading,
+    error,
+    isValidating,
+    mutate,
+  };
+}
+
+export function useCompletedLabResults(order: Order) {
+  const {
+    encounter,
+    isLoading: isLoadingEncounter,
+    mutate: mutateLabOrders,
+    error: encounterError,
+  } = useLabEncounter(order.encounter.uuid);
+  const {
+    data: observation,
+    isLoading: isLoadingObs,
+    error: isErrorObs,
+    mutate: mutateObs,
+  } = useObservation(encounter?.obs.find((obs) => obs?.concept?.uuid === order?.concept?.uuid)?.uuid ?? '');
+
+  return {
+    isLoading: isLoadingEncounter || isLoadingObs,
+    completeLabResult: observation,
+    mutate: () => {
+      mutateLabOrders();
+      mutateObs();
+    },
+    error: isErrorObs ?? encounterError,
+  };
+}
+
+export function useCompletedLabResultsArray(order: Order) {
+  const {
+    encounter,
+    isLoading: isLoadingEncounter,
+    mutate: mutateLabOrders,
+    error: encounterError,
+  } = useLabEncounter(order.encounter.uuid);
+
+  const obsUuids = encounter?.obs.filter((o) => o?.order.uuid === order?.uuid).map((o) => o.uuid);
+
+  const { data: observations, isLoading: isLoadingObs, error: errorObs, mutate: mutateObs } = useObservations(obsUuids);
+
+  return {
+    isLoading: isLoadingEncounter || isLoadingObs,
+    completeLabResults: observations,
+    mutate: () => {
+      mutateLabOrders();
+      mutateObs();
+    },
+    error: errorObs ?? encounterError,
+  };
+}
+
+function getUrlForConcept(conceptUuid: string) {
+  return `${restBaseUrl}/concept/${conceptUuid}?v=${labConceptRepresentation}`;
+}
+
+async function fetchAllSetMembers(conceptUuid: string): Promise<LabOrderConcept> {
+  const conceptResponse = await openmrsFetch<LabOrderConcept>(getUrlForConcept(conceptUuid));
+  const concept = conceptResponse.data;
+  const secondLevelSetMembers = concept.set
+    ? concept.setMembers
+        .map((member) => (member.set ? member.setMembers.map((lowerMember) => lowerMember.uuid) : []))
+        .flat()
+    : [];
+  if (secondLevelSetMembers.length > 0) {
+    const concepts = await Promise.all(secondLevelSetMembers.map((uuid) => fetchAllSetMembers(uuid)));
+    const uuidMap = concepts.reduce((acc, c) => {
+      acc[c.uuid] = c;
+      return acc;
+    }, {} as Record<string, LabOrderConcept>);
+    concept.setMembers = concept.setMembers.map((member) => {
+      if (member.set) {
+        member.setMembers = member.setMembers.map((lowerMember) => uuidMap[lowerMember.uuid]);
+      }
+      return member;
+    });
+  }
+
+  return concept;
+}
+
+export function useOrderConceptByUuid(uuid: string) {
+  const apiUrl = `${restBaseUrl}/concept/${uuid}?v=${labConceptRepresentation}`;
+
+  const { data, error, isLoading, isValidating, mutate } = useSWR<LabOrderConcept, Error>(uuid, fetchAllSetMembers);
+  /**
+   * We are fetching 2 levels of set members at one go.
+   */
+
+  const results = useMemo(
+    () => ({
+      concept: data,
+      isLoading,
+      error,
+      isValidating,
+      mutate,
+    }),
+    [data, error, isLoading, isValidating, mutate],
+  );
+
+  return results;
+}
+
+export function useOrderConceptsByUuids(uuids: Array<string>) {
+  const { data, error, isLoading, isValidating, mutate } = useSWR<Array<LabOrderConcept>, Error>(
+    uuids.length ? ['concepts', ...uuids] : null,
+    () => Promise.all(uuids.map((uuid) => fetchAllSetMembers(uuid))),
+  );
+
+  const results = useMemo(
+    () => ({
+      concepts: data ?? [],
+      isLoading,
+      error,
+      isValidating,
+      mutate,
+    }),
+    [data, error, isLoading, isValidating, mutate],
+  );
+
+  return results;
+}
+
+export function updateObservation(observationUuid: string, payload: Record<string, any>) {
+  return openmrsFetch(`${restBaseUrl}/obs/${observationUuid}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(payload),
+  });
+}
+
+export const isCoded = (concept: LabOrderConcept) => concept.datatype?.display === 'Coded';
+export const isNumeric = (concept: LabOrderConcept) => concept.datatype?.display === 'Numeric';
+export const isPanel = (concept: LabOrderConcept) => concept.setMembers?.length > 0;
+export const isText = (concept: LabOrderConcept) => concept.datatype?.display === 'Text';
+
+export function useMappedLabConcepts(order: Order) {
+  const [orderConceptUuids, setOrderConceptUuids] = useState([]);
+  const {
+    isLoading: isLoadingLabResultsArray,
+    completeLabResults,
+    mutate: mutateResults,
+  } = useCompletedLabResultsArray(order);
+  const { isLoading: isLoadingResultConcepts, concepts: conceptArray } = useOrderConceptsByUuids(orderConceptUuids);
+  const [object, setObject] = useState({});
+
+  useEffect(() => {
+    if (Array.isArray(completeLabResults) && completeLabResults.length > 1) {
+      const conceptUuids = completeLabResults.map((r) => r.concept.uuid);
+      setOrderConceptUuids(conceptUuids);
+    }
+
+    const mapLabConcepts = () => {
+      if (Array.isArray(conceptArray) && conceptArray.length > 1) {
+        conceptArray.forEach((concept, index) => {
+          const completeLabResult = completeLabResults.find((r) => r.concept.uuid === concept.uuid);
+          if (concept && completeLabResult) {
+            if (isCoded(concept) && typeof completeLabResult?.value === 'object' && completeLabResult?.value?.uuid) {
+              const v = completeLabResult.value.uuid;
+              setObject((obj) => ({ ...obj, [concept.uuid]: v }));
+              // object[concept.uuid] = completeLabResult.value.uuid;
+              // setValue(concept.uuid, completeLabResult.value.uuid);
+            } else if (isNumeric(concept) && completeLabResult?.value) {
+              const v = parseFloat(completeLabResult.value as string);
+              setObject((obj) => ({ ...obj, [concept.uuid]: v }));
+              // object[concept.uuid] = parseFloat(completeLabResult.value as string);
+              // setValue(concept.uuid, parseFloat(completeLabResult.value as string));
+            } else if (isText(concept) && completeLabResult?.value) {
+              const v = completeLabResult?.value;
+              setObject((obj) => ({ ...obj, [concept.uuid]: v }));
+              // object[concept.uuid] = completeLabResult?.value;
+              // setValue(concept.uuid, completeLabResult?.value);
+            } else if (isPanel(concept)) {
+              concept.setMembers.forEach((member) => {
+                const obs = completeLabResult.groupMembers.find((v) => v.concept.uuid === member.uuid);
+                let value: ObservationValue;
+                if (isCoded(member)) {
+                  value = typeof obs?.value === 'object' ? obs.value.uuid : obs?.value;
+                } else if (isNumeric(member)) {
+                  value = obs?.value ? parseFloat(obs.value as string) : undefined;
+                } else if (isText(member)) {
+                  value = obs?.value;
+                }
+                if (value) {
+                  const v = value;
+                  setObject((obj) => ({ ...obj, [member.uuid]: v }));
+                  // object[member.uuid] = value; //setValue(member.uuid, value);
+                }
+              });
+            }
+          }
+        });
+      }
+    };
+
+    mapLabConcepts();
+
+    // if (conceptArray) {
+    //   mapLabConcepts();
+    // }
+  }, [completeLabResults, conceptArray]);
+
+  return {
+    values: object,
+    completeLabResults,
+    isLoading: isLoadingLabResultsArray || isLoadingResultConcepts,
+    mutateResults,
+  };
+}
+
+export async function updateObservationAndOrder(
+  order: Order,
+  observationStatus: ObservationStatus,
+  fulfillerStatus: FulfillerStatus,
+  abortController: AbortController,
+  values,
+  completeLabResults: Array<any>,
+) {
+  // const { completeLabResults, values, mutateResults } = useMappedLabConcepts(order);
+
+  const updateTasks = Object.entries(values)
+    .filter(([, value]) => value !== undefined && value !== null && value !== '')
+    .map(([conceptUuid, value]) => {
+      let obs = completeLabResults.find((r) => r.concept.uuid === conceptUuid);
+      if (!obs) {
+        for (const result of completeLabResults) {
+          obs = result.groupMembers?.find((m) => m.concept.uuid === conceptUuid);
+          if (obs) break;
+        }
+      }
+      const status = observationStatus;
+      return updateObservation(obs?.uuid, { value, status });
+    });
+  const updateResults = await Promise.allSettled(updateTasks);
+  const failedObsconceptUuids = updateResults.reduce((prev, curr, index) => {
+    if (curr.status === 'rejected') {
+      return [...prev, Object.keys(values).at(index)];
+    }
+    return prev;
+  }, []);
+
+  await setFulfillerStatus(order.uuid, fulfillerStatus, abortController);
+
+  // mutateResults();
+
+  const showNotification = (kind: 'error' | 'success', message: string) => {
+    showSnackbar({
+      title: kind === 'success' ? 'Save lab results' : 'Error saving lab results',
+      kind: kind,
+      subtitle: message,
+    });
+  };
+
+  if (failedObsconceptUuids.length) {
+    showNotification('error', 'Could not save obs with concept uuids ' + failedObsconceptUuids.join(', '));
+  } else {
+    showNotification('success', 'Lab results have been successfully updated');
+  }
+}

package/src/routes.json

@@ -13,12 +13,14 @@
     {
       "name": "laboratory-dashboard",
       "slot": "laboratory-dashboard-slot",
-      "component": "root"
+      "component": "root",
+      "privileges": ["O3 View Labs Dashboard"]
     },
     {
       "name": "laboratory-dashboard-link",
       "slot": "homepage-dashboard-slot",
       "component": "laboratoryDashboardLink",
+      "privileges": ["O3 View Labs Dashboard"],
       "meta": {
         "name": "laboratory",
         "slot": "laboratory-dashboard-slot",
@@ -152,6 +154,19 @@
       "name": "add-lab-request-results-action",
       "component": "addLabRequestResultsAction",
       "slot": "inprogress-tests-actions-slot"
+    },
+    {
+      "name": "generate-bill-request-action",
+      "component": "generateBillRequestAction",
+      "slot": "tests-ordered-actions-slot"
+    },
+    {
+      "name": "lab-result-1",
+      "component": "labResult",
+      "slot": "completed-lab-order-results-slot-1",
+      "meta": {
+        "fullWidth": false
+      }
     }
   ],
   "workspaces2": [
@@ -201,4 +216,4 @@
       "scopePattern": "/home/laboratory"
     }
   ]
-}
+}