Your Knowledge Base will consist of articles that are contributed and collaborated upon by an internal team of knowledge experts. External consumers of the articles expect them to contain valid and approved information.

Content contributors can author new articles or work on existing articles using any of the authoring facilities in Alfresco. They can use Alfresco Explorer to navigate the content hierarchy to find and work on articles. Contributors can also use conventional desktop applications, such as Microsoft Word, to open and save files directly against Alfresco through its CIFS interface.

Articles must have a lifecycle state. For example, when an article is first authored, it is assigned with a draft status. This simply means that the article's content has not yet been approved. It may require more work before it can be considered complete, or it may be essentially complete and just need someone to sign off on its validity.

The workflow engine is responsible for handling the routing of the article to the appropriate people for sign-off and approval. This process may be instantaneous or take quite a while, even days, depending on the availability of staff to participate in the process. During this time, the article is assigned with a pending approval status.

As a positive outcome of this workflow process, the article's status should be modifiable to an approved current state. An article with a current status is valid and the external consumer audience should be able to retrieve it.

Alternatively, the workflow process may discover a problem with the article. In that case, it sets the article's status back to draft and allows the internal staff to continue making modifications.

Figure 14-1 shows an overview of this workflow process.

The Knowledge Base article conforms to this lifecycle. Now you'll look at how you can model your Knowledge Base article using the content modeling facilities of the Alfresco repository.

Figure 14.1. FIGURE 14-1

To define a content model for the Knowledge Base metadata, you first determine a namespace URI and a prefix you want to use. While you can use anything you like as long as it is unique, it helps to have a short prefix. This example uses the following:

With this in place, you can reference anything you define in the model by using the simple kb prefix. Now you can start defining things inside of the model. You should focus on two primary entities:

The next sections look at Knowledge Base spaces and articles in detail.

<types>
   <type name="kb:space">
      <title>Knowledge Base Space</title>
      <parent>cm:folder</parent>
   </type>
</types>

<types>
   <type name="kb:article">
      <title>Knowledge Base Article</title>
      <parent>cm:content</parent>
      <properties>
         <property name="kb:status">
            <title>Status</title>
            <type>d:text</type>
            <default>Draft</default>
         </property>
         <property name="kb:articletype">
            <title>Article Type</title>
            <type>d:text</type>
            <default>Article</default>
         </property>
      </properties>
   </type>
</types>

<aspects>

   <aspect name="kb:status">
      <title>Status</title>
      <properties>
         <property name="kb:status">
            <title>Status</title>
            <type>d:text</type>
            <default>Draft</default>

</property>
      </properties>
   </aspect>

   <aspect name="kb:article">
      <title>Article</title>
      <properties>
         <property name="kb:articletype">
            <title>Article Type</title>
            <type>d:text</type>
            <default>Article</default>
         </property>
      </properties>
      <mandatory-aspects>
         <aspect>kb:status</aspect>
      </mandatory-aspects>
   </aspect>

</aspects>

<constraints>
   <constraint name="kb:status_constraint" type="LIST">
      <parameter name="allowedValues">
         <list>
            <value>Draft</value>
            <value>Pending Approval</value>
            <value>Current</value>
            <value>Archived</value>
         </list>
      </parameter>
   </constraint>
   <constraint name="kb:articletype_constraint" type="LIST">
      <parameter name="allowedValues">
         <list>
            <value>Any</value>
            <value>Article</value>
            <value>FAQ</value>
            <value>White Paper</value>
         </list>
      </parameter>
   </constraint>
</constraints>

<property name="kb:status">
   <title>Status</title>
   <type>d:text</type>
   <default>Draft</default>
   <constraints>
      <constraint ref="kb:status_constraint" />
   </constraints>
</property>
<property name="kb:articletype">
   <title>Article Type</title>
   <type>d:text</type>
   <default>Article</default>
   <constraints>
      <constraint ref="kb:articletype_constraint" />
   </constraints>
</property>

