A short, but sometimes time consuming thing are the missing Webreport Tabs. Imagine, you have a Content Server with an jetty based internal Admin Server or an external Admin server on a fast machine.
The problem
Then, from time to time, you will see this on editing a webreport:
All Edit Tabs for the webreport are missing. Although you can start the missing functions within the URL, its annoying.
The Cure
If this happens, use this Magic Trick N,12:
Simply stop Content Server and Admin Server. Start the Admin Server and wait at least 5 min before starting the Content Server.
Then you’ll see everything is there.
Wow. You made it. You are a great wizard.
Seriously:
There is a timing problem in the Content/Admin Server. If the Content Server starts to fast, COntent Server thinks, there is no license for webreports at first. Later, it gets the license, but the GUI is drawn without the webreports tabs.
Wait for your Content Server to start up. Wait at least for 5 min. Then everything will be drawn in the GUI.
In the new Content Server Version 21.1 there are two new Report Widgets for Security Clearances and Supplemental Markings.
How does it look like?
Here, both are shown on a landing page. This Widgets can be expanded by clicking on thy symbol on the lower right.
Then the full page widget view will be drawn. The report can be refined by selecting several columns.
How to configure?
Simply add this widgets on the perspectives you want by dragging and dropping the widgets from the new group “Security Clearance Reports” to the widget area.
How to Install?
The widgets must be installed. They are based on several webreports and livereports. These reports are bundled in an Content Server App called OTRMSecReports. Open the “Applications Management” and install the application along with OTRMReports.
If its installed, you can check the components in “View Application”.
Ensure, that the version number is correct or correct the appropiate zip file.
Happy Security Clearance and Supplemental Markings Listing!
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.
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 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.
This is the thirth article on calling Java from OScript. If you want to refer the first two articles on how to call Java from Oscript, please take a look at the first article and the second article here.
The equivalent data types in java and oscript are:
Disclaimer: This requires a modification of app.html. Doing that will put you in the club of villains who intentionally change internal weblingo files.
OK, you’ve been warned.
Just kidding.
Permanent modifications
Lets take a look on the result. Maybe you need such a thing to comply with federal rules, to setup any “Impressum” or any links with GPDR of other infos. Then this example is for you:
This is not a thing you can do with perspectives. So the easiest way is to change the app.html which starts smartUI. This time, a serious disclaimer:
As always, the app.html can be changed by patches or with new versions of Content Server without a notice. You should test these things after applying patches/new versions to check, if the modifications are still inside this html file.
But this is normal. At least on 20.4 this is running.
So how to do this?
Lets take a look on app.html (hier its named app-demo.html, I can switch between footer version and normal version by simply copying the appropriate html files).
First half is quite standard. The page adds the theme stylesheet and, if the CSS-Override is switched on, loads the custom stylesheet at last.
Then the Oscript based configuration of dynamic JS module parameters is loaded and the csui modules on the client side are configurated with that parameters by sending JSON arrays to csui.config.
Then all bundles are required for csui.
As mentioned, straitforward and not very complex.
The second part is simply an empty body. csui is using JQuery to add the perspective contents in the main body.
So you can simply add permanent things in that main body.
Csui will append the content after your content.
The content to make the red footer (see above) is
<body>
<div id="custhdr"
style="position: fixed;
left: 0; bottom: 0; width: 100%; z-index:10;
background-color: darkred; color: white;
text-align: center;font-size:15px; font-weight:bold">
<p id="borderimg1" style="border: 10px solid transparent; padding: 15px; border-image: url(img/border.png) 30 stretch;">
Standard html links like <a href="www.spiegel.de">Spiegel Magazine</a> or
normal content server legacy gui links like
<a href="http://localhost/cs162/cs.exe?func=ll&objId=2000&objAction=properties&nexturl=%2Fcs162%2Fcs%2Eexe%3Ffunc%3Dllworkspace" target="_blank" >Enterprise Workspace</a> of custom widgets can be used
</p>
</div>
</body>
First, lets define a div with our custom extension. The positioning is done via an internal style and serves as an example. The position can be set to any direction, I put it down as footer.
Then inside a p element is the content. First, to make things more nicely, a border image is put around the p element. Then standard text, standard html links or links to the content server content can be used as content.
You can even add a widget here, but this follows no perspective conventions. It will be fixed on the screen.
The smartUI will follow later after the closing </div>.
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.
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.