@omegabigdata/honoplay-redux-helper/Src/reducers/Training.js

honoplay-redux-helper

import {
  CREATE_TRAINING_FAILED,
  CREATE_TRAINING_SUCCESS,
  CREATING_TRAINING,
  FETCHING_TRAINING,
  FETCHING_TRAINING_LIST,
  FETCH_TRAINING_FAILED,
  FETCH_TRAINING_LIST_FAILED,
  FETCH_TRAINING_LIST_SUCCESS,
  FETCH_TRAINING_SUCCESS,
  UPDATE_TRAINING_FAILED,
  UPDATE_TRAINING_SUCCESS,
  UPDATING_TRAINING,
  FETCHING_TRAINING_BY_TRAININGSERIES_LIST,
  FETCH_TRAINING_BY_TRAININGSERIES_LIST_FAILED,
  FETCH_TRAINING_BY_TRAININGSERIES_LIST_SUCCESS
} from "../helpers/ActionTypes/Training";

const TRAINING_LIST_INITIAL_STATE = {
  isTrainingListLoading: false,
  TrainingList: null,
  errorTrainingList: null
};

const TRAINING_INITIAL_STATE = {
  isTrainingLoading: false,
  training: null,
  errorTraining: null
};

const CREATE_TRAINING_INITIAL_STATE = {
  isCreateTrainingLoading: false,
  createTraining: null,
  errorCreateTraining: null
};

const UPDATE_TRAINING_INITIAL_STATE = {
  isUpdateTrainingLoading: false,
  updateTraining: null,
  errorUpdateTraining: null
};

const TRAINING_LIST_BY_TRAININGSERIESID_INITIAL_STATE = {
  isTrainingListByTrainingSeriesIdLoading: false,
  TrainingListByTrainingSeriesId: null,
  errorTrainingListByTrainingSeriesId: null
};

export const trainingListByTrainingSeriesIdReducers = (
  state = TRAINING_LIST_BY_TRAININGSERIESID_INITIAL_STATE,
  action
) => {
  switch (action.type) {
    case FETCHING_TRAINING_BY_TRAININGSERIES_LIST:
      return {
        ...state,
        isTrainingListByTrainingSeriesIdLoading: true,
        errorTrainingListByTrainingSeriesId: null
      };
    case FETCH_TRAINING_BY_TRAININGSERIES_LIST_SUCCESS:
      return {
        ...state,
        isTrainingListByTrainingSeriesIdLoading: false,
        TrainingListByTrainingSeriesId: action.data
      };
    case FETCH_TRAINING_BY_TRAININGSERIES_LIST_FAILED:
      return {
        ...state,
        isTrainingListByTrainingSeriesIdLoading: false,
        errorTrainingListByTrainingSeriesId: action.data.error
      };
    default:
      return state;
  }
};

export const trainingListReducers = (
  state = TRAINING_LIST_INITIAL_STATE,
  action
) => {
  switch (action.type) {
    case FETCHING_TRAINING_LIST:
      return {
        ...state,
        isTrainingListLoading: true,
        errorTrainingList: null
      };
    case FETCH_TRAINING_LIST_SUCCESS:
      return {
        ...state,
        isTrainingListLoading: false,
        TrainingList: action.data
      };
    case FETCH_TRAINING_LIST_FAILED:
      return {
        ...state,
        isTrainingListLoading: false,
        errorTrainingList: action.data.error
      };
    default:
      return state;
  }
};

export const trainingReducers = (state = TRAINING_INITIAL_STATE, action) => {
  switch (action.type) {
    case FETCHING_TRAINING:
      return {
        ...state,
        isTrainingLoading: true,
        errorTraining: null
      };
    case FETCH_TRAINING_SUCCESS:
      return {
        ...state,
        isTrainingLoading: false,
        training: action.data
      };
    case FETCH_TRAINING_FAILED:
      return {
        ...state,
        isTrainingLoading: false,
        errorTraining: action.data.error
      };
    default:
      return state;
  }
};

export const createTrainingReducers = (
  state = CREATE_TRAINING_INITIAL_STATE,
  action
) => {
  switch (action.type) {
    case CREATING_TRAINING:
      return {
        ...state,
        isCreateTrainingLoading: true,
        errorCreateTraining: null
      };
    case CREATE_TRAINING_SUCCESS:
      return {
        ...state,
        isCreateTrainingLoading: false,
        createTraining: action.data
      };
    case CREATE_TRAINING_FAILED:
      return {
        ...state,
        isCreateTrainingLoading: false,
        errorCreateTraining: action.data.error
      };
    default:
      return state;
  }
};

export const updateTrainingReducers = (
  state = UPDATE_TRAINING_INITIAL_STATE,
  action
) => {
  switch (action.type) {
    case UPDATING_TRAINING:
      return {
        ...state,
        isUpdateTrainingLoading: true,
        errorUpdateTraining: null
      };
    case UPDATE_TRAINING_SUCCESS:
      return {
        ...state,
        isUpdateTrainingLoading: false,
        updateTraining: action.data
      };
    case UPDATE_TRAINING_FAILED:
      return {
        ...state,
        isUpdateTrainingLoading: false,
        errorUpdateTraining: action.data.error
      };
    default:
      return state;
  }
};