Alfresco Explorer is an out-of-the-box Web application that provides a useful interface for content contributors. For example, content contributors can use Alfresco Explorer to create new Knowledge Base articles and adjust metadata properties using automatically rendered property sheets.

Alfresco Explorer features a number of configuration options that you can tweak to make it easier to work with your Knowledge Base spaces and articles.

<config evaluator="aspect-name" condition="kb:article">
   <property-sheet>
      <separator name="sep" display-label="KB Article Properties"
                 component-generator="HeaderSeparatorGenerator"
                 show-in-edit-mode="false"/>
      <show-property name="kb:kbid"  show-in-edit-mode="true"/>
      <show-property name="kb:article_type"  show-in-edit-mode="true"/>
      <show-property name="kb:status" display-label="kb:status"
                     show-in-edit-mode="true"/>
   </property-sheet>
</config>
<config evaluator="aspect-name" condition="kb:status">
   <property-sheet>
      <show-property name="kb:status" display-label="kb:status"/>
   </property-sheet>
</config>

<config evaluator="string-compare" condition="Space Wizards">
   <folder-types>
      <type name="kb:space" icon="/images/icons/space-icon-pen.gif" />
   </folder-types>
</config>

<config evaluator="string-compare" condition="Action Wizard">
   <aspects>
      <aspect name="kb:article"/>
   </aspects>
</config>

<config evaluator="string-compare" condition="kb:space icons">
   <icons>
      <icon name="space-icon-pen" path="/images/icons/space-icon-pen.gif" />
   </icons>
</config>

A space in the Alfresco repository is fundamentally a container. Users who interact with a space through a CIFS file share will really see nothing more than a folder. For all intents and purposes, they believe they are actually working with content in a folder.

In reality, however, you can make your spaces smart by wiring in business logic behind them. You can tell your spaces how to behave when certain things occur to them or within them. For example, you could tell your spaces to perform specific actions when content is newly placed within. You could tell them to launch workflows, automatically tag content, or fire off emails to notify collaborators of updates and activities.

You can do this because Alfresco provides out-of-the-box event handling for interactions with spaces and content. Alfresco fires events when interactions occur between a user or the environment and a piece of content. These events are like signals that your custom code or scripts can listen for. When they hear these signals, they can react.

The principal hook point for these interactions is achieved using aspects. You have seen aspects throughout this book. Aspects let you catch these signals and then act on them. They provide a code-level interface for intercepting the events and triggering a repository action as a response.

This means that you could write custom aspects to wire in some intense behavior behind your content spaces. This is ideal for developers and for testing. You can write custom handlers along with unit and integration tests.

However, there are many times when you do not need as much rigor. Alfresco makes things easier for non-developers by providing simple user interface tools for applying business logic behind your spaces.

Rules let you describe actions that should be triggered when one or more conditions are met. Rules were discussed in Chapter 13. They are accessible through Alfresco Explorer and appear as shown in Figure 14-2.

Figure 14.2. FIGURE 14-2

A rule fires when one or more of its conditions is met. For example, if a rule has a single condition for the content item's mimetype property to equal application/word, the rule will only trigger for Microsoft Word documents. When a rule triggers, it fires off one or more repository actions that you configure.

For example, you may tell the rule to copy the content item to another place in the repository or you may have it transform the content into another MIME type (such as PDF). A large number of repository actions are available out of the box for you to work with or you can add your own.

Alfresco makes things even easier by letting you create scriptable actions using server-side JavaScript. You can write your own JavaScript files and have them do anything you would like to your content.

JavaScript files can be defined in one of two places:

Thus, you really do not have to do any development at all! Using rules and scripting, you can wire custom business logic into your space without the need for any Java code. No compilers, no server restarts.

Using content types, rules, and server-side JavaScript, you can implement a wide variety of custom workspaces. You may have elaborate folder structures or a complex chain of rules established. You may have set up permissions and groups exactly according to the needs of your project or task. It would be ideal if there were an easy way to capture and reuse that work!

