@os1-platform/dispatch-mobile 2.1.2 → 2.1.4

package/src/network/NetworkClient.ts

@@ -0,0 +1,58 @@
+import HttpClient from './client';
+import DispatchSdkCache from '../manager/sdk/DispatchSdkCache';
+import type { DispatchSDKConfig } from '../models/sdk';
+import type { Headers } from '../models/auth';
+
+const cache = DispatchSdkCache.getInstance();
+const cacheKeys = DispatchSdkCache.KEYS;
+
+export default class NetworkClient extends HttpClient {
+  constructor(baseURL: string) {
+    super(baseURL);
+  }
+
+  public async requestGet() {}
+
+  public async requestPost(
+    endpoint: string,
+    requestBody: any,
+    headers: Headers
+  ) {
+    const sdkConfig = (await cache.getObjectFromCache(
+      cacheKeys.SDK_CONFIG
+    )) as DispatchSDKConfig;
+
+    return this.instance.post(endpoint, requestBody, {
+      headers: {
+        'accept': 'application/json',
+        'X-COREOS-REQUEST-ID':
+          'DispatchSdk:' + ((headers && headers.requestId) || ''),
+        'X-COREOS-ACCESS': sdkConfig.accessToken ?? '',
+        'X-COREOS-TID': sdkConfig.tenantID ?? '',
+        'Content-Type': 'application/json',
+      },
+    });
+  }
+
+  public async requestPut(
+    endpoint: string,
+    requestBody: any,
+    headers: Headers
+  ) {
+    const sdkConfig = (await cache.getObjectFromCache(
+      cacheKeys.SDK_CONFIG
+    )) as DispatchSDKConfig;
+
+    return this.instance.put(endpoint, requestBody, {
+      headers: {
+        'accept': 'application/json',
+        'X-COREOS-REQUEST-ID':
+          'DispatchSdk:' + ((headers && headers.requestId) || ''),
+        'X-COREOS-ACCESS': sdkConfig.accessToken ?? '',
+        'X-COREOS-TID': sdkConfig.tenantID ?? '',
+        'X-COREOS-USERINFO': JSON.stringify({ id: sdkConfig.userID ?? '' }),
+        'Content-Type': 'application/json',
+      },
+    });
+  }
+}

package/src/network/NetworkUtils.ts

@@ -0,0 +1,41 @@
+import DispatchSdkCache from '../manager/sdk/DispatchSdkCache';
+import type { Headers } from '../components/executiontasks/httpRequest/HttpRequestETSchema';
+import type { DispatchSDKConfig } from '../models/sdk';
+
+export async function getHeaders(contentType: string) {
+  const cache = DispatchSdkCache.getInstance();
+  const sdkConfig: DispatchSDKConfig = await cache.getObjectFromCache(
+    DispatchSdkCache.KEYS.SDK_CONFIG
+  );
+  const newHeadersObj = sdkConfig?.headers
+    ? Object.fromEntries(
+        Object.entries(sdkConfig.headers || {}).map(([k, v]) => [
+          k.toLowerCase(),
+          v,
+        ])
+      )
+    : {};
+
+  const dspID = await cache.getKeyFromCache(DispatchSdkCache.KEYS.DISPATCH_ID);
+  return Object.keys(newHeadersObj).length
+    ? newHeadersObj
+    : {
+        'x-user-id': sdkConfig?.userID,
+        'x-coreos-tid': sdkConfig?.tenantID,
+        'x-coreos-access': sdkConfig?.accessToken,
+        'content-type': contentType,
+        'x-coreos-request-id': dspID ?? sdkConfig?.userID,
+        'x-coreos-userinfo': JSON.stringify({ id: sdkConfig?.userID }),
+      };
+}
+
+export function getAddHeaders(headers?: Headers[]) {
+  if (!headers || headers.length === 0) return {};
+  else {
+    const addHeaders: { [k: string]: string } = {};
+    headers.forEach((h) => {
+      if (h.key && h.value) addHeaders[h.key] = h.value;
+    });
+    return addHeaders;
+  }
+}

package/src/network/Queries.ts

