Simon Chadwick Consulting - RosettaNet Solutions 

Implementing a RosettaNet system using the BizTalk Accelerator for RosettaNet.

This section describes the tasks and issues involved when implementing a system using the BizTalk Accelerator for RosettaNet. After working extensively with both the Accelerator and with the RosettaNet standard, I have learned a great deal about the complexity of each, and also many related nuances, techniques, tips, traps, etc. The suite of RosettaNet PIP specifications can be daunting, and each can take some time to study and comprehend. Fortunately most trading partners concentrate on the same core set of RosettaNet PIPs, that includes invoices (3C3), purchase orders (3A4), etc.

As its (cumbersome) name implies, the BizTalk Accelerator for RosettaNet speeds up the process of implementing a RosettaNet solution using BizTalk. It contains a set of RosettaNet document specifications, some basic PIP orchestration schedules, some utility components, a few simple management and configuration tools, and fairly good documentation. As such, it is not really an extension to BizTalk, but rather an engineering toolkit for enabling BizTalk to implement a set of RosettaNet PIPs.

Here are some of my general recommendations for implementing a RosettaNet solution using the BizTalk Accelerator:

1. A new RosettaNet implementation usually takes at least three months. The first two months are dedicated to  planning, ordering, and installing hardware and software, followed by configuring and customizing the Accelerator. 
   The last month is usually dedicated to PIP and partner integration testing.
2. Before you engage in a RosettaNet implementation,
   • understand your business model, and
   • understand the scope of the project.
3. Know BizTalk very well before working with the Accelerator for RosettaNet. Trying to learn BizTalk while working with the Accelerator will definitely lead to significant implementation problems and delays.
4. Start with a pilot implementation, supporting just one or two PIPs. I suggest the commonly used 3C3 (Invoice) and 3C4 (Invoice Rejection) PIPs, as these exercise the local organization as both a PIP initiator and a PIP responder.
5. Decouple the back-end ERP or order processing system as much as possible at first. This integration can be a major task in itself, and it is better to focus on just the RosettaNet implementation first. Initially a simple CSV-file exchange system will usually suffice, and this makes repeated testing of PIPs mush easier.
6. Use BizTalk file receive functions to initiate PIPs, at least initially. These also make developing and testing easier, especially when CSV files are used.
7. Plan for throughput and performance. Prepare for peak loads caused by trading partner batches.
8. Logging and auditing are vital. Use BizTalk document tracking at a minimum. Even better, custom inbound and outbound document logging can be much more useful.
9. Email notifications work well; plan to use these for failure alerts and warnings, in addition to such confirmations as new purchase order received, and successful invoice transmission. During development, attach the corresponding RosettaNet document XML files

Here is an outline of specific implementation steps that have worked well for me:

1. Arrange a PIP implementation and testing plan with the primary (or first) trading partner. If there is to be more than one trading partner, then designate one as the primary partner, and build out the RosettaNet system targeting just that one partner. When the system is operational, other trading partners can be added.
2. Receive and study specifications from the trading partner that describe the exact interpretation of each PIP document, and the semantics and valid values of pertinent fields of each PIP document. Also determine the exact version of each RosettaNet PIP supported by the trading partner.
3. Install the primary trading partner's digital certificates for processing both test and production RosettaNet documents. Obtain corresponding certificates for your organization, and supply these to the trading partner.
4. Install the following on development, test, and production servers: SQL Server 2000, Microsoft Visio, BizTalk Server 2000 or 2002, the Accelerator for BizTalk, and all service packs for these.
5. Assemble all the DTDs (XML schemas) of the versions of the RosettaNet PIPs supported by the trading partner. Place these files in a folder, and use the Accelerator's PIP Schema Manager to convert each into a consolidated RosettaNet message, and then merge these messages into a BizTalk Messaging RosettaNet Universal Message.
6. Start planning the overall RosettaNet system architecture now. Create an initial diagram of the system; this will be an extremely useful reference as the system is built out and extended.
   Click on the thumbnail below to see an example of a complete architecture diagram:
   
   
7. Use the Accelerator's Messaging Configuration Wizard to do the initial configuration of the BizTalk channels and ports for the trading partner. Ensure that then channels refer to the Universal message document definition created above.
8. Set up an IIS virtual directory for hosting the ASP file that receives RosettaNet documents from the trading partner. This virtual directory must only respond to HTTPS requests, and so a valid digital certificate must be installed on the IIS server. Configure the ASP file to submit incoming RosettaNet documents to the appropriate BizTalk channel.
9. Use the Accelerator's PIP Administrator to bind the supported RosettaNet PIPs to the corresponding BizTalk XLANG schedules. Initially these schedules will be copies of the basic template ones supplied with the Accelerator; eventually these will be modified to implement the specific business requirements of the local organization.
10. Engineer initial versions of the initiator and responder adapters, using the samples provided with the Accelerator as starting points. Initially target a basic PIP, such as the 3C3 invoice notification. Hook these adapters into the corresponding XLANG schedules.
11. Use the Accelerator's PIP XLANG Schedule Tester to start exercising one or two of the simpler PIPs, such as the 3C3 invoice and the 0A1 failure notification. After this, test these PIPs with sample documents sent to the test system of the trading partner.
12. Build out the initiator and responder adapters to handle the remaining supported PIPs. A lot of work here will involve integrating with the back-end order processing system.
13. Test all the PIPs extensively with sample RosettaNet documents. Locally initiated PIPs, such as the 3C3 invoice, can be sent on demand to the test system at the trading partner. To test PIPs initiated by the remote partner, I have found it far easier to transmit the initiating documents from another local machine configure for this purpose. This mechanism avoids repeated phone calls (or instant messages) to the trading partner staff requesting that they initiate new test PIP scenario.

This is just a general outline of what it takes to get a production RosettaNet implementation running. Every situation will differ somewhat based on your requirements.

Click here to see information about my RosettaNet consulting services.
Please see the main page for my contact and résumé information.