SanteSuite Help Portal
  • SanteSuite Help Portal
    • Disclaimer
  • Product Overview
    • SanteSuite Products
      • Introducing SanteDB CDR
        • SanteDB Solutions
      • Master Patient Index - SanteMPI
      • Immunization Management System - SanteIMS
      • Privacy & Security - SanteGuard
    • SanteDB Versions
  • Architecture
    • SanteDB Architecture
      • SanteDB History
    • Solution Architecture
    • Software Architecture
      • Publish / Subscribe Architecture
      • New ADO (nuado)
      • Roadmap
    • Data & Information Architecture
      • Conceptual Information Model
        • Concept Dictionary
          • Data Dictionary
        • Acts
          • State Machine
          • Act Relationships
          • Mood Concepts
          • Class Concepts
          • Data Dictionary
        • Entities
          • State Machine
          • Entity Relationships
          • Determiner Codes
          • Class Codes
          • Data Dictionary
        • Null Reasons
        • Extended Data
      • Physical Model
        • Act Data Dictionary
        • Entity Data Dictionary
        • Concept Dictionary Data Dictionary
      • Data Storage Patterns
        • Master Data Storage
      • SanteDB Object Identifiers (OIDs)
    • Security Architecture
    • Privacy Architecture
    • Matching Engine
    • HIE & Interoperability
  • Installation
    • Installation
    • Releases
      • 3.0 Releases
      • Queenston Release
    • Quick Start Guide
      • Seeding ONC Patient Matching Data
    • Operationalizing SanteDB
      • Information Gathering & Analysis
      • Planning & Preparation Work
        • Pre-flight Checklist
        • Develop a Business Architecture
        • Develop an Information Architecture
          • Establishing Minimum Datasets
          • Identity Environment
        • Develop Operational Technology Architecture
        • Developing Privacy Impact Assessments
        • Develop Threat / Risk Assessments
      • Deployment
        • Pre-Flight Checklist
        • Installing Software
          • SanteDB iCDR Server
            • Installation on Virtual or Physical Environments
              • Installation on Microsoft Windows
              • Installation on Linux and Unix
            • Installation using Appliances
              • Using Docker Containers
                • Adding Sample Data
                • Feature Configuration
                • SanteDB within Instant OpenHIE
              • Using Virtual Appliances
            • Installation Qualification
              • Master Patient Index / Client Registry Qualification
                • MPI/CR Test Cases for HL7v2
                  • TEST: OHIE-CR-02-HL7v2
                  • TEST: OHIE-CR-03-HL7v2
                  • TEST: OHIE-CR-04-HL7v2
                  • TEST: OHIE-CR-05-HL7v2
                  • TEST: OHIE-CR-06-HL7v2
                  • TEST: OHIE-CR-07-HL7v2
                  • TEST: OHIE-CR-08-HL7v2
                  • TEST: OHIE-CR-09-HL7v2
                  • TEST: OHIE-CR-10-HL7v2
                  • TEST: OHIE-CR-11-HL7v2
                  • TEST: OHIE-CR-12-HL7v2
                  • TEST: OHIE-CR-13-HL7v2
                  • TEST: OHIE-CR-14-HL7v2
                  • TEST: OHIE-CR-15-HL7v2
                  • TEST: OHIE-CR-16-HL7v2
                  • TEST: OHIE-CR-17-HL7v2
                  • TEST: OHIE-CR-18-HL7v2
                  • TEST: OHIE-CR-01-HL7v2
                  • HL7v2 Test Cases Instructions
                • MPI/CR Test Cases for FHIR
                  • TEST: OHIE-CR-01-FHIR
                  • TEST: OHIE-CR-02-FHIR
                  • TEST: OHIE-CR-03-FHIR
                  • TEST: OHIE-CR-04-FHIR
                  • TEST: OHIE-CR-05-FHIR
                  • TEST: OHIE-CR-06-FHIR
                  • TEST: OHIE-CR-07-FHIR
                  • TEST: OHIE-CR-08-FHIR
                  • TEST: OHIE-CR-09-FHIR
                  • FHIR Test Cases Instructions
              • Security Administration Testing
                • Administrative Panel Validation
                  • User Management Tests
                    • TEST: SECURITY-UM-01
                    • TEST: SECURITY-UM-02
                    • TEST: SECURITY-UM-03
                    • TEST: SECURITY-UM-04
                    • TEST: SECURITY-UM-05
                    • TEST: SECURITY-UM-06
                    • TEST: SECURITY-UM-07
                    • TEST: SECURITY-UM-08
                    • TEST: SECURITY-UM-09
                    • TEST: SECURITY-UM-10
                    • TEST: SECURITY-UM-11
                    • TEST: SECURITY-UM-12
                    • TEST: SECURITY-UM-13
                    • TEST: SECURITY-UM-14
                    • TEST: SECURITY-UM-15
                    • TEST: SECURITY-UM-16
                    • TEST: SECURITY-UM-17
                    • TEST: SECURITY-UM-18
                    • TEST: SECURITY-UM-19
                    • TEST: SECURITY-UM-20
                    • TEST: SECURITY-UM-21
                    • TEST: SECURITY-UM-22
                    • TEST: SECURITY-UM-23
                    • TEST: SECURITY-UM-24
                    • TEST: SECURITY-UM-25
                    • TEST: SECURITY-UM-26
                    • TEST: SECURITY-UM-27
                    • TEST: SECURITY-UM-28
                    • TEST: SECURITY-UM-29
                    • TEST: SECURITY-UM-30
                    • TEST: SECURITY-UM-31
                    • TEST: SECURITY-UM-32
                    • TEST: SECURITY-UM-33
                    • TEST: SECURITY-UM-34
                    • TEST: SECURITY-UM-35
                    • TEST: SECURITY-UM-36
                    • TEST: SECURITY-UM-37
                  • Group/Role Management Tests
                    • TEST: SECURITY-GRM-01
                    • TEST: SECURITY-GRM-02
                    • TEST: SECURITY-GRM-03
                    • TEST: SECURITY-GRM-04
                    • TEST: SECURITY-GRM-05
                    • TEST: SECURITY-GRM-06
                    • TEST: SECURITY-GRM-07
                    • TEST: SECURITY-GRM-08
                    • TEST: SECURITY-GRM-09
                    • TEST: SECURITY-GRM-10
                    • TEST: SECURITY-GRM-11
                    • TEST: SECURITY-GRM-12
                    • TEST: SECURITY-GRM-13
                    • TEST: SECURITY-GRM-14
                    • TEST: SECURITY-GRM-15
                  • Security Policy Management Tests
                    • TEST: SECURITY-PM-01
                    • TEST: SECURITY-PM-02
                    • TEST: SECURITY-PM-03
                    • TEST: SECURITY-PM-04
                  • Device Management Tests
                    • TEST: SECURITY-DM-01
                    • TEST: SECURITY-DM-02
                    • TEST: SECURITY-DM-03
                    • TEST: SECURITY-DM-04
                    • TEST: SECURITY-DM-05
                    • TEST: SECURITY-DM-06
                    • TEST: SECURITY-DM-07
                    • TEST: SECURITY-DM-08
                    • TEST: SECURITY-DM-09
                  • Application Management Tests
                    • TEST: SECURITY-AM-01
                    • TEST: SECURITY-AM-02
                    • TEST: SECURITY-AM-03
                    • TEST: SECURITY-AM-04
                    • TEST: SECURITY-AM-05
                    • TEST: SECURITY-AM-06
                    • TEST: SECURITY-AM-07
                    • TEST: SECURITY-AM-08
          • SanteDB dCDR Instances
            • Installing Web Access Gateway
            • Installing Disconnected Gateway
            • Installing Disconnected Windows Application
            • Installing the dCDR SDK
            • User Interface App Settings
        • Configuring Privacy Controls
        • Post Deployment Tuning
        • Securing SanteDB Configuration
        • Securing SanteDB Databases
        • Securing SanteDB APIs
      • Rollout
    • Demonstration Environments
  • Operations
    • SanteDB Operations
    • Server Administration
      • Configuration Tool
        • Messaging Settings
          • HL7 Version 2 Service
          • FHIR R4 Service
          • GS1 BMS XML Service
          • Health Data Services Interface
          • Administrative Management Interface
        • Diagnostics Settings
        • Persistence Settings
          • Retention Policies
          • Resource Manager Settings
          • Database Connections
        • System Settings
        • Performance Settings
        • Security Settings
          • Data Privacy Filtering
          • Auditing Configuration
        • Operating System Settings
      • Server Configuration File
        • Service API Configuration
          • REST Service Configuration
        • Connection Strings
        • Application Service Context Configuration
        • Applet Configuration
        • Diagnostics Configuration
        • Data Quality Services
      • SanteDB iCDR Host Command
      • Backup Procedures
      • Log File Management
    • CDR Administration
      • SanteDB Administration Portal
        • Logging In
        • Managing Your Profile
        • System Administration
          • Jobs
          • Logs
          • Pub/Sub Manager
          • Server Status
          • Dispatcher Queue
          • Probes
        • Reference Data Administration
          • Place Administration
          • Facility Administration
          • Materials
          • Identity Domain Management
        • Concept Dictionary Administration
          • Concept Sets
          • Concepts
          • Code Systems
        • CDR Administration
          • Importing Data
          • Data Quality Rules
          • Extensions
          • Decision Support Library
            • View CDSS Library
            • Edit CDSS Library
          • Matching Configuration
            • Creating / Viewing Configurations
            • General Configuration
            • Blocking Configuration
            • Scoring Configuration
            • Classification Configuration
            • Testing Match Configuration
            • Match Configuration XML Definition
        • Data Warehouse
        • Reports Centre
        • Security Administration
          • Managing User Accounts
          • Managing Groups
          • Managing Policies
          • Managing Devices
          • Managing Applications
          • Reviewing Audits
      • SanteDB Administration Console
        • User Administration
        • Group / Role Administration
        • Policy Administration
        • Device Administration
        • Application Administration
    • Standard Operating Procedures
      • User Management SOPs
        • SOP: Onboarding Users
        • SOP: User Lockout
        • SOP: Deactivating Users
      • Role Management SOPs
        • SOP: Role Policy Assignment
        • SOP: Assigning Users to Roles
        • SOP: Creating New Roles
      • Device Management SOPs
        • SOP: Onboarding new HL7v2 Device
        • SOP: Onboarding new dCDR Device
      • Application Management SOPs
      • Standard Operating Procedure Template
  • User Guides & Training
    • SanteDB User Guides
    • Common User Interface Elements
    • SanteMPI
      • Getting Started with the MPI
      • SanteMPI Matches
      • SanteMPI Searching
      • SanteMPI Power Search
      • SanteMPI Patient Detail
        • Demographics Tab
          • Demographic Information Panel
          • Identifiers Panel
          • Related Persons Panel
          • Entity Relationships Panel
        • Master Data Management Tab
          • Records of Truth
        • Data Quality Tab
      • SanteMPI Dashboard
    • SanteEMR
      • EMR Administration
        • Care Pathways
        • Visit Types & Flows
        • Clinical Templates
    • SanteGuard
  • Developers
    • Extending & Customizing SanteDB
    • Getting Started
    • SanteDB XML Schemas
    • Applets
      • Applet Use and Lifecycle
      • Applet SDK Components
        • Applet Development Environment
        • SanteDB Brain Bug
        • Package Manager
        • BRE Debugger
      • Applet Structure
      • JavaScript API
      • Business Intelligence Assets
        • BI Asset Definitions
          • Data Sources
          • Parameters
          • Queries
          • Reference Data
          • Views
          • Data Marts
          • Reports
          • Indicators
        • BI Render Controls
      • Localization
      • Customization & Branding
      • Assets
        • HTML Assets
        • HTML Widgets
        • Virtual Assets
      • AngularJS
      • Clinical Decision-Support
        • CDSS Definitions
        • Legacy CDSS
      • Business Rules
      • Dataset Files
      • External Data Maps
      • Applet Solution Packages
      • JavaScript API Reference
      • Recipes
        • Adding Security Policy based on Occupation
        • Assigning a Home Facility
        • Codified Address
        • Generating ID on Registration
    • .NET Plugins
      • Plugin Libraries
      • Host Context & Lifecycle
      • Business Model Objects
      • Services & Configuration
        • Configuration
          • Configuration Panels
          • Custom Docker Feature Configuration
        • Passive Services
        • Daemon Services
        • Service Definitions
          • Ad-Hoc Cache Provider
          • Application Identity Provider
          • Audit Dispatch Service
          • Barcode Generator Provider
          • Business Rules Service
          • Care Plan Generation Service
          • CDSS Clinical Protocol Repository
          • Concept/Terminology Provider
          • Configuration Manager Service
          • Daemon Service
          • Data Archiving Service
          • Data Privacy Enforcement Provider
          • Data Signing Service
          • dCDR Subscription Definition Provider
          • dCDR Subscription Execution Provider
          • Device Identity Provider
          • Exec-Once Message Persistence
          • Freetext Search Provider
          • IDataPersistenceService{TData}
          • IDataPersistenceServiceEx{TModel}
          • IDataQualityConfigurationProviderService
          • Identity Domain Provider
          • IDispatcherQueueManagerService
          • IElevatableIdentityProviderService
          • IExtensionTypeRepository
          • IFastQueryDataPersistenceService{TEntity}
          • IFastQueryRepositoryService{TEntity}
          • IPersistableQueryRepositoryService{TEntity}
          • IPubSubManagerService
          • IRecordMergingService{T}
          • IRepositoryService
          • ISecurityRepositoryService
          • ISqlDataPersistenceService
          • IStoredQueryDataPersistenceService{TEntity}
          • ITagPersistenceService
          • ITemplateDefinitionRepositoryService
          • IThreadPoolService
          • IUnionQueryDataPersistenceService{TEntity}
          • IValidatingRepositoryService{TModel}
          • Job Management Service
          • Localization Provider
          • Mail Repository Provider
          • Name Alias Provider
          • Network Metadata Provider
          • Password Hashing Service
          • Password Validation Service
          • Policy Decision Provider (PDP)
          • Policy Enforcement Provider (PEP)
          • Policy Information Provider (PIP)
          • Primary Data Caching Provider
          • Query Result Scoring Provider
          • Record Matching Configuration Provider
          • Record Matching Provider
          • Record Merging Provider
          • Repository Service
          • Repository Service with Cancellation Support
          • Repository Service with Extended Functions
          • Repository Service with Notification Support
          • Resource Checkout/Locking Provider
          • Resource Patching Provider
          • Resource Pointer Service
          • Role Provider
          • Security Challenge Authentication Provider
          • Security Challenge Storage Provider
          • Session Authentication Provider
          • Session Storage Provider
          • Stateful Query Provider
          • Stock Management Provider
          • Symmetric Encryption Provider
          • TFA/MFA Secret Generator
          • User Identity Provider
          • User Notification Relay Provider
          • User Notification Template Filler
          • User Notification Template Repository
      • Plugin Metadata
      • Database Patching
      • Custom Match Algorithms
      • Unit Testing Framework
      • Digital Signing Requirements
      • .NET API Reference
    • Service APIs
      • OpenID Connect
        • Consent & Privacy
      • Business Intelligence Service (BIS)
      • Administration Management Interface (AMI)
      • Health Data Service Interface (HDSI)
        • HTTP Request Verbs
        • HDSI Query Syntax
          • Filter Functions
        • API Responses
        • Patching
        • MDM Extensions for HDSI
        • Synchronization API
        • Visual Resource Pointer API
      • HL7v2
        • Enabling HL7v2 Interfaces
        • HL7 Authentication
        • SanteDB HL7v2 Implementation
      • HL7 FHIR
        • Enabling FHIR Interfaces
        • SanteDB FHIR Implementation
          • FHIR Subscriptions
          • Related Persons
        • Extending FHIR Functionality
      • GS1 BMS XML
      • Examples
        • Connecting to the FHIR API
        • Obtaining A Session
    • SanteDB Software Publishers
  • Knowledgebase
    • Knowledgebase
      • SanteDB 2.1.161+ on PostgreSQL 10 returns "websearch_to_tsquery" error
      • Upgrading SanteDB iCDR with large databases
      • Upgrading Gateway to SanteDB Langley (v2.0.30+) from SanteDB Kelowna and earlier
      • When sending a National Scoped ID in PID-19 (SSN) you receive "AuthorityUuid" missing error
      • After Installing dCDR you receive an error on SecurityUser
      • When logging into the dCDR you are immediately logged back out
      • PostgreSQL connections fail with block message
      • Backing up HDSI server database
      • You receive an "out of disk space" error on the IMS server
      • Setting up the "sherlock" service
      • Diagnosing service port issues
      • You receive a certificate expired or certificate not found error on startup
      • After updating a database field the values are not reflected in the application layer
      • Diagnosing Submission Errors From Mobile Device
      • Migrating A SanteDB Server
      • Pruning and Cleaning the Database
      • Improving Download Speeds on Slow Connections
      • You receive a client already running error message
      • Resetting the configuration of the Windows & Linux Applications
      • After setting up the application data appears to be missing
      • Disconnected Client Window is Scaled Improperly
      • Fatal Error on Startup
      • Synchronization Issues on Mobile
      • Installation on Mono 4.x does not permit joining of realm
      • Creating A Public Backup
      • Installing the SanteDB Disconnected Server
    • Fixes & Patches
      • 20170721-01
      • 20170725-01
      • 20170803-01
      • 20170804-01
      • 20170913-01
      • 20171003-01
      • 20171011-01
      • 20171016-01
      • 20171023-01
      • 20171030-01
      • 20171108-01
      • 20171124-01
      • 20180126-01
      • 20180131-01
      • 20180211-01
      • 20181112-01
      • 20181113-01
      • 20190322-01
      • 20190522-01
      • 20190625-01
      • 20200105-01
  • OpenIZ
    • About OpenIZ
      • Upgrading from OpenIZ to SanteDB
    • FAQ
    • OpenIZ Demonstration Servers
