vineanova-redux-artifacts 1.34.0

package/src/selectors/lookupTrellisSelector.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 getlookupTrellisEntity = state => state.entities.lookupTrellis;
+
+export const getlookupTrellisEntityMeta = createSelector(
+  [getlookupTrellisEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupTrellisEntityData = createSelector(
+  [getlookupTrellisEntity],
+  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/lookupVarietyCloneSelector.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 getlookupVarietyCloneEntity = state => state.entities.lookupVarietyClone;
+
+export const getlookupVarietyCloneEntityMeta = createSelector(
+  [getlookupVarietyCloneEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupVarietyCloneEntityData = createSelector(
+  [getlookupVarietyCloneEntity],
+  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/lookupVarietySelector.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 getlookupVarietyEntity = state => state.entities.lookupVariety;
+
+export const getlookupVarietyEntityMeta = createSelector(
+  [getlookupVarietyEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupVarietyEntityData = createSelector(
+  [getlookupVarietyEntity],
+  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/lookupVintageSelector.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 getlookupVintageEntity = state => state.entities.lookupVintage;
+
+export const getlookupVintageEntityMeta = createSelector(
+  [getlookupVintageEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupVintageEntityData = createSelector(
+  [getlookupVintageEntity],
+  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/processblocksamplingSelector.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 getprocessblocksamplingEntity = state => state.entities.processblocksampling;
+
+export const getprocessblocksamplingEntityMeta = createSelector(
+  [getprocessblocksamplingEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getprocessblocksamplingEntityData = createSelector(
+  [getprocessblocksamplingEntity],
+  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/queueMessageSelector.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 getQueueMessageEntity = state => state.entities.queueMessage;
+
+export const getQueueMessageEntityMeta = createSelector(
+  [getQueueMessageEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getQueueMessageEntityData = createSelector(
+  [getQueueMessageEntity],
+  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/sampleBlockVintagesSelector.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 getSampleBlockVintagesEntity = state => state.entities.sampleBlockVintages;
+
+export const getSampleBlockVintagesEntityMeta = createSelector(
+  [getSampleBlockVintagesEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getSampleBlockVintagesEntityData = createSelector(
+  [getSampleBlockVintagesEntity],
+  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/sampleHeaderSelector.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 getSampleHeaderEntity = state => state.entities.sampleHeader;
+
+export const getSampleHeaderEntityMeta = createSelector(
+  [getSampleHeaderEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getSampleHeaderEntityData = createSelector(
+  [getSampleHeaderEntity],
+  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/sampleHeaderStatusSelector.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 getSampleHeaderStatusEntity = state => state.entities.sampleHeaderStatus;
+
+export const getSampleHeaderStatusEntityMeta = createSelector(
+  [getSampleHeaderStatusEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getSampleHeaderStatusEntityData = createSelector(
+  [getSampleHeaderStatusEntity],
+  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/sampleHeadersSelector.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 getSampleHeadersEntity = state => state.entities.sampleHeaders;
+
+export const getSampleHeadersEntityMeta = createSelector(
+  [getSampleHeadersEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getSampleHeadersEntityData = createSelector(
+  [getSampleHeadersEntity],
+  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/sampleIdentitySelector.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 getSampleIdentityEntity = state => state.entities.sampleIdentity;
+
+export const getSampleIdentityEntityMeta = createSelector(
+  [getSampleIdentityEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getSampleIdentityEntityData = createSelector(
+  [getSampleIdentityEntity],
+  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;
+  },
+);
+