Quick List of all Categories and Attributes in a Content Server

Looking for a quick list of all Categories and Attributes configured in a Content Server? Tired of browsing the Categories Volume? Want to see all attrobutes and their IDs in a list?

Easy.

Simple use this line as your URL

<server><OT base><cgi>?func=attributes.dump

(p.ex. http://myserver/myContentServer/cs.exe?func=attributes.dump)

This will return this list:

The attribute.dump output
The attribute.dump output

Although this is a screenshot from a Contentserver 16.2.6, you can use this command at least back to Version 10.5.

 

The Cluster Manager is dead in Content Server 16.2.6 – Long live System Center Manager

In Content Server 16.2.6 the Cluster Manager is gone.

Whenever you try to open the Admin pages, you see this:

Admin Page 16.2.6
The new Entry “Cluster Management”

Install the System Center Software

First, you have to download and install the System Center Software. Clicking on the Link “Download Software” directly connects you the the Knowledge Center. After logging into this Knowledge Center, you’ll arrive at the  Landing Page for the System Center.

Knowledge Center “System Center Landing Page”

The System Center(s) are avaliable for Windows and for Linux servers. Select the proper version for your system and download it.

Install it.

You’ll find the System Center directly in the list of programs, like here in Windows Server 2012

Configure it

Double Click to start. Next, you’ll see the System Center Home Page

Like in the cluster management, you’ll need to download an agent per Content Server system and install that agent at that particular system – Click on Download and Install Agent.

(dont forget your local system!).

Next, you have to register the systems, onto which you just unstalled the agents. Go back to the “Home” of the System Center and click on “Register Systems”

Under “Managed Systems”, you see all systems already registered, under “Pendig systems” there are all systems with agents recognized by the System Center.

Click on the entry in the column “Actions” on the system pending, and you can register the agent. A Click will give you the detail view (here the system is already registered)

So you are nearly done!

Click on “Discover Products” for this particular system at the bottom of the page and the system is checked for all supported products and those installed are listed.

 

How to check for patches and install them?

Easy. Until now, you did the setup.

This has to be done only once.

Go back to the “Home” and click on “Check for Updates”

This will lead you to the “Products” tab with Updates for the registered product.

Either expand the “Avaliable Patches” entry and select the patches you want to install or select all by checking the checkbox at “Avaliable Patches”. Then click on “Download Selected” and see the system working.

First you need to login into Knowledge Center

Patch Download started

 

Press Close and you see the download window. As the download is done async, you see green marks (downloaded and installed) and also the moving circles (waiting for download or still in progress)

Download Window in System Center

 

It also provides a list of supported products by clicking “Catalog” from the “Home” page of the system Center

Catalog of supported products

The latest releases are listed directly in the calalog overview.

 

So the System center is much better then the Cluster Management doing updates.

 

 

 

 

 

 

 

 

 

Using Webreports as Widget Alternative in smartUI

Widgets are controlled by perspectives, changing the data displayed in the widget requires a change of perspectives
When you restrict yourself to use only the standard REST command set, you’ll find that you fire a lot of REST commands
You lost the capability of using navigational menus with computed URLs.

This leads me to some thoughts towards webreports as an adddition to widgets.

Webreports used as widget surrogates do have this pros and cons.

Pros:
You can use standard bootstrap navigational menus and UI elements, which allows you to mimic your webreport like a widget.
You can easily build things like Wizards inside your webreport structures. This is interesting, when you require some complex categories setup at doc creation time.
Webreports can use different sources to diyplay things, all server based. You can add the complete output via asynchronous AJAX call directly in your hosting webreport.
You can start actions inside the surrounding smartUI using standard jquery and html selections.
Starting Webreports and inserting the output via AJAX makes things quite fast. Especially when you display more than 1 record.
You get the option of using normal menu structures w/o the requirement of changing the perspectives.
Its easy for experienced webreport developers to modify the menu structures and the contents of such a meta webreport.

Cons:
Storing Webreports in the database require an additional license.
You have to load jquery by yourself.
No access to binf.js, unless you build one binf library without the normal csui-hierarchy or load a plain bootstrap.js.
In the last case, you’ll loose the css overwrite capability offered by the Content Server.
Webreports tend to require large numbers of themselves. This requires a very clean process documentation for the group of webreports.
Webreports take some time to start. On performance points, Subwebreports are evil. On the other hand, Subwebreports are required for a lot of things.
Doing things via AJAX means, you enter the wunderful world of async processing. Actually, you have no control on when the async webreport is finished

Here is a short receipe howto use webreports as widget surrogates:

Add a webreport html widget to your perspective. This one will held your base webreport.
This base webreport contains all menu structures and also all js needed.

Define your webreports for the different “pages” controlled by your menu. Each webreport is a stand alone webreport.
Call these via js from your menu structure. Use AJAX calls.
Insert the output from this webreports in a html structure (like a div).
Add somewhere a home button to switch back to your first page.

Some more tips:
Consider using stored searches in your “page” webreports. These are quite fast, depending on your search infrastructure. You dont have to use multible webreports to support this, you can switch the sourceID on the AJAX call to the webreport.
Consider to use the REST tags of a webreport.

Adding a Bootstrap Menu in a smartUI Webreport or HTML widget

Inside the webreport html widget there used to be the opportunity to use plain html for menu or other purposes. Since 16.2.4 there is a new widget in town, a plain html widget without the need of an webreport license.

In both cases, you have to think of the new namespace (“binf”) on using bootstrap.

Take a bootstrap menu for example.

This is an example of a plain bootstrap menu

The plain bootstrap code wont work, because OpenText added the prefix “binf” to introduce a special namespace.

Change the plain code by adding these “binf” prefixes:

<nav class="binf-navbar binf-navbar-default" role="navigation">
 <div class="binf-navbar-header">
 <a class="binf-navbar-brand" href="#" >Committee Menu</a>
</div>
<div>
 <ul class="binf-nav binf-navbar-nav">
 <li><a href="#" ;alert(s);">Committee News</a></li>
 <li><a href="#">Member List</a></li>
 <li class="binf-dropdown">
 <a href="#" class="binf-dropdown-toggle" data-binf-toggle="dropdown">
 Documents
 <b class="binf-caret"></b>
 </a>
 <ul class="binf-dropdown-menu">
 <li href="#">List Documents</li>
 <li href="#">Notify users</li>
 </ul>
 </li>
 </ul>
</div>
</nav>

Please do not forget to change the “data-toggle” also to “data-binf-toggle”.

Using handlebars to setup a select box in CSUI

Look at the standard problem:

Your handlebars template contains a Selectbox to display a the status of a task:

<select name="status" id="Status" class="binf-selectpicker" data-style="binf-btn-warning">

<select name="status" id="Status" class="binf-selectpicker" data-style="binf-btn-warning">

{{#select status}}

<option value="0" selected="">Pending</option> 

<option value="1">In Process</option> <option value="2">Issue</option>

<option value="3">On Hold</option> 

<option value="-1">Completed</option> 

<option value="-2">Cancelled </option>

{{/select}} 

</select>

And the values you receive from the REST Calls are between -2 and 3.

How can you transfer this in a “selected” clause in the html select box?

 

Easy.

Ass a select helper in your main marionette view:

 Handlebars.registerHelper('select', 
function (selected, options) { 
Handlebars.registerHelper('select', function (selected, options) 
{ return options.fn(this).replace( new RegExp(' value=\"' + selected + '\"'),
 '$& selected="selected"'); });

This handlebars helper named “select” will examine the coding tagged betweern a {{select}} and a {{/select}} in your handlebars template and insert at the option clause which is selected a ‘selected=”” ‘ clause. Then the Selectbox is ready to use.

 

Simply add a

status: this.model.get('status'),

to be returned in your template helper and the

{{#select status}}

...

{{/select}}

 

will trigger your select box helper to check for the v ariable status and to add a selected at the proper place.

Thats the magic behind the handlebars select helpers.

Technical Training “How to program a Widget in the new Content Server GUI” with the CSUI SDK

Hi folks

Beeing Content Server Trainer, I was asked to provide a training “How to program a Widget for the new Content Server GUI” to several customers. This is about the content of such a training and the reason why such a training is technically really advanced.

CSUI SDK introduces a shift in paradigma, the server is no longer providing the GUI, all is done by a Javascript Application at the client side.

Basic Training (newest version 1.005 from Feb/2018)

The basic training is very compact and lasts 5 days.

First, lets take a look on the components:

As a prerequisite, a firm knowledge of CSIDE, How to build a module, the Node Structure and whats to do with Content server Nodes is necessary.

At the end of the training, you’ll have a working knowledge of:

  1. Content Server Perspectives. What are they and how you can use them to provide a user specific interface.
  2. Content Server REST. This is the only possibility for the client to communicate with the server, so its mandantory to know the REST interface from the application point of vue. And, as REST can be very slow due to unneccesary data, its also mandantory to know, how to add REST services to the Content Server to get the data you want in the fastest way.
  3. Javascript. There are Javascript Patterns, which are used heavily in the SDK. If “Javascript Object Inheritance”, “Currying/Schoenfinkelizing”, “Decorators” etc are weird words for you, this chapter is the right chapter for you.
  4. Next is the infrastructural world of the sdk.
    CSUI Components
    The CSUI Components

    There are several components, which must be understood prior to build a Widget.

    1. node.js is the base Javascript system for our development
    2. grunt.js is a Javascript task runner, which we use to build, test and debug our widget
    3. yeoman is a scaffolding system, which will be used by a Opentext extension to initialize the development folder. It also creates the skeleton of a Content Server module, which is used as a “Carrier” for our Widget(s)
    4. backbone.js is the base framework to be used
    5. marionette.js is an extension to backbone.js, making Views easier.
    6. handlebars.js is the html templating framework used in the sdk
    7. require.js is the javascript module loader to be used
    8. bootstrap.js/binf.js is originally the public domain CSS/JS framework from Twitter for the appearance of the Widget. Binf is the Opentext variant, allowing to override CSS without negative effects
  5. Next is the SDK itself. Due to time restrictions, in the base training are only the base functions, the advanced training covers the other aspects. It contains
    1. Installing the SDK
    2. Building the Demo Widget
    3. CSS Style Overrides binf
    4. General Overview of the SDK
    5. Content of the SDK
    6. Routing (Preview of the Advanced Training)
    7. New Commands
    8. Custom Columns
    9. Metadata
    10. Define a new NodeType
    11. Create a Widget
    12. Base Widgets
    13. Controls
    14. Models
  6. Mockup and Test Data. How to setup mockup REST data. How to build test facilities in the SDK
  7. Anatomy of the Hello Widget. A walktrough through this widget
  8. Anatomy of the MyAssignment Widget
  9. Add another Widget to the Content Server. Change the Hello Widget and add additional fields
  10. Build a Custom Widget to be used as Client with a custom REST service. Here, a custom widget is build, which uses an extended version of the custom REST service from Part 2.
  11. If time allows: Some Tips and Tricks from a “Work-in-Progress” Widget

 

Advanced Training (Version 1.005 Feb/2018)

OK, thats the basic training. There are a lot of additional things inside the SDK, but to understand these, there must be a couple of weeks with practical experience in between. The advanced part has beed remodelled to include a couple of interesting things.  The advanced part contains:

  1. Chapter 1 Extended SDK Parts
    1. Additional Widgets
      1. NodesListReportView
      2. TilereportView
      3. FilteredCountChartView
      4. Carousel Widget View
      5. Userwidget eSocial
      6. ActivityFeedWidgetView
      7. ActivityFeedContent
      8. ChatWidget
    2. Datepicker
    3. switch
    4. Workflow (new in Content Server 16.2)
      1. Workflow Components
      2. Workflow in smartUI
      3. Starting Workflows
      4. URL Routes
      5. Workitem Actions
      6. Workitem Extension
      7. Writing Workflow Extensions
    5. New REST API Support (16.2) for Workflows
    6. Widgets not part of the SDK
      1. Mobile Scanning
      2. xECM: Header Widget with Business Object Infos
      3. xECM: Snapshot of current document Attachments
      4. xECM: Dossier View Widget
      5. Engineering Doc Management: Search
      6. xECM: Office365 Groups
  2. Chapter 2 Extended SDK Features
    1. Build Language Packs for Internationalization
    2. Commands
      1. Implementation and Inheritance from “CommandModel”
      2. Best Practices
      3. Using Commands
    3. Custom URL Router. Routing, adding custom Routers. Using Routers as Navigation.
    4. Behaviours. What are Behaviours?
      1. DefaultActionBehaviour
      2. BlockingBehaviour
      3. ExpandingBehaviour
      4. InfiniteScrollingBehaviour
      5. PerfectScrollingBehaviour
      6. PageLeavingBehaviour
    5. Mixins. What are Mixins? All available Mixins.
    6. Browsable Support for Collections. Using the “Browsable” support for Model-Collections.
  3. Chapter 3 Additional Things to consider
    1. Tips and Tricks (Work in Progress- List can change)
      1. Add a OTDS Ticket already in the browser to the connection object
      2. Re-using a OTDS Ticket as LLCookie
      3. Checking the paths in the test/index.html
      4. Using Helpers for supporting a select box with Handlebars
      5. Adding non CSUI supported JQuery functions in a view
    2. Handlebars advanced. A deeper look into Handlebars
    3. LESS advanced. A deepter look into LESS, the CSS language used in Bootstrap
    4. Accessibility in Bootstrap. What can be done to add support for screenreades etc to Bootstrap/Binf? Whats to avoid? Which tools are available
    5. Best Practices in Development

 

As you can see, there is a lot of stuff. The basic training last 5 days, the advanced training 2. But on the other side, you’ll get happy users with your new Widgets.

And that’s all what counts.

References

Javascript
  • “JavaScript Application Design “as a general introduction (covering Grunt) https://www.manning.com/books/javascript-application-design
  • Stoyanow’s JavaScript patterns http://shop.oreilly.com/product/9780596806767.do
  • Flanagan’s “JavaScript: The Definitive Guide” http://shop.oreilly.com/product/9780596805531.do
  • Crockfords “Javascript The good Parts” http://shop.oreilly.com/product/9780596517748.do
  • Flanagans “JavaScript Pocket Reference” http://shop.oreilly.com/product/0636920011460.do
Bootstrap
  • Spurlock: Bootstrap Responsive Web Development http://shop.oreilly.com/product/0636920027867.do
  • Syed Fazle Rahman: Jump Start Bootstrap: Get Up to Speed With Bootstrap in a Weekend https://www.amazon.com/gp/product/0992279437
  • Alan Forbes: The Joy of Bootstrap: A smarter way to learn the world’s most popular web framework https://www.amazon.com/gp/product/1522792813/
Require.JS
  • Greg Franko: Instant Dependency Management with RequireJS How-to https://www.amazon.com/Instant-Dependency-Management-RequireJS-How/dp/1782169067
  • David Sulc: Structuring Backbone Code with RequireJS and Marionette Modules
    https://leanpub.com/structuring-backbone-with-requirejs-and-marionette
Backbone
  • Developing Backbone.js Applications Adnan Osmani http://shop.oreilly.com/product/0636920025344.do
  • js Patterns and Best Practices Swarnendu De https://www.amazon.com/Backbone-js-Patterns-Best-Practices-Swarnendu/dp/1783283572
  • js Cookbook Vadim Mirgorod http://shop.oreilly.com/product/9781782162728.do
  • js Blueprints Andrew Burgess http://shop.oreilly.com/product/9781783286997.do

 

Backbone-Marionette
  • Getting Started with Backbone Marionette Raymundo Armendariz, Arturo Soto
    https://www.packtpub.com/web-development/getting-started-backbone-marionette
  • Marionette.js: A Gentle Introduction David Sulc https://leanpub.com/marionette-gentle-introduction
  • Marionette.js: A Serious Progression David Sulc https://leanpub.com/marionette-serious-progression
Mockjax and Jasmine
  • js Cookbook Vadim Mirgorod https://www.packtpub.com/mapt/book/web_development/9781782162728 Chapter 8
  • KnockoutJS Essentials Jorge Ferrando
    https://www.packtpub.com/application-development/knockoutjs-essentials
  • JavaScript Testing with Jasmine Eva Hahn https://www.safaribooksonline.com/library/view/javascript-testing-with/9781449356729/

 

Content Server Trainings
  • 4-0140 Content Server IDE (CSIDE) Fundamentals
  • 971-301 Livelink ECM Enterprise Server Workflow Customization Fundamentals
  • 03-0117/8 Webreports Design

 

 

New in 16.2 Workflows in SmartGUI

A new feature in the content server version 16.2 is the usage of smartGUI in workflows. This gives a standard workflow user a great new experience in using this workflow.

Lets see, how:

Setup

But first, you have to setup an few things.

This is our workflow map which we use in this example:

Example Workflow Map
Example Workflow Map: Computer Approval

In the Classic UI edit the workflow map.

Goto to the Initiator. Mark „Initiate in Smart View“ . Add to Workflow Definition and save the map

Workflow Start Step
Initiator

(optional)

goto the Tab „Smart View“ and add a form. Forms can be added to all steps, if they are enabled for display in Smart View.

This is an example of the last step on „How to enable a step for SmartUI“:

Enable a Step in SmartGUI
Enable a Step in smartGUI

Save the map and exit.

Now its time to see our workflow in the smartGUI.

Usage

Switch to the smartGUI and instantiate the workflow from the map.

Instantiate a Workflow
Instantiate a Workflow

Then the Workflow Widget appears. At this stage, you can set all attributes as usual, you can add files at to the workflow by dragging and dropping these to the right side of the widget

Workflow Widget
Workflow Widget

Add some comments

Comments on the Workflow
Comments on the Workflow

Click submit and login with the userid of the first step assignee.

Open Workflow
An open workflow in a landing page

Here, you see your open workflow step in the “My Assignments” widget. Clicking on the entry opens the Approval widget

Approval in the workflow
Approval in the workflow

By clicking on the attachment at the right side, the attachment can be opened, downloaded or the properties can be checked.

Attachment
Attachment

The properties look like

Attachment Properties Window
Attachment Properties Window

Now after the examination, you can click on “Approve” and add a comment.

Then the Workflow Step is approved. The entry in MyAssignments is removed. The workflow is on the next step.

 

Easy, ist’t it?

Configuring elink and Mercury Mailserver

From time to time, you need a test email server on a VM or on a test environment to configure the Content Server elink capabilities. Or maybe a Exchange is too powerful for you?

Then Mercury as an email server and Pegasus as email client may be a good choice for you. You can download this at http://www.pmail.com/ .

But having a mail server up and running is only half of the price. You still have to configure elink and the mail server.

elink is a Content Server mechanism, which allows you to store documents via email or post replies to to discussions or send documents also via email.

Setting up elink is simple.

You have to imagine, that elink has to have a mailbox on the mail server, which is used to retrieve messages to the content server. This means, a mail to this mailbox is processed by the content server. The mail server must be configured that all mails from a domain will be stored in this mailbox.

for example the message

<123BeDessfdj>@elink.net must be stored in the elink mailbox to be processed by the content server.

First, lets configure the Mercury Server. First, we need to setup a Content Server used. Lets call it elink.

User Administration on Mercury

Second, we need to setup the Domain for this mailbox. If we enter the DM=user with the username just defined and an Internet Name (here elink.net) for our mails to the content server, we define that all  mails from the Domain elink.net will be stored in the elink mailbox.

Domain Administration on Mercury

Next, we need to configure elink. This must be done on the Content Server admin pages.

elink on Admin pages
Configuration of elink on the admin pages

Virtual Hostname is the name of the Domain, from which we want to store all messages in the elink mailbox.

Username/Password is the name of out mailbox user (elink) and its password. You can test the connection by pressing the “Test Connection” button.

If everything runs, you’ll see mails like these in the Pegasus mail client.

If everything runs, Content Server can be used though Pegasus

Setting Node ACLs via Web Services API

One of the nicest things in the content server area is, you can set Access Control Lists not only for the owner or the default group of a node, and you can add or revoke rights to the node for virtually all users and groups defined in the content server.

Here, we want do discuss how to do this using Content Server Web services. First, let’s see how ACLs are organized. A simple object would display something like this:

The ACLs for this object

On the left hand side, you see the default access, there is always one Owner, one default group and a public group.

If you want to assign further access, you can select a user or a group by clicking on the bottom at the lower left hand side. This will select a user or a group. (Btw: It’s recommended to use groups instead of users)

On the right hand side, there are the ACLs for the selected user/group on the object. Here, we used the Administrator, therefore all rights are switched on.

Ok, how to use this on a c# client?

First, the ACLs for a given user are called NodePermissions. Use them like this. Let’s say, this is utils.setNodeRights(….)

/// <summary>
 /// Creates a Noderight Structure and returns it
 /// </summary>
 /// <param name="rights">"all" or see (see,seecontents)</param>
 /// <param name="id">the member ID for this node rights</param>
 /// <param name="type">Owner, Ownergroup, Public or ACL </param>
 /// <returns></returns>
 public DocumentManagement.NodeRight setNodeRights(string rights, long id, string type )
 {
 DocumentManagement.NodePermissions newPerm = new DocumentManagement.NodePermissions();

newPerm.SeeContentsPermission = true;
 newPerm.SeePermission = true;
 if (rights.Equals("all"))
 {
 newPerm.AddItemsPermission = true;
 newPerm.DeletePermission = true;
 newPerm.DeleteVersionsPermission = true;
 newPerm.EditAttributesPermission = true;
 newPerm.EditPermissionsPermission = true;
 newPerm.ModifyPermission = true;
 newPerm.ReservePermission = true;
 }
 DocumentManagement.NodeRight newRight = new DocumentManagement.NodeRight();
 newRight.Permissions = newPerm;
 newRight.RightID = id;
 newRight.Type =type;
 return newRight;

}

The Nodepermissions is simply a container with the single access rights set to true or false.

When the definition is finished, the NodePermissions must be encapsulated in a structure called NodeRight. This contains the ACLs defined and the user/group for the ACL. Use the id as long integer, this is the unique identifier of a user/group in the content server. You can use MemberServices to get this number, if you know the login-name.

Then, the system wants to know, which kind this user/group is. Use ACL, if these are additional users/groups, or use something like Owner, Ownergroup or Public, if the ACLs should belong to the predefined entities.

How to use this?

First, login to the Webservices.

Second. Get the node, onto which you want to set ACLs.

Thirth. Get the node rights

 NodeRightsUtilities utils = new NodeRightsUtilities();
 DocumentManagement.NodeRights nodeRights = docclient.GetNodeRights(ref otauth, pargs.nodenumber);
 Console.WriteLine("Got Noderights ");
 
 DocumentManagement.NodeRight[] nodesrights = nodeRights.ACLRights;

Forth. Set the ACLs for the standard entities (if needed). Define a NodeRight for every entity (user/group) you want to set. Define these 2 right groups.

 // setup standard permissions for base ACL group
 DocumentManagement.NodeRight newRightstandardGroup = utils.setNodeRights("see", standardGoupID, "ACL");
 DocumentManagement.NodeRight newRightsmanagerGroup = utils.setNodeRights("all", managergroupID, "ACL");

Define a special right group

 DocumentManagement.NodeRight newOwnerright = utils.setNodeRights("all", ownerID, "Owner");
 nodeRights.OwnerRight = newOwnerright;

 

The nodesrights on a node can contain something or be null. First, lets check, if the thing is null.

 if (nodesrights == null)
 {
 Console.WriteLine("Nodesrights not found- no external Users/groups assigned");
 Console.WriteLine("Setting a group with rights see/seecontent");
 
 DocumentManagement.NodeRight[] allrights = new DocumentManagement.NodeRight[2];
 allrights[0] = newRightstandardGroup;
 allrights[1] = newRightsmanagerGroup;
 nodeRights.ACLRights = allrights;
 docclient.SetNodeRights(ref otauth, pargs.nodenumber, nodeRights);
 authClient.Close();
 Console.WriteLine("All Rights and Groups set --- Finish");
 return;
 }

In this case we simply define a NodeRight array with two entries containing our new RightstandardGroup and our newRightmanagerGroup.

Let’s store them into our newly created array.

Let’s store this array in our nodeRights under ACLRights. This will change our copy of our structure which we downloaded before.

Next is simply a SetNodeRights with the nodenumber and the updated nodeRights array to write our changes back to the server.

If there are already entries, you should set them like this:

// Just display the first Entry of the first assigned Users/groups
 DocumentManagement.NodeRight right = nodesrights[0];
 DocumentManagement.NodePermissions nperms = right.Permissions;
 // check, if we do habe the groups already set

int newLen = nodesrights.Length;

 // copy rights into new longer Array
 DocumentManagement.NodeRight[] allrights = new DocumentManagement.NodeRight[newLen+2];
 for ( int i = 0; i < newLen;i++ )
 {
 allrights[i] = nodesrights[i];
 }
 allrights[newLen] = newRightsmanagerGroup;
 allrights[newLen + 1] = newRightstandardGroup;
 nodeRights.ACLRights = null;
 nodeRights.ACLRights = allrights;
 docclient.SetNodeRights(ref otauth, pargs.nodenumber, nodeRights);
 Console.WriteLine("All Rights and Groups set --- Finish");
 authClient.Close();

In this case, our nodesrights come from the nodeRights.ACLRights, because there are alredy entries.

Now, let’s do the same thing like we did on a new structure. But, we don’t want to delete existing entries, lets simply add our new RightstandardGroup and our newRightmanagerGroup to the ACLRights array.

One thing, if finished, first set the nodesRights.ACLRight to null and then fill it with the new extended ACL array.

Then do a SetNodeRights with the nodenumber and the updated nodeRights array to write our changes back to the server.

 

Finished. Quite easy, isn’t it?

 

BTW: There is no equivalent to do this on the REST api at the time of this post.

 

 

 

Installing and activating Content Server Web Services on a Content Server Installation

If you are thinking on using Content Server Webservices (CWS´) you may wonder how to activate this on a standard Content Server Installation. Normally, right out of the box, CWS is not active or installed, although you got the license to use it in your basic license.

As Administrator, you have to do a couple of things to activate CWS.

Decide which architecture you will use.

CWS can be used inside of the Microsoft Internet Information Server or inside a Java Application Server like Tomcat. Both ways to activate will be described here.

Locate the CWS Software

Look in your install directory of the content server. There, you will find a directory named “webservices”.

Webservices Basedirectory

Here, there are three entries:

  1. dotnet contains all CWS service definitions for use inside the Microsoft IIS
  2. java contains all webapps for use inside the Tomcat application server
  3. java6 contains the same thing as in 2. but for use with java 6.
Installing CWS inside the Microsoft Internet Information Server IIS

First, let’s examine how to install CWS inside IIS. Switch to the dotnet subdirectory, then to cws (do not use les-services, this is an old version supporting legacy clients)

All svc files for installation

Locate the .svc files you wish to install and use in CWS.

Open the IIS Manager. Create a new Application at the default web site

Create a new Application
App pointing to CWS

Enter the path to the dotnet\cws directory , enter for example CWS as alias.

Remark: IIS must be configured to

  • execute .NET 2.0 apps
  • allow “Read” and “Script” rights to the new app
  • execute WCF (can be ensured for example by “%SystemRoot%\Microsoft.NET\Framework\v3.0\Windows Communication Foundation\ServiceModelReg.exe -i”  (check, if something changed, if you are using newer versions)
  • allow “Read” and “Execute” rights for the ID of the Application pool on $OTHOME/webservices/dotnet

And (don’t forget), ensure that your webservides will use the same port as your content server uses.  If you use a nonstandard port (not 2099) you need to change the port in the file $OTHOME\webservices\dotnet\cws\web.conf

If you use the standard port, there is nothing for you to do.

 

Installing CWS in Tomcat

Alternatively, you can use Tomcat as a base for CWS.

In this case, go to the java6 base directory in the webservices dir.

The war files

In this dir, you’ll find the war (web application archive) files, which you need to deploy.

Deploy the cws.war file either to the TOMCAT\webapps directory or use the Tomcat service manager to deploy this file.

The tomcat webapps dir

Don’t forget, if you changed your port number of your content server from 2099 to something else, change also the value in the web.xml of the unpacked cws web app.

The port in the web.xml file

If you don’t use the same port numbers, the whole system will listen to different ports and will do nothing.

Test your installation

Your installation is correct, if a browser, pointing to

http://127.0.0.1:8080/cws/services/DocumentManagement  (Tomcat) or

http://127.0.0.1//cws/Documentmanagement.svc?wsdl (IIS) shows

DocumentManagement

Remark: The WSDL Urls reflect the infrastructure of course. You see “:8080” only with Tomcat.

 

And now, feel free to discover the new world of content web services.