@bjsdistribution/dms-client-return 0.1.44-prod → 0.1.45-prod

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.44-prod",
+  "version": "0.1.45-prod",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/components/order-view/order-actions/actions/confirm-order/index.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect } from 'react';
+import React, { useEffect, useState } from 'react';
 import OrderActionModal from '../../../../../common/modals/order-action-modal/OrderActionModal';
 import styled from 'styled-components';
 import CustomerInformation from './customer-info';
@@ -11,26 +11,28 @@ import {
   useCurrentAction,
   useCustomerInfo,
   useErrorConfirmOrder,
-  useGlobalStateHitOrder,
   useNotificationConfirmedDate,
   useOrderDetails,
   useOrderDetailsConfirmOrder,
   useOrderId,
   usePrevOrderDetails,
   useSelectionAction,
-  useStatusDetails,
 } from '../../../store';
-
+import { useConfirmOrderDate } from '../../store';
 import { ApiResponse } from '../../../types';
 import { compareOrderDetailsStates, filterObject } from '../../../utils';
 import { format } from 'date-fns';
-import { useConfirmOrderDate } from '../../store';
+import SendComms from './send-comms/SendComms';
+// import { useClientPortal } from '../../../../store';
 
 interface IProps {
+  callOrdersApi: any;
+  callOrderStatusApi: any;
   callOrderAlertsApi: any;
 }
 
 function ConfirmOrder(props: IProps) {
+  // const [isClientPortal] = useClientPortal();
   const [, setCurrentAction] = useCurrentAction();
   const [orderDetails, setOrderDetails] = useOrderDetails();
   const [prevOrderDetails, setPrevOrderDetails] = usePrevOrderDetails();
@@ -43,11 +45,12 @@ function ConfirmOrder(props: IProps) {
   const [deliveryDate, setDeliveryDate] = useConfirmOrderDate();
   const [orderId] = useOrderId();
   const [errorState] = useErrorConfirmOrder();
-  const [, setRecallOrders] = useGlobalStateHitOrder();
   const [confirmedDate] = useNotificationConfirmedDate();
   const [selectedAction] = useSelectionAction();
-  const [, setOrderStatus] = useStatusDetails();
-
+  const [confirmOrderSendComms, setConfirmOrderSendComms] = useState({
+    sms: true,
+    email: true,
+  });
   const contactHome = orderDetailsConfirmOrder?.order_recipient?.contact_home;
   const contactMobile =
     orderDetailsConfirmOrder?.order_recipient?.contact_mobile;
@@ -65,7 +68,7 @@ function ConfirmOrder(props: IProps) {
   const { fetchData: notificationCall } = useAxios<{
     data: ApiResponse[];
   }>({
-    endpoint: `orders/${orderId}/send-comms/?notification_type={Confirm - Accepted} `,
+    endpoint: `orders/${orderId}/send-comms/?notification_type=Confirm - Attempted&send_sms=${confirmOrderSendComms?.sms}&send_email=${confirmOrderSendComms?.email}`,
     method: 'POST',
   });
 
@@ -79,43 +82,31 @@ function ConfirmOrder(props: IProps) {
   const { fetchData: confirmDeliveryDate } = useAxios<{
     data: ApiResponse[];
   }>({
-    endpoint: `orders/${orderId}/confirm-date/?date=${confirmedDate?.currentDate}`,
+    endpoint: `orders/${orderId}/confirm-date/?date=${confirmedDate?.currentDate}&send_sms=${confirmOrderSendComms?.sms}&send_email=${confirmOrderSendComms?.email}`,
     method: 'POST',
   });
 
   const { fetchData: sendComs } = useAxios<{
     data: ApiResponse[];
   }>({
-    endpoint: `orders/${orderId}/send-comms/?notification_type=Precall`,
+    endpoint: `orders/${orderId}/send-comms/?notification_type=Precall&send_sms=${confirmOrderSendComms?.sms}&send_email=${confirmOrderSendComms?.email}`,
     method: 'POST',
   });
 
   const { fetchData: noResponseApi } = useAxios<{
     data: ApiResponse[];
   }>({
-    endpoint: `orders/${orderId}/no-response-date/?date=${confirmedDate?.currentDate}`,
+    endpoint: `orders/${orderId}/no-response-date/?date=${confirmedDate?.currentDate}&send_sms=${confirmOrderSendComms?.sms}&send_email=${confirmOrderSendComms?.email}`,
     method: 'POST',
   });
 
   const { fetchData: proposeDate } = useAxios<{
     data: ApiResponse[];
   }>({
-    endpoint: `orders/${orderId}/propose-date/?date=${confirmedDate?.currentDate}`,
+    endpoint: `orders/${orderId}/propose-date/?date=${confirmedDate?.currentDate}&send_sms=${confirmOrderSendComms?.sms}&send_email=${confirmOrderSendComms?.email}`,
     method: 'POST',
   });
 
-  //Order status api
-  const {
-    fetchData: fetchStatusData,
-    data: statusData,
-    loading: statusDataLoading,
-  } = useAxios<{
-    data: ApiResponse[];
-  }>({
-    endpoint: `/orders/get_live_status/${orderId}`,
-    method: 'GET',
-  });
-
   const onClose = () => {
     setCurrentAction(undefined);
   };
@@ -128,69 +119,99 @@ function ConfirmOrder(props: IProps) {
     };
   }, []);
 
-  useEffect(() => {
-    if (statusData && statusData?.data) {
-      setOrderStatus(statusData?.data);
-    }
-  }, [statusDataLoading]);
-
-  // THIS HAS BEEN REMOVED AS WE HAVE NEW APIS
-  // const {
-  //   loading: loadingForConfirm,
-  //   data: response,
-  //   setShouldPerformAction: setPerformAction,
-  // } = useApiHook<{
-  //   data: ApiResponse[];
-  // }>({
-  //   endpoint: `orders/${orderId}/confirm-date/?date=${deliveryDate}`,
-  //   method: 'POST',
-  //   performAction: false,
-  // });
-
   function hasOnlyIdKey(obj: any) {
     return Object.keys(obj).length === 1 && obj.hasOwnProperty('id');
   }
 
+  const handleSuccess = (message: string, res?: any) => {
+    const apiMessage =
+      res?.data?.message || res?.message || res?.data?.data?.message;
+
+    notification.success({
+      message: 'Success',
+      description: apiMessage || message,
+    });
+  };
+
+  const handleError = (error: any, fallback: string) => {
+    const err = error as any;
+    notification.error({
+      message: 'Request Failed',
+      description:
+        err?.response?.data?.error ||
+        err?.response?.data?.message ||
+        err?.message ||
+        fallback,
+    });
+  };
+
   const executeActions = async () => {
     switch (selectedAction) {
       case 'decline_and_propose_new_date':
-        // call propose date api
-        if (confirmedDate?.previousDate !== null) {
-          await declineDate();
+        try {
+          if (confirmedDate?.previousDate !== null) {
+            const response = (await declineDate()) as any;
+            handleSuccess('Previous date declined successfully', response);
+          }
+
+          const response = (await proposeDate()) as any;
+          handleSuccess('New date proposed successfully', response);
+        } catch (error) {
+          handleError(error, 'Failed to propose new date');
         }
-        await proposeDate();
-        await fetchStatusData();
         break;
 
       case 'decline_and_confirm_new_date':
-        if (confirmedDate?.previousDate !== null) {
-          await declineDate();
+        try {
+          if (confirmedDate?.previousDate !== null) {
+            const response = (await declineDate()) as any;
+            handleSuccess('Previous date declined successfully', response);
+          }
+
+          const response = (await confirmDeliveryDate()) as any;
+          handleSuccess('New date confirmed successfully', response);
+        } catch (error) {
+          handleError(error, 'Failed to confirm new date');
         }
-        await confirmDeliveryDate();
-        await fetchStatusData();
         break;
 
       case 'declined_proposed_date(outstanding)':
-        if (confirmedDate?.previousDate !== null) {
-          await declineDate();
+        try {
+          if (confirmedDate?.previousDate !== null) {
+            const response = (await declineDate()) as any;
+            handleSuccess('Proposed date declined successfully', response);
+          }
+        } catch (error) {
+          handleError(error, 'Failed to decline proposed date');
         }
-        await fetchStatusData();
         break;
 
       case 'no_response_propose_new_date':
-        if (confirmedDate?.previousDate !== null) {
-          await declineDate();
+        try {
+          if (confirmedDate?.previousDate !== null) {
+            const response = (await declineDate()) as any;
+            handleSuccess('Previous date declined successfully', response);
+          }
+
+          const response = (await noResponseApi()) as any;
+          handleSuccess('No response date proposed successfully', response);
+        } catch (error) {
+          handleError(error, 'Failed to propose date (no response)');
         }
-        await noResponseApi();
-        await fetchStatusData();
         break;
 
       case 'confirmed':
-        if (confirmedDate?.previousDate !== null) {
-          await declineDate();
+        try {
+          if (confirmedDate?.previousDate !== null) {
+            const response = (await declineDate()) as any;
+            handleSuccess('Previous date declined successfully', response);
+          }
+
+          const response = (await confirmDeliveryDate()) as any;
+          handleSuccess('Delivery date confirmed successfully', response);
+        } catch (error) {
+          handleError(error, 'Failed to confirm delivery date');
         }
-        await confirmDeliveryDate();
-        await fetchStatusData();
         break;
 
       default:
@@ -203,115 +224,167 @@ function ConfirmOrder(props: IProps) {
       case 'left_message':
       case 'contact_made':
       case 'no_contact':
-        // await confirmDeliveryDate();
-        notificationCall();
-        await fetchStatusData();
+        try {
+          const response = (await notificationCall()) as any;
+          handleSuccess('Notification sent successfully', response);
+        } catch (error) {
+          handleError(error, 'Failed to send notification');
+        }
         break;
 
       case 'precall':
-        if (confirmedDate?.previousDate !== null) {
-          await declineDate();
+        try {
+          if (confirmedDate?.previousDate !== null) {
+            const response = (await declineDate()) as any;
+            handleSuccess('Previous date declined successfully', response);
+          }
+
+          const response = (await sendComs()) as any;
+          handleSuccess('Precall communication sent successfully', response);
+        } catch (error) {
+          handleError(error, 'Failed to send precall communication');
         }
-        // await confirmDeliveryDate();
-        sendComs();
-        await fetchStatusData();
         break;
+
       default:
         break;
     }
   };
 
   const confirmOrder = async () => {
-    setRecallOrders(false);
-
-    if (
-      selectedAction === 'left_message' ||
-      selectedAction === 'contact_made' ||
-      selectedAction === 'no_contact' ||
-      selectedAction === 'precall'
-    ) {
-      if (
-        contactHome?.length === 0 &&
-        contactMobile?.length === 0 &&
-        contactWork?.length === 0
-      ) {
-        notification.info({
-          message: 'Info',
-          description: 'Please add contact information',
-        });
-        return;
-      }
+    try {
       if (
-        confirmedDate?.previousDate === null &&
-        confirmedDate?.currentDate === null
+        selectedAction === 'left_message' ||
+        selectedAction === 'contact_made' ||
+        selectedAction === 'no_contact' ||
+        selectedAction === 'precall'
       ) {
-        notification.info({
-          message: 'Info',
-          description: 'Please add delivery date',
-        });
-        return;
+        if (
+          contactHome?.length === 0 &&
+          contactMobile?.length === 0 &&
+          contactWork?.length === 0
+        ) {
+          notification.info({
+            message: 'Info',
+            description: 'Please add contact information',
+          });
+          return;
+        }
+
+        if (
+          confirmedDate?.previousDate === null &&
+          confirmedDate?.currentDate === null
+        ) {
+          notification.info({
+            message: 'Info',
+            description: 'Please add delivery date',
+          });
+          return;
+        }
       }
-    }
 
-    const keysToRemovefromOrders = [
-      'order_locked',
-      'order_communications',
-      'updated_at',
-      'updated_by',
-      'stock_alias',
-      'order_delivery_declined_dates',
-      'order_eta_updates',
-    ];
-
-    const filteredOrderDetails = filterObject(
-      orderDetailsConfirmOrder,
-      keysToRemovefromOrders
-    );
-    const filteredPrevOrderDetails = filterObject(
-      prevOrderDetails,
-      keysToRemovefromOrders
-    );
-    const payload = compareOrderDetailsStates(
-      filteredPrevOrderDetails,
-      filteredOrderDetails
-    );
-    const notUpdateOrder = hasOnlyIdKey(payload);
-
-    if (!notUpdateOrder) {
+      const keysToRemovefromOrders = [
+        'order_locked',
+        'order_communications',
+        'updated_at',
+        'updated_by',
+        'stock_alias',
+        'order_delivery_declined_dates',
+        'order_eta_updates',
+        'order_status',
+        'tomtom_status',
+        'refused_service',
+        'order_type',
+        'order_failures',
+        'order_on_hold',
+        'order_cancellations',
+        'order_routes',
+      ];
+
+      const filteredOrderDetails = filterObject(
+        orderDetailsConfirmOrder,
+        keysToRemovefromOrders
+      );
+
+      const filteredPrevOrderDetails = filterObject(
+        prevOrderDetails,
+        keysToRemovefromOrders
+      );
+
+      const payload = compareOrderDetailsStates(
+        filteredPrevOrderDetails,
+        filteredOrderDetails
+      );
+
       const updatedPayload = {
         ...payload,
         action_date: confirmedDate?.currentDate,
       };
 
-      const response = (await callUpdateOrderAPI({
-        payload: [updatedPayload],
-      })) as {
-        code: number | null;
-        error?: string | null | undefined;
-        [key: string]: any;
-      };
+      const notUpdateOrder = hasOnlyIdKey(updatedPayload);
+
+      if (!notUpdateOrder) {
+        try {
+          const response = (await callUpdateOrderAPI({
+            payload: [updatedPayload],
+          })) as any;
+
+          if (response?.data?.length > 0) {
+            const updatedOrder = response?.data[0];
+            setOrderDetails(updatedOrder);
+            setPrevOrderDetails(updatedOrder);
+            handleSuccess('Order updated successfully', response);
+          } else {
+            setOrderDetails(prevOrderDetails);
+          }
+        } catch (error) {
+          handleError(error, 'Failed to update order');
+          setOrderDetails(prevOrderDetails);
+        }
+      }
 
-      if (response?.data?.length > 0) {
-        const updatedOrder = response?.data[0];
-        setOrderDetails(updatedOrder);
-        setPrevOrderDetails(updatedOrder);
-        setRecallOrders(true);
-      } else {
-        setOrderDetails(prevOrderDetails);
+      try {
+        await executeActions();
+      } catch (error) {
+        handleError(error, 'Failed to execute actions');
       }
-    }
 
-    // Execute actions first
-    await executeActions();
-    await executeSendComs();
+      try {
+        await executeSendComs();
+      } catch (error) {
+        handleError(error, 'Failed to send communications');
+      }
 
-    if (orderId && deliveryDate) {
-      const formattedDate = format(new Date(deliveryDate), 'yyyy-MM-dd');
-      setDeliveryDate(formattedDate);
-    }
-    await props?.callOrderAlertsApi();
+      if (orderId && deliveryDate) {
+        const formattedDate = format(new Date(deliveryDate), 'yyyy-MM-dd');
+        setDeliveryDate(formattedDate);
+      }
 
-    setCurrentAction(undefined);
+      try {
+        await props?.callOrderStatusApi();
+        handleSuccess('Order status refreshed successfully');
+      } catch (error) {
+        handleError(error, 'Failed to refresh order status');
+      }
+
+      try {
+        await props?.callOrderAlertsApi();
+        handleSuccess('Order alerts refreshed successfully');
+      } catch (error) {
+        handleError(error, 'Failed to refresh alerts');
+      }
+
+      try {
+        await props?.callOrdersApi();
+        handleSuccess('Orders refreshed successfully');
+      } catch (error) {
+        handleError(error, 'Failed to refresh orders');
+      }
+
+      handleSuccess('Order processed successfully');
+    } catch (error) {
+      handleError(error, 'Something went wrong');
+    }
   };
 
   const errorFound = () => {
@@ -328,13 +401,19 @@ function ConfirmOrder(props: IProps) {
   return (
     <OrderActionModal
       headerTitle="Confirm Order"
-      minWidth="28vw"
+      minWidth="60vw"
       showAdditionalInfo
       infoText={infoText}
       onCloseHeader={onClose}
       onSubmit={confirmOrder}
       submitBtnTitle="Save Details"
       isSubmitDisabled={errorFound() && disabledButton}
+      footerActions={
+        <SendComms
+          sendCommsState={confirmOrderSendComms}
+          setSendCommsState={setConfirmOrderSendComms}
+        />
+      }
     >
       <ContentContainer>
         <Alert
@@ -375,6 +454,7 @@ const ContentContainer = styled.div`
   overflow-x: hidden;
   max-height: 500px;
   scrollbar-width: thin;
+  width: 100%;
 `;
 
 export default ConfirmOrder;

package/src/components/order-view/order-actions/actions/confirm-order/send-comms/SendComms.tsx

@@ -0,0 +1,86 @@
+import { Checkbox } from 'antd';
+import React from 'react';
+import styled from 'styled-components';
+import { useOrderDetailsConfirmOrder } from '../../../../store';
+
+interface IProps {
+  sendCommsState: any;
+  setSendCommsState: any;
+}
+
+const SendComms = (props: IProps) => {
+  const [orderDetailsConfirmOrder] = useOrderDetailsConfirmOrder();
+
+  const onChange = (e: any, type: string) => {
+    if (type === 'email') {
+      const updatedData = {
+        sms: props?.sendCommsState?.sms,
+        email: e.target.checked,
+      };
+      props?.setSendCommsState(updatedData);
+    } else {
+      const updatedData = {
+        sms: e.target.checked,
+        email: props?.sendCommsState?.email,
+      };
+      props?.setSendCommsState(updatedData);
+    }
+  };
+
+  const contactHome = orderDetailsConfirmOrder?.order_recipient?.contact_home;
+  const contactMobile =
+    orderDetailsConfirmOrder?.order_recipient?.contact_mobile;
+  const contactWork = orderDetailsConfirmOrder?.order_recipient?.contact_work;
+  const contactEmail = orderDetailsConfirmOrder?.order_recipient?.contact_email;
+
+  const showSms =
+    (contactHome?.length !== 0 && contactHome != null) ||
+    (contactMobile?.length !== 0 && contactMobile != null) ||
+    (contactWork?.length !== 0 && contactWork != null);
+
+  const showEmail = contactEmail?.length !== 0 && contactEmail != null;
+
+  return (
+    <SendCommsMainContainer>
+      {showEmail && (
+        <div className="send-comms-container">
+          <span className="label">Send Email</span>
+          <Checkbox
+            checked={props?.sendCommsState?.email}
+            onChange={(e: any) => onChange(e, 'email')}
+          />
+        </div>
+      )}
+      {showSms && (
+        <div className="send-comms-container">
+          <span className="label">Send SMS</span>
+          <Checkbox
+            checked={props?.sendCommsState?.sms}
+            onChange={(e: any) => onChange(e, 'sms')}
+          />
+        </div>
+      )}
+    </SendCommsMainContainer>
+  );
+};
+
+const SendCommsMainContainer = styled.div`
+  display: flex;
+  align-items: center;
+  gap: 15px;
+
+  .send-comms-container {
+    display: flex;
+    gap: 5px;
+    align-items: center;
+    .label {
+      color: #6a7378;
+      font-size: 14px;
+      font-weight: 400;
+      font-family: 'Lato', sans-serif;
+      line-height: 20px;
+    }
+  }
+`;
+
+export default React.memo(SendComms);

package/src/components/order-view/order-actions/index.tsx

@@ -250,7 +250,13 @@ function OrderActions() {
           />
         );
       case 'confirm-order':
-        return <ConfirmOrder callOrderAlertsApi={callOrderAlertsApi} />;
+        return (
+          <ConfirmOrder
+            callOrdersApi={callOrdersApi}
+            callOrderStatusApi={fetchStatusData}
+            callOrderAlertsApi={callOrderAlertsApi}
+          />
+        );
       case 'send-sms':
         return <SendSmsModal />;