@openmrs/esm-fast-data-entry-app 1.0.0-pre.9 → 1.0.1-pre.101

package/src/context/FormWorkflowContext.tsx

@@ -0,0 +1,126 @@
+import React, { useEffect, useMemo, useReducer } from "react";
+import reducer from "./FormWorkflowReducer";
+import { useParams, useLocation } from "react-router-dom";
+import useGetSystemSetting from "../hooks/useGetSystemSetting";
+import { useSession } from "@openmrs/esm-framework";
+interface ParamTypes {
+  formUuid?: string;
+}
+
+const initialActions = {
+  addPatient: (uuid: string | number) => undefined,
+  openPatientSearch: () => undefined,
+  saveEncounter: (encounterUuid: string | number) => undefined,
+  editEncounter: (patientUuid: string | number) => undefined,
+  submitForNext: () => undefined,
+  submitForReview: () => undefined,
+  submitForComplete: () => undefined,
+  goToReview: () => undefined,
+  destroySession: () => undefined,
+  closeSession: () => undefined,
+};
+
+export const initialWorkflowState = {
+  // activeFormUuid and forms are the only two real values stored at state root level
+  activeFormUuid: null, // the corrently open form
+  forms: {}, // object containing all forms session data
+  // the following fields will be available in context but are not stored at the
+  //     state root level, but refer to nested values for the current
+  //     aciveFormUuid
+  workflowState: null, // pseudo field from state[activeFormUuid].workflowState
+  activePatientUuid: null, // pseudo field from state[activeFormUuid].activePatientUuid
+  activeEncounterUuid: null, // pseudo field from state[activeFormUuid].encounterUuid
+  patientUuids: [], // pseudo field from state[activeFormUuid].patientUuids
+  encounters: {}, // pseudo field from state[activeFormUuid].encounters
+  singleSessionVisitTypeUuid: null,
+  userUuid: null, // UUID of the user to which this workflow state belongs to
+};
+
+const FormWorkflowContext = React.createContext({
+  ...initialWorkflowState,
+  ...initialActions,
+});
+
+const FormWorkflowProvider = ({ children }) => {
+  const { user } = useSession();
+  const { formUuid } = useParams() as ParamTypes;
+  const activeFormUuid = formUuid.split("&")[0];
+  const { search } = useLocation();
+  const newPatientUuid = new URLSearchParams(search).get("patientUuid");
+  const [state, dispatch] = useReducer(reducer, {
+    ...initialWorkflowState,
+    ...initialActions,
+  });
+  const systemSetting = useGetSystemSetting(
+    "@openmrs/esm-fast-data-entry-app.groupSessionVisitTypeUuid"
+  );
+  const singleSessionVisitTypeUuid =
+    systemSetting?.result?.data?.results?.[0]?.value;
+
+  const actions = useMemo(
+    () => ({
+      initializeWorkflowState: ({ activeFormUuid, newPatientUuid }) =>
+        dispatch({
+          type: "INITIALIZE_WORKFLOW_STATE",
+          activeFormUuid,
+          newPatientUuid,
+          userUuid: user.uuid,
+        }),
+      addPatient: (patientUuid) =>
+        dispatch({ type: "ADD_PATIENT", patientUuid }),
+      openPatientSearch: () => dispatch({ type: "OPEN_PATIENT_SEARCH" }),
+      saveEncounter: (encounterUuid) =>
+        dispatch({
+          type: "SAVE_ENCOUNTER",
+          encounterUuid,
+        }),
+      submitForNext: () => dispatch({ type: "SUBMIT_FOR_NEXT" }),
+      submitForReview: () => dispatch({ type: "SUBMIT_FOR_REVIEW" }),
+      submitForComplete: () => dispatch({ type: "SUBMIT_FOR_COMPLETE" }),
+      editEncounter: (patientUuid) =>
+        dispatch({ type: "EDIT_ENCOUNTER", patientUuid }),
+      goToReview: () => dispatch({ type: "GO_TO_REVIEW" }),
+      destroySession: () => dispatch({ type: "DESTROY_SESSION" }),
+      closeSession: () => dispatch({ type: "CLOSE_SESSION" }),
+    }),
+    [user]
+  );
+
+  // if formUuid isn't a part of state yet, grab it from the url params
+  // this is the entry into the workflow system
+  useEffect(() => {
+    if (state?.workflowState === null && activeFormUuid) {
+      actions.initializeWorkflowState({ activeFormUuid, newPatientUuid });
+    }
+  }, [activeFormUuid, newPatientUuid, state?.workflowState, actions]);
+
+  return (
+    <FormWorkflowContext.Provider
+      value={{
+        ...state,
+        ...actions,
+        workflowState:
+          state.forms?.[state.activeFormUuid]?.workflowState ??
+          initialWorkflowState.workflowState,
+        activePatientUuid:
+          state.forms?.[state.activeFormUuid]?.activePatientUuid ??
+          initialWorkflowState.activePatientUuid,
+        activeEncounterUuid:
+          state.forms?.[state.activeFormUuid]?.activeEncounterUuid ??
+          initialWorkflowState.activeEncounterUuid,
+        patientUuids:
+          state.forms?.[state.activeFormUuid]?.patientUuids ??
+          initialWorkflowState.patientUuids,
+        encounters:
+          state.forms?.[state.activeFormUuid]?.encounters ??
+          initialWorkflowState.encounters,
+        singleSessionVisitTypeUuid,
+      }}
+    >
+      {children}
+    </FormWorkflowContext.Provider>
+  );
+};
+
+export default FormWorkflowContext;
+export { FormWorkflowProvider };

