resources/assets/js/store/Job/jobReducer.ts - Code Metrics - Inspection of "Bump laravel/framework from 6.18.36 to 6.18.37" - GCTC-NTGC/TalentCloud - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — dev ( 10068f...94c023 )

unknown

created 2020-08-28 14:19 UTC

resources/assets/js/store/Job/jobReducer.ts A

↳ Parent: Project

Complexity

Total Complexity	2
Complexity/F	0

Size

Lines of Code	358
Function Count	0

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
wmc	2
eloc	279
mnd	2
bc	2
fnc	0
dl	0
loc	358
rs	10
bpm	0
cpm	0
noi	0
c	0
b	0
f	0

import { combineReducers } from "redux";
import { Job, Criteria, JobPosterKeyTask, Comment } from "../../models/types";
import {
  JobAction,
  FETCH_JOB_STARTED,
  FETCH_JOB_SUCCEEDED,
  FETCH_JOB_FAILED,
  UPDATE_JOB_SUCCEEDED,
  UPDATE_JOB_STARTED,
  UPDATE_JOB_FAILED,
  EDIT_JOB,
  CLEAR_JOB_EDIT,
  CREATE_JOB_SUCCEEDED,
  CREATE_JOB_STARTED,
  CREATE_JOB_FAILED,
  SET_SELECTED_JOB,
  FETCH_JOB_TASKS_SUCCEEDED,
  BATCH_UPDATE_JOB_TASKS_SUCCEEDED,
  FETCH_CRITERIA_SUCCEEDED,
  BATCH_UPDATE_CRITERIA_SUCCEEDED,
  SUBMIT_JOB_FOR_REVIEW_SUCCEEDED,
  SUBMIT_JOB_FOR_REVIEW_STARTED,
  SUBMIT_JOB_FOR_REVIEW_FAILED,
  FETCH_CRITERIA_STARTED,
  FETCH_CRITERIA_FAILED,
  BATCH_UPDATE_CRITERIA_FAILED,
  BATCH_UPDATE_CRITERIA_STARTED,
  FETCH_JOB_TASKS_STARTED,
  BATCH_UPDATE_JOB_TASKS_STARTED,
  FETCH_JOB_TASKS_FAILED,
  BATCH_UPDATE_JOB_TASKS_FAILED,
  CREATE_COMMENT_SUCCEEDED,
  FETCH_COMMENTS_SUCCEEDED,
  FETCH_JOB_INDEX_SUCCEEDED,
  FETCH_JOB_INDEX_STARTED,
  FETCH_JOB_INDEX_FAILED,
  FETCH_COMMENTS_STARTED,
  FETCH_COMMENTS_FAILED,
} from "./jobActions";
import {
  mapToObject,
  getId,
  deleteProperty,
  filterObjectProps,
} from "../../helpers/queries";

export interface EntityState {
  jobs: {
    byId: {
      [id: number]: Job;
    };
  };
  criteria: {
    byId: {
      [id: number]: Criteria;
    };
  };
  tasks: {
    byJobId: {
      [id: number]: JobPosterKeyTask[];
    };
  };
  comments: {
    byJobId: {
      [id: number]: Comment;
    };
  };
  jobEdits: {
    [id: number]: Job;
  };
}

export interface UiState {
  jobUpdating: {
    [id: number]: boolean;
  };
  jobIndexUpdating: boolean;
  criteriaUpdating: {
    [id: number]: boolean;
  };
  criteriaUpdatingByJob: {
    [jobId: number]: boolean;
  };
  tasksUpdatingByJob: {
    [jobId: number]: boolean;
  };
  creatingJob: boolean;
  selectedJobId: number | null;
  fetchingComments: boolean;
}

export interface JobState {
  entities: EntityState;
  ui: UiState;
}

export const initEntities = (): EntityState => ({
  jobs: { byId: {} },
  criteria: { byId: {} },
  tasks: { byJobId: {} },
  comments: { byJobId: {} },
  jobEdits: {},
});

export const initUi = (): UiState => ({
  jobUpdating: {},
  jobIndexUpdating: false,
  criteriaUpdating: {},
  criteriaUpdatingByJob: {},
  tasksUpdatingByJob: {},
  creatingJob: false,
  selectedJobId: null,
  fetchingComments: false,
});

export const initState = (): JobState => ({
  entities: initEntities(),
  ui: initUi(),
});

