Merge branch 'update-deps' into Sensotrend-smartpix-on-tp-master

SUMMARY.md

@@ -21,8 +21,6 @@
    * [Abbott FreeStyle meters](docs/checklists/abbottFreeStyleLite.md)
    * [Abbott Precision Xtra](docs/checklists/abbottPrecisionXtra.md)
    * [Accu-chek Aviva Connect & Guide (BGM)](docs/checklists/avivaConnectAndGuide.md)
-   * [Animas Vibe CGM](docs/checklists/animasCGM.md)
-   * [Animas Ping and Vibe Insulin Pumps](docs/checklists/animasPingAndVibe.md)
    * [Ascensia/Bayer Contour Next meters](docs/checklists/bayerContourNext.md)
    * [Dexcom CGM](docs/checklists/dexcom.md)
    * [Insulet OmniPod](docs/checklists/insuletOmniPod.md)

app/actions/async.js

@@ -20,6 +20,7 @@ import semver from 'semver';
 import os from 'os';
 import { push } from 'connected-react-router';
 import { checkCacheValid } from 'redux-cache';
+import { ipcRenderer } from 'electron';
 
 import * as actionTypes from '../constants/actionTypes';
 import * as actionSources from '../constants/actionSources';
@@ -42,6 +43,9 @@ let hostMap = {
   'linux': 'linux',
 };
 
+const isBrowser = typeof window !== 'undefined';
+let win = isBrowser ? window : null;
+
 function createActionError(usrErrMessage, apiError) {
   const err = new Error(usrErrMessage);
   if (apiError) {
@@ -94,6 +98,13 @@ export function doAppInit(opts, servicesToInit) {
     log('Getting OS details.');
     await actionUtils.initOSDetails();
 
+    ipcRenderer.on('bluetooth-pairing-request', async (event, details) => {
+      const displayBluetoothModal = actionUtils.makeDisplayBluetoothModal(dispatch);
+      displayBluetoothModal((response) => {
+        ipcRenderer.send('bluetooth-pairing-response', response);
+      }, details);
+    });
+
     log('Initializing device');
     device.init({
       api,
@@ -257,12 +268,27 @@ export function doLogout() {
     api.user.logout((err) => {
       if (err) {
         dispatch(sync.logoutFailure());
-        dispatch(setPage(pages.LOGIN, actionSources.USER));
       }
       else {
         dispatch(sync.logoutSuccess());
-        dispatch(setPage(pages.LOGIN, actionSources.USER));
       }
+      dispatch(setPage(pages.LOGIN, actionSources.USER));
+    });
+  };
+}
+
+export function doLoggedOut() {
+  return (dispatch, getState) => {
+    const { api } = services;
+    dispatch(sync.logoutRequest());
+    api.user.logout((err) => {
+      if (err) {
+        dispatch(sync.logoutFailure());
+      }
+      else {
+        dispatch(sync.logoutSuccess());
+      }
+      dispatch(setPage(pages.LOGGED_OUT, actionSources.USER));
     });
   };
 }
@@ -293,7 +319,7 @@ export function doDeviceUpload(driverId, opts = {}, utc) {
       opts.filename = currentUpload.file.name;
     }
 
-    device.detect(driverId, opts, (err, dev) => {
+    device.detect(driverId, opts, async (err, dev) => {
       if (err) {
         let displayErr = new Error(ErrorMessages.E_SERIAL_CONNECTION);
         let deviceDetectErrProps = {
@@ -316,6 +342,9 @@ export function doDeviceUpload(driverId, opts = {}, utc) {
         }
 
         displayErr.originalError = err;
+        if (process.env.NODE_ENV !== 'test') {
+          deviceDetectErrProps = await actionUtils.sendToRollbar(displayErr, deviceDetectErrProps);
+        }
         return dispatch(sync.uploadFailure(displayErr, deviceDetectErrProps, targetDevice));
       }
 
@@ -337,6 +366,9 @@ export function doDeviceUpload(driverId, opts = {}, utc) {
           disconnectedErrProps.code = 'E_DEXCOM_CONNECTION';
         }
 
+        if (process.env.NODE_ENV !== 'test') {
+          disconnectedErrProps = await actionUtils.sendToRollbar(displayErr, disconnectedErrProps);
+        }
         return dispatch(sync.uploadFailure(displayErr, disconnectedErrProps, targetDevice));
       }
 
@@ -373,6 +405,7 @@ export function doUpload(deviceKey, opts, utc) {
       }));
 
       try {
+        ipcRenderer.send('setSerialPortFilter', filters);
         opts.port = await navigator.serial.requestPort({ filters: filters });
       } catch (err) {
         // not returning error, as we'll attempt user-space driver instead
@@ -418,6 +451,9 @@ export function doUpload(deviceKey, opts, utc) {
           code: 'E_HID_CONNECTION',
         };
 
+        if (process.env.NODE_ENV !== 'test') {
+          errProps = await actionUtils.sendToRollbar(hidErr, errProps);
+        }
         return dispatch(sync.uploadFailure(hidErr, errProps, devices[deviceKey]));
       }
     }
@@ -439,6 +475,9 @@ export function doUpload(deviceKey, opts, utc) {
           code: 'E_BLUETOOTH_OFF',
         };
 
+        if (process.env.NODE_ENV !== 'test') {
+          errProps = await actionUtils.sendToRollbar(btErr, errProps);
+        }
         return dispatch(sync.uploadFailure(btErr, errProps, devices[deviceKey]));
       }
       console.log('Done.');
@@ -1154,6 +1193,56 @@ export function setPage(page, actionSource = actionSources[actionTypes.SET_PAGE]
       } else {
         dispatch(sync.getClinicsForClinicianSuccess(clinics, clinicianId, options));
       }
+      // fetch EHR and MRN settings for clinics
+      _.each(clinics, (clinic) => {
+        console.log('fetching settings for clinic', clinic.clinic.id);
+        dispatch(fetchClinicEHRSettings(api, clinic.clinic.id));
+        dispatch(fetchClinicMRNSettings(api, clinic.clinic.id));
+      });
+    });
+  };
+}
+
+/**
+ * Fetch Clinic MRN Settings Action Creator
+ *
+ * @param {Object} api - an instance of the API wrapper
+ * @param {String} clinicId - Id of the clinic
+ */
+export function fetchClinicMRNSettings(api, clinicId) {
+  return (dispatch) => {
+    dispatch(sync.fetchClinicMRNSettingsRequest());
+
+    api.clinics.getMRNSettings(clinicId, (err, settings) => {
+      if (err) {
+        dispatch(sync.fetchClinicMRNSettingsFailure(
+          createActionError(ErrorMessages.ERR_FETCHING_CLINIC_MRN_SETTINGS, err), err
+        ));
+      } else {
+        dispatch(sync.fetchClinicMRNSettingsSuccess(clinicId, settings));
+      }
+    });
+  };
+}
+
+/**
+ * Fetch Clinic EHR Settings Action Creator
+ *
+ * @param {Object} api - an instance of the API wrapper
+ * @param {String} clinicId - Id of the clinic
+ */
+export function fetchClinicEHRSettings(api, clinicId) {
+  return (dispatch) => {
+    dispatch(sync.fetchClinicEHRSettingsRequest());
+
+    api.clinics.getEHRSettings(clinicId, (err, settings) => {
+      if (err) {
+        dispatch(sync.fetchClinicEHRSettingsFailure(
+          createActionError(ErrorMessages.ERR_FETCHING_CLINIC_EHR_SETTINGS, err), err
+        ));
+      } else {
+        dispatch(sync.fetchClinicEHRSettingsSuccess(clinicId, settings));
+      }
     });
   };
 }

