8) Cross Model Abstraction Reference

This Blog entry is from the Getting Started in Jube section in Learn Jube.

The Cross Model Abstraction Page allows for the retrieval of Abstraction Rule values from other Entity Models. Cross Model Abstractions are a useful means of cross model communication alongside TTL Counters, which can also be incremented across models. A Cross Model Abstraction Value fetch is the process of retrieving the most current execution of a transaction in another model for that entity value. For example, if there are two models which share the same entity (e.g. an Account Identifier) yet they process inherently different data, the values created in Abstraction Rules in one model can be referenced in another model. Cross Model Abstraction Rules are one means of communicating between models with another possible means being TTL counters.

The page is available by navigating through the menu as Entity Models >>> Abstraction and Fitting > Cross Model Abstraction Reference. The page is presented as a tree objects for the purposes of administering a model child objects:


The general administration of this tree is as documented in the child object section of this documents, with the fields as defined follows:



This Example


The name of the model that the required Cross Model Abstraction belongs to. The model will be integrated for the most recent Abstraction Rule values for the last transaction for the Entity Key.



The Abstraction Rule to be returned from the most recent Abstraction for the Entity Key.


If following the Blog entries step by step, there exists only one Entity Model at this time, hence there would not be a Entity Model available. For the purposes of demonstration, a second model titled Account Non Monetary Events has been created. The second model processes audit events from customer accounts, such as change of address:


With the following Request XPath configuration example:


The IP is specified as a Search Key. A simple Abstraction Rule has been created in the new model, which counts up all events on an IP:


For completeness, a some events have been processed through the new Entity Model, but that is outside the scope of this Blog Entry however, the AccountID element as the same value as contained in the Account Financial Transaction messages taken from the formats document (Rich16).


Return to the Cross Model Abstraction Reference and create an entry as per the parameters set out in the table above and the following:


Click the Add button to create a version of this Cross Model Abstraction Rule:


On recalling the Account Financial Transactions XML Post, it can be see that an entry has been created reaching into the value created in the new model:


It can be seen that the Abstraction Rule has been returned and merged as if it were originating from the same entity model.

7) Code Construction Widget

This Blog entry is from the Getting Started in Jube section in Learn Jube.

Several pages in the platform rely on the construction of code and in all cases this is facilitated by a point and click construction tool or direct freehand code (yet heavily restricted with only certain language functions being allowed). In most cases the code is of vb.net dialect, unless it is used for reporting or Adaptation training in which case it is an SQL fragment.

The following example is taken from the Entity Models Activation Rules page, which can be navigated to via Entity Models >>> Activation >>> Activation Rules, then selecting any child:


The default is Builder which uses a point and click interface to build up the vb.net code.

The Rule Constructor takes the form of Object, Field, Comparison and Value. Depending upon the Rule that is being constructed, different Objects will be available. Hovering over the Data Object, there are a large amount of fields available for selection:


Upon selecting an Object field, the Comparison operator can be specified. The operators differ depending the area of the platform and how the model is configured:


Finally, the Value can be specified for comparison:


Upon each update made to the Rule and Code Constructor, the code fragment is written out to the code window:


Having the code written out in this manner is rather easier to review and also helps to identify if there are any obvious issues that would leads to compilation issues. Toggling to Coder, using the radio buttons towards the top of the the Code Construction Widget, it becomes possible to create code by hand:


When typing in code, every second and on change, the code is sent to the server to be parsed, returning any errors that may exist at that point of code construction:


It is incumbent on the user to continue constructing and correcting the code, until it is declared to be ‘Parsed and Compiled’:


Only a small number of tokens from the vb.net language are allowed in the Coder for security reasons.

As aforementioned, the Code Constriction Widget mostly creates vb.net dialect code, with the exception of the Adaptation page, which can be navigated to via Entity Models >>> Adaptation and Prescription, with an arbitrary child selected as follows:


In the case of Adaptation, the code is an SQL fragment which helps build a data set that is intended for machine learning:


It is not possible to update the Adaptation with hand crafted code.

6) Response Payload

This Blog entry is from the Getting Started in Jube section in Learn Jube.

All children have the option to specify if it should be specified as being a Response Payload. A Response Payload means that the content or value created by the object will be returned to the HTTP response stream, otherwise excluded. It is a means to reduce the amount of bandwidth that is used for extremely large models and thus speed up transport of the response message:


Irrespective of the Response Payload being selected, the value will still be stored in the archive database.

5) Name and Description

This Blog entry is from the Getting Started in Jube section in Learn Jube.

Each parent and child object entry will have a Name field, which is a character string accepting a maximum of 50 characters. A description field appears on a more irregular basis and is a character string accepting a large number of characters.


