In the context of an Alfresco Share page rendering a node's details, a special root object named document is exposed to the FreeMarker template. This document object is a TemplateNode wrapper around the actual content node. If the node has the cm:templatable aspect applied and a presentation template is associated with it, the web script controller resolves this template's path. This path is then made available as the .template property on the document object. Therefore, the expression document.template is used to access and subsequently include this presentation template.

A. template: This is ambiguous. It could refer to the current template context but does not specifically access the presentation template associated with the document node.

B. node.template: The standard node root object (of type ScriptNode) does not have a .template property to access the associated presentation template.

C. node.document: This represents an incorrect object hierarchy. document is a root-level object, not a property of the generic node object in this context.

D. document: This expression accesses the entire document object wrapper (TemplateNode), not the specific presentation template property associated with it.

1. Alfresco Content Services 5.2 Documentation, Content Model Guide: The cm:templatable aspect is defined in the out-of-the-box content models. This aspect adds the cm:template association, which links a node to its presentation template node. The logic for document.template relies on this association being present. (See: Alfresco 5.2 Docs, systemdictionary.xml model definition for cm:templatable).

2. Default Alfresco Share Template Source Code: The default FreeMarker template for the document details page (document-details.get.html.ftl) in Alfresco 5.x explicitly uses this expression. The relevant code snippet is:

freemarker

...

This demonstrates the canonical method for checking and including a presentation template. (Source: tomcat/webapps/share/WEB-INF/classes/alfresco/site-webscripts/org/alfresco/components/document-details/document-details.get.html.ftl).

3. Alfresco Content Services 5.2 Documentation, Web Scripts: The documentation on web scripts explains that controllers (.get.js files) prepare a model for the view (.get.html.ftl file). The controller for the document details page resolves the template and places it in the model, making it accessible via the document root object. (See: Alfresco 5.2 Docs, Developing -> APIs -> Web Scripts -> Architecture and framework).

Smart Folders are not a unique content type but rather a standard Alfresco folder (cm:folder) with a specific aspect, smf:smartFolder, applied to it. This aspect is the key identifier that distinguishes a Smart Folder from a regular folder. It contains the properties, such as the search query (smf:query) and the template (smf:template), that define the folder's dynamic behavior and how its content is populated. Therefore, recognizing the presence of the smf:smartFolder aspect is the correct method for identifying a Smart Folder.

A. Smart Folders are not a distinct node type. They are standard cm:folder nodes enhanced with an aspect.

B. smf:contains is the child-association type used for the virtual nodes within a Smart Folder, not for identifying the folder itself.

D. A node reference is a unique identifier for any node in the repository; it does not inherently describe the node's behavior or identify it as a Smart Folder.

E. Smart Folders are functionally different from standard folders due to the applied smf:smartFolder aspect, which enables their dynamic, query-based content.

1. Alfresco Content Services 5.2 Documentation, "Smart Folders": "A Smart Folder is a standard Alfresco folder (cm:folder) that has the aspect smf:smartFolder applied. The aspect adds the required properties for a search query and a template." This statement directly confirms that the aspect is the defining characteristic.

Source: Alfresco Content Services 5.2 Documentation, Administering > Administering Content Services > Smart Folders.

2. Alfresco Content Services 5.2 Documentation, "Smart Folder model": The documentation details the smf:smartFolder aspect and its properties (smf:query, smf:template, smf:language, etc.). This shows the aspect is the container for all Smart Folder-specific metadata.

Source: Alfresco Content Services 5.2 Documentation, Developing > Content model > Out-of-the-box models > Smart Folder model.

The file util.js is a core part of the Alfresco Share client-side JavaScript library. It defines the Alfresco.util namespace, which contains a collection of commonly-used, general-purpose utility functions. These functions are designed to be reusable across various components and widgets within the Share user interface. Examples of functions provided include those for HTML encoding (encodeHTML), date formatting (formatDate), managing CSS dependencies (loadCSS), and creating unique DOM IDs (generateDomId), among others.

A. common.js is not a standard file in the core Alfresco Share JavaScript framework for housing general-purpose utility functions.

