Saved Search and Search Page XML Reference¶

<SEARCH>
  <ITEM NAME="KEYWORDS" VALUE="contract renewal" VISIBLE="TRUE" />
  <ITEM NAME="DATECRITERIA" VALUE="MODIFIED" DATETYPE="PREVIOUS" PREVIOUSDATETYPE="D" PREVIOUSN="30" DATE1="" DATE2="" VISIBLE="TRUE" />
</SEARCH>

<ITEM NAME="DATECRITERIA" VALUE="CREATED" DATETYPE="BETWEEN" DATE1="2026-01-01" DATE2="2026-03-31" VISIBLE="TRUE" />
<ITEM NAME="DATECRITERIA" VALUE="EXPIRATION DATE" DATETYPE="NEXT" PREVIOUSDATETYPE="W" PREVIOUSN="2" VISIBLE="TRUE" />

<ITEM NAME="PROPERTYSETNAME" VALUE="INVOICE"
      ATTRIBUTES="CUSTOMER|INVOICEAMOUNT|INVOICEDATE"
      CONDITIONS="CONTAINS|EQGT|BETWEEN"
      VALUES="Acme|1000|2026-01-01;2026-03-31"
      VISIBLE="TRUE" />

/*
 * infoRouter saved searches and search pages - browser helper, no dependencies.
 *
 * Works in any modern browser (fetch, DOMParser, URLSearchParams). Copy it as it is,
 * or take the functions you need.
 *
 *   const ir = createInfoRouterClient('https://yourserver', ticket);
 *   const id = await ir.createSavedSearch({ type: 'savedSearch', name: 'My Q4 Contracts', isPersonal: true, items });
 */

/** Every field a definition carries, with the value an unused field has. */
const SEARCH_ITEM_DEFAULTS = {
  SEARCHSCOPE:     { VALUE: '0' },
  SEARCHFOR:       { VALUE: '' },
  DOCTYPE:         { VALUE: '' },
  KEYWORDS:        { VALUE: '' },
  DOCUMENTNAME:    { VALUE: '' },
  FOLDERDESC:      { VALUE: '' },
  DOCUMENTID:      { VALUE: '' },
  FOLDERBYID:      { VALUE: '' },
  USERNAME:        { VALUE: '' },
  FOLDER:          { VALUE: '0', INCLUDESUBFOLDERS: 'TRUE' },
  CHECKOUTSTATUS:  { VALUE: '', USERNAME: '0' },
  DATECRITERIA:    { VALUE: '', DATETYPE: '', PREVIOUSDATETYPE: '', PREVIOUSN: '0', DATE1: '', DATE2: '' },
  SIZEIS:          { VALUE: '', SIZEAMOUNT: '0' },
  IMPORTANCE:      { VALUE: '-1', OPERATOR: '' },
  CLEVEL:          { VALUE: '' },
  DOCUMENTFORMAT:  { VALUE: '' },
  VIEWCRITERIA:    { VALUE: '', USERNAME: '0' },
  DOCSRC:          { VALUE: '' },
  DOCLANG:         { VALUE: '' },
  DOCAUTHOR:       { VALUE: '' },
  TAGTEXT:         { VALUE: '' },
  RDDEFID:         { VALUE: '0' },
  PUBLISHSTATUS:   { VALUE: '0' },
  AIENHANCED:      { VALUE: '' },
  PROPERTYSETNAME: { VALUE: '', ATTRIBUTES: '', CONDITIONS: '', VALUES: '' },
};

function escapeXml(text) {
  return String(text ?? '')
    .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;').replace(/'/g, '&apos;');
}

/**
 * Builds the searchParametersXml string.
 *
 * items: { KEYWORDS: { VALUE: 'budget', VISIBLE: true }, FOLDER: { VALUE: '1234', INCLUDESUBFOLDERS: 'FALSE' }, ... }
 *
 * Every field is written, because a field the XML leaves out is shown. A field you do not
 * pass gets its unused value and `defaultVisible` (default false), so for a search page
 * you only list the fields the page offers.
 */