export const entitiesReducer = (
  state = initEntities(),
  action: JobAction,
): EntityState => {
  switch (action.type) {
    case FETCH_JOB_SUCCEEDED:
      return {
        ...state,
        jobs: {
          byId: {
            ...state.jobs.byId,
            [action.payload.job.id]: action.payload.job,
          },
        },
        criteria: {
          byId: {
            ...filterObjectProps<Criteria>(
              state.criteria.byId,
              (criteria): boolean => criteria.job_poster_id !== action.meta.id,
            ),
            ...mapToObject(action.payload.criteria, getId),
          },
        },
      };
    case FETCH_JOB_INDEX_SUCCEEDED:
      return {
        ...state,
        jobs: {
          byId: {
            ...state.jobs.byId,
            ...mapToObject(action.payload.jobs, getId),
          },
        },
      };
    case CREATE_JOB_SUCCEEDED:
      return {
        ...state,
        jobs: {
          byId: {
            ...state.jobs.byId,
            [action.payload.id]: action.payload,
          },
        },
      };
    case UPDATE_JOB_SUCCEEDED:
    case SUBMIT_JOB_FOR_REVIEW_SUCCEEDED:
      return {
        ...state,
        jobs: {
          byId: {
            ...state.jobs.byId,
            [action.meta.id]: action.payload,
          },
        },
      };
    case EDIT_JOB:
      return {
        ...state,
        jobEdits: {
          ...state.jobEdits,
          [action.payload.id]: action.payload,
        },
      };
    case CLEAR_JOB_EDIT:
      return {
        ...state,
        jobEdits: deleteProperty(state.jobEdits, action.payload),
      };
    case FETCH_JOB_TASKS_SUCCEEDED:
    case BATCH_UPDATE_JOB_TASKS_SUCCEEDED:
      return {
        ...state,
        tasks: {
          byJobId: {
            ...state.tasks.byJobId,
            [action.meta.jobId]: action.payload,
          },
        },
      };
    case FETCH_CRITERIA_SUCCEEDED:
    case BATCH_UPDATE_CRITERIA_SUCCEEDED:
      return {
        ...state,
        criteria: {
          byId: {
            ...filterObjectProps<Criteria>(
              state.criteria.byId,
              (criteria): boolean =>
                criteria.job_poster_id !== action.meta.jobId,
            ),
            ...mapToObject(action.payload, getId),
          },
        },
      };
    case FETCH_COMMENTS_SUCCEEDED:
      return {
        ...state,
        comments: {
          byJobId: {
            ...state.comments.byJobId,
            ...mapToObject(action.payload, getId),
          },
        },
      };
    case CREATE_COMMENT_SUCCEEDED:
      return {
        ...state,
        comments: {
          byJobId: {
            ...state.comments.byJobId,
            [action.payload.id]: action.payload,
          },
        },
      };
    default:
      return state;
  }
};

