@bjsdistribution/dms-client-return 0.0.94-prod → 0.0.95-prod

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

@@ -1,7 +1,16 @@
-import React from 'react';
+import React, { useEffect } from 'react';
 import AddResources from './actions/add-resources';
 import styled from 'styled-components';
-import { useCurrentAction } from '../store';
+import {
+  useCurrentAction,
+  useOrderAlertsData,
+  useOrderDetails,
+  useOrderId,
+  usePrevOrderDetails,
+  useProductDetails,
+  useProductDetailsCopy,
+  useStatusDetails,
+} from '../store';
 import SplitOrder from './actions/split-order';
 import LogServiceRefusal from './actions/log-service-refusal';
 import CancelOrder from './actions/cancel-order';
@@ -10,20 +19,189 @@ import SendSmsModal from './actions/send-sms/SendSmsModal';
 import SendEmailModal from './actions/send-email/SendEmailModal';
 import ChangeCustomerAccModal from './actions/change-customer-account/ChangeCustomerAccModal';
 import HoldOrderModal from './actions/hold-order/HoldOrderModal';
-import LogFeedback from './actions/log-feedback/LogFeedback';
 import UnholdOrder from './actions/unhold-order/UnholdOrder';
-import TaskReminderModal from './actions/create-task-reminder';
-import OrderLock from './actions/order-lock';
+import ViewReminderModal from '../view-reminder/ViewReminder';
+// import OrderLock from './actions/order-lock';
 import ViewFlag from '../flags-action-modal/index';
 import ReleaseOrder from './actions/release-order/ReleaseOrder';
-import UncancelOrder from './actions/uncancel-order/UncancelOrder';
 import ClearBookingStatus from './actions/clear-booking-status/ClearBookingStatus';
+import UncancelOrder from './actions/uncancel-order/UncancelOrder';
 import RemoveFromRoute from './actions/remove-from-route/RemoveFromRoute';
+import { useAxios } from '@bjsdistribution/dms-component-library';
+import { ApiResponse, OrdersType } from '../types';
+import { useLoading } from '../../order-daily-overview/store/store';
+import { useReminderNotiData, useTasksData } from './store';
+import ChargeLog from './actions/charge-log';
+import ReminderModal from './actions/create-task-reminder';
 import TaskModal from './actions/create-task-reminder/TaskModal';