function buildSearchXml(items = {}, { defaultVisible = false } = {}) {
  const lines = Object.keys(SEARCH_ITEM_DEFAULTS).map((name) => {
    const given = items[name] ?? {};
    const attributes = { NAME: name, ...SEARCH_ITEM_DEFAULTS[name] };
    for (const [key, value] of Object.entries(given)) {
      if (key !== 'VISIBLE') attributes[key] = value;
    }
    const visible = given.VISIBLE ?? (items[name] ? true : defaultVisible);
    attributes.VISIBLE = visible ? 'TRUE' : 'FALSE';
    const text = Object.entries(attributes).map(([k, v]) => `${k}="${escapeXml(v)}"`).join(' ');
    return `  <ITEM ${text} />`;
  });
  return `<SEARCH>\n${lines.join('\n')}\n</SEARCH>`;
}

/** Reads a <SEARCH> element (from GetSavedSearch) into the same shape buildSearchXml takes. */
function parseSearchElement(searchElement) {
  const items = {};
  if (!searchElement) return items;
  for (const item of Array.from(searchElement.getElementsByTagName('ITEM'))) {
    const entry = {};
    for (const attribute of Array.from(item.attributes)) {
      if (attribute.name === 'NAME') continue;
      entry[attribute.name] = attribute.name === 'VISIBLE' ? attribute.value.toUpperCase() === 'TRUE' : attribute.value;
    }
    items[item.getAttribute('NAME')] = entry;
  }
  return items;
}

class InfoRouterError extends Error {}

