Introduction

Welcome to the SmartFlow API! The SmartFlow API is organized around REST and is designed to have predictable, resource-oriented URLs and to use HTTP response codes to indicate API errors. JSON will be returned in all responses from the API, including errors.

By using the SmartFlow API the third-party software (hereinafter EMR) can create, edit and read patient data, as well as receive different events from the SmartFlow services.

Environment Setup

API Sandbox Endpoint:

https://sandbox.smartflowsheet.com/api/v3

API Production Endpoint:

https://www.smartflowsheet.com/api/v3

To make the SmartFlow API as explorable as possible, we provide test-mode API keys as well as live-mode API keys. The test-mode API keys should be used in our sandbox environment, while live-mode keys should be used in our production environment.

To retrieve the events from SmartFlow you should register two webhooks: one for sandbox environment, and another for production. SmartFlow then sends an HTTP POST request with the event object to the URLs you provided.

To receive your API keys, please prepare the urls that will be used for the webhooks, and send us a request at info@smartflowsheet.com.

Your API keys carry many privileges, so be sure to keep them secret!

You can find the API endpoints for sandbox and production in Details section in the right part of this page.

You may also register a custom webhook per each clinic account (see Register custom webhook for more information).

Clinic Setup

Sandbox Home and Settings pages:

https://sandbox.smartflowsheet.com
https://sandbox.smartflowsheet.com/Settings?page=emr

Production Home and Settings pages:

https://www.smartflowsheet.com
https://www.smartflowsheet.com/Settings?page=emr

Our API is intended for use with a registered clinic account. You can register a clinic account on the Home page both in sandbox and production environments.

After a new clinic account has been registered in SmartFlow, there is a clinic API Key automatically generated. This key should be used to authenticate against our API (see Authentication for more information). It is also used with the Events sent to EMR to identify the account.

The clinic API key can be obtained by user from Settings page on our web-site after registration. We assume that SmartFlow user will be able to register this key in EMR's user interface.

Basic Use-Cases

Sample Project: https://github.com/IDEXX/public-sfs

This section describes the basic integration workflows.

Please download a sample project from GitHub that contains several examples of the SmartFlow API usage.

Creating Patients

Creating patients from EMR into SmartFlow has two obvious benefits:

1. Saving the clinic's staff time. Almost always the information required to create a patient in SmartFlow has been already entered into EMR user interface upon patient addmission to the hospital. Using /hospitalization API method it is possible to transfer that information into SmartFlow and we will automatically create a new patient record for the user.

2. Automatically collecting charges for the patient. SmartFlow will not send medical records for the patients created from SmartFlow user interface. To receive medical records for the patient you will need to create a patient in SmartFlow explicitly using /hospitalization API method.

Usually, what we recommend is that you place 'SmartFlow' button on your user interface. Clinic staff could then press it when they are ready to create a patient's flowsheet (usually when a doctor decides to leave a patient in the hospital). Before creating a patient in SmartFlow, you may want to allow a user to select a treatment template and department for the patient. After the required treatment template and department has been selected, you should use this API to create patient record in SmartFlow.

After the patient has been submitted to SmartFlow, you may want to query the patient's hospitalization status using this API. With its help, you can get some additional information, e.g. patient image file to update your user interface. Or you may track the status of the patient, and as soon as the patient has been discharged, you could download and attach to your medical records the set of files related to the patient, e.g. the flowsheet report.

Discharging Patients

At the end of hospitalization, the clinic staff will usually discharge the patient. During this step, SmartFlow generates a set of documents (in pdf format) that your practice management software might want to attach to the patient record. The list of documents to attach is determined by the user on the Settings/Documents Management page.

Documents Management in Smart Flow

From Settings / Documents Management page (see image below) the user will be able to turn on/off exporting of the documents after patient discharge. If the user disables EXPORT DOCUMENTS TO EMR option then:

If the user sets MERGE REPORTS INTO ONE PDF setting to YES, then hospitalization.reportPath as well as download the flowsheet report API will return the merged pdf file, that will include all the documents specified in Files To Retain After Discharge section. This option allows you download only one pdf file that will include all documents chosen by the user rather than implementing all Smart Flow APIs mentioned above to access each document separately. More detail about this functionality is available in the Clinic Settings section.

Discharging Patients

There are two options for discharging the patient in SmartFlow:

1. The user initiates discharge of the patient from SmartFlow user interface. In this case, SmartFlow will prepare all pdf reports and send the hospitalization.discharged event that your EMR may consume, download the appropriate pdf files from SmartFlow and attach them to the patient records.

2. The user initiates discharge operation from the EMR side. In this case, the EMR should call discharge API to initiate discharging of the patient in SmartFlow. After the successful call to this API, the response will include the hospitalization object with the status field equal to discharged, but the reportPath field will be empty. At this point, all patient reports are not generated yet - SmartFlow only initiated the document generation process. To download the files, you have a couple of implementation strategies:

   • wait for the hospitalization.discharged event and then start downloading the documents
   • wait at least 15 seconds and then call the get hospitalization API. If the reportPath is not empty, then you may start downloading the reports
   • add some sort of "Download patient documents" button that will call the get hospitalization API, and if the reportPath is not empty, then the download may start. Otherwise, propose to repeat the operation later because the documents are not ready yet

Working with the Forms

Smart Flow provides a feature called Customised Hospitalization Forms. These give the user the ability to digitalize the majority of your paper forms, such as:

• Surgical consent
• Euthanasia consent
• Admission
• and many more...

To make use of these forms and understand how this feature works, please read this article. There are two types of forms in Smart Flow that can be created as follows:

1. those that could be used to create a patient in Smart Flow (e.g. Admission form). These forms have Show on Main Screen setting set to YES on Settings/Forms web page
2. those that do not provide such an option, but rather can be added to the existing patient from the Smart Flow user interface

Creating Patients from Forms

By default SmartFlow provides a couple of forms that allow you to create patients from the “Smart Flow” iPad app. This means clients have the ability from the iPad to fill out their own information, take a photo of their pet, enter a reason for their visit and update and/or enter the name of their regular clinic from the waiting room. Upon completion of the form, the patient is created in Smart Flow and appears on the whiteboard.

As soon as the patient is created from the form, SmartFlow will notify the EMR by sending hospitalizations.created and forms.created events. You might want to consume and handle these events to:

• Automatically register both the client and patient into the EMR.

• Attach to SmartFlow hospitalization to receive treatment events as well as the patient`s medical records and pdf reports.

There are three steps that should be followed to get client’s data entered on the form:

1. The EMR should consume the hospitalizations.created event that is sent from SmartFlow as soon as a patient is added from the form. The hospitalization object will be provided with the event. When the event is received both the client and patient records should be created in the EMR.

2. In a second step, you should attach your internal records to SmartFlow hospitalization. This is required to receive all other types of events related to this patient, as well as to be able to use any hospitalization API.

3. Finally, SmartFlow will send the forms.created event that you should consume to get the rest of the data entered by the client during the check-in process.

Editing Forms Notifications

When the user edits (changes the content of the form or its status to finalized) or deletes a form then SmartFlow fires the forms.updated event. When the user finalizes the form then SmartFlow generates a pdf report for this form.

Parsing Custom Forms and Properties

SmartFlow allows users to create a custom set of forms and properties from the Settings/Forms web page. If you want to parse the data from these custom forms then you should utilize Internal Name attributes when creating forms and properties.

The value of Internal Name attribute ('checkinform' on a picture above) of the form will be transferred with the name property of the form object.

The value of Internal Name attribute of the property ('pet_name' on a picture above) will be transferred with the name property of the formfield object.

Inventory Import

The most common reason to integrate with the SmartFlow services is to be able to receive medical records from SmartFlow upon treatment execution. This information can be used to automatically collect charges for the inventory items stored in EMR database.

In order to accomplish this goal the SmartFlow API provides a possibility to import inventory items from the EMR system into SmartFlow. We will store external identifiers for the inventory items during inventory import, and will provide these identifiers back to EMR with the medical records information entered during treatment execution. In this way EMR will be able to associate entered medical record with the correct inventory item, and create a charge.

To import inventory you may use next API methods:

• /inventoryitem - to import single inventory item;

• /inventoryitems - to import multiple inventory items;

The later API method works asynchronously and sends inventoryitems.imported event to the url specified with the webhook.

After the import is finished, the user can start using the inventory immediately by adding imported items to the patients` flowsheets. For the inventory items being added for the first time, Smart Flow will display a popup window. In this window, the user can adjust the display name of the item, and which SmartFlow section (monitoring, activity, fluid, medication, or procedure) it should be attached to. If you have included a concentration with the item, the concentration will automatically populate, making it much easier for the user to set these items. The concentration number will automatically be appended to the beginning of the medication name. This facilitates differentiating concentrations of the same item from screens in Smart Flow where there is a character limit.