Fortunately—you guessed it—there is! Alfresco lets you capture your smart spaces into space templates. A space template is a bit like a cookie cutter – you can apply it to any location in the repository and stamp out an exact copy of your entire preconfigured workspace. This includes

You'll walk through the creation of a space template when you get to the "Putting It into Action" section. You'll actually build your Knowledge Base space as a space template. That way, you can stamp out Knowledge Base spaces very quickly (and so can anyone else)!

Before doing anything else, you should stop the Alfresco server. You can do this either from a command line or through the Windows Start menu (if you used the Windows Installer).

From the command line, type the following:

cd <installLocation>
alf_stop.bat

This shuts down Alfresco and returns you to the command prompt.

Begin by introducing the Knowledge Base content model to the Alfresco repository. This informs Alfresco how to deal with your Knowledge Base content types and aspects.

From the following directory:

copy the following files:

to:

Next, you can plug in your Alfresco Explorer configurations. This enables the additional property sheets, wizards, and icons for your Knowledge Base space content type and Knowledge Base aspects.

From the following directory:

copy the following files:

to:

Finally, install the Knowledge Base Search Web script into the Alfresco repository.

From the following directory:

copy the following files:

to:

You can start up the Alfresco server either from a command prompt or through the Windows Start menu (if you used the Windows Installer).

From the command line, type the following:

cd <installLocation>
alf_start.bat

This starts Alfresco and returns you to the command prompt.

You are going to use Alfresco Explorer to set up the Alfresco Knowledge Base workspace. Follow these instructions:

You can use the administrator account with the user name admin and password admin. Your user dashboard will display once you log in.

The Alfresco repository provides a Data Dictionary into which you can place your custom script files. This is the ideal place for you to put your custom server-side JavaScript file.

You want to add a custom JavaScript file that will use the Alfresco Tagging Service to apply tags to your document. Tags are universal throughout the repository and they provide an elegant way to discover relevant information. By applying lifecycle tags to your documents, you simply make it easier for other people to locate knowledge in the Knowledge Base.

Figure 14.5. FIGURE 14-5

Figure 14.6. FIGURE 14-6

Now you'll have some fun. You will create a Knowledge Base space template inside of Alfresco Explorer. In doing so, you're creating a "cookie cutter" that you can use to quickly stamp out preconfigured workspaces that implement all of your Knowledge Base functionality.

Creating the Space Template

Follow these instructions to create the Space template:

1. Click the Company Home link at the top left of the page.

2. In the Navigator view on the left-hand side of the page, click the small arrow next to the Data Dictionary space to reveal its subspaces.

3. Click on Space Templates in the Navigator's subspaces. This will take you into the Space Templates space. You should only see one subspace inside, called Software Engineering Project.

4. Click the Create menu to display options for content creation and select Advanced Space Wizard from the drop-down list (see Figure 14-7).

   

   Figure 14.7. FIGURE 14-7

   This brings up the Create Space Wizard that lets you create different kinds of spaces.

5. On the Step One - Starting Space page, choose the From Scratch option and click Next (see Figure 14-8).

   

   Figure 14.8. FIGURE 14-8

   The next page you see will be titled Step Two – Space Options. This will show you the various kinds of spaces that you can create. Notice there is now an extra icon for a Knowledge Base Space (as shown in Figure 14-9). This is because you configured it to be thus using the Alfresco Explorer configuration file that you provided (web-client-config-knowledgebase-custom.xml).

   

   Figure 14.9. FIGURE 14-9

6. Select the Knowledge Base Space option and click Next.

7. On the Step Three - Space Details page, enter the details about the Knowledge Base space you wish to create (see Figure 14-10), and then click Finish. In this example, you've elected to call the space template "Knowledge Base Project."

   

   Figure 14.10. FIGURE 14-10

   You have created your Knowledge Base space. It should appear similar to Figure 14-11.

Figure 14.11. FIGURE 14-11

