This is a non-technical article, you can skip it or skim it to get an idea how to get experienced RedDot staff and/or more traction for your RedDot business. Beside these facts this site is a big teaser page to our job and RedDot project work section.

You might have come across the RedDot CMS consultant corner we’ve set up here a few months ago.

Have you seen the RedDot Consultant job corner?

If you are looking for a LiveServer consultant, a RedDot Contractor to solve your CMS project tasks or a worldwide group of Open Text Partners you wish to respond to your Request for Proposal then the job section is the right place for you.

Are you a RedDot CMS Consultant looking for work?

If you are a RedDot CMS consultant and want to upload your profile fee free to do so. There are plenty of new project out there waiting to get done. Why not publishing your CV and your RedDot CMS consultant eperience and get more job enquiries? Every you will get people visiting this site. Placing your Reddot Consultant profile up here is the next logical step to push your reputation.

Do you need a RedDot LiveServer Consultants?

If you are looking for a RedDot LiveServer consultant and want to advertise your job you can easily do that too. LiveServer experience is rare these days and there are a few chosen RedDot CMS and LiveServer experts out there able to help you. If you can’t find them here it is unlikely you will find them somewhere else.

Open Text RedDot Web Solutions Experts find and search projects here

Are you looking for the right ressource to complement your team? Do you have project work?
Would like to get an overview which capable RedDot agencies and consultants are out there and available for you?

Our visitors are the elite of Open Text consultants. They are exchanging ideas, solutions, tipps and tricks every day on this site from all over the world. This gives you the opportunity to find the matching development and consulting ressource in your country but also compare worldwide market rates.

RedDot CMS consultant work can often be done remotely and doesn’t necessarily require onsite work during the whole project cycle. A project can be set up and tested locally, then being imported to your UAT environment. You can have a RedDot consultant working for you from everywhere on this planet. All you need to do is find them.

Oh and yes, it’s free. Uploading your profile, adding a RFP(Request For Proposal) or entering any sort of RedDot job description is generally free of charge. You can get your own login and participate on the forum. You also can get us to do the work for you and it is still free.
Have a look at it, now.

In this article we will show you how to find the right files to extend Open Texts Delivery Server (formerly known as RedDot LiveServer) with your own Java classes.

You might have worked with LiveServer DynaMents before and sometimes you just wish you would have that special method or a nicer way to process this bit of information but the existing set of Delivery Server DynaMents just doesn’t exactly fit your needs. Therefore here comes your LiveServer tutorial for including your own Dynaments inside of LiveServer.

If you want to start your own adventure with DynaMents and inline Java functions which will extend the DynaMents functionality, you’ll need to go through the following steps:

1. Prepare the LiveServer (Delivery Server) environment
2. Prepare the java package and the java class files
3. Create your own class which you want to use to extend the built-in java classes

Prepare the LiveServer Delivery Server environment

First of all check your Delivery Server version and build. I was working on LiveServer (Delivery Server) build 4.0.0.8 but it’s recommended to upgrade it to LiveServer 4 SP1. Of course it is not necessary to upgrade your LiveServerS/Delivery Server, but it makes things easier if you are able to go with the upgrade as you will see below. (Always keep in mind to check the release notes and check issues affecting your environment. LS 4 for example has a known defect with updating/connecting to Active Directory which is yet about to get fixed)

Prepare the java package and the java class files

Finding the classes on your LiveServer environment can be a bit tricky, to create your own Java class file you will have to import one very important class package which is built in the LS. The class is called:
de.reddot.xmaps.dynament.DefaultInlineFunctions;
There are two ways to find it and to import into your class package during the compilation process:

A) Especially recommended to use if you have LiveServer without SP1, is to import the above mentioned class into your java project in which you will compile your own class. To accomplish that, simply import the JAR file with the necessary class which is located in
<LiveServer_Install_Directory>\\tomcat\\webapps\\cps\\WEB-INF\\lib\\rdls-rde-x.x.x.x.jar
x.x.x.x corresponds to a build version of LS. In my case it was rdls-rde-4.0.0.8.jar.

