@medipass/web-sdk 11.38.1-feature-eclipse-reporting.0 → 11.38.1-feature-typescript-claudia.0

package/lib/resources/devices.js.flow

@@ -1,64 +0,0 @@
-// @flow
-
-import platform from 'platform';
-import medipassWebSdk from '../index';
-import request from '../utils/request';
-import storage from '../services/storage';
-
-import type { MedipassRequestOpts } from '../_types';
-
-const PATH__DEVICES = '/devices';
-let isRegistering = false;
-
-/**
- * Register a device
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const registerDevice = async (opts?: MedipassRequestOpts): Promise<Object> => {
-  if (!isRegistering) {
-    try {
-      isRegistering = true;
-      const deviceData = {
-        deviceType: 'browser',
-        os: {
-          type: platform.os.family || 'Unknown',
-          ver: platform.os.version || '0'
-        },
-        app: {
-          appId: platform.ua || 'Unknown'
-        }
-      };
-
-      const data = await request(
-        { ...opts, path: PATH__DEVICES },
-        { method: 'post', data: deviceData, skipDeviceCheck: true }
-      );
-      medipassWebSdk.device = data;
-      storage.set('device', data);
-      return data;
-    } finally {
-      isRegistering = false;
-    }
-  } else {
-    let data;
-    do {
-      await new Promise(resolve => setTimeout(resolve, 100));
-      data = medipassWebSdk.device;
-    } while (!data);
-
-    return data;
-  }
-};
-
-/**
- * Check if the device exists, and set the device id request header.
- */
-export const getDeviceId = async (): Promise<?void> => {
-  const device = medipassWebSdk.device || storage.get('device');
-  if (!device || !device.deviceId) {
-    const data = await registerDevice();
-    return data.deviceId;
-  }
-  return device.deviceId;
-};

package/lib/resources/doc-accounts.js.flow

@@ -1,61 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-const PATH__DOC_ACCOUNTS = '/docaccounts';
-const pathDocAccount = docAccountId => `/docaccounts/${docAccountId}`;
-
-/**
- * Get documentation accounts
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getDocAccounts = async (query?: Object = {}, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__DOC_ACCOUNTS }, { method: 'get', params: query });
-};
-
-/**
- * Get documentation account
- * @param {String} docAccountId - Documentation Account ID
- * @param {Object} opts - Additional options
- */
-export const getDocAccount = async (partnerId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ partnerId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathDocAccount(partnerId) }, { method: 'get' });
-};
-
-/**
- * Create documentation account
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createDocAccount = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__DOC_ACCOUNTS }, { method: 'post', data: body });
-};
-
-/**
- * Update documentation account
- * @param {String} docAccountId - Documentation Account ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const updateDocAccount = async (
-  docAccountId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ docAccountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathDocAccount(docAccountId) }, { method: 'put', data: body });
-};
-
-/**
- * Delete documentation account
- * @param {String} docAccountId - Documentation Account ID
- * @param {Object} opts - Additional options
- */
-export const deleteDocAccount = async (docAccountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ docAccountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathDocAccount(docAccountId) }, { method: 'delete' });
-};

package/lib/resources/documents.js.flow

