@medipass/web-sdk 11.38.0 → 11.38.1-feature-typescript-claudia.1

package/lib/resources/rnas.js.flow

@@ -1,108 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { PaginatedQuery } from '../_types';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathHealthFundRNAs = (healthFundId: string) => `/healthfunds/${healthFundId}/rnas`;
-export const pathHealthFundRNA = (healthFundId: string, rnaId: string) => `/healthfunds/${healthFundId}/rnas/${rnaId}`;
-export const pathHealthFundRNAAppointments = (healthFundId: string, rnaId: string) =>
-  `/healthfunds/${healthFundId}/rnas/${rnaId}/rnaappointments`;
-export const pathHealthFundRNAAppointment = (healthFundId: string, rnaId: string, rnaAppointmentId: string) =>
-  `/healthfunds/${healthFundId}/rnas/${rnaId}/rnaappointments/${rnaAppointmentId}`;
-export const pathBusinessesRNAs = (businessId: string) => `/businesses/${businessId}/rnas`;
-export const pathBusinessRNA = (businessId: string, rnaId: string) => `/businesses/${businessId}/rnas/${rnaId}`;
-
-/**
- * Get businesses Requests and Appointments
- * @param {String} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessRNAs = (
-  businessId: string,
-  query?: ?{ ...PaginatedQuery, searchText?: string },
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessesRNAs(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get business Requests and Appointments
- * @param {String} businessId - Business ID
- * @param {String} rnaId - RNA ID
- * @param {Object} opts - Additional options
- */
-export const getBusinessRNA = (businessId: string, rnaId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId, rnaId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: `${pathBusinessRNA(businessId, rnaId)}` }, { method: 'get' });
-};
-
-/**
- * Check if dan and epId is valid
- * @param {String} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const checkRNAExists = (
-  businessId: string,
-  query: { dan: string, epId: string },
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: `${pathBusinessesRNAs(businessId)}/exists` }, { method: 'get', params: query });
-};
-
-export const createHealthFundRNA = (
-  healthFundId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundRNAs(healthFundId) }, { method: 'post', data: body });
-};
-
-export const createAppointmentForHealthFundRNA = (
-  healthFundId: string,
-  rnaId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, rnaId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundRNAAppointments(healthFundId, rnaId) }, { method: 'post', data: body });
-};
-
-export const getHealthFundRNA = (
-  healthFundId: string,
-  rnaId: string,
-  query?: ?{ includeDeleted?: boolean },
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, rnaId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundRNA(healthFundId, rnaId) }, { method: 'get', params: query });
-};
-
-export const getHealthFundRNAs = (
-  healthFundId: string,
-  query?: ?{ ...PaginatedQuery, searchText?: string },
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundRNAs(healthFundId) }, { method: 'get', params: query });
-};
-
-export const updateAppointmentForHealthFundRNA = (
-  healthFundId: string,
-  rnaId: string,
-  rnaAppointmentId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, rnaId, rnaAppointmentId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathHealthFundRNAAppointment(healthFundId, rnaId, rnaAppointmentId) },
-    { method: 'put', data: body }
-  );
-};

package/lib/resources/roles.js.flow

@@ -1,12 +0,0 @@
-// @flow
-import request from '../utils/request';
-import { type MedipassRequestOpts } from '../_types';
-
-const PATH__ROLES = '/roles';
-/**
- * Get roles
- * @param {Object} opts - Additional options
- */
-export const getRoles = async (opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__ROLES }, { method: 'get' });
-};

package/lib/resources/self-checkout-sessions.js.flow