@@ -0,0 +1,46 @@
+import { gql } from '@apollo/client';
+
+export const FETCH_REASONS = gql`
+  query ($limit: String, $offset: String) {
+    reasonList(limit: $limit, offset: $offset) {
+      data {
+        description
+        isEnabled
+        reasonCode
+        isSystemDefined
+      }
+    }
+  }
+`;
+
+export const CREATE_FMS_FOLDER = gql`
+  mutation CreateDispatch($input: Folder!) {
+    createFolder(input: $input) {
+      id
+    }
+  }
+`;
+
+export const CUSTODY_IN = gql`
+  mutation CustodyInBatch($input: CustodyBatchInput!) {
+    custodyInBatch(input: $input) {
+      success
+    }
+  }
+`;
+
+export const CUSTODY_OUT = gql`
+  mutation CustodyOutBatch($input: CustodyBatchInput!) {
+    custodyOutBatch(input: $input) {
+      success
+    }
+  }
+`;
+
+export const WORKFLOW_UPDATE = gql`
+  mutation ($input: WorkflowUpdateStatusInput!) {
+    updateWorkflowStatus(input: $input) {
+      id
+    }
+  }
+`;

package/src/network/client.ts

@@ -0,0 +1,61 @@
+import axios, { AxiosInstance, AxiosResponse } from 'axios';
+import StatusCode from '../constants/statuscode';
+// import { handleAccessTokenExpiry } from './utils/helper';
+
+export default abstract class HttpClient {
+  protected readonly instance: AxiosInstance;
+
+  protected constructor(baseURL: string) {
+    this.instance = axios.create({
+      baseURL,
+      timeout: 15000, // timeout of 15s
+    });
+
+    this._initializeResponseInterceptor();
+  }
+
+  private _initializeResponseInterceptor = () => {
+    this.instance.interceptors.response.use(
+      this._handleResponse,
+      this._handleError
+    );
+  };
+
+  protected _handleResponse = (response: AxiosResponse) => {
+    return response;
+  };
+
+  protected _handleError = (error: any) => {
+    if (error.response) {
+      // Request made and server responded
+      const { status } = error.response;
+      switch (status) {
+        case StatusCode.InternalServerError: {
+          // Handle InternalServerError
+          break;
+        }
+        case StatusCode.Forbidden: {
+          // Handle Forbidden
+          break;
+        }
+        case StatusCode.Unauthorized: {
+          // Handle Unauthorized
+          //LoginHelper.handleAccessTokenExpiry();  //commented out as this was causing cycles
+          //cycle: ../src/utils/loginHelper.ts -> ../src/resources/Login.ts -> ../src/network/client.ts -> ../src/utils/loginHelper.ts
+          break;
+        }
+        case StatusCode.TooManyRequests: {
+          // Handle TooManyRequests
+          break;
+        }
+      }
+    } else if (error.request) {
+      // The request was made but no response was received
+      // Network error should be received here
+    } else {
+      // Something happened in setting up the request that triggered an Error
+      console.log('Error else', error.message);
+    }
+    return Promise.reject(error);
+  };
+}

package/src/res/strings.ts

@@ -0,0 +1 @@
+export const PLEASE_WAIT = 'Please wait...';

package/src/resources/Login.ts

@@ -0,0 +1,36 @@
+import HttpClient from '../network/client';
+import type {
+  AccessTokenPayload,
+  LoginPayload,
+  RefreshTokenPayload,
+} from '../models/auth';
+
+class Login extends HttpClient {
+  public constructor() {
+    super('https://delhivery.dev.fxtrt.io/core/api/v1/aaa/');
+  }
+  public loginMobilePassword = (payload: LoginPayload) => {
+    return this.instance.post('/auth/login/mobile-password', payload);
+  };
+  public loginMobileOtp = (payload: LoginPayload) => {
+    return this.instance.post('/auth/login/mobile-otp', payload);
+  };
+  public loginMpin = (payload: LoginPayload) => {
+    return this.instance.post('​/auth​/login​/mpin', payload);
+  };
+  public loginUserName = (payload: LoginPayload) => {
+    return this.instance.post('/auth/login/username-password', payload);
+  };
+  public loginCredential = (payload: LoginPayload) => {
+    return this.instance.post('/auth/client-login', payload);
+  };
+  public validateToken = (accessToken: AccessTokenPayload) => {
+    return this.instance.post('/auth/validate', accessToken);
+  };
+  public refreshToken = (refreshTokenPayload: RefreshTokenPayload) => {
+    return this.instance.post('/auth/validate', refreshTokenPayload);
+  };
+}
+
+const Auth = new Login();
+export default Auth;