@@ -1,216 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type {
-  BusinessDocumentsQuery,
-  BusinessDocumentResponse,
-  BusinessDocumentsResponse,
-  CeaseHealthFundDocumentBody,
-  DeclineHealthFundDocumentBody,
-  HealthFundDocumentResponse,
-  HealthFundDocumentsResponse,
-  HealthFundDocumentsQuery,
-  ParkHealthFundDocumentBody,
-  MedipassRequestOpts
-} from '../_types';
-
-export const pathBusinessDocuments = (businessId: string) => `/businesses/${businessId}/documents`;
-export const pathBusinessDocument = (businessId: string, documentId: string) =>
-  `/businesses/${businessId}/documents/${documentId}`;
-export const pathBusinessDocumentCancel = (businessId: string, documentId: string) =>
-  `/businesses/${businessId}/documents/${documentId}/cancellations`;
-export const pathHealthFundDocument = (healthFundId: string, documentId: string) =>
-  `/healthfunds/${healthFundId}/documents/${documentId}`;
-export const pathHealthFundDocumentApprove = (healthFundId: string, documentId: string) =>
-  `/healthfunds/${healthFundId}/documents/${documentId}/approvals`;
-export const pathHealthFundDocumentAssignToMe = (healthFundId: string, documentId: string) =>
-  `/healthfunds/${healthFundId}/documents/${documentId}/assigntome`;
-export const pathHealthFundDocumentDecline = (healthFundId: string, documentId: string) =>
-  `/healthfunds/${healthFundId}/documents/${documentId}/decline`;
-export const pathHealthFundDocumentCease = (healthFundId: string, documentId: string) =>
-  `/healthfunds/${healthFundId}/documents/${documentId}/cease`;
-export const pathHealthFundDocumentPark = (healthFundId: string, documentId: string) =>
-  `/healthfunds/${healthFundId}/documents/${documentId}/park`;
-export const pathHealthFundDocumentTag = (healthFundId: string, documentId: string, tagId: string) =>
-  `/healthfunds/${healthFundId}/documents/${documentId}/tags/${tagId}`;
-export const pathHealthFundDocuments = (healthFundId: string) => `/healthfunds/${healthFundId}/documents`;
-
-/**
- * Approve health fund document
- * @param {String} healthFundId - Business ID
- * @param {String} documentId - Document ID
- * @param {Object} opts - Additional options
- */
-export const approveHealthFundDocument = (
-  healthFundId: string,
-  documentId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<HealthFundDocumentResponse> => {
-  doesParamExist({ healthFundId, documentId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundDocumentApprove(healthFundId, documentId) }, { method: 'post' });
-};
-
-/**
- * Get business documents
- * @param {String} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const assignHealthFundDocumentToMe = (
-  healthFundId: string,
-  documentId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<HealthFundDocumentResponse> => {
-  doesParamExist({ healthFundId, documentId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundDocumentAssignToMe(healthFundId, documentId) }, { method: 'put' });
-};
-
-/**
- * Cancel business document
- * @param {String} businessId - Business ID
- * @param {String} documentId - Document ID
- * @param {Object} opts - Additional options
- */
-export const cancelBusinessDocument = (
-  businessId: string,
-  documentId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<HealthFundDocumentResponse> => {
-  doesParamExist({ businessId, documentId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessDocumentCancel(businessId, documentId) }, { method: 'post' });
-};
-
-/**
- * Decline health fund document
- * @param {String} healthFundId - Business ID
- * @param {String} documentId - Document ID
- * @param {Object} opts - Additional options
- */
-export const declineHealthFundDocument = (
-  healthFundId: string,
-  documentId: string,
-  body: DeclineHealthFundDocumentBody,
-  opts?: MedipassRequestOpts = {}
-): Promise<HealthFundDocumentResponse> => {
-  doesParamExist({ healthFundId, documentId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathHealthFundDocumentDecline(healthFundId, documentId) },
-    { method: 'post', data: body }
-  );
-};
-
-/**
- * Cease health fund document
- * @param {String} healthFundId - Business ID
- * @param {String} documentId - Document ID
- * @param {Object} opts - Additional options
- */
-export const ceaseHealthFundDocument = (
-  healthFundId: string,
-  documentId: string,
-  body: CeaseHealthFundDocumentBody,
-  opts?: MedipassRequestOpts = {}
-): Promise<HealthFundDocumentResponse> => {
-  doesParamExist({ healthFundId, documentId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathHealthFundDocumentCease(healthFundId, documentId) },
-    { method: 'post', data: body }
-  );
-};
-
-/**
- * Delete business document tag
- * @param {String} businessId - Business ID
- * @param {String} documentId - Document ID
- * @param {String} tagId - Tag ID
- * @param {Object} opts - Additional options
- */
-export const deleteHealthFundDocumentTag = (
-  healthFundId: string,
-  documentId: string,
-  tagId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<null> => {
-  doesParamExist({ healthFundId, documentId, tagId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundDocumentTag(healthFundId, documentId, tagId) }, { method: 'delete' });
-};
-
-/**
- * Get business documents
- * @param {String} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessDocuments = (
-  businessId: string,
-  query: BusinessDocumentsQuery,
-  opts?: MedipassRequestOpts = {}
-): Promise<BusinessDocumentsResponse> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessDocuments(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get business document
- * @param {String} businessId - Business ID
- * @param {String} documentId - Document ID
- * @param {Object} opts - Additional options
- */
-export const getBusinessDocument = (
-  businessId: string,
-  documentId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<BusinessDocumentResponse> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessDocument(businessId, documentId) }, { method: 'get' });
-};
-
-/**
- * Get health fund documents
- * @param {String} healthFundId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getHealthFundDocuments = (
-  healthFundId: string,
-  query: HealthFundDocumentsQuery,
-  opts?: MedipassRequestOpts = {}
-): Promise<HealthFundDocumentsResponse> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundDocuments(healthFundId) }, { method: 'get', params: query });
-};
-
-/**
- * Get health fund document
- * @param {String} healthFundId - Business ID
- * @param {String} documentId - Document ID
- * @param {Object} opts - Additional options
- */
-export const getHealthFundDocument = (
-  healthFundId: string,
-  documentId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<HealthFundDocumentResponse> => {
-  doesParamExist({ healthFundId, documentId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundDocument(healthFundId, documentId) }, { method: 'get' });
-};
-
-/**
- * Park a health fund document
- * @param {String} healthFundId - Business ID
- * @param {String} documentId - Document ID
- * @param {Object} opts - Additional options
- */
-export const parkHealthFundDocument = (
-  healthFundId: string,
-  documentId: string,
-  body: ParkHealthFundDocumentBody,
-  opts?: MedipassRequestOpts = {}
-): Promise<HealthFundDocumentResponse> => {
-  doesParamExist({ healthFundId, documentId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathHealthFundDocumentPark(healthFundId, documentId) },
-    { method: 'post', data: body }
-  );
-};

package/lib/resources/emails.js.flow

@@ -1,96 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const healthFundEmailSections = (healthFundId: string, emailTemplateId: string) =>
-  `/healthfunds/${healthFundId}/emailtemplates/${emailTemplateId}/emailsections`;
-export const healthFundEmailTemplates = (healthFundId: string) => `/healthfunds/${healthFundId}/emailtemplates`;
-export const healthFundTransactionEmail = (healthFundId: string, transactionId: string) =>
-  `/healthfunds/${healthFundId}/transactions/${transactionId}/emails`;
-export const healthFundDocumentEmail = (healthFundId: string, documentId: string) =>
-  `/healthfunds/${healthFundId}/documents/${documentId}/emails`;
-export const transactionEmailPackages = (transactionId: string) => `/transactions/${transactionId}/emailpackages`;
-export const transactionEmailPackage = (transactionId: string, emailPackageId: string) =>
-  `/transactions/${transactionId}/emailpackages/${emailPackageId}`;
-
-export const getHealthFundEmailSections = (
-  healthFundId: string,
-  emailTemplateId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, emailTemplateId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: healthFundEmailSections(healthFundId, emailTemplateId) },
-    { method: 'get', params: query }
-  );
-};
-
-export const getHealthFundEmailTemplates = (
-  healthFundId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: healthFundEmailTemplates(healthFundId) }, { method: 'get', params: query });
-};
-
-export const generateEmailTemplate = (
-  healthFundId: string,
-  transactionId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, transactionId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: healthFundTransactionEmail(healthFundId, transactionId) },
-    { method: 'post', data: body }
-  );
-};
-
-export const generateDocumentEmailTemplate = (
-  healthFundId: string,
-  documentId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, documentId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: healthFundDocumentEmail(healthFundId, documentId) }, { method: 'post', data: body });
-};
-
-export const createEmailPackage = (
-  transactionId: string,
-  body?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ transactionId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: transactionEmailPackages(transactionId) }, { method: 'post', data: body });
-};
-
-export const updateEmailPackage = (
-  transactionId: string,
-  emailPackageId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ transactionId, emailPackageId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: transactionEmailPackage(transactionId, emailPackageId) },
-    { method: 'put', data: body }
-  );
-};
-
-export const sendEmailPackage = (
-  transactionId: string,
-  emailPackageId: string,
-  body?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ transactionId, emailPackageId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: `${transactionEmailPackage(transactionId, emailPackageId)}/send` },
-    { method: 'post', data: body }
-  );
-};