Now that you've built your Knowledge Base space template, you can use it to stamp out Knowledge Base workspaces quite easily. You'll create a test space under the Company Home space to see how it works.

Follow these steps:

Figure 14.14. FIGURE 14-14

With that, your new Knowledge Base space is created in the Company Home folder. You should see it appear alongside the other folders, as shown in Figure 14-15.

Figure 14.15. FIGURE 14-15

You can now create a Knowledge Base article and contribute it to your new Knowledge Base. You can do this using either Alfresco Explorer or CIFS desktop integration.

Using Alfresco Explorer

You can use Alfresco Explorer to create a Knowledge Base article and contribute it to your new My First Knowledge Base workspace.

1. Browse into the My First Knowledge Base space by clicking on it in Alfresco Explorer.

2. Click the Create menu for content creation options, and select Create Content from the list.

   You will use the Create Content Wizard to create a Knowledge Base article.

3. On the first page of the Create Content Wizard, do the following (see Figure 14-16):

   1. In the Name field, type a name for your Knowledge Base article, such as Article1.txt. For this example, make sure it ends in .txt so you can treat the article as plain text.

   2. In the Type menu, select Content.

   3. In the Content Type menu, select Plain Text.

   4. In the Other Properties area, clear the check box.

   5. Click Next.

      

      Figure 14.16. FIGURE 14-16

4. On the second page, titled Step Two- Enter Content, type the following text content:

   A book is a gift you can open again and again.

5. Once you have finished entering your content, click Finish.

Your content has been created. Your space titled My First Knowledge Base should appear similar to what is shown in Figure 14-17.

Figure 14.17. FIGURE 14-17

net use z: \<MACHINE_NAME>A

If you like, you can modify the properties of your Knowledge Base article in Alfresco Explorer.

So far, you've used Alfresco Explorer and/or desktop integration via CIFS to create and modify Knowledge Base articles. All of these articles are ultimately stored in the Alfresco repository as pure content objects with metadata, aspects, and content types, exactly as you prescribed.

You can now try fetching this content via HTTP by calling into your custom Knowledge Base Web script. The HTTP interface lets third-party systems or external applications (such as Alfresco Share) interact with your Knowledge Base and interrogate the data inside.

It's pretty simple to try this out. Just do the following:

If things are working correctly, you should be given back a JSON (JavaScript Object Notation) structure as a bit of text. You might see this show up in your browser or you may be asked to download it. You can simply save it somewhere and then open it inside of a text editor.

The JSON text is pure data. It contains the search results for content in the Knowledge Base. This includes your Article1.txt file. It is pure data – ready for consumption by external applications, including Alfresco Share!

This section describes the configuration of the Alfresco repository. The following content model files should be placed into this directory:

Defines the Knowledge Base content model

<?xml version="1.0" encoding="UTF-8"?>

<!--                              -->
<!-- Knowledge Base Content Model -->
<!--                              -->

<model name="kb:contentmodel" xmlns="http://www.alfresco.org/model/dictionary/1.0">

   <!-- Metadata about the model -->
   <description>Knowledge Base Content Model</description>

<author>alfresco_professional</author>
   <version>1.0</version>

   <!-- Imports are required to allow references to definitions in other models -->
   <imports>
     <!-- Import Alfresco Dictionary Definitions -->
      <import uri="http://www.alfresco.org/model/dictionary/1.0" prefix="d"/>
      <!-- Import Alfresco Content Domain Model Definitions -->
      <import uri="http://www.alfresco.org/model/content/1.0" prefix="cm"/>
   </imports>

   <!-- Define the URI and Prefix for this content model -->
   <namespaces>
      <namespace uri="http://www.alfresco.org/model/knowledgebase/1.0"
      prefix="kb"/>
   </namespaces>

   <!-- Define constraints -->
   <constraints>

      <!-- Ensures that one of the allowed values is assigned -->
      <constraint name="kb:status_constraint" type="LIST">
         <parameter name="allowedValues">
            <list>
               <value>Draft</value>
               <value>Pending Approval</value>
               <value>Current</value>
               <value>Archived</value>
            </list>
         </parameter>
      </constraint>

      <!-- Ensures that one of the allowed values is assigned -->
      <constraint name="kb:articletype_constraint" type="LIST">
         <parameter name="allowedValues">
            <list>
               <value>Any</value>
               <value>Article</value>
               <value>FAQ</value>
               <value>White Paper</value>
            </list>
         </parameter>
      </constraint>
   </constraints>

   <!-- Content Types -->
   <types>
      <type name="kb:space">
         <title>Knowledge Base Space</title>
         <parent>cm:folder</parent>
      </type>
   </types>