Powered by GitBook
On this page
  • Introduction
  • What is a Business Rule?
  • How does SanteDB treat Business Rules?
  • Technically how is this done?
  • A simple business rule
  • Debugging your business rules
  • More Information

Was this helpful?

  1. Developers
  2. Applets

Business Rules

PreviousLegacy CDSSNextDataset Files

Last updated 3 years ago

Was this helpful?

Introduction

This tutorial is intended to assist developers with the writing of business rules using the SanteDB Jint business rules engine (the default business rules engine in SanteDB).

SanteDB can run rules in the user interface on demand (which run in the user's browser) otherwise they are run in the dCDR and iCDR using a C# to JavaScript interpreter bridge named . The JINT library.

  • SanteDB < 2.0.x use JINT 2.0 which is compatible with ECMA Script 5.1

  • SanteDB > 2.1.x use JINT 3.0 Beta which is compatible with a subset of ECMA Script 6 functions (see: )

What is a Business Rule?

SanteDB provides a series of extension points where developers can write custom triggers to modify, extend, add, or remove data from resources. These changes are used to implement business rules on the series of objects the subscribe to. Some examples might be:

  • Interpreting an observation based on some pre-defined lookup tables

  • Merging patients before they are persisted based on specified criteria

  • Validating that a substance administration is correct before persisting it

This article covers writing business rules in JavaScript in your applets. While this method is convenient and allows sharing of a single business rule implementation in all dCDR instances and the iCDR, if you require higher performing business rules on the iCDR, consider implementing a Business Rules Servicein C# instead.

How does SanteDB treat Business Rules?

Business rules subscribe to persistence events on the repository layer of the architecture. Whenever a piece of data is modified, these events fire, and the correlated business rules are triggered.

Technically how is this done?

From a technical standpoint, SanteDB (and the disconnected client) compile JavaScript into .NET code at runtime. An entire BRE script is executed on application startup (or server startup) and here the script is free to subscribe to a series of events.

These events are:

Event

Description

BeforeInsert

Fired before data is persisted to the database

AfterInsert

Fired after data has successfully been persisted to the database

BeforeUpdate

Fired before data is updated in the database

AfterUpdate

Fired after data has successfully been updated in the database

BeforeObsolete

Fired prior to data being obsoleted in the database

AfterObsolete

Fired after data has been obsoleted in the database

BeforeQuery

Fired before a query is run allowing the rule to change query

AfterQuery

Fired after a query has been executed and results are ready

Business rules which are executed before persistence (BeforeInsert, BeforeObsolete, BeforeUpdate) have the opportunity to change data that is about to be persisted. This is done by returning data from the function which is to be updated.

Business rules which are executed after persistence (AfterInsert, AfterObsolete, AfterUpdate) may also change data, however it is important to note that these are done as a separate transaction as the rules are executed after the operation has been committed to the database. This means that any operation where the "After" trigger fails, will result in a 422 response to the client, whilst the data is persisted to the database.

If your trigger requires operation within the master transaction, however you want to ensure the persistence is completed, you can return a Bundle (for a transaction) and push additional operations to the scoped bundle.

A simple business rule

Business rules are loaded from the rules/ folder of your applet. This tutorial will create a rule which will add a tag to a patient called "ReviewState" and will set it to "NotReviewed". This operation will illustrate the BeforeInsert rule and AfterUpdate rules.

  1. Create an empty JavaScript file in the rules/ folder of your applet

  2. We need to call the SanteDBBre.AddBusinessRule() function to register our rule, we're subscribing to "Patient"s.

    SanteDBBre.AddBusinessRule("id", "Patient", "BeforeInsert", [], function(patient) {
    
    });

    The AddBusinessRule function accepts a callback which is to be called whenever the trigger "BeforeInsert" on a Patient is called. The [ ] is reserved for filter properties which prevent the filter from being called.

  3. Next, we want to add a tag to this patient object, this is done using the standard SanteDB JavaScript bridge functionality you write your regular applet controller code in:

    SanteDBBre.AddBusinessRule("my_patient_rule", "Patient", "BeforeInsert", [], function(patient) {
    
        patient.tag = patient.tag || {};
        // ensure the rule has not been run
        if(patient.tag["ReviewState"] === undefined)
            patient.tag["ReviewState"] = 'NotReviewed';
        return patient;
    
    });
  4. Next, we may want to add a rule for AfterUpdate which clears this tag or sets the status to reviewed (note: since AfterUpdate is called after the data is committed, we have to manually save. We could call SanteDB.resources.patient.saveAsync() however that would result in a new version. For tagging we can use the built-in SaveTags function)

     SanteDBBre.AddBusinessRule("my_patient_rule", "Patient", "AfterUpdate", [], function(patient) {
    
         patient.tag = patient.tag || {};
    
         // is the state 'NotReviewed'?
         if(patient.tag["ReviewState"] == 'NotReviewed') {
             patient.tag["ReviewState"] = 'Reviewed';
             SanteDBBre.SaveTags(patient); // we updated the tag after a commit so we have to save them manully
         }
    
         return patient;
     });

Adding Validation

Another operation that can be injected into the SanteDB logic is resource validation. If you have custom rules that you would like evaluated before a resource is saved, you can add a validation function.

For example, if we want to prevent patients from being saved without a date of birth or gender, we could write a simple validator:

SanteDBBre.AddValidator("my_patient_validator", "Patient", function(patient) {
    var issues = [];

    if(!patient.dateOfBirth)
        issues.push({ text: 'Patients must have date of birth', priority: 1 });
    if(!patient.genderConcept)
        issues.push({ text: 'Patients must have a gender', priority: 1 });
    
    return issues;
});

The result of the validator function is an array of SanteDBBre.DetectedIssue instances.

Debugging your business rules

The SanteDB SDK provides a mechanism to debug your business rules including setting break points, stepping in/over functions, etc. These tools are provided via the sdb-dbg program in the SDK.

When running the SDK you must specify a disconnected client database to test with. This can acquired using several techniques:

  • Creating a backup from the SanteDB Disconnected Client mobile application

  • Pointing the database at a configured sdb-ade database (--db=%localappdata%\sdbare\santedb.sqlite). Note this is the default operating mode when launching the application from the start menu.

  • Creating a new database and using anonymous patients (only recommended for simple protocols)

To debug a clinical protocol, you can use the following command:

> sdb-ade --db=newdb1.sqlite --bre
SanteDB Debugger v1.10.0.20334 (Fredericton)
Copyright (C) 2015-2019 Mohawk College of Applied Arts and Technology
Loading debuggees...
Working Directory: C:\Users\justin\Documents
Ready...
dbg >

Note that you can pre-load a script file by specifying --source= , however this tutorial, will load the file from the debug command prompt.

dbg >cd c:\users\justin\source\repos\applet-starter\rules
INF: c:\users\justin\source\repos\applet-starter\rules
dbg >x tageme.js
tagme.js (run) >
Execution Finished
tagme.js (idle) >

The command to "open" a file (o) will only load the file into the current source buffer, whereas "execute file" (x) will load the file and execute it.

We can print the file contents using the print file (pf) command:

tagme.js (idle) >pf
[1]   SanteDBBre.AddBusinessRule("Patient", "BeforeInsert", [], function(patient) {
[2]
[3]       patient.tag = patient.tag || {};
[4]       // ensure the rule has not been run
[5]       if(patient.tag["ReviewState"] === undefined)
[6]           patient.tag["ReviewState"] = 'NotReviewed';
[7]       return patient;
[8]
[9]   });

Setting a breakpoint is done using the break (b) command and a line number. For example, the commands b 3 and then pf 0 10 will set a breakpoint at line 3 and then print the file from lines 0 to 10:

tagme.js (idle) >b 3
tagme.js (idle) >pf 0 10
[1]   SanteDBBre.AddBusinessRule("Patient", "BeforeInsert", [], function(patient) {
[2]
[3]***    patient.tag = patient.tag || {};
[4]       // ensure the rule has not been run
[5]       if(patient.tag["ReviewState"] === undefined)
[6]           patient.tag["ReviewState"] = 'NotReviewed';
[7]       return patient;
[8]
[9]   });
[10]

Notice the *** indicator for the breakpoint. You can also list a series of breakpoints with the breakpoint list command (bl).

In order to execute a rule, we first must load a Patient into scope. This can be done with either:

  • Set data query (sdq) to load a patient from the database

  • Set data file (sfv , sfx, or sfj) to load the patient from view model, XML or JSON respectively

  • Creating a new patient with set scope (ss)

For this tutorial lets set the scope to a new patient:

tagme.js (idle) >ss Patient '{ "dateOfBirth":"2017-01-01" }'
tagme.js (idle) >dj
{
  "dateOfBirth": "2017-01-01",
  "language": [],
  "classConcept": "bacd9c6f-3fa9-481e-9636-37457962804d",
  "determinerConcept": "f29f08de-78a7-4a5e-aeaf-7b545ba19a09",
  "relationship": [],
  "$type": "Patient"
}
tageme.js (idle) >

Dumping the scope can be done as:

  • XML (IMSI format) with dump scope xml (dx)

  • JSON (IMSI format) with dump scope JSON (dj)

  • View Model (Applet Format) with dump scope viewmodel (dv)

Scope data can be exchange with exchange scope (xs), which is useful if you're using the set data query operation to select a single result.

Once we're ready to run a rule, we use the goto rule function (go.rule). Because a breakpoint is set on line 3 in BeforeInsert the debugger will break on line 3:

tageme.js (idle) >go.rule BeforeInsert
[3]++>    patient.tag = patient.tag || {};

At a breakpoint we can print the current block of code with print block (pb) to get context of where our breakpoint is (highlighted with +++>)

tageme.js @ 3 (step) >pb
[1]   SanteDBBre.AddBusinessRule("Patient", "BeforeInsert", [], function(patient) {
[2]
[3]++>    patient.tag = patient.tag || {};
[4]       // ensure the rule has not been run
[5]       if(patient.tag["ReviewState"] === undefined)
[6]           patient.tag["ReviewState"] = 'NotReviewed';
[7]       return patient;
[8]

Our prompt will also show the current line of code (tagme.js @ 3 (step)).

We can use the dump local (dl) or dump global (dg) to inspect the contents of the local or global JavaScript scope:

tageme.js @ 3 (step) >dl
Count:2
[patient] System.Dynamic.ExpandoObject
[arguments] [object Arguments]

To get a specific variable contents we dump the object

tageme.js @ 3 (step) >dl patient
Count:4
[$type] Patient
[$id] obj0
[dateOfBirth] 1/1/2017 12:00:00 AM
[creationTimeModel] 1/1/0001 12:00:00 AM

To increment the program we can use:

  • Step over using "go over" (go) which will run the line of code and stop

  • Step into using "go in" (gi) which will run the line of code and break at the first line of a called function

  • Go until next breakpoint (gn) which will continue to run the program until the next break point is hit

  • Step out using "go up" (gu) which will execute until the current scope is exited

If we run the rule line by line using go we get the following output:

tageme.js @ 3 (step) >go
[5]++>    if(patient.tag["ReviewState"] === undefined)
tageme.js @ 5 (step) >go
[6]++>        patient.tag["ReviewState"] = 'NotReviewed';
tageme.js @ 6 (step) >go
[7]++>    return patient;
tageme.js @ 7 (step) >go
tageme.js @ 7 (step) >
Execution Complete, result set to scope

The execution of the rule is now complete, if we were to dump the scope we would see our patient object has been updated with our tag:

tageme.js (idle) >dj
{
  "dateOfBirth": "2017-01-01",
  "language": [],
  "classConcept": "bacd9c6f-3fa9-481e-9636-37457962804d",
  "determinerConcept": "f29f08de-78a7-4a5e-aeaf-7b545ba19a09",
  "relationship": [],
  "tag": [
    {
      "key": "ReviewState",
      "value": "NotReviewed",
      "$type": "EntityTag"
    }
  ],
  "creationTime": "0001-01-01T00:00:00.0000000-05:00",
  "$type": "Patient"
}

We can also debug our validator by running go.validate:

tageme.js (idle) >go.validate
tageme.js (run) >Error  Patients must have a gender

Execution Complete

Here we can see our validation rule has failed for the currently scoped patient. In the IMS this result in an HTTP 422 error and an OperationResult with that message listed.

More Information

You can find out more information about how to use the debugger with the debugger manual pages.

JINT
https://github.com/sebastienros/jint/blob/main/README.md