The service that perked my interest the most though was their Simple Storage Service or (S3).  S3 is, as the name indicates, a very simple storage service that allows users to store files along with up to 2k of metadata in the Amazon cloud(buzz) storage system.  Files can be as large as 5gb and are accessible via SOAP or REST services using either HTTP or bit-torrent protocols.  It’s not a free service, but the cost is very reasonable(they provide an online calculator to estimate your cost…I think you’ll find they are very cheap.  Total development cost for this little project was 8 cents).

Great, but what does S3 have to do with Content Management?

S3 is essentially a content repository as a service.  Obviously it does not meet all the requirements for a full blown content management system, but from the perspective of the things you absolutely need in a content repository(security, metadata, storage) to the things you’d like to have(high availability, high reliability, unlimited storage) it really does make for an excellent repository. 

I also really like the concept of being able to store the metadata with the content revision, it’s certainly not a requirement or even a common practice with most CMSs, but it just adds another layer of redundancy down the road.  I’m getting a little away from the theme of the post here, but the fella over at “Me and Content Management” had a great post on this concept and I have to agree with his thoughts.

So would it be possibly to take the robust content repository features of S3 and bundle them with a content management system?  Use the content management system as the front end, managing user security, contribution, workflows, delivery…all the great things that content management systems do, but then also utilize S3 as the content repository leveraging it’s power.

Enter Oracle UCM File Store Providers

One of the neat features of Oracle UCM 10gr3(also formerly known as Stellent v8), was the new concept of File Store Providers.  Earlier versions of Stellent forced a simple yet elegant configuration where the original files were stored in a protected folder structure known as the vault and the web accessible versions which might just be a copy of the original or a multitude of transformed versions are stored in a “weblayout” folder.  This set up works very well and I am sure is still employed by most Content Server instances.

One of the problems with this design was that it did not offer many options as far as drive space, each file has at least one copy in the vault and in the weblayout, so you automatically have to double your space projections.   Probably not a huge problem for word and text content, but start using the content server for Digital Asset Management and space requirememts definitely rise on the priority list.  Enter 10gr3 with file store providers and you now have a variety of storage options.

• Content can be stored without a web version
• Content can be stored in the database
• Content can be stored half in the database half on the file system

File Store providers are essentially a configurable abstraction layer from the content server to wherever you want to store your content.  The really neat thing about them though is that they appear to be a planned area of extensibility for the content server.

My S3 File Store Provider

A File Store provider for Amazon S3 seemed like such a logical enhancement to the content server that I had to give it a go.  Unlike service handlers, filters and all the other goodies in Bex’s book and the How to Components, I know of no best practices for File Store providers, so I’m a little on my own here.  Basically, if you use my project as a template, I am not sure I did it things “Oracle way” (or even if there is one).

In setting up the project I tried to figure out how Oracle configured and registered it’s JDBCStorage class, which is the primary object used in the database provider.  My set up consists of a class called SimpleStorage which implements the ExternalStorageImplementor and CommonStoreImplementor interfaces.  The File Store and classes are then registered in two tables: a mergeable table located in a component resources called FSStores and a non mergeable resultset found in the defaultFileStore’s provider.hda file(an install filter in the component handles the edit for you).  Most of the methods required by the interface are pretty straightforward; store here move there, etc…though there are handful of others that represented many hours of starting at the system audit window(addFilesystemPathInfo for one).

For the actual S3 communication I used and bundled an open source API called JetS3t.  JetS3t is an excellent API which I would highly recommend for all your Java/S3 needs.  In addition to the API, JetS3t includes a little GUI called Cockpit.  I’ve included it with the API in the component so you can use to take a peek at your S3 buckets.  You’ll find it in the lib/bin folder.  Site note: Thanks JetS3t team…your API worked great.

From a sort of overview perspective the provider works as so:

1. A user checks in a piece of content flagged for S3 storage
2. The vault content item is immediately stored on S3 along with up to 2k of it’s metadata(a config entry determines the fields to include)
3. If all content is to be stored in S3, the web version is then also stored on S3, otherwise it is written to the web layout folder
4. When the indexer attempts to access the vault file, it is retrieved and written out to the vault folder.
5. When a user views the content information page, or tries to access the web layout rendition, the web layout version is retrieved and saved to the web layout folder
6. A scheduled task then runs behind and deletes any vault or weblayout files which are stored on S3, but have not been accessed in a preset number of minutes.

