@os1-platform/dispatch-mobile 2.1.2 → 2.1.4

package/src/components/executiontasks/httpRequest/HttpEtUtils.ts

@@ -0,0 +1,49 @@
+import type { APIData, HttpRequestETOutput } from './HttpRequestETSchema';
+import axios, { AxiosRequestConfig } from 'axios';
+import { getAddHeaders, getHeaders } from '../../../network/NetworkUtils';
+import { API_CONTENT_TYPES } from '../../../network/GraphQLClient';
+import { JSONPath } from 'jsonpath-plus';
+import { isEmptyOrBlank } from '../../../utils/utils';
+import { getBaseETResponse } from '../../../utils/ExecTaskUtils';
+import {
+  BaseEventCodes,
+  EntityCode,
+  ExecutionTaskID,
+} from '../../../models/execTasks/ETConfig';
+
+export async function getApiResponse(apiData: APIData) {
+  const axiosConfig: AxiosRequestConfig = {
+    data: apiData.requestBody,
+    method: apiData.httpMethod,
+    timeout: apiData.timeout ?? 15000, // timeout in millis i.e 15s
+    url: apiData.uri,
+    headers: {
+      ...getAddHeaders(apiData.headers),
+      ...(await getHeaders(API_CONTENT_TYPES.APPLICATION_JSON)),
+    },
+  };
+  return axios(axiosConfig);
+}
+export function getOutputUsingJsonpath(json: object, jsonPath: string) {
+  if (isEmptyOrBlank(jsonPath)) return json;
+  return JSONPath({ path: jsonPath, json });
+}
+
+export async function getHttpETOutput(
+  apiResponse: object,
+  jsonPath: string,
+  success: boolean,
+  mergedObjectiveId: Array<string>
+): Promise<HttpRequestETOutput> {
+  return {
+    ...(await getBaseETResponse(
+      EntityCode.HTTP_REQUEST_ET,
+      success,
+      success ? BaseEventCodes.ENTITY_SUCCESS : BaseEventCodes.ENTITY_FAILURE,
+      '',
+      mergedObjectiveId,
+      ExecutionTaskID.HTTP_REQUEST_ET
+    )),
+    apiResponse: getOutputUsingJsonpath(apiResponse, jsonPath),
+  };
+}

package/src/components/executiontasks/httpRequest/HttpRequestET.tsx

@@ -0,0 +1,59 @@
+import type { HttpRequestETInput } from './HttpRequestETSchema';
+import { CommonStyles } from '../../../styles/executionTasks/CommonStyles';
+import ProgressDialog from '../../widgets/ProgressDialog';
+import { View } from 'react-native';
+import React, { useEffect, useState } from 'react';
+import { PLEASE_WAIT } from '../../../res/strings';
+import { getApiResponse, getHttpETOutput } from './HttpEtUtils';
+
+const HttpRequestET = (props: HttpRequestETInput) => {
+  const [inProgress, setInProgress] = useState(true);
+
+  useEffect(() => {
+    (async () => {
+      if (inProgress) {
+        try {
+          const apiResponse = await getApiResponse(props.api);
+          setInProgress(false);
+          props.onSubmitET(
+            await getHttpETOutput(
+              apiResponse.data,
+              props.api.responseJsonPath,
+              true,
+              props.mergedObjectiveId
+            )
+          );
+        } catch (error: any) {
+          setInProgress(false);
+          if (error.response) {
+            /**
+             * The request was made and the server responded
+             * with a status code that falls out of the range of 2xx
+             */
+            props.onSubmitET(
+              await getHttpETOutput(
+                error.response.data,
+                props.api.errorJsonPath,
+                false,
+                props.mergedObjectiveId
+              )
+            );
+          } else {
+            props.onSubmitET(
+              await getHttpETOutput(error, '', false, props.mergedObjectiveId)
+            );
+          }
+        }
+      }
+    })();
+  }, [inProgress, props]);
+  return (
+    <View style={CommonStyles.mainContainer}>
+      <ProgressDialog
+        visible={inProgress}
+        label={props.message ?? PLEASE_WAIT}
+      />
+    </View>
+  );
+};
+export default HttpRequestET;

package/src/components/executiontasks/httpRequest/HttpRequestETSchema.ts