View on the web interface: View on the iPad:

Receiving Medical Records

Receiving medical records information from SmartFlow provides an opportunity to automatically collect charges for the inventory items stored in your database. Please make sure to import inventory into SmartFlow before that.

Medical record information is sent to EMR with the treatment.record_entered event (or treatments.records_entered event when multiple records has been entered).

Here is an example:

Example inventoryitem object imported with /inventoryitem API:

{
    "id": "external-inventory-id",
    "name": "Cefazolin 100",
    "concentration": 100,
    "concentrationUnits": "mg",
    "concentrationVolume": "ml"
}

Example treatment.record_entered event object sent to webhook:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "treatment.record_entered",
    "object": {
        "objectType": "treatment",
        "name": "Cefazolin 100",
        "inventoryId": "external-inventory-id",
        "hospitalizationId": "external-hospitalization-id",
        "treatmentGuid": "internal-sfs-treatment-guid",
        "time":"2013-03-28T14:23:56.000+00:00",
        "status": "added",
        "qty": 2.25,
        "volume": 2.25,
        "value": "IZ",
        "units": "ml",
        "doctorName": "Dr. Ivan Zak"
    }
}

1. EMR imports Cefazolin 100 mg/ml inventory item with the /invetoryitem API method.

2. Then doctor creates a patient in the EMR, the patient record is transferred into SmartFlow with the /hospitalization API method and new patient automatically appears on a SmartFlow whiteboard.

3. After the patient is created in SmartFlow, doctor adds Cefazolin 100 mg/ml to the flowsheet, and sets the dosage to 25 mg/kg (see image below).

4. When Cefazolin 100 mg/ml is given to the patient, SmartFlow sends medical record information with the treatment.record_entered event to the EMR webhook, and transfer the volume of the medication dispensed. In this case it will be 2.25 ml.

You can find the example JSONs in Details section in the right part of this page. As you can notice the object transferred with the treatment.record_entered event contains the inventoryId field that is equal to the id field of the inventory item imported into SmartFlow with the /inventoryitem API method. In this way EMR is able to associate entered medical record with the correct inventory item, and create a charge.

Billing for a Surgery

When the patient is admitted for surgery, SmartFlow provides access to the electronic anesthetic sheet feature. The anesthetic sheet allows medical staff to map the patient’s vitals and calculate pre-op and emergency drugs. After the surgery is over, the clinic staff finalizes the anesthetic sheet to:

• Generate anesthetic sheet protocols.
• Calculate an invoice for the surgery.

To make it easier for your EMR to calculate billing for the surgery, SmartFlow sends the anesthetics.finalized event with the included anesthetic object as soon as the user presses the 'Finalize Anesthetiс Sheet' button on the iPad.

Authentication

GET /inventoryitems HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

You authenticate to the SmartFlow API by providing both EMR API key and clinic API key in all API requests to the server in a header.

emrApiKey: emr-api-key-received-from-sfs

clinicApiKey: clinic-api-key-taken-from-account-web-page

You must replace emr-api-key-received-from-sfs with your personal emr API key and clinic-api-key-taken-from-account-web-page with the clinic API key taken from the Settings web-page.

All API requests must be made over HTTPS. Calls made over plain HTTP will fail. You must authenticate for all requests.

We also recommend providing the time zone name with the timezoneName header of the HTTP request (e.g. timezoneName: Europe/Helsinki). Please visit this web-page for the complete list of the time zone names.

Errors

HTTP Status Code Summary

200 OK - Everything worked as expected.

204 No Content - May happen when trying to access the patient report that was not generated for the patient.

400 Bad Request - Often missing a required parameter.

401 Unauthorized - No valid emrApiKey or clinicApiKey provided.

402 Payment Required - If reached clinic`s patient limit. This may happen when trying to create a new patient, but clinic`s subscription expired.

403 Forbidden - If trying to update clinic with different clinicApiKey.

404 Not Found - The requested item doesn`t exist.

409 Conflict - If the request with the same “id“ (e.g. “inventoryitems.id“) has been already received and is currenly under processing. Normally means that second request is not needed.

429 Too Many Requests - May happen when trying to upload a lot of inventory items. Need to slown down. 

465 Access to the Document Denied - Heppens when manager turns off the document on the `Settings / Documents Management` page.

500, 502, 503, 504 Server errors - something went wrong on SmartFlow`s end.

SmartFlow uses conventional HTTP response codes to indicate success or failure of an API request. In general, codes in the 2xx range indicate success, codes in the 4xx range indicate an error that resulted from the provided information (e.g. a required parameter was missing), and codes in the 5xx range indicate an error with SmartFlow's servers.

Not all errors map cleanly onto HTTP response codes, however. Please refer to the documentation on a particular API method for the details on possible HTTP codes and responses.

The Error object

GET /inventoryitem HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

HTTP/1.1 404 Not Found
Accept: application/json

{
   "Message" : "Inventory item not found"
}

SmartFlow may send the Error object in the response to the API methods that failed with the 4xx HTTP status codes.

Also, SFS expects EMR to send the Error object (optionally) in the response to the event calls that fail together with the 4xx HTTP status codes.

Attributes

Clinic Settings

This API allows to get the settings of a particular clinic. You may want to use this API to check these settings before downloading reports for discharged patients.

The clinicSettings object

Attributes

The documentsManagement object

The documentsManagement object gives you access to the clinic's settings on the Documents Management settings page.

Attributes

Based on these details, you can determine what to do next.

• exportToEmr:

  • false: If the exportToEmr parameter is false, you do not need to attempt to download any files for the patient.
    • reportPath fields in hospitalization, anesthetic, form objects will be NULL;
    • attempts to access documents with any API will return 465 with the message "The manager turned off the document on the Settings / Documents management page";
  • true: If the exportToEmr parameter is true, then the user may specify which documents to export to EMR in Files To Retain After Discharge section.

• retain In any case where a document is not retained after discharge, the appropriate API will return 465 error with the message "The manager turned off the document on the Settings / Documents management page" (as well as reportPath field in the appropriate object will be NULL, if applicable).

• merge If the user sets MERGE REPORTS INTO ONE PDF setting to YES, then hospitalization.reportPath as well as download the flowsheet report API will return the merged pdf file, that will include all the documents specified in Files To Retain After Discharge section. If this option has been selected by the user, you should download only one pdf file that will include all documents chosen by the user rather than implementing all Smart Flow APIs mentioned above to access each document separately. When this is true, any file download APIs except the flowsheet report API API will return 465 error with the message "The manager turned off the document on the Settings / Documents management page" (as well as reportPath field in the appropriate object will be NULL, if applicable)

Here are the reports that will be created for every hospitalization, with references to their API documentation:

• Flowsheet report
• Medical records report
• Billing report
• Notes report

For the following real-time reports, it's best practice to download the reports when the Finalized event is sent, which includes the reportPath (and recordsReportPath for anesthetic) if the documentsManagement settings indicate you can download those reports.

• If the anesthetic sheet was created, completed, and finalized, for the patient, then the associated Anesthetic Sheet and Anesthetic Records reports can be downloaded
• Form report for each form created for the patient. To download all forms upon patient discharge you will need to get all patients forms first, and then download the document from the Form.reportPath
• If a dental chart was created, completed and finalized for the patient, then the associated Dental Chart Report and Media can be downloaded

Retreive clinicSettings

Example Request:

GET /clinicsettings HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

{
    "objectType":"clinicsettings",
    "documentsManagement":
    {
        "objectType":"documentsmanagementsettings",
        "exportToEmr":true,
        "merge":true,
        "retain":
        {
            "medical_records":true,
            "billing":true,
            "notes":true,
            "flowsheet":true,
            "anesthetic":true,
            "anesthetic_records":true,
            "checkinform":true,
            "surgicalconsentform":true,
            "Allergy Form":true,
            "dentalcharts":true
        }
    }
}