Content can also be moved to and from S3 by preforming an Update and just changing the storage rule.

So what good is this thing?

I am pretty excited about this component because I think it’s a concept with some potential.  Couple your existing content management system with the ultimate content repository.  You get unlimited enterprise class, scalable storage at a very reasonable cost without the infrastructure and staffing requirements that go along with it.  I like to imagine future content server instances using a limited “working” storage area storing only content being actively used with terabytes of content stored out on S3.  No more SANs or the endless list of non-technology related headaches they bring.

I think we could also envision scenarios where content is managed in S3 by a content management system, but then read and accessed directly by other systems, potentially on different sides of the planet?  My knee-jerk reaction to that is that it sounds like a bad practice, but if it’s secured properly, why not?

Bandwidth and performance are probably the two things that would need to be watched in this sort of model, but I just don’t think they would prove to be much of a problem for the majority of content items.  Large files could potentially pose a performance problem, but how much more noticeable would downloading a 25mb file be if it had to come down from S3 first?  I am not sure most users would notice.

Something that may only interest me 

S3 is SOAP/REST based service…Imagine that, a protocol/service being used to retrieve content?  I hope the JSR170/283 fans take notice.

How to get it

The component is available for download here.  I should be clear that this is one of the more complex projects I’ve developed for the site and it hasn’t exactly gone through any stringent QA testing(it’s just me).  Like all my sample projects, it’s provided without warranty or support and I recommend you test it out thoroughly on a dev environment first.  My development(and testing) environment was a WIN2003 server, Oracle UCM 10GR3, Oracle 11g DB environment, but  I am fairly confident that the component will run on just about any environment that the Content Server will.  We just might need to switch out some jars.

You may have noticed from the nav, that this site now has a forums section.  If you do encounter an issue, please feel free to post it so the support forum.  I’ll get an email and maybe be able to help.

Here’s the download link:

Amazon S3 File Store Provider for Oracle UCM

Use Real Names for Section IDs

Starting work on a new site, my first step is to go through and set up the known folder structure of the site.  This usually only takes a little while, but it helps me visualize how everything will work as I’m developing.  One thing that’s very important to me during this step and really throughout the build is to ensure I’m using logical names for the section ids and not just the default numerical ones that the designer will assign.  Down the road when debugging fragments or even reviewing content in the repository, numbers as section ids can be very confusing and will probably cost more time the it takes to just give them logical names.

Create a Templates Folder

When I am building out the site’s folder structure I also like to create a contributor-only templates section.  There I add a section for each template the site will use, actually creating the template and assigning it to the section during the process.  Often I will break up the template sections by how they are used, adding primary and secondary template parent sections.  If I have any html ready, I paste it in to the templates, adjusting any css, javascript or image paths during the process.

The templates folder allows me to get all my templates in and assigned to the site, but in a central location.  Templates can be added as a site asset, so this is a bit redundant, but having them in a folder allows me to assign region content, test custom properties and potentially navigation as well.

Use Fragments for Images, Javascript and CSS

When I start work on a site I usually have the luxury of receiving all of my html, css and some of my javascript pre-built from our user experience group which means I am not doing any serious HTML development in Site Studio other then some simple tweaks.  Since that’s the case, there’s no good reason for me to load what could be hundreds of individual site assets in to the content server.  It’s much easier just to load each set of assets in to fragments and then check them in that way.  In addition you can preserve any folder structure the assets already have, making tweaks to the template html a bit easier too.  Loading each asset individually is perfectly fine, but I thinks far easier and a little cleaner in the content server to load them in fragments.

When you save the fragments it’s assets are written out to the weblayout/fragments folder.  Once those assets are there, I just create a single “head” fragment which references the nessecary items from css and javascript assets, never actually referencing the css or javascript fragments.

One Fragment per Library 

I’m a fan of creating a new library for each fragment in my site.  I’ve done this differently in the past, creating more contextual libraries with multiple fragments, but I’m much happier now with the one fragment per library way.  Right off it’s much easier to manage fragment development with multiple developers.  Multiple fragments in a single library means that one developer can check out a library at a time thereby preventing other developers from working on other fragments in the same library.  