package/src/resources/network.ts

@@ -0,0 +1,13 @@
+import HttpClient from '../network/client';
+
+class Network extends HttpClient {
+  public constructor() {
+    super('https://google.com');
+  }
+  public heartBeat = () => {
+    return this.instance.head('/');
+  };
+}
+
+const network = new Network();
+export default network;

package/src/styles/SdkColors.ts

@@ -0,0 +1,24 @@
+export enum ColorTheme {
+  LIGHT = 'light',
+  DARK = 'dark',
+}
+
+const tintColor = '#4e9bde';
+const darkTintColor = '#1a74b3';
+const primaryButton = '#5B80F7';
+const exitButton = '#DC2626';
+const defaultColor = '#3D445C';
+
+export default {
+  [ColorTheme.LIGHT]: {
+    tintColor,
+    darkTintColor,
+    primaryButton,
+    exitButton,
+    defaultColor,
+  },
+  [ColorTheme.DARK]: {
+    tintColor: darkTintColor,
+    darkTintColor: tintColor,
+  },
+};

package/src/styles/executionTasks/CommonStyles.ts

@@ -0,0 +1,189 @@
+import { StyleSheet } from 'react-native';
+import SdkColors, { ColorTheme } from '../SdkColors';
+
+export enum Fonts {
+  IBMPlexSans_400Regular = 'IBMPlexSans_400Regular',
+  IBMPlexSans_600SemiBold = 'IBMPlexSans_600SemiBold',
+  IBMPlexSans_300Light = 'IBMPlexSans_300Light',
+  IBMPlexSans_700Bold = 'IBMPlexSans_700Bold',
+  IBMPlexSans_100Thin = 'IBMPlexSans_100Thin',
+  IBMPlexSans_100Thin_Italic = 'IBMPlexSans_100Thin_Italic',
+  IBMPlexSans_200ExtraLight = 'IBMPlexSans_200ExtraLight',
+  IBMPlexSans_200ExtraLight_Italic = 'IBMPlexSans_200ExtraLight_Italic',
+  IBMPlexSans_300Light_Italic = 'IBMPlexSans_300Light_Italic',
+  IBMPlexSans_400Regular_Italic = 'IBMPlexSans_400Regular_Italic',
+  IBMPlexSans_500Medium = 'IBMPlexSans_500Medium',
+  IBMPlexSans_500Medium_Italic = 'IBMPlexSans_500Medium_Italic',
+  IBMPlexSans_600SemiBold_Italic = 'IBMPlexSans_600SemiBold_Italic',
+  IBMPlexSans_700Bold_Italic = 'IBMPlexSans_700Bold_Italic',
+}
+export const deliverETStyles = StyleSheet.create({
+  item: {
+    padding: 2,
+    marginTop: 8,
+  },
+  title: {
+    fontSize: 16,
+  },
+  footerButtonStyles: {
+    flexDirection: 'row',
+    width: '100%',
+  },
+  input: {
+    marginTop: 12,
+    marginBottom: 10,
+  },
+  footerComponent: {
+    flex: 1,
+    marginStart: 8,
+    marginEnd: 8,
+    marginRight: 8,
+    width: '100%',
+    position: 'absolute',
+    bottom: 10,
+  },
+  errorText: {
+    color: 'red',
+    fontSize: 16,
+    fontStyle: 'normal',
+  },
+});
+export const CommonStyles = StyleSheet.create({
+  alignCenter: {
+    flex: 1,
+    alignItems: 'center',
+  },
+  flexRow: {
+    flex: 1,
+    flexDirection: 'row',
+  },
+  mainContainer: {
+    flex: 1,
+    backgroundColor: '#f9f9f9',
+  },
+  nextButton: {
+    backgroundColor: SdkColors[ColorTheme.LIGHT].primaryButton,
+  },
+  nextButtonLabel: {
+    color: '#ffffff',
+    fontFamily: Fonts.IBMPlexSans_500Medium,
+    fontSize: 14,
+    lineHeight: 20,
+    textAlign: 'center',
+    fontStyle: 'normal',
+    fontWeight: '500',
+  },
+  cancelButton: {
+    borderWidth: 1,
+    borderColor: SdkColors[ColorTheme.LIGHT].primaryButton,
+  },
+  cancelButtonLabel: {
+    color: SdkColors[ColorTheme.LIGHT].defaultColor,
+    fontFamily: Fonts.IBMPlexSans_500Medium,
+    fontSize: 14,
+    fontWeight: '500',
+    lineHeight: 20,
+    textAlign: 'center',
+    fontStyle: 'normal',
+    textTransform:'capitalize'
+  },
+  mainExitButton: {
+    backgroundColor: SdkColors[ColorTheme.LIGHT].exitButton,
+  },
+  mainExitButtonLabel: {
+    color: '#ffffff',
+    fontFamily: Fonts.IBMPlexSans_500Medium,
+    fontSize: 14,
+    fontWeight: '500',
+    lineHeight: 20,
+    textAlign: 'center',
+    fontStyle: 'normal',
+  },
+  exitButton: {
+    borderWidth: 1,
+    borderColor: SdkColors[ColorTheme.LIGHT].exitButton,
+  },
+  exitButtonLabel: {
+    color: SdkColors[ColorTheme.LIGHT].exitButton,
+    fontFamily: Fonts.IBMPlexSans_500Medium,
+    fontSize: 14,
+    fontWeight: '500',
+    lineHeight: 20,
+    textAlign: 'center',
+    fontStyle: 'normal',
+  },
+  bottom: {
+    flex: 1,
+    justifyContent: 'flex-end',
+    marginBottom: 10,
+  },
+  modalContent: {
+    marginStart: 60,
+    marginEnd: 60,
+    flex: 1,
+    marginBottom: 60,
+  },
+  modalView: {
+    backgroundColor: 'white',
+    padding: 15,
+    borderRadius: 9,
+  },
+  subText: {
+    justifyContent: 'center',
+    fontFamily: 'IBMPlexSans_400Regular',
+    fontStyle: 'normal',
+    fontSize: 14,
+    letterSpacing: 0.25,
+    lineHeight: 20,
+    textAlign: 'center',
+    color: '#000000',
+    marginBottom: 10,
+  },
+});
+export const DeliverPickupStyles = StyleSheet.create({
+  itemTextStyle: {
+    fontFamily: Fonts.IBMPlexSans_400Regular,
+    color: '#111111',
+    textAlign: 'center',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  mainContainer: {
+    flex: 1,
+    backgroundColor: 'rgba(61, 68, 92, 0.7)',
+  },
+  modalContent: {
+    marginStart: 60,
+    marginEnd: 60,
+    flex: 1,
+    marginBottom: 60,
+  },
+  flatList: {
+    marginTop: 7,
+  },
+  modalView: {
+    backgroundColor: 'white',
+    padding: 15,
+    borderRadius: 9,
+  },
+  titleText: {
+    justifyContent: 'center',
+    fontFamily: Fonts.IBMPlexSans_600SemiBold,
+    fontStyle: 'normal',
+    fontSize: 14,
+    lineHeight: 20,
+    textAlign: 'center',
+    color: '#111111',
+  },
+  messageText: {
+    marginTop: 10,
+    justifyContent: 'center',
+    fontFamily: Fonts.IBMPlexSans_400Regular,
+    fontStyle: 'normal',
+    fontWeight: '400',
+    fontSize: 14,
+    lineHeight: 20,
+    textAlign: 'center',
+    color: '#000000',
+  },
+});

package/src/ui/screens/CancellationScreen.tsx

@@ -0,0 +1,144 @@
+import CancelET from '../../components/executiontasks/cancellation/CancelET';
+import React, { useEffect, useState } from 'react';
+import { getEventCodeByET } from '../../manager/dispatchCodes/EventCodeContainer';
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import type { BaseETProps } from '../../models/DispatchModels';
+import {
+  getBaseETResponse,
+  getEntityCodeByET,
+} from '../../utils/ExecTaskUtils';
+import ReasonCodeContainer from '../../manager/dispatchCodes/ReasonCodeContainer';
+import type { EventsRow, ReasonsRow } from '../../manager/syncmanager/DBConfig';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+
+const instance = DispatchStateContainer.getInstance();
+const CancellationScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+  const [reasons, setReasons] = useState<string[]>([]);
+  const [events, setEvents] = useState<string[]>([]);
+  useEffect(() => {
+    const reasonCodes = route.params[RouteParams.REASONS];
+    if (reasonCodes && reasonCodes.length) {
+      const values: string[] = [];
+      for (let reasonCode of reasonCodes as ReasonsRow[]) {
+        values.push(reasonCode.description);
+      }
+      setReasons(values);
+    }
+    const eventCodes = route.params[RouteParams.EVENT_CODES];
+
+    if (eventCodes && eventCodes.length) {
+      const e_values: string[] = [];
+      for (let eventCode of route.params[
+        RouteParams.EVENT_CODES
+      ] as EventsRow[]) {
+        e_values.push(eventCode.description);
+      }
+      setEvents(e_values);
+    }
+  }, [route.params]);
+
+  return events.length || reasons.length ? (
+    <CancelET
+      // mergedObjectiveId={mergedObjectiveId}
+      cancelEvent={route.params[RouteParams.CANCEL_EVENT] || ''}
+      cancellationEvents={events}
+      cancellationReasons={reasons}
+      applicableCodes={route.params[RouteParams.APPLICABLE_CODES]}
+      eventRows={route.params[RouteParams.EVENT_CODES]}
+      onSubmitET={async (reason, eventCode, reasonsRow) => {
+        const isMergedObjBasedOutput =
+          route.params[RouteParams.IS_MERGED_OBJ_BASED_OUTPUT];
+        if (route.params[RouteParams.ET_SUCCESS]) {
+          if (route.params[RouteParams.EVENT_CODES] && eventCode) {
+            // if (isJobBasedOutput)
+            //   route.params[
+            //     RouteParams.ET_SUCCESS_RESPONSE
+            //   ].baseResponse.eventCode = eventCode;
+            // else
+            route.params[RouteParams.ET_SUCCESS_RESPONSE].eventCode = eventCode;
+          } else if (eventCode) {
+            // if (isJobBasedOutput)
+            //   route.params[
+            //     RouteParams.ET_SUCCESS_RESPONSE
+            //   ].baseResponse.eventCode = eventCode;
+            // else
+            route.params[RouteParams.ET_SUCCESS_RESPONSE].eventCode = eventCode;
+          }
+
+          // if (isJobBasedOutput)
+          //   route.params[
+          //     RouteParams.ET_SUCCESS_RESPONSE
+          //   ].baseResponse.reasonCode =
+          //     ReasonCodeContainer.getReasonCodeFromText(
+          //       reason,
+          //       route.params[RouteParams.REASONS]
+          //         ? route.params[RouteParams.REASONS]
+          //         : reasonsRow
+          //     );
+          // else
+          route.params[RouteParams.ET_SUCCESS_RESPONSE].reasonCode =
+            ReasonCodeContainer.getReasonCodeFromText(
+              reason,
+              route.params[RouteParams.REASONS]
+                ? route.params[RouteParams.REASONS]
+                : reasonsRow
+            );
+
+          await instance.saveAndProceed(
+            baseETProps,
+            route.params[RouteParams.ET_SUCCESS_RESPONSE],
+            route.params,
+            navigation,
+            route.params[RouteParams.IS_LAST_ET],
+            isMergedObjBasedOutput
+          );
+        } else {
+          let _eventCodeOutput = '';
+          if (route.params[RouteParams.EVENT_CODES] && eventCode) {
+            _eventCodeOutput = eventCode;
+          } else if (eventCode) _eventCodeOutput = eventCode;
+
+          await instance.saveAndProceed(
+            baseETProps,
+            await getBaseETResponse(
+              getEntityCodeByET(route.params[RouteParams.CURRENT_ET_NAME]),
+              false,
+              _eventCodeOutput
+                ? _eventCodeOutput
+                : getEventCodeByET(
+                    route.params[RouteParams.CURRENT_ET_NAME],
+                    false,
+                    route.params[RouteParams.EVENT_CODES] || []
+                  ),
+              ReasonCodeContainer.getReasonCodeFromText(
+                reason,
+                route.params[RouteParams.REASONS]
+                  ? route.params[RouteParams.REASONS]
+                  : reasonsRow
+              ),
+              mergedObjectiveId,
+              route.params[RouteParams.CURRENT_ET_NAME]
+            ),
+            route.params,
+            navigation,
+            route.params[RouteParams.IS_LAST_ET],
+            isMergedObjBasedOutput
+          );
+        }
+      }}
+    />
+  ) : null;
+};
+export default withBaseDispatchScreen(CancellationScreen);

