ACSCE-5X Practice Questions

The Alfresco Web Script framework provides a set of core root objects available by default in FreeMarker templates. These include objects related to the request context, such as args (URL arguments), user (authenticated user), and url (request URL details).

The workflow object, while available in the template's root model, is not a core framework object. It is a root-scoped object that exposes the Alfresco Workflow Service. It is considered an Alfresco Repository service-specific object made available to the scripting and templating context, rather than a fundamental object of the Web Script framework itself. Therefore, it is the one that is NOT a default root object of the core framework.

A. args: This is incorrect. args is a fundamental, default root object provided by the Web Script framework to access arguments from the request URL.

B. user: This is incorrect. user is a standard, default root object that provides information about the currently authenticated user, which is essential for context and security.

C. url: This is incorrect. url is a default root object provided by the framework to help construct URLs and access information about the request URI.

1. Alfresco Content Services 5.2 Documentation, "Web Script reference": This page lists the root objects available to the controller script and template model as part of the core framework. Notably, it includes args, user, and url, but it does not list workflow as a core framework object.

Reference: Alfresco Documentation 5.2 > Developing > Web Scripts > Web Script reference > Root objects available to the controller script and template model.

2. Alfresco Content Services 5.2 Documentation, "FreeMarker Template API": This document distinguishes between different types of objects available. It lists url and args under "Web Script objects" and workflow under "Alfresco Repository objects". This supports the distinction that workflow is a repository-level object, not a core framework-level one.

Reference: Alfresco Documentation 5.2 > Developing > APIs > FreeMarker API > Available root objects.

3. Alfresco Content Services 5.2 Documentation, "Root-scoped JavaScript objects": This page officially lists workflow as one of the root-scoped objects available to server-side JavaScripts, defining it as an interface to the WorkflowService. This confirms its status as a service-level object rather than a core Web Script context object.

Reference: Alfresco Documentation 5.2 > Developing > APIs > JavaScript API > Root-scoped JavaScript objects > Root-scoped Services APIs.

The maximum number of results returned by a search in the Alfresco Share interface is a configurable application setting. The correct and standard method to override the default value is by modifying the Share configuration file. The element, located within the section of share-config-custom.xml, directly controls this limit. Setting its value to 1000 will achieve the desired outcome. This approach ensures that customizations are maintained across upgrades and follows Alfresco's recommended extension patterns.

A. system.acl.maxPermissionChecks is a repository-side setting that limits the number of permissions evaluated during a search to prevent performance issues, not control the UI result count.

B. Modifying users.js is incorrect as this file pertains to the user management components and does not control the global content search results limit.

C. Modifying nodebrowser.js is incorrect as this file is specific to the Node Browser administration tool, not the primary search interface used by end-users.

1. Alfresco Content Services 5.2 Documentation, Administering > Configuring Alfresco Share > Share configuration files > share-config-custom.xml file: This section describes the purpose of share-config-custom.xml as the primary location for overriding default Share configurations.

2. Alfresco Content Services 5.2 Documentation, Administering > Configuring Alfresco Share > Configuring search: This page explicitly details the search configuration options. It states, "The property specifies the maximum number of search results to return." and provides an example of its use within share-config-custom.xml. The default is listed as 250.

3. Alfresco Content Services 5.2 Documentation, Administering > Tuning the server > Tuning search > alfresco-global.properties settings for search: This section describes the system.acl.maxPermissionChecks property, clarifying its role in limiting ACL evaluation for performance reasons, which is distinct from limiting the number of results returned to the user interface.

In Alfresco, the Solr index operates on an "eventual consistency" model. This means that when content or metadata is updated in the Alfresco repository, the change is not instantly and atomically reflected in the search index. Instead, the repository transaction is recorded, and the Solr indexer processes it asynchronously. There is a brief delay between the repository commit and the index update. The index is considered fully consistent with the repository only when the queue of pending transactions has been completely processed, which occurs when there are no new changes to index.