My biggest reasoning though has to do with change management.  If there are multiple fragments in a library all of them must be production ready to deploy.  You easily can find yourself in a situation where a change is occurring on one fragment, when a bug or another emergency change needs to happen on another.  If all the fragments are in the same library it can become a confusing mess.  If you stick with one per library you may have a few more libraries in the content server, but you’ll also have a great deal more flexibility.

Debug that JSP

This next part can be a little tricky and from an Oracle perspective is probably a bad practice.  Generally whenever I set up a new development environment also set up eclipse to debug the content server as well.  Bex Huff’s book “The Definitive Guide to Stellent Content Server Development” details how to configure eclipse for debugging so I am not going to cover that process here.  What I will talk about though is that if you are running a version of Eclipse with JSP support, you can also debug JSP fragments and layout templates just as easily as filters and service handlers.

This sounds great, but you have to remember that if you’re debugging and editing your fragments through eclipse, ultimately you’re also doing it in the content server’s area of the file system.  If you’re not careful this is an excellent way to loose your work.  If anyone else edits your fragment library or if they deploy your fragment through the Site Studio fragment administration page, any changes you’ve made on the file system will be immediately overwritten.  To counter the threat of loosing my changes, I make sure I always check out each item I’m debugging and frequently save my changes back to the fragment using the designer.  All that said, being able to debug with eclipse can make development so much easier the rewards far outweigh the risks. 

To set up JSP debugging, first follow the steps in Bex’s book to set up your eclipse environment and then just link the weblayout folder to your content server project.  From there you’ll find your fragment JSPs in the weblayout/groups/[your jsp enabled security group]/WEB-INF/fragments/[fragment name] folder.

Some of the highlights so far:

1. There is a new web-based Site Studio editor coming out in the next few months to replace the existing activex one.  Personally this was huge for me as the IE only aspect of the existing editor has always been a pain point with some of my clients who prefer macs.  In general the editor was pretty slick.  It appears as a pop-up when you click the in-context edit button and has a tabbed interface allowing you to contribute content on one tab and update metadata on the other.  They’ve also added some additional validation which can be configured to require specific standards compliance when contributing.

 2. The WCMA project appears to now be called Open WCM and it looks to be very cool.  Not much of a demo this time, but more of an architectural discussion.  The concept is to allow web content management delivery on any platform, using any language..hence the open part.  In addition they also would like to take the content server out of the delivery environment, moving to more of a hybrid publishing model, which can be consumed by your web app.

 3. During the digital asset management session, we got a nice demo of what you can do with the Folios component that was released just last week.  Folios is very, very cool new feature which allows you to relate several content items together and have them become an additional new item in the system.  You’re new folio then can be associated with metadata, sent through workflow for approvals or, depending on the formats, published as a compound document.

Also very cool are some of ideas on how they plan on integrating Content Server with the other application in the Fusion Middleware stack.  There seems to be a big focus on delivering personalized, targeted content using Seibel profiles and Oracle’s Real Time decisioning application(part of the BI suite).  All of that is just conjecture at this point, but still very cool to hear they were working on it.

From what I read in the change log, Script.aculo.us has added some pretty cool features, but what I am most excited about is that Prototype 1.6 includes a JSON parser which was not available in the previous version.

I’ve updated the Oracle / Stellent Content Server script.aculo.us component available on this site.

Feel free to download it here:

Script.aculo.us Component for Oracle / Stellent Content Server

The component adds an admin-accessible interface for developing and executing IDOC Script.  Users can enter their script in to the very simple editor(just a textarea) and then execute it.  The resulting HTML is displayed in another area below the script editor.  Where I think it gets a little cooler though, is that it also outputs all local values created in the binder as well all resultset values in to windows-like box areas off to the side.  In addition you can also run the script as another user in the system to test out permissions and security. (NOTE: nice for development but probably bad for production so please be careful where you deploy this).

You essentially get a pretty clear view of what’s occurring with your script, but without restarting the server, saving a resource file or even refreshing a page.  The interface uses AJAX calls to execute the script and the parse the response.  The result is a responsive interface and what I think is a smooth experience…no jumping around to different windows or adding output variables to check values.

