vineanova-redux-artifacts 1.119.20 → 1.119.21

package/src/selectors/lookupJobStatusSelector.js

@@ -0,0 +1,65 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import {isValid, format} from 'date-fns';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+const viewDateFormat = 'dd/MM/yyyy';
+
+export const getlookupJobStatusEntity = state => state.entities.lookupJobStatus;
+
+export const getlookupJobStatusEntityMeta = createSelector(
+  [getlookupJobStatusEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupJobStatusEntityData = createSelector(
+  [getlookupJobStatusEntity],
+  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 =
+          !isEmpty(d.effectiveToDate) && isValid(new Date(d.effectiveToDate))
+            ? format(new Date(d.effectiveToDate), viewDateFormat)
+            : '';
+        fromDate =
+          !isEmpty(d.effectiveFromDate) &&
+          isValid(new Date(d.effectiveFromDate))
+            ? format(new Date(d.effectiveFromDate), viewDateFormat)
+            : '';
+        const seperator = toDate ? '-' : '';
+        fromToDate = `${fromDate} ${seperator} ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/lookupJobTypeSelector.js

@@ -0,0 +1,65 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import {isValid, format} from 'date-fns';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+const viewDateFormat = 'dd/MM/yyyy';
+
+export const getlookupJobTypeEntity = state => state.entities.lookupJobType;
+
+export const getlookupJobTypeEntityMeta = createSelector(
+  [getlookupJobTypeEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupJobTypeEntityData = createSelector(
+  [getlookupJobTypeEntity],
+  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 =
+          !isEmpty(d.effectiveToDate) && isValid(new Date(d.effectiveToDate))
+            ? format(new Date(d.effectiveToDate), viewDateFormat)
+            : '';
+        fromDate =
+          !isEmpty(d.effectiveFromDate) &&
+          isValid(new Date(d.effectiveFromDate))
+            ? format(new Date(d.effectiveFromDate), viewDateFormat)
+            : '';
+        const seperator = toDate ? '-' : '';
+        fromToDate = `${fromDate} ${seperator} ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/lookupJobTypeWorkRecordTypeSelector.js

@@ -0,0 +1,65 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import {isValid, format} from 'date-fns';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+const viewDateFormat = 'dd/MM/yyyy';
+
+export const getlookupJobTypeWorkRecordTypeEntity = state => state.entities.lookupJobTypeWorkRecordType;
+
+export const getlookupJobTypeWorkRecordTypeEntityMeta = createSelector(
+  [getlookupJobTypeWorkRecordTypeEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupJobTypeWorkRecordTypeEntityData = createSelector(
+  [getlookupJobTypeWorkRecordTypeEntity],
+  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 =
+          !isEmpty(d.effectiveToDate) && isValid(new Date(d.effectiveToDate))
+            ? format(new Date(d.effectiveToDate), viewDateFormat)
+            : '';
+        fromDate =
+          !isEmpty(d.effectiveFromDate) &&
+          isValid(new Date(d.effectiveFromDate))
+            ? format(new Date(d.effectiveFromDate), viewDateFormat)
+            : '';
+        const seperator = toDate ? '-' : '';
+        fromToDate = `${fromDate} ${seperator} ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/lookupJobWorkUnitSelector.js

@@ -0,0 +1,65 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import {isValid, format} from 'date-fns';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+const viewDateFormat = 'dd/MM/yyyy';
+
+export const getlookupJobWorkUnitEntity = state => state.entities.lookupJobWorkUnit;
+
+export const getlookupJobWorkUnitEntityMeta = createSelector(
+  [getlookupJobWorkUnitEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupJobWorkUnitEntityData = createSelector(
+  [getlookupJobWorkUnitEntity],
+  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 =
+          !isEmpty(d.effectiveToDate) && isValid(new Date(d.effectiveToDate))
+            ? format(new Date(d.effectiveToDate), viewDateFormat)
+            : '';
+        fromDate =
+          !isEmpty(d.effectiveFromDate) &&
+          isValid(new Date(d.effectiveFromDate))
+            ? format(new Date(d.effectiveFromDate), viewDateFormat)
+            : '';
+        const seperator = toDate ? '-' : '';
+        fromToDate = `${fromDate} ${seperator} ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/lookupPayrollRecordTypeSelector.js

@@ -0,0 +1,65 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import {isValid, format} from 'date-fns';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+const viewDateFormat = 'dd/MM/yyyy';
+
+export const getlookupPayrollRecordTypeEntity = state => state.entities.lookupPayrollRecordType;
+
+export const getlookupPayrollRecordTypeEntityMeta = createSelector(
+  [getlookupPayrollRecordTypeEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupPayrollRecordTypeEntityData = createSelector(
+  [getlookupPayrollRecordTypeEntity],
+  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 =
+          !isEmpty(d.effectiveToDate) && isValid(new Date(d.effectiveToDate))
+            ? format(new Date(d.effectiveToDate), viewDateFormat)
+            : '';
+        fromDate =
+          !isEmpty(d.effectiveFromDate) &&
+          isValid(new Date(d.effectiveFromDate))
+            ? format(new Date(d.effectiveFromDate), viewDateFormat)
+            : '';
+        const seperator = toDate ? '-' : '';
+        fromToDate = `${fromDate} ${seperator} ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+

package/src/selectors/lookupStatusSelector.js

@@ -65,6 +65,15 @@ const getLkplookupActivityGroup = state => state.entities.lookupActivityGroup;
 const getLkplookupPlanType = state => state.entities.lookupPlanType;
 const getLkplookupPlanStatus = state => state.entities.lookupPlanStatus;
 const getLkplookupSupplyContractType = state => state.entities.lookupSupplyContractType;
+const getLkplookupJobEventAction = state => state.entities.lookupJobEventAction;
+const getLkplookupJobInvoiceMethod = state => state.entities.lookupJobInvoiceMethod;
+const getLkplookupJobQuantityType = state => state.entities.lookupJobQuantityType;
+const getLkplookupJobStatus = state => state.entities.lookupJobStatus;
+const getLkplookupJobType = state => state.entities.lookupJobType;
+const getLkplookupJobTypeWorkRecordType = state => state.entities.lookupJobTypeWorkRecordType;
+const getLkplookupWorkRecordLevel = state => state.entities.lookupWorkRecordLevel;
+const getLkplookupPayrollRecordType = state => state.entities.lookupPayrollRecordType;
+const getLkplookupJobWorkUnit = state => state.entities.lookupJobWorkUnit;
 
 export const areLookupsLoading = createSelector(
   [
@@ -133,6 +142,15 @@ export const areLookupsLoading = createSelector(
     getLkplookupPlanType,
     getLkplookupPlanStatus,
     getLkplookupSupplyContractType,
+    getLkplookupJobEventAction,
+    getLkplookupJobInvoiceMethod,
+    getLkplookupJobQuantityType,
+    getLkplookupJobStatus,
+    getLkplookupJobType,
+    getLkplookupJobTypeWorkRecordType,
+    getLkplookupWorkRecordLevel,
+    getLkplookupPayrollRecordType,
+    getLkplookupJobWorkUnit,
   ],
   (
     lkplookupClassification,
@@ -200,6 +218,15 @@ export const areLookupsLoading = createSelector(
     lkplookupPlanType,
     lkplookupPlanStatus,
     lkplookupSupplyContractType,
+    lkplookupJobEventAction,
+    lkplookupJobInvoiceMethod,
+    lkplookupJobQuantityType,
+    lkplookupJobStatus,
+    lkplookupJobType,
+    lkplookupJobTypeWorkRecordType,
+    lkplookupWorkRecordLevel,
+    lkplookupPayrollRecordType,
+    lkplookupJobWorkUnit,
   ) => {
     const { isLoading: lookupClassificationIsLoading } = lkplookupClassification;
     const { isLoading: lookupClassificationGroupIsLoading } = lkplookupClassificationGroup;
@@ -266,6 +293,15 @@ export const areLookupsLoading = createSelector(
     const { isLoading: lookupPlanTypeIsLoading } = lkplookupPlanType;
     const { isLoading: lookupPlanStatusIsLoading } = lkplookupPlanStatus;
     const { isLoading: lookupSupplyContractTypeIsLoading } = lkplookupSupplyContractType;
+    const { isLoading: lookupJobEventActionIsLoading } = lkplookupJobEventAction;
+    const { isLoading: lookupJobInvoiceMethodIsLoading } = lkplookupJobInvoiceMethod;
+    const { isLoading: lookupJobQuantityTypeIsLoading } = lkplookupJobQuantityType;
+    const { isLoading: lookupJobStatusIsLoading } = lkplookupJobStatus;
+    const { isLoading: lookupJobTypeIsLoading } = lkplookupJobType;
+    const { isLoading: lookupJobTypeWorkRecordTypeIsLoading } = lkplookupJobTypeWorkRecordType;
+    const { isLoading: lookupWorkRecordLevelIsLoading } = lkplookupWorkRecordLevel;
+    const { isLoading: lookupPayrollRecordTypeIsLoading } = lkplookupPayrollRecordType;
+    const { isLoading: lookupJobWorkUnitIsLoading } = lkplookupJobWorkUnit;
 
     return (
       lookupClassificationIsLoading ||
@@ -333,6 +369,15 @@ export const areLookupsLoading = createSelector(
       lookupPlanTypeIsLoading ||
       lookupPlanStatusIsLoading ||
       lookupSupplyContractTypeIsLoading ||
+      lookupJobEventActionIsLoading ||
+      lookupJobInvoiceMethodIsLoading ||
+      lookupJobQuantityTypeIsLoading ||
+      lookupJobStatusIsLoading ||
+      lookupJobTypeIsLoading ||
+      lookupJobTypeWorkRecordTypeIsLoading ||
+      lookupWorkRecordLevelIsLoading ||
+      lookupPayrollRecordTypeIsLoading ||
+      lookupJobWorkUnitIsLoading ||
       false
     );
   },
@@ -406,6 +451,15 @@ export const areLookupsLoaded = createSelector(
     getLkplookupPlanType,
     getLkplookupPlanStatus,
     getLkplookupSupplyContractType,
+    getLkplookupJobEventAction,
+    getLkplookupJobInvoiceMethod,
+    getLkplookupJobQuantityType,
+    getLkplookupJobStatus,
+    getLkplookupJobType,
+    getLkplookupJobTypeWorkRecordType,
+    getLkplookupWorkRecordLevel,
+    getLkplookupPayrollRecordType,
+    getLkplookupJobWorkUnit,
   ],
   (
     lkplookupClassification,
@@ -473,6 +527,15 @@ export const areLookupsLoaded = createSelector(
     lkplookupPlanType,
     lkplookupPlanStatus,
     lkplookupSupplyContractType,
+    lkplookupJobEventAction,
+    lkplookupJobInvoiceMethod,
+    lkplookupJobQuantityType,
+    lkplookupJobStatus,
+    lkplookupJobType,
+    lkplookupJobTypeWorkRecordType,
+    lkplookupWorkRecordLevel,
+    lkplookupPayrollRecordType,
+    lkplookupJobWorkUnit,
   ) => {
     const { isLoaded: lookupClassificationIsLoaded } = lkplookupClassification;
     const { isLoaded: lookupClassificationGroupIsLoaded } = lkplookupClassificationGroup;
@@ -539,6 +602,15 @@ export const areLookupsLoaded = createSelector(
     const { isLoaded: lookupPlanTypeIsLoaded } = lkplookupPlanType;
     const { isLoaded: lookupPlanStatusIsLoaded } = lkplookupPlanStatus;
     const { isLoaded: lookupSupplyContractTypeIsLoaded } = lkplookupSupplyContractType;
+    const { isLoaded: lookupJobEventActionIsLoaded } = lkplookupJobEventAction;
+    const { isLoaded: lookupJobInvoiceMethodIsLoaded } = lkplookupJobInvoiceMethod;
+    const { isLoaded: lookupJobQuantityTypeIsLoaded } = lkplookupJobQuantityType;
+    const { isLoaded: lookupJobStatusIsLoaded } = lkplookupJobStatus;
+    const { isLoaded: lookupJobTypeIsLoaded } = lkplookupJobType;
+    const { isLoaded: lookupJobTypeWorkRecordTypeIsLoaded } = lkplookupJobTypeWorkRecordType;
+    const { isLoaded: lookupWorkRecordLevelIsLoaded } = lkplookupWorkRecordLevel;
+    const { isLoaded: lookupPayrollRecordTypeIsLoaded } = lkplookupPayrollRecordType;
+    const { isLoaded: lookupJobWorkUnitIsLoaded } = lkplookupJobWorkUnit;
 
     return (
       lookupClassificationIsLoaded ||
@@ -606,6 +678,15 @@ export const areLookupsLoaded = createSelector(
       lookupPlanTypeIsLoaded ||
       lookupPlanStatusIsLoaded ||
       lookupSupplyContractTypeIsLoaded ||
+      lookupJobEventActionIsLoaded ||
+      lookupJobInvoiceMethodIsLoaded ||
+      lookupJobQuantityTypeIsLoaded ||
+      lookupJobStatusIsLoaded ||
+      lookupJobTypeIsLoaded ||
+      lookupJobTypeWorkRecordTypeIsLoaded ||
+      lookupWorkRecordLevelIsLoaded ||
+      lookupPayrollRecordTypeIsLoaded ||
+      lookupJobWorkUnitIsLoaded ||
       false
     );
   },

package/src/selectors/lookupWorkRecordLevelSelector.js

@@ -0,0 +1,65 @@
+import { createSelector } from 'reselect';
+import isEmpty from 'lodash/isEmpty';
+import {isValid, format} from 'date-fns';
+import isNil from 'lodash/isNil';
+import has from 'lodash/has';
+
+const viewDateFormat = 'dd/MM/yyyy';
+
+export const getlookupWorkRecordLevelEntity = state => state.entities.lookupWorkRecordLevel;
+
+export const getlookupWorkRecordLevelEntityMeta = createSelector(
+  [getlookupWorkRecordLevelEntity],
+  reference => {
+    const { isLoading, isLoaded, hasError, error } = reference;
+    return {
+      isLoading,
+      isLoaded,
+      hasError,
+      error,
+    };
+  },
+);
+
+export const getlookupWorkRecordLevelEntityData = createSelector(
+  [getlookupWorkRecordLevelEntity],
+  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 =
+          !isEmpty(d.effectiveToDate) && isValid(new Date(d.effectiveToDate))
+            ? format(new Date(d.effectiveToDate), viewDateFormat)
+            : '';
+        fromDate =
+          !isEmpty(d.effectiveFromDate) &&
+          isValid(new Date(d.effectiveFromDate))
+            ? format(new Date(d.effectiveFromDate), viewDateFormat)
+            : '';
+        const seperator = toDate ? '-' : '';
+        fromToDate = `${fromDate} ${seperator} ${toDate}`;
+      }
+      
+      return {
+        ...d,
+        ...(hasDates && {
+          fromDate,
+          toDate,
+          fromTo,  
+        })              
+      };
+    });
+    
+    return formattedData;
+  },
+);
+