vineanova-redux-artifacts 1.34.0

package/src/selectors/lookupGrowingRegionSelector.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 getlookupGrowingRegionEntity = state => state.entities.lookupGrowingRegion;
+
+export const getlookupGrowingRegionEntityMeta = createSelector(
+  [getlookupGrowingRegionEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupGrowingRegionEntityData = createSelector(
+  [getlookupGrowingRegionEntity],
+  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/lookupGrowingSubRegionSelector.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 getlookupGrowingSubRegionEntity = state => state.entities.lookupGrowingSubRegion;
+
+export const getlookupGrowingSubRegionEntityMeta = createSelector(
+  [getlookupGrowingSubRegionEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupGrowingSubRegionEntityData = createSelector(
+  [getlookupGrowingSubRegionEntity],
+  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/lookupIdentityTypeSelector.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 getlookupIdentityTypeEntity = state => state.entities.lookupIdentityType;
+
+export const getlookupIdentityTypeEntityMeta = createSelector(
+  [getlookupIdentityTypeEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupIdentityTypeEntityData = createSelector(
+  [getlookupIdentityTypeEntity],
+  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/lookupKeywordSelector.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 getlookupKeywordEntity = state => state.entities.lookupKeyword;
+
+export const getlookupKeywordEntityMeta = createSelector(
+  [getlookupKeywordEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupKeywordEntityData = createSelector(
+  [getlookupKeywordEntity],
+  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/lookupLanguageSelector.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 getlookupLanguageEntity = state => state.entities.lookupLanguage;
+
+export const getlookupLanguageEntityMeta = createSelector(
+  [getlookupLanguageEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupLanguageEntityData = createSelector(
+  [getlookupLanguageEntity],
+  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/lookupMeasureGroupSelector.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 getlookupMeasureGroupEntity = state => state.entities.lookupMeasureGroup;
+
+export const getlookupMeasureGroupEntityMeta = createSelector(
+  [getlookupMeasureGroupEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupMeasureGroupEntityData = createSelector(
+  [getlookupMeasureGroupEntity],
+  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/lookupMeasureInstanceSelector.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 getlookupMeasureInstanceEntity = state => state.entities.lookupMeasureInstance;
+
+export const getlookupMeasureInstanceEntityMeta = createSelector(
+  [getlookupMeasureInstanceEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupMeasureInstanceEntityData = createSelector(
+  [getlookupMeasureInstanceEntity],
+  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/lookupMeasureSelector.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 getlookupMeasureEntity = state => state.entities.lookupMeasure;
+
+export const getlookupMeasureEntityMeta = createSelector(
+  [getlookupMeasureEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupMeasureEntityData = createSelector(
+  [getlookupMeasureEntity],
+  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/lookupNationalitySelector.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 getlookupNationalityEntity = state => state.entities.lookupNationality;
+
+export const getlookupNationalityEntityMeta = createSelector(
+  [getlookupNationalityEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupNationalityEntityData = createSelector(
+  [getlookupNationalityEntity],
+  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/lookupNoteStatusSelector.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 getlookupNoteStatusEntity = state => state.entities.lookupNoteStatus;
+
+export const getlookupNoteStatusEntityMeta = createSelector(
+  [getlookupNoteStatusEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupNoteStatusEntityData = createSelector(
+  [getlookupNoteStatusEntity],
+  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/lookupPayrollSystemSelector.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 getlookupPayrollSystemEntity = state => state.entities.lookupPayrollSystem;
+
+export const getlookupPayrollSystemEntityMeta = createSelector(
+  [getlookupPayrollSystemEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupPayrollSystemEntityData = createSelector(
+  [getlookupPayrollSystemEntity],
+  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;
+  },
+);
+