The app leverages the script.aculo.us/prototype javascript frameworks to handle the AJAX callbacks as well as the parsing and rendering of the data in the windows.  From an application architecture perspective, I basically added an admin only service called RUN_DEV_IDOC, which in turn calls a custom service handler class.  That class then creates and calls a new “stub” service to open up “clean” data binder and pager merger objects under the account of the requested user.  After that the IDOC script is executed, the results are returned and the data binder is parsed for local data and result sets.  All of that data is then wrapped in XML and dropped back in to the RUN_DEV_IDOC’s as a local data field.  The server then sends the response back to the page, where it’s parsed using javascript and used to create the output on the page.

My sort of grandiose idea on the plane was to create an editor with breakpoints, variable inspecting and watches.  I still may come back to that with a later updated version, but unfortunately the level of effort on that was a little more than two cross country trips.  Still this was a pretty fun app to work on and I personally look at it as unfinished, so check back in a few weeks and hopefully I’ll be able to add more to it.  Also if you have any ideas, I would love to hear them.

Feel free to download the component here:

IDOC Developer Interface

You will also need the script.aculo.us framework, which I’ve already wrapped in a component and can be downloaded here:

Script.aculo.us Component for Oracle/Stellent   

This sample project utilizes the YUI library to create that pop up as well as to provide a “slide” effect seen when the pop up appears and disappears. I was hoping to use a variety of YUI features, but unfortunately this example turned out to be extremely simple. It uses a similar “Panel” object to the one used in the Security Overrides example, however as you’ll see from this project it does not make any Connection Manager based AJAX calls like that one does.

This component has a couple IDOC resource overrides to add Pop Up Preview links to the Stellent UI, but in terms of actual code there’s a single Javascript class with really just a single major method, callPopUpPreview:

this.callPopUpPreview = function(id,name){
 //set the dID
 _dID = id;
 //set the dDocName
 _dDocName = name;//start the build of our URL
 var url = _httpCgiPath + "?IdcService=GET_DYNAMIC_CONVERSION"//if we have a dID add it to the url
 if(_dID)
  url += "&dID=" + _dID;//if we have a dDocName add it to the url
 if(_dDocName)
  url += "&dDocName=" + _dDocName;//if we have a revisionselectionmethod add it to the url
 if(_RevisionSelectionMethod)
  url += "&RevisionSelectionMethod=" + _RevisionSelectionMethod;//if we have a conversion template add it to the url
 if(_conversionTemplate)
  url += "&conversionTemplate=" + _conversionTemplate;//This line create the panel object
 YAHOO.popUpPreview.container.popupPreview = new YAHOO.widget.Panel("popUpPreviewDiv",
 { //set the width and hieght to the values set in the class
  width : _width + "px",
  height : _height + "px",
  //the pop up should be fixed to the center of the screen
  fixedcenter : true,
  //show a close link
  close:true,
  //don't allow dragging of the pop up
  draggable:false,
  //the panel starts out invisible
  visible:false,
  //this line sets the transision effect, where we are using the slide
  //effect and setting it's duration to .25 seconds.
  effect:[{effect:YAHOO.widget.ContainerEffect.SLIDE,duration:0.25}]
  } );//Sets the header / menu bar of the pop up
 YAHOO.popUpPreview.container.popupPreview.setHeader("Dynamic Conversion Preview");
 //Sets the body, note the use of the iframe to load the content. The onload event calls the handleiFrameLoad method to display the pop up
 YAHOO.popUpPreview.container.popupPreview.setBody("<iframe id='popUpPreviewBody' onload='Javascript:" + _objectName + ".handleiFrameLoad();' src='" + url + "'></iframe>");
 //render the panel to the page. this just starts the dynamic conversion call
 YAHOO.popUpPreview.container.popupPreview.render(document.body);
}}

The code does not come through so great on the blog, but what’s occurring is the URL to the dynamic conversion is assembled and then placed in the “src” attribute of an iFrame which is then written to a YUI panel object.  Why the iFrame?  Well when I started I intended to make more of a traditional AJAX call to get the dynamic conversion.  The problem though is that the dynamic converter creates a full HTML document complete with head and body elements, which can wreak havoc on the panel’s divs.  Using the iFrame let’s us encapsulate the dynamic conversion output in it’s own private little window and protects the rest of our panel and page from the variety of HTML that may be rendered in it. 

The callPopUpPreview method takes care of creating the URL to the dynamic conversion, creating the panel object and adding the iFrame to it, but it does not actually cause the panel display on the page.  Dynamic conversions can sometimes take a second or two to render and it’s a much nicer effect if we wait for the conversion before displayiing the pop up window.  So instead of just rendering the panel to the page, the onload event for the iFrame is used to call another method(handleiFrameLoad) in the popUpPreview class that can display the pop up once everything is loaded.  This way the pop up window will only appear once the conversion is complete.

