About the Authors |
|
xvii | |
About the Technical Reviewer |
|
xix | |
Acknowledgments |
|
xxi | |
Introduction |
|
xxiii | |
|
PART 1 Basic Concepts of BizTalk Mapping |
|
|
|
|
3 | (28) |
|
Using the Development Studio |
|
|
3 | (6) |
|
|
3 | (3) |
|
The Solution Explorer Window |
|
|
6 | (1) |
|
|
6 | (2) |
|
|
8 | (1) |
|
|
8 | (1) |
|
|
9 | (21) |
|
Creating a BizTalk Project |
|
|
9 | (1) |
|
Adding a Project File Structure |
|
|
10 | (1) |
|
Creating the Input and Output Schemas |
|
|
11 | (3) |
|
Creating a New BizTalk Map File |
|
|
14 | (2) |
|
|
16 | (1) |
|
|
17 | (13) |
|
|
30 | (1) |
|
|
31 | (28) |
|
Understanding How BizTalk Maps Work |
|
|
31 | (5) |
|
|
32 | (1) |
|
Generating the Underlying Map |
|
|
33 | (3) |
|
Examining the Hidden Constructs in Maps |
|
|
36 | (4) |
|
|
36 | (2) |
|
Compiler-Generated Variables |
|
|
38 | (2) |
|
Compiler-Generated Scripts |
|
|
40 | (1) |
|
Digging into the HelloWorld Map Rules |
|
|
40 | (17) |
|
Using the Logical String Functoid Rule to Qualify a Data Extract |
|
|
42 | (4) |
|
Looking Deeper into Understanding Maps |
|
|
46 | (11) |
|
|
57 | (2) |
|
|
59 | (34) |
|
Choosing Between Scripts and Functoids |
|
|
59 | (6) |
|
Our Guidelines for Scripts vs. Functoids |
|
|
61 | (1) |
|
|
61 | (4) |
|
Selecting from Available Scripting Languages |
|
|
65 | (17) |
|
|
66 | (5) |
|
|
71 | (1) |
|
|
72 | (2) |
|
|
74 | (1) |
|
|
74 | (2) |
|
Using External Assemblies |
|
|
76 | (6) |
|
Choosing Your Scripting Language |
|
|
82 | (2) |
|
Combining Types of Scripting |
|
|
84 | (4) |
|
Examples of When You Should Use a Script |
|
|
88 | (3) |
|
|
91 | (2) |
|
|
93 | (22) |
|
|
93 | (3) |
|
Addressing Architecture Considerations |
|
|
96 | (4) |
|
Organizing Your BizTalk Applications |
|
|
97 | (1) |
|
Organizing Your BizTalk Solutions |
|
|
98 | (1) |
|
Organizing Your BizTalk Projects |
|
|
98 | (1) |
|
Separating Schemas and Maps |
|
|
99 | (1) |
|
|
100 | (3) |
|
Generating Test Data from a Schema |
|
|
100 | (1) |
|
Generating Test Data from a Flat File |
|
|
101 | (2) |
|
Generating Test Data from an EDI File |
|
|
103 | (1) |
|
Testing in the Map Editor |
|
|
103 | (7) |
|
Advantages to Testing in the Map Editor |
|
|
104 | (1) |
|
Testing Techniques for the Map Editor |
|
|
104 | (5) |
|
Testing Output Structures |
|
|
109 | (1) |
|
|
110 | (5) |
|
PART 2 Step-by-Step Mapping |
|
|
|
|
115 | (16) |
|
|
115 | (2) |
|
Blocking Output When Data Doesn't Exist |
|
|
117 | (2) |
|
Checking If a Specific Condition Exists |
|
|
119 | (2) |
|
Checking If a Specific Condition Does Not Exist |
|
|
121 | (2) |
|
|
123 | (2) |
|
Using the Logical OR for a Single Return Value |
|
|
125 | (1) |
|
|
126 | (2) |
|
|
128 | (3) |
|
|
131 | (22) |
|
|
131 | (4) |
|
Determining if a String Is a Number |
|
|
133 | (1) |
|
Using a Regular Expression to Check for a Number |
|
|
134 | (1) |
|
Testing for a Numeric Value with the XSLT Number Function |
|
|
134 | (1) |
|
Is This Number an Integer? |
|
|
135 | (2) |
|
|
137 | (2) |
|
|
139 | (2) |
|
Using the Cumulative Sum Functoid to Sum Data |
|
|
139 | (1) |
|
Using an Inline XSLT Script to Sum Data |
|
|
140 | (1) |
|
|
141 | (1) |
|
|
141 | (4) |
|
|
142 | (1) |
|
Counting Qualified Records Simply |
|
|
142 | (1) |
|
Counting Complex Qualified Records |
|
|
143 | (2) |
|
Converting Real Numbers to Integers (and Back Again) |
|
|
145 | (1) |
|
Moving the Sign to a Trailing Position |
|
|
146 | (3) |
|
Converting a Number to or from Sign-Trailing Overpunch Format |
|
|
149 | (3) |
|
|
152 | (1) |
|
|
153 | (16) |
|
|
153 | (3) |
|
Trimming Nonblank Characters from a String |
|
|
156 | (1) |
|
|
157 | (1) |
|
Selecting Substrings from String Data |
|
|
158 | (3) |
|
|
161 | (2) |
|
|
163 | (1) |
|
Removing and Replacing Characters from Strings |
|
|
164 | (3) |
|
Using the RegEx Function to Remove Garbage from a String |
|
|
167 | (1) |
|
|
167 | (2) |
|
Manipulating Dates and Times |
|
|
169 | (14) |
|
BizTalk Date and Time Functoids |
|
|
169 | (2) |
|
Altering the Format of a Date |
|
|
171 | (3) |
|
|
174 | (1) |
|
|
175 | (1) |
|
Performing Time Zone Conversions |
|
|
176 | (1) |
|
Converting Gregorian Dates to Ordinal Dates |
|
|
177 | (1) |
|
Converting Ordinal Dates to Gregorian Dates |
|
|
178 | (2) |
|
Converting Dates and Times Using the ParseExact Method |
|
|
180 | (1) |
|
Getting Dates and Times for an XSLT Script |
|
|
180 | (2) |
|
|
182 | (1) |
|
|
183 | (20) |
|
Collecting Nonlooping Data from the Source |
|
|
183 | (2) |
|
Collecting Looping Data from the Source |
|
|
185 | (4) |
|
Modifying the Target Schema for Data Collection |
|
|
189 | (1) |
|
Using Global Variables for Data Collection |
|
|
190 | (4) |
|
Accumulating an Output Counter in a Script |
|
|
190 | (2) |
|
Accumulating an Output Counter in an XSLT Script |
|
|
192 | (1) |
|
Loading a Hard-Coded Reference List |
|
|
193 | (1) |
|
Loading a Unique List from Input Data |
|
|
194 | (1) |
|
|
195 | (1) |
|
Using an Array to Control Data Selection for Output |
|
|
195 | (7) |
|
|
202 | (1) |
|
|
203 | (26) |
|
Using External Flat Files |
|
|
204 | (12) |
|
Retrieving a Single Value from a Flat File |
|
|
204 | (5) |
|
Retrieving Multiple Values from a Flat File |
|
|
209 | (4) |
|
Retrieving Values from a Flat File Using an Array |
|
|
213 | (3) |
|
Using the BizTalk Database Functoids with External Data |
|
|
216 | (5) |
|
Retrieving a Single Value Using Database Functoids |
|
|
217 | (3) |
|
Retrieving Multiple Values Using Multiple Value Extractor Functoids |
|
|
220 | (1) |
|
Locating External Files with Path Names and Connect Strings |
|
|
221 | (4) |
|
|
221 | (1) |
|
Using System Environment Variables |
|
|
222 | (2) |
|
Using the Machine Configuration File |
|
|
224 | (1) |
|
Using an Application Configuration File |
|
|
225 | (1) |
|
BizTalk Cross-Reference Tables |
|
|
225 | (1) |
|
|
225 | (4) |
|
|
|
Using Basic Looping Controls |
|
|
229 | (30) |
|
|
229 | (2) |
|
Understanding BizTalk Mapping Engine's Basic Looping Concepts |
|
|
231 | (8) |
|
|
234 | (2) |
|
Adding Compiler-Generated Links |
|
|
236 | (3) |
|
Limiting the Output of a Loop |
|
|
239 | (3) |
|
Forcing Looping in the Output |
|
|
242 | (2) |
|
Simultaneously Forcing and Limiting a Loop |
|
|
244 | (3) |
|
|
247 | (2) |
|
|
249 | (1) |
|
|
250 | (4) |
|
|
254 | (3) |
|
|
257 | (2) |
|
Handling Advanced Looping |
|
|
259 | (18) |
|
Many-to-One Looping with a Source Child Loop |
|
|
259 | (7) |
|
One-to-Many Looping with a Child Target Loop |
|
|
266 | (7) |
|
|
273 | (4) |
|
PART 4 EDI Mapping with BizTalk |
|
|
|
Introducing Electronic Data Interchange (EDI) |
|
|
277 | (24) |
|
EDI Standards-Based Transactions |
|
|
278 | (1) |
|
|
279 | (1) |
|
|
279 | (1) |
|
|
280 | (1) |
|
Using the Basic Building Blocks of EDI Messages |
|
|
280 | (11) |
|
Examining a Simple X12 Data Element |
|
|
281 | (1) |
|
Using Simple EDIFACT Data Elements |
|
|
282 | (1) |
|
Using Composite X12 Elements |
|
|
283 | (1) |
|
Using Composite EDIFACT Elements |
|
|
284 | (1) |
|
|
284 | (2) |
|
Creating EDIFACT Segments |
|
|
286 | (1) |
|
Exploring X12 Segment Syntax Rules and Mapping |
|
|
286 | (1) |
|
Understanding X12 Transactions |
|
|
287 | (3) |
|
Understanding EDIFACT Transactions |
|
|
290 | (1) |
|
Exploring X12 Interchanges |
|
|
291 | (4) |
|
|
291 | (1) |
|
|
292 | (1) |
|
|
293 | (2) |
|
Exploring EDIFACT Interchanges |
|
|
295 | (4) |
|
|
296 | (1) |
|
|
297 | (1) |
|
|
298 | (1) |
|
Illustrating the Differences Between X12 and EDIFACT |
|
|
299 | (1) |
|
|
300 | (1) |
|
|
301 | (16) |
|
Looping from EDI to an Application |
|
|
301 | (9) |
|
Exploring the X12-to-Application Solution |
|
|
305 | (4) |
|
Exploring the EDIFACT-to-Application Solution |
|
|
309 | (1) |
|
Looping from an Application to EDI |
|
|
310 | (6) |
|
|
316 | (1) |
|
Processing EDI Code Pairs |
|
|
317 | (18) |
|
Introducing EDI Code Pairs |
|
|
317 | (1) |
|
Handling ID Codes in X12 REF and EDIFACT RFF Segments |
|
|
318 | (4) |
|
Looking for Specific Code Pairs in an X12-to-Application Map |
|
|
318 | (2) |
|
Looking for Specific Code Pairs in an EDIFACT-to-Application Map |
|
|
320 | (1) |
|
Using a Script to Select Specific Code Pairs from One REF or RFF Loop |
|
|
321 | (1) |
|
Using a Recursive XSLT Call Template to Process Code Pairs |
|
|
322 | (2) |
|
Using Nested XSLT Call Templates to Process Code Pairs |
|
|
324 | (3) |
|
Multiple Code Pair Positions in a Single Segment |
|
|
327 | (3) |
|
Handling Multiple Code Pairs in an Inbound Segment with C# |
|
|
328 | (2) |
|
Handling Multiple Code Pairs in an Inbound Segment with XSLT |
|
|
330 | (1) |
|
Creating Code Pairs in EDI Output |
|
|
330 | (3) |
|
|
333 | (2) |
|
Unraveling the SDQ Segment |
|
|
335 | (24) |
|
Exploring the SDQ Segment |
|
|
335 | (1) |
|
|
336 | (12) |
|
|
337 | (1) |
|
Sorting and Storing the Data into Hash Tables |
|
|
338 | (3) |
|
Retrieving the Locations for Output |
|
|
341 | (2) |
|
|
343 | (2) |
|
Adding the Item Numbers and Quantity Information to the Output |
|
|
345 | (2) |
|
Considering the Decisions in This Map |
|
|
347 | (1) |
|
Mapping Outbound SDQ Data |
|
|
348 | (10) |
|
Collecting the Item and Quantity Information |
|
|
348 | (2) |
|
Retrieving Item Numbers from the Hash Table |
|
|
350 | (1) |
|
Building the LIN and ZA Loops |
|
|
351 | (4) |
|
Adding the SDQ Node to the ZALoop1 Nodes |
|
|
355 | (3) |
|
|
358 | (1) |
|
Taming the Dreaded 856 ASN HL Loop |
|
|
359 | (34) |
|
|
359 | (4) |
|
Planning to Map the HL Loop |
|
|
363 | (1) |
|
|
363 | (7) |
|
Mapping an Outbound 856 ASN |
|
|
370 | (11) |
|
Building the ASN with an XSLT Script |
|
|
378 | (3) |
|
Creating the Simple Outbound 856 ASN |
|
|
381 | (9) |
|
|
390 | (3) |
|
PART 5 Advanced Techniques |
|
|
|
Building Custom Assemblies and Functoids |
|
|
393 | (20) |
|
Deciding to Use a Custom Assembly or Custom Functoid |
|
|
393 | (1) |
|
Creating an External Assembly for Date Conversion Functions |
|
|
394 | (2) |
|
Building a Custom Functoid |
|
|
396 | (12) |
|
Establishing a Common Terminology |
|
|
397 | (1) |
|
|
397 | (1) |
|
Building the Functoid Worksheet |
|
|
398 | (1) |
|
Creating the Class Library Project |
|
|
399 | (1) |
|
Creating a Strong-Named Key File |
|
|
399 | (1) |
|
Setting Up the Application Values |
|
|
400 | (1) |
|
Setting Up the Functoid Resource File |
|
|
401 | (1) |
|
Adding the Bitmap for the Functoid Icon |
|
|
402 | (1) |
|
Adding Resources to the Project |
|
|
403 | (1) |
|
Adding Code to the Class Library Object |
|
|
403 | (3) |
|
Building and Deploying the Class Library Object |
|
|
406 | (1) |
|
Adding the Functoid to the Toolbar |
|
|
406 | (1) |
|
|
407 | (1) |
|
|
408 | (1) |
|
Doing a Custom Database Lookup |
|
|
408 | (4) |
|
|
412 | (1) |
|
|
413 | (28) |
|
Modifying Outbound EDI Envelope Data |
|
|
413 | (4) |
|
Creating the Custom Pipeline Component |
|
|
414 | (3) |
|
Building BizTalk Maps Outside the Map Editor |
|
|
417 | (6) |
|
Deciding to Use an XSLT File As Your Map |
|
|
417 | (1) |
|
Creating an External XSLT Map |
|
|
418 | (2) |
|
Implementing the External XSLT File As a Map |
|
|
420 | (1) |
|
Accessing C# Scripts in a Stand-Alone XSLT Map |
|
|
421 | (1) |
|
Calling Other XSLT Templates From a Stand-Alone XSLT Map |
|
|
422 | (1) |
|
Building Dynamic Tag Names in Your XML Output |
|
|
422 | (1) |
|
Breaking Up Large Strings Using Table Looping |
|
|
423 | (16) |
|
Reformatting Source Files for Easier Mapping |
|
|
428 | (5) |
|
Testing C# and VB Scripts |
|
|
433 | (1) |
|
Setting Up a Test Project |
|
|
433 | (2) |
|
|
435 | (1) |
|
Using a Console Window to View the Function's Returned Value |
|
|
436 | (1) |
|
Using Function Calls to View the Function's Returned Value |
|
|
436 | (1) |
|
Running and Continuing the Debugger |
|
|
437 | (1) |
|
|
437 | (1) |
|
Viewing Data in the Debugger |
|
|
438 | (1) |
|
|
439 | (2) |
Index |
|
441 | |