C. slingshot.js is the main application file for the Share web application (codenamed "Slingshot"), responsible for initializing the application's primary components and page structure.

D. alfresco.js is the bootstrap file that creates the root Alfresco JavaScript namespace and loads other core components, but it does not contain the utility functions themselves.

1. Alfresco Content Services 5.2 Documentation, Share Client-side Library: The official documentation describes the Alfresco.util object as the location for common utility functions. The file that provides this object is util.js.

Source: Alfresco Content Services 5.2 Documentation, "Share Client-side Library". (While the page doesn't explicitly state "util.js contains Alfresco.util", this is the standard convention and verifiable in the source code. The documentation focuses on the API namespace provided by the file).

2. Alfresco Content Services 5.2 Documentation, JavaScript API: The JavaScript API reference details the functions available under the Alfresco.util namespace, confirming its role as the central repository for client-side utilities.

Source: Alfresco Content Services 5.2 Documentation, "JavaScript API > Alfresco.util object". This section lists the utility functions such as encodeHTML, formatDate, and generateDomId.

The TemplateNode is the specific FreeMarker API wrapper provided by Alfresco to access and manipulate repository nodes and their properties within a template. When a ScriptNode object is passed from a web script controller to the FreeMarker model, it is automatically converted into a TemplateNode for use in the view. This API provides convenient methods and property accessors (e.g., ${document.name}, ${document.properties.title}, ${document.children}) suitable for a templating context.

A. ScriptNode is the API used in server-side JavaScript (e.g., web script controllers), not directly within FreeMarker templates.

C. NodeRef is a low-level object representing a node's unique identifier, not the high-level API with methods for accessing properties.

D. TemplateObject is a generic term and not the specific name of the Alfresco API class for accessing nodes in templates.

1. Alfresco Content Services 5.2 Documentation, "FreeMarker Template Guide": This guide explicitly states the role of TemplateNode. In the section "The Alfresco Template Model," it details how objects are made available to the template. It clarifies: "Alfresco Repository script objects of type ScriptNode are automatically converted to objects of type TemplateNode."

Source: Alfresco Content Services 5.2 Documentation > Developing > API > Scripting API > FreeMarker Template Guide.

2. Alfresco Content Services 5.2 Documentation, "ScriptNode API": This document describes the ScriptNode object, which is used in the server-side JavaScript context of a web script controller. This distinguishes it from the TemplateNode used in the FreeMarker view.

Source: Alfresco Content Services 5.2 Documentation > Developing > API > Scripting API > Scripting API services > ScriptNode API.

3. Alfresco Content Services 5.2 Documentation, "Web scripts": The overview of web scripts explains the Model-View-Controller (MVC) pattern used. The controller (JavaScript) prepares a model of data, which often includes ScriptNode objects. These are then passed to the view (FreeMarker template), where they are accessed as TemplateNode objects.

Source: Alfresco Content Services 5.2 Documentation > Developing > API > Web scripts.

The simplest and most direct method to execute a custom script from a content rule is by leveraging the built-in "Execute a Script" action. This standard action is designed to locate and run JavaScript files stored in a specific, predefined location within the repository: the Data Dictionary/Scripts folder. When configuring a rule in the user interface, this action provides a dropdown list of all available scripts from that folder. This approach requires no custom Java development, Spring configuration, or packaging into an AMP, making it the most straightforward option.

A. Creating a new custom action and bundling it into an AMP is a more complex, heavyweight development process, not the simplest way.

C. Placing a script on the classpath with a specific function name does not automatically register it as a new, selectable rule action in the UI.

D. The "Execute a Script" action is hard-coded to look in the Data Dictionary/Scripts folder, not the folder where the rule is applied.

1. Alfresco Content Services 5.2 Documentation, "Out-of-the-box actions": This official documentation lists the available actions for content rules. For the "Execute script" action, it states: "Executes a script against the content item. You select a script from the menu that contains all the scripts available in the Data Dictionary > Scripts folder."

Source: Alfresco Documentation, Alfresco Content Services 5.2, "Using rules > Out-of-the-box actions". (Specific section reference).

2. Alfresco Content Services 5.2 Documentation, "Repository-side JavaScript files": This section explains where to store repository-side JavaScript files for them to be accessible by features like rules. It specifies: "Store your scripts in the repository in Company Home > Data Dictionary > Scripts. The out-of-the-box rule action 'Execute a script' can then be used to run the script."

Source: Alfresco Documentation, Alfresco Content Services 5.2, "Developing > Customizing and Extending > Repository-side JavaScript > Repository-side JavaScript files". (Specific section reference).

The Alfresco 5.2 REST API, specifically the Repository-level API, is built upon the Web Script Framework. The framework's dispatcher servlet, which handles incoming RESTful calls, is mapped to two primary URL patterns by default. The base URL http://server/alfresco/service is the main entry point for web scripts. Additionally, http://server/alfresco/s is provided as an alias for /service that enforces authentication for the web script call. Both are valid base URLs for accessing the web script-based REST API.

B. http://server/alfresco/restful: This is not a default or standard base URL for any of the REST APIs provided with Alfresco 5.2.

C. http://server/alfresco/script: This URL pattern is not used by the Web Script Framework; the correct patterns are /service and /s.

D. http://server/alfresco/ws: This base URL is reserved for the Alfresco SOAP (Simple Object Access Protocol) Web Services, not the REST API.

1. Alfresco Content Services 5.2 Documentation, "Web script dispatcher": This official documentation page details the configuration of the web script dispatcher servlet. It explicitly states the URL mappings: "The Web Script Framework is bound to the URL /service/ and /s/ by the web script dispatcher servlet." This confirms that both /service (E) and /s (A) are correct base URLs.

Source: Alfresco Content Services 5.2 Documentation > Developing > Web Scripts > Web Script Framework > Dispatcher.

2. Alfresco Content Services 5.2 Documentation, "Web Services": This section describes the SOAP-based web services. It provides examples of WSDL URLs, such as http://localhost:8080/alfresco/ws/API/Repository?wsdl, which confirms that the /ws path (D) is designated for SOAP Web Services, not REST.

Source: Alfresco Content Services 5.2 Documentation > Developing > Integrations > Web Services.

The web script descriptor's element controls the transactional context for the script's execution. If this element is omitted from the descriptor file (.desc.xml), Alfresco defaults to a value of required. This default behavior ensures that by default, all repository operations performed by the web script are wrapped in a transaction, guaranteeing data consistency and integrity. The script will join an existing transaction if one is present, or a new one will be initiated if not.

A. None: none is a valid value that must be explicitly set. It is often used for read-only (GET) operations to improve performance but is not the default.

B. None for GET Web Scripts, “required” for POST/PUT: This describes a common best practice, not the framework's default behavior. The default is required for all HTTP methods.

D. Depends on the value of : The and elements are independent configuration settings within the descriptor; one does not influence the default of the other.

1. Alfresco Content Services 5.2 Documentation, Web Script description language reference:

Section:

Content: "Specifies the transactional context in which the web script will run... If not specified, the default is required."

Reference: Alfresco Documentation - Web Script Description Language Reference for ACS 5.2.

2. Alfresco One 5.1 Documentation, Web Script description language reference:

Section:

Content: The documentation for this earlier but compatible version also confirms the default. "If not specified, the default is required."

Reference: Alfresco Documentation - Web Script Description Language Reference for Alfresco One 5.1.

The Alfresco Content Services security model is fundamentally hierarchical. By default, a node (a file or folder) inherits its Access Control List (ACL) from its parent folder. When a node is moved from one folder to another, its parent in the repository hierarchy changes. Consequently, the node ceases to inherit permissions from its original parent and begins inheriting the ACL from its new parent folder. This ensures that content automatically adopts the security context of the location to which it is moved, which is a core principle of managing permissions within the Alfresco repository.

B. It will inherit the ACL from the user who is moving it.

A user's permissions determine if they can perform the move action, but the object's permissions are derived from its location, not the user acting upon it.

C. It will inherit the system wide ACL.

There is no single "system wide ACL" for content. Permissions are granular and determined by a node's position within the folder hierarchy, not a global setting.

D. It will keep its old ACL.

This is incorrect for the inherited portion of its permissions. While a node can have its own local ACL, it also inherits permissions, and that inherited part will change upon moving.

1. Alfresco Content Services 5.2 Documentation, Administering, Managing Permissions: The documentation states, "By default, a folder or content item inherits the permissions of its parent folder." This core principle dictates that changing the parent by moving the item will change the source of inherited permissions. (Source: Alfresco Content Services 5.2 Documentation, docs.alfresco.com, Section: "Managing permissions").

2. Alfresco Content Services 5.2 Documentation, Repository Concepts, Permissions: This section explains the hierarchical model: "The permission model is hierarchical. Permissions set on a container (a space) are inherited by the objects it contains (other spaces, content items)." A move operation is a change of container, which directly implies a change in inherited permissions. (Source: Alfresco Content Services 5.2 Documentation, docs.alfresco.com, Section: "Repository concepts > Permissions").

Alfresco's official Software Development Kit (SDK) for the 5.x platform is fundamentally based on Apache Maven. The SDK provides Maven archetypes to generate standardized project structures, such as the All-In-One (AIO) project, which is the recommended starting point for most customizations. This approach streamlines the entire development lifecycle, including dependency management, compilation, packaging of extensions into Alfresco Module Packages (AMPs) or simple JARs, and running integration tests. The use of Maven is deeply integrated into the documented development process, making it the unequivocally preferred tool for building and packaging extensions for Alfresco 5.x.

A. Winzip: This is a file archiving utility, not a build automation tool. It cannot compile Java code, manage dependencies, or execute project lifecycle phases.

B. Ant: While used in much older Alfresco versions (pre-4.0), Ant was superseded by Maven as the preferred tool due to Maven's superior dependency management and standardized project structure.

D. Gradle: Although a capable modern build tool, the official Alfresco SDK, tutorials, and project archetypes for the 5.x series are exclusively based on Maven, not Gradle.

1. Alfresco Content Services 5.2 Documentation, "Introduction to the Alfresco SDK": "The Alfresco SDK is a Maven-based development kit that makes it easy for developers to build customizations for Alfresco. It is based on a standard Maven layout, and provides a number of archetypes (project templates) that can be used to generate projects for a number of common use cases."

Source: Alfresco Content Services 5.2 Official Documentation, docs.alfresco.com, Section: Developing -> Alfresco SDK -> Introduction to the Alfresco SDK.

2. Alfresco Content Services 5.2 Documentation, "Creating an Alfresco project with the SDK": The primary instruction for creating a new extension project is to use a Maven command: mvn archetype:generate ... -DartifactId=my-project-repo-amp. This demonstrates that Maven is the required tool for using the official SDK.

Source: Alfresco Content Services 5.2 Official Documentation, docs.alfresco.com, Section: Developing -> Alfresco SDK -> Getting Started with the Alfresco SDK -> Creating an Alfresco project with the SDK.

The url.templateArgs object is specifically designed to access values from placeholders within a web script's URI template. When a URL like /user/{username} is defined, and a request is made to /user/johndoe, the value "johndoe" is captured and made available in both the JavaScript controller and the FreeMarker template via url.templateArgs.username. This object provides a map of the arguments extracted directly from the URL path.

B. url.args: This object contains parameters passed in the query string of the URL (e.g., ?name=value), not from the URL path itself.

C. arguments: This is a standard JavaScript object that provides access to arguments passed to a function, not a specific Alfresco root object for URL parameters.

D. args: This is a convenient root-level shortcut for url.args, which contains query string parameters, not parameters from the URL path template.

1. Alfresco Content Services 5.2 Documentation, "Root objects": This official documentation page lists the root objects available to web scripts. It explicitly defines url.templateArgs as "An associative array of arguments extracted from the URI path." and args as "An associative array of all query parameter values from the URI."

Reference: Alfresco Content Services 5.2 Documentation > Developing > APIs > Web Scripts > Web script reference > Root objects.

2. Alfresco Content Services 5.2 Documentation, "url": This section details the properties of the url root object.

Reference: Alfresco Content Services 5.2 Documentation > Developing > APIs > Web Scripts > Web script reference > Root objects > url. It states:

templateArgs: "An associative array of arguments from the URI path."

args: "An associative array of arguments from the URI query string."