@@ -0,0 +1,42 @@
+import type {
+  BaseETRequest,
+  BaseETResponse,
+} from '../../../models/execTasks/ETBaseModels';
+
+export type HTTPMethod = 'PUT' | 'POST' | 'GET';
+export type HeaderKey = string;
+export type HeaderValue = string;
+/**
+ * API headers
+ */
+export type Headers = {
+  key?: HeaderKey;
+  value?: HeaderValue;
+};
+
+export type HttpRequestETInput = BaseETRequest & {
+  api: APIData;
+  onSubmitET: (value: HttpRequestETOutput) => void;
+};
+/**
+ * API Details
+ */
+
+export type HttpRequestETOutput = BaseETResponse & {
+  apiResponse: object;
+};
+export interface APIData {
+  uri: string;
+  timeout?: number;
+  httpMethod: HTTPMethod;
+  requestBody?: HTTPRequestBody;
+  headers?: Headers[];
+  errorJsonPath: string;
+  responseJsonPath: string;
+}
+/**
+ * request body object
+ */
+export interface HTTPRequestBody {
+  [k: string]: unknown;
+}

package/src/components/executiontasks/imageCapture/CaptureSchema.ts

@@ -0,0 +1,94 @@
+/**
+ * Length (in cm)
+ */
+import type {
+  BaseETRequest,
+  BaseETResponse,
+} from '../../../models/execTasks/ETBaseModels';
+
+export interface CapturedImage {
+  /**
+   * Url of image
+   */
+  url: string;
+  file?: { folder: string; name: string };
+
+  /**
+   * Epoch timestamp for the image capture
+   */
+  timestamp: number;
+}
+
+export type CaptureOutput = BaseETResponse & {
+  /**
+   * Array of captured images
+   */
+  captures?: CapturedImage[];
+};
+
+export type ImageData = {
+  id: string;
+  path: string;
+  url: string;
+  timestamp: number;
+};
+
+/**
+ * Length (in cm)
+ */
+export type Length = number;
+/**
+ * Breadth (in cm)
+ */
+export type Breadth = number;
+/**
+ * Maximum Size limit (in kb) of image to be captured
+ */
+export type MaxFileSize = number;
+/**
+ * Mode of capturing image
+ */
+export type CaptureMode = 'SINGLE' | 'MULTI';
+/**
+ * Max limit of images to be captured in multi-capture mode
+ */
+export type MaxImageCount = number;
+/**
+ * Title of instruction
+ */
+export type Title = string;
+/**
+ * Message of instruction
+ */
+export type Message = string;
+/**
+ * Can go back
+ */
+export type CanGoBack = boolean;
+
+export type MultiAdditionalConfig = '1' | 'N';
+
+export interface AdditionalMultiConfig {
+  minCaptureCount: MultiAdditionalConfig;
+}
+
+export type CaptureInput = BaseETRequest & {
+  isSelfLoop: boolean;
+  resolution: Resolution;
+  fileSizeLimit: MaxFileSize;
+  captureMode: CaptureMode;
+  captureCountLimit?: MaxImageCount;
+  additionalMultiConfig?: AdditionalMultiConfig;
+  onSubmitET: (etOutput: CaptureOutput) => void;
+} & {
+  captureCount: number;
+  jobIds: string[];
+  objRefs: string[];
+};
+/**
+ * Resolution of image to be captured
+ */
+export interface Resolution {
+  length: Length;
+  breadth: Breadth;
+}

package/src/components/executiontasks/imageCapture/CaptureUtils.ts

