From 5b0b431498027bb67d8d54b0b7c54833c5c94fac Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Wed, 17 Jan 2024 12:53:27 +0530
Subject: [PATCH 01/16] Implemented: support for fetching the rules for
 orderRouting(#24)

---
 src/router/index.ts                           |  5 +--
 src/services/RoutingService.ts                | 11 +++++-
 .../modules/orderRouting/OrderRoutingState.ts |  2 +-
 src/store/modules/orderRouting/actions.ts     | 32 ++++++++++++++++-
 src/store/modules/orderRouting/getters.ts     |  9 ++++-
 src/store/modules/orderRouting/index.ts       |  2 +-
 .../modules/orderRouting/mutation-types.ts    |  2 +-
 src/store/modules/orderRouting/mutations.ts   |  4 +--
 src/views/BrokeringQuery.vue                  | 36 ++++++++++++-------
 src/views/BrokeringRoute.vue                  |  7 +++-
 10 files changed, 87 insertions(+), 23 deletions(-)

diff --git a/src/router/index.ts b/src/router/index.ts
index 163ee06..9b65a9a 100644
--- a/src/router/index.ts
+++ b/src/router/index.ts
@@ -43,8 +43,9 @@ const routes: Array<RouteRecordRaw> = [
         props: true
       },
       {
-        path: "brokering/query",
-        component: () => import("@/views/BrokeringQuery.vue")
+        path: "brokering/:routingGroupId/:orderRoutingId/rules",
+        component: () => import("@/views/BrokeringQuery.vue"),
+        props: true
       },
       {
         path: "settings",
diff --git a/src/services/RoutingService.ts b/src/services/RoutingService.ts
index f7d2acf..6336d77 100644
--- a/src/services/RoutingService.ts
+++ b/src/services/RoutingService.ts
@@ -24,8 +24,17 @@ const fetchOrderRoutings = async (payload: any): Promise<any> => {
   });
 }
 
+const fetchRoutingRules = async (payload: any): Promise<any> => {
+  return api({
+    url: `routings/${payload.orderRoutingId}/rules`,
+    method: "GET",
+    query: payload
+  });
+}
+
 export const OrderRoutingService = {
   createRoutingGroup,
   fetchOrderRoutings,
-  fetchRoutingGroups
+  fetchRoutingGroups,
+  fetchRoutingRules
 }
\ No newline at end of file
diff --git a/src/store/modules/orderRouting/OrderRoutingState.ts b/src/store/modules/orderRouting/OrderRoutingState.ts
index 38e7251..6b19fb2 100644
--- a/src/store/modules/orderRouting/OrderRoutingState.ts
+++ b/src/store/modules/orderRouting/OrderRoutingState.ts
@@ -1,7 +1,7 @@
 export default interface OrderRoutingState {
   groups: Array<any>; // runs
   routes: Array<any>;
-  rule: Array<any>;
+  rules: Array<any>;
   currentGroupId: string;
   currentRouteId: string;
 }
\ No newline at end of file
diff --git a/src/store/modules/orderRouting/actions.ts b/src/store/modules/orderRouting/actions.ts
index f21c163..15e80e3 100644
--- a/src/store/modules/orderRouting/actions.ts
+++ b/src/store/modules/orderRouting/actions.ts
@@ -77,7 +77,37 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
     }
 
     commit(types.ORDER_ROUTINGS_UPDATED, orderRoutings)
-  }
+  },
+
+  async fetchRoutingRules({ commit }, orderRoutingId) {
+    let routingRules = [] as any;
+    // filter groups on the basis of productStoreId
+    const payload = {
+      orderRoutingId
+    }
+
+    try {
+      const resp = await OrderRoutingService.fetchRoutingRules(payload);
+
+      if(!hasError(resp) && resp.data.length) {
+        routingRules = resp.data
+      } else {
+        throw resp.data
+      }
+    } catch(err) {
+      logger.error(err);
+    }
+
+    if(routingRules.length) {
+      routingRules = sortSequence(routingRules)
+    }
+
+    commit(types.ORDER_ROUTING_RULES_UPDATED, routingRules)
+  },
+
+  async setCurrentOrderRoutingId({ commit }, payload) {
+    commit(types.ORDER_ROUTING_CURRENT_ROUTE_UPDATED, payload)
+  },
 }
 
 export default actions;
\ No newline at end of file
diff --git a/src/store/modules/orderRouting/getters.ts b/src/store/modules/orderRouting/getters.ts
index 85a27fd..03866c8 100644
--- a/src/store/modules/orderRouting/getters.ts
+++ b/src/store/modules/orderRouting/getters.ts
@@ -1,7 +1,7 @@
 import { GetterTree } from "vuex"
 import OrderRoutingState from "./OrderRoutingState"
 import RootState from "@/store/RootState"
