Unifi can be patched between releases by using a special Script Include called hotfix. If you find a bug in Unifi we may issue an update to hotfix so you can get the features you need without having to upgrade.

Upgrading

When upgrading Unifi, you can revert to the latest version of hotfix included in the upgrade. We reset hotfix with each release when the fixes become part of the main application.

Patching

We occasionally release a hotfix when minor issues are found. Simply replace the script in the hotfix Script Include with the one shown below and you will instantly have access to the fixes.

These hotfixes will be shipped as real fixes with the next version of Unifi, so make sure you have the correct hotfix for your version.

/**
 * Executes a child function corresponding to the object's type property.
 * The object is passed to the child function so methods and properties can be overridden.
 *
 * @param  {Object} obj The full class object to be patched.
 */
function hotfix(obj) {
  var type = typeof obj === 'function' ? obj.prototype.type : obj.type;
  if (type && typeof hotfix[type] === 'function') {
    hotfix[type](obj);
  }
}

hotfix.version = '4.0.2.3';

hotfix.Dataset = function (Dataset) {
  // Fix import logging
  Dataset.beginTransform = function beginTransform(dataset_id, import_set) {
    var dataset = Dataset.getInstance(dataset_id);
    var request = DatasetRequest.findActive(dataset);
    if (request.isValidRecord()) {
      ActivityLog.setDocument(request.getRecord());
      request.setProcessing();
      request.setStatus('Transform in progress...');
      request.setImportSet(import_set.sys_id);
      request.commit();
    } else {
      ActivityLog.setDocument(dataset);
    }
    if (!dataset.getElement('import_logging')) {
      ws_console.info('Logging is disabled. Please enable import logging on the Dataset to see Activity Logs for import set rows.');
      ws_console.pause();
    }
  };
};

hotfix.AttachmentHandler = function (AttachmentHandler) {
  // Allow multi-table attachment handling
  AttachmentHandler.createBondAttachment = function createBondAttachment(attachment) {
    var send = false,
        bond_gr,
        gr;

    function getBonds(sys_id, table) {
      var gr = new GlideRecord('x_snd_eb_bond');
      gr.addQuery('document', '=', sys_id);
      gr.addQuery('table', '=', table);
      gr.addQuery('state', '!=', 'Closed');
      gr.query();
      return gr;
    }

    function getConfig(bond) {
      return new Process(bond.integration.process).getConfig();
    }

    bond_gr = getBonds(attachment.table_sys_id, attachment.table_name);

    while (bond_gr.next()) {
      if (AttachmentHandler.addToBond([attachment], new Bond(getConfig(bond_gr), bond_gr))) {
        send = true;
      }
    }

    if (send) {
      gr = new GlideRecord(attachment.table_name);
      gr.get(attachment.table_sys_id);
      if (gr.isValidRecord()) {
        Message.processOutbound(gr, {
          attachment_added: true, // only match messages with "Attachment added" condition
          parent_tables: true // search table hierarchy
        });
      } else {
        gs.error(t('Attachment %0 does not have a valid record. Cannot process outbound.', attachment));
      }
    }
  };
};

hotfix.IntegrationTest = function (IntegrationTest) {
  // Fix integration delete from Designer portal
  IntegrationTest.getDeleteStack = function getDeleteStack(config, sys_id) {
    var stack = new Stack('x_snd_eb_integration_test', 'integration_test');

    if (sys_id) {
      stack.filter('sys_id=' + sys_id); // delete this record
    } else {
      stack.filter(function (scope, data) { // deleting parent record
        if (scope.integration) {
          return 'integration=' + scope.integration;
        }
        return 'sys_id=-1';
      });
    }

    stack.each(function (integration_test, scope, data) {
      scope.integration_test = integration_test.sys_id + '';
    });
    stack.afterEach(function (integration_test, scope, data) {
      integration_test.deleteRecord();
    });

    stack.addChild(IntegrationTestScenario.getDeleteStack(config));

    return stack;
  };
};

hotfix.Bond = function (Bond) {
  // UN-1266 Insert the bond when it is created to prevent double bonds from sync updates that 
  // happen before the insert has finished. This only applies to inbound transactions.
  Bond.prototype.create = function create(integration, internal_ref, external_ref, ref_method) {
    var ref;

    if (!external_ref && !internal_ref) {
      throw this.customError('Cannot create bond. No reference given.');
    }

    if (this.locateReference(integration, internal_ref, external_ref, ref_method)) {
      ref = this._getRefText(internal_ref, external_ref);
      throw this.customError('Bond already exists for document. ' + ref + '.');
    }

    this.newRecord();
    this.setValue('integration', integration.getValue('sys_id'));
    this.setValue('internal_reference', internal_ref);
    this.setValue('external_reference', external_ref);
    this.setValue('state', 'Pending');
    this.setValue('status', 'OK');
    this.isNew(true);
    Model.prototype.commit.apply(this);
  };
};

hotfix.Integration = function (Integration) {
  // Fix UN-1298 error messages defined on the Integration are not retrieved properly
  Integration.prototype.getSyncErrorMessage = function getSyncErrorMessage() {
    return Message.getMessageById(this.getConfig(), this.getValue('sync_error_message'));
  };
  Integration.prototype.getAsyncErrorMessage = function getAsyncErrorMessage() {
    return Message.getMessageById(this.getConfig(), this.getValue('async_error_message'));
  };
};