package/src/context/FormWorkflowReducer.ts

@@ -0,0 +1,287 @@
+import { navigate } from "@openmrs/esm-framework";
+import { initialWorkflowState } from "./FormWorkflowContext";
+
+export const fdeWorkflowStorageVersion = "1.1.0";
+export const fdeWorkflowStorageName = "openmrs:fastDataEntryWorkflowState";
+const persistData = (data) => {
+  localStorage.setItem(
+    fdeWorkflowStorageName + ":" + data.userUuid,
+    JSON.stringify(data)
+  );
+};
+
+const initialFormState = {
+  workflowState: "NEW_PATIENT",
+  activePatientUuid: null,
+  activeEncounterUuid: null,
+  patientUuids: [],
+  encounters: {},
+};
+
+const reducer = (state, action) => {
+  switch (action.type) {
+    case "INITIALIZE_WORKFLOW_STATE": {
+      const savedData = localStorage.getItem(
+        fdeWorkflowStorageName + ":" + action.userUuid
+      );
+      const savedDataObject = savedData ? JSON.parse(savedData) : {};
+      let newState: { [key: string]: unknown } = {};
+      const newPatient = action.newPatientUuid
+        ? {
+            activePatientUuid: action.newPatientUuid,
+            workflowState: "EDIT_FORM",
+          }
+        : {};
+
+      if (
+        savedData &&
+        savedDataObject["_storageVersion"] === fdeWorkflowStorageVersion
+      ) {
+        // there is localStorage data and it is still valid
+        newState = {
+          ...savedDataObject,
+          activeFormUuid: action.activeFormUuid,
+          forms: {
+            ...savedDataObject.forms,
+            // initialize this particular form if it hasn't been created already
+            [action.activeFormUuid]: {
+              ...initialFormState,
+              ...savedDataObject.forms[action.activeFormUuid],
+              // if we receive activePatientUuid from a query parameter use that one
+              ...newPatient,
+              patientUuids:
+                savedDataObject.forms[action.activeFormUuid]?.patientUuids ||
+                initialFormState.patientUuids,
+            },
+          },
+        };
+        if (
+          action.newPatientUuid &&
+          !newState.forms[action.activeFormUuid].patientUuids.includes(
+            action.newPatientUuid
+          )
+        ) {
+          newState.forms[action.activeFormUuid].patientUuids.push(
+            action.newPatientUuid
+          );
+        }
+      } else {
+        // no localStorage data, or we should void it
+        newState = {
+          ...initialWorkflowState,
+          _storageVersion: fdeWorkflowStorageVersion,
+          forms: {
+            [action.activeFormUuid]: initialFormState,
+          },
+          activeFormUuid: action.activeFormUuid,
+          userUuid: action.userUuid,
+        };
+      }
+      persistData(newState);
+      return { ...newState };
+    }
+    case "ADD_PATIENT": {
+      const newState = {
+        ...state,
+        forms: {
+          ...state.forms,
+          [state.activeFormUuid]: {
+            ...state.forms[state.activeFormUuid],
+            patientUuids: [
+              ...state.forms[state.activeFormUuid].patientUuids,
+              action.patientUuid,
+            ],
+            activePatientUuid: action.patientUuid,
+            activeEncounterUuid: null,
+            workflowState: "EDIT_FORM",
+          },
+        },
+      };
+      persistData(newState);
+      return newState;
+    }
+    case "OPEN_PATIENT_SEARCH": {
+      const newState = {
+        ...state,
+        forms: {
+          ...state.forms,
+          [state.activeFormUuid]: {
+            ...state.forms[state.activeFormUuid],
+            activePatientUuid: null,
+            activeEncounterUuid: null,
+            workflowState: "NEW_PATIENT",
+          },
+        },
+      };
+      // the persist here is optional...
+      persistData(newState);
+      return newState;
+    }
+    case "SAVE_ENCOUNTER": {
+      if (
+        state.forms[state.activeFormUuid].workflowState ===
+        "SUBMIT_FOR_COMPLETE"
+      ) {
+        const { [state.activeFormUuid]: activeForm, ...formRest } = state.forms;
+        const newState = {
+          ...state,
+          forms: formRest,
+          activeFormUuid: null,
+        };
+        persistData(newState);
+        // eslint-disable-next-line
+        navigate({ to: "${openmrsSpaBase}/forms" });
+        return newState;
+      } else {
+        const newState = {
+          ...state,
+          forms: {
+            ...state.forms,
+            [state.activeFormUuid]: {
+              ...state.forms[state.activeFormUuid],
+              encounters: {
+                ...state.forms[state.activeFormUuid].encounters,
+                [state.forms[state.activeFormUuid].activePatientUuid]:
+                  action.encounterUuid,
+              },
+              activePatientUuid: null,
+              activeEncounterUuid: null,
+              workflowState:
+                state.forms[state.activeFormUuid].workflowState ===
+                "SUBMIT_FOR_NEXT"
+                  ? "NEW_PATIENT"
+                  : state.forms[state.activeFormUuid].workflowState ===
+                    "SUBMIT_FOR_REVIEW"
+                  ? "REVIEW"
+                  : state.forms[state.activeFormUuid].workflowState,
+            },
+          },
+        };
+        persistData(newState);
+        return newState;
+      }
+    }
+    case "EDIT_ENCOUNTER": {
+      const newState = {
+        ...state,
+        forms: {
+          ...state.forms,
+          [state.activeFormUuid]: {
+            ...state.forms[state.activeFormUuid],
+            activeEncounterUuid:
+              state.forms[state.activeFormUuid].encounters[action.patientUuid],
+            activePatientUuid: action.patientUuid,
+            workflowState: "EDIT_FORM",
+          },
+        },
+      };
+      persistData(newState);
+      return newState;
+    }
+    case "SUBMIT_FOR_NEXT":
+      // this state should not be persisted
+      window.dispatchEvent(
+        new CustomEvent("ampath-form-action", {
+          detail: {
+            formUuid: state.activeFormUuid,
+            patientUuid: state.forms[state.activeFormUuid].activePatientUuid,
+            action: "onSubmit",
+          },
+        })
+      );
+      return {
+        ...state,
+        forms: {
+          ...state.forms,
+          [state.activeFormUuid]: {
+            ...state.forms[state.activeFormUuid],
+            workflowState: "SUBMIT_FOR_NEXT",
+          },
+        },
+      };
+    case "SUBMIT_FOR_REVIEW":
+      // this state should not be persisted
+      window.dispatchEvent(
+        new CustomEvent("ampath-form-action", {
+          detail: {
+            formUuid: state.activeFormUuid,
+            patientUuid: state.forms[state.activeFormUuid].activePatientUuid,
+            action: "onSubmit",
+          },
+        })
+      );
+      return {
+        ...state,
+        forms: {
+          ...state.forms,
+          [state.activeFormUuid]: {
+            ...state.forms[state.activeFormUuid],
+            workflowState: "SUBMIT_FOR_REVIEW",
+          },
+        },
+      };
+    case "SUBMIT_FOR_COMPLETE":
+      // this state should not be persisted
+      window.dispatchEvent(
+        new CustomEvent("ampath-form-action", {
+          detail: {
+            formUuid: state.activeFormUuid,
+            patientUuid: state.forms[state.activeFormUuid].activePatientUuid,
+            action: "onSubmit",
+          },
+        })
+      );
+      return {
+        ...state,
+        forms: {
+          ...state.forms,
+          [state.activeFormUuid]: {
+            ...state.forms[state.activeFormUuid],
+            workflowState: "SUBMIT_FOR_COMPLETE",
+          },
+        },
+      };
+    case "GO_TO_REVIEW": {
+      const newState = {
+        ...state,
+        forms: {
+          ...state.forms,
+          [state.activeFormUuid]: {
+            ...state.forms[state.activeFormUuid],
+            activeEncounterUuid: null,
+            activePatientUuid: null,
+            workflowState: "REVIEW",
+          },
+        },
+      };
+      persistData(newState);
+      return newState;
+    }
+    case "DESTROY_SESSION": {
+      const { [state.activeFormUuid]: activeForm, ...formRest } = state.forms;
+      const newState = {
+        ...state,
+        forms: formRest,
+        activeFormUuid: null,
+      };
+      persistData(newState);
+      //eslint-disable-next-line
+      navigate({ to: "${openmrsSpaBase}/forms" });
+      return newState;
+    }
+    case "CLOSE_SESSION": {
+      const newState = {
+        ...state,
+        activeFormUuid: null,
+      };
+      persistData(newState);
+      //eslint-disable-next-line
+      navigate({ to: "${openmrsSpaBase}/forms" });
+      return newState;
+    }
+    default:
+      return state;
+  }
+};
+
+export default reducer;