-import { Group } from "@/types"
+import { Group, Route } from "@/types"
 
 const getters: GetterTree<OrderRoutingState, RootState> = {
   getRoutingGroups(state) {
@@ -10,9 +10,16 @@ const getters: GetterTree<OrderRoutingState, RootState> = {
   getOrderRoutings(state) {
     return state.routes
   },
+  getRoutingRules(state) {
+    return state.rules
+  },
   getCurrentRoutingGroup(state) {
     const currentRoutingGroup = state.groups?.find((group: Group) => group.routingGroupId === state.currentGroupId)
     return currentRoutingGroup ? currentRoutingGroup : {}
+  },
+  getCurrentOrderRouting(state) {
+    const orderRouting = state.routes?.find((route: Route) => route.orderRoutingId === state.currentRouteId)
+    return orderRouting ? orderRouting : {}
   }
 }
 
diff --git a/src/store/modules/orderRouting/index.ts b/src/store/modules/orderRouting/index.ts
index 275bf06..f589cf9 100644
--- a/src/store/modules/orderRouting/index.ts
+++ b/src/store/modules/orderRouting/index.ts
@@ -10,7 +10,7 @@ const orderRoutingModule: Module<OrderRoutingState, RootState> = {
   state: {
     groups: [],
     routes: [],
-    rule: [],
+    rules: [],
     currentGroupId: '', // choosing only to save id and not whole object, as when updating the state we don't need to care updating the state on two different places
     currentRouteId: ''
   },
diff --git a/src/store/modules/orderRouting/mutation-types.ts b/src/store/modules/orderRouting/mutation-types.ts
index 4515191..9df8103 100644
--- a/src/store/modules/orderRouting/mutation-types.ts
+++ b/src/store/modules/orderRouting/mutation-types.ts
@@ -1,6 +1,6 @@
 export const SN_ORDER_ROUTING = "orderRouting"
 export const ORDER_ROUTING_GROUPS_UPDATED = SN_ORDER_ROUTING + "/GROUPS_UPDATED"
 export const ORDER_ROUTINGS_UPDATED = SN_ORDER_ROUTING + "/ROUTES_UPDATED"
-export const ORDER_ROUTING_RULE_UPDATED = SN_ORDER_ROUTING + "/RULE_UPDATED"
+export const ORDER_ROUTING_RULES_UPDATED = SN_ORDER_ROUTING + "/RULE_UPDATED"
 export const ORDER_ROUTING_CURRENT_GROUP_UPDATED = SN_ORDER_ROUTING + "/CURRENT_GROUP_UPDATED"
 export const ORDER_ROUTING_CURRENT_ROUTE_UPDATED = SN_ORDER_ROUTING + "/CURRENT_ROUTE_UPDATED"
\ No newline at end of file
diff --git a/src/store/modules/orderRouting/mutations.ts b/src/store/modules/orderRouting/mutations.ts
index 1667a59..8f8581c 100644
--- a/src/store/modules/orderRouting/mutations.ts
+++ b/src/store/modules/orderRouting/mutations.ts
@@ -9,8 +9,8 @@ const mutations: MutationTree<OrderRoutingState> = {
   [types.ORDER_ROUTINGS_UPDATED](state, payload) {
     state.routes = payload
   },
-  [types.ORDER_ROUTING_RULE_UPDATED](state, payload) {
-    state.rule = payload
+  [types.ORDER_ROUTING_RULES_UPDATED](state, payload) {
+    state.rules = payload
   },
   [types.ORDER_ROUTING_CURRENT_GROUP_UPDATED](state, groupId) {
     state.currentGroupId = groupId
diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index 170af6b..1d1c18a 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -4,7 +4,7 @@
       <div>
         <div class="menu">
           <ion-item lines="none">
-            <ion-label>{{ "<order lookup name>" }}</ion-label>
+            <ion-label>{{ currentRouting.routeName }}</ion-label>
             <ion-chip slot="end" outline @click="router.push('route')">
               {{ "2/4" }}
               <ion-icon :icon="chevronUpOutline" />
@@ -67,16 +67,8 @@
         <div class="menu">
           <ion-list>
             <ion-reorder-group :disabled="false">
-              <ion-item>
-                <ion-label>{{ "Warehouse only" }}</ion-label>
-                <ion-reorder />
-              </ion-item>
-              <ion-item>
-                <ion-label>{{ "Warehouse and stores" }}</ion-label>
-                <ion-reorder />
-              </ion-item>
-              <ion-item>
-                <ion-label>{{ "Any Location" }}</ion-label>
+              <ion-item v-for="rule in routingRules" :key="rule.routingRuleId">
+                <ion-label>{{ rule.ruleName }}</ion-label>
                 <ion-reorder />
               </ion-item>
             </ion-reorder-group>
@@ -186,11 +178,31 @@
 </template>
 
 <script setup lang="ts">
-import { IonButton, IonCard, IonChip, IonContent, IonIcon, IonItem, IonItemDivider, IonItemGroup, IonLabel, IonList, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption } from "@ionic/vue";
+import { IonButton, IonCard, IonChip, IonContent, IonIcon, IonItem, IonItemDivider, IonItemGroup, IonLabel, IonList, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, onIonViewWillEnter } from "@ionic/vue";
 import { checkmarkOutline, chevronUpOutline, filterOutline, optionsOutline, swapVerticalOutline } from "ionicons/icons"
 import { useRouter } from "vue-router";
+import { computed, defineProps } from "vue";
+import store from "@/store";
 
 const router = useRouter();
+const props = defineProps({
+  orderRoutingId: {
+    type: String,
+    required: true
+  },
+  routingGroupId: {
+    type: String,
+    requied: true
+  }
+})
+
+const currentRouting = computed(() => store.getters["orderRouting/getCurrentOrderRouting"])
+const routingRules = computed(() => store.getters["orderRouting/getRoutingRules"])
+
+onIonViewWillEnter(async () => {
+  await store.dispatch("orderRouting/fetchRoutingRules", props.orderRoutingId)
+})
+
 </script>
 
 <style scoped>
diff --git a/src/views/BrokeringRoute.vue b/src/views/BrokeringRoute.vue
index 0a9aeda..b9e10c8 100644
--- a/src/views/BrokeringRoute.vue
+++ b/src/views/BrokeringRoute.vue
@@ -18,7 +18,7 @@
               <ion-icon :icon="addCircleOutline" />
             </ion-button>
           </ion-list-header>
-          <ion-card v-for="routing in orderRoutings" :key="routing.orderRoutingId" @click="router.push('query')">
+          <ion-card v-for="routing in orderRoutings" :key="routing.orderRoutingId" @click="redirect(routing.orderRoutingId)">
             <ion-item lines="full">
               <ion-label>
                 <h1>{{ routing.routingName }}</h1>
@@ -106,6 +106,11 @@ onIonViewWillEnter(async () => {
     await store.dispatch("orderRouting/fetchOrderRoutingGroups")
   }
 })
+
+async function redirect(orderRoutingId: string) {
+  await store.dispatch('orderRouting/setCurrentOrderRoutingId', orderRoutingId)
+  router.push(`${orderRoutingId}/rules`)
+}
 </script>
 
 <style scoped>

From bb2e9842ca0019cfbe7b9da157302f3176a4a8dc Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Wed, 17 Jan 2024 15:44:26 +0530
Subject: [PATCH 02/16] Implemented: support to define state for storing order
 filters(#24)

---
 .../modules/orderRouting/OrderRoutingState.ts |  7 ++++
 src/store/modules/orderRouting/actions.ts     | 39 +++++++++++++++++++
 src/store/modules/orderRouting/getters.ts     |  3 ++
 src/store/modules/orderRouting/index.ts       |  3 +-
 .../modules/orderRouting/mutation-types.ts    |  3 +-
 src/store/modules/orderRouting/mutations.ts   |  3 ++
 6 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/src/store/modules/orderRouting/OrderRoutingState.ts b/src/store/modules/orderRouting/OrderRoutingState.ts
index 6b19fb2..b1b90ff 100644
--- a/src/store/modules/orderRouting/OrderRoutingState.ts
+++ b/src/store/modules/orderRouting/OrderRoutingState.ts
@@ -1,7 +1,14 @@
+import { RouteFilter } from "@/types";
+
 export default interface OrderRoutingState {
   groups: Array<any>; // runs
   routes: Array<any>;
   rules: Array<any>;
   currentGroupId: string;
   currentRouteId: string;
+  currentRouteFilters: {
+    [key: string]: {  // conditionTypeEnumId as key
+      [key: string]: RouteFilter  // enumCode/fieldName as key
+    }
+  };
 }
\ No newline at end of file
diff --git a/src/store/modules/orderRouting/actions.ts b/src/store/modules/orderRouting/actions.ts
index 15e80e3..50758c7 100644
--- a/src/store/modules/orderRouting/actions.ts
+++ b/src/store/modules/orderRouting/actions.ts
@@ -5,6 +5,7 @@ import { OrderRoutingService } from "@/services/RoutingService"
 import { hasError, showToast, sortSequence } from "@/utils"
 import * as types from './mutation-types'
 import logger from "@/logger"
+import { RouteFilter } from "@/types"
 
 const actions: ActionTree<OrderRoutingState, RootState> = {
   async fetchOrderRoutingGroups({ commit }) {
@@ -105,6 +106,44 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
     commit(types.ORDER_ROUTING_RULES_UPDATED, routingRules)
   },
 
+  async fetchRoutingFilters({ commit }, orderRoutingId) {
+    let routingFilters = [] as any;
+    // filter groups on the basis of productStoreId
+    const payload = {
+      orderRoutingId
+    }
+
+    try {
+      const resp = await OrderRoutingService.fetchRoutingFilters(payload);
+
+      if(!hasError(resp) && resp.data.length) {
+        routingFilters = resp.data.reduce((filters: any, filter: RouteFilter) => {
+          if(filters[filter.conditionTypeEnumId]) {
+            filters[filter.conditionTypeEnumId][filter.fieldName] = filter
+          } else {
+            filters[filter.conditionTypeEnumId] = {
+              [filter.fieldName]: filter
+            }
+          }
+          return filters
+        }, {})
+      } else {
+        throw resp.data
+      }
+    } catch(err) {
+      logger.error(err);
+    }
+
+    const sortEnum = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)["SORT"] as any
+
+    // As we only need to add support of reordering for sortBy filter
+    if(routingFilters[sortEnum]?.length) {
+      routingFilters[sortEnum] = sortSequence(routingFilters[sortEnum])
+    }
+
+    commit(types.ORDER_ROUTING_FILTERS_UPDATED, routingFilters)
+  },
+
   async setCurrentOrderRoutingId({ commit }, payload) {
     commit(types.ORDER_ROUTING_CURRENT_ROUTE_UPDATED, payload)
   },
diff --git a/src/store/modules/orderRouting/getters.ts b/src/store/modules/orderRouting/getters.ts
index 03866c8..221faf3 100644
--- a/src/store/modules/orderRouting/getters.ts
+++ b/src/store/modules/orderRouting/getters.ts
@@ -20,6 +20,9 @@ const getters: GetterTree<OrderRoutingState, RootState> = {
   getCurrentOrderRouting(state) {
     const orderRouting = state.routes?.find((route: Route) => route.orderRoutingId === state.currentRouteId)
     return orderRouting ? orderRouting : {}
+  },
+  getCurrentRouteFilters(state) {
+    return state.currentRouteFilters
   }
 }
 
diff --git a/src/store/modules/orderRouting/index.ts b/src/store/modules/orderRouting/index.ts
index f589cf9..b790847 100644
--- a/src/store/modules/orderRouting/index.ts
+++ b/src/store/modules/orderRouting/index.ts
@@ -12,7 +12,8 @@ const orderRoutingModule: Module<OrderRoutingState, RootState> = {
     routes: [],
     rules: [],
     currentGroupId: '', // choosing only to save id and not whole object, as when updating the state we don't need to care updating the state on two different places
-    currentRouteId: ''
+    currentRouteId: '',
+    currentRouteFilters: {}
   },
   getters,
   actions,
diff --git a/src/store/modules/orderRouting/mutation-types.ts b/src/store/modules/orderRouting/mutation-types.ts
index 9df8103..389eee3 100644
--- a/src/store/modules/orderRouting/mutation-types.ts
+++ b/src/store/modules/orderRouting/mutation-types.ts
@@ -3,4 +3,5 @@ export const ORDER_ROUTING_GROUPS_UPDATED = SN_ORDER_ROUTING + "/GROUPS_UPDATED"
 export const ORDER_ROUTINGS_UPDATED = SN_ORDER_ROUTING + "/ROUTES_UPDATED"
 export const ORDER_ROUTING_RULES_UPDATED = SN_ORDER_ROUTING + "/RULE_UPDATED"
 export const ORDER_ROUTING_CURRENT_GROUP_UPDATED = SN_ORDER_ROUTING + "/CURRENT_GROUP_UPDATED"
-export const ORDER_ROUTING_CURRENT_ROUTE_UPDATED = SN_ORDER_ROUTING + "/CURRENT_ROUTE_UPDATED"
\ No newline at end of file
+export const ORDER_ROUTING_CURRENT_ROUTE_UPDATED = SN_ORDER_ROUTING + "/CURRENT_ROUTE_UPDATED"
+export const ORDER_ROUTING_FILTERS_UPDATED = SN_ORDER_ROUTING + "/FILTERS_UPDATED"
\ No newline at end of file
diff --git a/src/store/modules/orderRouting/mutations.ts b/src/store/modules/orderRouting/mutations.ts
index 8f8581c..437676f 100644
--- a/src/store/modules/orderRouting/mutations.ts
+++ b/src/store/modules/orderRouting/mutations.ts
@@ -17,6 +17,9 @@ const mutations: MutationTree<OrderRoutingState> = {
   },
   [types.ORDER_ROUTING_CURRENT_ROUTE_UPDATED](state, routeId) {
     state.currentRouteId = routeId
+  },
+  [types.ORDER_ROUTING_FILTERS_UPDATED](state, payload) {
+    state.currentRouteFilters = payload
   }
 }
 export default mutations;
\ No newline at end of file

From ecb32c3459d85f91aa39a48c6868b29c45ca7f0e Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Wed, 17 Jan 2024 15:47:25 +0530
Subject: [PATCH 03/16] Implemented: service for fetching routeFilters, defined
 type for routeFilters, defined env entry to map filter with id and its code
 and added support to dynamically fetch the filters value(#24)

---
 .env.example                   |  3 ++-
 src/services/RoutingService.ts |  9 +++++++++
 src/types/index.ts             | 13 +++++++++++++
 src/views/BrokeringQuery.vue   | 19 ++++++++++++-------
 4 files changed, 36 insertions(+), 8 deletions(-)

diff --git a/.env.example b/.env.example
index 0bdf027..3adbc88 100644
--- a/.env.example
+++ b/.env.example
@@ -3,4 +3,5 @@ VUE_APP_I18N_FALLBACK_LOCALE=en
 VUE_APP_CACHE_MAX_AGE=3600
 VUE_APP_VIEW_SIZE=10
 VUE_APP_PERMISSION_ID=
-VUE_APP_DEFAULT_LOG_LEVEL="error"
\ No newline at end of file
+VUE_APP_DEFAULT_LOG_LEVEL="error"
+VUE_APP_RULE_ENUMS={"FILTER":"ENTCT_FILTER","SORT":"ENTCT_SORT_BY","QUEUE":{"id":"OIP_QUEUE","code":"facilityId"},"SHIPPING_METHOD":{"id":"OIP_SHIP_METH_TYPE","code":"shipmentMethodTypeId"},"PRIORITY":{"id":"OIP_PRIORITY","code":"priority"},"PROMISE_DATE":{"id":"OIP_PROMISE_DATE","code":"promiseDaysCutoff"},"SALES_CHANNEL":{"id":"OIP_SALES_CHANNEL","code":"salesChannelEnumId"},"SHIP_BY":{"id":"OSP_SHIP_BY","code":"shipBeforeDate"},"SHIP_AFTER":{"id":"OSP_SHIP_AFTER","code":"shipAfterDate"},"ORDER_DATE":{"id":"OSP_ORDER_DATE","code":"orderDate"},"SHIPPING_METHOD_SORT":{"id":"OSP_SHIP_METH","code":"deliveryDays"}}
\ No newline at end of file
diff --git a/src/services/RoutingService.ts b/src/services/RoutingService.ts
index 6336d77..cb670f4 100644
--- a/src/services/RoutingService.ts
+++ b/src/services/RoutingService.ts
@@ -32,9 +32,18 @@ const fetchRoutingRules = async (payload: any): Promise<any> => {
   });
 }
 
+const fetchRoutingFilters = async (payload: any): Promise<any> => {
+  return api({
+    url: `routings/${payload.orderRoutingId}/filter-conditions`,
+    method: "GET",
+    query: payload
+  });
+}
+
 export const OrderRoutingService = {
   createRoutingGroup,
   fetchOrderRoutings,
+  fetchRoutingFilters,
   fetchRoutingGroups,
   fetchRoutingRules
 }
\ No newline at end of file
diff --git a/src/types/index.ts b/src/types/index.ts
index b314955..a216dee 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -50,10 +50,23 @@ type Rule = {
   lastUpdatedStamp: string
 }
 
+type RouteFilter = {
+  orderRoutingId: string,
+  conditionSeqId: string,
+  conditionTypeEnumId: string,
+  fieldName: string,
+  operator: string,
+  fieldValue: string,
+  sequenceNum: number,
+  createdDate: string,
+  lastUpdatedStamp: string
+}
+
 export {
   Enumeration,
   EnumerationAndType,
   Group,
   Route,
+  RouteFilter,
   Rule
 }
\ No newline at end of file
diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index 1d1c18a..2be677d 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -5,7 +5,7 @@
         <div class="menu">
           <ion-item lines="none">
             <ion-label>{{ currentRouting.routeName }}</ion-label>
-            <ion-chip slot="end" outline @click="router.push('route')">
+            <ion-chip slot="end" outline @click="router.go(-1)">
               {{ "2/4" }}
               <ion-icon :icon="chevronUpOutline" />
             </ion-chip>
@@ -16,26 +16,26 @@
               <ion-label>{{ "Filters" }}</ion-label>
             </ion-item-divider>
             <ion-item>
-              <ion-select label="Queue" value="Brokering Queue">
+              <ion-select label="Queue" :value="routingFilters[enums['FILTER']]?.[enums['QUEUE'].code]">
                 <ion-select-option value="Brokering Queue">{{ "Brokering Queue" }}</ion-select-option>
               </ion-select>
             </ion-item>
             <ion-item>
-              <ion-select label="Shipping method" value="Next Day">
+              <ion-select label="Shipping method" :value="routingFilters[enums['FILTER']]?.[enums['SHIPPING_METHOD'].code]">
                 <ion-select-option value="Next Day">{{ "Next Day" }}</ion-select-option>
               </ion-select>
             </ion-item>
             <ion-item>
-              <ion-select label="Order priority" value="High">
+              <ion-select label="Order priority" :value="routingFilters[enums['FILTER']]?.[enums['PRIORITY'].code]">
                 <ion-select-option value="High">{{ "High" }}</ion-select-option>
               </ion-select>
             </ion-item>
             <ion-item>
               <ion-label>{{ "Promise date" }}</ion-label>
-              <ion-chip>{{ "select date" }}</ion-chip>
+              <ion-chip>{{ routingFilters[enums['FILTER']]?.[enums['PROMISE_DATE'].code] }}</ion-chip>
             </ion-item>
             <ion-item>
-              <ion-select label="Queue" value="Brokering Queue">
+              <ion-select label="Queue" :value="routingFilters[enums['FILTER']]?.[enums['SALES_CHANNEL'].code]">
                 <ion-select-option value="Brokering Queue">{{ "Brokering Queue" }}</ion-select-option>
               </ion-select>
             </ion-item>
@@ -69,7 +69,8 @@
             <ion-reorder-group :disabled="false">
               <ion-item v-for="rule in routingRules" :key="rule.routingRuleId">
                 <ion-label>{{ rule.ruleName }}</ion-label>
-                <ion-reorder />
+                <!-- Don't display reordering option when there is a single rule -->
+                <ion-reorder v-show="routingRules.length > 1" />
               </ion-item>
             </ion-reorder-group>
           </ion-list>
@@ -196,11 +197,15 @@ const props = defineProps({
   }
 })
 
+const enums = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)
+
 const currentRouting = computed(() => store.getters["orderRouting/getCurrentOrderRouting"])
 const routingRules = computed(() => store.getters["orderRouting/getRoutingRules"])
+const routingFilters = computed(() => store.getters["orderRouting/getCurrentRouteFilters"])
 
 onIonViewWillEnter(async () => {
   await store.dispatch("orderRouting/fetchRoutingRules", props.orderRoutingId)
+  await store.dispatch("orderRouting/fetchRoutingFilters", props.orderRoutingId)
 })
 
 </script>

From c9a78c3fd38ece514158a7ad344f5cc4f987b66d Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Wed, 17 Jan 2024 17:29:51 +0530
Subject: [PATCH 04/16] Implemented: support to select filters from available
 inventory filters and sort options(#24)

---
 .../AddInventoryFilterOptionsModal.vue        | 34 +++++++++++++++++++
 .../AddInventorySortOptionsModal.vue          | 33 ++++++++++++++++++
 src/store/modules/util/getters.ts             |  6 +++-
 src/views/BrokeringQuery.vue                  | 29 +++++++++++++---
 4 files changed, 97 insertions(+), 5 deletions(-)
 create mode 100644 src/components/AddInventoryFilterOptionsModal.vue
 create mode 100644 src/components/AddInventorySortOptionsModal.vue

diff --git a/src/components/AddInventoryFilterOptionsModal.vue b/src/components/AddInventoryFilterOptionsModal.vue
new file mode 100644
index 0000000..6ef5206
--- /dev/null
+++ b/src/components/AddInventoryFilterOptionsModal.vue
@@ -0,0 +1,34 @@
+<template>
+  <ion-page>
+    <ion-header>
+      <ion-toolbar>
+        <ion-title>{{ "Inventory Filters" }}</ion-title>
+        <ion-buttons slot="end">
+          <ion-button @click="closeModal">{{ $t('Close') }}</ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+    <ion-content>
+      <ion-list>
+        <ion-item v-for="filter in Object.values(inventoryFilterOptions['INV_FILTER_PRM_TYPE'])" :key="filter.enumId">
+          <ion-checkbox>{{ filter.description || filter.enumCode }}</ion-checkbox>
+        </ion-item>
+      </ion-list>
+    </ion-content>
+  </ion-page>
+</template>
+
+<script setup lang="ts">
+import { IonButton, IonButtons, IonCheckbox, IonContent, IonHeader, IonItem, IonList, IonPage, IonTitle, IonToolbar, modalController } from "@ionic/vue";
+import { useRouter } from "vue-router";
+import { useStore } from "vuex";
+import { computed } from "vue";
+
+const store = useStore();
+
+const inventoryFilterOptions = computed(() => store.getters["util/getEnums"])
+
+function closeModal() {
+  modalController.dismiss({ dismissed: true })
+}
+</script>
diff --git a/src/components/AddInventorySortOptionsModal.vue b/src/components/AddInventorySortOptionsModal.vue
new file mode 100644
index 0000000..873d0ac
--- /dev/null
+++ b/src/components/AddInventorySortOptionsModal.vue
@@ -0,0 +1,33 @@
+<template>
+  <ion-page>
+    <ion-header>
+      <ion-toolbar>
+        <ion-title>{{ "Inventory Sort" }}</ion-title>
+        <ion-buttons slot="end">
+          <ion-button @click="closeModal">{{ $t('Close') }}</ion-button>
+        </ion-buttons>
+      </ion-toolbar>
+    </ion-header>
+    <ion-content>
+      <ion-list>
+        <ion-item v-for="filter in Object.values(inventoryFilterOptions['INV_SORT_PARAM_TYPE'])" :key="filter.enumId">
+          <ion-checkbox>{{ filter.description || filter.enumCode }}</ion-checkbox>
+        </ion-item>
+      </ion-list>
+    </ion-content>
+  </ion-page>
+</template>
+
+<script setup lang="ts">
+import { IonButton, IonButtons, IonCheckbox, IonContent, IonHeader, IonItem, IonList, IonPage, IonTitle, IonToolbar, modalController } from "@ionic/vue";
+import { useStore } from "vuex";
+import { computed } from "vue";
+
+const store = useStore();
+
+const inventoryFilterOptions = computed(() => store.getters["util/getEnums"])
+
+function closeModal() {
+  modalController.dismiss({ dismissed: true })
+}
+</script>
diff --git a/src/store/modules/util/getters.ts b/src/store/modules/util/getters.ts
index 39918ab..01740e4 100644
--- a/src/store/modules/util/getters.ts
+++ b/src/store/modules/util/getters.ts
@@ -2,6 +2,10 @@ import { GetterTree } from "vuex"
 import UtilState from "./UtilState"
 import RootState from "@/store/RootState"
 
-const getters: GetterTree<UtilState, RootState> = {}
+const getters: GetterTree<UtilState, RootState> = {
+  getEnums(state) {
+    return state.enums
+  }
+}
 
 export default getters;
\ No newline at end of file
diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index 2be677d..f2d0faa 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -35,7 +35,7 @@
               <ion-chip>{{ routingFilters[enums['FILTER']]?.[enums['PROMISE_DATE'].code] }}</ion-chip>
             </ion-item>
             <ion-item>
-              <ion-select label="Queue" :value="routingFilters[enums['FILTER']]?.[enums['SALES_CHANNEL'].code]">
+              <ion-select label="Sales Channel" :value="routingFilters[enums['FILTER']]?.[enums['SALES_CHANNEL'].code]">
                 <ion-select-option value="Brokering Queue">{{ "Brokering Queue" }}</ion-select-option>
               </ion-select>
             </ion-item>
@@ -81,7 +81,9 @@
               <ion-item>
                 <ion-icon slot="start" :icon="filterOutline"/>
                 <ion-label>{{ "Filters" }}</ion-label>
-                <ion-icon :icon="optionsOutline"/>
+                <ion-button fill="clear" @click="addInventoryFilterOptions()">
+                  <ion-icon slot="icon-only" :icon="optionsOutline"/>
+                </ion-button>
               </ion-item>
               <ion-item>
                 <ion-select label="Group" value="East coast stores">
@@ -102,7 +104,9 @@
               <ion-item>
                 <ion-icon slot="start" :icon="swapVerticalOutline"/>
                 <ion-label>{{ "Sort" }}</ion-label>
-                <ion-icon :icon="optionsOutline"/>
+                <ion-button fill="clear" @click="addInventorySortOptions()">
+                  <ion-icon slot="icon-only" :icon="optionsOutline"/>
+                </ion-button>
               </ion-item>
               <ion-reorder-group :disabled="false">
                 <ion-item>
@@ -179,11 +183,13 @@
 </template>
 
 <script setup lang="ts">
-import { IonButton, IonCard, IonChip, IonContent, IonIcon, IonItem, IonItemDivider, IonItemGroup, IonLabel, IonList, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, onIonViewWillEnter } from "@ionic/vue";
+import { IonButton, IonCard, IonChip, IonContent, IonIcon, IonItem, IonItemDivider, IonItemGroup, IonLabel, IonList, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, modalController, onIonViewWillEnter } from "@ionic/vue";
 import { checkmarkOutline, chevronUpOutline, filterOutline, optionsOutline, swapVerticalOutline } from "ionicons/icons"
 import { useRouter } from "vue-router";
 import { computed, defineProps } from "vue";
 import store from "@/store";
+import AddInventoryFilterOptionsModal from "@/components/AddInventoryFilterOptionsModal.vue";
+import AddInventorySortOptionsModal from "@/components/AddInventorySortOptionsModal.vue";
 
 const router = useRouter();
 const props = defineProps({
@@ -208,6 +214,21 @@ onIonViewWillEnter(async () => {
   await store.dispatch("orderRouting/fetchRoutingFilters", props.orderRoutingId)
 })
 
+async function addInventoryFilterOptions() {
+  const inventoryFilterOptionsModal = await modalController.create({
+    component: AddInventoryFilterOptionsModal
+  })
+
+  await inventoryFilterOptionsModal.present();
+}
+
+async function addInventorySortOptions() {
+  const inventorySortOptionsModal = await modalController.create({
+    component: AddInventorySortOptionsModal
+  })
+
+  await inventorySortOptionsModal.present();
+}
 </script>
 
 <style scoped>

From 12f73bf12aa1ba5213636a59162abe9fa9dcc13a Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Wed, 17 Jan 2024 18:41:42 +0530
Subject: [PATCH 05/16] Implemented: services for fetching rule conditions and
 actions(#24)

---
 src/services/RoutingService.ts | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/services/RoutingService.ts b/src/services/RoutingService.ts
index cb670f4..bd6623a 100644
--- a/src/services/RoutingService.ts
+++ b/src/services/RoutingService.ts
@@ -40,10 +40,28 @@ const fetchRoutingFilters = async (payload: any): Promise<any> => {
   });
 }
 
+const fetchRuleConditions = async (payload: any): Promise<any> => {
+  return api({
+    url: `rules/${payload.routingRuleId}/condition`,
+    method: "GET",
+    query: payload
+  });
+}
+
+const fetchRuleActions = async (payload: any): Promise<any> => {
+  return api({
+    url: `rules/${payload.orderRoutingId}/actions`,
+    method: "GET",
+    query: payload
+  });
+}
+
 export const OrderRoutingService = {
   createRoutingGroup,
   fetchOrderRoutings,
   fetchRoutingFilters,
   fetchRoutingGroups,
-  fetchRoutingRules
+  fetchRoutingRules,
+  fetchRuleActions,
+  fetchRuleConditions
 }
\ No newline at end of file

From 6750d881b51583251bd030e67463936be313b282 Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Wed, 17 Jan 2024 18:42:11 +0530
Subject: [PATCH 06/16] Implemented: actions in store for rule actions and
 conditions(#24)

---
 .../modules/orderRouting/OrderRoutingState.ts |  2 +
 src/store/modules/orderRouting/actions.ts     | 61 +++++++++++++++++++
 src/store/modules/orderRouting/getters.ts     |  6 ++
 src/store/modules/orderRouting/index.ts       |  4 +-
 .../modules/orderRouting/mutation-types.ts    |  4 +-
 src/store/modules/orderRouting/mutations.ts   |  6 ++
 6 files changed, 81 insertions(+), 2 deletions(-)

diff --git a/src/store/modules/orderRouting/OrderRoutingState.ts b/src/store/modules/orderRouting/OrderRoutingState.ts
index b1b90ff..9c6d1b2 100644
--- a/src/store/modules/orderRouting/OrderRoutingState.ts
+++ b/src/store/modules/orderRouting/OrderRoutingState.ts
@@ -11,4 +11,6 @@ export default interface OrderRoutingState {
       [key: string]: RouteFilter  // enumCode/fieldName as key
     }
   };
+  ruleConditions: {};
+  ruleActions: {}
 }
\ No newline at end of file
diff --git a/src/store/modules/orderRouting/actions.ts b/src/store/modules/orderRouting/actions.ts
index 50758c7..3dbb62d 100644
--- a/src/store/modules/orderRouting/actions.ts
+++ b/src/store/modules/orderRouting/actions.ts
@@ -144,6 +144,67 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
     commit(types.ORDER_ROUTING_FILTERS_UPDATED, routingFilters)
   },
 
+  async fetchRuleConditions({ commit }, routingRuleId) {
+    let ruleConditions = [] as any;
+    // filter groups on the basis of productStoreId
+    const payload = {
+      routingRuleId
+    }
+
+    try {
+      const resp = await OrderRoutingService.fetchRuleConditions(payload);
+
+      console.log(resp)
+
+      if(!hasError(resp) && resp.data.length) {
+        ruleConditions = resp.data
+      } else {
+        throw resp.data
+      }
+    } catch(err) {
+      logger.error(err);
+    }
+
+    // const sortEnum = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)["SORT"] as any
+
+    // // As we only need to add support of reordering for sortBy filter
+    // if(routingFilters[sortEnum]?.length) {
+    //   routingFilters[sortEnum] = sortSequence(routingFilters[sortEnum])
+    // }
+
+    commit(types.ORDER_ROUTING_RULE_CONDITIONS_UPDATED, ruleConditions)
+  },
+
+  async fetchRuleActions({ commit }, routingRuleId) {
+    let ruleActions = [] as any;
+    const payload = {
+      routingRuleId
+    }
+
+    try {
+      const resp = await OrderRoutingService.fetchRuleActions(payload);
+
+      console.log('actions', resp.data)
+
+      if(!hasError(resp) && resp.data.length) {
+        ruleActions = resp.data
+      } else {
+        throw resp.data
+      }
+    } catch(err) {
+      logger.error(err);
+    }
+
+    // const sortEnum = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)["SORT"] as any
+
+    // // As we only need to add support of reordering for sortBy filter
+    // if(routingFilters[sortEnum]?.length) {
+    //   routingFilters[sortEnum] = sortSequence(routingFilters[sortEnum])
+    // }
+
+    commit(types.ORDER_ROUTING_RULE_ACTIONS_UPDATED, ruleActions)
+  },
+
   async setCurrentOrderRoutingId({ commit }, payload) {
     commit(types.ORDER_ROUTING_CURRENT_ROUTE_UPDATED, payload)
   },
diff --git a/src/store/modules/orderRouting/getters.ts b/src/store/modules/orderRouting/getters.ts
index 221faf3..7575d30 100644
--- a/src/store/modules/orderRouting/getters.ts
+++ b/src/store/modules/orderRouting/getters.ts
@@ -23,6 +23,12 @@ const getters: GetterTree<OrderRoutingState, RootState> = {
   },
   getCurrentRouteFilters(state) {
     return state.currentRouteFilters
+  },
+  getRuleConditions(state) {
+    return state.ruleConditions
+  },
+  getRuleActions(state) {
+    return state.ruleActions
   }
 }
 
diff --git a/src/store/modules/orderRouting/index.ts b/src/store/modules/orderRouting/index.ts
index b790847..b554efd 100644
--- a/src/store/modules/orderRouting/index.ts
+++ b/src/store/modules/orderRouting/index.ts
@@ -13,7 +13,9 @@ const orderRoutingModule: Module<OrderRoutingState, RootState> = {
     rules: [],
     currentGroupId: '', // choosing only to save id and not whole object, as when updating the state we don't need to care updating the state on two different places
     currentRouteId: '',
-    currentRouteFilters: {}
+    currentRouteFilters: {},
+    ruleConditions: {},
+    ruleActions: {}
   },
   getters,
   actions,
diff --git a/src/store/modules/orderRouting/mutation-types.ts b/src/store/modules/orderRouting/mutation-types.ts
index 389eee3..447da3d 100644
--- a/src/store/modules/orderRouting/mutation-types.ts
+++ b/src/store/modules/orderRouting/mutation-types.ts
@@ -4,4 +4,6 @@ export const ORDER_ROUTINGS_UPDATED = SN_ORDER_ROUTING + "/ROUTES_UPDATED"
 export const ORDER_ROUTING_RULES_UPDATED = SN_ORDER_ROUTING + "/RULE_UPDATED"
 export const ORDER_ROUTING_CURRENT_GROUP_UPDATED = SN_ORDER_ROUTING + "/CURRENT_GROUP_UPDATED"
 export const ORDER_ROUTING_CURRENT_ROUTE_UPDATED = SN_ORDER_ROUTING + "/CURRENT_ROUTE_UPDATED"
-export const ORDER_ROUTING_FILTERS_UPDATED = SN_ORDER_ROUTING + "/FILTERS_UPDATED"
\ No newline at end of file
+export const ORDER_ROUTING_FILTERS_UPDATED = SN_ORDER_ROUTING + "/FILTERS_UPDATED"
+export const ORDER_ROUTING_RULE_CONDITIONS_UPDATED = SN_ORDER_ROUTING + "/RULE_CONDITIONS_UPDATED"
+export const ORDER_ROUTING_RULE_ACTIONS_UPDATED = SN_ORDER_ROUTING + "/RULE_ACTIONS_UPDATED"
\ No newline at end of file
diff --git a/src/store/modules/orderRouting/mutations.ts b/src/store/modules/orderRouting/mutations.ts
index 437676f..6ce1f3d 100644
--- a/src/store/modules/orderRouting/mutations.ts
+++ b/src/store/modules/orderRouting/mutations.ts
@@ -20,6 +20,12 @@ const mutations: MutationTree<OrderRoutingState> = {
   },
   [types.ORDER_ROUTING_FILTERS_UPDATED](state, payload) {
     state.currentRouteFilters = payload
+  },
+  [types.ORDER_ROUTING_RULE_CONDITIONS_UPDATED](state, payload) {
+    state.ruleConditions = payload
+  },
+  [types.ORDER_ROUTING_RULE_ACTIONS_UPDATED](state, payload) {
+    state.ruleActions = payload
   }
 }
 export default mutations;