hotfix.DataSetProcessor = function (DataSetProcessor) {
  // Fix UN-1299 prevent DataSetProcessor events from being queued when there is no additional data to process
  DataSetProcessor.prototype._executeQueue = function _executeQueue(callback) {
    var rows = this._execute(callback);
    if (this.event) {
      if (rows == this.limit && this.gr && this.gr.hasNext()) {
        ws_console.info('Event ' + this.event.name + ' processed the maximum ' + this.limit + ' records. Auto queueing next event.');
        this.queueNext(this.event, this.current);
      } else {
        ws_console.info('Event ' + this.event.name + ' processed less than the maximum ' + this.limit + ' records. Processing complete.');
      }
    } else {
      ws_console.warn('Cannot auto queue additional processing; event not found.');
    }
    return rows;
  };
};

Unifi has some functionality that requires access to methods not available to scoped applications. We grant Unifi access to those methods through a single global utility Script Include which you can install via Update Set.

With version 4.0, the Update Set also includes a queue processing job Unifi dataset events process which is necessary for Datasets to be processed.

It is strongly advised that you install this utility to get the most out of Unifi.

1. Download Unifi Global Utility.

2. Import the file as an update set, then preview and commit it. You can find more information on how to Load customizations from a single XML file in the ServiceNow Product Documentation.

Dependent Features

Execute Now

Method: snd_eb_util.executeNow(job)

This is necessary for Datasets to execute their associated ServiceNow Import Job.

Get SOAP Response Element

Method: snd_eb_util.getSoapResponseElement(xml)

When working with Scripted SOAP Services, it’s important to be able to set the soapResponseElement directly in order to preserve the exact payload to be sent back to the calling system. This can only be done with the Global Utility.

Moving Attachments

Method: snd_eb_util.moveAttachments(attachment_ids, record)

The ServiceNow scoped attachment API does not support moving attachments from one record to another. This is necessary for inbound attachments which initially reside on the HTTP Request and are then moved to the Target record.

Run As User

Method: snd_eb_util.runAsUser(user, fn)

On occasion, Unifi needs to run some code as the given user. This is necessary things like replaying requests.

Jelly Processing

Method: snd_eb_util.runJelly(jelly_code, vars)

Jelly processing is not supported in the ServiceNow scoped API’s, however it is very useful for XML processing. Use of the Global Utility drastically improves XML payload capabilities if you are working with XML payloads.

Script Validation

Method: snd_eb_util.validateScript(script, scope)

Used by the Unifi Integration Diagnostic to check scripts for errors.

Binary Attachment Handling

Method: snd_eb_util.writeAttachment(record, filename, content_type, data)

The Scoped Attachment API does not support writing binary attachments which can cause problems when receiving things like Word documents or PDF’s. This method allows Unifi to use the global attachment API to write those files to the database meaning they will work properly.

Update Set Packaging

Method: snd_eb_util.packager.*

The packager methods included in the global utility allow Unifi to automatically export all the components of an integration in one easy step. The packager methods will allow Unifi to create an update set for the integration, add all the configuration records to that update set, and export it as a file download from the Integration page on the Unifi Integration Designer portal.

Web Service Creation

Method: snd_eb_util.web_service.*

The web service methods included in the global utility allow Unifi to automatically create and update REST Methods used by Unifi integrations.

Trigger Rule Creation

Method: snd_eb_util.trigger_rule.*

The trigger methods included in the global utility allow Unifi to automatically create a Trigger Business Rule on a table if one doesn't already exist.

Dataset Create Data Source

Method: snd_eb_util.datasetCreateDataSource(dataset, attachment)

Create a data source for datasets to use when importing data.

Dataset Delete Scheduled Import

Method: snd_eb_util.datasetDeleteScheduledImport(scheduled_import_id)

Delete a scheduled import that belongs to and was created by a Dataset. Used when deleting a Dataset.

Dataset Delete Transform Map

Method: snd_eb_util.datasetDeleteTransformMap(transform_map_id)

Delete a transform map that belongs to and was created by a Dataset. Used when deleting a Dataset.

Dataset Ensure Transform Map

Method: snd_eb_util.datasetEnsureTransformMap(dataset)

Update a transform map for a Dataset to use when importing data. Used when building a Dataset.

Dataset Update Transform Map Fields

Method: snd_eb_util.datasetUpdateTransformMapFields(dataset)

Update the coalesce fields for a transform map. Used when building a Dataset.

Follow these steps to install or upgrade Unifi.

1. Install or Upgrade Unifi

2. Install Global Utility

3. Install Hotfix

4. Configure

1. Install or Upgrade Unifi

Unifi is exclusively available through the ServiceNow Store with a limited trial or paid subscription.

To install Unifi on your instance, you will need to ensure it has been given entitlement to the application. You must do this through the ServiceNow Store.

Once you have setup entitlement, you can use the Application Manager in your ServiceNow instance to install and upgrade Unifi. You can find more information on how to Install a ServiceNow Store Application in the ServiceNow Product Documentation.

2. Install Global Utility

Unifi has some powerful features that will only work with access to the global scope. Access is granted through the Unifi Global Utility.

Full details can be found on the Global Utility page.

3. Install Hotfix

Unifi has the ability to be patched between releases by using a special Script Include called hotfix.

Full details can be found on the Hotfixes page.

4. Configure

You're good to start building your first integration or import one you already have.

If you’re new to Unifi then you might like to follow one of our integration guides. You can access the Integration Guides from the menu.