export const uiReducer = (state = initUi(), action: JobAction): UiState => {
  switch (action.type) {
    case CREATE_JOB_STARTED:
      return {
        ...state,
        creatingJob: true,
      };
    case CREATE_JOB_SUCCEEDED:
      return {
        ...state,
        creatingJob: false,
      };
    case CREATE_JOB_FAILED:
      return {
        ...state,
        creatingJob: false,
      };
    case FETCH_JOB_STARTED:
    case UPDATE_JOB_STARTED:
    case SUBMIT_JOB_FOR_REVIEW_STARTED:
      return {
        ...state,
        jobUpdating: {
          ...state.jobUpdating,
          [action.meta.id]: true,
        },
      };
    case FETCH_JOB_INDEX_STARTED:
      return {
        ...state,
        jobIndexUpdating: true,
      };
    case FETCH_JOB_SUCCEEDED:
    case FETCH_JOB_FAILED:
    case UPDATE_JOB_FAILED:
    case UPDATE_JOB_SUCCEEDED:
    case SUBMIT_JOB_FOR_REVIEW_SUCCEEDED:
    case SUBMIT_JOB_FOR_REVIEW_FAILED:
      return {
        ...state,
        jobUpdating: {
          ...state.jobUpdating,
          [action.meta.id]: false,
        },
      };
    case FETCH_JOB_INDEX_SUCCEEDED:
    case FETCH_JOB_INDEX_FAILED:
      return {
        ...state,
        jobIndexUpdating: false,
      };
    case SET_SELECTED_JOB:
      return {
        ...state,
        selectedJobId: action.payload.jobId,
      };
    case FETCH_JOB_TASKS_STARTED:
    case BATCH_UPDATE_JOB_TASKS_STARTED:
      return {
        ...state,
        tasksUpdatingByJob: {
          ...state.tasksUpdatingByJob,
          [action.meta.jobId]: true,
        },
      };
    case FETCH_JOB_TASKS_FAILED:
    case FETCH_JOB_TASKS_SUCCEEDED:
    case BATCH_UPDATE_JOB_TASKS_FAILED:
    case BATCH_UPDATE_JOB_TASKS_SUCCEEDED:
      return {
        ...state,
        tasksUpdatingByJob: {
          ...state.tasksUpdatingByJob,
          [action.meta.jobId]: false,
        },
      };
    case FETCH_CRITERIA_STARTED:
    case BATCH_UPDATE_CRITERIA_STARTED:
      return {
        ...state,
        criteriaUpdatingByJob: {
          ...state.criteriaUpdatingByJob,
          [action.meta.jobId]: true,
        },
      };
    case FETCH_CRITERIA_FAILED:
    case FETCH_CRITERIA_SUCCEEDED:
    case BATCH_UPDATE_CRITERIA_FAILED:
    case BATCH_UPDATE_CRITERIA_SUCCEEDED:
      return {
        ...state,
        criteriaUpdatingByJob: {
          ...state.criteriaUpdatingByJob,
          [action.meta.jobId]: false,
        },
      };
    case FETCH_COMMENTS_STARTED:
      return {
        ...state,
        fetchingComments: true,
      };
    case FETCH_COMMENTS_SUCCEEDED:
    case FETCH_COMMENTS_FAILED:
      return {
        ...state,
        fetchingComments: false,
      };
    default:
      return state;
  }
};

export const jobsReducer = combineReducers({
  entities: entitiesReducer,
  ui: uiReducer,
});

export default jobsReducer;