B) If you already have LiveServer running with the SP1 updgrade, you can find the necessary class in
<LiveServer_Install_Directory>\\tomcat\\webapps\\cps\\WEB-INF\\classes\\de\\reddot\\xmaps\\dynament\\DefaultInlineFunctions.class

Create your own class which you want to use to extend the built-in java classes

The Next step is to prepare a definition of your own class. It should looks like this:

// ############################
package com.company.package;
import de.reddot.xmaps.dynament.DefaultInlineFunctions;
public class ExtendedInlineFunctionsClassName extends DefaultInlineFunctions{
         public String function(String value, ...ANY OTHER VARS DESIRED){
                   String mustReturnAString=value;
                   return mustReturnAString;
         }
         //called inline like [#source:attribute#].function(...ANY OTHER VARS DESIRED)
}
// ############################

After that, all you have to do is to compile your own class file with your function(s) and then copying it to to the classes folder on your LiveServer directory:
<LiveServer_Install_Directory>\\tomcat\\webapps\\cps\\WEB-INF\\classes

And Voila! Based on that you are ready to go. Create your own Java methods and use the according DynaMents in your LiveServer project.
Questions? Ideas? More LiveServer enhancements? Use the comment box below!

Step 1 – %CMSRoot%\RadEditor.Net\Configuration\ToolsFile.xml

This file controls the global configuration of the RadEditor.  You will need to add a tool to one of the toolbars with the name InsertSnippet which (obviously) adds the drop-down list of snippets where you want it.  Then you add the snippets themselves by adding a new element, snippets, and putting the code you want for the snippet inside.  See below.

<root>
    <tools>
        <tool name="InsertSnippet" />
    </tools>
    <tools>
    ...
    </tools>
    <contextMenus>
    ...
    </contextMenus>
    <snippets>
        <snippet name="Standard Table">
            <![CDATA[
                <table summary="[Insert a table summary here for WCAG compliance]" class="nolines">
                    <thead>
                        <tr>
                            <th>Column 1</th>
                            <th>Column 2</th>
                         </tr>
                     </thead>
                     <tbody>
                         <tr>
                             <td>Digital Home</td>
                             <td>Consumer electronics</td>
                         </tr>
                     </tbody>
                </table>
            ]]>
        </snippet>
    </snippets>
</root>

Step 2 – Images

You can put icons in the snippet title, which is cool I reckon.

Just do this:

<snippet name="&lt;img src='images/Table.gif' /&gt; Standard Table">

Instead of this:

<snippet name="Standard Table">

The image doesn’t have to go at the front but it probably should.  Keep them small and remember the path is relative to the RadEditor.Net folder and not the CMS app itself. And be careful when mixing single and double quotes.  Lastly I have tried to use images from inside the Asset Manager for the icons but the URL seems to be too complicated.  Particularly in the escaping of &.  It can probably be done but I ran out of patience.

PS. Before you ask there is no easy way to do this on a placeholder-by-placeholder basis without multiple ToolsFile.xml files or some tricky hacked-in server-side code.  Go there at your own risk (it does work but it’s harder than described above).

The Problem

Postbacks won’t work in SmartEdit because the page isn’t being served in its natural state from ASPX, even in CMS 10.  The form post target contains the internal CMS URL of the page, not the SmartEdit URL.

The Solution

%ProgramFiles%\\Open Text\\WS\\MS\\ASP\\RDServer.ini

It is necessary to ensure that the temporary ASPX files generated for SmartEdit and Preview modes are persisted, as these are our postback targets.  To do this we need to alter a setting in the RDServer.ini file.   Changes to this file do not require RedDot to be reset, they take effect immediately in most cases.  Alter the Flags setting as follows:

;flags=1024
flags=1280

The semi-colon in front of the original value makes the line into a comment so that the value is ignored by the system.