The Names for the object should always be unique for that object, for example each Abstraction Rule should have a unique name, whereas the description is of freehand.

4) Locked and Active

This Blog entry is from the Getting Started in Jube section in Learn Jube.

For every parent and for every child there exists an Active and Locked flag:


Both the Active and the Locked flags form part of the record and are updated in the same manner as the rest of its properties.

The Active flag provides a means to deactivate an object without having to delete it. In most cases deactivating a child object has a very similar behavior to deleting it, insofar as the entry will be unavailable for processing.

The Locked flag may be toggled in just one direction, Locking a record. If a record is Locked it means that all subsequent editing of that record is completely barred and the records is presented a read only. Locking records is useful to avoid the inadvertent update or deletion of important records. An example of objects that once created should not be deleted are Abstraction Rules which are in use my an Adaptation, as the alteration of these Abstraction Rules would render the results of the Adaptation inaccurate. Another example is ensuring that the Request XPath configuration, once created, remains unchanged such is the importance of these values in maintaining real time interfaces into the Jube Platform:


In the above example, note how the Update and Delete buttons are no longer available.

3) Child Versioning

This Blog entry is from the Getting Started in Jube section in Learn Jube.

For children there is a version system in place. When a record is created for a child object, it is always accompanied by version data:


The fields that relate to version of children are descried in the table as follows:




The version in a sequential number that indicates the extent to which this record has been updated. Upon a record being created, it is allocated version 1, then for each update (i.e. click of the update button) the version will increment by one.

User Created

The name of the user that last created or updated this child record.

Created Date

The date and time this record was last created or updated.

For children all update and deletes are done on a logical basis, which means that they are marked as deleted in the database but still remain there for the purposes of audit. When a child record is updated, in actuality the record being updated is logically deleted and a new record with the incremented version number is created. It follows that there is record for each update maintained in the database.

2) Children

This Blog entry is from the Getting Started in Jube section in Learn Jube.

Children roll up to the Parents and they are administered via a common user interface spanning the platform. In this example, a Request XPath will be added to an Entity Model (whereby the Entity Model was used as an example of a Parent object previously). The Request XPath page is available by navigating to Entity Models >>> References >>> Request XPath:


Navigation around children takes place via a tree control, where each parent is represented as the upper level of the tree object. In the following example, it can be seen that each parent is the top level of the tree:


To expand on the top most level to expose children, simply click on the triangle icon next to the parent name:


On clicking the triangle icon, a list of all children rolling up to the parent will be revealed:


To add a child object, click on the parent entry in the tree for which you wish to create the child, exposing a blank for for the creation of a child object in the right hand pane:


Upon completing each field required of the child object in right hand panel, clicking the Add button at the base of the form will commit the object:


Confirmation of the object having been committed will be returned care of the Add button disappearing and being replaced with an Update and Delete button, alongside confirmation of the version and created date:


If the tree is expanded, the new entry will be added to that tree, otherwise the new entry can be viewed by expanding as aforementioned:


To update a child object, start by expanding on the tree as described in the Navigate subsection of this section of the documentation, then click on the child entry to be edited:


Alter the values of the child object as required, then click the Update button to commit the changes:


Upon clicking Update, confirmation of a change to the child object is received by the Version being incremented by one:


As with update, to delete a child object, start by expanding on the tree as described in the Navigate subsection of this section of the documentation, then click on the child entry to be deleted. Upon the child object being expanded into the right hand pane, click on the Delete button to confirm that this child object requires deletion:


Upon clicking Delete, a prompt will be displayed which will ask for confirmation of this delete:


Upon confirmation being given, the delete will take place. The entry on the left hand pane will be removed from the tree if it is still expanded, whereas the right hand pane will write out further confirmation of the delete having taken place:


1) Parents

This Blog entry is from the Getting Started in Jube section in Learn Jube.

There are several basic hierarchies created in the JUbe platform, where a parent is created and many configuration elements cascade down from then.

For the time being, knowing the parents in the Jube platform and how to navigate to them is adequate. The following table details how to navigate to the parent objects in Jube:



Entity Models

Navigate to Entity Models >>> Entity Models


Navigate to Symbol Models >>> Symbols

Cases Workflows

Navigate to Administration >>> Cases >>> Cases Workflows


Navigate to Administration >>> Roles

The parents share similar characteristics for the purposes of administration. Firstly, a list control will return all parents configured for that part of the platform. In the following example, all Entity Models are returned:


To move from one record to the next, use the scroll buttons or index buttons at the base of the list:


To Add a record to an object, a button is implemented at the top of the List Control:


Clicking on this button will overlay an entry form to accept a new record:


