Implemented: support to fetch the enums based on parentType

Fetching enums with parentType ORDER_ROUTING
Improved type for enums state
Fetching enums on the initial load of runs page

src/services/UtilService.ts

@@ -0,0 +1,13 @@
+import api from "@/api"
+
+const fetchEnums = async (payload: any): Promise<any> => {
+  return api({
+    url: "enums", 
+    method: "GET",
+    params: payload
+  });
+}
+
+export const UtilService = {
+  fetchEnums
+}

src/store/modules/util/UtilState.ts

@@ -1,5 +1,9 @@
 import { Enumeration } from "@/types";
 
 export default interface UtilState {
-  enums: Array<Enumeration>
+  enums: {
+    [key: string]: {
+      [key: string]: Enumeration
+    }
+  }
 }

src/store/modules/util/actions.ts

@@ -1,7 +1,37 @@
 import { ActionTree } from "vuex"
 import RootState from "@/store/RootState"
 import UtilState from "./UtilState"
+import logger from "@/logger"
+import { hasError } from "@/utils"
+import * as types from "./mutation-types"
+import { UtilService } from "@/services/UtilService"
+import { EnumerationAndType } from "@/types"
 
-const actions: ActionTree<UtilState, RootState> = {}
+const actions: ActionTree<UtilState, RootState> = {
+  async fetchEnums({ commit }, payload) {
+    let enums = {}
+
+    try {
+      const resp = await UtilService.fetchEnums(payload);
+
+      if(!hasError(resp) && resp.data.length) {
+        enums = resp.data.reduce((enumerations: any, data: EnumerationAndType) => {
+          if(enumerations[data.enumTypeId]) {
+            enumerations[data.enumTypeId][data.enumId] = data
+          } else {
+            enumerations[data.enumTypeId] = {
+              [data.enumId]: data
+            }
+          }
+          return enumerations
+        }, {})
+      }
+    } catch(err) {
+      logger.error('error', err)
+    }
+
+    commit(types.UTIL_ENUMS_UPDATED, enums)
+  }
+}
 
 export default actions;

src/store/modules/util/index.ts

@@ -8,7 +8,7 @@ import RootState from "@/store/RootState"
 const utilModule: Module<UtilState, RootState> = {
   namespaced: true,
   state: {
-    enums: [],
+    enums: {},
   },
   getters,
   actions,

src/types/index.ts

@@ -8,6 +8,12 @@ type Enumeration = {
   sequenceNum: number
 }
 
+type EnumerationAndType = Enumeration & {
+  typeDescription: string,
+  parentTypeId: string,
+  hasTable: string
+}
+
 type Group = {
   routingGroupId: string,
   productStoreId: string,
@@ -46,6 +52,7 @@ type Rule = {
 
 export {
   Enumeration,
+  EnumerationAndType,
   Group,
   Route,
   Rule

src/views/BrokeringRuns.vue

@@ -54,10 +54,11 @@ import { useStore } from "vuex";
 
 const store = useStore()
 const router = useRouter()
-const groups = computed(() => store.getters['orderRouting/getRoutingGroups'])
+const groups = computed(() => store.getters["orderRouting/getRoutingGroups"])
 
 onIonViewWillEnter(async () => {
-  await store.dispatch('orderRouting/fetchOrderRoutingGroups');
+  await store.dispatch("orderRouting/fetchOrderRoutingGroups");
+  store.dispatch("util/fetchEnums", { parentTypeId: "ORDER_ROUTING" })
 })
 
 async function addNewRun() {