vineanova-redux-artifacts 1.34.0

package/src/selectors/assignSampleHeadersSelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getAssignSampleHeadersEntity = state => state.entities.assignSampleHeaders;
+
+export const getAssignSampleHeadersEntityMeta = createSelector(
+  [getAssignSampleHeadersEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getAssignSampleHeadersEntityData = createSelector(
+  [getAssignSampleHeadersEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/blockVintageSelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getBlockVintageEntity = state => state.entities.blockVintage;
+
+export const getBlockVintageEntityMeta = createSelector(
+  [getBlockVintageEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getBlockVintageEntityData = createSelector(
+  [getBlockVintageEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/contactMethodSelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getContactMethodEntity = state => state.entities.contactMethod;
+
+export const getContactMethodEntityMeta = createSelector(
+  [getContactMethodEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getContactMethodEntityData = createSelector(
+  [getContactMethodEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/cropBlockPhenologySelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getCropBlockPhenologyEntity = state => state.entities.cropBlockPhenology;
+
+export const getCropBlockPhenologyEntityMeta = createSelector(
+  [getCropBlockPhenologyEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getCropBlockPhenologyEntityData = createSelector(
+  [getCropBlockPhenologyEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/cropBlockSettingSelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getCropBlockSettingEntity = state => state.entities.cropBlockSetting;
+
+export const getCropBlockSettingEntityMeta = createSelector(
+  [getCropBlockSettingEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getCropBlockSettingEntityData = createSelector(
+  [getCropBlockSettingEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/cropBlockVintageSelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getCropBlockVintageEntity = state => state.entities.cropBlockVintage;
+
+export const getCropBlockVintageEntityMeta = createSelector(
+  [getCropBlockVintageEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getCropBlockVintageEntityData = createSelector(
+  [getCropBlockVintageEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/deAssignSampleHeadersSelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getDeAssignSampleHeadersEntity = state => state.entities.deAssignSampleHeaders;
+
+export const getDeAssignSampleHeadersEntityMeta = createSelector(
+  [getDeAssignSampleHeadersEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getDeAssignSampleHeadersEntityData = createSelector(
+  [getDeAssignSampleHeadersEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/getLookUpSelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getGetLookUpEntity = state => state.entities.getLookUp;
+
+export const getGetLookUpEntityMeta = createSelector(
+  [getGetLookUpEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getGetLookUpEntityData = createSelector(
+  [getGetLookUpEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/gridVineyardBlocksSelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getGridVineyardBlocksEntity = state => state.entities.gridVineyardBlocks;
+
+export const getGridVineyardBlocksEntityMeta = createSelector(
+  [getGridVineyardBlocksEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getGridVineyardBlocksEntityData = createSelector(
+  [getGridVineyardBlocksEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/healthcheckSelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const gethealthcheckEntity = state => state.entities.healthcheck;
+
+export const gethealthcheckEntityMeta = createSelector(
+  [gethealthcheckEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const gethealthcheckEntityData = createSelector(
+  [gethealthcheckEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/identityClassificationSelector.js

@@ -0,0 +1,61 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import moment from 'moment';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+
+export const getIdentityClassificationEntity = state => state.entities.identityClassification;
+
+export const getIdentityClassificationEntityMeta = createSelector(
+  [getIdentityClassificationEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getIdentityClassificationEntityData = createSelector(
+  [getIdentityClassificationEntity],
+  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 = moment(d.effectiveToDate).isValid()
+          ? moment(d.effectiveToDate).format('DD/MM/YYYY')
+          : '';
+        fromDate = moment(d.effectiveFromDate).isValid()
+          ? moment(d.effectiveFromDate).format('DD/MM/YYYY')
+          : d.effectiveFromDate;
+        
+        fromTo = `${fromDate} - ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+