package/src/context/GroupFormWorkflowContext.tsx

@@ -0,0 +1,176 @@
+import React, { useEffect, useMemo, useReducer } from "react";
+import reducer from "./GroupFormWorkflowReducer";
+import { useParams } from "react-router-dom";
+import { Type, useSession } from "@openmrs/esm-framework";
+import useGetSystemSetting from "../hooks/useGetSystemSetting";
+interface ParamTypes {
+  formUuid?: string;
+}
+
+export interface GroupType {
+  id: string;
+  name: string;
+  members: Array<Type.Object>;
+}
+export interface MetaType {
+  sessionName: string;
+  sessionDate: string;
+  practitionerName: string;
+  sessionNotes: string;
+}
+
+const initialActions = {
+  setGroup: (group: GroupType) => undefined,
+  unsetGroup: () => undefined,
+  setSessionMeta: (meta: MetaType) => undefined,
+  openPatientSearch: () => undefined,
+  saveEncounter: (encounterUuid: string | number) => undefined,
+  editEncounter: (patientUuid: string | number) => undefined,
+  validateForNext: () => undefined,
+  validateForComplete: () => undefined,
+  updateVisitUuid: (visitUuid: string) => undefined,
+  submitForNext: (nextPatientUuid: string = null) => undefined,
+  submitForReview: () => undefined,
+  submitForComplete: () => undefined,
+  addPatientUuid: (patientUuid: string) => undefined,
+  removePatientUuid: (patientUuid: string) => undefined,
+  goToReview: () => undefined,
+  destroySession: () => undefined,
+  closeSession: () => undefined,
+};
+
+export const initialWorkflowState = {
+  // activeFormUuid and forms are the only two real values stored at state root level
+  activeFormUuid: null, // the corrently open form
+  forms: {}, // object containing all forms session data
+  // the following fields will be available in context but are not stored at the
+  //     state root level, but refer to nested values for the current
+  //     aciveFormUuid
+  workflowState: null, // pseudo field from state[activeFormUuid].workflowState
+  activePatientUuid: null, // pseudo field from state[activeFormUuid].activePatientUuid
+  activeEncounterUuid: null, // pseudo field from state[activeFormUuid].activeEncounterUuid
+  activeVisitUuid: null, // pseudo field from state[activeFormUuid].activeVisitUuid
+  patientUuids: [], // pseudo field from state[activeFormUuid].patientUuids
+  encounters: {}, // pseudo field from state[activeFormUuid].encounters
+  visits: {}, // pseudo field from state[activeFormUuid].visits
+  activeGroupUuid: null, // pseudo field from state[activeFormUuid].groupUuid
+  activeGroupName: null, // pseudo field from state[activeFormUuid].groupName
+  activeGroupMembers: [], // pseudo field from state[activeFormUuid].groupMembers
+  activeSessionMeta: {
+    sessionName: null,
+    practitionerName: null,
+    sessionDate: null,
+    sessionNotes: null,
+  },
+  groupVisitTypeUuid: null,
+  userUuid: null, // UUID of the user to which this workflow state belongs to
+};
+
+const GroupFormWorkflowContext = React.createContext({
+  ...initialWorkflowState,
+  ...initialActions,
+});
+
+const GroupFormWorkflowProvider = ({ children }) => {
+  const { user } = useSession();
+  const { formUuid } = useParams() as ParamTypes;
+  const activeFormUuid = formUuid.split("&")[0];
+  const systemSetting = useGetSystemSetting(
+    "@openmrs/esm-fast-data-entry-app.groupSessionVisitTypeUuid"
+  );
+  const groupVisitTypeUuid = systemSetting?.result?.data?.results?.[0]?.value;
+  const [state, dispatch] = useReducer(reducer, {
+    ...initialWorkflowState,
+    ...initialActions,
+  });
+
+  const actions = useMemo(
+    () => ({
+      initializeWorkflowState: ({ activeFormUuid }) =>
+        dispatch({
+          type: "INITIALIZE_WORKFLOW_STATE",
+          activeFormUuid,
+          userUuid: user.uuid,
+        }),
+      setGroup: (group) => dispatch({ type: "SET_GROUP", group }),
+      unsetGroup: () => dispatch({ type: "UNSET_GROUP" }),
+      setSessionMeta: (meta) => dispatch({ type: "SET_SESSION_META", meta }),
+      addPatientUuid: (patientUuid) =>
+        dispatch({ type: "ADD_PATIENT_UUID", patientUuid }),
+      removePatientUuid: (patientUuid) =>
+        dispatch({ type: "REMOVE_PATIENT_UUID", patientUuid }),
+      openPatientSearch: () => dispatch({ type: "OPEN_PATIENT_SEARCH" }),
+      saveEncounter: (encounterUuid) =>
+        dispatch({
+          type: "SAVE_ENCOUNTER",
+          encounterUuid,
+        }),
+      validateForNext: () => dispatch({ type: "VALIDATE_FOR_NEXT" }),
+      validateForComplete: () => dispatch({ type: "VALIDATE_FOR_COMPLETE" }),
+      updateVisitUuid: (visitUuid) =>
+        dispatch({ type: "UPDATE_VISIT_UUID", visitUuid }),
+      submitForNext: (nextPatientUuid) =>
+        dispatch({ type: "SUBMIT_FOR_NEXT", nextPatientUuid }),
+      submitForComplete: () => dispatch({ type: "SUBMIT_FOR_COMPLETE" }),
+      editEncounter: (patientUuid) =>
+        dispatch({ type: "EDIT_ENCOUNTER", patientUuid }),
+      goToReview: () => dispatch({ type: "GO_TO_REVIEW" }),
+      destroySession: () => dispatch({ type: "DESTROY_SESSION" }),
+      closeSession: () => dispatch({ type: "CLOSE_SESSION" }),
+    }),
+    [user]
+  );
+
+  // if formUuid isn't a part of state yet, grab it from the url params
+  // this is the entry into the workflow system
+  useEffect(() => {
+    if (state?.workflowState === null && activeFormUuid) {
+      actions.initializeWorkflowState({ activeFormUuid });
+    }
+  }, [activeFormUuid, state?.workflowState, actions]);
+
+  return (
+    <GroupFormWorkflowContext.Provider
+      value={{
+        groupVisitTypeUuid,
+        ...state,
+        ...actions,
+        workflowState:
+          state.forms?.[state.activeFormUuid]?.workflowState ??
+          initialWorkflowState.workflowState,
+        activePatientUuid:
+          state.forms?.[state.activeFormUuid]?.activePatientUuid ??
+          initialWorkflowState.activePatientUuid,
+        activeEncounterUuid:
+          state.forms?.[state.activeFormUuid]?.activeEncounterUuid ??
+          initialWorkflowState.activeEncounterUuid,
+        activeVisitUuid:
+          state.forms?.[state.activeFormUuid]?.activeVisitUuid ??
+          initialWorkflowState.activeVisitUuid,
+        patientUuids:
+          state.forms?.[state.activeFormUuid]?.patientUuids ??
+          initialWorkflowState.patientUuids,
+        encounters:
+          state.forms?.[state.activeFormUuid]?.encounters ??
+          initialWorkflowState.encounters,
+        activeGroupUuid:
+          state.forms?.[state.activeFormUuid]?.groupUuid ??
+          initialWorkflowState.activeGroupUuid,
+        activeGroupName:
+          state.forms?.[state.activeFormUuid]?.groupName ??
+          initialWorkflowState.activeGroupName,
+        activeGroupMembers:
+          state.forms?.[state.activeFormUuid]?.groupMembers ??
+          initialWorkflowState.activeGroupMembers,
+        activeSessionMeta:
+          state.forms?.[state.activeFormUuid]?.sessionMeta ??
+          initialWorkflowState.activeSessionMeta,
+      }}
+    >
+      {children}
+    </GroupFormWorkflowContext.Provider>
+  );
+};
+
+export default GroupFormWorkflowContext;
+export { GroupFormWorkflowProvider };