vineanova-redux-artifacts 1.34.0

package/src/selectors/identityRelationshipTypeSelector.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 getIdentityRelationshipTypeEntity = state => state.entities.identityRelationshipType;
+
+export const getIdentityRelationshipTypeEntityMeta = createSelector(
+  [getIdentityRelationshipTypeEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getIdentityRelationshipTypeEntityData = createSelector(
+  [getIdentityRelationshipTypeEntity],
+  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/identityRoleSelector.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 getIdentityRoleEntity = state => state.entities.identityRole;
+
+export const getIdentityRoleEntityMeta = createSelector(
+  [getIdentityRoleEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getIdentityRoleEntityData = createSelector(
+  [getIdentityRoleEntity],
+  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/identitySelector.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 getIdentityEntity = state => state.entities.identity;
+
+export const getIdentityEntityMeta = createSelector(
+  [getIdentityEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getIdentityEntityData = createSelector(
+  [getIdentityEntity],
+  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/identityServiceProviderSelector.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 getIdentityServiceProviderEntity = state => state.entities.identityServiceProvider;
+
+export const getIdentityServiceProviderEntityMeta = createSelector(
+  [getIdentityServiceProviderEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getIdentityServiceProviderEntityData = createSelector(
+  [getIdentityServiceProviderEntity],
+  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/identityVineyardBlockRowSelector.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 getIdentityVineyardBlockRowEntity = state => state.entities.identityVineyardBlockRow;
+
+export const getIdentityVineyardBlockRowEntityMeta = createSelector(
+  [getIdentityVineyardBlockRowEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getIdentityVineyardBlockRowEntityData = createSelector(
+  [getIdentityVineyardBlockRowEntity],
+  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/identityVineyardBlockRowsSelector.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 getIdentityVineyardBlockRowsEntity = state => state.entities.identityVineyardBlockRows;
+
+export const getIdentityVineyardBlockRowsEntityMeta = createSelector(
+  [getIdentityVineyardBlockRowsEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getIdentityVineyardBlockRowsEntityData = createSelector(
+  [getIdentityVineyardBlockRowsEntity],
+  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/identityVineyardBlockSelector.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 getIdentityVineyardBlockEntity = state => state.entities.identityVineyardBlock;
+
+export const getIdentityVineyardBlockEntityMeta = createSelector(
+  [getIdentityVineyardBlockEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getIdentityVineyardBlockEntityData = createSelector(
+  [getIdentityVineyardBlockEntity],
+  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/identityVineyardBlocksSelector.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 getIdentityVineyardBlocksEntity = state => state.entities.identityVineyardBlocks;
+
+export const getIdentityVineyardBlocksEntityMeta = createSelector(
+  [getIdentityVineyardBlocksEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getIdentityVineyardBlocksEntityData = createSelector(
+  [getIdentityVineyardBlocksEntity],
+  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/identityVineyardSelector.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 getIdentityVineyardEntity = state => state.entities.identityVineyard;
+
+export const getIdentityVineyardEntityMeta = createSelector(
+  [getIdentityVineyardEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getIdentityVineyardEntityData = createSelector(
+  [getIdentityVineyardEntity],
+  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/index.js

@@ -0,0 +1,85 @@
+
+export * from "./blockVintageSelector";
+export * from "./cropBlockPhenologySelector";
+export * from "./cropBlockSettingSelector";
+export * from "./cropBlockVintageSelector";
+export * from "./healthcheckSelector";
+export * from "./identitySelector";
+export * from "./identityDetailsSelector";
+export * from "./identityClassificationSelector";
+export * from "./identityContactMethodSelector";
+export * from "./contactMethodSelector";
+export * from "./identityContactMethodAddressSelector";
+export * from "./identityDataConnectorSelector";
+export * from "./identityNotesSelector";
+export * from "./identityNoteSelector";
+export * from "./identityNoteImageSelector";
+export * from "./identityOrganisationSelector";
+export * from "./identityPersonSelector";
+export * from "./identityReferenceSelector";
+export * from "./identityRelationshipSelector";
+export * from "./identityRelationshipTypeSelector";
+export * from "./identityRoleSelector";
+export * from "./identityServiceProviderSelector";
+export * from "./gridVineyardBlocksSelector";
+export * from "./identityVineyardBlocksSelector";
+export * from "./identityVineyardBlockSelector";
+export * from "./identityVineyardBlockRowsSelector";
+export * from "./identityVineyardBlockRowSelector";
+export * from "./getLookUpSelector";
+export * from "./queueMessageSelector";
+export * from "./processblocksamplingSelector";
+export * from "./sampleHeadersSelector";
+export * from "./sampleHeaderStatusSelector";
+export * from "./sampleHeaderSelector";
+export * from "./sampleIdentitySelector";
+export * from "./assignSampleHeadersSelector";
+export * from "./samplingUsersSelector";
+export * from "./deAssignSampleHeadersSelector";
+export * from "./sampleSetsSelector";
+export * from "./sampleBlockVintagesSelector";
+export * from "./sampleSetSelector";
+export * from "./searchIdentitySelector";
+export * from "./identityVineyardSelector";
+export * from "./lookupClassificationSelector";
+export * from "./lookupClassificationGroupSelector";
+export * from "./lookupClassificationGroupIdentityTypeSelector";
+export * from "./lookupReferenceTypeSelector";
+export * from "./lookupIdentityTypeSelector";
+export * from "./lookupRoleTypeSelector";
+export * from "./lookupRoleTypeIdentityTypeSelector";
+export * from "./lookupBusinessUnitSelector";
+export * from "./lookupReferenceTypeIdentityTypeSelector";
+export * from "./lookupRelationshipTypeSelector";
+export * from "./lookupRelationshipSubTypeSelector";
+export * from "./lookupContactMethodSelector";
+export * from "./lookupGenderSelector";
+export * from "./lookupNationalitySelector";
+export * from "./lookupEthnicitySelector";
+export * from "./lookupLanguageSelector";
+export * from "./lookupCountrySelector";
+export * from "./lookupSalutationSelector";
+export * from "./lookupGrowingRegionSelector";
+export * from "./lookupGrowingSubRegionSelector";
+export * from "./lookupTownSelector";
+export * from "./lookupVarietySelector";
+export * from "./lookupBlockVintageStatusSelector";
+export * from "./lookupTrellisSelector";
+export * from "./lookupRootStockSelector";
+export * from "./lookupVarietyCloneSelector";
+export * from "./lookupVintageSelector";
+export * from "./lookupRowSpecialAttributeSelector";
+export * from "./lookupNoteStatusSelector";
+export * from "./lookupMeasureSelector";
+export * from "./lookupMeasureGroupSelector";
+export * from "./lookupMeasureInstanceSelector";
+export * from "./lookupKeywordSelector";
+export * from "./lookupSampleRequestStatusSelector";
+export * from "./lookupPayrollSystemSelector";
+export * from "./lookupDataProviderSelector";
+export * from "./lookupDataProviderTypeSelector";
+export * from "./lookupPhenologyMeasureSelector";
+export * from "./lookupPhenologyMeasureOptionSelector";
+export * from "./lookupPhenologyMeasureSetSelector";
+export * from "./lookupPhenologyMeasureTypeSelector";
+export * from './lookupStatusSelector';