<!-- Aspects -->
   <aspects>

      <!-- Marks a content item as having status -->
      <aspect name="kb:status">
         <title>Knowledge Base Status</title>
         <properties>

            <!-- Adds a new metadata property to the KB article -->
            <!-- Constrains the value -->
            <property name="kb:status">
               <title>Status</title>
               <type>d:text</type>
               <default>Draft</default>
               <constraints>
                  <constraint ref="kb:status_constraint" />
               </constraints>
            </property>

         </properties>
      </aspect>

      <!-- Marks a content item as a KB Article -->
      <aspect name="kb:article">
         <title>Knowledge Base Article</title>
         <properties>

            <!-- Adds a new metadata property to the KB article -->
            <!-- Constrains the value -->
            <property name="kb:articletype">
               <title>Article Type</title>
               <type>d:text</type>
               <default>Article</default>
               <constraints>
                  <constraint ref="kb:articletype_constraint" />
               </constraints>
            </property>

         </properties>

         <!-- Content with this aspect also receive kb:status aspect -->
         <mandatory-aspects>
            <aspect>kb:status</aspect>
         </mandatory-aspects>
      </aspect>

   </aspects>

</model>

Code snippet extensionkbModel.xml

Bootstraps the Knowledge Base content model into the Alfresco repository

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE beans PUBLIC '-//SPRING//DTD BEAN//EN'
'http://www.springframework.org/dtd/spring-beans.dtd'>
<beans>

<!-- Registration of new models -->
<bean id="kbmodel.extension.dictionaryBootstrap"
      parent="dictionaryModelBootstrap"
      depends-on="dictionaryBootstrap">
<property name="models">
<list>
<value>alfresco/extension/kbModel.xml</value>
</list>
</property>
</bean>

</beans>

Code snippet extensionkbModel-model-context.xml

The following files should be placed into this directory:

Defines customizations for Alfresco Explorer

<alfresco-config>

   <!--  Configuration for the kb:article aspect -->
   <config evaluator="aspect-name" condition="kb:article">

      <!-- Display the kb:article properties -->
      <property-sheet>
         <separator name="sep" display-label="Knowledge Base Article Properties"
                    component-generator="HeaderSeparatorGenerator"
                    show-in-edit-mode="false"/>
         <show-property name="kb:articletype" display-label="Article Type"
                        show-in-edit-mode="true" />
      </property-sheet>

   </config>

<!-- Configuration for the kb:status aspect -->
   <config evaluator="aspect-name" condition="kb:status">

      <!-- Display the kb:status property -->
      <property-sheet>
         <show-property name="kb:status" display-label="KB Status"
                        show-in-edit-mode="true" />
      </property-sheet>
   </config>

   <!--  Configures the space wizards -->
   <config evaluator="string-compare" condition="Space Wizards">

      <!-- Allow for the creation of kb:folder instances -->
      <folder-types>
         <type name="kb:space" icon="/images/icons/space-icon-pen.gif" />
      </folder-types>

   </config>

   <!-- Configures the action wizards -->
   <config evaluator="string-compare" condition="Action Wizards">

      <!-- Allow the kb:article aspect to be added and removed -->
      <aspects>
         <aspect name="kb:article"/>
      </aspects>

   </config>

   <!-- Specify icon for the kb:space instances -->
   <config evaluator="string-compare" condition="kb:space icons">
      <icons>
         <icon name="space-icon-pen" path="/images/icons/space-icon-pen.gif" />
      </icons>
   </config>