A server restart is a disruptive event and not the designed mechanism for achieving routine index consistency.

Alfresco's default Solr indexing is a near real-time, asynchronous process, not a daily batch job.

While Solr uses Lucene, this option is too generic. Option B correctly describes the specific state when consistency is achieved: the cessation of new transactions.

1. Alfresco Content Services 5.2 Documentation, "Solr overview": This section describes the architecture where the Alfresco repository and Solr server are separate. It explains that communication is asynchronous, which is the foundation of the eventual consistency model. The repository tracks changes, and Solr polls for them, creating a natural delay.

2. Alfresco Content Services 5.2 Documentation, "Transactional metadata query": This page details how Alfresco can query the database directly for metadata to ensure up-to-the-minute accuracy, acknowledging that the Solr index might lag behind. It states, "The search subsystem is eventually consistent. This means that there is a small delay between making a change to the content and the change being reflected in the search index." This directly confirms the delay inherent in the model.

3. Alfresco Content Services 5.2 Documentation, "Solr core configuration": The configuration properties for Solr, such as alfresco.solr.commit.lockType and settings related to transaction tracking intervals, illustrate the mechanisms that manage this asynchronous, eventually consistent process. The consistency is achieved when the tracking and commit cycles have processed all outstanding repository transactions.

The Alfresco Share framework is designed to be highly configurable through XML. The most direct and minimal method for adding a custom search form is to use the declarative Share Forms configuration. This involves defining the form's fields and appearance within a element in share-config-custom.xml. This new form definition is then registered by adding it to the list of available forms within the section. This approach leverages the built-in form rendering engine and search components, avoiding the need for custom FreeMarker templates or new web scripts for a standard implementation.

B: This is incorrect because providing a custom web script to handle the search request is not a minimum requirement; the existing search framework can handle forms defined declaratively.

C: This is incorrect because defining the form markup in a FreeMarker file is not the simplest method. The declarative Share form configuration is the intended minimal approach.

D: This is incorrect as it represents the most complex approach, requiring two new web scripts. This is unnecessary for adding a standard custom search form.

1. Alfresco Content Services 5.2 Documentation, "Customizing the Advanced Search form": This official guide details the process. It states, "You can customize the Advanced Search form by editing the share-config-custom.xml file." The example provided shows defining a new element and then adding it to the list under the AdvancedSearch configuration section, confirming that only XML configuration is needed.

Source: Alfresco Documentation Server, docs.alfresco.com/5.2/concepts/share-advsearch-custom.html

2. Alfresco Content Services 5.2 Documentation, "Share Forms": This document explains the declarative nature of the Share Forms engine. It describes how to define form controls, layout, and visibility entirely within the XML configuration, which is the foundation of the process described in the correct answer.

Source: Alfresco Documentation Server, docs.alfresco.com/5.2/concepts/share-forms-config.html

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.

In Activiti, the workflow engine embedded in Alfresco ACS 5.x, variables have two primary scopes. The first is the 'process instance' scope, where variables are accessible throughout the entire lifecycle of that specific workflow instance, including all its tasks and execution paths. The second is the 'task' scope, where variables are local to a particular user task. Task-local variables are typically used for data that is only relevant to that specific step and are not propagated to the parent process instance upon task completion.

B. Node and task: "Node" is a generic term for any element in a process diagram (e.g., task, gateway). It is not a defined variable scope in Activiti; scope is tied to the process instance or a specific task.

C. Process instance and form: A form is a user interface component used to capture data and set variables. It is not a variable scope itself; the variables it sets are stored in either the task or process instance scope.

D. Process instance and global: The term "global" is ambiguous. While process instance variables are global within that instance, Activiti does not have a "global" scope that spans across multiple, independent process instances. The correct terms are process instance and task.

1. Activiti 5.x User Guide, Section 7.5. Variables: "Every process instance can have variables... A variable can also be local to a specific task. Such a variable is only accessible on that task and its lifecycle is bound to that task." This section explicitly defines the two scopes.