%PreExecuteTemp%\\web.config
%ProgramFiles%\\Open Text\\WS\\MS\\ASP\\web.config

The config files in your pre-execute temp and CMS directories need to disable event validation and view state MAC since the page posts will be crossing application domains.  If your CMS directory doesn’t have a web.config file it is safe to create one.  Ensure the pages element contains attributes as follows:

<configuration>
    …
    <system.web>
        …
        <pages enableEventValidation="false" enableViewStateMac="false">
            …
        </pages>
        …
    </system.web>
…
</configuration>

Template Code

There is 1 critical and a few optional things you’ll need in your template to make postbacks work.  We need to redirect the postback to the page that is used to deliver the content.  In production that would be the ASPX page itself but inside the CMS it isn’t.  Worse still it’s different for Preview and SmartEdit.  You’ll need a script block as below as the last thing in your page, just above the </body>:

<script type=”text/javascript”>
    document.getElementById( "form1" ).action = location.href;
</script>

…assuming your main form has the ID form1 of course.

If your form/control does autopostback on field types that don’t normally support posting you will also require a little server side script block like this:

<script runat="server">
    public void Page_Init( object sender, EventArgs e )
    {
        //this ensures the __doPostBack() JS method is included on the page
        ClientScript.GetPostBackClientHyperlink( this, "" );
    }
</script>

…as it says in the comment, this ensures the __doPostBack JS method is included in the page.  This will only work if your page has AutoEventWireup set to true.  Also, if you’re using a “User Control” it will need to be Page.ClientScript instead of just ClientScript.

If possible put this into inline code so you can use a SmartEdit Mode block (<!IoRangeRedDotMode>) to remove it for publication.  If you need to put in into code-behind you can use the URL to filter out this code at run-time.

Finishing Touches – Asynchronous Postbacks

In CMS 10 the user interface makes use of the Microsoft AJAX library, particularly in SmartEdit.  This means that you can’t include a ScriptManager in your form without breaking the CMS.  See the ScriptManager causes the Microsoft AJAX library to be added too, meaning it is added twice, which screws things up.  You need to do two things to fix it.

Template Code – Server-side bit

Put the following into your Page_Init() method, either the inline one that you added just a moment ago, or the one in your code-behind:

//this is required to ensure MicrosoftAjax.js code is not included
//in the page twice; the path "null.js" is intended to result in a 404
sm.ResolveScriptReference += new EventHandler<ScriptReferenceEventArgs>( ( obj, args ) => { if ( args.Script.Name.ToLower() == "microsoftajax.js" ) args.Script.Path = "null.js"; } );

This code assumes your ScriptManager has the ID sm.  It will re-write the path to the MicrosoftAjax.js that is generated by the ScriptManager to “null.js”, which obviously doesn’t exist, thereby ensuring the MS Ajax library is only loaded once.

Template Code – Client-side bit

Annoyingly there is one method you need to re-write in the Microsoft AJAX framework which controls the async postback target.  I haven’t tested thoroughly enough to be sure this doesn’t have any side-effects on the CMS itself so if you see something let me know and I’ll try to work through it.

Essentially we need to direct async calls from Update Panels to the CMS Temp virtual directory rather than the default directory, which is the CMS itself (the current path).

Append the following to the client-side script block at the end of the page (just before the </body>):

//re-write this to use the overloaded version of _resolveUrl with the
//provided base path
Sys.Net.WebRequest.prototype.getResolvedUrl =
    function Sys$Net$WebRequest$getResolvedUrl() {
        if (arguments.length !== 0) throw Error.parameterCount();
            return Sys.Net.WebRequest._resolveUrl(this._url,'http://cms/RDTemp/');
    };

You will need to update the url to match that of your own Pre-Execute Temp virtual directory.  The overload for _resolveUrl already exists in the framework but it is always called with the basePath parameter set to null.  We are just adjusting that behaviour a little.  There may be a way to do that using server-side attributes but I can’t see it at the moment.

Download the template here and before you use it donate $1 to keep this site up and running.