1			import { combineReducers } from "redux";
2			import { Job, Criteria, JobPosterKeyTask, Comment } from "../../models/types";
3			import {
4			JobAction,
5			FETCH_JOB_STARTED,
6			FETCH_JOB_SUCCEEDED,
7			FETCH_JOB_FAILED,
8			UPDATE_JOB_SUCCEEDED,
9			UPDATE_JOB_STARTED,
10			UPDATE_JOB_FAILED,
11			EDIT_JOB,
12			CLEAR_JOB_EDIT,
13			CREATE_JOB_SUCCEEDED,
14			CREATE_JOB_STARTED,
15			CREATE_JOB_FAILED,
16			SET_SELECTED_JOB,
17			FETCH_JOB_TASKS_SUCCEEDED,
18			BATCH_UPDATE_JOB_TASKS_SUCCEEDED,
19			FETCH_CRITERIA_SUCCEEDED,
20			BATCH_UPDATE_CRITERIA_SUCCEEDED,
21			SUBMIT_JOB_FOR_REVIEW_SUCCEEDED,
22			SUBMIT_JOB_FOR_REVIEW_STARTED,
23			SUBMIT_JOB_FOR_REVIEW_FAILED,
24			FETCH_CRITERIA_STARTED,
25			FETCH_CRITERIA_FAILED,
26			BATCH_UPDATE_CRITERIA_FAILED,
27			BATCH_UPDATE_CRITERIA_STARTED,
28			FETCH_JOB_TASKS_STARTED,
29			BATCH_UPDATE_JOB_TASKS_STARTED,
30			FETCH_JOB_TASKS_FAILED,
31			BATCH_UPDATE_JOB_TASKS_FAILED,
32			CREATE_COMMENT_SUCCEEDED,
33			FETCH_COMMENTS_SUCCEEDED,
34			FETCH_JOB_INDEX_SUCCEEDED,
35			FETCH_JOB_INDEX_STARTED,
36			FETCH_JOB_INDEX_FAILED,
37			FETCH_COMMENTS_STARTED,
38			FETCH_COMMENTS_FAILED,
39			} from "./jobActions";
40			import {
41			mapToObject,
42			getId,
43			deleteProperty,
44			filterObjectProps,
45			} from "../../helpers/queries";
46
47			export interface EntityState {
48			jobs: {
49			byId: {
50			[id: number]: Job;
51			};
52			};
53			criteria: {
54			byId: {
55			[id: number]: Criteria;
56			};
57			};
58			tasks: {
59			byJobId: {
60			[id: number]: JobPosterKeyTask[];
61			};
62			};
63			comments: {
64			byJobId: {
65			[id: number]: Comment;
66			};
67			};
68			jobEdits: {
69			[id: number]: Job;
70			};
71			}
72
73			export interface UiState {
74			jobUpdating: {
75			[id: number]: boolean;
76			};
77			jobIndexUpdating: boolean;
78			criteriaUpdating: {
79			[id: number]: boolean;
80			};
81			criteriaUpdatingByJob: {
82			[jobId: number]: boolean;
83			};
84			tasksUpdatingByJob: {
85			[jobId: number]: boolean;
86			};
87			creatingJob: boolean;
88			selectedJobId: number \| null;
89			fetchingComments: boolean;
90			}
91
92			export interface JobState {
93			entities: EntityState;
94			ui: UiState;
95			}
96
97			export const initEntities = (): EntityState => ({
98			jobs: { byId: {} },
99			criteria: { byId: {} },
100			tasks: { byJobId: {} },
101			comments: { byJobId: {} },
102			jobEdits: {},
103			});
104
105			export const initUi = (): UiState => ({
106			jobUpdating: {},
107			jobIndexUpdating: false,
108			criteriaUpdating: {},
109			criteriaUpdatingByJob: {},
110			tasksUpdatingByJob: {},
111			creatingJob: false,
112			selectedJobId: null,
113			fetchingComments: false,
114			});
115
116			export const initState = (): JobState => ({
117			entities: initEntities(),
118			ui: initUi(),
119			});
120
121			export const entitiesReducer = (
122			state = initEntities(),
123			action: JobAction,
124			): EntityState => {
125			switch (action.type) {
126			case FETCH_JOB_SUCCEEDED:
127			return {
128			...state,
129			jobs: {
130			byId: {
131			...state.jobs.byId,
132			[action.payload.job.id]: action.payload.job,
133			},
134			},
135			criteria: {
136			byId: {
137			...filterObjectProps<Criteria>(
138			state.criteria.byId,
139			(criteria): boolean => criteria.job_poster_id !== action.meta.id,
140			),
141			...mapToObject(action.payload.criteria, getId),
142			},
143			},
144			};
145			case FETCH_JOB_INDEX_SUCCEEDED:
146			return {
147			...state,
148			jobs: {
149			byId: {
150			...state.jobs.byId,
151			...mapToObject(action.payload.jobs, getId),
152			},
153			},
154			};
155			case CREATE_JOB_SUCCEEDED:
156			return {
157			...state,
158			jobs: {
159			byId: {
160			...state.jobs.byId,
161			[action.payload.id]: action.payload,
162			},
163			},
164			};
165			case UPDATE_JOB_SUCCEEDED:
166			case SUBMIT_JOB_FOR_REVIEW_SUCCEEDED:
167			return {
168			...state,
169			jobs: {
170			byId: {
171			...state.jobs.byId,
172			[action.meta.id]: action.payload,
173			},
174			},
175			};
176			case EDIT_JOB:
177			return {
178			...state,
179			jobEdits: {
180			...state.jobEdits,
181			[action.payload.id]: action.payload,
182			},
183			};
184			case CLEAR_JOB_EDIT:
185			return {
186			...state,
187			jobEdits: deleteProperty(state.jobEdits, action.payload),
188			};
189			case FETCH_JOB_TASKS_SUCCEEDED:
190			case BATCH_UPDATE_JOB_TASKS_SUCCEEDED:
191			return {
192			...state,
193			tasks: {
194			byJobId: {
195			...state.tasks.byJobId,
196			[action.meta.jobId]: action.payload,
197			},
198			},
199			};
200			case FETCH_CRITERIA_SUCCEEDED:
201			case BATCH_UPDATE_CRITERIA_SUCCEEDED:
202			return {
203			...state,
204			criteria: {
205			byId: {
206			...filterObjectProps<Criteria>(
207			state.criteria.byId,
208			(criteria): boolean =>
209			criteria.job_poster_id !== action.meta.jobId,
210			),
211			...mapToObject(action.payload, getId),
212			},
213			},
214			};
215			case FETCH_COMMENTS_SUCCEEDED:
216			return {
217			...state,
218			comments: {
219			byJobId: {
220			...state.comments.byJobId,
221			...mapToObject(action.payload, getId),
222			},
223			},
224			};
225			case CREATE_COMMENT_SUCCEEDED:
226			return {
227			...state,
228			comments: {
229			byJobId: {
230			...state.comments.byJobId,
231			[action.payload.id]: action.payload,
232			},
233			},
234			};
235			default:
236			return state;
237			}
238			};
239
240			export const uiReducer = (state = initUi(), action: JobAction): UiState => {
241			switch (action.type) {
242			case CREATE_JOB_STARTED:
243			return {
244			...state,
245			creatingJob: true,
246			};
247			case CREATE_JOB_SUCCEEDED:
248			return {
249			...state,
250			creatingJob: false,
251			};
252			case CREATE_JOB_FAILED:
253			return {
254			...state,
255			creatingJob: false,
256			};
257			case FETCH_JOB_STARTED:
258			case UPDATE_JOB_STARTED:
259			case SUBMIT_JOB_FOR_REVIEW_STARTED:
260			return {
261			...state,
262			jobUpdating: {
263			...state.jobUpdating,
264			[action.meta.id]: true,
265			},
266			};
267			case FETCH_JOB_INDEX_STARTED:
268			return {
269			...state,
270			jobIndexUpdating: true,
271			};
272			case FETCH_JOB_SUCCEEDED:
273			case FETCH_JOB_FAILED:
274			case UPDATE_JOB_FAILED:
275			case UPDATE_JOB_SUCCEEDED:
276			case SUBMIT_JOB_FOR_REVIEW_SUCCEEDED:
277			case SUBMIT_JOB_FOR_REVIEW_FAILED:
278			return {
279			...state,
280			jobUpdating: {
281			...state.jobUpdating,
282			[action.meta.id]: false,
283			},
284			};
285			case FETCH_JOB_INDEX_SUCCEEDED:
286			case FETCH_JOB_INDEX_FAILED:
287			return {
288			...state,
289			jobIndexUpdating: false,
290			};
291			case SET_SELECTED_JOB:
292			return {
293			...state,
294			selectedJobId: action.payload.jobId,
295			};
296			case FETCH_JOB_TASKS_STARTED:
297			case BATCH_UPDATE_JOB_TASKS_STARTED:
298			return {
299			...state,
300			tasksUpdatingByJob: {
301			...state.tasksUpdatingByJob,
302			[action.meta.jobId]: true,
303			},
304			};
305			case FETCH_JOB_TASKS_FAILED:
306			case FETCH_JOB_TASKS_SUCCEEDED:
307			case BATCH_UPDATE_JOB_TASKS_FAILED:
308			case BATCH_UPDATE_JOB_TASKS_SUCCEEDED:
309			return {
310			...state,
311			tasksUpdatingByJob: {
312			...state.tasksUpdatingByJob,
313			[action.meta.jobId]: false,
314			},
315			};
316			case FETCH_CRITERIA_STARTED:
317			case BATCH_UPDATE_CRITERIA_STARTED:
318			return {
319			...state,
320			criteriaUpdatingByJob: {
321			...state.criteriaUpdatingByJob,
322			[action.meta.jobId]: true,
323			},
324			};
325			case FETCH_CRITERIA_FAILED:
326			case FETCH_CRITERIA_SUCCEEDED:
327			case BATCH_UPDATE_CRITERIA_FAILED:
328			case BATCH_UPDATE_CRITERIA_SUCCEEDED:
329			return {
330			...state,
331			criteriaUpdatingByJob: {
332			...state.criteriaUpdatingByJob,
333			[action.meta.jobId]: false,
334			},
335			};
336			case FETCH_COMMENTS_STARTED:
337			return {
338			...state,
339			fetchingComments: true,
340			};
341			case FETCH_COMMENTS_SUCCEEDED:
342			case FETCH_COMMENTS_FAILED:
343			return {
344			...state,
345			fetchingComments: false,
346			};
347			default:
348			return state;
349			}
350			};
351
352			export const jobsReducer = combineReducers({
353			entities: entitiesReducer,
354			ui: uiReducer,
355			});
356
357			export default jobsReducer;
358

GCTC-NTGC / TalentCloud

Push — dev ( 10068f...94c023 )

resources/assets/js/store/Job/jobReducer.ts A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like