2. Alfresco Content Services 5.2 Documentation, Workflow API: The Java API for the TaskService clearly distinguishes between the two scopes with methods like setVariable(String taskId, String variableName, Object value) which sets a process-instance-scoped variable from a task context, and setVariableLocal(String taskId, String variableName, Object value) which sets a task-scoped variable.

3. Alfresco Content Services 5.2 Documentation, Server-side JavaScript API, Workflow objects: The documentation for the task object in the Workflow JavaScript API shows properties for both process-scoped variables (task.vars) and task-scoped variables (task.localVariables), reinforcing the two distinct scopes.

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 widgetUtils.findObject function is a core utility within the Aikau framework, specifically used for customizing existing pages in Alfresco Share. When an extension module is processed, this function is used to traverse the JSON model of an out-of-the-box page to locate a specific target widget, typically by its id. Once the widget is found, the extension can then modify it, for example, by adding new child widgets (like a new menu item) or altering its configuration. This is the standard, non-intrusive method for extending default Aikau pages.

A. When creating entirely new pages, you define the complete widget structure, so there is no pre-existing model to search through with this function.

B. This function is designed to find a single, specific widget object that matches a criterion, not to retrieve a comprehensive list of all widgets.

D. The function operates within the JSON model of a single page to find widgets, not to discover or list the Aikau pages within the application.

1. Official Alfresco Documentation (5.2): The "Add new menu item to Share header" tutorial explicitly demonstrates this use case. The controller logic uses widgetUtils.findObject(model.jsonModel, "id", "HEADERAPPMENUBAR") to locate the main menu bar widget in the existing page model before adding a new item to it.

Source: Alfresco Content Services 5.2 Documentation, "Share Header" section within Share Extension Points. (While the direct link may change, this is a canonical example found in the 5.x era developer guides for Share customization).

2. Official Alfresco Aikau Tutorial: In tutorials covering Aikau development and customization, the primary example for page modification involves finding a component to extend. The widgetUtils.findObject is presented as the key helper function for this task.

Source: Alfresco Aikau Tutorial, Section on "Customizing Existing Pages". The example shows finding the alfresco/documentlibrary/AlfDocumentList to add custom actions. (Reference from historical Alfresco University courseware and developer series on Aikau).

In Alfresco Share, the selection of an "action group" for the Document Library is primarily determined by the context of the user interface and the fundamental nature of the content item. The current view (e.g., Detailed, Simple, Gallery) directly maps to specific action groups like doclib-details or doclib-browse in the configuration. Concurrently, the type of node (e.g., a cm:folder versus a cm:content document) dictates which set of actions within that group is relevant. For instance, a folder has an "Upload" action, while a document does not. These two factors establish the base set of actions to be considered.

B. The aspects applied to the node typically enable or disable individual actions within a group (e.g., versioning actions), but do not select the entire group.

C. The mime type of the node is used by evaluators to control specific actions (e.g., "Edit in Google Docs"), not to determine the overall action group.

D. The status of the document, often managed by workflows, influences action availability via permissions or specific conditions, rather than selecting a different base action group.

E. The current user's permissions filter which actions from the selected group are ultimately displayed and executable, but do not determine the initial group selection.

1. Alfresco Content Services 5.2 Documentation, Share Extensibility, Actions: This section details how actions are configured. It shows that action groups are defined within a component configuration, such as the Document Library. The examples and structure implicitly and explicitly tie action groups to UI views and differentiate actions based on node characteristics. (See Developing -> Share Extensions -> Share Extensibility -> Actions).

2. Default Share Configuration (share-documentlibrary-config.xml): Examination of this core configuration file for Alfresco 5.x reveals the defined action groups. For example, and directly correspond to the Document Library views (supporting option F).

3. Default Share Configuration (share-documentlibrary-config.xml): Within the action groups, individual actions use evaluators like evaluator.doclib.action.isContainer to differentiate between folders and documents, confirming that the node type is a primary determinant for the set of applicable actions (supporting option A).

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").