Hotfix

/**
 * 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;
  };
};