\ No newline at end of file

From 7865bd7ca1d26ef90fe46c2c0964a429a9181542 Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Thu, 18 Jan 2024 10:41:02 +0530
Subject: [PATCH 07/16] Implemented: support for actions configurable on the
 rules page(#24)

---
 src/services/RoutingService.ts            |  2 +-
 src/store/modules/orderRouting/actions.ts | 10 +++---
 src/views/BrokeringQuery.vue              | 38 ++++++++++++++---------
 3 files changed, 31 insertions(+), 19 deletions(-)

diff --git a/src/services/RoutingService.ts b/src/services/RoutingService.ts
index bd6623a..0b49c9a 100644
--- a/src/services/RoutingService.ts
+++ b/src/services/RoutingService.ts
@@ -50,7 +50,7 @@ const fetchRuleConditions = async (payload: any): Promise<any> => {
 
 const fetchRuleActions = async (payload: any): Promise<any> => {
   return api({
-    url: `rules/${payload.orderRoutingId}/actions`,
+    url: `rules/${payload.routingRuleId}/actions`,
     method: "GET",
     query: payload
   });
diff --git a/src/store/modules/orderRouting/actions.ts b/src/store/modules/orderRouting/actions.ts
index 3dbb62d..ab1600a 100644
--- a/src/store/modules/orderRouting/actions.ts
+++ b/src/store/modules/orderRouting/actions.ts
@@ -176,7 +176,7 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
   },
 
   async fetchRuleActions({ commit }, routingRuleId) {
-    let ruleActions = [] as any;
+    let ruleActions = {} as any;
     const payload = {
       routingRuleId
     }
@@ -184,10 +184,12 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
     try {
       const resp = await OrderRoutingService.fetchRuleActions(payload);
 
-      console.log('actions', resp.data)
-
       if(!hasError(resp) && resp.data.length) {
-        ruleActions = resp.data
+        ruleActions = resp.data.reduce((actions: any, action: any) => {
+          // considering that only one value for an action is available
+          actions[action.actionTypeEnumId] = action
+          return actions
+        }, {})
       } else {
         throw resp.data
       }
diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index dc2c06e..e0e4f57 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -120,10 +120,11 @@
                   <ion-label>{{ "Proximity" }}</ion-label>
                   <ion-reorder />
                 </ion-item>
-                <ion-item>
+                <!-- TODO: Does not have support for order limit, but need to add this support in future -->
+                <!-- <ion-item>
                   <ion-label>{{ "Order limit" }}</ion-label>
                   <ion-reorder />
-                </ion-item>
+                </ion-item> -->
                 <ion-item>
                   <ion-label>{{ "Inventory balance" }}</ion-label>
                   <ion-reorder />
@@ -160,25 +161,25 @@
                   <ion-label>{{ "Unavailable items" }}</ion-label>
                 </ion-item>
                 <ion-item lines="none">
-                  <ion-select label="Move items to" interface="popover">
-                    <ion-select-option value="next">
+                  <ion-select label="Move items to" interface="popover" :value="getRuleActionType()">
+                    <ion-select-option :value="actionEnums['NEXT_RULE'].id">
                       {{ "Next rule" }}
                       <ion-icon :icon="playForwardOutline"/>
                     </ion-select-option>
-                    <ion-select-option value="queue">
+                    <ion-select-option :value="actionEnums['MOVE_TO_QUEUE'].id">
                       {{ "Queue" }}
                       <ion-icon :icon="golfOutline"/>
                     </ion-select-option>
                   </ion-select>
                 </ion-item>
-                <ion-item lines="none">
+                <ion-item lines="none" v-show="getRuleActionType() === actionEnums['MOVE_TO_QUEUE'].id">
                   <ion-select label="Queue" interface="popover">
-                    <ion-select-option>{{ "Next rule" }}</ion-select-option>
+                    <ion-select-option>{{ "Queue" }}</ion-select-option>
                   </ion-select>
                 </ion-item>
                 <ion-item lines="none">
                   <ion-label>{{ "Auto cancel days" }}</ion-label>
-                  <ion-chip outline>{{ "10 days" }}</ion-chip>
+                  <ion-chip outline>{{ ruleActions[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue }}{{ ' days' }}</ion-chip>
                 </ion-item>
               </ion-card>
             </div>
@@ -203,22 +204,24 @@ const props = defineProps({
   orderRoutingId: {
     type: String,
     required: true
-  },
-  routingGroupId: {
-    type: String,
-    requied: true
   }
 })
 
 const enums = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)
+const actionEnums = JSON.parse(process.env?.VUE_APP_RULE_ACTION_ENUMS as string)
 
 const currentRouting = computed(() => store.getters["orderRouting/getCurrentOrderRouting"])
 const routingRules = computed(() => store.getters["orderRouting/getRoutingRules"])
 const routingFilters = computed(() => store.getters["orderRouting/getCurrentRouteFilters"])
+const ruleActions = computed(() => store.getters["orderRouting/getRuleActions"])
 
 onIonViewWillEnter(async () => {
-  await store.dispatch("orderRouting/fetchRoutingRules", props.orderRoutingId)
-  await store.dispatch("orderRouting/fetchRoutingFilters", props.orderRoutingId)
+  console.log('this.rules before', JSON.parse(JSON.stringify(routingRules.value)))
+  await Promise.all([store.dispatch("orderRouting/fetchRoutingRules", props.orderRoutingId), store.dispatch("orderRouting/fetchRoutingFilters", props.orderRoutingId)])
+
+  if(routingRules.value.length) {
+    await Promise.all([store.dispatch("orderRouting/fetchRuleConditions", routingRules.value[0].routingRuleId), store.dispatch("orderRouting/fetchRuleActions", routingRules.value[0].routingRuleId)])
+  }
 })
 
 async function addInventoryFilterOptions() {
@@ -260,6 +263,13 @@ async function addInventoryRule() {
 
   return newRuleAlert.present();
 }
+
+function getRuleActionType() {
+  const actionTypes = ["ORA_NEXT_RULE", "ORA_MV_TO_QUEUE"]
+  return Object.keys(ruleActions.value).find((actionId: string) => {
+    return actionTypes.includes(actionId)
+  })
+}
 </script>
 
 <style scoped>

From 96347202cbe1f08d96f0c41bd41f880dfe36c445 Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Thu, 18 Jan 2024 10:55:11 +0530
Subject: [PATCH 08/16] Implemented: support to update auto cancel days(#24)

---
 src/views/BrokeringQuery.vue | 39 +++++++++++++++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index e0e4f57..4f18b07 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -179,7 +179,7 @@
                 </ion-item>
                 <ion-item lines="none">
                   <ion-label>{{ "Auto cancel days" }}</ion-label>
-                  <ion-chip outline>{{ ruleActions[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue }}{{ ' days' }}</ion-chip>
+                  <ion-chip outline @click="updateAutoCancelDays(ruleActions[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue)">{{ ruleActions[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue }}{{ ' days' }}</ion-chip>
                 </ion-item>
               </ion-card>
             </div>
@@ -198,6 +198,7 @@ import { computed, defineProps } from "vue";
 import store from "@/store";
 import AddInventoryFilterOptionsModal from "@/components/AddInventoryFilterOptionsModal.vue";
 import AddInventorySortOptionsModal from "@/components/AddInventorySortOptionsModal.vue";
+import { showToast } from "@/utils";
 
 const router = useRouter();
 const props = defineProps({
@@ -270,6 +271,42 @@ function getRuleActionType() {
     return actionTypes.includes(actionId)
   })
 }
+
+async function updateAutoCancelDays(cancelDays: any) {
+  const alert = await alertController.create({
+    header: "Auto Cancel Days",
+    inputs: [{
+      name: "autoCancelDays",
+      placeholder: "auto cancel days",
+      type: "number",
+      min: 0,
+      value: cancelDays
+    }],
+    buttons: [{
+      text: "Cancel",
+      role: "cancel"
+    },
+    {
+      text: "Apply",
+      handler: (data) => {
+        let setLimit = this.setLimit as any;
+
+        if(data) {
+          if(data.cancelDays === '') {
+            showToast("Please provide a value")
+            return false;
+          } else if(data.cancelDays < 0) {
+            showToast("Provide a value greater than or equal to 0")
+            return false;
+          } else {
+            cancelDays = data.cancelDays
+          }
+        }
+      }
+    }]
+  })
+  await alert.present()
+}
 </script>
 
 <style scoped>

From 82e848c7afd675c0a5cbbe713e4c5fd061f60adb Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Thu, 18 Jan 2024 11:18:47 +0530
Subject: [PATCH 09/16] Fixed: autoCancelDays not updating locally after
 update(#24)

---
 src/store/modules/orderRouting/getters.ts |  4 ++--
 src/views/BrokeringQuery.vue              | 18 ++++++++++--------
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/store/modules/orderRouting/getters.ts b/src/store/modules/orderRouting/getters.ts
index 7575d30..d52948a 100644
--- a/src/store/modules/orderRouting/getters.ts
+++ b/src/store/modules/orderRouting/getters.ts
@@ -25,10 +25,10 @@ const getters: GetterTree<OrderRoutingState, RootState> = {
     return state.currentRouteFilters
   },
   getRuleConditions(state) {
-    return state.ruleConditions
+    return JSON.parse(JSON.stringify(state.ruleConditions))
   },
   getRuleActions(state) {
-    return state.ruleActions
+    return JSON.parse(JSON.stringify(state.ruleActions))
   }
 }
 
diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index 4f18b07..0903c81 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -179,7 +179,7 @@
                 </ion-item>
                 <ion-item lines="none">
                   <ion-label>{{ "Auto cancel days" }}</ion-label>
-                  <ion-chip outline @click="updateAutoCancelDays(ruleActions[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue)">{{ ruleActions[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue }}{{ ' days' }}</ion-chip>
+                  <ion-chip outline @click="updateAutoCancelDays(autoCancelDays)">{{ autoCancelDays }}{{ ' days' }}</ion-chip>
                 </ion-item>
               </ion-card>
             </div>
@@ -194,7 +194,7 @@
 import { IonButton, IonCard, IonChip, IonContent, IonIcon, IonItem, IonItemDivider, IonItemGroup, IonLabel, IonList, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, IonToggle, alertController, modalController, onIonViewWillEnter } from "@ionic/vue";
 import { addCircleOutline, checkmarkOutline, chevronUpOutline, closeCircleOutline, filterOutline, golfOutline, optionsOutline, playForwardOutline, swapVerticalOutline } from "ionicons/icons"
 import { useRouter } from "vue-router";
-import { computed, defineProps } from "vue";
+import { computed, defineProps, ref } from "vue";
 import store from "@/store";
 import AddInventoryFilterOptionsModal from "@/components/AddInventoryFilterOptionsModal.vue";
 import AddInventorySortOptionsModal from "@/components/AddInventorySortOptionsModal.vue";
@@ -210,6 +210,7 @@ const props = defineProps({
 
 const enums = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)
 const actionEnums = JSON.parse(process.env?.VUE_APP_RULE_ACTION_ENUMS as string)
+const autoCancelDays = ref(0)
 
 const currentRouting = computed(() => store.getters["orderRouting/getCurrentOrderRouting"])
 const routingRules = computed(() => store.getters["orderRouting/getRoutingRules"])
@@ -223,6 +224,8 @@ onIonViewWillEnter(async () => {
   if(routingRules.value.length) {
     await Promise.all([store.dispatch("orderRouting/fetchRuleConditions", routingRules.value[0].routingRuleId), store.dispatch("orderRouting/fetchRuleActions", routingRules.value[0].routingRuleId)])
   }
+
+  autoCancelDays.value = ruleActions.value[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue
 })
 
 async function addInventoryFilterOptions() {
@@ -287,19 +290,18 @@ async function updateAutoCancelDays(cancelDays: any) {
       role: "cancel"
     },
     {
-      text: "Apply",
+      text: "Save",
       handler: (data) => {
-        let setLimit = this.setLimit as any;
-
         if(data) {
-          if(data.cancelDays === '') {
+          if(data.autoCancelDays === '') {
             showToast("Please provide a value")
             return false;
-          } else if(data.cancelDays < 0) {
+          } else if(data.autoCancelDays < 0) {
             showToast("Provide a value greater than or equal to 0")
             return false;
           } else {
-            cancelDays = data.cancelDays
+            autoCancelDays.value = data.autoCancelDays
+            ruleActions.value[actionEnums['AUTO_CANCEL_DAYS'].id].actionValue = data.autoCancelDays
           }
         }
       }

From 292e07a2abf08b39149862c3932df08de070d59f Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Thu, 18 Jan 2024 12:16:05 +0530
Subject: [PATCH 10/16] Improved: support to update the rule actions(#24)

---
 src/views/BrokeringQuery.vue | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index 0903c81..ba150c1 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -70,7 +70,7 @@
         <div class="menu">
           <ion-list>
             <ion-reorder-group :disabled="false">
-              <ion-item v-for="rule in routingRules" :key="rule.routingRuleId">
+              <ion-item v-for="rule in routingRules" :key="rule.routingRuleId" button>
                 <ion-label>{{ rule.ruleName }}</ion-label>
                 <!-- Don't display reordering option when there is a single rule -->
                 <ion-reorder v-show="routingRules.length > 1" />
@@ -161,7 +161,7 @@
                   <ion-label>{{ "Unavailable items" }}</ion-label>
                 </ion-item>
                 <ion-item lines="none">
-                  <ion-select label="Move items to" interface="popover" :value="getRuleActionType()">
+                  <ion-select label="Move items to" interface="popover" :value="ruleActionType" @ionChange="updateRuleActionType($event.detail.value)">
                     <ion-select-option :value="actionEnums['NEXT_RULE'].id">
                       {{ "Next rule" }}
                       <ion-icon :icon="playForwardOutline"/>
@@ -172,7 +172,7 @@
                     </ion-select-option>
                   </ion-select>
                 </ion-item>
-                <ion-item lines="none" v-show="getRuleActionType() === actionEnums['MOVE_TO_QUEUE'].id">
+                <ion-item lines="none" v-show="ruleActionType === actionEnums['MOVE_TO_QUEUE'].id">
                   <ion-select label="Queue" interface="popover">
                     <ion-select-option>{{ "Queue" }}</ion-select-option>
                   </ion-select>
@@ -211,6 +211,7 @@ const props = defineProps({
 const enums = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)
 const actionEnums = JSON.parse(process.env?.VUE_APP_RULE_ACTION_ENUMS as string)
 const autoCancelDays = ref(0)
+const ruleActionType = ref('')
 
 const currentRouting = computed(() => store.getters["orderRouting/getCurrentOrderRouting"])
 const routingRules = computed(() => store.getters["orderRouting/getRoutingRules"])
@@ -218,7 +219,6 @@ const routingFilters = computed(() => store.getters["orderRouting/getCurrentRout
 const ruleActions = computed(() => store.getters["orderRouting/getRuleActions"])
 
 onIonViewWillEnter(async () => {
-  console.log('this.rules before', JSON.parse(JSON.stringify(routingRules.value)))
   await Promise.all([store.dispatch("orderRouting/fetchRoutingRules", props.orderRoutingId), store.dispatch("orderRouting/fetchRoutingFilters", props.orderRoutingId)])
 
   if(routingRules.value.length) {
@@ -226,6 +226,11 @@ onIonViewWillEnter(async () => {
   }
 
   autoCancelDays.value = ruleActions.value[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue
+
+  const actionTypes = ["ORA_NEXT_RULE", "ORA_MV_TO_QUEUE"]
+  ruleActionType.value = Object.keys(ruleActions.value).find((actionId: string) => {
+    return actionTypes.includes(actionId)
+  }) || ''
 })
 
 async function addInventoryFilterOptions() {
@@ -268,11 +273,17 @@ async function addInventoryRule() {
   return newRuleAlert.present();
 }
 
-function getRuleActionType() {
-  const actionTypes = ["ORA_NEXT_RULE", "ORA_MV_TO_QUEUE"]
-  return Object.keys(ruleActions.value).find((actionId: string) => {
-    return actionTypes.includes(actionId)
-  })
+function updateRuleActionType(value: string) {
+  const actionType = ruleActionType.value
+  ruleActionType.value = value
+
+  ruleActions.value[ruleActionType.value] = {
+    ...ruleActions.value[actionType],
+    actionTypeEnumId: value,
+    actionValue: '' // after changing action type, as next_rule action does not need to have a value, so in all cases making intially the value as empty and will update it if required from some other function
+  }
+  // deleting previous action type, but using the data of previous action, as we will not call delete action on server for actionTypes
+  delete ruleActions.value[actionType]
 }
 
 async function updateAutoCancelDays(cancelDays: any) {

From 56d213d48a639eabb992a2dd0a0ca5d9915f529c Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Thu, 18 Jan 2024 14:42:20 +0530
Subject: [PATCH 11/16] Implemented: support to display the options for queue
 dynamically(#24)

---
 src/services/UtilService.ts               | 11 +++++++++-
 src/store/modules/orderRouting/actions.ts |  2 --
 src/store/modules/util/UtilState.ts       |  3 ++-
 src/store/modules/util/actions.ts         | 25 +++++++++++++++++++++++
 src/store/modules/util/getters.ts         |  3 +++
 src/store/modules/util/index.ts           |  1 +
 src/store/modules/util/mutation-types.ts  |  3 ++-
 src/store/modules/util/mutations.ts       |  3 +++
 src/views/BrokeringQuery.vue              | 15 +++++++++-----
 9 files changed, 56 insertions(+), 10 deletions(-)

diff --git a/src/services/UtilService.ts b/src/services/UtilService.ts
index 0a59366..299fa5c 100644
--- a/src/services/UtilService.ts
+++ b/src/services/UtilService.ts
@@ -8,6 +8,15 @@ const fetchEnums = async (payload: any): Promise<any> => {
   });
 }
 
+const fetchFacilities = async (payload: any): Promise<any> => {
+  return api({
+    url: "facilities", 
+    method: "GET",
+    params: payload
+  });
+}
+
 export const UtilService = {
-  fetchEnums
+  fetchEnums,
+  fetchFacilities
 }
\ No newline at end of file
diff --git a/src/store/modules/orderRouting/actions.ts b/src/store/modules/orderRouting/actions.ts
index ab1600a..d1ccee6 100644
--- a/src/store/modules/orderRouting/actions.ts
+++ b/src/store/modules/orderRouting/actions.ts
@@ -154,8 +154,6 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
     try {
       const resp = await OrderRoutingService.fetchRuleConditions(payload);
 
-      console.log(resp)
-
       if(!hasError(resp) && resp.data.length) {
         ruleConditions = resp.data
       } else {
diff --git a/src/store/modules/util/UtilState.ts b/src/store/modules/util/UtilState.ts
index 60076be..5f7ae5d 100644
--- a/src/store/modules/util/UtilState.ts
+++ b/src/store/modules/util/UtilState.ts
@@ -5,5 +5,6 @@ export default interface UtilState {
     [key: string]: {
       [key: string]: Enumeration
     }
-  }
+  };
+  facilities: object;
 }
\ No newline at end of file
diff --git a/src/store/modules/util/actions.ts b/src/store/modules/util/actions.ts
index 0445f74..ca9421e 100644
--- a/src/store/modules/util/actions.ts
+++ b/src/store/modules/util/actions.ts
@@ -31,6 +31,31 @@ const actions: ActionTree<UtilState, RootState> = {
     }
 
     commit(types.UTIL_ENUMS_UPDATED, enums)
+  },
+
+  async fetchFacilities({ commit }) {
+    let facilities = {}
+
+    const payload = {
+      parentTypeId: "VIRTUAL_FACILITY"
+    }
+
+    try {
+      const resp = await UtilService.fetchFacilities(payload);
+
+      if(!hasError(resp) && resp.data.length) {
+        facilities = resp.data.reduce((facilities: any, facility: any) => {
+          facilities[facility.facilityId] = facility
+          return facilities
+        }, {})
+      }
+    } catch(err) {
+      logger.error('error', err)
+    }
+
+    console.log('facilities', facilities)
+
+    commit(types.UTIL_FACILITIES_UPDATED, facilities)
   }
 }
 
diff --git a/src/store/modules/util/getters.ts b/src/store/modules/util/getters.ts
index 01740e4..7dd9bba 100644
--- a/src/store/modules/util/getters.ts
+++ b/src/store/modules/util/getters.ts
@@ -5,6 +5,9 @@ import RootState from "@/store/RootState"
 const getters: GetterTree<UtilState, RootState> = {
   getEnums(state) {
     return state.enums
+  },
+  getFacilities(state) {
+    return state.facilities
   }
 }
 
diff --git a/src/store/modules/util/index.ts b/src/store/modules/util/index.ts
index 6ca9e4a..40e881f 100644
--- a/src/store/modules/util/index.ts
+++ b/src/store/modules/util/index.ts
@@ -9,6 +9,7 @@ const utilModule: Module<UtilState, RootState> = {
   namespaced: true,
   state: {
     enums: {},
+    facilities: {}
   },
   getters,
   actions,
diff --git a/src/store/modules/util/mutation-types.ts b/src/store/modules/util/mutation-types.ts
index 6bc0c05..c3933fe 100644
--- a/src/store/modules/util/mutation-types.ts
+++ b/src/store/modules/util/mutation-types.ts
@@ -1,2 +1,3 @@
 export const SN_UTIL = "util"
-export const UTIL_ENUMS_UPDATED = SN_UTIL + "/ENUMS_UPDATED"
\ No newline at end of file
+export const UTIL_ENUMS_UPDATED = SN_UTIL + "/ENUMS_UPDATED"
+export const UTIL_FACILITIES_UPDATED = SN_UTIL + "/FACILITIES_UPDATED"
\ No newline at end of file
diff --git a/src/store/modules/util/mutations.ts b/src/store/modules/util/mutations.ts
index 6157429..7a06ea8 100644
--- a/src/store/modules/util/mutations.ts
+++ b/src/store/modules/util/mutations.ts
@@ -5,6 +5,9 @@ import * as types from "./mutation-types"
 const mutations: MutationTree<UtilState> = {
   [types.UTIL_ENUMS_UPDATED](state, payload) {
     state.enums = payload
+  },
+  [types.UTIL_FACILITIES_UPDATED](state, payload) {
+    state.facilities = payload
   }
 }
 export default mutations;
\ No newline at end of file
diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index ba150c1..5df7d08 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -16,8 +16,8 @@
               <ion-label>{{ "Filters" }}</ion-label>
             </ion-item-divider>
             <ion-item>
-              <ion-select label="Queue" :value="routingFilters[enums['FILTER']]?.[enums['QUEUE'].code]">
-                <ion-select-option value="Brokering Queue">{{ "Brokering Queue" }}</ion-select-option>
+              <ion-select label="Queue" interface="popover" :value="routingFilters[enums['FILTER']]?.[enums['QUEUE'].code]">
+                <ion-select-option v-for="(facility, facilityId) in facilities" :key="facilityId" :value="facilityId">{{ facility.facilityName || facilityId }}</ion-select-option>
               </ion-select>
             </ion-item>
             <ion-item>
@@ -173,8 +173,8 @@
                   </ion-select>
                 </ion-item>
                 <ion-item lines="none" v-show="ruleActionType === actionEnums['MOVE_TO_QUEUE'].id">
-                  <ion-select label="Queue" interface="popover">
-                    <ion-select-option>{{ "Queue" }}</ion-select-option>
+                  <ion-select label="Queue" interface="popover" :value="ruleActions[ruleActionType]?.actionValue" @ionChange="updateRuleActionValue($event.detail.value)">
+                    <ion-select-option v-for="(facility, facilityId) in facilities" :key="facilityId" :value="facilityId">{{ facility.facilityName || facilityId }}</ion-select-option>
                   </ion-select>
                 </ion-item>
                 <ion-item lines="none">
@@ -217,9 +217,10 @@ const currentRouting = computed(() => store.getters["orderRouting/getCurrentOrde
 const routingRules = computed(() => store.getters["orderRouting/getRoutingRules"])
 const routingFilters = computed(() => store.getters["orderRouting/getCurrentRouteFilters"])
 const ruleActions = computed(() => store.getters["orderRouting/getRuleActions"])
+const facilities = computed(() => store.getters["util/getFacilities"])
 
 onIonViewWillEnter(async () => {
-  await Promise.all([store.dispatch("orderRouting/fetchRoutingRules", props.orderRoutingId), store.dispatch("orderRouting/fetchRoutingFilters", props.orderRoutingId)])
+  await Promise.all([store.dispatch("orderRouting/fetchRoutingRules", props.orderRoutingId), store.dispatch("orderRouting/fetchRoutingFilters", props.orderRoutingId), store.dispatch("util/fetchFacilities")])
 
   if(routingRules.value.length) {
     await Promise.all([store.dispatch("orderRouting/fetchRuleConditions", routingRules.value[0].routingRuleId), store.dispatch("orderRouting/fetchRuleActions", routingRules.value[0].routingRuleId)])
@@ -286,6 +287,10 @@ function updateRuleActionType(value: string) {
   delete ruleActions.value[actionType]
 }
 
+function updateRuleActionValue(value: string) {
+  ruleActions.value[ruleActionType.value]["actionValue"] = value
+}
+
 async function updateAutoCancelDays(cancelDays: any) {
   const alert = await alertController.create({
     header: "Auto Cancel Days",

From 2cefb9dd0087e3c431aa2b9c1cd3fcf733fe8d8d Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Thu, 18 Jan 2024 15:30:53 +0530
Subject: [PATCH 12/16] Implemented: support to fetch sales channel options
 from enums and improved variable names(#24)

---
 src/store/modules/util/actions.ts | 10 +++++-----
 src/views/BrokeringQuery.vue      | 17 +++++++++--------
 2 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/src/store/modules/util/actions.ts b/src/store/modules/util/actions.ts
index ca9421e..298d6cc 100644
--- a/src/store/modules/util/actions.ts
+++ b/src/store/modules/util/actions.ts
@@ -8,8 +8,10 @@ import { UtilService } from "@/services/UtilService"
 import { EnumerationAndType } from "@/types"
 
 const actions: ActionTree<UtilState, RootState> = {
-  async fetchEnums({ commit }, payload) {
-    let enums = {}
+  async fetchEnums({ commit, state }, payload) {
+    let enums = {
+      ...state.enums
+    }
 
     try {
       const resp = await UtilService.fetchEnums(payload);
@@ -24,7 +26,7 @@ const actions: ActionTree<UtilState, RootState> = {
             }
           }
           return enumerations
-        }, {})
+        }, enums)
       }
     } catch(err) {
       logger.error('error', err)
@@ -53,8 +55,6 @@ const actions: ActionTree<UtilState, RootState> = {
       logger.error('error', err)
     }
 
-    console.log('facilities', facilities)
-
     commit(types.UTIL_FACILITIES_UPDATED, facilities)
   }
 }
diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index 5df7d08..3a21916 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -16,30 +16,30 @@
               <ion-label>{{ "Filters" }}</ion-label>
             </ion-item-divider>
             <ion-item>
-              <ion-select label="Queue" interface="popover" :value="routingFilters[enums['FILTER']]?.[enums['QUEUE'].code]">
+              <ion-select label="Queue" interface="popover" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['QUEUE'].code]">
                 <ion-select-option v-for="(facility, facilityId) in facilities" :key="facilityId" :value="facilityId">{{ facility.facilityName || facilityId }}</ion-select-option>
               </ion-select>
             </ion-item>
             <ion-item>
-              <ion-select label="Shipping method" :value="routingFilters[enums['FILTER']]?.[enums['SHIPPING_METHOD'].code]">
+              <ion-select label="Shipping method" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['SHIPPING_METHOD'].code]">
                 <ion-select-option value="Next Day">{{ "Next Day" }}</ion-select-option>
               </ion-select>
             </ion-item>
             <ion-item>
-              <ion-select label="Order priority" :value="routingFilters[enums['FILTER']]?.[enums['PRIORITY'].code]">
+              <ion-select label="Order priority" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['PRIORITY'].code]">
                 <ion-select-option value="High">{{ "High" }}</ion-select-option>
               </ion-select>
             </ion-item>
             <ion-item>
               <ion-label>{{ "Promise date" }}</ion-label>
               <ion-chip>
-                {{ routingFilters[enums['FILTER']]?.[enums['PROMISE_DATE'].code] }}
+                {{ routingFilters[ruleEnums['FILTER']]?.[ruleEnums['PROMISE_DATE'].code] }}
                 <ion-icon :icon="closeCircleOutline"/>
               </ion-chip>
             </ion-item>
             <ion-item>
-              <ion-select label="Sales Channel" :value="routingFilters[enums['FILTER']]?.[enums['SALES_CHANNEL'].code]">
-                <ion-select-option value="Brokering Queue">{{ "Brokering Queue" }}</ion-select-option>
+              <ion-select label="Sales Channel" interface="popover" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['SALES_CHANNEL'].code].fieldValue">
+                <ion-select-option v-for="(enumInfo, enumId) in enums['ORDER_SALES_CHANNEL']" :key="enumId" :value="enumId">{{ enumInfo.description || enumInfo.enumId }}</ion-select-option>
               </ion-select>
             </ion-item>
           </ion-item-group>
@@ -208,7 +208,7 @@ const props = defineProps({
   }
 })
 
-const enums = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)
+const ruleEnums = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)
 const actionEnums = JSON.parse(process.env?.VUE_APP_RULE_ACTION_ENUMS as string)
 const autoCancelDays = ref(0)
 const ruleActionType = ref('')
@@ -218,12 +218,13 @@ const routingRules = computed(() => store.getters["orderRouting/getRoutingRules"
 const routingFilters = computed(() => store.getters["orderRouting/getCurrentRouteFilters"])
 const ruleActions = computed(() => store.getters["orderRouting/getRuleActions"])
 const facilities = computed(() => store.getters["util/getFacilities"])
+const enums = computed(() => store.getters["util/getEnums"])
 
 onIonViewWillEnter(async () => {
   await Promise.all([store.dispatch("orderRouting/fetchRoutingRules", props.orderRoutingId), store.dispatch("orderRouting/fetchRoutingFilters", props.orderRoutingId), store.dispatch("util/fetchFacilities")])
 
   if(routingRules.value.length) {
-    await Promise.all([store.dispatch("orderRouting/fetchRuleConditions", routingRules.value[0].routingRuleId), store.dispatch("orderRouting/fetchRuleActions", routingRules.value[0].routingRuleId)])
+    await Promise.all([store.dispatch("orderRouting/fetchRuleConditions", routingRules.value[0].routingRuleId), store.dispatch("orderRouting/fetchRuleActions", routingRules.value[0].routingRuleId), store.dispatch("util/fetchEnums", { enumTypeId: "ORDER_SALES_CHANNEL" })])
   }
 
   autoCancelDays.value = ruleActions.value[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue

From ad7b0aca9a47db649968b307541d2a1df43d6052 Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Thu, 18 Jan 2024 15:49:52 +0530
Subject: [PATCH 13/16] Implemented: support for changing the currently
 selected routeRule(#24)

---
 src/views/BrokeringQuery.vue | 35 +++++++++++++++++++++++++----------
 1 file changed, 25 insertions(+), 10 deletions(-)

diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index 3a21916..86b7726 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -16,29 +16,31 @@
               <ion-label>{{ "Filters" }}</ion-label>
             </ion-item-divider>
             <ion-item>
-              <ion-select label="Queue" interface="popover" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['QUEUE'].code]">
+              <ion-select label="Queue" interface="popover" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['QUEUE'].code]?.fieldValue">
                 <ion-select-option v-for="(facility, facilityId) in facilities" :key="facilityId" :value="facilityId">{{ facility.facilityName || facilityId }}</ion-select-option>
               </ion-select>
             </ion-item>
             <ion-item>
-              <ion-select label="Shipping method" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['SHIPPING_METHOD'].code]">
+              <ion-select label="Shipping method" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['SHIPPING_METHOD'].code]?.fieldValue">
                 <ion-select-option value="Next Day">{{ "Next Day" }}</ion-select-option>
               </ion-select>
             </ion-item>
             <ion-item>
-              <ion-select label="Order priority" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['PRIORITY'].code]">
-                <ion-select-option value="High">{{ "High" }}</ion-select-option>
+              <ion-select label="Order priority" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['PRIORITY'].code]?.fieldValue">
+                <ion-select-option value="HIGH">{{ "High" }}</ion-select-option>
+                <ion-select-option value="MEDIUM">{{ "Medium" }}</ion-select-option>
+                <ion-select-option value="Low">{{ "Low" }}</ion-select-option>
               </ion-select>
             </ion-item>
             <ion-item>
               <ion-label>{{ "Promise date" }}</ion-label>
               <ion-chip>
-                {{ routingFilters[ruleEnums['FILTER']]?.[ruleEnums['PROMISE_DATE'].code] }}
+                {{ routingFilters[ruleEnums['FILTER']]?.[ruleEnums['PROMISE_DATE'].code]?.fieldValue }}
                 <ion-icon :icon="closeCircleOutline"/>
               </ion-chip>
             </ion-item>
             <ion-item>
-              <ion-select label="Sales Channel" interface="popover" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['SALES_CHANNEL'].code].fieldValue">
+              <ion-select label="Sales Channel" interface="popover" :value="routingFilters[ruleEnums['FILTER']]?.[ruleEnums['SALES_CHANNEL'].code]?.fieldValue">
                 <ion-select-option v-for="(enumInfo, enumId) in enums['ORDER_SALES_CHANNEL']" :key="enumId" :value="enumId">{{ enumInfo.description || enumInfo.enumId }}</ion-select-option>
               </ion-select>
             </ion-item>
@@ -70,7 +72,7 @@
         <div class="menu">
           <ion-list>
             <ion-reorder-group :disabled="false">
-              <ion-item v-for="rule in routingRules" :key="rule.routingRuleId" button>
+              <ion-item v-for="rule in routingRules" :key="rule.routingRuleId" @click="fetchRuleInformation(rule.routingRuleId)" button>
                 <ion-label>{{ rule.ruleName }}</ion-label>
                 <!-- Don't display reordering option when there is a single rule -->
                 <ion-reorder v-show="routingRules.length > 1" />
@@ -212,6 +214,7 @@ const ruleEnums = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)
 const actionEnums = JSON.parse(process.env?.VUE_APP_RULE_ACTION_ENUMS as string)
 const autoCancelDays = ref(0)
 const ruleActionType = ref('')
+const selectedRoutingRule = ref('')
 
 const currentRouting = computed(() => store.getters["orderRouting/getCurrentOrderRouting"])
 const routingRules = computed(() => store.getters["orderRouting/getRoutingRules"])
@@ -221,12 +224,15 @@ const facilities = computed(() => store.getters["util/getFacilities"])
 const enums = computed(() => store.getters["util/getEnums"])
 
 onIonViewWillEnter(async () => {
-  await Promise.all([store.dispatch("orderRouting/fetchRoutingRules", props.orderRoutingId), store.dispatch("orderRouting/fetchRoutingFilters", props.orderRoutingId), store.dispatch("util/fetchFacilities")])
+  await Promise.all([store.dispatch("orderRouting/fetchRoutingRules", props.orderRoutingId), store.dispatch("orderRouting/fetchRoutingFilters", props.orderRoutingId), store.dispatch("util/fetchFacilities"), store.dispatch("util/fetchEnums", { enumTypeId: "ORDER_SALES_CHANNEL" })])
 
-  if(routingRules.value.length) {
-    await Promise.all([store.dispatch("orderRouting/fetchRuleConditions", routingRules.value[0].routingRuleId), store.dispatch("orderRouting/fetchRuleActions", routingRules.value[0].routingRuleId), store.dispatch("util/fetchEnums", { enumTypeId: "ORDER_SALES_CHANNEL" })])
+  if(!routingRules.value.length) {
+    return;
   }
 
+  selectedRoutingRule.value = routingRules.value[0].routingRuleId
+  await fetchRuleInformation(selectedRoutingRule.value);
+
   autoCancelDays.value = ruleActions.value[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue
 
   const actionTypes = ["ORA_NEXT_RULE", "ORA_MV_TO_QUEUE"]
@@ -235,6 +241,15 @@ onIonViewWillEnter(async () => {
   }) || ''
 })
 
+async function fetchRuleInformation(routingRuleId: string) {
+  if(selectedRoutingRule.value === routingRuleId) {
+    return;
+  }
+
+  selectedRoutingRule.value = routingRuleId
+  await Promise.all([store.dispatch("orderRouting/fetchRuleConditions", routingRuleId), store.dispatch("orderRouting/fetchRuleActions", routingRuleId)])
+}
+
 async function addInventoryFilterOptions() {
   const inventoryFilterOptionsModal = await modalController.create({
     component: AddInventoryFilterOptionsModal

From 9184c0ed5150e4c2a22e177128885d2c68e6758d Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Thu, 18 Jan 2024 16:45:11 +0530
Subject: [PATCH 14/16] Implemented: support to create a new rule(#24)

Defined an alert to let user enter the name and created the ruleId from the name
Added default values for parameters
---
 src/services/RoutingService.ts | 24 ++++++++++++
 src/views/BrokeringQuery.vue   | 71 ++++++++++++++++++++++------------
 2 files changed, 71 insertions(+), 24 deletions(-)

diff --git a/src/services/RoutingService.ts b/src/services/RoutingService.ts
index 0b49c9a..84f5953 100644
--- a/src/services/RoutingService.ts
+++ b/src/services/RoutingService.ts
@@ -1,4 +1,7 @@
 import api from "@/api"
+import logger from "@/logger";
+import store from "@/store";
+import { hasError, showToast } from "@/utils";
 
 const fetchRoutingGroups = async (payload: any): Promise<any> => {
   return api({
@@ -24,6 +27,26 @@ const fetchOrderRoutings = async (payload: any): Promise<any> => {
   });
 }
 
+const createRoutingRule = async (payload: any): Promise<any> => {
+  let routingRuleId = '';
+  try {
+    const resp = await api({
+      url: "rules",
+      method: "POST",
+      data: payload
+    })
+
+    if(!hasError(resp) && resp?.data.routingRuleId) {
+      routingRuleId = resp.data.routingRuleId
+    }
+  } catch(err) {
+    showToast("Failed to create new rule")
+    logger.error(err)
+  }
+
+  return routingRuleId
+}
+
 const fetchRoutingRules = async (payload: any): Promise<any> => {
   return api({
     url: `routings/${payload.orderRoutingId}/rules`,
@@ -58,6 +81,7 @@ const fetchRuleActions = async (payload: any): Promise<any> => {
 
 export const OrderRoutingService = {
   createRoutingGroup,
+  createRoutingRule,
   fetchOrderRoutings,
   fetchRoutingFilters,
   fetchRoutingGroups,
diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index 86b7726..75f0137 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -142,26 +142,34 @@
             <h2 class="ion-padding-start">{{ "Actions" }}</h2>
             <div class="actions">
               <ion-card>
-                <ion-item lines="none">
-                  <ion-label>{{ "Allocated Items" }}</ion-label>
-                </ion-item>
+                <ion-card-header>
+                  <ion-card-title>
+                    {{ "Allocated Items" }}
+                  </ion-card-title>
+                </ion-card-header>
                 <ion-item lines="none">
                   <ion-toggle>{{ "Clear auto cancel days" }}</ion-toggle>
                 </ion-item>
               </ion-card>
               <ion-card>
-                <ion-item lines="none">
-                  <ion-label>{{ "Partially available" }}</ion-label>
-                  <p>{{ "Select if partial allocation should be allowed in this inventory rule" }}</p>
-                </ion-item>
+                <ion-card-header>
+                  <ion-card-title>
+                    {{ "Partially available" }}
+                  </ion-card-title>
+                </ion-card-header>
+                <ion-card-content>
+                  {{ "Select if partial allocation should be allowed in this inventory rule" }}
+                </ion-card-content>
                 <ion-item lines="none">
                   <ion-toggle>{{ "Allow partial allocation" }}</ion-toggle>
                 </ion-item>
               </ion-card>
               <ion-card>
-                <ion-item lines="none">
-                  <ion-label>{{ "Unavailable items" }}</ion-label>
-                </ion-item>
+                <ion-card-header>
+                  <ion-card-title>
+                    {{ "Unavailable items" }}
+                  </ion-card-title>
+                </ion-card-header>
                 <ion-item lines="none">
                   <ion-select label="Move items to" interface="popover" :value="ruleActionType" @ionChange="updateRuleActionType($event.detail.value)">
                     <ion-select-option :value="actionEnums['NEXT_RULE'].id">
@@ -193,14 +201,15 @@
 </template>
 
 <script setup lang="ts">
-import { IonButton, IonCard, IonChip, IonContent, IonIcon, IonItem, IonItemDivider, IonItemGroup, IonLabel, IonList, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, IonToggle, alertController, modalController, onIonViewWillEnter } from "@ionic/vue";
-import { addCircleOutline, checkmarkOutline, chevronUpOutline, closeCircleOutline, filterOutline, golfOutline, optionsOutline, playForwardOutline, swapVerticalOutline } from "ionicons/icons"
+import { IonButton, IonCard, IonCardContent, IonCardHeader, IonCardTitle, IonChip, IonContent, IonIcon, IonItem, IonItemDivider, IonItemGroup, IonLabel, IonList, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, IonToggle, alertController, modalController, onIonViewWillEnter } from "@ionic/vue";
+import { addCircleOutline, chevronUpOutline, closeCircleOutline, filterOutline, golfOutline, optionsOutline, playForwardOutline, swapVerticalOutline } from "ionicons/icons"
 import { useRouter } from "vue-router";
 import { computed, defineProps, ref } from "vue";
 import store from "@/store";
 import AddInventoryFilterOptionsModal from "@/components/AddInventoryFilterOptionsModal.vue";
 import AddInventorySortOptionsModal from "@/components/AddInventorySortOptionsModal.vue";
 import { showToast } from "@/utils";
+import { OrderRoutingService } from "@/services/RoutingService"
 
 const router = useRouter();
 const props = defineProps({
@@ -230,15 +239,7 @@ onIonViewWillEnter(async () => {
     return;
   }
 
-  selectedRoutingRule.value = routingRules.value[0].routingRuleId
-  await fetchRuleInformation(selectedRoutingRule.value);
-
-  autoCancelDays.value = ruleActions.value[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue
-
-  const actionTypes = ["ORA_NEXT_RULE", "ORA_MV_TO_QUEUE"]
-  ruleActionType.value = Object.keys(ruleActions.value).find((actionId: string) => {
-    return actionTypes.includes(actionId)
-  }) || ''
+  await fetchRuleInformation(routingRules.value[0].routingRuleId);
 })
 
 async function fetchRuleInformation(routingRuleId: string) {
@@ -248,6 +249,13 @@ async function fetchRuleInformation(routingRuleId: string) {
 
   selectedRoutingRule.value = routingRuleId
   await Promise.all([store.dispatch("orderRouting/fetchRuleConditions", routingRuleId), store.dispatch("orderRouting/fetchRuleActions", routingRuleId)])
+
+  autoCancelDays.value = ruleActions.value[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue
+
+  const actionTypes = ["ORA_NEXT_RULE", "ORA_MV_TO_QUEUE"]
+  ruleActionType.value = Object.keys(ruleActions.value).find((actionId: string) => {
+    return actionTypes.includes(actionId)
+  }) || ''
 }
 
 async function addInventoryFilterOptions() {
@@ -281,9 +289,24 @@ async function addInventoryRule() {
     }]
   })
 
-  newRuleAlert.onDidDismiss().then((result: any) => {
-    if(result.data?.values?.ruleName) {
-      console.log('ruleName', result.data?.values?.ruleName)
+  newRuleAlert.onDidDismiss().then(async (result: any) => {
+    const ruleName = result.data?.values?.ruleName;
+    if(ruleName) {
+      // TODO: check for the default value of params
+      const payload = {
+        routingRuleId: ruleName.split(" ").join("_").toUpperCase(),
+        orderRoutingId: props.orderRoutingId,
+        ruleName,
+        statusId: "SERVICE_ACTIVE", // by default considering the rule to be active
+        sequenceNum: 0,
+        assignmentEnumId: "ORA_SINGLE", // by default, considering partial fulfillment to inactive
+        fulfillEntireShipGroup: "N",
+      }
+
+      const resp = await OrderRoutingService.createRoutingRule(payload)
+      if(resp.routingRuleId) {
+        fetchRuleInformation(resp.routingRuleId)
+      }
     }
   })
 

From bd49c6737354010c2b396eb1e7135971f8683f88 Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Thu, 18 Jan 2024 17:29:01 +0530
Subject: [PATCH 15/16] Implemented: support to update partial allocation value
 for rule(#24)

---
 src/views/BrokeringQuery.vue | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/views/BrokeringQuery.vue b/src/views/BrokeringQuery.vue
index 75f0137..2e732f1 100644
--- a/src/views/BrokeringQuery.vue
+++ b/src/views/BrokeringQuery.vue
@@ -161,7 +161,7 @@
                   {{ "Select if partial allocation should be allowed in this inventory rule" }}
                 </ion-card-content>
                 <ion-item lines="none">
-                  <ion-toggle>{{ "Allow partial allocation" }}</ion-toggle>
+                  <ion-toggle :checked="selectedRoutingRule.assignmentEnumId === 'ORA_MULTI'" @ionChange="updatePartialAllocation($event.detail.checked)">{{ "Allow partial allocation" }}</ion-toggle>
                 </ion-item>
               </ion-card>
               <ion-card>
@@ -204,12 +204,13 @@
 import { IonButton, IonCard, IonCardContent, IonCardHeader, IonCardTitle, IonChip, IonContent, IonIcon, IonItem, IonItemDivider, IonItemGroup, IonLabel, IonList, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, IonToggle, alertController, modalController, onIonViewWillEnter } from "@ionic/vue";
 import { addCircleOutline, chevronUpOutline, closeCircleOutline, filterOutline, golfOutline, optionsOutline, playForwardOutline, swapVerticalOutline } from "ionicons/icons"
 import { useRouter } from "vue-router";
-import { computed, defineProps, ref } from "vue";
+import { computed, defineProps, reactive, ref } from "vue";
 import store from "@/store";
 import AddInventoryFilterOptionsModal from "@/components/AddInventoryFilterOptionsModal.vue";
 import AddInventorySortOptionsModal from "@/components/AddInventorySortOptionsModal.vue";
 import { showToast } from "@/utils";
 import { OrderRoutingService } from "@/services/RoutingService"
+import { Rule } from "@/types";
 
 const router = useRouter();
 const props = defineProps({
@@ -223,7 +224,7 @@ const ruleEnums = JSON.parse(process.env?.VUE_APP_RULE_ENUMS as string)
 const actionEnums = JSON.parse(process.env?.VUE_APP_RULE_ACTION_ENUMS as string)
 const autoCancelDays = ref(0)
 const ruleActionType = ref('')
-const selectedRoutingRule = ref('')
+let selectedRoutingRule = reactive({}) as Rule
 
 const currentRouting = computed(() => store.getters["orderRouting/getCurrentOrderRouting"])
 const routingRules = computed(() => store.getters["orderRouting/getRoutingRules"])
@@ -243,11 +244,11 @@ onIonViewWillEnter(async () => {
 })
 
 async function fetchRuleInformation(routingRuleId: string) {
-  if(selectedRoutingRule.value === routingRuleId) {
+  if(selectedRoutingRule.routingRuleId === routingRuleId) {
     return;
   }
 
-  selectedRoutingRule.value = routingRuleId
+  selectedRoutingRule = routingRules.value.find((rule: Rule) => rule.routingRuleId === routingRuleId)
   await Promise.all([store.dispatch("orderRouting/fetchRuleConditions", routingRuleId), store.dispatch("orderRouting/fetchRuleActions", routingRuleId)])
 
   autoCancelDays.value = ruleActions.value[actionEnums['AUTO_CANCEL_DAYS'].id]?.actionValue
@@ -364,6 +365,10 @@ async function updateAutoCancelDays(cancelDays: any) {
   })
   await alert.present()
 }
+
+function updatePartialAllocation(event: CustomEvent) {
+  selectedRoutingRule.assignmentEnumId = event ? "ORA_MULTI" : "ORA_SINGLE"
+}
 </script>
 
 <style scoped>

From f248fe98ad53e06de13e6ec0d38482877e8c723c Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Thu, 18 Jan 2024 17:37:21 +0530
Subject: [PATCH 16/16] Improved: env example(#24)

---
 .env.example | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.env.example b/.env.example
index 3adbc88..6868e6a 100644
--- a/.env.example
+++ b/.env.example
@@ -4,4 +4,7 @@ VUE_APP_CACHE_MAX_AGE=3600
 VUE_APP_VIEW_SIZE=10
 VUE_APP_PERMISSION_ID=
 VUE_APP_DEFAULT_LOG_LEVEL="error"
-VUE_APP_RULE_ENUMS={"FILTER":"ENTCT_FILTER","SORT":"ENTCT_SORT_BY","QUEUE":{"id":"OIP_QUEUE","code":"facilityId"},"SHIPPING_METHOD":{"id":"OIP_SHIP_METH_TYPE","code":"shipmentMethodTypeId"},"PRIORITY":{"id":"OIP_PRIORITY","code":"priority"},"PROMISE_DATE":{"id":"OIP_PROMISE_DATE","code":"promiseDaysCutoff"},"SALES_CHANNEL":{"id":"OIP_SALES_CHANNEL","code":"salesChannelEnumId"},"SHIP_BY":{"id":"OSP_SHIP_BY","code":"shipBeforeDate"},"SHIP_AFTER":{"id":"OSP_SHIP_AFTER","code":"shipAfterDate"},"ORDER_DATE":{"id":"OSP_ORDER_DATE","code":"orderDate"},"SHIPPING_METHOD_SORT":{"id":"OSP_SHIP_METH","code":"deliveryDays"}}
\ No newline at end of file
+VUE_APP_RULE_ENUMS={"FILTER":"ENTCT_FILTER","SORT":"ENTCT_SORT_BY","QUEUE":{"id":"OIP_QUEUE","code":"facilityId"},"SHIPPING_METHOD":{"id":"OIP_SHIP_METH_TYPE","code":"shipmentMethodTypeId"},"PRIORITY":{"id":"OIP_PRIORITY","code":"priority"},"PROMISE_DATE":{"id":"OIP_PROMISE_DATE","code":"promiseDaysCutoff"},"SALES_CHANNEL":{"id":"OIP_SALES_CHANNEL","code":"salesChannelEnumId"},"SHIP_BY":{"id":"OSP_SHIP_BY","code":"shipBeforeDate"},"SHIP_AFTER":{"id":"OSP_SHIP_AFTER","code":"shipAfterDate"},"ORDER_DATE":{"id":"OSP_ORDER_DATE","code":"orderDate"},"SHIPPING_METHOD_SORT":{"id":"OSP_SHIP_METH","code":"deliveryDays"}}
+VUE_APP_RULE_FILTER_ENUMS={"FACILITY_GROUP":{"id":"IIP_FACILITY_GROUP","code":"facilityGroupId"},"PROXIMITY":{"id":"IIP_PROXIMITY","code":"distance"},"BRK_SAFETY_STOCK":{"id":"IIP_BRK_SFTY_STOCK","code":"brokeringSafetyStock"},"MEASUREMENT_SYSTEM":{"id":"IIP_MSMNT_SYSTEM","code":"measurementSystem"}}
+VUE_APP_RULE_SORT_ENUMS={"PROXIMITY":{"id":"ISP_PROXIMITY","code":"distance"},"INV_BALANCE":{"id":"ISP_INV_BAL","code":"inventoryForAllocation"},"CUSTOMER_SEQ":{"id":"ISP_CUST_SEQ","code":"facilitySequence"}}
+VUE_APP_RULE_ACTION_ENUMS={"AUTO_CANCEL_DAYS":{"id":"ORA_AUTO_CANCEL_DATE","code":"ADD_AUTO_CANCEL_DATE"},"NEXT_RULE":{"id":"ORA_NEXT_RULE","code":"NEXT_RULE"},"MOVE_TO_QUEUE":{"id":"ORA_MV_TO_QUEUE","code":"MOVE_TO_QUEUE"}}
\ No newline at end of file