</alfresco-config>

Code snippet extensionweb-client-config-knowledgebase-custom.xml

Bootstraps the Alfresco Explorer customizations into Alfresco Explorer

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE beans PUBLIC '-//SPRING//DTD BEAN//EN'
'http://www.springframework.org/dtd/spring-beans.dtd'>

<beans>

<!--  Bootstraps the Web client configuration -->
<bean id="kb.extension.webClientBootstrap"
      class="org.alfresco.web.config.WebClientConfigBootstrap"
      init-method="init">
   <property name="configs">
      <list>
         <value>
            classpath:alfresco/extension/web-client-config-
            knowledgebase-custom.xml
         </value>
      </list>
   </property>
</bean>

</beans>

Code snippet extensionweb-client-config-knowledgebase-context.xml

The following file should be copied into the Alfresco repository using Alfresco Explorer and placed in the following path:

Updates the tags for a content item based on the content item's status

if (document.type != "{http://www.alfresco.org/model/content/1.0}thumbnail" &&
document.type != "{http://www.alfresco.org/model/content/1.0}folder")
{
 // All Knowledge Base status ids
 var kbStatusIds = ["draft", "pending", "current", "archived"];

 // Remove all previous status tags so you only have the latest one added
 document.removeTags(kbStatusIds);

 // Add a tag to reflect the status
 switch (document.properties["kb:status"])
 {
case "Draft":
 document.addTag("draft");
 break;

case "Pending Approval":
 document.addTag("pending");
 break;

case "Current":
document.addTag("current");
break;

case "Archived":
 document.addTag("archived");
 break;

default:
 }

 // Save changes
 document.save();
}

Code snippet scriptsadd-and-update-knowledge-base-tags.js

The following files should be placed into this directory:

Knowledge Base–search Web script descriptor file

<webscript>
   <shortname>Knowledge Base Search</shortname>
   <description>Searches for knowledge base articles</description>
   <url>/knowledgebase/search?maxResults={maxResults?}</url>
   <url>/knowledgebase/search/site/{site}?maxResults={maxResults?}</url>
   <format default="json">argument</format>
   <authentication>user</authentication>
</webscript>

Code snippet extension emplateswebscriptsorgalfrescoknowledgebasekb-search.get.desc.xml

Knowledge Base–search Web script controller

/**
 * KnowledgeBase Search Web Script
 *
 * Inputs:
 *   optional:  siteId = site ID to search in
 *   optional:  maxResults = max items to return.
 *
 * Outputs:
 *   data.items/data.error - object containing list of search results
 *
 * If siteId is null, the entire repository will be searched.
 */
/**

* Search constants
 */
const DEFAULT_MAX_RESULTS = 500;
const SITES_SPACE_QNAME_PATH = "/app:company_home/st:sites/";

/**
 * Performs a search for knowledge base articles in a site
 *
 * @method doSearch
 * @param siteId {string} The site to search in (or null to search full repository)
 * @param maxResults {int} Maximum number of results to return
 * @return {array} Articles matching the query in the same format that toArticle()
                   method returns
 */