function createInfoRouterClient(baseUrl, ticket) {
  /** POSTs a form to /srv.asmx/{action} and returns the root element; throws when success is not "true". */
  async function call(action, params = {}) {
    const body = new URLSearchParams({ authenticationTicket: ticket });
    for (const [key, value] of Object.entries(params)) body.append(key, value === undefined || value === null ? '' : String(value));

    const response = await fetch(`${baseUrl}/srv.asmx/${action}`, { method: 'POST', body });
    const text = await response.text();
    if (!response.ok) throw new InfoRouterError(`${action}: HTTP ${response.status} ${text.slice(0, 200)}`);

    const root = new DOMParser().parseFromString(text, 'text/xml').documentElement;
    if (root.getAttribute('success') !== 'true') throw new InfoRouterError(`${action}: ${root.getAttribute('error')}`);
    return root;
  }

  function entryForm(entry) {
    return {
      searchPageType: entry.type,                        // 'savedSearch' or 'searchPage'
      name: entry.name,
      description: entry.description ?? '',
      isPersonal: entry.isPersonal ? 'true' : 'false',
      anonymousAccess: entry.anonymousAccess ? 'true' : 'false',
      publicAccess: entry.publicAccess ? 'true' : 'false',
      userGroupNames: (entry.userGroupNames ?? []).join('|'),   // ['Legal', 'Finance\\Controllers']
      searchParametersXml: entry.searchParametersXml ?? buildSearchXml(entry.items ?? {}, { defaultVisible: entry.defaultVisible }),
    };
  }

  return {
    call,

    /** Creates an entry and returns its id. */
    async createSavedSearch(entry) {
      const root = await call('CreateSavedSearch', entryForm(entry));
      return Number(root.getAttribute('id'));
    },

    /** Replaces an entry. Send every property: a missing definition resets the fields, missing groups remove them. */
    async updateSavedSearch(id, entry) {
      await call('UpdateSavedSearch', { searchPageId: id, ...entryForm(entry) });
    },

    /** Reads an entry into the shape createSavedSearch and updateSavedSearch take. */
    async getSavedSearch(id) {
      const page = (await call('GetSavedSearch', { searchPageId: id })).getElementsByTagName('SearchPage')[0];
      const groups = page.getAttribute('userGroupNames');
      return {
        id: Number(page.getAttribute('id')),
        type: page.getAttribute('type'),
        name: page.getAttribute('name'),
        description: page.getAttribute('description'),
        ownerId: Number(page.getAttribute('ownerId')),
        isPersonal: page.getAttribute('ownerId') !== '0',
        anonymousAccess: page.getAttribute('anonymousAccess') === 'true',
        publicAccess: page.getAttribute('publicAccess') === 'true',
        userGroupNames: groups ? groups.split('|') : [],
        items: parseSearchElement(page.getElementsByTagName('SEARCH')[0]),
      };
    },

    /** Lists what the user may use: type 'savedSearch', 'searchPage' or 'all'. */
    async listSavedSearches(type = 'all') {
      const root = await call('GetSavedSearches', { searchPageType: type });
      return Array.from(root.getElementsByTagName('SearchPage')).map((page) => ({
        id: Number(page.getAttribute('id')),
        type: page.getAttribute('type'),
        name: page.getAttribute('name'),
        description: page.getAttribute('description'),
        isPersonal: page.getAttribute('ownerId') !== '0',
      }));
    },

    async deleteSavedSearch(id) {
      await call('DeleteSavedSearch', { searchPageId: id });
    },

    /**
     * Runs a saved search: translates its fields into Search API criteria and calls Search.
     * Returns { count, criteriaXml, skipped }. Read the results with GetNextSearchPage.
     */
    // sortBy: a Search API sort field. Not empty - the REST endpoint rejects an empty SortBy.
    async runSavedSearch(id, { sortBy = 'DOCUMENTNAME', ascending = true } = {}) {
      const { items } = await this.getSavedSearch(id);
      const { criteriaXml, skipped } = await toSearchCriteriaXml(items, (name) => this.getPropertySetFieldTypes(name));
      const root = await call('Search', { xmlcriteria: criteriaXml, SortBy: sortBy, AscendingOrder: ascending ? 'true' : 'false' });
      return { count: Number(root.getAttribute('count')), criteriaXml, skipped };
    },

    /** { FIELDNAME: 'CHAR' | 'NUMBER' | 'DATE' | 'BOOLEAN' } for a property set. */
    async getPropertySetFieldTypes(propertySetName) {
      const root = await call('GetPropertySetDefinition', { PropertySetName: propertySetName });
      const types = {};
      for (const field of Array.from(root.getElementsByTagName('field'))) {
        types[field.getAttribute('FieldName').toUpperCase()] = field.getAttribute('DataType').toUpperCase();
      }
      return types;
    },
  };
}

// ---------------------------------------------------------------------------------------------
// Saved search fields -> Search API criteria.
//
// A saved search stores the server's own form of a search, which is not the <criteria> form the
// Search API reads: a folder is an id rather than a path, CHECKOUTSTATUS says ME rather than
// CHECKEDOUTBYME, a relative date says PREVIOUS 30 D rather than a date range. This turns one into
// the other. Ids are passed as short references (~F1234 for a folder, ~U4 for a user), which the
// Search API resolves itself.
// ---------------------------------------------------------------------------------------------

const SCOPE_WORDS = { 0: 'ONLINE', 1: 'ALL', 2: 'ARCHIVE', 3: 'ONLINE-HIDDENS' };
const CHECKOUT_WORDS = { ALL: 'CHECKEDOUT', 0: 'NOTCHECKEDOUT', ME: 'CHECKEDOUTBYME', USER: 'CHECKEDOUTBYUSER' };
const CLEVEL_WORDS = { 0: 'NOMARKINGS', 1: 'DECLASSIFIED', 2: 'CONFIDENTIAL', 3: 'SECRET', 4: 'TOPSECRET' };

