Summary Table

Categories Total Count
PII 0
URL 0
DNS 0
EKL 0
IP 0
PORT 0
VsID 0
CF 0
AI 0
VPD 0
PL 0
Other 0

File Content

import { PatientActionTypes, PatientActions } from '../actions/patient.action';
import { PatientState } from '../models/state';
import { Patient, FilterOps } from '../models/patientModels';
import * as init from './init';
import * as _ from 'lodash';

export function patientReducer(state: PatientState = init.initialPatientState, action: PatientActions): PatientState {

switch ( action.type ) {


// add patient(s) to queue if they're not already there
case PatientActionTypes.AddToPatientQueue: {
return {...state, patientQueue: [...state.patientQueue, ...action.payload.filter(itm => {
return state.patientQueue.findIndex(existingItm => itm.patientId === existingItm.patientId) === -1;
}) ]};
}


// remove patient from queue & clear selected patient if it was the removed patient
case PatientActionTypes.RemFromPatientQueue: {
if (state.selectedPatient.data.identity && action.payload.patientId === state.selectedPatient.data.identity.patientId) {
return {...state,
patientQueue: state.patientQueue.filter(patient => patient.patientId !== action.payload.patientId),
selectedPatient: {data: {}, params: state.selectedPatient.params}
};
} else {
return {...state, patientQueue: state.patientQueue.filter(patient => patient.patientId !== action.payload.patientId)};
}
}


// remove all items from the patient queue
case PatientActionTypes.ClearPatientQueue: {
return {...state, patientQueue: [], selectedPatient: {data: {}, params: state.selectedPatient.params}};
}


// set the selected patient, clear out patient data,
// keep current query parameters, queue up requests for new data
// and set the queue trigger
case PatientActionTypes.SelectPatient: {
if (state.selectedPatient.data.identity && action.payload.patientId === state.selectedPatient.data.identity.patientId ) {
return {...state};
} else {
const p: Patient = {
identity: action.payload
};

// grab all patient parameters to get the initial list of requests
const requests = Object.keys(init.initialPatientState.selectedPatient.params);

// remove vitals history from initial selection and clear vitals parameters
requests.splice(requests.indexOf('vitals'), 1);
const newParams = {...state.selectedPatient.params };
delete(newParams.vitals.filter.name);

return { ...state, selectedPatient: { data: p, params: {...newParams} },
requestQueue: [...requests], requestTrigger: (state.requestTrigger + requests.length) };
}
}

// update the patient data query parameters
case PatientActionTypes.SetQueryParameters: {

const params = {...state.selectedPatient.params};
params[action.payload.element] = {...action.payload.params};

return {...state,
selectedPatient: {
data: state.selectedPatient.data,
params: {...params}
},
requestQueue: [...state.requestQueue, action.payload.element],
requestTrigger: (state.requestTrigger + 1)
};
}

case PatientActionTypes.ResetQueryParameters: {

const params = {...state.selectedPatient.params};
params[action.payload.element] = {...init.initialPatientState.selectedPatient.params[action.payload.element]};

return {...state,
selectedPatient: {
data: state.selectedPatient.data,
params: {...params}
},
requestQueue: [...state.requestQueue, action.payload.element],
requestTrigger: (state.requestTrigger + 1)
};
}

case PatientActionTypes.SetDetails: {
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
details: action.payload
},
}
};
}

case PatientActionTypes.SetAllergies: {
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
allergies: action.payload
}
}
};
}

case PatientActionTypes.SetConsults: {
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
consults: action.payload
}
}
};
}

case PatientActionTypes.SetLabs: {
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
labs: action.payload
}
}
};
}

case PatientActionTypes.SetVitals: {
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
vitals: action.payload
}
}
};
}

case PatientActionTypes.SetVitalSummary: {

const data = (state.selectedPatient.data.vitalSummary) ? JSON.parse(JSON.stringify(state.selectedPatient.data.vitalSummary)) : {};
data[action.payload.key] = {
data: action.payload.data,
err: action.payload.err,
queryDate: action.payload.queryDate
};

// return new state
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
vitalSummary: {...data}
}
}
};
}