• Url: /clinicsettings
• Method: GET
• Synchronous
• Returns HTTP status 200 and any applicable clinicsettings objects
• In case of error returns the Error object

Anesthetics

Anesthetic is an abstraction used in SmartFlow to represent the anesthetic sheet data. The main purpose of this abstraction is to provide the possibility to download anesthetic sheet report when it is finalized or after the patient discharge event.

The anesthetics object

Attributes

The anesthetic object

Attributes

Finalize anesthetic event

Example of anesthetics.finalized event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "anesthetics.finalized",
    "object": {
        "objectType": "anesthetics",
        "id": "sfs-operation-id",
        "anesthetics": [
            {
                "objectType": "anesthetic",
                "hospitalizationId": "emr-hospitalization-id",
                "surgeryGuid": "sfs-surgery-guid",
                "dateStarted": "2015-11-04T17:23:07.707+00:00",
                "dateEnded": "2015-11-04T19:17:03.463+00:00",
                "reportPath": "https://pdf-anesthetic-sheet-report-webfile-path",
                "recordsReportPath": "https://pdf-anesthetic-records-report-webfile-path",
                "surgeon": {
                    "objectType": "medic",
                    "medicId": "emrIdm4",
                    "name": "Dr. George",
                    "medicType": "doctor"
                },
                "anesthetist": {
                    "objectType": "medic",
                    "medicId": "emrIdm3",
                    "name": "Ivan",
                    "medicType": "doctor"
                },
                "assistant": {
                    "objectType": "medic",
                    "medicId": "emrIdm4",
                    "name": "Dr. George",
                    "medicType": "doctor"
                }
            }
        ]
    }
}

As soon as one or several anesthetic sheets have been finalized in the SmartFlow app on an iPad, SmartFlow will notify the EMR by sending anesthetics.finalized event. The anesthetics object will be transferred with the event.

• Url: webhook provided by EMR
• Method: POST
• Asynchronous
• Transfers anesthetics object included in the event object
• Expected response with 200 Http code in case of success.
• In case of the error, EMR should return 400 Http code and optionally the Error object

Retreive anesthetic sheet and anesthetic records reports

Example Request:

GET /hospitalization/{hospitalizationId}/anesthetics HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

{
    "objectType": "anesthetics",
    "id": "sfs_operation_id",
    "anesthetics": [
        {
            "objectType": "anesthetic",
            "hospitalizationId": "emr-hospitalization-id",
            "surgeryGuid": "sfs-surgery-guid",
            "dateStarted": "2015-11-04T17:23:07.707+00:00",
            "dateEnded": "2015-11-04T19:17:03.463+00:00",
            "reportPath": "https://pdf-anesthetic-sheet-report-webfile-path",
            "recordsReportPath": "https://pdf-anesthetic-records-report-webfile-path",
            "surgeon": {
                "objectType": "medic",
                "medicId": "emrIdm4",
                "name": "Dr. George",
                "medicType": "doctor"
            },
            "anesthetist": {
                "objectType": "medic",
                "medicId": "emrIdm3",
                "name": "Ivan",
                "medicType": "doctor"
            },
            "assistant": {
                "objectType": "medic",
                "medicId": "emrIdm4",
                "name": "Dr. George",
                "medicType": "doctor"
            }
        },
        {
            "objectType": "anesthetic",
            "hospitalizationId": "emr-hospitalization-id",
            "surgeryGuid": "sfs-surgery-guid",          
            "dateStarted": "2015-11-04T17:23:07.707+00:00",
            "dateEnded": null,
            "reportPath": null,
            "recordsReportPath": null,
            "surgeon": {
                "objectType": "medic",
                "medicId": "emrIdm4",
                "name": "Dr. George",
                "medicType": "doctor"
            },
            "anesthetist": {
                "objectType": "medic",
                "medicId": "emrIdm3",
                "name": "Ivan",
                "medicType": "doctor"
            },
            "assistant": null
        }
    ]
}

This method allows to download all anesthetic sheet reports and anesthetic records reports related to some hospitalization from SmartFlow.

Specify the hospitalizationId of the hospitalization object in the EMR. Use the same hospitalizationId that was supplied when hospitalization had been created.

• Url: /hospitalization/{hospitalizationId}/anesthetics
• Method: GET
• Synchronous
• Returns the Anesthetics object.
• Expected response with 200 Http code in case of success.
• In case of the error, the Error object will be returned

Dental Charts

Dental Chart is an abstraction used in SmartFlow to represent the Dental Chart data. The main purpose of this abstraction is to provide the possibility to download dental chart report when it is finalized or after the patient discharge event.

The dentalcharts object

Attributes

The dentalchart object

Example of dentalchart object:

{

    "objectType": "dentalchart",
    "hospitalizationId": "emr-hospitalization-id",
    "dentalChartGuid": "sfs-dental-guid",
    "dateFinalized": "2019-11-04T17:23:07.707+00:00",
    "reportPath": "https://pdf-dental-chart-report-webfile-path",
    "media": [ 
        {
            "dentalChartMediaGuid": "sfs-dental-guid",
            "section": "before",
            "dateCreated": "2020-03-13T16:21:19.193+00:00",
            "filePath": "https://pdf-dental-chart-photo-1-webfile-path",
            "contentType": "image/jpg"
        }
    ],
}

Attributes

The dental media object

Example of dental media object:

{
    "dentalChartMediaGuid": "sfs-dental-guid",
    "section": "before",
    "dateCreated": "2020-03-13T16:21:19.193+00:00",
    "filePath": "https://pdf-dental-chart-photo-1-webfile-path",
    "contentType": "image/jpg"
}

Attributes

Finalize Dentalchart event

Example of dentalcharts.finalized event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "dentalcharts.finalized",
    "object": {
        "objectType": "dentalcharts",
        "id": "sfs-operation-id",
        "dentalcharts": [
            {
                "objectType": "dentalchart",
                "hospitalizationId": "emr-hospitalization-id",
                "dentalChartGuid": "sfs-dental-guid",
                "dateFinalized": "2019-11-04T17:23:07.707+00:00",
                "reportPath": "https://pdf-dental-chart-report-webfile-path",
                "media": [ 
                    {
                        "dentalChartMediaGuid": "sfs-dental-guid",
                        "section": "before",
                        "dateCreated": "2020-03-13T16:21:19.193+00:00",
                        "filePath": "https://pdf-dental-chart-photo-1-webfile-path",
                        "contentType": "image/jpg"
                    }
                ],
            }
        ]
    }
}

As soon as a dental chart has been finalized in the SmartFlow app on an iPad, SmartFlow will notify the EMR by sending a dentalcharts.finalized event. The dentalcharts object will be transferred with the event.

• Url: webhook provided by EMR
• Method: POST
• Asynchronous
• Transfers dentalcharts object included in the event object
• Expected response with 200 Http code in case of success.
• In case of the error, EMR should return 400 Http code and optionally the Error object

Retreive dental chart and associated media

Example Request:

GET /hospitalization/{hospitalizationId}/dentalcharts HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

This method allows to download all dental chart reports and associated media related to some hospitalization from SmartFlow.

Specify the hospitalizationId of the hospitalization object in the EMR. Use the same hospitalizationId that was supplied when hospitalization had been created.

• Url: /hospitalization/{hospitalizationId}/dentalcharts
• Method: GET
• Synchronous
• Returns the dentalcharts object.
• Expected response with 200 Http code in case of success.
• In case of the error, the Error object will be returned

Departments

This API allows to get the list of departments in the clinic. You may want to use this API to allow users to select a department before submitting a new patient into SmartFlow.

The department object

Attributes

Retreive existing departments

Example Request:

GET /departments HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

[
{
     "objectType":"department",
     "name":"Treatment Room",
     "departmentId":0
},
{
     "objectType":"department",
     "name":"Internal Medicine",
     "departmentId":1
}
]

• Url: /departments
• Method: GET
• Synchronous
• Returns HTTP status 200 and a collection of all department objects
• In case of error returns the Error object

Forms

The are three objects used by SmartFlow to notify EMR when forms are filled in:

• forms

• form

• formfield

All objects are sent with the asynchronous forms.created or forms.udpated events when one or several forms has been entered or changed.

The forms object

Attributes

The form object

Attributes

<%= image_tag "images/formsetting.png" %>

The formfield object

Attributes

<%= image_tag "images/propertysetting.png" %>