-import ViewReminderModal from '../view-reminder/ViewReminder';
 
 function OrderActions() {
-  const [currentAction] = useCurrentAction();
+  const [currentAction, setCurrentAction] = useCurrentAction();
+  const [orderId] = useOrderId();
+  const [, setOrderDetails] = useOrderDetails();
+  const [, setPrevOrderDetails] = usePrevOrderDetails();
+  const [, setOrderStatus] = useStatusDetails();
+  const [, setOrderAlertsData] = useOrderAlertsData();
+  const [, setProductDetails] = useProductDetails();
+  const [, setProductDetailsCopy] = useProductDetailsCopy();
+  const [, setLoading] = useLoading();
+  const [, setTasksData] = useTasksData();
+  const [, setReminderNotifyData] = useReminderNotiData();
+
+  // call orders api
+
+  const { fetchData: callOrdersApi, loading, data: fetchedData } = useAxios<{
+    data: OrdersType[];
+  }>({
+    endpoint: `/orders/${orderId}`,
+    method: 'GET',
+  });
+
+  useEffect(() => {
+    setLoading(loading);
+    if (fetchedData && fetchedData?.data) {
+      const requiredData = fetchedData?.data;
+      setOrderDetails(requiredData[0]);
+      setPrevOrderDetails(requiredData[0]);
+      setCurrentAction(undefined);
+    }
+    if (
+      (fetchedData && fetchedData?.data === null) ||
+      fetchedData?.data?.length === 0
+    ) {
+      setCurrentAction(undefined);
+    }
+  }, [loading]);
+
+  // orders api ends
+
+  // call order products api start
+
+  const {
+    data: productsData,
+    loading: orderProductsLoading,
+    fetchData: callOrderProductsApi,
+  } = useAxios<{
+    data: ApiResponse[];
+  }>({
+    endpoint: `/order/order_products/${orderId}`,
+    method: 'GET',
+  });
+
+  useEffect(() => {
+    if (productsData && productsData?.data?.length > 0) {
+      setProductDetails(productsData?.data);
+      setProductDetailsCopy(productsData?.data);
+    } else {
+      setProductDetails(null);
+      setProductDetailsCopy(null);
+    }
+  }, [orderProductsLoading]);
+
+  // call order products api end
+
+  // call alerts api
+
+  const {
+    data: alertsData,
+    fetchData: callOrderAlertsApi,
+    loading: alertsApiLoading,
+  } = useAxios<{
+    data: ApiResponse[];
+  }>({
+    endpoint: `v1/orders/alerts/?order_id=${orderId}`,
+    method: 'GET',
+  });
+
+  useEffect(() => {
+    if (alertsData && alertsData?.data) {
+      setOrderAlertsData(alertsData?.data);
+    }
+  }, [alertsApiLoading]);
+
+  // alerts api ends
+
+  // call live status api
+
+  const {
+    fetchData: fetchStatusData,
+    data: statusData,
+    loading: statusDataLoading,
+  } = useAxios<{
+    data: ApiResponse[];
+  }>({
+    endpoint: `/orders/get_live_status/${orderId}`,
+    method: 'GET',
+  });
+
+  useEffect(() => {
+    if (statusData && statusData?.data) {
+      setOrderStatus(statusData?.data);
+    }
+  }, [statusDataLoading]);
+
+  // Call Task Get Api
+  const {
+    fetchData: callUnresolvedTaskApi,
+    data: fetchedUnresolvedData,
+    loading: unresolvedLoading,
+  } = useAxios<{
+    data: ApiResponse[];
+  }>({
+    endpoint: `/v1/task/`,
+    method: 'GET',
+    pagination: { is_pagination: false },
+    filters: [{ field: 'order_id', op: '=', value: orderId }],
+  });
+
+  useEffect(() => {
+    if (fetchedUnresolvedData && fetchedUnresolvedData?.data) {
+      setTasksData(fetchedUnresolvedData?.data);
+    }
+  }, [unresolvedLoading]);
+
+  // Task Api Ends
+
+  // reminder api starts here
+
+  //reminder get
+  const {
+    data: fetchedReminderData,
+    loading: reminderLoading,
+    fetchData: callReminderApi,
+  } = useAxios<{
+    data: ApiResponse[];
+  }>({
+    endpoint: `/v1/task/reminder/get/`,
+    method: 'GET',
+    pagination: { is_pagination: false },
+    filters: [{ field: 'order_id', op: '=', value: orderId }],
+  });
+
+  useEffect(() => {
+    if (fetchedReminderData && fetchedReminderData?.data) {
+      setReminderNotifyData(fetchedReminderData?.data);
+      const filteredReminders = fetchedReminderData?.data?.filter(
+        (reminder: any) => reminder?.status === false
+      );
+
+      const filteredOverDueReminders = fetchedReminderData?.data?.filter(
+        (reminder: any) =>
+          reminder?.status === false &&
+          new Date(reminder?.due_datetime).getTime() < new Date().getTime()
+      );
+
+      // Store them correctly in localStorage
+      localStorage.setItem(
+        'filteredRemindersCount',
+        JSON.stringify(filteredReminders?.length)
+      );
+      localStorage.setItem(
+        'filteredOverDueReminders',
+        JSON.stringify(filteredOverDueReminders?.length)
+      );
+    }
+  }, [reminderLoading]);
 
   const renderContent = () => {
     switch (currentAction) {
@@ -36,11 +214,25 @@ function OrderActions() {
       // case 'unrelease-order':
       //   return <UnreleaseOrder />;
       case 'log-service-refusal':
-        return <LogServiceRefusal />;
+        return <LogServiceRefusal callOrdersApi={callOrdersApi} />;
       case 'cancel-order':
-        return <CancelOrder />;
+        return (
+          <CancelOrder
+            callOrdersApi={callOrdersApi}
+            callOrderStatusApi={fetchStatusData}
+            callOrderAlertsApi={callOrderAlertsApi}
+            callOrderProductsApi={callOrderProductsApi}
+          />
+        );
       case 'uncancel-order':
-        return <UncancelOrder />;
+        return (
+          <UncancelOrder
+            callOrdersApi={callOrdersApi}
+            callOrderStatusApi={fetchStatusData}
+            callOrderAlertsApi={callOrderAlertsApi}
+            callOrderProductsApi={callOrderProductsApi}
+          />
+        );
       case 'confirm-order':
         return <ConfirmOrder />;
       case 'send-sms':
@@ -48,21 +240,44 @@ function OrderActions() {
       case 'send-email':
         return <SendEmailModal />;
       case 'change-customer-account':
-        return <ChangeCustomerAccModal />;
+        return <ChangeCustomerAccModal callOrdersApi={callOrdersApi} />;
+
       case 'hold-order':
-        return <HoldOrderModal />;
+        return (
+          <HoldOrderModal
+            callOrdersApi={callOrdersApi}
+            callOrderAlertsApi={callOrderAlertsApi}
+            callUnresolvedTaskApi={callUnresolvedTaskApi}
+          />
+        );
       case 'create-reminder':
-        return <TaskReminderModal />;
+        return (
+          <ReminderModal
+            callUnresolvedTaskApi={callUnresolvedTaskApi}
+            callReminderApi={callReminderApi}
+          />
+        );
       case 'create-task':
-        return <TaskModal />;
-      case 'view-reminder':
-        return <ViewReminderModal />;
-      case 'log-feedback':
-        return <LogFeedback />;
+        return (
+          <TaskModal
+            callUnresolvedTaskApi={callUnresolvedTaskApi}
+            callReminderApi={callReminderApi}
+          />
+        );
+      case 'charge-log':
+        return <ChargeLog />;
       case 'unhold-order':
-        return <UnholdOrder />;
-      case 'order-lock':
-        return <OrderLock />;
+        return (
+          <UnholdOrder
+            callOrdersApi={callOrdersApi}
+            callOrderAlertsApi={callOrderAlertsApi}
+            callUnresolvedTaskApi={callUnresolvedTaskApi}
+          />
+        );
+      case 'view-reminder':
+        return <ViewReminderModal callReminderApi={callReminderApi} />;
+      // case 'order-lock':
+      //   return <OrderLock />;
       case 'view-flag':
         return <ViewFlag />;
       case 'clear-date':

package/src/components/order-view/order-actions/store.ts

@@ -2,71 +2,62 @@ import { atom, useAtom } from 'jotai';
 import {
   CreateReminderPayload,
   CreateTaskPayload,
-  SingleFlagPayload,
-  SingleResolvedPayload,
+  TaskUpdateType,
   UpdateReminderPayload,
   allTypes,
+  resolveTaskPayload,
   splitOrderType,
 } from './types';
 import { OrdersType } from '../types';
 import { ordersInitialValue } from '../store';
 
 export const initialPayload: CreateTaskPayload = {
-  details: '',
-  task_type_id: null,
-  task_categories_id: null,
-  task_subcategories_id: null,
-  task_priority_id: 1,
+  description: '',
   is_private: true,
-  due_datetime: undefined,
-  task_status_id: 1,
   order_id: null,
-  customer_id: null,
-  associated_object_id: null,
-  associated_object_name: null,
-  provider_id: null,
-  flag_attribute: '',
-  completion_note: '',
-  resolved_by: '',
-  sla: null,
-  description: '',
-  assigned_to: null,
-  legacy_id: null,
+  flag_type: '',
+  priority: 3,
+  status: 'AD',
+  due_datetime: '',
 };
 
 export const initialValue: CreateReminderPayload = {
-  due: undefined,
-  details: '',
-  assigned_to: null,
-  status_id: 3,
-  task_priority_id: null,
-  department_id: null,
-  task_categories_id: null,
-  task_subcategories_id: null,
+  due_datetime: null,
+  description: '',
+  assigned_to: '',
   order_id: null,
+  priority: 3,
+  department: '',
+  status: false,
 };
 
 export const updatePayload: UpdateReminderPayload = {
-  details: '',
+  due_datetime: '',
+  description: '',
+  assigned_to: '',
+  order_id: null,
+  priority: null,
+  department: null,
+  status: false,
   id: null,
-  assigned_to: null,
-  due_date: null,
-  due_time: null,
-  status_id: null,
+  is_deleted: null,
+  legacy_reminder_id: null,
+  order_data: null,
+  reference: null,
+  completed_at: null,
+  completed_by: null,
 };
 
-export const flagInitialValue: SingleFlagPayload = {
+export const flagInitialValue: TaskUpdateType = {
   description: '',
-  task_type_id: 0,
-  task_priority_id: 0,
-  is_resolved: false,
+  flag_type: 0,
+  priority: 0,
   id: null,
   is_private: false,
 };
 
-export const resolvedValue: SingleResolvedPayload = {
-  is_resolved: false,
-  id: null,
+export const resolvedValue: resolveTaskPayload = {
+  task_ids: null,
 };
 
 const allStaticData = atom<allTypes[] | null>([]);
@@ -95,7 +86,7 @@ const reminderNotifiData = atom<any>([]);
 
 const singleFlagData = atom<any>({});
 
-const singleModalPayload = atom<SingleFlagPayload>(flagInitialValue);
+const flagByIdData = atom<any>({});
 
 const flagRefId = atom<number | null>(null);
 
@@ -103,7 +94,7 @@ const ReminderRefId = atom<number | null>(null);
 
 const reminderData = atom<any>([]);
 
-const resolvedModalPayload = atom<SingleResolvedPayload>(resolvedValue);
+const resolvedModalPayload = atom<resolveTaskPayload>(resolvedValue);
 
 const routeDetails = atom<any>({});
 
@@ -125,6 +116,8 @@ const loadingText = atom<{ title: string; subtitle: string } | undefined>(
   defaultLoadingText
 );
 
+const deptData = atom<any>([]);
+
 const loading = atom<boolean>(true);
 
 export function useFlagsLoading() {
@@ -190,7 +183,7 @@ export function useCreateReminderPayload() {
   return useAtom(createReminderPayload);
 }
 
-export function useAllStaticData() {
+export function useStaticData() {
   return useAtom(allStaticData);
 }
 
@@ -219,16 +212,26 @@ export function useTaskTypeExtended() {
   return useAtom(taskTypeExtended);
 }
 
-export function useNotificationData() {
+export function useTasksData() {
   return useAtom(notificationData);
 }
 
+export function useDeptData() {
+  return useAtom(deptData);
+}
+
 export function useReminderNotiData() {
   return useAtom(reminderNotifiData);
 }
 
-export function useSinglePayload() {
-  return useAtom(singleModalPayload);
+export function useFlagById() {
+  return useAtom(flagByIdData);
+}
+
+const taskUpdate = atom<TaskUpdateType>(flagInitialValue);
+
+export function useUpdateTask() {
+  return useAtom(taskUpdate);
 }
 
 export function useSingleFlagData() {
@@ -247,7 +250,7 @@ export function useReminderRefId() {
   return useAtom(ReminderRefId);
 }
 
-export function useSingleReminderData() {
+export function useReminderById() {
   return useAtom(reminderData);
 }
 
@@ -264,7 +267,6 @@ export function useAllOrderStatus() {
   return useAtom(allOrderStatus);
 }
 
-
 export const selectedCategoryIdAtom = atom<any>(null);
 export const selectedDocumentTypeAtom = atom<any>(null);
 export const selectedTypeAtom = atom<any>(null);

package/src/components/order-view/order-actions/types.ts

@@ -3,24 +3,6 @@ export interface Department {
   name: string;
 }
 
-interface TaskTypeExtended {
-  id: number;
-  department_id: number;
-  type: string;
-  is_active: boolean;
-}
-
-interface TaskCategory {
-  id: number;
-  category: string;
-}
-
-interface TaskSubCategory {
-  id: number;
-  sub_category: string;
-  category_id: number;
-}
-
 export interface TaskPriority {
   id: number;
   name: string;
@@ -28,56 +10,32 @@ export interface TaskPriority {
 
 export interface allTypes {
   department: Department[];
-  task_categories: TaskCategory[];
-  task_sub_categories: TaskSubCategory[];
-  tasks_priority: TaskPriority[];
-  tasks_types: TaskTypeExtended[];
+  flags_static_data: any;
+  order_flag_types: any;
+  priority: any;
 }
 
-//create-task
 export interface CreateTaskPayload {
-  details: string;
-  task_type_id?: number | null;
-  task_categories_id: number | null;
-  task_subcategories_id: number | null;
-  task_priority_id: number | string | null;
-  task_status_id: number | null;
-  is_private?: boolean;
-  due_datetime: any;
+  description: string | null;
+  is_private: boolean | null;
   order_id: number | null;
-  customer_id: number | null;
-  associated_object_id: number | null;
-  associated_object_name: string | null;
-  provider_id: number | null;
-  flag_attribute: string;
-  completion_note: string;
-  resolved_by: string;
-  sla: any;
-  description?: string;
-  assigned_to: number | null;
-  legacy_id: number | null;
+  flag_type: string | null;
+  priority: number | null;
+  status: string | null;
+  due_datetime: string | null;
+}
+export interface resolveTaskPayload {
+  task_ids: number[] | null;
 }
 
-//create reminder
 export interface CreateReminderPayload {
-  due: any;
-  details: string;
-  assigned_to: number | null;
-  status_id: number | null;
-  task_priority_id: number | null;
-  department_id: number | null;
-  task_categories_id: number | null;
-  task_subcategories_id: number | null;
+  due_datetime: Date | null;
+  description: string | null;
+  assigned_to: string | null;
   order_id: number | null;
-}
-
-export interface SingleFlagPayload {
-  description?: string;
-  task_type_id?: number;
-  task_priority_id?: number;
-  is_resolved: boolean;
-  id: number | null;
-  is_private?: boolean;
+  priority: number | null;
+  department: string | null;
+  status: boolean | null;
 }
 
 export type StatusType = 'AD' | 'SD';
@@ -89,15 +47,32 @@ export interface SingleResolvedPayload {
 
 //update Reminder Payload
 export interface UpdateReminderPayload {
-  details: string;
+  due_datetime: any | null;
+  description: any | null;
+  assigned_to: string | null;
+  order_id: number | null;
+  priority: number | null;
+  department: any | null;
+  status: boolean | null;
   id: number | null;
-  assigned_to: number | null;
-  due_date: any;
-  due_time: any;
-  status_id: number | null;
+  is_deleted: boolean | null;
+  legacy_reminder_id: number | null;
+  order_data: any[] | null;
+  reference: any | null;
+  completed_at: any | null;
+  completed_by: any | null;
 }
+
 export interface splitOrderType {
   return_order: number;
   products: any[];
   force: boolean;
 }
+
+export interface TaskUpdateType {
+  description: string | null;
+  flag_type: number | null;
+  priority: number | null;
+  id: number | null;
+  is_private: boolean | null;
+}

package/src/components/order-view/order-actions/utils.ts

@@ -33,15 +33,22 @@ export const getStatusColor = (status: StatusType) => {
 };
 
 //date format
-export function formatDate(dateString: any) {
-  if (dateString) {
-    const date = new Date(dateString);
+export function formatDate(dateInput?: string | number | Date): string {
+  if (!dateInput) return 'N/A';
 
-    if (!isNaN(date.getTime())) {
-      return format(date, 'dd/MM/yyyy HH:mm:ss');
-    }
-  }
-  return 'Invalid date';
+  const date = new Date(dateInput);
+  if (isNaN(date.getTime())) return 'N/A';
+
+  return format(date, 'eee, dd/MM/yyyy HH:mm:ss');
+}
+
+export function getDay(dateInput?: string | number | Date): string {
+  if (!dateInput) return 'N/A';
+
+  const date = new Date(dateInput);
+  if (isNaN(date.getTime())) return 'N/A';
+
+  return format(date, 'eee');
 }
 
 //with colors

package/src/components/order-view/order-details/expanded-content/customer-section/contact-info/ContactEmail.tsx

@@ -2,6 +2,7 @@ import { Input, Label } from '@bjsdistribution/dms-component-library';
 import React from 'react';
 import styled from 'styled-components';
 import { errorAtom, useAtom, useOrderDetails } from '../../../../store';
+import { sanitizeInput } from '../../../../utils';
 
 function ContactEmail() {
   const emailRegex = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i;
@@ -10,7 +11,7 @@ function ContactEmail() {
   const orderRecipient = orderDetails?.order_recipient;
 
   const onChange = (e: React.ChangeEvent<HTMLInputElement>) => {
-    const val = e.target.value;
+    let val = sanitizeInput(e.target.value);
     validateInput(val);
     const updatedOrderRecipient = {
       ...(orderRecipient === null