app/actions/sync.js

@@ -856,6 +856,21 @@ export function dismissedAdHocPairingDialog() {
   };
 }
 
+export function bluetoothPairingRequest(callback, cfg) {
+  return {
+    type: ActionTypes.BLUETOOTH_PAIRING_REQUEST,
+    payload: { callback, cfg },
+    meta: { source: actionSources[ActionTypes.BLUETOOTH_PAIRING_REQUEST] }
+  };
+}
+
+export function dismissedBluetoothPairingDialog() {
+  return {
+    type: ActionTypes.BLUETOOTH_PAIRING_DISMISSED,
+    meta: { source: actionSources[ActionTypes.BLUETOOTH_PAIRING_DISMISSED] }
+  };
+}
+
 export function fetchPatientsForClinicRequest() {
   return {
     type: ActionTypes.FETCH_PATIENTS_FOR_CLINIC_REQUEST,
@@ -1030,10 +1045,62 @@ export function selectClinic(clinicId) {
   };
 }
 
-export function keycloakReady(event, error){
+export function fetchClinicMRNSettingsRequest() {
+  return {
+    type: ActionTypes.FETCH_CLINIC_MRN_SETTINGS_REQUEST,
+  };
+}
+
+export function fetchClinicMRNSettingsSuccess(clinicId, settings) {
+  return {
+    type: ActionTypes.FETCH_CLINIC_MRN_SETTINGS_SUCCESS,
+    payload: {
+      clinicId,
+      settings,
+    },
+  };
+}
+
+export function fetchClinicMRNSettingsFailure(error, apiError) {
+  return {
+    type: ActionTypes.FETCH_CLINIC_MRN_SETTINGS_FAILURE,
+    error: error,
+    meta: {
+      apiError: apiError || null,
+    },
+  };
+}
+
+export function fetchClinicEHRSettingsRequest() {
+  return {
+    type: ActionTypes.FETCH_CLINIC_EHR_SETTINGS_REQUEST,
+  };
+}
+
+export function fetchClinicEHRSettingsSuccess(clinicId, settings) {
+  return {
+    type: ActionTypes.FETCH_CLINIC_EHR_SETTINGS_SUCCESS,
+    payload: {
+      clinicId,
+      settings,
+    },
+  };
+}
+
+export function fetchClinicEHRSettingsFailure(error, apiError) {
+  return {
+    type: ActionTypes.FETCH_CLINIC_EHR_SETTINGS_FAILURE,
+    error: error,
+    meta: {
+      apiError: apiError || null,
+    },
+  };
+}
+
+export function keycloakReady(event, error, logoutUrl){
   return {
     type: ActionTypes.KEYCLOAK_READY,
-    payload: { error, event },
+    payload: { error, event, logoutUrl },
   };
 }
 
@@ -1108,3 +1175,9 @@ export function keycloakInstantiated(){
     type: ActionTypes.KEYCLOAK_INSTANTIATED
   };
 }
+
+export function keycloakReset(){
+  return {
+    type: ActionTypes.KEYCLOAK_RESET
+  };
+}

app/actions/utils.js

@@ -16,12 +16,12 @@
  */
 
 import _ from 'lodash';
-import stacktrace from 'stack-trace';
 
 import sundial from 'sundial';
 
 import ErrorMessages from '../constants/errorMessages';
 import * as syncActions from './sync';
+import rollbar from '../../app/utils/rollbar';
 
 const isBrowser = typeof window !== 'undefined';
 // eslint-disable-next-line no-console
@@ -64,8 +64,14 @@ export function makeDisplayAdhocModal(dispatch) {
   };
 }
 