Adding the actual links to the content server’s search results and content information pages requires a couple of resource include overrides: 

Append an additional PopupProps row in the extra_setup_search_results_action_popups include to add a links in the Search Results.
<@dynamichtml extra_setup_search_results_action_popups@> <$exec rsAppendNewRow("PopupProps")$>
<$exec setValue("PopupProps", "label", "Pop Up Preview")$>
<$exec setValue("PopupProps", "function", "Javascript:popUp.callPopUpPreview('<$url(dID)$>','<$url(dDocName)$>');")$>
<$exec setValue("PopupProps", "ifClause", "dcShowExportLink()")$>
<$exec setValue("PopupProps", "class", "document")$> <$exec setValue("PopupProps","id", "popuppreview")$>
<@end@>

The docinfo_conversion_link include can be used to add a link on the Content Information page
<@dynamichtml docinfo_conversion_link@>
<$include super.docinfo_conversion_link$>
<tr><td nowrap align="right"><span class="infoLabel"></span></td>
<td><span class="tableEntry">
<a href="Javascript:;" mce_href="Javascript:;" onclick="Javascript:popUp.callPopUpPreview('<$dID$>','<$dDocName$>');">Pop Up Preview</a></span>
</td></tr>
<@end@>


Also of note is that I used a new editor to create the popuppreview.js file. Rather than my standard text editor, I gave Adobe’s JSEclipse plug in a try. I am not sure I was using it correctly as the experience was not that much different from my text editor(only in eclipse), but as I figure out how to best use it’s features I’ll keep you informed.

The Pop Up Preview component is available for download here:

Pop Up Preview Component

However it’s done, I think their server has a huge amount of potential from an ECM perspective.  Nearly every client of mine has asked about offering some level of automation to their meta-tagging while contributing content.  While many of the enterprise vendors offer applications to automatically tag content, I find that they are usually focused on batch loading or migrating content, rather than assisting the every day contributor.  In my ideal world I’d love to see contribution forms come up pre-loaded with system recommended meta-data, allowing contributors to make only necessary edits and then simply approve thier submissions.

I was pretty pumped when I ran across Yahoo’s service, so I decided to throw together a quick component to take advantage of it for  Stellent / Oracle Universal Content Server.  Nothing too crazy here, the component basically adds an additional option to the Content Action menu called “Add Yahoo Terms”, which executes a service called “ADD_YAHOO_TERMS”.

The service then does the following:

• Performs a dynamic conversion on the document
• Reads the contents of the resulting HCST output file
• Posts the HTML to Yahoo’s Terms Extraction service
• Parses(XML) the terms returned
• Creates a comma delimited list of the best terms
• Saves the list to the binder in a predesignated memo meta-data field(the default is xComments)

The remainder of the service is basically the GET_UPDATE_FORM service, which brings up the update form.  Since the terms are in the binder as a meta-data field, the update forms comes up pre-loaded with the document’s meta-data as well as the Yahoo terms in the pre-designated field.  From there on you are on the standard Stellent / Oracle update form, so saving will commit your changes.

It’s a pretty simple integration, nothing revolutionary, but I think it’s a decent example of how one might integrate Stellent with Yahoo’s service.

Feel free to download the component here:

Yahoo Terms Extractor Integration for Stellent / Oracle

The concept behind the example component, Security Overrides, is an IDOC enabled version of the Security Filter example, which is part of Stellent’s HowToComponents Bundle.  Stellent’s SecurityFilter component is an example of how to use the alterUserCredentials filter to change the rights of a user during a specific service request.  The primary example is the BlackHole check in example which grants everyone write access when checking in an item using the Black Hole service.

Creating security filters or overrides with the alterUserCredentials can be a tricky proposition.  Depending on your implementation, you’re basically altering the behavior of the content server with no real visible indication that it’s being done.  In addition the alterUserCredentials filter is called with every service call, so it’s a great place to cause a performance problem with inefficient code, or just by adding multiple security filter components.