Get patient`s forms

Example Request:

GET /hospitalization/emr-hospitalization-id/forms HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method allows getting all forms for the patient specified by hospitalizationId. This method returns the list of forms objects with empty fields. To get the form fields for each form please use the get form values API.

• Url: /hospitalization/{hospitalizationId}/forms
• Method: GET
• Synchronous
• Returns HTTP status 200 and a collection of form objects with empty fields
• In case of error returns the Error object

Get form values

Example Request:

GET /hospitalization/emr-hospitalization-Id/form/form-guid HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method allows getting all fields for the form determined by formGuid and hospitalizationId.

• Url: /hospitalization/{hospitalizationId}/form/{formGuid}
• Method: GET
• Synchronous
• Returns HTTP status 200 and the form object with all the fields
• In case of error returns the Error object

Retreive forms with events

Example of forms.created event JSON:

{
  "clinicApiKey": "clinic-api-key",
  "eventType": "forms.created",
  "object": {
    "objectType": "forms",
    "id": "sfs-operation-id"
    "forms": [
      {
        "objectType": "form",
        "formGuid": "sfs-form-guid",
        "hospitalizationId": "external-hospitalization-id",
        "name": "checkinform",
        "title": "Client Self Check-in",
        "fields": [
          {
            "objectType": "formfield",
            "name": "avatar",
            "title": "Avatar",
            "value": "https://attached-image-webfile-path",
            "contentType": "image/jpg"
          },
          {
            "objectType": "formfield",
            "name": "email",
            "title": "Your email",
            "value": "me@example.com",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "first_name",
            "title": "Your name",
            "value": "John",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "last_name",
            "title": "Last name",
            "value": "Doe",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "address",
            "title": "Address",
            "value": "105, 11th Ave",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "city",
            "title": "City",
            "value": "New York",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "state",
            "title": "State",
            "value": "NY",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "zip",
            "title": "Zip",
            "value": "10001",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "phone_home",
            "title": "Home phone",
            "value": "(111) 111-1111",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "phone_work",
            "title": "Work phone",
            "value": "(222) 222-2222",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "phone_cell",
            "title": "Owner's cell phone",
            "value": "(333) 333-3333",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "phone_co_owner",
            "title": "Co-Owner's cell phone",
            "value": "(444) 444-4444",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "phone_number_to_reach",
            "title": "Best number to reach you today",
            "value": "Home phone",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "pet_name",
            "title": "Your Pet's Name",
            "value": "Fluffy",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "weight",
            "title": "Weight (kg)",
            "value": "3.5",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "birth_date",
            "title": "Birth date",
            "value": "2016-07-16T19:20:30.000+00:00",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "breed",
            "title": "Breed",
            "value": "English Cocker Spaniel",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "sex",
            "title": "Sex",
            "value": "Male",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "family_veterinarian",
            "title": "Family veterinarian",
            "value": "Dr. Ivan Zak",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "clinic",
            "title": "Clinic",
            "value": "Best Pet Vet",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "visit_reason",
            "title": "What is the reason for your visit today?",
            "value": "Vaccination",
            "contentType": "text/plain"
          },
          {
            "objectType": "formfield",
            "name": "signature",
            "title": "Consent Form",
            "value": "https://attached-image-webfile-path",
            "contentType": "image/jpg"
          }
        ]
      }
    ]
  }
}

The forms.created and form.updated events are sent from SmartFlow when one or several forms were created or updated. SmartFlow will send forms object with all information entered into the forms.

• Url: webhook provided by EMR
• Method: POST
• Asynchronous
• Transfers forms object included in the event object
• Expected response with 200 Http code in case of success.
• In case of the error, EMR should return 400 Http code and optionally the Error object

Download the form report

Example Request:

GET /hospitalization/emr-hospitalization-id/formreport/form-guid HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method allows to download the form pdf report generated upon form finalization.

All the dates in the downloaded report will be represented in the time zone that you must explicitly specify in the timezoneName header of the HTTP request (e.g. timezoneName: Europe/Helsinki). Please visit this web-page for the complete list of the time zone names.

Specify the hospitalizationId of the hospitalization object in the EMR. Use the same hospitalizationId that was supplied when hospitalization had been created. Also specify the formGuid value that uniquely identifies the form. This value can be obtained from forms.created event or by fetching all the forms for the patient with this API.

• Url: /hospitalization/{hospitalizationId}/formreport/{formGuid}
• Method: GET
• Synchronous
• Returns the pdf report with the output stream. The Content-Type header will contain the application/pdf value
• In case of error returns the Error object

Hospitalizations

Hospitalization is an abstraction used in SmartFlow to represent the patient record. As soon as patient is admitted in the hospital the Hospitalization object is created. In turn, the hospitalization object nests patient and client information. This information can be transferred and retrieved from SmartFlow using the patient object and the client object.

There are the hospitalizations and hospitalization objects used to create hosptitalizations in SmartFlow and receiving events from the SmartFlow services.

The hospitalizations object

Attributes

This object will be sent with the hospitalizations.discharged event in case when multiple patients were discharged from the SmartFlow whiteboard.

The hospitalization object

Attributes

The patient object

Attributes

The client object

Attributes

Create a patient

Example Typical Request:

POST /hospitalization HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

{
    "objectType": "hospitalization",
    "hospitalizationId": "emr-hospitalization-id",
    "dateCreated": "2014-11-03T17:54:55.221+00:00",
    "temperatureUnits": "C",
    "weightUnits": "kg",
    "weight": 5.8,
    "estimatedDaysOfStay": 1,
    "fileNumber": "# 123",
    "caution": false,
    "color": "#439FE0",
    "doctorName": "Dr. Ivan",
    "medicId": "dr-ivan-emr-id",
    "diseases": [
        "high temperature",
        "vomiting"
    ],
    "patient": {
        "objectType": "patient",
        "patientId": "emr-patient-id",
        "name": "Jordi Alba",
        "species": "Canin",
        "owner": {
            "objectType": "client",
            "ownerId": "emr-client-id",
            "nameLast": "Dow",
            "nameFirst": "Jack",
            "workPhone": "555-55-55"
        },
        "color": "Brown",
        "sex": "M",
        "criticalNotes": "Cefazolin allergy",
        "customField": "some notes"
    }
}

Example Minimal Request (only including required fields):

POST /hospitalization HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

    {"hospitalizationId": "emr-hospitalization-id",
"dateCreated": "2014-11-03T17:54:55.221+00:00",
"patient": {
"objectType": "patient",
"sex": "U",
"owner":{
"objectType": "client"
}
}
}

• Url: /hospitalization
• Method: POST
• Synchronous
• Accepts hospitalization object
• Returns HTTP status 201 in case the new hospitalization has been created
• In case of error returns the Error object

The Smart Slow Sheet API does not allow to create several hospitalizations with the same hospitalizationId. However, it may happen that the user needs to re-submit the hospitalization that has been previously created (and then deleted or discharged from SmartFlow user interface). In this case, the second call of this API will return the error with the message Hospitalization already exists. If this happens, we advise to show the user the error message and prompt them if they would like to re-submit the patient. If user selects the option to re-submit the patient, then EMR should:

1. Make a call to delete hospitalization API first;
2. Call create a patient API again to re-submit the patient information.

Get active hospitalizations

Example Request:

GET /hospitalizations HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method allows to get all hospitalizations that have active value of the status field.

• Url: /hospitalizations
• Method: GET
• Synchronous
• Returns HTTP status 200 and a collection of hospitalization objects
• In case of error returns the Error object

Get hospitalization

Example Request:

GET /hospitalization/emr-hospitalization-id HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method allows to get information about hospitalization by id. Specify the hospitalizationId of the hospitalization object in the EMR. Use the same hospitalizationId that was supplied when hospitalization had been created.

• Url: /hospitalization/{hospitalizationId}
• Method: GET
• Synchronous
• Returns HTTP status 200 and the hospitalization object
• If hospitalization cannot be found in SmartFlow, the Error object will be returned with HTTP 404 status code

Attach to existing hospitalization

Example Request:

POST /hospitalization/sfs-hospitalization-guid/attach/emr-hospitalization-id HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

When a patient is created manually by the user with SmartFlow user interface, the hospitalization will be sent to EMR with hospitalizations.created event. The hospitalizationId field of the object will be empty, however, hospitalizationGuid field (a unique internal identifier of the hospitalization) will be provided. You may want to attach your EMR internal ID to this hospitalization to be able to receive any other type of events, as well as download patient reports and use any other API that requires hospitalizationId. The HTTP request below provides such possibility. It takes hospitalizationGuid value as one part of Url, while your internal hospializationId is included in another part of Url.

• Url: /hospitalization/{hospitalizationGuid}/attach/{hospitalizationId}
• Method: POST
• Body: empty
• Synchronous
• Returns HTTP status 200 in case the hospitalizationId has been successfully attached to the hospitalization located by hospitalizationGuid
• In case of error returns the Error object

Upon attachment to the existing hospitalization, Smart Flow will collect all treatments recorded so far for this hospitalization and send them with the treatments.records_entered event.

Delete hospitalization

Example Request:

DELETE /hospitalization/emr-hospitalization-id HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method deletes hospitalization by id. Specify the hospitalizationId of the hospitalization object in the EMR. Use the same hospitalizationId that was supplied when hospitalization had been created. This method also "unmaps" the hospitalizationId from the internal hospitalization record - this allows to submit the patient to SmartFlow again afterward.

• Url: /hospitalization/{hospitalizationId}
• Method: DELETE
• Synchronous
• If hospitalization cannot be found in SmartFlow, the Error object will be returned with HTTP 404 status code

Discharge hospitalization

Example Request:

POST /hospitalization/discharge/emr-hospitalization-id HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method initiates the patient discharge operation. Specify the hospitalizationId of the hospitalization object in the EMR. Use the same hospitalizationId that was supplied when hospitalization had been created. This API requires the valid timezoneName header specified in the request.

• Url: /hospitalization/discharge/{hospitalizationId}
• Method: POST
• Body: empty
• Asynchronous. In the case of success, the response will include the hospitalization object with the status field equal to discharged. At this point, all patient reports are not generated yet - SmartFlow only initiated the document generation process. After the files are generated, and operation is complete, SmartFlow will send the hospitalization.discharged event to the EMR.
• In case of error returns the Error object

Discharge hospitalization event

Example of hospitalizations.discharged event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "hospitalizations.discharged",
    "object": {
        "objectType": "hospitalizations",
        "id": "sfs-operation-id",
        "hospitalizations": [
            {
                "objectType": "hospitalization",
                "hospitalizationId": "emr-hospitalization-id",
                "hospitalizationGuid": "sfs-hospitalization-guid",
                "dateCreated": "2014-11-05T10:20:19.000+00:00",
                "fileNumber": "#File number",
                "reportPath": "https://pdf-report-webfile-path"
            }
        ]
    }
}

As soon as one or several patients have been discharged from the SmartFlow whiteboard, SmartFlow will notify EMR by sending one of the following events:

1. The hospitalization.discharged event in case if single patient was discharged. In this case the hospitalization object will be transferred with the event.

2. The hospitalizations.discharged event in case if multiple patients were discharged. In this case the hospitalizations object will be transferred with the event.

Every hospitalization object transferred with these events will contain the path to the flowsheet report pdf file in the reportPath field. If for some reason the value of this field is empty then you may explicitly download the flowsheet report.

Get notified about new hospitalizations

Example of hospitalizations.created event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "hospitalizations.created",
    "object": {
        "objectType": "hospitalizations",
        "id": "sfs-operation-id",
        "hospitalizations": [
            {
                "objectType": "hospitalization",
                "hospitalizationGuid": "sfs-hospitalization-guid",
                "dateCreated": "2014-11-05T10:20:19.000+00:00",
                "weight": 5.8,
                "estimatedDaysOfStay": 1,
                "fileNumber": "# 123",
                "caution": false,
                "color": "#439FE0",
                "doctorName": "Dr. Ivan",
                "medicId": "dr-ivan-emr-id",
                "diseases": [
                    "high temperature",
                    "vomiting"
                ],
                "patient": {
                    "objectType": "patient",
                    "name": "Jordi Alba",
                    "species": "Canin",
                    "owner": {
                        "objectType": "client",
                        "nameLast": "Dow",
                        "nameFirst": "Jack",
                        "workPhone": "555-55-55"
                    },
                    "color": "Brown",
                    "sex": "M",
                    "criticalNotes": "Cefazolin allergy",
                    "customField": "some notes"
                }
            }
        ]
    }
}

When hospitalization is created in SmartFlow (both through the user interface and create patient API) the hospitalizations.created event will be sent to EMR. The hospitalization object will be included in the payload.

The hospitalizationId field would be empty in case if the patient were created manually from SmartFlow user interface. You may want to attach your EMR internal ID to this hospitalization to be able to receive any other type of events, as well as download patient reports and use any other API that requires hospitalizationId.

You may find more details about attaching hospitalizations API here.

Download the Flowsheet report

Example Request:

GET /hospitalization/emr-hospitalization-id/flowsheetreport HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method allows to download the flowsheet report from SmartFlow.

All the dates in the downloaded report will be represented in the time zone that you must explicitly specify in the timezoneName header of the HTTP request (e.g. timezoneName: Europe/Helsinki). Please visit this web-page for the complete list of the time zone names.

Specify the hospitalizationId of the hospitalization object in the EMR. Use the same hospitalizationId that was supplied when hospitalization had been created.

• Url: /hospitalization/{hospitalizationId}/flowsheetreport
• Method: GET
• Synchronous
• Returns the pdf report with the output stream. The Content-Type header will contain the application/pdf value
• In case of error returns the Error object

For more information about merging reports functionality please take a look at Documents Management in Smart Flow section.

Download the Medical Records report

Example Request:

GET /hospitalization/emr-hospitalization-id/medicalrecordsreport HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method allows to download the medical record report from SmartFlow. Use this method when receiving hospitalizations.discharged event, as at this point the report should contain all medical records of the specified hospitalization.

All the dates in the downloaded report will be represented in the time zone that you must explicitly specify in the timezoneName header of the HTTP request (e.g. timezoneName: Europe/Helsinki). Please visit this web-page for the complete list of the time zone names.

Specify the hospitalizationId of the hospitalization object in the EMR. Use the same hospitalizationId that was supplied when hospitalization had been created.

• Url: /hospitalization/{hospitalizationId}/medicalrecordsreport
• Method: GET
• Synchronous
• Returns the pdf report with the output stream. The Content-Type header will contain the application/pdf value
• In case of error returns the Error object

Download the Billing report

Example Request:

GET /hospitalization/emr-hospitalization-id/billingreport HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: America/Chicago

This method allows to download the billing report from SmartFlow. Use this method when receiving hospitalizations.discharged event, as at this point the report should contain the complete inventory usage information of the specified hospitalization.

All the dates in the downloaded report will be represented in the time zone that you must explicitly specify in the timezoneName header of the HTTP request (e.g. timezoneName: America/Chicago). Please visit this web-page for the complete list of the time zone names.

Specify the hospitalizationId of the hospitalization object in the EMR. Use the same hospitalizationId that was supplied when hospitalization had been created.

• Url: /hospitalization/{hospitalizationId}/billingreport
• Method: GET
• Synchronous
• Returns the pdf report with the output stream. The Content-Type header will contain the application/pdf value
• In case of error returns the Error object

Download the Notes report

Example Request:

GET /hospitalization/emr-hospitalization-id/notesreport HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method allows to download the notes report from SmartFlow. Use this method when receiving hospitalizations.discharged event, as at this point the report should contain all the tech notes of the specified hospitalization.

All the dates in the downloaded report will be represented in the time zone that you must explicitly specify in the timezoneName header of the HTTP request (e.g. timezoneName: Europe/Helsinki). Please visit this web-page for the complete list of the time zone names.

Specify the hospitalizationId of the hospitalization object in the EMR. Use the same hospitalizationId that was supplied when hospitalization had been created.

• Url: /hospitalization/{hospitalizationId}/notesreport
• Method: GET
• Synchronous
• Returns the pdf report with the output stream. The Content-Type header will contain the application/pdf value
• In case of error returns the Error object

Estimates

Estimates created in the PIMS can be sent to SmartFlow, which allows a user to easily add these items to their treatment sheet. The estimate ID, if applicable, will be included with the treatment object if the item was added from an estimate.

There are the estimate and inventoryItems objects used to populate the estimate information in SmartFlow. This functionality is dependent on the inventory being set up by the user in the SmartFlow UI.

The estimates object

Attributes

The estimate object

Attributes

The ID of this object will be sent with treatments.records_entered events for you to associate with charges as needed.

The inventoryItems object

Attributes

Create an estimate

Example Typical Request:

POST /hospitalization/emr-hospitalization-id/estimate HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

{
    "objectType": "estimate",
    "hospitalizationId": "emr-hospitalization-id",
    "dateCreated": "2020-8-03T17:54:55.221+00:00",
    "description": "OVH with nail trim and pre-op bloodwork",
    "createdByName": "Dr Jones",
    "dateExpires": "2020-11-03T17:54:55.221+00:00",
    "externalId": "estimate-1234",
    "inventoryItems": [
        {
            "id": "some-emr-internal-id",
            "name": "Chem 17",
        },
        {
            "id": "some-emr-internal-id2",
            "name": "Nail Trim"
        }
    ]
}

• Url: /hospitalization/{hospitalizationId}/estimate
• Method: POST
• Synchronous
• Accepts estimate object
• Returns HTTP status 201 in case the new estimate has been created
• In case of error returns the Error object

Create multiple estimates

Example Typical Request:

POST /hospitalization/emr-hospitalization-id/estimates HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

{   "objectType": "estimates",
    "id":"all-todays-estimates-for-fluffy",
    "estimates": [
        {
        "objectType": "estimate",
        "HospitalizationId": "emr-hospitalization-id",
        "dateCreated": "2020-8-03T17:54:55.221+00:00",
        "Description": "OVH with nail trim and pre-op bloodwork",
        "CreatedBy": "Dr Jones",
        "DateExpires": "2020-11-03T17:54:55.221+00:00",
        "ExternalId": "estimate-1234",
        "InventoryItems": [
            {
                "id": "some-emr-internal-id",
                "name": "Chem 17",
            },
            {
                "id": "some-emr-internal-id2",
                "name": "Nail Trim"
            }
        ]
        },
        {
        "objectType": "estimate",
        "HospitalizationId": "emr-hospitalization-id2",
        "dateCreated": "2020-8-03T17:50:55.221+00:00",
        "Description": "Castration with nail trim",
        "CreatedBy": "Dr Jones",
        "DateExpires": "2020-11-03T17:50:55.221+00:00",
        "ExternalId": "estimate-1235",
        "InventoryItems": [
            {
                "id": "some-emr-internal-id4",
                "name": "Castration",
            },
            {
                "id": "some-emr-internal-id2",
                "name": "Nail Trim"
            }
        ]
        }
    ]
}

• Url: /hospitalization/{hospitalizationId}/estimates
• Method: POST
• Synchronous
• Accepts estimates object
• Returns HTTP status 201 in case the new estimates have been created
• In case of error returns the Error object

Get estimates associatd with a hospitalization

Example Request:

GET /hospitalization/emr-hospitalization-id/estimates HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method allows to get all estimates associated with a hospitalization.

• Url: /hospitalization/{hospitalizationId}/estimates
• Method: GET
• Synchronous
• Returns HTTP status 200 and a collection of estimate objects
• In case of error returns the Error object

Update estimate

Example Typical Request:

PUT /hospitalization/emr-hospitalization-id/estimate HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

{
    "objectType": "estimate",
    "hospitalizationId": "emr-hospitalization-id",
    "dateCreated": "2020-8-03T17:54:55.221+00:00",
    "description": "OVH with nail trim and pre-op bloodwork",
    "createdByName": "Dr Jones",
    "dateExpires": "2020-11-03T17:54:55.221+00:00",
    "externalId": "estimate-1234",
    "inventoryItems": [
        {
            "id": "some-emr-internal-id",
            "name": "Chem 17",
        },
        {
            "id": "some-emr-internal-id2",
            "name": "Nail Trim"
        },
        {
            "id": "some-emr-internal-id3",
            "name": "CBC (in-house)"
        }
    ]
}

• Url: /hospitalization/{hospitalizationId}/estimate
• Method: POST
• Synchronous
• Accepts estimate object
• Returns HTTP status 201 in case the estimate has updated successfully
• In case of error returns the Error object

Delete estimate

Example Request:

DELETE /hospitalization/emr-hospitalization-id/estimate/estimate-1234 HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"
timezoneName: Europe/Helsinki

This method deletes estimates by id. Specify the estimateId of the estimate object in the EMR. Use the same estimateId that was supplied when estimate had been created.

• Url: /hospitalization/{hospitalizationId}/estimate/{estimateId}
• Method: DELETE
• Synchronous
• If estimate cannot be found in SmartFlow, returns the Error object

Inventory Items

There are the inventoryitems and inventoryitem objects used to import inventory from EMR to SmartFlow.

The inventoryitems object

Example inventoryitems object with 2 nested inventoryitem objects:

{
    "objectType": "inventoryitems",
    "id": "some-operation-id",
    "inventoryitems": [
        {
            "objectType": "inventoryitem",
            "id": "some-emr-internal-id",
            "name": "Cefazolin 100",
            "concentration": 100,
            "concentrationUnits": "mg",
            "concentrationVolume": "ml"
        },
        {
            "objectType": "inventoryitem",
            "id": "some-emr-internal-id2",
            "name": "Ampicillin"
        }
    ]
}

This object should be sent with the /inventoryitems API method (POST or PUT method).

Attributes

The inventoryitem object

Attributes

Review Use-case for details on how concentration affects the user

Create or update single inventory item

Example Request:

POST /inventoryitem HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-SmartFlow"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

{
    "id": "external-inventory-id",
    "name": "Cefazolin 100",
    "concentration": 100,
    "concentrationUnits": "mg",
    "concentrationVolume": "ml"
}

Creates or updates single inventory item sent in the request.

• Url: /inventoryitem
• Method: POST
• Synchronous
• Accepts inventoryitem object
• Returns HTTP status 201 in case the new item has been created or an existing item has been updated
• In case of error returns the Error object

Create or update multiple inventory items

Example Request:

POST /inventoryitems HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-SmartFlow"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

{
    "id": "some-emr-operation-id",
    "inventoryitems": [
        {
            "id": "some-emr-internal-id",
            "name": "Cefazolin 100",
            "concentration": 100,
            "concentrationUnits": "mg",
            "concentrationVolume": "ml"
        },
        {
            "id": "some-emr-internal-id2",
            "name": "Ampicillin"
        }
    ]
}

Asynchronously creates or updates the inventory items sent with the request. Before creating an inventory item system tries to match it with any existing records by ID. If exact match is found then records are linked, otherwise a new inventory item is created.

• Url: /inventoryitems
• Method: POST
• Asynchronous
• Accepts inventoryitems object.
• Returns HTTP status 200 in case the input data has been accepted for import
• In case of error returns the Error object

After an import operation finishes SmartFlow will send the inventoryitems.imported event to the registered webhook. We will pass back the same inventoryitems object to EMR, and fill in the status of the import operation for every inventory item provided.

Retreive existing inventory items

• Url: /inventoryitems
• Method: GET
• Synchronous
• Returns HTTP status 200 and a collection of all inventoryitem objects linked with EMR
• In case of error returns the Error object

Retreive single inventory item

Returns the inventory item. Specify the id of the inventory item in the EMR. The same id that was supplied when object was created

• Url: /inventoryitem/{id}
• Method: GET
• Synchronous
• Returns HTTP status 200 and an inventoryitem object linked with EMR
• In case of error returns the Error object

Delete single inventory item

This method deletes an inventory item by id.

• Url: /inventoryitem/{id}
• Method: DELETE
• Synchronous
• If item cannot be found in SmartFlow, returns 200 Success message

Delete multiple inventory items

This method is available in our Sandbox environment as of Jan 2020, and will be available soon in production. This method deletes multiple inventory items by id.

• Url: /inventoryitems
• Method: DELETE
• Returns HTTP status 200
• Note that items which cannot be found will be ignored

Example Request:

DELETE /inventoryitems HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
clinicApiKey: "clinic-api-key-taken-from-account-web-page" 
emrApiKey: "emr-api-key-received-from-SmartFlow"

["id1", "id2", "id3", "...", "idN"]

Receiving the status of import operation

Example of inventoryitems.imported event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "inventoryitems.imported",
    "object": {
        "objectType": "inventoryitems",
        "id": "some-emr-internal-id",
        "inventoryitems": [
            {
                "objectType": "inventoryitem",
                "id": "some-emr-internal-id",
                "name": "Cefazolin 100",
                "concentration": 100,
                "concentrationUnits": "mg",
                "concentrationVolume": "ml",
                "asyncOperationStatus": 0
            },
            {
                "objectType": "inventoryitem",
                "id": "some-emr-internal-id2",
                "name": "Ampicillin",
                "asyncOperationStatus": -1,
                "asyncOperationMessage":  "Some error message"
            }
        ]
    }
}

SmartFlow will send the inventoryitems.imported event to the url provided by EMR at the end of asynchronous import operation. SmartFlow sends the inventoryitems object with this event. Every inventoryitem object will contain asyncOperationStatus and optionally asyncOperationMessage in case of errors.

• Url: webhook provided by EMR
• Method: POST
• Synchronous
• Transfers inventoryitems object included in the event object
• Expected response with 200 Http code in case of success.
• In case of the error, EMR should return 400 Http code and optionally the Error object

Vitals

There are the vitaltypes and vitaltype objects used to tell SmartFlow what vital signs you have in the EMR.

The vitaltypes object

Example vitaltypes object with 2 nested vitaltype objects:

{
    "objectType": "vitaltypes",
    "id": "some-operation-id",
    "vitaltypes": [
        {
            "dataType": "text",
            "objectType": "vitaltype",
            "id": "vtype_3",
            "name": "CRT (Text)"
        },
        {
            "dataType": "list",
            "options": [
                {
                    "id": "vtype_4_opt1",
                    "name": "RR Option 1"
                },
                {
                    "id": "vtype_4_opt2",
                    "name": "RR Option 2"
                }
            ],
            "objectType": "vitaltype",
            "id": "vtype_4",
            "name": "Resp Rate (List)",
            "units": []
        }
    ]
}

This object should be sent with the /vitaltypes API method (POST or PUT method).

Attributes

The vitaltype object

Attributes

Both the units and options arrays should include a dictionary with keys "id" and "name" for each item.

The vitals object

Attributes

Create or update single vital

Example Request:

POST /vitaltype HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-SmartFlow"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

{
    "dataType": "numeric",
    "min": null,
    "max": 120,
    "objectType": "vitaltype",
    "id": "vtype_5",
    "name": "Weight",
    "units": [
        {
            "id": "uid1",
            "name": "kg"
        },
        {
            "id": "uid2",
            "name": "lbs"
        }
    ]
}

Creates or updates single vital sent in the request.

• Url: /vitaltype
• Method: POST
• Synchronous
• Accepts vitaltype object
• Returns HTTP status 200 in case the new item has been created or an existing item has been updated
• In case of error returns the Error object

Create or update multiple vitals

Example Request:

POST /vitaltypes HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-SmartFlow"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

{
    "id": "idd",
    "objectType": "vitaltypes",
    "vitaltypes": [
        {
            "dataType": "text",
            "objectType": "vitaltype",
            "id": "vtype_3",
            "name": "CRT (Text)"
        },
        {
            "dataType": "list",
            "options": [
                {
                    "id": "vtype_4_opt1",
                    "name": "RR Option 1"
                },
                {
                    "id": "vtype_4_opt2",
                    "name": "RR Option 2"
                }
            ],
            "objectType": "vitaltype",
            "id": "vtype_4",
            "name": "Resp Rate (List)",
            "units": []
        }
    ]
}

Asynchronously creates or updates the vitals sent with the request.

• Url: /vitaltypes
• Method: POST
• Asynchronous
• Accepts vitaltypes object.
• Returns HTTP status 200 in case the input data has been accepted for import
• In case of error returns the Error object

After an import operation finishes SmartFlow will send the vitaltypes.imported event to the registered webhook. We will pass back the same vitaltypes object to EMR, and fill in the status of the import operation for every vital provided.

Receiving the entered vitals for a patient

Example of vitals.records_entered event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "vitals.records_entered",
    "object": {
        "objectType": "vitals",
        "vitals": [
            {
                "objectType": "vital",
                "vitalTypeId": "vtype_3_5",
                "name": "Weight-V",
                "hospitalizationId": "ExtId",
                "vitalGuid": "GuidString",
                "time": "2018-10-26T23:00:00.000+03:00",
                "status": "added",
                "value": "7.1",
                "source": 0,
                "doctorName": "Doctor",
                "doctor": null,
                "unit": {
                    "id": "viUnit3-1",
                    "name": "kg"
                },
                "asyncOperationStatus": null,
                "asyncOperationMessage": null
            }
        ],
        "id": "idOfVitalRecord"
    }
}

SmartFlow will send the vitals.records_entered event to the url provided by EMR each time a treatment is completed on a hospitalization, where that treatment is mapped to a Vital by the SmartFlow user. SmartFlow sends the vitals object with this event. The EMR should use the vitalTypeId and value, taking note of the status, unit, time and hospitalizationId to correctly action on this data.

• Url: webhook provided by EMR
• Method: POST
• Synchronous
• Transfers vitals object included in the event object
• Expected response with 200 Http code in case of success.
• In case of the error, EMR should return 400 Http code and optionally the Error object

Retreive existing vitals

If you need to check what vitals are in SmartFlow already, you can get a list with this call. Returns a list of all vitals.

• Url: /vitaltypes
• Method: GET
• Synchronous
• Returns HTTP status 200 and a collection of all vitaltype objects linked with EMR
• In case of error returns the Error object

Retreive single vital

If you need to check one specific vital is in SmartFlow already, you can do that with this call. Returns the specified vital. Specify the id of the vital in the EMR, the same id that was supplied when object was created.

• Url: /vitaltype/{id}
• Method: GET
• Synchronous
• Returns HTTP status 200 and an vitaltype object linked with EMR
• In case of error returns the Error object

Delete single vital

This method deletes an vital by id.

• Url: /vitaltype/{id}
• Method: DELETE
• Synchronous
• Returns HTTP status 204

Delete multiple vitals

This method deletes multiple vitals by id. Pass IDs as URL query parameters

• Url: /api/v3/vitaltypes?vitalTypeId={id}&vitalTypeId={id}&…
• Method: DELETE
• Returns HTTP status 204
• Note that items which cannot be found will be ignored

Receiving the status of import operation

Example of vitaltypes.imported event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "vitaltypes.imported",
    "object": {
        "objectType": "vitaltypes",
        "id": "some-emr-internal-id",
        "vitaltypes": [
            {
                "dataType": "list",
                "options": [
                    {
                        "id": "vtype_4_opt1",
                        "name": "RR Option 1"
                    },
                    {
                        "id": "vtype_4_opt2",
                        "name": "RR Option 2"
                    }
                ],
                "objectType": "vitaltype",
                "id": "vtype_4",
                "name": "Resp Rate (List)",
                "units": [],
                "asyncOperationStatus": null,
                "asyncOperationMessage": null
            }
        ]
    }
}

SmartFlow will send the vitaltypes.imported event to the url provided by EMR at the end of asynchronous import operation. SmartFlow sends the vitaltypes object with this event. Every vitaltype object will contain asyncOperationStatus and optionally asyncOperationMessage in case of errors.

• Url: webhook provided by EMR
• Method: POST
• Synchronous
• Transfers vitaltypes object included in the event object
• Expected response with 200 Http code in case of success.
• In case of the error, EMR should return 400 Http code and optionally the Error object

Medics

There are the medics and medic objects used to import the list of clinic stuff from EMR to SmartFlow.

The medics object

Example medics object with 2 nested medic objects:

{
    "objectType": "medics",
    "id": "some-operation-id",
    "medics": [
        {
            "objectType": "medic",
            "medicId": "some-emr-internal-id-1",
            "name": "Dr. Jackson",
            "medicType": "doctor"
        },
        {
            "objectType": "medic",
            "medicId": "some-emr-internal-id-2",
            "name": "Dr. Smith",
            "medicType": "doctor"
        }
    ]
}

This object should be sent with the /medics API method (POST or PUT method).

Attributes

The medic object

Attributes

Create or update single medic

Example Request:

POST /medic HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

{
    "medicId": "some-emr-internal-id-1",
    "name": "Dr. Jackson",
    "medicType": "doctor"
}

Creates or updates single medic object sent in the request. SmartFlow will attempt to link the transferred medic object with the internal SmartFlow items by name.

• Url: /medic
• Method: POST
• Synchronous
• Accepts medic object
• Returns HTTP status 201 in case the new item has been created or an existing item has been updated
• In case of error returns the Error object

Create or update multiple medics

Example Request:

POST /medics HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
emrApiKey: "emr-api-key-received-from-sfs"
clinicApiKey: "clinic-api-key-taken-from-account-web-page"

{
    "id": "some-operation-id",
    "medics": [
        {
            "medicId": "some-emr-internal-id-1",
            "name": "Dr. Jackson",
            "medicType": "doctor"
        },
        {
            "medicId": "some-emr-internal-id-2",
            "name": "Dr. Smith",
            "medicType": "doctor"
        }
    ]
}

Asynchronously creates or updates the medics objects sent with the request. Before creating a medic object system tries to match it with any existing records by name. If exact match is found then records are linked, otherwise a new medic is created.

• Url: /medics
• Method: POST
• Asynchronous
• Accepts medics object.
• Returns HTTP status 200 in case the input data has been accepted for import
• In case of error returns the Error object

After an import operation finishes SmartFlow will send the medics.imported event to the registered webhook. We will pass back the same medics object to EMR, and fill in the status of the import operation for every object provided.

Retreive existing medics

• Url: /medics
• Method: GET
• Synchronous
• Returns HTTP status 200 and a collection of all medic objects linked with EMR
• In case of error returns the Error object

Retreive single medic

Returns the medic object. Specify the id of the medic in the EMR. The same id that was supplied when the object was created

• Url: /medic/{id}
• Method: GET
• Synchronous
• Returns HTTP status 200 and an medic object linked with EMR
• In case of error returns the Error object

Delete single medic

This method deletes a medic by id.

• Url: /medic/{id}
• Method: DELETE
• Synchronous
• If item cannot be found in SmartFlow, the Error object will be returned with HTTP 404 status code

Delete multiple medics

This method is available in our Sandbox environment as of Jan 2020, and will be available soon in production. This method deletes multiple inventory items by id.

• Url: /medics
• Method: DELETE
• Returns HTTP status 200
• Note that items which cannot be found will be ignored

Example Request:

DELETE /medics HTTP/1.1
User-Agent: MyClient/1.0.0
Content-Type: application/json
clinicApiKey: "clinic-api-key-taken-from-account-web-page" 
emrApiKey: "emr-api-key-received-from-sfs"

["id1", "id2", "id3", "...", "idN"]

Receiving the status of the import operation

Example of medics.imported event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "medics.imported",
    "object": {
        "objectType": "medics",
        "id": "some-emr-internal-id",
        "medics": [
            {
                "objectType": "medic",
                "medicId": "some-emr-internal-id-1",
                "name": "Dr. Jackson",
                "medicType": "doctor",
                "asyncOperationStatus": 0
            },
            {
                "objectType": "medic",
                "medicId": "some-emr-internal-id-2",
                "name": "Dr. Smith",
                "medicType": "doctor",
                "asyncOperationStatus": -1,
                "asyncOperationMessage":  "Some error message"
            }
        ]
    }
}

SmartFlow will send the medics.imported event to the url provided by EMR at the end of asynchronous import operation. SmartFlow sends the medics object with this event. Every medic object will contain asyncOperationStatus and optionally asyncOperationMessage in case of errors.

• Url: webhook provided by EMR
• Method: POST
• Synchronous
• Transfers medics object included in the event object
• Expected response with 200 Http code in case of success.
• In case of the error, EMR should return 400 Http code and optionally the Error object

Notes

The are two objects used by SmartFlow to notify EMR when notes entered into the flowsheet or anesthetic:

• note

• notes

Both objects are sent with the asynchronous notes.entered event when one or several tech notes has been entered/removed.

The notes object

Attributes

The note object

Attributes

Retreive multiple notes

Example of notes.entered event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "notes.entered",
    "object": {
        "objectType": "notes",
        "id": "sfs-operation-id",
        "notes":[
            {
                "objectType": "note",
                "noteGuid": "sfs-note-guid1",
                "hospitalizationId": "external-hosp-id1",
                "time":"2013-03-28T14:23:56.000+00:00",
                "status": "changed",
                "text": "Lorem ipsum...",
                "type": 0,
                "anestheticGuid": null
            },
            {
                "objectType": "note",
                "noteGuid": "sfs-note-guid2",
                "hospitalizationId": "external-hosp-id1",
                "time":"2013-03-28T14:23:56.000+00:00",
                "status": "added",
                "text": "Donec eu mattis diam...",
                "type": 1,
                "anestheticGuid": "sfs-anesthetic-guid"
            }       
        ]
    }
}

• Url: webhook provided by EMR
• Method: POST
• Asynchronous
• Transfers notes object included in the event object
• Expected response with 200 Http code in case of success.
• In case of the error, EMR should return 400 Http code and optionally the Error object

Treatments

The are two objects used by SmartFlow to notify EMR when medical records entered into the flowsheet:

• treatment - this object is sent with the synchronous treatment.record_entered event when one medical record has been entered/removed;

• treatments - this object is sent with the asynchronous treatments.records_entered event when one or several medical records has been entered/removed. SmartFlow expects EMR to send the treatments object back with the /treatments API method after the treatments.records_entered event has been processed

The treatments object

Attributes

The treatment object

Attributes

Including treatments in the billing

SmartFlow provides a user interface option for the user to explicitly include or exclude the treatment from being included in the billing (see image below). This option is only shown for the parameters mapped to the EMR inventory items. If the user sets "Billing" option to ON, then true is provided with the billed field. Otherwise, Smart Flow sends false. If you receive a treatments.records_entered event where a treatment object has billed set as false, you should not enter this item on the invoice in your EMR. This generally means the item was not performed by the user.

Retreive single medical record

Example of treatment.record_entered event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "treatment.record_entered",
    "object": {
        "objectType": "treatmet",
        "name": "Cefazolin 100",
        "inventoryId": "external-inventory-id",
        "hospitalizationId": "external-hospitalization-id1",
        "treatmentGuid": "sfs-treatment-guid1",
        "time":"2013-03-28T14:23:56.000+00:00",
        "status": "changed",
        "qty": 3.5,
        "volume": 3.5,
        "value": "IZ",
        "mediaPath": "https://attached-image-webfile-path",
        "mediaContentType": "image/jpg",
        "units": "ml",
        "doctorName": "name-of-the-doctor",
        "doctor": {
            "objectType": "medic",
            "medicId": "some-emr-internal-id-2",
            "name": "name-of-the-doctor",
            "medicType": "doctor"
            }
    }
}

The treatment.record_entered event is sent from SmartFlow when one medical record has been entered/removed. SmartFlow will send treatment object with all information about medical record.

• Url: webhook provided by EMR
• Method: POST
• Synchronous (can be changed to asynchronous at some point)
• Transfers treatment object included in the event object
• Expected response with 200 Http code in case of success.
• In case of the error, EMR should return 400 Http code and optionally the Error object

Retrieve multiple medical records

Example of treatments.records_entered event JSON:

{
    "clinicApiKey": "clinic-api-key",
    "eventType": "treatments.records_entered",
    "object": {
        "objectType": "treatments",
        "id": "sfs-operation-id",
        "treatments":[
            {
                "objectType": "treatment",
                "name": "Cefazolin 100",
                "inventoryId": "external-inventory-id",
                "hospitalizationId": "external-hosp-id1",
                "treatmentGuid": "sfs-treatment-guid1",
                "time":"2013-03-28T14:23:56.000+00:00",
                "status": "changed",
                "qty": 3.5,
                "volume": 3.5,
                "value": "IZ",
                "units": "ml",
                "doctorName": "name-of-the-doctor",
                "doctor": {
                    "objectType": "medic",
                    "medicId": "some-emr-internal-id",
                    "name": "name-of-the-doctor",
                    "medicType": "doctor"
                    }               
            },
            {
                "objectType": "treatment",
                "name": "Temperature",
                "inventoryId": null,
                "hospitalizationId": "external-hosp-id2",
                "treatmentGuid": "sfs-treatment-guid2",
                "time":"2013-03-28T14:23:56.000+00:00",
                "status": "added",
                "qty": 1,
                "volume": null,
                "value": "36.6",
                "units": null,
                "doctorName": "name-of-the-doctor-2",
                "doctor": null
            }       
        ]
    }
}