vineanova-redux-artifacts 1.34.0

package/src/selectors/lookupBlockVintageStatusSelector.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 getlookupBlockVintageStatusEntity = state => state.entities.lookupBlockVintageStatus;
+
+export const getlookupBlockVintageStatusEntityMeta = createSelector(
+  [getlookupBlockVintageStatusEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupBlockVintageStatusEntityData = createSelector(
+  [getlookupBlockVintageStatusEntity],
+  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/lookupBusinessUnitSelector.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 getlookupBusinessUnitEntity = state => state.entities.lookupBusinessUnit;
+
+export const getlookupBusinessUnitEntityMeta = createSelector(
+  [getlookupBusinessUnitEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupBusinessUnitEntityData = createSelector(
+  [getlookupBusinessUnitEntity],
+  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/lookupClassificationGroupIdentityTypeSelector.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 getlookupClassificationGroupIdentityTypeEntity = state => state.entities.lookupClassificationGroupIdentityType;
+
+export const getlookupClassificationGroupIdentityTypeEntityMeta = createSelector(
+  [getlookupClassificationGroupIdentityTypeEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupClassificationGroupIdentityTypeEntityData = createSelector(
+  [getlookupClassificationGroupIdentityTypeEntity],
+  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/lookupClassificationGroupSelector.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 getlookupClassificationGroupEntity = state => state.entities.lookupClassificationGroup;
+
+export const getlookupClassificationGroupEntityMeta = createSelector(
+  [getlookupClassificationGroupEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupClassificationGroupEntityData = createSelector(
+  [getlookupClassificationGroupEntity],
+  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/lookupClassificationSelector.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 getlookupClassificationEntity = state => state.entities.lookupClassification;
+
+export const getlookupClassificationEntityMeta = createSelector(
+  [getlookupClassificationEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupClassificationEntityData = createSelector(
+  [getlookupClassificationEntity],
+  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/lookupContactMethodSelector.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 getlookupContactMethodEntity = state => state.entities.lookupContactMethod;
+
+export const getlookupContactMethodEntityMeta = createSelector(
+  [getlookupContactMethodEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupContactMethodEntityData = createSelector(
+  [getlookupContactMethodEntity],
+  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/lookupCountrySelector.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 getlookupCountryEntity = state => state.entities.lookupCountry;
+
+export const getlookupCountryEntityMeta = createSelector(
+  [getlookupCountryEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupCountryEntityData = createSelector(
+  [getlookupCountryEntity],
+  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/lookupDataProviderSelector.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 getlookupDataProviderEntity = state => state.entities.lookupDataProvider;
+
+export const getlookupDataProviderEntityMeta = createSelector(
+  [getlookupDataProviderEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupDataProviderEntityData = createSelector(
+  [getlookupDataProviderEntity],
+  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/lookupDataProviderTypeSelector.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 getlookupDataProviderTypeEntity = state => state.entities.lookupDataProviderType;
+
+export const getlookupDataProviderTypeEntityMeta = createSelector(
+  [getlookupDataProviderTypeEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupDataProviderTypeEntityData = createSelector(
+  [getlookupDataProviderTypeEntity],
+  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/lookupEthnicitySelector.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 getlookupEthnicityEntity = state => state.entities.lookupEthnicity;
+
+export const getlookupEthnicityEntityMeta = createSelector(
+  [getlookupEthnicityEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupEthnicityEntityData = createSelector(
+  [getlookupEthnicityEntity],
+  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/lookupGenderSelector.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 getlookupGenderEntity = state => state.entities.lookupGender;
+
+export const getlookupGenderEntityMeta = createSelector(
+  [getlookupGenderEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupGenderEntityData = createSelector(
+  [getlookupGenderEntity],
+  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;
+  },
+);
+