So how does the Security Overrides component and more importantly IDOC help the situation?  The component creates a central, administrator controlled, interface for creating and managing overrides. What’s more, each service configured has an IDOC script prompt, which is used in the final decisioning of whether to apply the override or not.  For example if an administrator desired to only allow the “sysadmin” account access to the providers page, they would configure an override  that removed all permissions for the “GET_ALL_PROVIDERS” service.  In the IDOC prompt script would be added to evaluate the dUser variable, ensuring it was the “sysadmin” account.

The beautiful thing here is that because the component is processing IDOC for it’s final decsioning logic, the override becomes extremely simple to alter as well as include addtional actions down the road if desired.  And as you’ll see in the code, creating a component which can support IDOC scripting takes very little additional work.

In addition to integrating IDOC scripting in a Java-based component, the component also demonstrates:

• Creating an installation filter, which creates a database table after start up
• Working with the YUI library to create a model, pop-up form as well as creating and handling AJAX requests
• The run-time creation and altering of environment variables
• Customizing the Stellent / Oracle interface

As you might have guessed from the word “Introduction” in the title, I plan on making the review of this component a multi-part series, rather then one long post.  The component along with it’s source code will be available for download here.

I should also mention that Oracle has a fully supported component available for download which has some of the same features as this one.  It’s called the “Need to Know” component and if you are considering using my example in a production system, please take a look at their component first.

Security Overrides Component for Stellent / Oracle

Despite my personal fandom of the WSDL component, it does have a couple drawbacks:

1.  Each web service is in it’s own namespace.  This makes it a bit of a pain when working with multi-step operations, for instance if you’re calling the DocInfo service with a WSDL it will return all custom metadata in an array of IdcProperty objects.  If you’re then planning on updating that item or checking in another related item, you’ll have to copy all your original IdcProperty objects over to new IdcProperty objects specific to the Checkin/Update service’s namespace.

2.  Aside from the seven or so pre-defined services, you have to define any additional WSDLS you wish to consume.  Not the end of the world, but it does make the development a little tricker when you need ensure your WSDL exists on each instance you connect to and that it’s defined to your specs.

There is an alternative; rather then using the WSDLs, you could just add IsSoap=1 to the end of any service call, which will then return you request in SOAP format.  Of course there’s no friendly WSDL to create all your proxy classes, leaving the SOAP parsing up to you.  In addition uploading files can also be pretty tricky as you essentially need to replicate a multi-part/form upload.

To make my life(and potentially yours) a little easier, I’ve been experimenting and ultimately developed a simple .NET API for the Stellent / Oracle Content Server.  Modeled after the Stellent’s Java-based idcserver package, the API can make IsSoap service calls to retrieve information, or just straight HTTP calls when downloading files.  In addition since all calls are made as multipart-form/data posts, one to many files may be uploaded and checked in.

The API has two public classes, the ServerBean which is the primary interface to the API and the ServerResultSet class which acts and behaves like a Stellent Resultset.  If you think you’ve seen those class names before, it’s because you have.  I tried to replicate the functionality of the Content Server’s idcserver package in .NET.

Here’s an example of a search results call using the API:

//create the object
ServerBean sb = new ServerBean();
//set the url to the content server
sb.ContentServerURL = "http://localhost/stellent/idcplg";
//set our credentials
sb.ContentServerCredentials = new System.Net.NetworkCredential("sysadmin", "idc");
//set the service
sb.putLocal("IdcService", "GET_SEARCH_RESULTS");
//pass in our query
sb.putLocal("QueryText", "dDocTitle <substring> `Test`");
//execute the service
sb.executeService();
//get our search results
ServerResultSet SearchResults = sb.getResultSet("SearchResults");
if (SearchResults != null)
{
  //loop through the search results
  for(SearchResults.first();SearchResults.isRowPresent();SearchResults.next()){
  //write the content id
  System.Diagnostics.Debug.WriteLine(SearchResults.getStringValue("dDocName"));
  }
} 

As you can see the syntax is extremely similar to the Content Server’s idcserver package.  Anyone familier with JSP development in the content server, should find it very familiar.

Uploading files is also very easy.  I’ve overriden the “putLocal” method so that it can accept a string or a FileInfo object as a value argument.