This template is a nice piece of work from the German RedDot Developer Ingo Hillebrand, also known as shift8.de. Simply insert the guids where required or replace them with your placeholder. Links to the specific page the feed points to have been realized with a dynamic list element because Render Tags can’t reference pages within a target container setup.

“What RedDot needs is some love! Instead they got renamed from RedDot CMS to Open Text Web Solutions Suite and must have felt like Cinderella living with the step mother and some ugly sisters.”

source

What’s next in 2010

Open Text will present us something new in 2010 I believe, something to show some support for the RedDot Community, something new and shiny and hopefully not too marketing flavoured. I had good conversations this year with some Open Text guys. A lot of guys are trying hard to make a change there and wake up from the RedDot buyout fatigue but Open Text is a big fat vendor vessel (no offense) and those are usually quite slow, so getting something ready for crew usually takes time and it might be a bit like the Titanic struggeling with changing course. But we learned from the past, didn’t we?

Where can you find some RedDot love before the year ends?

Yep – you are right – within the community. That is you out there! You are on the lookout with everyone else and we are willing to shout if we either think we can see an iceberg or on the contrary something of interest worth heading for. The people from Longwood University in Farmville, Virginia, United States, Planet Earth don’t have icebergs and they seem really happy with their RedDot CMS.
So they did something neat to share with you earlier this year and made a nice video. I’ve already tweeted this one earlier this year and I think in the spirit of Christmas this video is worth being seen and getting some props from us.

With the right RedDot CMS Partner and/or the right RedDot integration Team for your implementation this video is pretty close to what could happen to you when you migrate your CMS project with RedDot CMS. Sounds like marketing (and I apologise), but fact is: The more your development team has to think and suffer – the happier your editors should be.. right?

Merry Christmas!

to the guys from Longwood University and all of you out there in the RedDot Community!
Thank you for a great 2009 and see you next year!

Wishes?

What do you wish for 2010 from Open Text or your favoured CMS vendor?
Which

• features?
• fixes?
• additional geek toys?
• usability enhancements?
• the next big marketing suite report bang?
• simplified collaboration and solution sharing?

…or whatever gave you grief in 2009 and what would you like to get solved or rather not have to encounter again in 2010?

It’s not only a matter of “nicer looking” filenames, but it’s also a serious issue in a project’s SEO strategy: You can translate important keywords in your filename for better search engine rankings for each of your language variants.

Download

Transfer Filenames 1.00 (ZIP, 6 KB)

Plugin: Transfer RedDot Descriptions

New! This is a real timesaver: Transferring the RedDot descriptive texts of all of your content classes to another interface language is now done with a few clicks – you can even translate them with an easy XML export.

Plugin: Transfer Filenames

New! Translate all the filenames in your project to other language variants: Optimize your SEO results, place relevant keywords directly in the filename for each of your site’s languages.

RedDot UI: Check Filename

Update: In addition to the default HTML popup window, you can use AJAX to get the plaintext response directly. It’s also possible to validate a given filename and make sure it doesn’t contain special chars, umlauts or spaces.

RedDot UI: Report

Update: It’s just a little stability update which has been lying around for almost a year. I’m really terrible sorry for that!

I hope you enjoy these new releases. Merry Xmas!

Fear not, my fellow CMS developer, with this plugin you can easily transfer RedDot descriptions into another language variant, either directly or translating them first. Therefore it’s splitted into two components: The first part reads all RedDot descriptions from each placeholder of every template and stores it into an XML file. This can be used for translation. Afterwards, the second component writes these settings back to a different user interface language.

Download

Transfer RedDot Descriptions 1.00 (ZIP, 12 KB)

Some background first I think.  There are 2 ways to log in to CMS – normal and integrated.  An integrated login means that your Windows user account is passed silently by your browser to the CMS server and you don’t need to type in a username or password.  If you’re organisation uses Windows and you aren’t using integrated login slap yourself across the face now for being lazy, then read up on how to configure it.  Your users will thank you tomorrow.  It takes about 10 minutes to set up and is much better for security (since it’s harder to forge).  If you are using integrated login already this is super-easy and you’re probably wondering why I’m bothering to blog about this at all.  If you’re reading this, therefore, it stands to reason that you’re not.