// Property set conditions are stored as numbers whose meaning depends on the field's type.
// null marks a condition the Search API has no operator for.
const PROPERTY_OPERATORS = {
  DATE: { 1: 'ANYTIME', 2: 'YESTERDAY', 3: 'TODAY', 4: 'LAST7DAYS', 5: 'NEXT7DAYS', 6: 'LASTWEEK', 7: 'THISWEEK',
          8: 'NEXTWEEK', 9: 'LASTMONTH', 10: 'THISMONTH', 11: 'NEXTMONTH', 12: 'EQ', 13: 'EQGT', 14: 'EQLT', 15: 'NULL', 16: null },
  NUMBER: { 1: 'EQ', 2: 'NOTEQ', 3: 'EQLT', 4: 'EQGT', 5: 'GT', 6: 'LT', 7: 'NOTNULL', 8: 'NULL', 9: null },
  CHAR: { 1: 'LIKE', 2: 'EQ', 3: 'NULL', 4: 'NOTNULL', 5: null, 6: null },
  BOOLEAN: { 1: 'EQ', 2: 'NOTNULL', 3: 'NULL' },
};

function localDate(date) {
  const pad = (n) => String(n).padStart(2, '0');
  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
}

function addPeriod(date, unit, n) {
  const d = new Date(date.getFullYear(), date.getMonth(), date.getDate());
  if (unit === 'D') d.setDate(d.getDate() + n);
  if (unit === 'W') d.setDate(d.getDate() + 7 * n);
  if (unit === 'M') d.setMonth(d.getMonth() + n);
  if (unit === 'Y') d.setFullYear(d.getFullYear() + n);
  return d;
}

/** A stored DATE1/DATE2 (a UTC timestamp) as the local calendar date it was saved as. */
function storedDate(value) {
  return value ? localDate(new Date(value)) : '';
}

/**
 * items: what getSavedSearch returned. propertySetFieldTypes: async (name) => { FIELD: 'CHAR', ... }.
 * Returns { criteriaXml, skipped } - skipped names what the Search API cannot express.
 */
