From f417ee22f28b91421cad1173c39ee2991cdf0b5e Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Fri, 26 Jan 2024 14:45:09 +0530
Subject: [PATCH 1/3] Improved: support to fetch route with current group and
 update routes in bulk(feat/route)

---
 src/components/ArchivedRoutingModal.vue   |  19 ++--
 src/services/RoutingService.ts            |  13 +--
 src/store/modules/orderRouting/actions.ts | 119 +++-----------------
 src/store/modules/orderRouting/getters.ts |   3 -
 src/utils/index.ts                        |   2 +
 src/views/BrokeringRoute.vue              | 127 ++++++++++++++++------
 src/views/BrokeringRuns.vue               |   1 -
 7 files changed, 119 insertions(+), 165 deletions(-)

diff --git a/src/components/ArchivedRoutingModal.vue b/src/components/ArchivedRoutingModal.vue
index a0f2508..2731943 100644
--- a/src/components/ArchivedRoutingModal.vue
+++ b/src/components/ArchivedRoutingModal.vue
@@ -24,7 +24,6 @@
 </template>
 
 <script setup lang="ts">
-import emitter from "@/event-bus";
 import { Route } from "@/types";
 import {
   IonButton,
@@ -41,26 +40,26 @@ import {
 } from "@ionic/vue";
 import { closeOutline } from "ionicons/icons";
 import { defineProps, ref } from "vue";
-import { useStore } from "vuex";
 
-const store = useStore()
 const props = defineProps({
   archivedRoutings: {
     required: true
   }
 })
 
-let routings = ref(props.archivedRoutings)
+let routings = ref(props.archivedRoutings) as any
+let routingsToUpdate = ref([]) as any
 
 function closeModal() {
-  modalController.dismiss({ dismissed: true });
+  modalController.dismiss({ dismissed: true, routings: routingsToUpdate.value.concat(routings.value) });
 }
 
 async function updateOrderRouting(routing: Route, fieldToUpdate: string, value: string) {
-  const orderRoutingId = await store.dispatch("orderRouting/updateOrderRouting", { orderRoutingId: routing.orderRoutingId, fieldToUpdate, value })
-  if(orderRoutingId) {
-    routings.value = (routings.value as any).filter((routing: Route) => routing.orderRoutingId !== orderRoutingId)
-    emitter.emit("initializeOrderRoutings")
-  }
+  routingsToUpdate.value.push({
+    ...routing,
+    [fieldToUpdate]: value
+  })
+  // remove the updated routing from the archivedRoutings
+  routings.value = routings.value.filter((route: Route) => route.orderRoutingId !== routing.orderRoutingId)
 }
 </script>
diff --git a/src/services/RoutingService.ts b/src/services/RoutingService.ts
index 0a25fd8..db4998e 100644
--- a/src/services/RoutingService.ts
+++ b/src/services/RoutingService.ts
@@ -8,7 +8,7 @@ const fetchRoutingGroups = async (payload: any): Promise<any> => {
   });
 }
 
