The latest addition in OpenTexts Template technology are Folder-Templates.
Reason for the new Folder-Templates:
Here is a couple of use cases:
Create a folder from template within in Workspace: Create some optional folders (not applicable to every Workspace) with predefined folder names, folder permissions, etc.
Create folder from template in the enterprise directory: Create a hierarchical structure with predefined folder names, folder permissions, etc
Folder-Templates – How do they work?
Lets explain this in a step-by-step example:
Create the Top Folder structure in “Content Server Document Templates”. Dont forget to add the Classifications according to your schema. Here the main structure is named “Stock Plan”
2. Create the folder structure as required.
3. Add the folder structure at any connected workspace you like. Here a smartUI based workspace is displayed. At the “+”, you can add the Folder Structure “Stock Plan” by one simple click.
5. Then the folder structure is added. The clock icon is a smartUI indicator, that this structure is new. (See my posts on this topic)
Annd there are all subfolders defined.
All Classifications, Categories etc applied to the template will also be present at this copy, like in any other template.
The Sky is the Limit!
Happy Templating.
Next week we’ll discuss the Improvements in Content Intelligence (3 new Widgets) and the Modifications in the Webreports in the amazing new Version 21.1 of Content Server.
Finally, Multilingual Metadata Support is implemented in Content Server 21.1. Before that version there was only Support available here.
The Users Point of Vue
Multilingual Metadata can be added/edited at the Property Panel of a document. The first screenshot gives the entry of the name, the second gives the entry of the Description field.
Only Names and Descriptions are supported for Multilingual Metadata. For more fields or even Category Attributes in multiple languages, refer to an OpenText Partner like CASSIA.
The Programmers Point of Vue
The Name and Description fields show at least two multilingual text pickers. These are found in the SDK in /lib/csui/controls/multilingual.text.picker and in /lib/csui/dialogs/multilingual.text.picker. Unfortunately there is no Documentation and no index.html. Lets take a look on that control:
The left screenshot is from dialogs, the right is from controls.
This is embedded in the header.view.js from the dialogs/node.picker and will only be activated, if Metadata Languages are enabled. The mixin allows the form to be displayed as a Bootstrap Popover.
Changes in that area require the changed multilingu<al text picker and also the changed paths to be followed for that changes. Therefore require a spawn of the whole nodestable widget to reflect that changes. This is acually not recommended.
The Treebrowse Component is a new in Content Server 21.1. What’s a Treebrowse?
Let’s take a look at the index.html at csui/controls/treebrowse/test
This is an additional Window with the tree based display of all folders in a Content Server. It can be configured that a click on the top left icon will switch it on and off. This Treebrowse Control will then change the display of a Nodestable according to the folder pressed.
Additional Features
Lazy loading and prefetch options for performance. There are a couple of options to configure the loading of the nodes for performance. A “Show More” button can be configured
Tree Navigation is in sync with Table View in Nodestable view. The Nodestable is displays the children of the selected folder.
Multiple root nodes can be configured.
Enable
This Treebrowse is always there, but it must be enabled.
var NavigationTree = {
enabled: function (status, options) {
if (!!enableSystemLevel) {
return true;
}
var enabled = false,
moduleConfigCollection = new configCollection(moduleConfigs);
moduleConfigCollection.some(function (mConfig) {
enabled = mConfig.get('enabled')(status, options);
if (enabled) {
status.originatingView.treeData = mConfig.get('data')(status, options);
}
enabled = enabled ? true : enabled;
return enabled;
});
return enabled;
}
};
return NavigationTree;
});
As you can see, the Enablement on a system level can be done in OScript. Refer to this post, if you want so figure out how.
If you want to configure this control only for certain folders, you should do:
Implement methods enable and data in a separate file and return them in an enclosed object.
Register this file which returns object containing enable and data methods as an extension to the “csui/controls/treebrowse/navigation.tree” in the respective module.
Enable method should return a condition that specifies when the Tree Navigation should be enabled.
The data method should return data that must be passed to tree navigation while instantiation. This data should include configurable settings. If there is no data to be passed default settings are applied.
Example
define([], function () {
'use strict';
var RMTreeView= {
enabled: function (status, options) {
var supportMaximizeWidget = $("body").hasClass("csui-support-maximize-widget"); return (supportMaximizeWidget && $("body").hasClass("csui-maximized-widget-mode") === false);
},
data: function () {
return {
"lazyTree": true;
};
},
sequence: 50
};
return RMTreeView;
});
A more complex enabled function (like in the index.html) is
enabled: function (status, options) { var parent_id = status && status.container && status.container.get('parent_id'); return !!parent_id; }
Parameters
Parameters thats need to be included as part of module config:
sequence – number default: 100 Decides the priority of a module when multiple modules enabled treeview.
enable – function controls whether the treeview command should be visible or not. Need to return a logic whether tree view command is visible.
data – function Returns an object of data that are passed to treeview. The parameters that are returned by the data method are passed as options to the constructor of node.tree.view.
Parameters that can be returned by the data method are::
lazyTree – Boolean default: false Decides whether to prefetch items at one level ahead to display without any delay on clicking showmore button / to fetch the items after clicking show more button.
showItemsBlockSize – Number default: 10 Number of items that are shown on expansion of any node or clicking on showmore button.
rootNodes – Array of nodemodels default: top most ancestor node of the currently active node An array of nodes which are used as root nodes by the tree. If more than one root node is provided then multiples root nodes are displayed.
Have you ever thought of the magic of extension points in smartUI?
What is an extension point?
This are the dynamic configuration points of smartUI. Calling the config URL in smartUI, you will see all extension points with all configured extension modules in the current smarUI. Normally you’ll add your modules in the file <your-base-requirepath>-extensions.json in your projectstructure build by yo.
All of these modules indicated by these json files are loaded at initialization and form the dynamic smartUI system.
This is an example of an actual configuration in a Content Server System :
As you can see in the configuration, an extension point allows the extension of the extension point with several definable extension modules. Ok,this sounds like a typical lawyer sentence.
In plain english:
This technique allows you to extend the capabilities of a base module (the extension point) with the extension modules listed.
How to add your own extension point?
Use cs-ext as requirejs extensions. This is part of the SDK (/lib/src/csui/utils/load-extensions). There is the module and a very brief short documentation.
If you want more infos on custom requirejs modules, refer to the example of a conditional module,
This is a require.js module like the one which I introduced for conditional loading in Febr 2020. cs-ext is part of the smartUI core. If you want to modify the cs-ext, then use the easy way of loading an requirejs extension described in the conditional loading article.
Overview of cs-ext (in the sdk)
Lets take a look at cs-ext. But if you are more interested in the usage of cs-ext, skip the overview and go to the next chapter “Usage of cs-ext” below.
define(['module', 'csui/lib/underscore'], function (module, _) { 'use strict';
This is the standard entry to add sme vars into the configuration. Interesting is the list of modulePrefixesToRetry, includes all modules to retry a reload, if the extension point loading fails.
function handleSuccess(onLoad, parameters) { onLoad(Array.prototype.slice.call(parameters)); }
The success handler, handles the callback
function handleError(error, onLoad) { if (config.ignoreRequireErrors) { console.error(error); console.warn('Loading extensions of "' + name + '" failed:', error.requireModules); onLoad([]); } else { onLoad.error(error); } }
The error Handler
function retryLoading(require, name, modules, onLoad, firstError) { var droppedModules = [], selectedModules = .filter(modules, function (module) { var slash = module.indexOf('/'); if (slash < 0 || .contains(config.modulePrefixesToRetry, module.substring(0, slash))) { return true; } else { droppedModules.push(module); } }); if (selectedModules.length && droppedModules.length) { console.error(firstError); console.warn('Loading extensions of "' + name + '" failed:', firstError.requireModules); console.warn('Dropping extensions:', droppedModules); console.warn('Retrying extensions:', selectedModules); require(selectedModules, function () { handleSuccess(onLoad, arguments); }, function (error) { handleError(error, onLoad); }); return true; } }
The retryLoading handler. Demonstrates how the reload a module, if there is an error condition. Only the modules with the prefixes listed in modulesPrefixesToRetry (see above) will be reloaded.
return { load: function (name, require, onLoad, runtimeConfig) { if (runtimeConfig.isBuild) { onLoad(); } else { var moduleConfig = runtimeConfig.config[name] || {}, modules = moduleConfig.extensions; if (modules) { if (!.isArray(modules)) { modules = Array.prototype.concat.apply([], .values(modules)); } if (modules.length) { require(modules, function () { handleSuccess(onLoad, arguments); }, function (error) { if (!retryLoading(require, name, modules, onLoad, error)) { handleError(error, onLoad); } }); } else { onLoad([]); } } else { onLoad(); } } } };
The main method is simply returned as js object.
All listed modules in the extension point list will be loaded and executed before the callback (the carrier module with the cs-ext entry) will be executed.
This may sound quite theoretical. Lets use cs-ext.
Usage of cs-ext
Select the module which you want to amend with an extension point. Lets use the csui/controls/table/cells/cell.factory (MUST exist) as an example.
Configure the proper extension in the project json like
Open the cell factory and examine the source code.
Notice the csui-ext! line at the end of the define-module list. This will search the require.config entries to get a list of the extension modules for this extension point. All listed modules (here hello.view) will be loaded and executed before the callback (stated in the line csui-ext) will be executed.
Back in the callback , the _.extend function extends the prototype of the cell factory by the methods “hasCellViewByOtherKey” and “getCellView”.
Summary
To make a custom extensible module (with extension point), add the csui-ext requirejs extension to your module and set the modules to be loaded in the appropriate json extension file.
Then point to your extensible module from your widget, and you are done. Then your module is configurable and extendable by using the csui-ext util module.
If you want to extend existing modules, you’ll have to spawn the widgets from the library to reflect your new module.
In the content server 20.4 you’ll encounter from time to time a requirejs error “define is not defined”. Normally on defining icons. This is very entertaining.
In 16.2.10 the same thing worked as a charm.
Dont panic, in the “Hitchhikers Guide to the Galaxy” you’ll find the solution.
42 (As always)
(Just kidding. Lets be serious.)
Serious
The case in 16.2.10:
In 20.2 and above
Ups. Looking insane.
Cure
Examine the browser console output. At the debug level.
Browser Console
As a nice addition for the entertainment, the module is uglyfied, it makes no sense to search for this strings, as they are produced during the grunt tasks. But on the other hand, a couple of lines further down there are some complaints of the grid.view.js that the “getSpritePath” is missing. And the offending module is supposed to return the getSpritePath function.
So, a search on getSpritePath gave the offending module, the sprite.js, which was introduced in 20.2 and is obviously required, when a widget wants to display sprites.
The module shows
Lets consult the requirejs error page mentioned in the browser console.
A check of stackoverflow.com gave me the resolution “name collisions can produce this” so I changed the sprite.js to
Changed Sprite.js
Changed the function argument from require to requireReiner. The name doesnt matter.
Result
Everything runs under 20.2 like it used to in previous releases. No more mismatched anonymous define() modules.
But be careful: You’ll get the old js file in all new SDK releases. You should override the old file with the corrected one in all js projects.
As always:
Disclaimer: This works for me. The usage requires proper testing and I will not be liable for any problems whatsoever on that.
Remember the System Messages in the Content Server? This is an handy tool to display system related messages, like: “Next weekend we have maintenance” to inform users on issues with the system.
Normally, System Messages are added or deleted in the Admin pages. Here is an example:
A name of the Message, the message itself, an option URL for any explanatory pages and an effective date build together the System Message. Per default the System Message has a timeout period of 2 days after publishing, but this can be set in the opentext.ini file by setting a value to NewsDFTExpiration.
From this source the System Messages will be displayed in the legacy gui like this
But whats if somebody uses smartUI? Unfortunately, there is no possibility to display System Messages in smartUI.
Until the otherwise senseless Welcome Widget is amended. It can look like this:
System Messages – the new feature in the Welcome Widget.
(Disclaimer: This widget is NOT in the OpenText SDK. This is made by me. Contact me if you interested in using that)
The widget gets its system messages directly from an REST call which extracts this Messages and delivers them to the widget.
The news player is basically an unordered list with an <li> for each news entry. all news were rendered in the <ul> This is a screenshot of the handlebars template.
If any url is in the System Messages, the link opens up in a new tab or a new window.
The news entries scroll with a pure CSS3 animation, no additional Javascript is needed for that. Here is the animation part of the news
And the magic of animation is done with this:
And suddenly the Welcome Widget supports System Messages.
One of the most interesting controls in the SDK is the side.panel. Reminds somehow to the good Documentum side panels, but is native in the new SDK for Content Server 20.4.
This can be used as a simple control to show things like search forms or oanything you like. Also, multiple views (slides) can be shown in a “Wizard Style”.
First lets take a look on the the sidepanel right out of the box. Quite astonishing, there is a index.html actually working under csui/controls/side.panel/test/index.html. If somebody starts this file, we’ll see side.panel in action:
Shows a nice panel sliding from left/right based on the configuration. This view can be used to show a single view or multiple views (as slides) as per configuration provided to it.
Quite interesting is the fact that if slides provided to the panel, panel’s footer include navigation buttons along with the button provided to the respective slide as part of configuration.
side.panel has modal (dialog) behaviour by default which optionally can pass using constructor param as well (options.modal).
There are several usage possibilities.
Simple Usage (on the right of the screenshot above):
var sidePanel = new SidePanelView({ title: 'Simple Usage Title', content: new Backbone.View(), buttons: [{ label: 'Button1' }] }); sidePanel.show();
If you want to have several buttons on the footer (in the middle of the screenshot above):
var sidePanel = new SidePanelView({ headerView: new Backbone.View(), content: new Backbone.View(), footer: { leftButtons: [{ label: 'Button1' }], rightButtons: [{ label: 'Button2', id: 'btn2' }] }); sidePanel.show();
An example for a “wizard style” sidepanel sliding from the left or the right into the screen
The approved way is to configure smartUI before its initialized from OScript.
This can be done by overriding the GetDynamicConfiguration in your base smartUI module (the one with the csuiextension orphan) like:
override function Assoc GetDynamicConfiguration(Object prgCtx, Record request)
List blacklist = { "Copy", "Move" }
return assoc{
"csui/widgets/nodestable/toolbaritems.masks": assoc{
"basecsui": assoc{
"tableHeaderToolbar": assoc{ "blacklist": blacklist },
"inlineToolbar": assoc{ "blacklist": blacklist },
}
},
"csui/widgets/nodestable/headermenuitems.masks": assoc{
"basecsui": assoc{ "blacklist": blacklist } } }
end
end
Here in this example, the toolbaritem.masks and the headermenuitem.masks are set up with our magic spice (a blacklist containing all the signatures of the commands not desired). This will remove the “Copy” and “Move” commands from the list of commands permanently. And permanently means, this will survice a Page Reload.
2. The ugly way (but also surviving a Page Reload)
The ugly way is a way is the standard OpenText Way of overriding app.html and configuring the blacklists by yourself. Lets take a look at the app.html (found at ../core/module/csui/html).
Here is an example on a windows server:
In the upper part you can see the csui.require calls. At the top you’ll notice a csui.require.config call, where you can put our magic spice (see above).
The disadvantage is, when you override app.html (directly or by using htmlmap) then you’ll have to check, if any future OpenText patches will override the app.html also.
BUT: If you override app.html, you can take advantage of this for example by implementing a permanent footer, which is always drawn at the bottom. You cannot do that with pure smartUI tools.
Here is an example of a permanent footer in the body part of the app.html.
3. The force way
There is also a brutal way to remove commands without that configuration of app.html. This requires
a widget or a command to do the removal
a couple of js lines
But on the other hand, this is the way which allows easy recovery of the command by doing a simple refresh of the page.
Here is a demo case (a wild version of the hello widget from my training installation). This is a widget with some demos and a new inserted button to delete a command.
Behind the button are some js lines of code, which will remove the Copy-Command. Actually, the lines var b=commands.get(“Copy”); and commands.remove(b); do the job.
You will have to require /csui/utils/commands unter commands to use this two lines.
Two Javascript Lines will decide the fate of the copy command
Lets see the initial command set. The Copy Command is here as usual.
After the red button is pressed in the then the Copy Command is gone:
We simply deleted the Copy command from the list of commands. This means, a simple Refresh will restore it.