//create the object
ServerBean sb = new ServerBean();
//set our url
sb.ContentServerURL = "http://localhost/stellent/idcplg";
//set our credentials
sb.ContentServerCredentials = new System.Net.NetworkCredential("sysadmin", "idc");
//service is a check in new
sb.putLocal("IdcService", "CHECKIN_NEW");
//set the title and required arguments
sb.putLocal("dDocTitle", "NET TEST CHECKIN");
sb.putLocal("dDocType", "Document");
sb.putLocal("dDocAuthor", "sysadmin");
sb.putLocal("dSecurityGroup", "Public");
//create to fileinfo objects based on some local files
System.IO.FileInfo File1 = new System.IO.FileInfo(@"C:\Test Spreadsheet.xls");
System.IO.FileInfo File2 = new System.IO.FileInfo(@"C:\Test Text File.txt");
//add the files
sb.putLocal("primaryFile", File1);
sb.putLocal("alternateFile", File2);
//execute the service
sb.executeService();
//check our status
Console.WriteLine(sb.getLocal("StatusMessage"));


Since we also need to download files or retrieve raw results like a dynamic conversion, the underlying executeServiceEx method which is called by the executeService method and also returns a raw stream from the Content Server’s response is a public method.  Calling executeServiceEx directly will skip the lines of code realted to parsing the server’s response.

In this example, we perform a dynamic conversion and write the raw HTML to the console window

//Create the object
ServerBean sb = new ServerBean();
//set the url
sb.ContentServerURL = "http://localhost/stellent/idcplg";
//set our credentials
sb.ContentServerCredentials = new System.Net.NetworkCredential("sysadmin", "idc");
//set the dynamic conversion
sb.putLocal("IdcService", "GET_DYNAMIC_CONVERSION");
//set our required parameters
sb.putLocal("dDocName", "[Content ID]");
sb.putLocal("RevisionSelectionMethod", "LatestReleased");
//call executeServiceEx, which returns the raw stream
Stream resultStream = sb.executeServiceEx();
//create a reader
System.IO.StreamReader reader = new System.IO.StreamReader(resultStream);
//read the stream
String resultString = reader.ReadToEnd();
//write it to the console
Console.Write(resultString);

That’s the basic gist on how to work with the API, I will be following up this post with one going through the actual code.  Like any of my code examples, the API is provided without support or warrenty, but I plan keeping the API as sort of a a personal ongoing project so you can expect future versions and enhancements.  If you have any questions or ideas please let me know.  I’m really looking for some feedback on this one, so comment away.

I’ve bundled the source as well as an installer package together and posted them for download here.  Once installed the API will appear in your Visual Studio add references dialog as OUCSNET.

.NET API For Stellent / Oracle Content Server

Scriptaculous is built on Prototype which is an independent Javascript framework used by several libraries in addition to Scriptaculous. Prototype’s claim to fame is the $() function, which is used to reference html elements and is far easier to type than document.getElementById().  The framework is chock full of functionality to make your life easier and also provides an abstraction layer to the browser so Prototype handles any compatibility issues for you.

Here’s a couple of my favorite Prototype functions:

//returns all elements which have a specified css class
document.getElementsByClassName([class name]);

//attaches a function to an object event
Event.observe([object],[event name],[function]);

//converts the input fields of a form in to an Ajax compatible query string format
[Form Object].serialize();


The Scriptaculous library then has an additional set of utilities, controls and my favorite the effects.

Couple of my favorite Scriptaculous Functions:

Effect.Fade($("testdiv"))
Effect.Appear($("testdiv"))
Effect.BlindDown($("testdiv"))


All of this brings me to Stellent/Oracle who actually have a Javascript preference of their own, the Yahoo YUI library.  I am also a big fan of YUI, but it’s much more of a control library then a framework.  This has caused problems for me when working with 3rd party web designers who are not developing HTML specifically for YUI.  Scriptaculous on the other hand often works great regardless of how the HTML is designed.  Both libraries can live harmoniously on the same page and I’ve often found myself using the Prototype $() function to reference YUI controls.

Oracle/Stellent implements the YUI library using a component which places their Javascriptand CSS files in the weblayout/resources folder.  Using that same concept, I put together a quick and dirty Scriptaculous component which does the same.  In addition there’s a  resource override of the std_html_head_declarations include, where I’ve added a reference to the library, making it globally available in the Content Server UI. That component is available for download here and it includes the latest release version of Scriptaculous 1.7.0.

Updated: 11/10/2007 – The latest Oracle / Stellent Script.aculo.us component(version 1.8) may be downloaded here:

Script.aculo.us Component for Oracle / Stellent Content Server