function doSearch(siteId, maxResults)
{
   // The initial template
   var alfQuery='ASPECT:"{http://www.alfresco.org/model/knowledgebase/1.0}article"'
      + ' AND NOT TYPE:"{http://www.alfresco.org/model/content/1.0}thumbnail"'
      + ' AND NOT TYPE:"{http://www.alfresco.org/model/content/1.0}folder"';

   // if you have a siteId, append it into the query
   if (siteId != null)
   {
      alfQuery += ' AND PATH:"' + SITES_SPACE_QNAME_PATH + '/cm:' + siteId;
      alfQuery += '/cm:documentLibrary//*"';
   }

   // Perform fts-alfresco language query for articles
   var queryDef = {
      query: alfQuery,
      language: "fts-alfresco",
      page: {maxItems: maxResults},
      templates: []
   };

   // Get article nodes
   var nodes = search.query(queryDef),
      articles = [],
      item;

   // Turn nodes into article objects
   for (var i = 0, j = nodes.length; i < j; i++)
   {
      // Create core object
      node = nodes[i];
      item =
      {
         nodeRef: node.nodeRef.toString(),
         type: node.typeShort,
         name: node.name,
         title: node.properties["cm:title"],
         description: node.properties["cm:description"],
         modifiedOn: node.properties["cm:modified"],
         modifiedByUser: node.properties["cm:modifier"],

createdOn: node.properties["cm:created"],
         createdByUser: node.properties["cm:creator"],
         author: node.properties["cm:author"],
         nodeDBID: node.properties["sys:node-dbid"],
         properties: {}
      };

      // Calculate display names for users
      var person = people.getPerson(item.modifiedByUser);
      item.modifiedBy = (person != null ? (person.properties.firstName + " " +
                        person.properties.lastName) : item.modifiedByUser);
      person = people.getPerson(item.createdByUser);
      item.createdBy = (person != null ? (person.properties.firstName + " " +
                       person.properties.lastName) : item.createdByUser);

      // Add the Article namespace properties
      for (var k in node.properties)
      {
         if (k.match("ˆ{http://www.alfresco.org/model/knowledgebase/1.0}") ==
             "{http://www.alfresco.org/model/knowledgebase/1.0}")
         {
            item.properties["kb_" + k.split('}')[1]] = node.properties[k];
         }
      }
      articles.push(item);
   }

   return articles;
}

/**
 * The WebScript bootstrap method
 *
 * @method main
 */
function main()
{
   // Gather webscript parameters
   var siteId = url.templateArgs.site;
   var maxResults = (args.maxResults !== null) ? parseInt(args.maxResults) :
                    DEFAULT_MAX_RESULTS;

   // Perform search
   var articles = doSearch(siteId, maxResults);

   // Generate model from results
   model.data = {
      items: articles
   };
}

main();

Code snippet extension emplateswebscriptsorgalfrescoknowledgebasekb-search.get.js

Knowledge Base–search Web script JSON template

<#escape x as jsonUtils.encodeJSONString(x)>
{
   "items":
   [
   <#list data.items as item>
      {
         "nodeRef": "${item.nodeRef}",
         "type": "${item.type}",
         "name": "${item.name}",
         "title": "${item.title!''}",
         "description": "${item.description!''}",
         "modifiedOn": "${xmldate(item.modifiedOn)}",
         "modifiedByUser": "${item.modifiedByUser}",
         "modifiedBy": "${item.modifiedBy}",
         "createdOn": "${xmldate(item.createdOn)}",
         "createdByUser": "${item.createdByUser}",
         "createdBy": "${item.createdBy}",
         "author": "${item.author!''}",
         "nodeDBID": "${item.nodeDBID}",
         "properties":
         {
         <#assign first=true>
         <#list item.properties?keys as k>
         <#if item.properties[k]??>
            <#if !first>,<#else><#assign first=false></#if>"${k}":
            <#assign prop = item.properties[k]>
            <#if prop?is_date>
               "${xmldate(prop)}"
            <#elseif prop?is_boolean>
               ${prop?string("true", "false")}
            <#elseif prop?is_enumerable>
              [<#list prop as p>"${p}"<#if p_has_next>,</#if></#list>]
            <#elseif prop?is_number>${prop?c}
            <#else>"${prop}"
            </#if>
         </#if>
         </#list>
         }
      }
      <#if item_has_next>,</#if>
   </#list>
   ]
}
</#escape>

Code snippet extension emplateswebscriptsorgalfrescoknowledgebasekb-search.get.json.ftl