-const fetchRoutingGroup = async (routingGroupId: string): Promise<any> => {
+const fetchRoutingGroupInformation = async (routingGroupId: string): Promise<any> => {
   return api({
     url: `groups/${routingGroupId}`,
     method: "GET"
@@ -31,14 +31,6 @@ const updateRoutingGroup = async (payload: any): Promise<any> => {
   })
 }
 
-const fetchOrderRoutings = async (payload: any): Promise<any> => {
-  return api({
-    url: `groups/${payload.routingGroupId}/routings`,
-    method: "GET",
-    query: payload
-  });
-}
-
 const fetchOrderRouting = async (orderRoutingId: string): Promise<any> => {
   return api({
     url: `routings/${orderRoutingId}`,
@@ -150,9 +142,8 @@ export const OrderRoutingService = {
   deleteRoutingFilter,
   deleteRuleCondition,
   fetchOrderRouting,
-  fetchOrderRoutings,
   fetchRoutingFilters,
-  fetchRoutingGroup,
+  fetchRoutingGroupInformation,
   fetchRoutingGroups,
   fetchRoutingRules,
   fetchRuleActions,
diff --git a/src/store/modules/orderRouting/actions.ts b/src/store/modules/orderRouting/actions.ts
index 550346d..55bca4a 100644
--- a/src/store/modules/orderRouting/actions.ts
+++ b/src/store/modules/orderRouting/actions.ts
@@ -50,40 +50,11 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
     }
   },
 
-  async updateRoutingGroup({ commit, state }, payload) {
-    const current = JSON.parse(JSON.stringify(state.currentGroup))
-
-    const params = {
-      routingGroupId: payload.routingGroupId,
-      [payload.fieldToUpdate]: payload.value
-    }
+  async fetchCurrentRoutingGroup({ commit }, routingGroupId) {
+    let currentGroup = {} as any
 
     try {
-      const resp = await OrderRoutingService.updateRoutingGroup(params);
-
-      if(!hasError(resp) && resp.data.routingGroupId) {
-        current[payload.fieldToUpdate] = payload.value
-        showToast("Rounting group information updated")
-      } else {
-        throw resp.data
-      }
-    } catch(err) {
-      logger.error(err);
-    }
-    commit(types.ORDER_ROUTING_CURRENT_GROUP_UPDATED, current)
-  },
-
-  async fetchCurrentRoutingGroup({ dispatch, state }, routingGroupId) {
-    const current = state.currentGroup
-    if(current.routingGroupId && current.routingGroupId === routingGroupId) {
-      dispatch("setCurrentRoutingGroup", current)
-      return;
-    }
-
-    let currentGroup = {}
-
-    try {
-      const resp = await OrderRoutingService.fetchRoutingGroup(routingGroupId);
+      const resp = await OrderRoutingService.fetchRoutingGroupInformation(routingGroupId);
 
       if(!hasError(resp) && resp.data) {
         currentGroup = resp.data
@@ -94,41 +65,15 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
       logger.error(err);
     }
 
-    dispatch("setCurrentRoutingGroup", currentGroup)
-  },
-
-  async setCurrentRoutingGroup({ commit }, payload) {
-    commit(types.ORDER_ROUTING_CURRENT_GROUP_UPDATED, payload)
-  },
-
-  async fetchOrderRoutings({ commit }, routingGroupId) {
-    let orderRoutings = [] as any;
-    // filter groups on the basis of productStoreId
-    const payload = {
-      routingGroupId
+    if(currentGroup.routings.length) {
+      currentGroup.routings = sortSequence(currentGroup.routings)
     }
 
-    try {
-      const resp = await OrderRoutingService.fetchOrderRoutings(payload);
-
-      if(!hasError(resp) && resp.data.length) {
-        orderRoutings = resp.data
-      } else {
-        throw resp.data
-      }
-    } catch(err) {
-      logger.error(err);
-    }
-
-    if(orderRoutings.length) {
-      orderRoutings = sortSequence(orderRoutings)
-    }
-
-    commit(types.ORDER_ROUTINGS_UPDATED, orderRoutings)
+    commit(types.ORDER_ROUTING_CURRENT_GROUP_UPDATED, currentGroup)
   },
 
-  async createOrderRouting({ commit, state }, payload) {
-    let orderRoutings = JSON.parse(JSON.stringify(state.routes))
+  async createOrderRouting({ dispatch, state }, payload) {
+    const currentGroup = JSON.parse(JSON.stringify(state.currentGroup))
     let orderRoutingId = ''
 
     try {
@@ -136,19 +81,18 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
 
       if(!hasError(resp) && resp?.data.orderRoutingId) {
         orderRoutingId = resp.data.orderRoutingId
-        orderRoutings.push({
+        currentGroup["routings"].push({
           ...payload,
           orderRoutingId
         })
-        showToast('New Order Routing Created')
+        showToast('New routing created')
       }
 
-      // Sort the routings and update the state only on success
-      if(orderRoutings.length) {
-        orderRoutings = sortSequence(orderRoutings)
+      if(currentGroup["routings"].length) {
+        currentGroup["routings"] = sortSequence(currentGroup["routings"])
       }
 
-      commit(types.ORDER_ROUTINGS_UPDATED, orderRoutings)
+      await dispatch("setCurrentGroup", currentGroup)
     } catch(err) {
       showToast("Failed to create order routing")
       logger.error('err', err)
@@ -157,41 +101,8 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
     return orderRoutingId;
   },
 
-  async updateOrderRouting({ commit, state }, payload) {
-    let orderRoutings = JSON.parse(JSON.stringify(state.routes))
-    const field: Route[keyof Route] = payload.fieldToUpdate
-    let orderRoutingId = ''
-
-    const params = {
-      orderRoutingId: payload.orderRoutingId,
-      [field]: payload.value  // only one field can be updated once for orderRouting
-    }
-
-    try {
-      const resp = await OrderRoutingService.updateOrderRouting(params);
-
-      if(!hasError(resp) && resp.data.orderRoutingId) {
-        orderRoutingId = resp.data.orderRoutingId
-        orderRoutings.map((routing: Route) => {
-          if(routing.orderRoutingId === orderRoutingId) {
-            routing[field] = payload.value
-          }
-        })
-        showToast("Order routing information updated")
-      } else {
-        throw resp.data
-      }
-    } catch(err) {
-      showToast("Failed to update order routing")
-      logger.error(err);
-    }
-
-    if(orderRoutings.length) {
-      orderRoutings = sortSequence(orderRoutings)
-    }
-
-    commit(types.ORDER_ROUTINGS_UPDATED, orderRoutings)
-    return orderRoutingId;
+  async setCurrentGroup({ commit }, currentGroup) {
+    commit(types.ORDER_ROUTING_CURRENT_GROUP_UPDATED, currentGroup)
   },
 
   async fetchCurrentOrderRouting({ dispatch, state }, orderRoutingId) {
diff --git a/src/store/modules/orderRouting/getters.ts b/src/store/modules/orderRouting/getters.ts
index a95480f..b38bfd2 100644
--- a/src/store/modules/orderRouting/getters.ts
+++ b/src/store/modules/orderRouting/getters.ts
@@ -6,9 +6,6 @@ const getters: GetterTree<OrderRoutingState, RootState> = {
   getRoutingGroups(state) {
     return state.groups
   },
-  getOrderRoutings(state) {
-    return state.routes
-  },
   getRoutingRules(state) {
     return JSON.parse(JSON.stringify(state.rules))
   },
diff --git a/src/utils/index.ts b/src/utils/index.ts
index 52856be..acfd9fd 100644
--- a/src/utils/index.ts
+++ b/src/utils/index.ts
@@ -119,6 +119,8 @@ const jsonToCsv = (file: any, options: JsonToCsvOption = {}) => {
 }
 
 const sortSequence = (sequence: Array<Group | Route | Rule>) => {
+  // Currently, sorting is only performed on sequenceNum, so if two seqence have same seqNum then they will be arranged in FCFS basis
+  // TODO: Need to check that if for the above case we need to define the sorting on name as well, when seqNum is same
   return sequence.sort((a, b) => a.sequenceNum - b.sequenceNum)
 }
 
diff --git a/src/views/BrokeringRoute.vue b/src/views/BrokeringRoute.vue
index 3dd0f26..b3593f6 100644
--- a/src/views/BrokeringRoute.vue
+++ b/src/views/BrokeringRoute.vue
@@ -96,7 +96,7 @@
         </section>
       </div>
       <ion-fab vertical="bottom" horizontal="end" slot="fixed">
-        <ion-fab-button :disabled="!routingsToUpdate.length">
+        <ion-fab-button @click="saveRoutingGroup">
           <ion-icon :icon="saveOutline" />
         </ion-fab-button>
       </ion-fab>
@@ -105,18 +105,17 @@
 </template>
 
 <script setup lang="ts">
-import { IonBackButton, IonBadge, IonButtons, IonButton, IonCard, IonCardHeader, IonCardTitle, IonChip, IonContent, IonFab, IonFabButton, IonHeader, IonIcon, IonItem, IonLabel, IonList, IonListHeader, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, IonTextarea, IonTitle, IonToolbar, alertController, modalController, onIonViewWillEnter, onIonViewWillLeave } from "@ionic/vue";
+import { IonBackButton, IonBadge, IonButtons, IonButton, IonCard, IonCardHeader, IonCardTitle, IonChip, IonContent, IonFab, IonFabButton, IonHeader, IonIcon, IonItem, IonLabel, IonList, IonListHeader, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, IonTextarea, IonTitle, IonToolbar, alertController, modalController, onIonViewWillEnter } from "@ionic/vue";
 import { addCircleOutline, archiveOutline, reorderTwoOutline, saveOutline, timerOutline } from "ionicons/icons"
 import { useRouter } from "vue-router";
 import { useStore } from "vuex";
 import { computed, defineProps, ref } from "vue";
 import { Group, Route } from "@/types";
 import ArchivedRoutingModal from "@/components/ArchivedRoutingModal.vue"
-import emitter from "@/event-bus";
 import { OrderRoutingService } from "@/services/RoutingService";
 import logger from "@/logger";
 import { DateTime } from "luxon";
-import { hasError, showToast } from "@/utils";
+import { hasError, showToast, sortSequence } from "@/utils";
 
 const router = useRouter();
 const store = useStore();
@@ -129,30 +128,24 @@ const props = defineProps({
 
 const routingStatus = JSON.parse(process.env?.VUE_APP_ROUTE_STATUS_ENUMS as string)
 const cronExpressions = JSON.parse(process.env?.VUE_APP_CRON_EXPRESSIONS as string)
-let routingsToUpdate = ref([])
-let initialRoutingsOrder = ref([])
 let routingsForReorder = ref([])
 let description = ref('')
 let isDescUpdating = ref(false)
 
 let job = ref({}) as any
+let orderRoutings = ref([]) as any
 
 const currentRoutingGroup: any = computed((): Group => store.getters["orderRouting/getCurrentRoutingGroup"])
-const orderRoutings = computed(() => store.getters["orderRouting/getOrderRoutings"])
+const currentEComStore = computed(() => store.getters["user/getCurrentEComStore"])
 
 onIonViewWillEnter(async () => {
-  await Promise.all([store.dispatch("orderRouting/fetchOrderRoutings", props.routingGroupId), store.dispatch("orderRouting/fetchCurrentRoutingGroup", props.routingGroupId)])
-
-  initializeOrderRoutings();
+  await store.dispatch("orderRouting/fetchCurrentRoutingGroup", props.routingGroupId)
 
   job.value = currentRoutingGroup.value["schedule"] ? JSON.parse(JSON.stringify(currentRoutingGroup.value))["schedule"] : {}
-
-  description.value = currentRoutingGroup.value.description ? currentRoutingGroup.value.description : "No description available"
-  emitter.on("initializeOrderRoutings", initializeOrderRoutings)
-})
-
-onIonViewWillLeave(() => {
-  emitter.off("initializeOrderRoutings", initializeOrderRoutings)
+  orderRoutings.value = currentRoutingGroup.value["routings"] ? JSON.parse(JSON.stringify(currentRoutingGroup.value))["routings"] : {}
+  description.value = currentRoutingGroup.value["description"] ? currentRoutingGroup.value["description"] : "No description available"
+  
+  initializeOrderRoutings();
 })
 
 function updateCronExpression(event: CustomEvent) {
@@ -164,7 +157,6 @@ function getTime(time: any) {
 }
 
 function initializeOrderRoutings() {
-  initialRoutingsOrder.value = JSON.parse(JSON.stringify(getActiveAndDraftOrderRoutings()))
   routingsForReorder.value = JSON.parse(JSON.stringify(getActiveAndDraftOrderRoutings()))
 }
 
@@ -239,14 +231,15 @@ async function createOrderRoute() {
         routingGroupId: props.routingGroupId,
         statusId: "ROUTING_DRAFT",
         routingName,
-        sequenceNum: orderRoutings.value.length && orderRoutings.value[orderRoutings.value.length - 1].sequenceNum >= 0 ? orderRoutings.value[orderRoutings.value.length - 1].sequenceNum + 5 : 0,  // added check for `>= 0` as sequenceNum can be 0 which will result in again setting the new route seqNum to 0
+        sequenceNum: orderRoutings.value.length && orderRoutings.value[orderRoutings.value.length - 1].sequenceNum >= 0 ? orderRoutings.value[orderRoutings.value.length - 1].sequenceNum + 5 : 0,  // added check for `>= 0` as sequenceNum can be 0 which will result in again setting the new route seqNum to 0, also considering archivedRouting when calculating new seqNum
         description: ""
       }
 
       const orderRoutingId = await store.dispatch("orderRouting/createOrderRouting", payload)
 
-      // update the routing order for reordering
+      // update the routing order for reordering and the cloned updated routings again
       if(orderRoutingId) {
+        orderRoutings.value = JSON.parse(JSON.stringify(currentRoutingGroup.value["routings"]))
         initializeOrderRoutings();
       }
     }
@@ -264,16 +257,20 @@ function getArchivedOrderRoutings() {
 }
 
 async function updateGroupDescription() {
-  // Do not update description, if the desc is unchanged, we do not have routingGroupId, and description is leaft empty
+  console.log('updateGroupDescription', description.value, currentRoutingGroup.value.description)
+  // Do not update description, if the desc is unchanged, and we do not have routingGroupId, and description is left empty
   if(description.value && props.routingGroupId && currentRoutingGroup.value.description !== description.value) {
-    await store.dispatch("orderRouting/updateRoutingGroup", { routingGroupId: props.routingGroupId, fieldToUpdate: 'description', value: description.value })
+    const routingGroupId = await updateRoutingGroup({ routingGroupId: props.routingGroupId, productStoreId: currentEComStore.value.productStoreId, description: description.value })
+    if(routingGroupId) {
+      await store.dispatch("orderRouting/setCurrentGroup", { ...currentRoutingGroup.value, description: description.value })
+    }
   }
   isDescUpdating.value = false
 }
 
 function findRoutingsDiff(previousSeq: any, updatedSeq: any) {
   const diffSeq: any = Object.keys(previousSeq).reduce((diff, key) => {
-    if (updatedSeq[key].orderRoutingId === previousSeq[key].orderRoutingId) return diff
+    if (updatedSeq[key].orderRoutingId === previousSeq[key].orderRoutingId && updatedSeq[key].statusId === previousSeq[key].statusId && updatedSeq[key].sequenceNum === previousSeq[key].sequenceNum) return diff
     return {
       ...diff,
       [key]: updatedSeq[key]
@@ -283,22 +280,21 @@ function findRoutingsDiff(previousSeq: any, updatedSeq: any) {
 }
 
 function doReorder(event: CustomEvent) {
-  const previousSeq = JSON.parse(JSON.stringify(initialRoutingsOrder.value))
+  const previousSeq = JSON.parse(JSON.stringify(routingsForReorder.value))
 
   // returns the updated sequence after reordering
   const updatedSeq = event.detail.complete(JSON.parse(JSON.stringify(routingsForReorder.value)));
 
   let diffSeq = findRoutingsDiff(previousSeq, updatedSeq)
-
+  
   const updatedSeqenceNum = previousSeq.map((routing: Route) => routing.sequenceNum)
   Object.keys(diffSeq).map((key: any) => {
     diffSeq[key].sequenceNum = updatedSeqenceNum[key]
   })
 
   diffSeq = Object.keys(diffSeq).map((key) => diffSeq[key])
-
   routingsForReorder.value = updatedSeq
-  routingsToUpdate.value = diffSeq
+  orderRoutings.value = sortSequence(updatedSeq.concat(getArchivedOrderRoutings()))
 }
 
 async function openArchivedRoutingModal() {
@@ -306,15 +302,80 @@ async function openArchivedRoutingModal() {
     component: ArchivedRoutingModal,
     componentProps: { archivedRoutings: getArchivedOrderRoutings() }
   })
+
+  archivedRoutingModal.onDidDismiss().then((result: any) => {
+    if(result.data?.routings?.length) {
+      orderRoutings.value = sortSequence(getActiveAndDraftOrderRoutings().concat(result.data?.routings))
+    }
+    initializeOrderRoutings()
+  })
+
   archivedRoutingModal.present();
 }
 
 async function updateOrderRouting(routing: Route, fieldToUpdate: string, value: string) {
-  const orderRoutingId = await store.dispatch("orderRouting/updateOrderRouting", { orderRoutingId: routing.orderRoutingId, fieldToUpdate, value })
-  if(orderRoutingId) {
-    initializeOrderRoutings()
+  orderRoutings.value.map((route: any) => {
+    if(route.orderRoutingId === routing.orderRoutingId) {
+      route[fieldToUpdate] = value
+    }
+  })
+
+  initializeOrderRoutings()
+}
+
+async function saveRoutingGroup() {
+  // Converting the routings into object { orderRoutingId: routing } format as to find the diff after performing all the operations
+  const initialRoutings = currentRoutingGroup.value["routings"].reduce((routings: any, routing: any) => {
+    routings[routing.orderRoutingId] = routing
+    return routings
+  }, {})
+
+  const finalRoutings = orderRoutings.value.reduce((routings: any, routing: any) => {
+    routings[routing.orderRoutingId] = routing
+    return routings
+  }, {})
+
+  const diff = findRoutingsDiff(initialRoutings, finalRoutings)
+
+  const routings = Object.values(diff).map((routing: any) => {
+    return {
+      routingGroupId: props.routingGroupId,
+      orderRoutingId: routing.orderRoutingId,
+      routingName: routing.routingName,
+      sequenceNum: routing.sequenceNum,
+      statusId: routing.statusId
+    }
+  })
+
+  const payload = {
+    routingGroupId: props.routingGroupId,
+    productStoreId: currentEComStore.value.productStoreId,
+    routings
+  }
+
+  const routingGroupId = await updateRoutingGroup(payload)
+  if(routingGroupId) {
+    await store.dispatch("orderRouting/setCurrentGroup", { ...currentRoutingGroup.value, routings: orderRoutings.value })
   }
 }
+
+async function updateRoutingGroup(payload: any) {
+  let routingGroupId = ''
+  try {
+    const resp = await OrderRoutingService.updateRoutingGroup(payload);
+
+    if(!hasError(resp) && resp.data.routingGroupId) {
+      routingGroupId = resp.data.routingGroupId
+      showToast("Routing group information updated")
+    } else {
+      throw resp.data
+    }
+  } catch(err) {
+    logger.error(err);
+  }
+
+  return routingGroupId
+}
 </script>
 
 <style scoped>
@@ -340,12 +401,6 @@ ion-content > div > div {
   border-right: 1px solid #92949C;
 }
 
-ion-modal.date-time-modal {
-  --width: 290px;
-  --height: 440px;
-  --border-radius: 8px;
-}
-
 .actions > ion-button {
   margin: var(--spacer-sm);
 }
diff --git a/src/views/BrokeringRuns.vue b/src/views/BrokeringRuns.vue
index 01bd683..4e961d2 100644
--- a/src/views/BrokeringRuns.vue
+++ b/src/views/BrokeringRuns.vue
@@ -87,7 +87,6 @@ async function addNewRun() {
 }
 
 async function redirect(group: Group) {
-  await store.dispatch('orderRouting/setCurrentRoutingGroup', group)
   router.push(`brokering/${group.routingGroupId}/routes`)
 }
 

From 2cb5c699f40ddfaa8a9d8a19695ca1a7d982b39a Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Fri, 26 Jan 2024 15:43:45 +0530
Subject: [PATCH 2/3] Improved: code to ask user before leaving the page if
 there are unsaved changes and added support to pass createdDate when creating
 new route and added toast message when groupUpdate api fails

---
 src/store/modules/orderRouting/actions.ts |  2 +-
 src/views/BrokeringRoute.vue              | 54 ++++++++++++++++++++---
 2 files changed, 49 insertions(+), 7 deletions(-)

diff --git a/src/store/modules/orderRouting/actions.ts b/src/store/modules/orderRouting/actions.ts
index 55bca4a..010cc9f 100644
--- a/src/store/modules/orderRouting/actions.ts
+++ b/src/store/modules/orderRouting/actions.ts
@@ -5,7 +5,7 @@ import { OrderRoutingService } from "@/services/RoutingService"
 import { hasError, showToast, sortSequence } from "@/utils"
 import * as types from './mutation-types'
 import logger from "@/logger"
-import { Route, RouteFilter } from "@/types"
+import { RouteFilter } from "@/types"
 
 const actions: ActionTree<OrderRoutingState, RootState> = {
   async fetchOrderRoutingGroups({ commit }) {
diff --git a/src/views/BrokeringRoute.vue b/src/views/BrokeringRoute.vue
index b3593f6..17fb80a 100644
--- a/src/views/BrokeringRoute.vue
+++ b/src/views/BrokeringRoute.vue
@@ -96,7 +96,7 @@
         </section>
       </div>
       <ion-fab vertical="bottom" horizontal="end" slot="fixed">
-        <ion-fab-button @click="saveRoutingGroup">
+        <ion-fab-button :disabled="!hasUnsavedChanges" @click="saveRoutingGroup">
           <ion-icon :icon="saveOutline" />
         </ion-fab-button>
       </ion-fab>
@@ -105,9 +105,9 @@
 </template>
 
 <script setup lang="ts">
-import { IonBackButton, IonBadge, IonButtons, IonButton, IonCard, IonCardHeader, IonCardTitle, IonChip, IonContent, IonFab, IonFabButton, IonHeader, IonIcon, IonItem, IonLabel, IonList, IonListHeader, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, IonTextarea, IonTitle, IonToolbar, alertController, modalController, onIonViewWillEnter } from "@ionic/vue";
+import { IonBackButton, IonBadge, IonButtons, IonButton, IonCard, IonCardHeader, IonCardTitle, IonChip, IonContent, IonFab, IonFabButton, IonHeader, IonIcon, IonItem, IonLabel, IonList, IonListHeader, IonPage, IonReorder, IonReorderGroup, IonSelect, IonSelectOption, IonTextarea, IonTitle, IonToolbar, alertController, modalController, onIonViewWillEnter, onIonViewWillLeave } from "@ionic/vue";
 import { addCircleOutline, archiveOutline, reorderTwoOutline, saveOutline, timerOutline } from "ionicons/icons"
-import { useRouter } from "vue-router";
+import { onBeforeRouteLeave, useRouter } from "vue-router";
 import { useStore } from "vuex";
 import { computed, defineProps, ref } from "vue";
 import { Group, Route } from "@/types";
@@ -131,6 +131,7 @@ const cronExpressions = JSON.parse(process.env?.VUE_APP_CRON_EXPRESSIONS as stri
 let routingsForReorder = ref([])
 let description = ref('')
 let isDescUpdating = ref(false)
+let hasUnsavedChanges = ref(false)
 
 let job = ref({}) as any
 let orderRoutings = ref([]) as any
@@ -148,6 +149,36 @@ onIonViewWillEnter(async () => {
   initializeOrderRoutings();
 })
 
+onBeforeRouteLeave(async (to) => {
+  if(to.path === '/login') return;
+  let canLeave = false;
+
+  const alert = await alertController.create({
+    header: "Leave page",
+    message: "Any edits made on this page will be lost.",
+    buttons: [
+      {
+        text: "STAY",
+        handler: () => {
+          canLeave = false;
+        },
+      },
+      {
+        text: "LEAVE",
+        handler: () => {
+          canLeave = true;
+        },
+      },
+    ],
+  });
+
+  if(hasUnsavedChanges.value) {
+    alert.present();
+    await alert.onDidDismiss();
+    return canLeave;
+  }
+})
+
 function updateCronExpression(event: CustomEvent) {
   job.value.cronExpression = event.detail.value
 }
@@ -232,7 +263,8 @@ async function createOrderRoute() {
         statusId: "ROUTING_DRAFT",
         routingName,
         sequenceNum: orderRoutings.value.length && orderRoutings.value[orderRoutings.value.length - 1].sequenceNum >= 0 ? orderRoutings.value[orderRoutings.value.length - 1].sequenceNum + 5 : 0,  // added check for `>= 0` as sequenceNum can be 0 which will result in again setting the new route seqNum to 0, also considering archivedRouting when calculating new seqNum
-        description: ""
+        description: "",
+        createdDate: DateTime.now().toMillis()
       }
 
       const orderRoutingId = await store.dispatch("orderRouting/createOrderRouting", payload)
@@ -257,7 +289,6 @@ function getArchivedOrderRoutings() {
 }
 
 async function updateGroupDescription() {
-  console.log('updateGroupDescription', description.value, currentRoutingGroup.value.description)
   // Do not update description, if the desc is unchanged, and we do not have routingGroupId, and description is left empty
   if(description.value && props.routingGroupId && currentRoutingGroup.value.description !== description.value) {
     const routingGroupId = await updateRoutingGroup({ routingGroupId: props.routingGroupId, productStoreId: currentEComStore.value.productStoreId, description: description.value })
@@ -295,6 +326,8 @@ function doReorder(event: CustomEvent) {
   diffSeq = Object.keys(diffSeq).map((key) => diffSeq[key])
   routingsForReorder.value = updatedSeq
   orderRoutings.value = sortSequence(updatedSeq.concat(getArchivedOrderRoutings()))
+  // considering that when reordering there are some changes in the order of routes
+  hasUnsavedChanges.value = true
 }
 
 async function openArchivedRoutingModal() {
@@ -305,6 +338,7 @@ async function openArchivedRoutingModal() {
 
   archivedRoutingModal.onDidDismiss().then((result: any) => {
     if(result.data?.routings?.length) {
+      hasUnsavedChanges.value = true
       orderRoutings.value = sortSequence(getActiveAndDraftOrderRoutings().concat(result.data?.routings))
     }
     initializeOrderRoutings()
@@ -319,7 +353,7 @@ async function updateOrderRouting(routing: Route, fieldToUpdate: string, value:
       route[fieldToUpdate] = value
     }
   })
-
+  hasUnsavedChanges.value = true
   initializeOrderRoutings()
 }
 
@@ -337,6 +371,12 @@ async function saveRoutingGroup() {
 
   const diff = findRoutingsDiff(initialRoutings, finalRoutings)
 
+  // If there is no diff in the routing order then do not make any api call and update hasUnsavedChanges values as we have made its value to true on calling of doReorder function
+  if(!Object.keys(diff).length) {
+    hasUnsavedChanges.value = false
+    return;
+  }
+
   const routings = Object.values(diff).map((routing: any) => {
     return {
       routingGroupId: props.routingGroupId,
@@ -355,6 +395,7 @@ async function saveRoutingGroup() {
 
   const routingGroupId = await updateRoutingGroup(payload)
   if(routingGroupId) {
+    hasUnsavedChanges.value = false
     await store.dispatch("orderRouting/setCurrentGroup", { ...currentRoutingGroup.value, routings: orderRoutings.value })
   }
 }
@@ -371,6 +412,7 @@ async function updateRoutingGroup(payload: any) {
       throw resp.data
     }
   } catch(err) {
+    showToast("Failed to update group information")
     logger.error(err);
   }
 

From a60c7c17f27d8c2a3996b8adc5273baea162a211 Mon Sep 17 00:00:00 2001
From: Yash Maheshwari <yashmaheshwari551@gmail.com>
Date: Fri, 26 Jan 2024 15:45:56 +0530
Subject: [PATCH 3/3] Implemented: support to pass createdDate when creating a
 new run

---
 src/store/modules/orderRouting/actions.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/store/modules/orderRouting/actions.ts b/src/store/modules/orderRouting/actions.ts
index 010cc9f..9f4d34a 100644
--- a/src/store/modules/orderRouting/actions.ts
+++ b/src/store/modules/orderRouting/actions.ts
@@ -6,6 +6,7 @@ import { hasError, showToast, sortSequence } from "@/utils"
 import * as types from './mutation-types'
 import logger from "@/logger"
 import { RouteFilter } from "@/types"
+import { DateTime } from "luxon"
 
 const actions: ActionTree<OrderRoutingState, RootState> = {
   async fetchOrderRoutingGroups({ commit }) {
@@ -35,7 +36,8 @@ const actions: ActionTree<OrderRoutingState, RootState> = {
   async createRoutingGroup({ dispatch }, groupName) {
     const payload = {
       groupName,
-      productStoreId: "STORE"
+      productStoreId: "STORE",
+      createdDate: DateTime.now().toMillis()
     }
     try {
       const resp = await OrderRoutingService.createRoutingGroup(payload)