@@ -0,0 +1,321 @@
+import type {
+  CapturedImage,
+  CaptureInput,
+  CaptureOutput,
+  ImageData,
+} from './CaptureSchema';
+import { Alert, Platform } from 'react-native';
+import * as FileSystem from 'expo-file-system';
+import * as ImagePicker from 'expo-image-picker';
+import { PermissionStatus } from 'expo-image-picker';
+import { showToast } from '../../widgets/Toaster';
+import type { ActionResize, ImageResult } from 'expo-image-manipulator';
+import * as ImageManipulator from 'expo-image-manipulator';
+import Logger, { LOG_TYPE } from '../../../utils/Logger';
+import { getBaseETResponse } from '../../../utils/ExecTaskUtils';
+import { getEventCodeByET } from '../../../manager/dispatchCodes/EventCodeContainer';
+import {
+  EntityCode,
+  ExecutionTaskID,
+} from '../../../models/execTasks/ETConfig';
+import { BaseError } from '../../../errors/BaseError';
+import BaseErrorCodes from '../../../errors/ErrorCodes';
+import DispatchSdkCache from '../../../manager/sdk/DispatchSdkCache';
+import { insertDocumentInDB } from '../../../utils/SyncManagerUtils';
+import {CameraOptions, launchCamera} from 'react-native-image-picker';
+
+export async function deleteImage(imageData: { path: string; id: { toString: () => string; }; }, images: any[]) {
+  await FileSystem.deleteAsync(imageData.path);
+  let filtered = images.filter(ele=>ele).filter(img => img.id.toString().toLowerCase() !== imageData.id.toString().toLowerCase()
+  );
+  console.log("filtered",filtered);
+  return filtered;
+}
+
+export function getMaxImagesCount(props: CaptureInput) {
+  if (props && props.captureCountLimit) return props.captureCountLimit;
+  else return 1;
+}
+
+export function getImagesFileName() {
+  return `IMG_${Date.now().toString()}.jpg`;
+}
+
+export async function getCompressionRatio(
+  uri: string,
+  maxSize: number
+): Promise<number> {
+  try {
+    let fileInfo = await FileSystem.getInfoAsync(uri, {
+      size: true,
+    });
+    maxSize = Math.min(maxSize, 1024);
+    if (fileInfo.exists) {
+      let fileSize = fileInfo.size / 1024;
+      if (fileSize > maxSize) {
+        return maxSize / fileSize;
+      } else return 1;
+    }
+    return 1;
+  } catch (error: any) {
+    Logger.getInstance().logEvent(
+      'getCompressionRatio',
+      error.message,
+      LOG_TYPE.SDK_ERROR
+    );
+    return 1;
+  }
+}
+
+export async function checkCameraPermissionUtil(): Promise<boolean> {
+  let response = await ImagePicker.getCameraPermissionsAsync();
+  if (response.granted) return true;
+  else {
+    let resp = await ImagePicker.requestCameraPermissionsAsync();
+    return resp.status === PermissionStatus.GRANTED;
+  }
+}
+
+interface responseType {
+  cancelled?: boolean;
+  uri?: string;
+  assets?: any[];
+}
+
+export async function captureImage(
+  imageWidth: number,
+  imageHeight: number,
+  fileSize: number
+): Promise<ImageResult | null> {
+  try {
+    if (!(await checkCameraPermissionUtil())) {
+      Alert.alert('Permissions Error', 'Camera permissions not provided!');
+      return null;
+    }
+
+
+    //let response : responseType;
+    let uri : string = ''
+    let cameraResult = null;
+
+    const options = {
+      selectionLimit: 1,
+      mediaType: 'photo',
+      includeBase64: false,
+    };
+
+    
+
+    // You can also use as a promise without 'callback':
+    // await launchCamera(options as CameraOptions , response => {  
+    //   if (response?.didCancel){
+    //     console.log("aks:didCancel=")
+    //     showToast('User cancelled the action');        
+    //     console.log('User cancelled the action');
+    //   } else if (response.errorCode == ('camera_unavailable' || 'permission' || 'others')) {
+    //     console.log("aks:errorCode=")
+    //     showToast(response.errorMessage? response.errorMessage : '');        
+    //     console.log('ImagePicker Error: ', response.errorMessage);
+    //   } else {
+    //     console.log("aks:errorCode=before")
+    //     async()=>{
+    //       console.log("aks:else=after")
+    //       let assets = response.assets? response.assets : null;   
+    //       console.log("aks:assets=", assets)
+    //       //       
+    //       if(assets != null){
+    //         uri = assets[0].uri as string;
+    //         //
+    //         let compressionRatio = await getCompressionRatio(uri, fileSize);
+    //         console.log("aks:compressionRatio=", compressionRatio)
+            
+    //         //
+    //         const saveOptions = {
+    //           compress: compressionRatio,
+    //         }
+    //         //
+    //         console.log("aks:uri=blank")
+    //         console.log("aks:uri=", uri)
+    //         let resizedImage = await ImageManipulator.manipulateAsync(uri, [], saveOptions,);
+    //         //
+    //         console.log("aks:resizedImage=", resizedImage)
+    //         //delete file
+    //         FileSystem.deleteAsync(uri)
+    //             .then(() =>
+    //               Logger.getInstance().logEvent('CAPTURE_ET','File deleted success',LOG_TYPE.SDK_DEBUG)
+    //             ).catch((error) => {
+    //               Logger.getInstance().logEvent('CAPTURE_ET',error.message,LOG_TYPE.SDK_ERROR);
+    //             });
+    //         //
+    //         return resizedImage;
+    //       }   
+    //       return null;       
+    //     }
+    //   }    
+    // });
+
+    await launchCamera(options as CameraOptions , response => {  
+      if (response?.didCancel){
+        console.log("aks:didCancel=")
+        showToast('User cancelled the action');        
+        console.log('User cancelled the action');
+      } else if (response.errorCode == ('camera_unavailable' || 'permission' || 'others')) {
+        console.log("aks:errorCode=")
+        showToast(response.errorMessage? response.errorMessage : '');        
+        console.log('ImagePicker Error: ', response.errorMessage);
+      } else {
+        console.log("aks:response=else-start")
+        //        
+        let assets = response.assets? response.assets : null;   
+        console.log("aks:assets=", assets)
+        
+        //
+        if(assets != null){
+          uri = assets[0].uri as string;
+        }
+
+        console.log("aks:uri=before", uri)
+      }    
+    });
+
+    console.log("aks:uri-after=", uri)
+    //       
+    if(uri != null){      
+      //
+      let compressionRatio = await getCompressionRatio(uri, fileSize);
+      console.log("aks:compressionRatio=", compressionRatio)
+      
+      //
+      const saveOptions = {
+        compress: compressionRatio,
+      }
+      //
+      console.log("aks:uri=blank")
+      console.log("aks:uri=", uri)
+      let resizedImage = await ImageManipulator.manipulateAsync(uri, [], saveOptions,);
+      //
+      console.log("aks:resizedImage=", resizedImage)
+      //delete file
+      FileSystem.deleteAsync(uri)
+          .then(() =>
+            Logger.getInstance().logEvent('CAPTURE_ET','File deleted success',LOG_TYPE.SDK_DEBUG)
+          ).catch((error) => {
+            Logger.getInstance().logEvent('CAPTURE_ET',error.message,LOG_TYPE.SDK_ERROR);
+          });
+      //
+
+    console.log("resizedImage=before")
+    console.log("resizedImage=", resizedImage)
+
+      return resizedImage;
+    }
+
+    // if(Platform.OS = 'android'){
+    //   response = {'uri': 'hello'}
+    //   uri = 'hello';
+    // } else {
+    //    response = await ImagePicker.launchCameraAsync({
+    //     quality: 1,
+    //   });
+    //   let assets = response.assets;
+    //   if(assets){
+    //     uri = assets[0].uri
+    //   }      
+    // }
+
+    // if (response?.cancelled){
+    //   showToast('User cancelled the action');
+    //   return null;
+    // }    
+
+    
+    // let actionResize: ActionResize = {
+    //   resize: {
+    //     width: imageWidth,
+    //     height: imageHeight,
+    //   },
+    // };
+
+  return null
+   
+  } catch (exception: any) {
+    //showToast(`Error ${exception.message}`);
+    //console.error('capture image error: ', exception);
+    return null;
+  }
+}
+
+
+export async function getCaptureOutput(
+  imageDataList: ImageData[],
+  captureProps: CaptureInput
+): Promise<CaptureOutput> {
+  if (!imageDataList || imageDataList.length === 0)
+    return {
+      ...(await getBaseETResponse(
+        EntityCode.IMAGE_CAPTURE,
+        false,
+        getEventCodeByET(
+          ExecutionTaskID.IMAGE_CAPTURE,
+          false,
+          captureProps.applicableReasons?.failure
+        ),
+        '',
+        captureProps.mergedObjectiveId,
+        ExecutionTaskID.IMAGE_CAPTURE
+      )),
+    };
+  else {
+    return {
+      ...(await getBaseETResponse(
+        EntityCode.IMAGE_CAPTURE,
+        true,
+        getEventCodeByET(
+          ExecutionTaskID.IMAGE_CAPTURE,
+          true,
+          captureProps.applicableReasons?.success
+        ),
+        '',
+        captureProps.mergedObjectiveId,
+        ExecutionTaskID.IMAGE_CAPTURE
+      )),
+      captures: await getImagesData(imageDataList, captureProps),
+    };
+  }
+}
+
+async function getImagesData(
+  imagesDataList: ImageData[],
+  captureProps: CaptureInput
+): Promise<CapturedImage[]> {
+  if (imagesDataList && imagesDataList.length > 0) {
+    let output: CapturedImage[] = [];
+    const folderName =
+      (await DispatchSdkCache.getInstance().getKeyFromCache(
+        DispatchSdkCache.KEYS.FMS_FOLDER
+      )) ?? 'NULL';
+    for (const data of imagesDataList) {
+      let insertID = await insertDocumentInDB(
+        data.id,
+        folderName,
+        // JSON.stringify(captureProps.jobIds),
+        // JSON.stringify(captureProps.objRefs),
+        null,
+        captureProps.title,
+        data.path
+      );
+      if (insertID)
+        output.push({
+          url: '',
+          timestamp: data.timestamp,
+          file: { folder: folderName, name: data.id },
+        });
+      else
+        throw new BaseError(
+          BaseErrorCodes.SQLiteDBIssue,
+          'Unable to save Image'
+        );
+    }
+    return output;
+  } else return [];
+}