Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· OpenAIAi2 WildChat-4.8M (AI2)

The following code is a ngrx 4 reducer could you make it compatible for ngrx 16 so it…

  1. User

    The following code is a ngrx 4 reducer could you make it compatible for ngrx 16 so it works with createReducer()

    export function reducer(state = initialState, action: nitNetwork.Actions | descriptor.Actions): State { switch (action.type) { case nitNetwork.ActionTypes.REQUEST_NIT_TREE: return Object.assign({}, state, { item: null, });

    case nitNetwork.ActionTypes.REQUEST_NIT_NETWORK_DETAIL:
      return Object.assign({}, state, {
        isLoading: true,
      });
    case nitNetwork.ActionTypes.REQUEST_NIT_NETWORK_DETAIL_FAIL:
      return Object.assign({}, state, {
        isLoading: false,
      });
    
    case nitNetwork.ActionTypes.REFRESH_NIT_NETWORK:
      return {
        ...state,
        isLoading: false,
        item: action.payload
      };
    
    case nitNetwork.ActionTypes.REQUEST_NIT_NETWORK_DETAIL_SUCCESS:
      return Object.assign({}, state, {
        isLoading: false,
        item: action.payload.detail,
        descriptors: action.payload.descriptors
      });
    
    case nitNetwork.ActionTypes.SELECT_NEW_NIT_NETWORK:
      return Object.assign({}, state, {
        item: action.payload,
        descriptors: null
      });
    
    case nitNetwork.ActionTypes.ADD_NIT_NETWORK:
    case nitNetwork.ActionTypes.UPDATE_NIT_NETWORK:
    case nitNetwork.ActionTypes.DELETE_NIT_NETWORK:
      return Object.assign({}, state, {
        isSaving: true
      });
    
    case nitNetwork.ActionTypes.ADD_NIT_NETWORK_SUCCESS:
      const tempPayload: any = action.payload;
      return Object.assign({}, state, {
        isSaving: false,
        item: tempPayload.nitNetworkDetail.detail,
        descriptors: tempPayload.nitNetworkDetail.descriptors
      });
    
    case nitNetwork.ActionTypes.ADD_NIT_NETWORK_FAIL:
    case nitNetwork.ActionTypes.UPDATE_NIT_NETWORK_FAIL:
    case nitNetwork.ActionTypes.DELETE_NIT_NETWORK_FAIL:
      return Object.assign({}, state, {
        isSaving: false
      });
    
    case nitNetwork.ActionTypes.UPDATE_NIT_NETWORK_SUCCESS:
      const tempPayload1: any = action.payload;
      return Object.assign({}, state, {
        isSaving: false,
        item: tempPayload1.nitNetworkDetail.detail,
        descriptors: tempPayload1.nitNetworkDetail.descriptors
      });
    
    case nitNetwork.ActionTypes.DELETE_NIT_NETWORK_SUCCESS:
      return Object.assign({}, state, {
        isSaving: false,
        item: null
      });
    
    case descriptor.ActionTypes.ADD_DESCRIPTOR_SUCCESS:
    case descriptor.ActionTypes.UPDATE_DESCRIPTOR_SUCCESS:
      if (action.payload.targetType === 'NitTable' && action.payload.targetId === state.item.id) {
        return Object.assign({}, state, {
          descriptors: state.descriptors.set(action.payload.id, action.payload)
        });
      }
    
      return state;
    
    case descriptor.ActionTypes.DELETE_DESCRIPTOR_SUCCESS:
      if (action.payload.targetType === 'NitTable' && action.payload.targetId === state.item.id) {
        return Object.assign({}, state, {
          descriptors: state.descriptors.delete(action.payload.id)
        });
      }
      return state;
    
    case descriptor.ActionTypes.MOVE_DESCRIPTOR_UP_SUCCESS:
    case descriptor.ActionTypes.MOVE_DESCRIPTOR_DOWN_SUCCESS:
      if (action.payload.targetType === 'NitTable' && action.payload.targetId === state.item.id) {
        let descriptorsPayload: Descriptor[] = action['descriptors'];
        let newDescriptors = Map(descriptorsPayload.map(d => [d.id, d]));
        return {
          ...state,
          descriptors: newDescriptors as Map<string, Descriptor>,
          isSaving: false,
        };
      }
      return state;
    
    default:
      return state;
    

    } }

  2. Assistant

    import { createReducer, on } from "@ngrx/store"; import * as nitNetwork from "<path-to-nitNetwork.actions>"; import * as descriptor from "<path-to-descriptor.actions>"; import { Map } from "immutable";

    export const initialState = { item: null, isLoading: false, descriptors: null, isSaving: false };

    export const reducer = createReducer( initialState, on(nitNetwork.requestNitTree, (state) => ({ ...state, item: null })), on(nitNetwork.requestNitNetworkDetail, (state) => ({ ...state, isLoading: true })), on(nitNetwork.requestNitNetworkDetailFail, (state) => ({ ...state, isLoading: false })), on(nitNetwork.refreshNitNetwork, (state, { payload }) => ({ ...state, isLoading: false, item: payload })), on(nitNetwork.requestNitNetworkDetailSuccess, (state, { payload }) => ({ ...state, isLoading: false, item: payload.detail, descriptors: payload.descriptors })), on(nitNetwork.selectNewNitNetwork, (state, { payload }) => ({ ...state, item: payload, descriptors: null })), on(nitNetwork.addNitNetwork, nitNetwork.updateNitNetwork, nitNetwork.deleteNitNetwork, (state) => ({ ...state, isSaving: true })), on(nitNetwork.addNitNetworkSuccess, (state, { payload }) => ({ ...state, isSaving: false, item: payload.nitNetworkDetail.detail, descriptors: payload.nitNetworkDetail.descriptors })), on(nitNetwork.addNitNetworkFail, nitNetwork.updateNitNetworkFail, nitNetwork.deleteNitNetworkFail, (state) => ({ ...state, isSaving: false })), on(nitNetwork.updateNitNetworkSuccess, (state, { payload }) => ({ ...state, isSaving: false, item: payload.nitNetworkDetail.detail, descriptors: payload.nitNetworkDetail.descriptors })), on(nitNetwork.deleteNitNetworkSuccess, (state) => ({ ...state, isSaving: false, item: null })), on(descriptor.addDescriptorSuccess, descriptor.updateDescriptorSuccess, (state, { payload }) => { if (payload.targetType === 'NitTable' && payload.targetId === state.item.id) { const descriptors = state.descriptors.set(payload.id, payload); return { ...state, descriptors }; } return state; }), on(descriptor.deleteDescriptorSuccess, (state, { payload }) => { if (payload.targetType === 'NitTable' && payload.targetId === state.item.id) { const descriptors = state.descriptors.delete(payload.id); return { ...state, descriptors }; } return state; }), on( descriptor.moveDescriptorUpSuccess, descriptor.moveDescriptorDownSuccess, (state, { descriptors }) => { if ( descriptors[0].targetType === "NitTable" && descriptors[0].targetId === state.item.id ) { const newDescriptors = Map( descriptors.map((d) => [d.id, d]) ); return { ...state, descriptors: newDescriptors as Map<string, Descriptor>, isSaving: false, }; } return state; } ) );

  3. User

    The following code is a ngrx 4 reducer could you make it compatible for ngrx 16 so it works with createReducer()

    export function reducer(state = initialState, action: sdtService.Actions | descriptor.Actions): State { switch (action.type) { case sdtService.ActionTypes.REQUEST_SDT_SERVICE_DETAILS: return Object.assign({}, state, { isLoading: true, });

    case sdtService.ActionTypes.REQUEST_SDT_SERVICE_DETAILS_FAIL:
      return Object.assign({}, state, {
        isLoading: false,
      });
    
    case sdtService.ActionTypes.REQUEST_SDT_SERVICE_DETAILS_SUCCESS:
      return Object.assign({}, state, {
        isLoading: false,
        item: action.payload.detail,
        descriptors: action.payload.descriptors
      });
    
    case descriptor.ActionTypes.ADD_DESCRIPTOR_SUCCESS:
    case descriptor.ActionTypes.UPDATE_DESCRIPTOR_SUCCESS:
      if (action.payload.targetType === 'SdtService' && action.payload.targetId === state.item.id) {
        return Object.assign({}, state, {
          descriptors: state.descriptors.set(action.payload.id, action.payload)
        });
      }
      return state;
    
    case descriptor.ActionTypes.DELETE_DESCRIPTOR_SUCCESS:
      if (action.payload.targetType === 'SdtService' && action.payload.targetId === state.item.id) {
        return Object.assign({}, state, {
          descriptors: state.descriptors.delete(action.payload.id)
        });
      }
      return state;
    case descriptor.ActionTypes.MOVE_DESCRIPTOR_UP_SUCCESS:
    case descriptor.ActionTypes.MOVE_DESCRIPTOR_DOWN_SUCCESS:
      if (action.payload.targetType === 'SdtService' && action.payload.targetId === state.item.id) {
        let descriptorsPayload: Descriptor[] = action['descriptors'];
        let newDescriptors = Map(descriptorsPayload.map(d => [d.id, d]));
        return {
          ...state,
          descriptors: newDescriptors as Map<string, Descriptor>,
          isSaving: false,
        };
      }
      return state;
    
    default:
      return state;
    

    } }

  4. Assistant

    import { createReducer, on } from "@ngrx/store"; import * as sdtService from "<path-to-sdtService.actions>"; import * as descriptor from "<path-to-descriptor.actions>"; import { Map } from "immutable";

    export const initialState = { isLoading: false, item: null, descriptors: null, isSaving: false, };

    export const reducer = createReducer( initialState, on(sdtService.requestSdtServiceDetails, (state) => ({ ...state, isLoading: true })), on(sdtService.requestSdtServiceDetailsFail, (state) => ({ ...state, isLoading: false })), on(sdtService.requestSdtServiceDetailsSuccess, (state, { payload }) => ({ ...state, isLoading: false, item: payload.detail, descriptors: payload.descriptors })), on(descriptor.addDescriptorSuccess, descriptor.updateDescriptorSuccess, (state, { payload }) => { if (payload.targetType === 'SdtService' && payload.targetId === state.item.id) { const descriptors = state.descriptors.set(payload.id, payload); return { ...state, descriptors }; } return state; }), on(descriptor.deleteDescriptorSuccess, (state, { payload }) => { if (payload.targetType === 'SdtService' && payload.targetId === state.item.id) { const descriptors = state.descriptors.delete(payload.id); return { ...state, descriptors }; } return state; }), on( descriptor.moveDescriptorUpSuccess, descriptor.moveDescriptorDownSuccess, (state, { descriptors }) => { if ( descriptors[0].targetType === "SdtService" && descriptors[0].targetId === state.item.id ) { const newDescriptors = Map( descriptors.map((d) => [d.id, d]) ); return { ...state, descriptors: newDescriptors as Map<string, Descriptor>, isSaving: false, }; } return state; } ) );

  5. User

    The following code is a ngrx 4 reducer could you make it compatible for ngrx 16 so it works with createReducer()

    export function reducer(state = initialState, action: actions.Actions): State { switch (action.type) { case actions.ActionTypes.SELECT_LOGICAL_SERVICE: return Object.assign({}, state, { selectedService: action.payload, }); case actions.ActionTypes.UNSELECT_LOGICAL_SERVICE: return Object.assign({}, state, { selectedService: null, });

    case actions.ActionTypes.ADD_LOGICAL_SERVICE_FAIL:
      return Object.assign({}, state, {
        messages: [{
          severity: 'error',
          summary: 'Failed to add service',
          detail: action.payload
        }]
      });
    case actions.ActionTypes.ADD_LOGICAL_SERVICE_SUCCESS:
      let addDetailPayload = action.payload.detail;
    
      return Object.assign({}, state, {
        selectedService: addDetailPayload,
        logicalServices: state.logicalServices.set(addDetailPayload.id, addDetailPayload),
        messages: [{
          severity: 'success',
          summary: 'Info Message',
          detail: `Service ${addDetailPayload.alias} added`
        }]
      });
    
    case actions.ActionTypes.UPDATE_LOGICAL_SERVICE_FAIL:
      return Object.assign({}, state, {
        messages: [{
          severity: 'error',
          summary: 'Failed to update service',
          detail: action.payload
        }]
      });
    case actions.ActionTypes.UPDATE_LOGICAL_SERVICE_SUCCESS:
      let updateDetailPayload = action.payload.detail;
      return Object.assign({}, state, {
        selectedService: updateDetailPayload,
        logicalServices: state.logicalServices.set(updateDetailPayload.id, updateDetailPayload),
        messages: [{
          severity: 'success',
          summary: 'Info Message',
          detail: `Service ${updateDetailPayload.alias} updated`
        }]
      });
    
    case actions.ActionTypes.DELETE_LOGICAL_SERVICE_SUCCESS:
      delete action.payload.originalNetworkId;
      return Object.assign({}, state, {
        selectedService: null,
        logicalServices: state.logicalServices.delete(action.payload.id),
        messages: [{
          severity: 'success',
          summary: 'service deleted',
          detail: `Service ${action.payload.alias} deleted`
        }]
      });
    case actions.ActionTypes.DELETE_LOGICAL_SERVICE_FAIL:
      return Object.assign({}, state, {
        messages: [{
          severity: 'error',
          summary: 'Failed to delete service',
          detail: action.payload
        }]
      });
    case actions.ActionTypes.GET_RELATED_DATA:
      return Object.assign({}, state, {
        isLoading: true,
        relatedData: {}
      });
    
    case actions.ActionTypes.GET_LOGICAL_SERVICE_LIST:
      return Object.assign({}, state, {
        isLoading: true,
        selectedService: null,
        logicalServices: null,
        messages: null
      });
    case actions.ActionTypes.GET_LOGICAL_SERVICE_LIST_SUCCESS:
      return Object.assign({}, state, {
        isLoading: false,
        logicalServices: action.payload
      });
    case actions.ActionTypes.GET_LOGICAL_SERVICE_LIST_FAIL:
      return Object.assign({}, state, {
        isLoading: false,
        selectedService: null,
        messages: [{
          severity: 'error',
          summary: 'Failed to retrieve services',
          detail: action.payload
        }]
      });
    case actions.ActionTypes.GET_RELATED_DATA_FAIL:
      return Object.assign({}, state, {
        isLoading: false,
        relatedData: {}
      });
    case actions.ActionTypes.GET_RELATED_DATA_SUCCESS:
      return Object.assign({}, state, {
        isLoading: false,
        relatedData: action.payload
      });
    
    case actions.ActionTypes.ADD_LOGICAL_SERVICE:
      return Object.assign({}, state, {
        ...state,
        isSaving: true,
      });
    
    case actions.ActionTypes.SET_LOGICAL_SERVICE_TRANSPORT_STREAMS_FAIL:
    case actions.ActionTypes.SET_LOGICAL_SERVICE_LCN_OVERRIDES_FAIL:
      return Object.assign({}, state, {
        messages: [{
          severity: 'error',
          summary: 'Failed to update service',
          detail: action.payload
        }]
      });
    
    case actions.ActionTypes.SET_LOGICAL_SERVICE_LCN_OVERRIDES_SUCCESS:
      let logicalServiceWithNewLcnOverrides = Object.assign({}, state.logicalServices.get(action.payload.detail.id), {
        lcnOverridesCount: action.payload.detail.lcnOverridesCount
      });
    
      return Object.assign({}, state, {
        logicalServices: state.logicalServices.set(action.payload.detail.id, logicalServiceWithNewLcnOverrides),
        messages: [{
          severity: 'success',
          summary: 'Info Message',
          detail: `Service updated`
        }]
      });
    
    case actions.ActionTypes.SET_LOGICAL_SERVICE_TRANSPORT_STREAMS_SUCCESS:
      let logicalServiceWithNewTsIds = Object.assign({}, state.logicalServices.get(action.payload.id), {
        sdtTableCount: action.payload.sdtTableCount
      });
    
      return Object.assign({}, state, {
        logicalServices: state.logicalServices.set(action.payload.id, logicalServiceWithNewTsIds),
        messages: [{
          severity: 'success',
          summary: 'Info Message',
          detail: `Service updated`,
        }]
      });
    
    case actions.ActionTypes.CREATE_SCHEDULE_SERVICE_SUCCESS:
    case actions.ActionTypes.UPDATE_SCHEDULE_SERVICE_SUCCESS:
      let relatedData = Object.assign({}, state.relatedData, {
        providers: state.relatedData.providers.set(action.payload.providerId, action.payload.providerId)
      });
      return Object.assign({}, state, {
        relatedData: relatedData,
        messages: [{
          severity: 'success',
          summary: 'Info Message',
          detail: `Provider updated`
        }]
      });
    
    case actions.ActionTypes.CREATE_SCHEDULE_SERVICE_FAIL:
    case actions.ActionTypes.UPDATE_SCHEDULE_SERVICE_FAIL:
      return Object.assign({}, state, {
        messages: [{
          severity: 'error',
          summary: 'Failed to update service',
          detail: action.payload
        }]
      });
    
    case actions.ActionTypes.LOGICAL_SERVICE_DOES_NOT_EXIST:
      return Object.assign({}, state, {
        messages: [{
          severity: 'error',
          summary: 'Failed to display the page',
          detail: 'Logical service doesn\'t exist'
        }],
      });
    
    default:
      return state;
    

    } }

  6. Assistant

    import { createReducer, on } from "@ngrx/store"; import * as actions from ""; import { Map } from "immutable";

    export const initialState = { selectedService: null, isLoading: false, logicalServices: null, messages: null, relatedData: {}, isSaving: false };

    export const reducer = createReducer( initialState, on(actions.selectLogicalService, (state, { payload }) => ({ ...state, selectedService: payload })), on(actions.unselectLogicalService, (state) => ({ ...state, selectedService: null })), on(actions.addLogicalServiceFail, (state, { payload }) => ({ ...state, messages: [{ severity: 'error', summary: 'Failed to add service', detail: payload }] })), on(actions.addLogicalServiceSuccess, (state, { payload }) => { const addDetailPayload = payload.detail; const logicalServices = state.logicalServices.set(addDetailPayload.id, addDetailPayload);

    return {
      ...state,
      selectedService: addDetailPayload,
      logicalServices,
      messages: [{
        severity: 'success',
        summary: 'Info Message',
        detail: `Service ${addDetailPayload.alias} added`
      }]
    };
    

    }), on(actions.updateLogicalServiceFail, (state, { payload }) => ({ ...state, messages: [{ severity: 'error', summary: 'Failed to update service', detail: payload }] })), on(actions.updateLogicalServiceSuccess, (state, { payload }) => { const updateDetailPayload = payload.detail; const logicalServices = state.logicalServices.set(updateDetailPayload.id, updateDetailPayload);

    return {
      ...state,
      selectedService: updateDetailPayload,
      logicalServices,
      messages: [{
        severity: 'success',
        summary: 'Info Message',
        detail: `Service ${updateDetailPayload.alias} updated`
      }]
    };
    

    }), on(actions.deleteLogicalServiceSuccess, (state, { payload }) => { delete payload.originalNetworkId;

    const logicalServices = state.logicalServices.delete(payload.id);
    
    return {
      ...state,
      selectedService: null,
      logicalServices,
      messages: [{
        severity: 'success',
        summary: 'service deleted',
        detail: `Service ${payload.alias} deleted`
      }]
    };
    

    }), on(actions.deleteLogicalServiceFail, (state, { payload }) => ({ ...state, messages: [{ severity: 'error', summary: 'Failed to delete service', detail: payload }]