Upon completing the form with valid values for this object (each of these is exhaustively documented later in Blog entries), to commit the record, it is a simple matter of clicking the tick box in the right hand corner of the list object:


Alternatively, clicking the opposing button will roll back the change:


To update an entry in the List control while browsing back and forth via the navigation buttons, it is a simple matter of clicking the pen icon at the bottom right hand corner of the list entry:


On Clicking the pen Icon, the entry will be overlay by a form entry, presenting the existing values for update:


Upon updating the form, the entry can be updating in the same manner as the addition, by clicking the tick icon:


Alternatively rolling back the change by clicking the opposing button:


To delete an entry, navigate to the entry in the entry in the list control that requires deletion and then click on the trash icon:


A message box will be displayed to confirm that it is the users intention that the entry is to be deleted, upon confirmation, the entry will be deleted:


1) HTTP Endpoint Request Payload and Switching

This Blog entry is from the Getting Started in Jube section in Learn Jube.

The Jube Platform does not have a hard-coded API specification and the HTTP Endpoint is promiscuous in the format of the GET or POST body that it accepts, with that POST body being parsed as per a specification configured in each Symbol or Entity model.

The POST body may be XML or JSON, in any structure, with its precise structure being configured in the Entity or Symbol model definition of Jube. It of course follows that the XML or JSON should pass a parse on receipt of the POST, appropriate to the specification. When the Jube Engine receives a HTTP request, the POST body is not initially inspected or parsed, instead only the Query String of the HTTP request is inspected for the presence of switching keys.

An example of a HTTP request to the Jube Engine is as follows:


In the above url the following parameters are implied:




SSL Encryption

http:// or https://

The http SSL designator which is used to encrypt HTTP traffic using SSL.



The IP address or sub domain name for which HTTP posts are to be made.



The colon designating a nonstandard port to be used, followed by the port.

This is not needed, but is included for completeness.

Query String Delineation


The model to be invoked for the purposes of processing the POST body is passed in the query string, everything that follows the ? will be considered model parameters.

Model Type Switch


While there are several parameters available in model recall, such as the ability to process a model asynchronously, for the purposes of this document there is a single parameter of EntityAnalysisModelGUID which, by virtue of its presence, switches to the entity subsystem and will seek a GUID as follows.



The GUID of the model, created automatically on model insert.

Switching, depending up the presence of a given Switch key, takes place in the following order:




A switch to be made to the Symbol Subsystem to process a new Symbol (e.g. Stock Price).


A switch to be made to the Exhaustive Subsystem to recall a trained model, bypassing the Entity Model and Symbol Model processing.


A switch to be made to the Entity Subsystem to process a new Entity (e.g. Account Transaction).

EntityAnalysisModelGUID and Tag

A switch to be made to process a Tag for a given transaction previously processed through an Entity Model.

Although the endpoint for all requests made to Jube is the same, the processing is very different depending upon the switch.

Jube has several pre-configured models for the purposes of validation, integration testing and confidence building. These pre-configured models will be explored in subsequent Blog entries. The pre-configured models and example switches and formats are contained in the formats document as follows:


The formats document provides examples of messages routed by each switch set out above.

2) Menu Navigation

This Blog entry is from the Getting Started in Jube section in Learn Jube.

Navigation in the Jube platform is performed by a Menu, where each Menu item will redirect the user to a specific page to administer a specific part of the Platform:


In the above example, navigating to the Request XPath screen would be refereed to as Navigate to Entity Modes > References > Request XPath, navigating firstly to the Entity Models menu item:


Then, the References sub menu item:


Then, the Request XPath sub menu item (in fact, this is both JSONPath and XPath):


Upon clicking on the menu item, in this case Request XPath, the whole page will be redirected away from the Activation Watcher to the Entity Models Request XPath page:


1) Logging into Jube.

This Blog entry is from the Getting Started in Jube section in Learn Jube.

If you have not already done so, create an account in Jube using the simple registration form. An account will be created straight away, although it may require a security check to be activated. You can check the status of your account using the support page or chat application.

Navigate to the login screen in Jube from the home page by clicking on the link, towards the left hand side:



If you are using a local installation of Jube, your link will be different and you will need to contact your system administrator.

Once navigated to the login screen, which can also be access directly from https://ui.jube.io/Login/Login the following screen will be displayed:


The login page needs to authenticate the user via a User Name and password. Insert the User Name and Password, in this case Example and a correct password:


Clicking on Login or pressing the Enter key will submit the form and attempt to authenticate the user, keeping in mind that in this case, the password is incorrect:


In the event that there is a problem with authentication and it fails, an error message will be returned in red below the login controls. In this example, repeat the process albeit with valid credentials:


A successful login will navigate to the Activation Watcher page as default.