@@ -1,382 +0,0 @@
-// @flow
-import _get from 'lodash/get';
-import { isMedicare } from '@medipass/utils/funders';
-
-import sdk from '../index';
-import request from '../utils/request';
-import doesParamExist from '../utils/does-param-exist';
-import type { MedipassRequestOpts } from '../_types';
-
-const PATH__SELF_CHECKOUT_SESSIONS = '/selfcheckoutsessions';
-
-/**
- * Create a self checkout session
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createSelfCheckoutSession = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__SELF_CHECKOUT_SESSIONS }, { method: 'post', data: body });
-};
-
-/**
- * Approve my self checkout session
- * @param {Object} body - request body
- * @param {Object} opts - Additional options
- */
-export const approve = async (body?: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me/approvals` },
-    { method: 'post', data: body, tokenType: 'session' }
-  );
-};
-
-/**
- * Cancel my self checkout session
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const cancel = async (body?: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me/cancellations` },
-    { method: 'post', data: body, tokenType: 'session' }
-  );
-};
-
-/**
- * Cancel my self checkout session
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const cancelSession = async (body?: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me/cancels` },
-    { method: 'post', data: body, tokenType: 'session' }
-  );
-};
-
-/**
- * Create invoice for my self checkout session
- * @param {Object} opts - Additional options
- */
-export const createMyInvoice = async (opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me/invoices` },
-    { method: 'post', tokenType: 'session' }
-  );
-};
-
-/**
- * Create payment authority for my self checkout session
- * @param {Object} opts - Additional options
- */
-export const createPaymentAuthority = async (opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me/paymentauthorities` },
-    { method: 'post', tokenType: 'session' }
-  );
-};
-
-/**
- * Create payment method for my self checkout session
- * @param {String} nonce - Nonce
- * @param {String} source - Source of payment
- * @param {Object} opts - Additional options
- */
-export const createPaymentMethod = async (
-  nonce: string,
-  source: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ nonce, source }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me/paymentmethods` },
-    { method: 'post', data: { nonce, source }, tokenType: 'session' }
-  );
-};
-
-/**
- * Get payment methods for my self checkout session
- * @param {Object} opts - Additional options
- */
-export const getPaymentMethods = async (opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me/paymentmethods` },
-    { method: 'get', tokenType: 'session' }
-  );
-};
-
-/**
- * Discover member for a self checkout session
- * @param {Object} ids - Find by ids (Accepts: `memberId` and `email`)
- * @param {Object} query - Additional query parameters
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const discoverMember = async (
-  { email, memberId }: { email?: string, memberId?: string },
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ email, memberId }, opts.hyperMediaEndpoint, { atLeastOneExists: true });
-  const params = Object.assign({}, query, { email, memberId });
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/discovery/members` },
-    { method: 'get', params, tokenType: 'session' }
-  );
-};
-
-/**
- * Check for duplicate member
- * @param {Object} body - Additional request body
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const checkDupe = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/checkdupe` },
-    { method: 'post', data: body, tokenType: 'session' }
-  );
-};
-
-/**
- * Get my self checkout session
- * @param {Object} opts - Additional options
- */
-export const getMySelfCheckoutSession = async (opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me` }, { method: 'get', tokenType: 'session' });
-};
-
-/**
- * Get transaction for self checkout session
- * @param {Object} opts - Additional options
- */
-
-export const getMySelfCheckoutSessionTransaction = async (
-  checkoutSessionId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/${checkoutSessionId}/transaction` },
-    { method: 'get', tokenType: 'session' }
-  );
-};
-
-/**
- * Remember me
- * @param {Object} opts - Additional options
- */
-export const rememberMe = async (opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me/rememberme` },
-    { method: 'post', tokenType: 'session' }
-  );
-};
-
-/**
- * Update my self checkout session
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const updateMySelfCheckoutSession = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me` },
-    { method: 'put', data: body, tokenType: 'session' }
-  );
-};
-
-/**
- * Request OTK for a self checkout session
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const requestOtk = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/otk` },
-    { method: 'post', data: { accountId }, tokenType: 'session' }
-  );
-};
-
-/**
- * Add a payment method to a self checkout session
- * @param {Object} body - Config for the method.
- * @param {Object} opts - Additional options
- */
-export const addPaymentMethodToSelfCheckoutSession = async (
-  body: { data?: Object, selfCheckoutSession: Object },
-  opts?: MedipassRequestOpts = {}
-) => {
-  const { data = {}, selfCheckoutSession } = body;
-  const isExistingAccount = Boolean(selfCheckoutSession.accountId);
-
-  let requestBody = {};
-  let paymentMethod;
-
-  // If card data exists, then add the card data to the self checkout session.
-  if (data.cardNumber && data.expiry && data.cvc) {
-    const { source, nonce } = await sdk.payments.getNonce({
-      cardNumber: data.cardNumber,
-      expiry: data.expiry,
-      cvc: data.cvc,
-      isSelfCheckoutSession: true
-    });
-
-    // If there is an existing account, create a new payment method and attach it to the self checkout session.
-    if (isExistingAccount) {
-      paymentMethod = await sdk.payments.createAccountPaymentMethod(selfCheckoutSession.accountId, nonce, source, opts);
-      requestBody = {
-        paymentMethod: { _id: paymentMethod._id }
-      };
-    } else {
-      // Otherwise, we want to create a payment method on the self checkout session.
-      await createPaymentMethod(nonce, source, opts);
-    }
-  } else if (data._id) {
-    // If a payment method id is specified, attach it to the self checkout session.
-    requestBody = {
-      paymentMethod: { _id: data._id }
-    };
-  } else if (isExistingAccount) {
-    // If there is an existing account, try get their payment method and attach it to the self checkout session.
-    const paymentMethods = await sdk.payments.getAccountPaymentMethods(selfCheckoutSession.accountId, opts);
-    paymentMethod = paymentMethods.find(paymentMethod => Boolean(paymentMethod.isDefault));
-    if (paymentMethod) {
-      requestBody = {
-        paymentMethod: { _id: paymentMethod._id }
-      };
-    }
-  }
-
-  const newSelfCheckoutSession = await updateMySelfCheckoutSession(requestBody, opts);
-
-  return { paymentMethod, selfCheckoutSession: newSelfCheckoutSession };
-};
-
-/**
- * Add a member to a self checkout session
- * @param {Object} body - Config for the method.
- * @param {Object} opts - Additional options
- */
-export const addMemberToSelfCheckoutSession = async (
-  body?: { data?: Object, selfCheckoutSession?: Object } = {},
-  opts?: MedipassRequestOpts = {}
-) => {
-  const { data = {}, selfCheckoutSession = {} } = body;
-
-  let requestBody = {};
-
-  // If a member exists and there isn't already one attached to the self checkout session, then attach the member.
-  if (_get(sdk, 'member._id') && !_get(selfCheckoutSession, 'member._id')) {
-    requestBody = { member: { _id: _get(sdk, 'member._id') } };
-  } else {
-    // Otherwise, add member manually to the self checkout session.
-    const [day, month, year] = _get(data, 'dob', '').split('/');
-    requestBody = {
-      patient: {
-        firstName: data.firstName,
-        lastName: data.lastName,
-        email: data.email,
-        mobile: data.mobile,
-        dobString: day && month && year ? `${year}-${month}-${day}` : undefined
-      }
-    };
-  }
-
-  const newSelfCheckoutSession = await updateMySelfCheckoutSession(requestBody, opts);
-
-  return { selfCheckoutSession: newSelfCheckoutSession };
-};
-
-/**
- * Add a health fund account to a self checkout session
- * @param {Object} body - Config for the method.
- * @param {Object} opts - Additional options
- */
-export const addHealthFundAccountToSelfCheckoutSession = async (
-  body: { data?: Object, funder: Object, selfCheckoutSession: Object },
-  opts?: MedipassRequestOpts = {}
-) => {
-  const { data = {}, funder, selfCheckoutSession } = body;
-  const isExistingAccount = selfCheckoutSession.accountId;
-  const memberId = _get(selfCheckoutSession, 'member._id') || _get(sdk, 'member._id');
-
-  let healthFund = data.healthFund;
-  if (isMedicare(funder.code)) {
-    healthFund = await sdk.healthfunds.getMedicareHealthFund({ ...opts, requestConfig: { tokenType: 'session' } });
-  }
-
-  // If there is an existing account, we will need to get their existing health fund accounts to use below.
-  let healthFundAccounts;
-  if (isExistingAccount) {
-    healthFundAccounts = await sdk.healthFundAccounts.getMembersHealthFundAccounts(
-      memberId,
-      { funderId: _get(funder, '_id') },
-      opts
-    );
-  }
-  const healthFundAccountId = _get(healthFundAccounts, 'items[0]._id');
-
-  let healthFundAccount;
-  let requestBody = {};
-
-  // If health fund account data exists, then add the data to the self checkout session.
-  if (data.membershipNumber || data.cardNumber) {
-    const healthFundAccountRequestBody = {
-      healthFundId: _get(healthFund, '_id'),
-      ...(data || {})
-    };
-
-    // If it's an existing account, delete their current health fund account (if any), and add the new one to their account.
-    if (isExistingAccount) {
-      if (healthFundAccountId) {
-        await sdk.healthFundAccounts.deleteMembersHealthFundAccount(memberId, healthFundAccountId, opts);
-      }
-      healthFundAccount = await sdk.healthFundAccounts.createMembersHealthFundAccount(
-        memberId,
-        healthFundAccountRequestBody,
-        opts
-      );
-      requestBody = {
-        healthFundAccount: { _id: healthFundAccount._id }
-      };
-    } else {
-      // Otherwise, just add the data to the self checkout session.
-      requestBody = {
-        healthFundAccount: healthFundAccountRequestBody
-      };
-    }
-  } else if (data._id) {
-    // If a health fund account id is specified, attach it to the self checkout session.
-    requestBody = {
-      healthFundAccount: { _id: data._id }
-    };
-  } else if (isExistingAccount) {
-    // If there is an existing account, try get the health fund account and attach it to the self checkout session.
-    if (healthFundAccountId) {
-      healthFundAccount = await sdk.healthFundAccounts.getMembersHealthFundAccount(memberId, healthFundAccountId, opts);
-      requestBody = {
-        healthFundAccount: { _id: healthFundAccount._id }
-      };
-    }
-  }
-
-  const newSelfCheckoutSession = await updateMySelfCheckoutSession(requestBody, opts);
-
-  return { healthFundAccount, selfCheckoutSession: newSelfCheckoutSession };
-};
-
-/**
- * Delete payment method
- * @param {String} paymentMethodId - Payment method ID
- * @param {Object} opts - Additional options
- */
-export const deletePaymentMethod = async (
-  paymentMethodId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ paymentMethodId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: `${PATH__SELF_CHECKOUT_SESSIONS}/me/paymentmethods/${paymentMethodId}` },
-    { method: 'delete', tokenType: 'session' }
-  );
-};