async function toSearchCriteriaXml(items, propertySetFieldTypes) {
  const out = [];
  const skipped = [];
  const add = (attributes, children = '') => {
    const text = Object.entries(attributes).map(([k, v]) => `${k}="${escapeXml(v)}"`).join(' ');
    out.push(children ? `  <criteria ${text}>\n${children}  </criteria>` : `  <criteria ${text} />`);
  };
  const value = (name) => (items[name]?.VALUE ?? '').trim();

  if (items.SEARCHSCOPE) add({ NAME: 'SEARCHSCOPE', VALUE: SCOPE_WORDS[value('SEARCHSCOPE')] ?? 'ONLINE' });
  if (value('SEARCHFOR')) add({ NAME: 'SEARCHFOR', VALUE: value('SEARCHFOR') });
  if (value('DOCTYPE')) add({ NAME: 'DOCTYPE', VALUE: value('DOCTYPE') });
  if (value('KEYWORDS')) add({ NAME: 'KEYWORDS', VALUE: value('KEYWORDS') });
  for (const name of value('DOCUMENTNAME').split('|').map((s) => s.trim()).filter(Boolean)) add({ NAME: 'DOCUMENTNAME', VALUE: name });
  if (value('FOLDERDESC')) add({ NAME: 'FOLDERDESCRIPTION', VALUE: value('FOLDERDESC') });
  if (value('DOCUMENTID')) add({ NAME: 'DOCUMENTID', VALUE: value('DOCUMENTID') });
  if (value('FOLDERBYID')) add({ NAME: 'FOLDERBYID', VALUE: value('FOLDERBYID') });
  if (value('DOCUMENTFORMAT')) add({ NAME: 'DOCUMENTFORMAT', VALUE: value('DOCUMENTFORMAT') });
  if (value('DOCSRC')) add({ NAME: 'DOCSRC', VALUE: value('DOCSRC') });
  if (value('DOCLANG')) add({ NAME: 'DOCLANG', VALUE: value('DOCLANG') });
  if (value('DOCAUTHOR')) add({ NAME: 'DOCAUTHOR', VALUE: value('DOCAUTHOR') });
  if (Number(value('RDDEFID')) > 0) add({ NAME: 'RDDEFID', VALUE: value('RDDEFID') });
  if (Number(value('PUBLISHSTATUS')) > 0) add({ NAME: 'PUBLISHSTATUS', VALUE: value('PUBLISHSTATUS') });
  if (value('AIENHANCED')) add({ NAME: 'AIENHANCED', VALUE: value('AIENHANCED') });
  if (value('TAGTEXT')) skipped.push('TAGTEXT: the Search API has no tag criterion');

  // Authors: the Search API takes one user.
  const authors = value('USERNAME').split(',').map((s) => s.trim()).filter(Boolean);
  if (authors.length > 0) add({ NAME: 'USERNAME', VALUE: `~U${authors[0]}` });
  if (authors.length > 1) skipped.push(`USERNAME: only the first of ${authors.length} authors is searched`);

  if (Number(value('FOLDER')) > 0) {
    add({ NAME: 'FOLDER', VALUE: `~F${value('FOLDER')}` });
    add({ NAME: 'INCLUDESUBFOLDERS', VALUE: (items.FOLDER.INCLUDESUBFOLDERS ?? 'TRUE').toUpperCase() === 'TRUE' ? 'true' : 'false' });
  }

  if (value('CHECKOUTSTATUS')) {
    const criterion = { NAME: 'CHECKOUTSTATUS', VALUE: CHECKOUT_WORDS[value('CHECKOUTSTATUS').toUpperCase()] };
    if (criterion.VALUE === 'CHECKEDOUTBYUSER') criterion.USERNAME = `~U${items.CHECKOUTSTATUS.USERNAME}`;
    add(criterion);
  }

  if (value('VIEWCRITERIA')) {
    const criterion = { NAME: 'VIEWCRITERIA', VALUE: value('VIEWCRITERIA') };
    if (Number(items.VIEWCRITERIA.USERNAME) > 0) criterion.USERNAME = `~U${items.VIEWCRITERIA.USERNAME}`;
    add(criterion);
  }

  if (value('SIZEIS')) {
    add({ NAME: 'SIZEIS', OPERATOR: value('SIZEIS').toUpperCase() === 'AT MOST' ? 'EQLT' : 'EQGT', VALUE: items.SIZEIS.SIZEAMOUNT ?? '0' });
  }

  if (Number(value('IMPORTANCE')) >= 0 && items.IMPORTANCE.OPERATOR) {
    add({ NAME: 'IMPORTANCE', OPERATOR: items.IMPORTANCE.OPERATOR, VALUE: value('IMPORTANCE') });
  }

  if (value('CLEVEL')) add({ NAME: 'CLEVEL', VALUE: CLEVEL_WORDS[value('CLEVEL')] });

  if (value('DATECRITERIA')) {
    // The same ranges the server computes for a saved search, in the browser's local time.
    const d = items.DATECRITERIA;
    const today = new Date();
    const n = Number(d.PREVIOUSN ?? 0);
    const subtype = value('DATECRITERIA');
    switch ((d.DATETYPE ?? '').toUpperCase()) {
      case 'BETWEEN': {
        const from = storedDate(d.DATE1);
        const to = storedDate(d.DATE2);
        if (from && to) add({ NAME: 'DATECRITERIA', SUBTYPE: subtype, OPERATOR: 'BETWEEN', VALUE: `${from}|${to}` });
        else if (from) add({ NAME: 'DATECRITERIA', SUBTYPE: subtype, OPERATOR: 'EQGT', VALUE: from });
        else if (to) add({ NAME: 'DATECRITERIA', SUBTYPE: subtype, OPERATOR: 'EQLT', VALUE: to });
        break;
      }
      case 'TODAY':
        add({ NAME: 'DATECRITERIA', SUBTYPE: subtype, OPERATOR: 'EQ', VALUE: localDate(today) });
        break;
      case 'PREVIOUS':
        add({ NAME: 'DATECRITERIA', SUBTYPE: subtype, OPERATOR: 'BETWEEN',
              VALUE: `${localDate(addPeriod(today, d.PREVIOUSDATETYPE, -n))}|${localDate(today)}` });
        break;
      case 'NEXT':
        add({ NAME: 'DATECRITERIA', SUBTYPE: subtype, OPERATOR: 'BETWEEN',
              VALUE: `${localDate(addPeriod(today, 'D', 1))}|${localDate(addPeriod(addPeriod(today, d.PREVIOUSDATETYPE, n), 'D', -1))}` });
        break;
    }
  }

  if (value('PROPERTYSETNAME')) {
    const p = items.PROPERTYSETNAME;
    const fields = (p.ATTRIBUTES ?? '').split('|');
    const conditions = (p.CONDITIONS ?? '').split('|');
    const values = (p.VALUES ?? '').split('|');
    const types = await propertySetFieldTypes(value('PROPERTYSETNAME'));
    let children = '';
    fields.forEach((field, i) => {
      const condition = Number(conditions[i] ?? 0);
      if (!field || condition === 0) return;
      const operator = PROPERTY_OPERATORS[types[field.toUpperCase()]]?.[condition];
      if (!operator) {
        skipped.push(`PROPERTYSETNAME: ${field} condition ${condition} has no Search API operator`);
        return;
      }
      const fieldValue = (values[i] ?? '').replace(/&PIPE;/g, '|');
      children += `    <criteria NAME="${escapeXml(field)}" OPERATOR="${operator}" VALUE="${escapeXml(fieldValue)}" />\n`;
    });
    if (children) add({ NAME: 'PROPERTYSETNAME', VALUE: value('PROPERTYSETNAME') }, children);
  }

  return { criteriaXml: `<search>\n${out.join('\n')}\n</search>`, skipped };
}

