vineanova-redux-artifacts 1.45.0 → 1.46.0

package/src/sagas/vineaNovaApi.sagas.js

@@ -4567,6 +4567,99 @@ import { VineaNovaActions } from '../actions'
     }
    
   
+    export function* getlookupInactiveReasonSagas(action) {
+      const {
+        payload = {},
+        meta: { reducerName },
+      } = action;
+      try {
+        yield put({
+          type: "FETCHING",
+          name: reducerName,
+        });
+
+        const response = yield call(APIServices.getlookupInactiveReason, payload);    
+        yield put({
+          type: "SUCCESS",
+          payload: response,
+          name: reducerName,
+        });
+
+        
+      } catch (err) {
+        logger.error(err);
+        /* istanbul ignore next */
+        yield put({
+          type: "ERROR",
+          payload: err,
+          name: reducerName,
+        });
+      }
+    }
+   
+  
+    export function* getlookupDocumentTypeSagas(action) {
+      const {
+        payload = {},
+        meta: { reducerName },
+      } = action;
+      try {
+        yield put({
+          type: "FETCHING",
+          name: reducerName,
+        });
+
+        const response = yield call(APIServices.getlookupDocumentType, payload);    
+        yield put({
+          type: "SUCCESS",
+          payload: response,
+          name: reducerName,
+        });
+
+        
+      } catch (err) {
+        logger.error(err);
+        /* istanbul ignore next */
+        yield put({
+          type: "ERROR",
+          payload: err,
+          name: reducerName,
+        });
+      }
+    }
+   
+  
+    export function* getlookupDocumentStatusSagas(action) {
+      const {
+        payload = {},
+        meta: { reducerName },
+      } = action;
+      try {
+        yield put({
+          type: "FETCHING",
+          name: reducerName,
+        });
+
+        const response = yield call(APIServices.getlookupDocumentStatus, payload);    
+        yield put({
+          type: "SUCCESS",
+          payload: response,
+          name: reducerName,
+        });
+
+        
+      } catch (err) {
+        logger.error(err);
+        /* istanbul ignore next */
+        yield put({
+          type: "ERROR",
+          payload: err,
+          name: reducerName,
+        });
+      }
+    }
+   
+  
 
 /** run all lookups requests **/
 export function* fetchAllLookupsSagas(action) {
@@ -4700,6 +4793,15 @@ export function* fetchAllLookupsSagas(action) {
         yield put(
           VineaNovaActions.api.v1.lookupCropSettingOption.get.request(),
         );
+        yield put(
+          VineaNovaActions.api.v1.lookupInactiveReason.get.request(),
+        );
+        yield put(
+          VineaNovaActions.api.v1.lookupDocumentType.get.request(),
+        );
+        yield put(
+          VineaNovaActions.api.v1.lookupDocumentStatus.get.request(),
+        );
     } catch (err) {
         logger.error(err);
     }
@@ -4898,6 +5000,9 @@ export default function* root() {
       takeLatest(VineaNovaActions.api.v1.lookupPhenologyMeasureType.get.request().type, getlookupPhenologyMeasureTypeSagas),    
       takeLatest(VineaNovaActions.api.v1.lookupCropSettingInstance.get.request().type, getlookupCropSettingInstanceSagas),    
       takeLatest(VineaNovaActions.api.v1.lookupCropSettingOption.get.request().type, getlookupCropSettingOptionSagas),    
+      takeLatest(VineaNovaActions.api.v1.lookupInactiveReason.get.request().type, getlookupInactiveReasonSagas),    
+      takeLatest(VineaNovaActions.api.v1.lookupDocumentType.get.request().type, getlookupDocumentTypeSagas),    
+      takeLatest(VineaNovaActions.api.v1.lookupDocumentStatus.get.request().type, getlookupDocumentStatusSagas),    
       takeLatest(VineaNovaActions.api.v1.fetchAllLookups.request().type, fetchAllLookupsSagas),
       takeLatest((action)=> /CLEARDATA/.test(action.type), clearReducerData),   
       takeLatest((action)=> /UPDATEPARTIALENTITY/.test(action.type), commonEntityPartialUpdateActionCreator),   

package/src/selectors/index.js

@@ -90,4 +90,7 @@ export * from "./lookupPhenologyMeasureSetSelector";
 export * from "./lookupPhenologyMeasureTypeSelector";
 export * from "./lookupCropSettingInstanceSelector";
 export * from "./lookupCropSettingOptionSelector";
+export * from "./lookupInactiveReasonSelector";
+export * from "./lookupDocumentTypeSelector";
+export * from "./lookupDocumentStatusSelector";
 export * from './lookupStatusSelector';

package/src/selectors/lookupDocumentStatusSelector.js

@@ -0,0 +1,64 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import {isValid, format} from 'date-fns';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getlookupDocumentStatusEntity = state => state.entities.lookupDocumentStatus;
+
+export const getlookupDocumentStatusEntityMeta = createSelector(
+  [getlookupDocumentStatusEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupDocumentStatusEntityData = createSelector(
+  [getlookupDocumentStatusEntity],
+  reference => {
+    const { data = [] } = reference;
+    const refData = isEmpty(data) ? [] : data;
+    if (!Array.isArray(refData) || isNil(refData)) return [];
+
+    const formattedData = refData.map(d => {
+      let hasDates = false;
+      let fromDate = '';
+      let toDate = '';
+      let fromTo = '';
+
+      if(has(d, 'effectiveToDate') && has(d, 'effectiveFromDate')){
+        hasDates = true;
+        toDate =
+          !isEmpty(d.effectiveToDate) && isValid(new Date(d.effectiveToDate))
+            ? format(new Date(d.effectiveToDate), viewDateFormat)
+            : '';
+        fromDate =
+          !isEmpty(d.effectiveFromDate) &&
+          isValid(new Date(d.effectiveFromDate))
+            ? format(new Date(d.effectiveFromDate), viewDateFormat)
+            : '';
+        const seperator = toDate ? '-' : '';
+        fromToDate = `${fromDate} ${seperator} ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/lookupDocumentTypeSelector.js

@@ -0,0 +1,64 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import {isValid, format} from 'date-fns';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getlookupDocumentTypeEntity = state => state.entities.lookupDocumentType;
+
+export const getlookupDocumentTypeEntityMeta = createSelector(
+  [getlookupDocumentTypeEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupDocumentTypeEntityData = createSelector(
+  [getlookupDocumentTypeEntity],
+  reference => {
+    const { data = [] } = reference;
+    const refData = isEmpty(data) ? [] : data;
+    if (!Array.isArray(refData) || isNil(refData)) return [];
+
+    const formattedData = refData.map(d => {
+      let hasDates = false;
+      let fromDate = '';
+      let toDate = '';
+      let fromTo = '';
+
+      if(has(d, 'effectiveToDate') && has(d, 'effectiveFromDate')){
+        hasDates = true;
+        toDate =
+          !isEmpty(d.effectiveToDate) && isValid(new Date(d.effectiveToDate))
+            ? format(new Date(d.effectiveToDate), viewDateFormat)
+            : '';
+        fromDate =
+          !isEmpty(d.effectiveFromDate) &&
+          isValid(new Date(d.effectiveFromDate))
+            ? format(new Date(d.effectiveFromDate), viewDateFormat)
+            : '';
+        const seperator = toDate ? '-' : '';
+        fromToDate = `${fromDate} ${seperator} ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/lookupInactiveReasonSelector.js

@@ -0,0 +1,64 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import {isValid, format} from 'date-fns';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getlookupInactiveReasonEntity = state => state.entities.lookupInactiveReason;
+
+export const getlookupInactiveReasonEntityMeta = createSelector(
+  [getlookupInactiveReasonEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupInactiveReasonEntityData = createSelector(
+  [getlookupInactiveReasonEntity],
+  reference => {
+    const { data = [] } = reference;
+    const refData = isEmpty(data) ? [] : data;
+    if (!Array.isArray(refData) || isNil(refData)) return [];
+
+    const formattedData = refData.map(d => {
+      let hasDates = false;
+      let fromDate = '';
+      let toDate = '';
+      let fromTo = '';
+
+      if(has(d, 'effectiveToDate') && has(d, 'effectiveFromDate')){
+        hasDates = true;
+        toDate =
+          !isEmpty(d.effectiveToDate) && isValid(new Date(d.effectiveToDate))
+            ? format(new Date(d.effectiveToDate), viewDateFormat)
+            : '';
+        fromDate =
+          !isEmpty(d.effectiveFromDate) &&
+          isValid(new Date(d.effectiveFromDate))
+            ? format(new Date(d.effectiveFromDate), viewDateFormat)
+            : '';
+        const seperator = toDate ? '-' : '';
+        fromToDate = `${fromDate} ${seperator} ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/lookupStatusSelector.js

@@ -43,6 +43,9 @@ const getLkplookupPhenologyMeasureSet = state => state.entities.lookupPhenologyM
 const getLkplookupPhenologyMeasureType = state => state.entities.lookupPhenologyMeasureType;
 const getLkplookupCropSettingInstance = state => state.entities.lookupCropSettingInstance;
 const getLkplookupCropSettingOption = state => state.entities.lookupCropSettingOption;
+const getLkplookupInactiveReason = state => state.entities.lookupInactiveReason;
+const getLkplookupDocumentType = state => state.entities.lookupDocumentType;
+const getLkplookupDocumentStatus = state => state.entities.lookupDocumentStatus;
 
 export const areLookupsLoading = createSelector(
   [
@@ -89,6 +92,9 @@ export const areLookupsLoading = createSelector(
     getLkplookupPhenologyMeasureType,
     getLkplookupCropSettingInstance,
     getLkplookupCropSettingOption,
+    getLkplookupInactiveReason,
+    getLkplookupDocumentType,
+    getLkplookupDocumentStatus,
   ],
   (
     lkplookupClassification,
@@ -134,6 +140,9 @@ export const areLookupsLoading = createSelector(
     lkplookupPhenologyMeasureType,
     lkplookupCropSettingInstance,
     lkplookupCropSettingOption,
+    lkplookupInactiveReason,
+    lkplookupDocumentType,
+    lkplookupDocumentStatus,
   ) => {
     const { isLoading: lookupClassificationIsLoading } = lkplookupClassification;
     const { isLoading: lookupClassificationGroupIsLoading } = lkplookupClassificationGroup;
@@ -178,6 +187,9 @@ export const areLookupsLoading = createSelector(
     const { isLoading: lookupPhenologyMeasureTypeIsLoading } = lkplookupPhenologyMeasureType;
     const { isLoading: lookupCropSettingInstanceIsLoading } = lkplookupCropSettingInstance;
     const { isLoading: lookupCropSettingOptionIsLoading } = lkplookupCropSettingOption;
+    const { isLoading: lookupInactiveReasonIsLoading } = lkplookupInactiveReason;
+    const { isLoading: lookupDocumentTypeIsLoading } = lkplookupDocumentType;
+    const { isLoading: lookupDocumentStatusIsLoading } = lkplookupDocumentStatus;
 
     return (
       lookupClassificationIsLoading ||
@@ -223,6 +235,9 @@ export const areLookupsLoading = createSelector(
       lookupPhenologyMeasureTypeIsLoading ||
       lookupCropSettingInstanceIsLoading ||
       lookupCropSettingOptionIsLoading ||
+      lookupInactiveReasonIsLoading ||
+      lookupDocumentTypeIsLoading ||
+      lookupDocumentStatusIsLoading ||
       false
     );
   },
@@ -274,6 +289,9 @@ export const areLookupsLoaded = createSelector(
     getLkplookupPhenologyMeasureType,
     getLkplookupCropSettingInstance,
     getLkplookupCropSettingOption,
+    getLkplookupInactiveReason,
+    getLkplookupDocumentType,
+    getLkplookupDocumentStatus,
   ],
   (
     lkplookupClassification,
@@ -319,6 +337,9 @@ export const areLookupsLoaded = createSelector(
     lkplookupPhenologyMeasureType,
     lkplookupCropSettingInstance,
     lkplookupCropSettingOption,
+    lkplookupInactiveReason,
+    lkplookupDocumentType,
+    lkplookupDocumentStatus,
   ) => {
     const { isLoaded: lookupClassificationIsLoaded } = lkplookupClassification;
     const { isLoaded: lookupClassificationGroupIsLoaded } = lkplookupClassificationGroup;
@@ -363,6 +384,9 @@ export const areLookupsLoaded = createSelector(
     const { isLoaded: lookupPhenologyMeasureTypeIsLoaded } = lkplookupPhenologyMeasureType;
     const { isLoaded: lookupCropSettingInstanceIsLoaded } = lkplookupCropSettingInstance;
     const { isLoaded: lookupCropSettingOptionIsLoaded } = lkplookupCropSettingOption;
+    const { isLoaded: lookupInactiveReasonIsLoaded } = lkplookupInactiveReason;
+    const { isLoaded: lookupDocumentTypeIsLoaded } = lkplookupDocumentType;
+    const { isLoaded: lookupDocumentStatusIsLoaded } = lkplookupDocumentStatus;
 
     return (
       lookupClassificationIsLoaded ||
@@ -408,6 +432,9 @@ export const areLookupsLoaded = createSelector(
       lookupPhenologyMeasureTypeIsLoaded ||
       lookupCropSettingInstanceIsLoaded ||
       lookupCropSettingOptionIsLoaded ||
+      lookupInactiveReasonIsLoaded ||
+      lookupDocumentTypeIsLoaded ||
+      lookupDocumentStatusIsLoaded ||
       false
     );
   },

package/src/services/apiServices.js

@@ -4048,3 +4048,87 @@ import serviceConfig from "./config/serviceConfig";
     };
    
   
+    export const getlookupInactiveReason = async (payload) => {
+      try {
+        const { queryParams, postBody, options } = payload || {};
+        const { code = '' } = queryParams || {};
+        const API_FUNCTION_CODE = process.env.REACT_APP_FUNCTION_CODE || code;
+        let apiUrl = '/GetLookUp';
+        const response = await serviceConfig.request({
+          url: apiUrl,
+          method: "get",
+          params: {
+            ...queryParams,
+            code: API_FUNCTION_CODE,
+            LookUpName: 'lookupInactiveReason'.replace('lookup',''),
+          },
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+          },
+          ...options,
+        });
+        return response;
+      } catch (err) {
+        logger.error(err);
+        throw err;
+      }
+    };
+   
+  
+    export const getlookupDocumentType = async (payload) => {
+      try {
+        const { queryParams, postBody, options } = payload || {};
+        const { code = '' } = queryParams || {};
+        const API_FUNCTION_CODE = process.env.REACT_APP_FUNCTION_CODE || code;
+        let apiUrl = '/GetLookUp';
+        const response = await serviceConfig.request({
+          url: apiUrl,
+          method: "get",
+          params: {
+            ...queryParams,
+            code: API_FUNCTION_CODE,
+            LookUpName: 'lookupDocumentType'.replace('lookup',''),
+          },
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+          },
+          ...options,
+        });
+        return response;
+      } catch (err) {
+        logger.error(err);
+        throw err;
+      }
+    };
+   
+  
+    export const getlookupDocumentStatus = async (payload) => {
+      try {
+        const { queryParams, postBody, options } = payload || {};
+        const { code = '' } = queryParams || {};
+        const API_FUNCTION_CODE = process.env.REACT_APP_FUNCTION_CODE || code;
+        let apiUrl = '/GetLookUp';
+        const response = await serviceConfig.request({
+          url: apiUrl,
+          method: "get",
+          params: {
+            ...queryParams,
+            code: API_FUNCTION_CODE,
+            LookUpName: 'lookupDocumentStatus'.replace('lookup',''),
+          },
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+          },
+          ...options,
+        });
+        return response;
+      } catch (err) {
+        logger.error(err);
+        throw err;
+      }
+    };
+   
+