case PatientActionTypes.AddVitalSummaryType: {

// validate the summary type isn't already in the list & continue
if (!action.payload.key || _.findIndex(state.selectedPatient.params.vitalSummary, {key: action.payload.key}) > -1) {
return state;
} else {

let vitalTypes = (state.selectedPatient && state.selectedPatient.params.vitals.filter.name) ?
state.selectedPatient.params.vitals.filter.name.value : '';

vitalTypes = ( vitalTypes.length === 0 ) ? action.payload.key : vitalTypes + '+' + action.payload.key;

return {...state,
selectedPatient: {
...state.selectedPatient,
params : {
...state.selectedPatient.params,
vitalSummary: [...state.selectedPatient.params.vitalSummary, action.payload],
vitals: { ...state.selectedPatient.params.vitals,
filter: {...state.selectedPatient.params.vitals.filter, name: {operator: FilterOps.eq, value: vitalTypes }}}
}
},
requestQueue: [...state.requestQueue, 'vitalSummary', 'vitals'],
requestTrigger: state.requestTrigger + 2
};
}
}

case PatientActionTypes.SetLabSummary: {

const data = (state.selectedPatient.data.labSummary) ? JSON.parse(JSON.stringify(state.selectedPatient.data.labSummary)) : {};
data[action.payload.key] = {
data: action.payload.data,
err: action.payload.err,
queryDate: action.payload.queryDate
};

// return new state
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
labSummary: {...data}
}
}
};
}

case PatientActionTypes.SetEncounterSummary: {

const data = (state.selectedPatient.data.encounterSummary) ?
JSON.parse(JSON.stringify(state.selectedPatient.data.encounterSummary)) : {};
data[action.payload.key] = {
data: action.payload.data,
err: action.payload.err,
queryDate: action.payload.queryDate
};

// toggle patient status based on encounterSummary data.
// if the latest inpatient encounter has an endDate, they're outpatient
// otherwise, inpatient
const isIn = (data.inpatient && data.inpatient.data && !data.inpatient.data.encounterEndDateTime) ? true : false;

// vitals history is a year for outpatient, a day for inpatient
const vitalStart = new Date();
if (isIn) {
vitalStart.setDate(new Date().getDate() - 7);
} else {
vitalStart.setDate(new Date().getDate() - 365);
vitalStart.setHours(0, 0, 0, 0);
}

// return new state
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
encounterSummary: {...data},
isInpatient: isIn
},
params: {
...state.selectedPatient.params,
vitals : {
...state.selectedPatient.params.vitals,
filter: {
...state.selectedPatient.params.vitals.filter,
timeTaken : {
operator: FilterOps.in,
value: vitalStart.toISOString()
}
}
}
}
}
};
}

case PatientActionTypes.SetProgressNotes: {
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
progressNotes: action.payload
}
}
};
}

case PatientActionTypes.SetCWAD: {
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
cwad: action.payload
}
}
};
}

case PatientActionTypes.SetImmunizations: {
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
immunizations: action.payload
}
}
};
}

case PatientActionTypes.SetProblemList: {
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
problemList: action.payload
}
}
};
}

case PatientActionTypes.SetAppointments: {
return {...state,
selectedPatient: {
...state.selectedPatient,
data: {
...state.selectedPatient.data,
appointments: action.payload
}
}
};
}

// add request to the request queue and increment the request trigger
case PatientActionTypes.AddPendingRequest: {
return {...state, requestQueue: [...state.requestQueue, action.payload], requestTrigger: (state.requestTrigger + 1) };
}

// remove a request from the request queue
case PatientActionTypes.RemovePendingRequest: {
const idx = state.requestQueue.indexOf(action.payload);
if (idx >= 0) {
return {...state, requestQueue: [...state.requestQueue.slice(0, idx), ...state.requestQueue.slice(idx + 1)]};
} else {
return {...state };
}
}

default: {
return state;
}

}
}