+export function makeDisplayBluetoothModal(dispatch) {
+  return (cb, cfg) => {
+    dispatch(syncActions.bluetoothPairingRequest(cb, cfg));
+  };
+}
+
 export function makeUploadCb(dispatch, getState, errCode, utc) {
-  return (err, recs) => {
+  return async (err, recs) => {
     const { devices, uploadsByUser, uploadTargetDevice, uploadTargetUser, version } = getState();
     const targetDevice = devices[uploadTargetDevice];
 
@@ -88,7 +94,6 @@ export function makeUploadCb(dispatch, getState, errCode, utc) {
         datasetId: err.datasetId || null,
         requestTrace: err.requestTrace || null,
         sessionTrace: err.sessionTrace || null,
-        sessionToken: err.sessionToken || null,
         code: err.code || errCode,
         version: version,
         data: recs
@@ -129,18 +134,13 @@ export function makeUploadCb(dispatch, getState, errCode, utc) {
         uploadErrProps.details = 'Could not validate the date format';
       }
 
-      if (!(process.env.NODE_ENV === 'test')) {
-        uploadErrProps.stringifiedStack = _.map(
-          _.filter(
-            stacktrace.parse(err),
-            (cs) => { return cs.functionName !== null; }
-          ),
-          'functionName'
-        ).join(', ');
+      if (process.env.NODE_ENV !== 'test') {
+        uploadErrProps = await sendToRollbar(displayErr, uploadErrProps);
       }
       return dispatch(syncActions.uploadFailure(displayErr, uploadErrProps, targetDevice));
     }
     const currentUpload = _.get(uploadsByUser, [uploadTargetUser, targetDevice.key], {});
+    debug('Device model used for metrics:', recs.deviceModel);
     dispatch(syncActions.uploadSuccess(uploadTargetUser, targetDevice, currentUpload, recs, utc));
   };
 }
@@ -158,6 +158,29 @@ export function mergeProfileUpdates(profile, updates){
   });
 }
 
+export function sendToRollbar(err, props) {
+  return new Promise((resolve) => {
+    if (rollbar) {
+      const extra = {};
+      if (_.get(props, 'data.blobId', false)) {
+        _.assign(extra, { blobId: props.data.blobId });
+      }
+
+      rollbar.error(err, extra, (err, data) => {
+        if (err) {
+          console.log('Error while reporting error to Rollbar:', err);
+        } else {
+          console.log(`Rollbar UUID: ${data.result.uuid}`);
+          props.uuid = data.result.uuid;
+        }
+        resolve(props);
+      });
+    } else {
+      resolve(props);
+    }
+  });
+}
+
 export async function initOSDetails() {
   if (typeof navigator !== 'undefined') {
     const ua = await navigator.userAgentData.getHighEntropyValues(