I am going to assume that you, reader, already has the capabilities required to locate the GUID of the page you want a preview of.  In some cases you will require the LinkFromGuid as well to provide CMS with the context it needs to render the page properly.  I have had success with the following minimalist URL:

http://rd/cms/ioRD.asp?
Action=RedDot
&Mode=0
&PageGuid=2875BB10F2944DF09BC041D44D6F79A0
&Type=page

[If you use Action=Preview it will work without the Mode parameter]
[If you have lots of projects you should send the ProjectGuid parameter too]

If you want the full thing for your case simply pop a preview window, right-click the page and hit Properties.  Triple-click (yes, you read that right) on the URL to select even the bits that fall off the screen and you can copy/paste into your editor of choice.

There are 3 approaches…

1. RQL => Hard

You can use the following RQL to get the preview HTML of a CMS page:

<IODATA loginguid="[LoginGuid]" sessionkey="[SessionKey]"> <PREVIEW mode="0" projectguid="[ProjectGuid]" versionguid="[VersionGuid]"    isolated="[Isolated]" generatedate="[AsAtDate]"    templateguid="[templateGuid]" rights1="[UserRights]"    loginguid="[LoginGuid]" url="[URL]"    querystring="[QueryStringParams]"    />
</IODATA>

This is hard for a few reasons.  Firstly there is quite a lot of information you are going to need to create an RQL like this, not least of which you are going to have to login to the RQL system which will require credentials and you may not want to ask your user for them.  This is where integrated login comes in.  With it you can use the Windows Integrated Login system so you can get your user into RQL without requiring a username and password for them [read how to do it here].  Otherwise just form the normal RQL login tags with a username and password.  The second problem is that while this will return you the HTML of the preview it will provide no assistance in rendering, so you will need to re-map all the image placeholders and probably generate a bunch more pages for JavaScript and CSS (assuming they are built off Content Classes and not just stored in the Asset library).  That is definitely the hard way.

2. Integrated Login => Super Easy

Simply point your user at the URL.  Since the browser and RedDot do the login in the background it should just work.  Assuming you already have the GUIDs you need from somewhere else.  If not, you first need to run some RQL to get them.  This is where the Integrated Login plugin I talked about before comes in handy.  Using that you can silently log your user into RQL, execute whatever steps are required to get your GUIDs, and redirect the user to the correct URL.  Job done.

3. Standard Login => Moderate

The problem here is that you need to get credentials off your user.  If you don’t log your session in to RedDot you will get a nasty error message when you launch the preview URL to the effect that LogonGuid and SessionKey are missing.  That’s because these are server variables that RedDot is expecting to have when it attempts to generate the preview.  The only way forward is to get them, and that means logging in.

You need to do this in ASP because we need to set Session variables for the CMS to use. It is possible to get/set session variables with other languages but it’s way harder than if you just use ASP.  Here are the steps to follow:

• Create a new plugin ASP page – this is the page you will call to perform all the tasks required to access the preview
  • On the first pass of the page show login username and password boxes for the user to complete
  • On the second pass use that information to form the login RQL command
  • Do other steps to get the GUIDs you need to form the preview URL – this may include asking the user for more information, or you could supply it as parameters in the originally called URL
  • Redirect the user to the preview URL
• Set your external app to call your plugin with the correct parameters
• Since you’re not calling this plugin from CMS’ SmartTree/SmartEdit there is no need to register it in the normal way.

The reason we do it as a plugin is that plugins run within the application scope of the CMS.  That means session data stored in a plug is available to the main CMS, including the LogonGuid and SessionKey that get generated as part of the RQL login process.  We can save these to Session variables so the preview page can get at them.

You can download a sample ASP file here.