if (typeof module !== 'undefined') {
  module.exports = { SEARCH_ITEM_DEFAULTS, buildSearchXml, parseSearchElement, createInfoRouterClient, toSearchCriteriaXml, InfoRouterError };
}

// Sign in once and keep the ticket.
const login = await fetch('/srv.asmx/AuthenticateUser', { method: 'POST', body: new URLSearchParams({ UID: user, PWD: password }) });
const ticket = new DOMParser().parseFromString(await login.text(), 'text/xml').documentElement.getAttribute('ticket');
const ir = createInfoRouterClient('', ticket);   // '' = same origin

// Save what the user searched for as a personal saved search.
const id = await ir.createSavedSearch({
  type: 'savedSearch',
  name: 'My Q4 Contracts',
  description: 'Contract documents changed in the last 30 days',
  isPersonal: true,
  items: {
    SEARCHFOR: { VALUE: 'DOCUMENTSONLY' },
    KEYWORDS: { VALUE: 'contract renewal' },
    DATECRITERIA: { VALUE: 'MODIFIED', DATETYPE: 'PREVIOUS', PREVIOUSDATETYPE: 'D', PREVIOUSN: '30' },
    IMPORTANCE: { VALUE: 'HIGH', OPERATOR: 'GT-EQ' },
  },
});

// Edit: read, change, send everything back.
const entry = await ir.getSavedSearch(id);
entry.items.KEYWORDS.VALUE = 'contract termination';
await ir.updateSavedSearch(id, entry);

// Run it, then page through the results.
const { count, skipped } = await ir.runSavedSearch(id);
const firstPage = await ir.call('GetNextSearchPage', { withrules: false, withPropertySets: false, withSecurity: false, withOwner: false, withVersions: false });

const page = await ir.getSavedSearch(searchPageId);
for (const [name, item] of Object.entries(page.items)) {
  if (!item.VISIBLE) continue;
  renderField(name, item);   // your control for KEYWORDS, DATECRITERIA, ... prefilled with item.VALUE
}