package/src/ui/screens/CaptureInputScreen.tsx

@@ -0,0 +1,79 @@
+import { CaptureText } from '../../components/executiontasks/ExecutionTasksIndex';
+import React, { useCallback, useEffect, useState } from 'react';
+import withBaseDispatchScreen from './WithBaseDispatchScreen';
+import type { BaseETProps } from '../../models/DispatchModels';
+import { EntityCode, ExecutionTaskID } from '../../models/execTasks/ETConfig';
+import DispatchStateContainer from '../../manager/dispatch/DispatchStateContainer';
+import { RouteParams, getDataFromNextState } from '../uiConfig/RouteParams';
+import { View } from 'react-native';
+import CancelOrderDialog from '../../components/widgets/CancelOrderDialog';
+import { onTaskStart } from '../../utils/ExecTaskUtils';
+import { GO_BACK_EVENT_CODE } from '../../constants/constants';	
+const CaptureInputScreen = ({
+  route,
+  navigation,
+  baseETProps,
+}: {
+  route: any;
+  navigation: any;
+  baseETProps: BaseETProps;
+}) => {
+  const nextState = route.params[RouteParams.NEXT_STATES];
+  const { taskMeta, mergedObjectiveId, input, wfMeta } =
+    getDataFromNextState(nextState);
+  useEffect(() => {
+    onTaskStart(
+      nextState,
+      route.params[RouteParams.ROOT_META_DATA].customEventsData
+    );
+  }, []);
+  const [showAlert, setShowAlert] = useState(false);
+  const [sResponse, setResponse] = useState<any>();
+  const submitOutput = useCallback(
+    async (response: any) => {
+      await DispatchStateContainer.getInstance().navigateToNextTask(
+        navigation,
+        route,
+        response,
+        response.success,
+        EntityCode.CAPTURE_INPUT,
+        ExecutionTaskID.CAPTURE_INPUT,
+        baseETProps,
+        false
+      );
+    },
+    [baseETProps, navigation, route]
+  );
+  return (
+    <View style={{ flex: 1 }}>
+      <CaptureText
+        {...input}
+        navigation={navigation}
+        taskMeta={taskMeta}
+        mergedObjectiveId={mergedObjectiveId}
+        onSubmitET={async (etResponse) => {
+          if (etResponse.success || etResponse.eventCode == GO_BACK_EVENT_CODE) {
+            await submitOutput(etResponse);
+          } else {
+            setResponse((_prevState: any) => {
+              setShowAlert(true);
+              return etResponse;
+            });
+          }
+        }}
+      />
+      <CancelOrderDialog
+        visible={showAlert}
+        onSubmit={async (value) => {
+          if (value) {
+            setShowAlert(false);
+            await submitOutput(sResponse);
+          } else {
+            setShowAlert(false);
+          }
+        }}
+      />
+    </View>
+  );
+};
+export default withBaseDispatchScreen(CaptureInputScreen);