package/lib/resources/form-application-templates.js.flow

@@ -1,52 +0,0 @@
-// @flow
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathBusinessFormApplicationTemplate = (
-  businessId: string,
-  formId: string,
-  formApplicationTemplateId: string
-) => `/businesses/${businessId}/forms/${formId}/formapplicationtemplates/${formApplicationTemplateId}`;
-export const pathHealthFundFormApplicationTemplate = (healthFundId: string, formApplicationTemplateId: string) =>
-  `/healthfunds/${healthFundId}/formapplicationtemplates/${formApplicationTemplateId}`;
-
-/**
- * Get business form application template
- * @param {String} businessId - Business ID
- * @param {String} formId - Form ID
- * @param {String} formApplicationTemplateId - Form ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessFormApplicationTemplate = (
-  businessId: string,
-  formId: string,
-  formApplicationTemplateId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, formId, formApplicationTemplateId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessFormApplicationTemplate(businessId, formId, formApplicationTemplateId) },
-    { method: 'get' }
-  );
-};
-
-/**
- * Get health fund form application template
- * @param {String} healthFundId - Health fund ID
- * @param {String} formApplicationTemplateId - Form ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getHealthFundFormApplicationTemplate = (
-  healthFundId: string,
-  formApplicationTemplateId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, formApplicationTemplateId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathHealthFundFormApplicationTemplate(healthFundId, formApplicationTemplateId) },
-    { method: 'get' }
-  );
-};

package/lib/resources/form-applications.js.flow

@@ -1,62 +0,0 @@
-// @flow
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathBusinessFormApplication = (businessId: string, formApplicationId: string) =>
-  `/businesses/${businessId}/formapplications/${formApplicationId}`;
-export const pathHealthFundFormApplication = (healthFundId: string, formApplicationId: string) =>
-  `/healthfunds/${healthFundId}/formapplications/${formApplicationId}`;
-export const pathUpdatePracticeRepresentative = (healthFundId: string, formApplicationId: string) =>
-  `/healthfunds/${healthFundId}/formapplications/${formApplicationId}/practicerepresentative`;
-
-/**
- * Get business form application
- * @param {String} businessId - Business ID
- * @param {String} formApplicationId - Form ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessFormApplication = (
-  businessId: string,
-  formApplicationId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, formApplicationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessFormApplication(businessId, formApplicationId) }, { method: 'get' });
-};
-
-/**
- * Get health fund form application
- * @param {String} healthFundId - Business ID
- * @param {String} formApplicationId - Form ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getHealthFundFormApplication = (
-  healthFundId: string,
-  formApplicationId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, formApplicationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundFormApplication(healthFundId, formApplicationId) }, { method: 'get' });
-};
-
-/**
- * Update form practice representative details
- * @param {Object} healthFundId - Health fund ID
- * @param {Object} body - Health fund details
- * @param {Object} opts - Additional options
- */
-export const updatePracticeRepresentative = async (
-  healthFundId: string,
-  formApplicationId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, formApplicationId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathUpdatePracticeRepresentative(healthFundId, formApplicationId) },
-    { method: 'put', data: body }
-  );
-};