06.26.08
Posted in Maximo at 8:52 pm by Mike
One of the features of the MEA is its ability to create a web service based on an integration interface. This is all done without having to write one line of code. You can create two different types of web services, Notify and Query/Response. A Notify web service is used for updating data. It is on inbound interface only. The web service will only return a “pass/fail” message. no data will be returned (like the ID it created for it). The other type, Query/Response is used for asking for data from Maximo. This will return one or more records of data, depending on what you ask for. Let’s have a look at creating a Notify web service.
The first step is to make sure that you have the MEA configured properly. Now you create your Integration Object with and inbound Integration Point of type Notify.
Next you create the Integration Interface. Since Maximo creates the Web Service for you, you cannot add any custom processing to it. However, you can effectively accomplish this by adding inbound processing rules to the interface. After you save the Interface, but are still on the screen, select “Deploy as Web service” from the Select Action menu.
In this example I am deploying the MXItemInterface.
The last thing you must do is add the interface to an enabled external system as an inbound interface. Also make sure the interface in enabled on the External System.
Congratulations, you have deployed a web service. Here are the stats:
URL: http://servername:portnumber/meaweb/services/interfacename
Service name: interfacename
WSDL: http://servername:portnumber/meaweb/services/interfacename?WSDL
XSD: http://servername:portnumber/meaweb/services/interfacename.xsd
So in using Weblogic server and the MXITEMInterface interface, my values would look like this:
URL: http://mydomain.com:7001/meaweb/services/MXITEMInterface
Service name: MXITEMInterface
WSDL: http://mydomain.com:7001/meaweb/services/MXITEMInterface?WSDL
XSD: http://mydomain.com:7001/meaweb/services/MXITEMInterface.xsd
To test it, you can use the INTCLIENT.bat tool. You will need to either create an xml file in the correct format (see integration interfaces on how to get the structure) or you can just export a record from the integration object to XML and then us it. Be sure to switch the sender and recipient IDs. Start up the INTCLIENT tool.
In the Client Type pull down, select SOAPDOC. Make sure the endpoint URL is correct as well as the service name. Click the BROWSE button and select your XML file you have ready. Now click test. The big text area will display the return message from the web service (including any errors).
Should an error occur, you would see the error message instead of "Success". The message will contain why Maximo rejected the message (invalid value, invalid date, etc).
On thing of note. If you do not change the Integration Web Application URL, then the WSDL will have issues. Web services uses this value when generating the WSDL and the XSD. If you do change it, then you will need to re-deploy any web service that you have already deployed.
This is standard web service and can be consumed by any language that can consume a web service.
Note for Java programmers. You can find the org.apache.soap library in %maximohome%/tools/maximo/soap.zip. You can also find the JAXRPC.jar file in the %maximohome%/applications/maximo/lib folder.
Permalink
06.22.08
Posted in Maximo at 2:02 am by Mike
One thing you might find is that when you have a MEA record error, the JMS server keeps trying to reprocess the record over and over. This causes the server to slow down and fill up the drive space with log files. The reason for this is that the default setting is for the server to retry every message in the queue unlimited number of times and every second. I really don’t understand the logic of having a system retry a message that was in error, over and over again, without some user intervention first. However, this is easy to fix. These instructions are for Weblogic (I don’t have an instance of Websphere available to me so figure out how to fix it there).
Open the console for the Websphere and navigate to MyDomain->Services->JMS->Servers->[queue name]->Destinations->[destination name]
Now click on the "redelivery" tab. The second text box, Redelivery Limit, is defaulted to -1. This means that the server will try infinitely to process the error. I am not sure what would be a good value for a production system (mainly because I can’t think of a situation where you would want the system to keep retrying records that are in error). For a development box, I recommend setting it to a value of 1. I also recommend doing this for all the queues.
Permalink
Posted in Maximo at 1:59 am by Mike
When the MEA processes a record and it has an error, the MEA do three things. The first is that it writes the error message to the server log file. Next it sends the error to the administrators email address. The last thing is that it write an XML file to the MEA Global’s folder.
Lets have a look at these folders. The Error handling uses the Delete, DeletedHistory, Error and retry folders. Each of these directories will have a sub folder directory. The first level is the queue name. Under that will be a folder for each External System. When an error happens, it writes a message to the error folder. From here you can look at the message. Event though the message is written to this folder, it is still in the JMS queue. Deleting he message from this folder will NOT remove it from the queue. If you fix the error, you can move the message to the retry folder. If however you just want to delete the message from the processing queue, move the message to the delete folder. And messages that gets deleted will be copied to the DeletedHistory folder.
The load folder is used as the default for folder for loading flat file and XML files. Under this folder is a folder called "XML". This is where to put your XML or flat files to load. The other folder is called "backup" and the MEA makes backup copies of loaded files here.
The next folder is called "schema". When the MEA generates an XML schema, it writes it to this folder.
The last folder I am going to talk about is the XMLFiles folder. This is where applications like the INTCLIENT and VIEWQUEUE write their XML files too.
Permalink
06.20.08
Posted in Maximo at 12:42 am by Mike
Let’s take a minute to look a the XML message format. When dealing with the MEA you will end up dealing with messages in XML format. Even when you import flat files and interface tables, Maximo converts each record to the XML format.
There are three different XML message formats, Integration Object, Integration Interface and Error Message. In reality, each builds on the prior message. Let’s start with the Integration Object.
Integration Object
This is where the actual data is formatted. In this example, we’ll look at MXItem Integration object.
1: <?xml version=”1.0″ encoding=”UTF-8″?>
2: <MXITEM xmlns=”http://www.mro.com/mx/integration”>
3: <ITEM>
4: <ITEMNUM />
5: <DESCRIPTION />
6: <ROTATING />
7: <LOTTYPE />
8: <CAPITALIZED />
9: <MSDSNUM />
10: <OUTSIDE />
11: <IN19 />
12: <IN20 />
13: <IN21 />
14: <IN22 />
15: <IN23 />
16: <SPAREPARTAUTOADD />
17: <INSPECTIONREQUIRED />
18: <SOURCESYSID />
19: <OWNERSYSID />
20: <EXTERNALREFID />
21: <IN24 />
22: <IN25 />
23: <IN26 />
24: <IN27 />
25: <SENDERSYSID />
26: <ITEMSETID />
27: <ORDERUNIT />
28: <ISSUEUNIT />
29: <DESCRIPTION_LONGDESCRIPTION />
30: <CONDITIONENABLED />
31: <GROUPNAME />
32: <METERNAME />
33: <COMMODITYGROUP />
34: <COMMODITY />
35: <ITEMTYPE />
36: <PRORATE />
37: <ITEMID />
38: <ISKIT />
39: <ATTACHONISSUE />
40: <TRANS_LANGCODE />
41: <CONVERSION>
42: <CONVERSIONID />
43: <FROMMEASUREUNIT />
44: <TOMEASUREUNIT />
45: <CONVERSION />
46: <CHANGEBY />
47: <CHANGEDATE />
48: </CONVERSION>
49: <ITEMCONDITION>
50: <CONDITIONCODE />
51: <DESCRIPTION />
52: <STOCKTYPE />
53: <CONDRATE />
54: <DESCRIPTION_LONGDESCRIPTION />
55: <COMMODITYGROUP />
56: <COMMODITY />
57: <ITEMCONDITIONID />
58: </ITEMCONDITION>
59: </ITEM>
60: </MXITEM>
The base tag (lines 2 and 60) are the name of the integration object. Next comes the main object (lines 3 and 59). Each attribute (field) in the MBO is a separate tag where the tag name is the attribute name. Remember that an Integration Object and consist of more than one MBO. In this example, Conversion and ItemCondition MBO are related MBOs. In the XML, you can see that Conversion (lines 41 thru 48) and ItemCondition (lines 49 thru 58) are where this data goes. Since the relationship between Item and these two MBOs is a Zero to Many, each of these sections will be repeated for each child record.
Integration Interface
An Integration Interface XML message wraps a few tags around the Integration Object XML message.
1: <?xml version=”1.0″ encoding=”UTF-8″?>
2: <MXITEMInterface xmlns=”http://www.mro.com/mx/integration” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” language=”EN”>
3: <Header operation=”Notify” event=”0″>
4: <RecipientID>EXTSYS1</RecipientID>
5: <SenderID type=”MAXIMO” majorversion=”6″ minorversion=”2″ build=”142″ dbbuild=”V600-502″>MX</SenderID>
6: <CreationDateTime>2008-06-19T14:32:47-06:00</CreationDateTime>
7: </Header>
8: <Content>
9: <MXITEM>
10: <ITEM>
11: <ITEMNUM />
12: <DESCRIPTION />
13: <ROTATING />
14: <LOTTYPE />
15: <CAPITALIZED />
16: <MSDSNUM />
17: <OUTSIDE />
18: <IN19 />
19: <IN20 />
20: <IN21 />
21: <IN22 />
22: <IN23 />
23: <SPAREPARTAUTOADD />
24: <INSPECTIONREQUIRED />
25: <SOURCESYSID />
26: <OWNERSYSID />
27: <EXTERNALREFID />
28: <IN24 />
29: <IN25 />
30: <IN26 />
31: <IN27 />
32: <SENDERSYSID />
33: <ITEMSETID />
34: <ORDERUNIT />
35: <ISSUEUNIT />
36: <DESCRIPTION_LONGDESCRIPTION />
37: <CONDITIONENABLED />
38: <GROUPNAME />
39: <METERNAME />
40: <COMMODITYGROUP />
41: <COMMODITY />
42: <ITEMTYPE />
43: <PRORATE />
44: <ITEMID />
45: <ISKIT />
46: <ATTACHONISSUE />
47: <TRANS_LANGCODE />
48: <CONVERSION>
49: <CONVERSIONID />
50: <FROMMEASUREUNIT />
51: <TOMEASUREUNIT />
52: <CONVERSION />
53: <CHANGEBY />
54: <CHANGEDATE />
55: </CONVERSION>
56: <ITEMCONDITION>
57: <CONDITIONCODE />
58: <DESCRIPTION />
59: <STOCKTYPE />
60: <CONDRATE />
61: <DESCRIPTION_LONGDESCRIPTION />
62: <COMMODITYGROUP />
63: <COMMODITY />
64: <ITEMCONDITIONID />
65: </ITEMCONDITION>
66: </ITEM>
67: </MXITEM>
68: </Content>
69: </MXITEMInterface>
The first thing to notice is the from line 8 thru line 67 is the Integration Object XML Message. Now the base tag is the name of the interface. The MEA uses this to route the message to the proper interface for processing. This message is now divided into two sections. A header (lines 3 thru 7) and the content (lines 8 thru 68). In this case, the content is just the Integration Object XML Message. The really important thing here is in the Header section. Line 3, the Header tag has one very important attribute: OPERATION. This tells Maximo or you what to do with the information in the message. For messages going into Maximo this will either be “Notify” (telling Maximo to update or sync the data) or “Query” (used to query Maximo data). For messages going out of Maximo this will be either “Notify” (telling the other system to sync or update the data) or “Response” (which is the results from the Query).
The next two lines (4 and 5) are very import to Maximo. The RecipientID is the name of the system that is receiving the message. For inbound messages, then needs to be “MX” (or whatever you have your MXSYSID setup as). For outbound, this will be the name of the External System the interface is attached to. The SenderID is the name of the system that is sending the message. For inbound, this MUST be the name of the External System the Interface is enabled on. For Outbound, this will be “MX” (or whatever you have your MXSYSID setup as). For a developer, the key to these two tags is that if you export a record, change it and want to send it back into Maximo to test your interface, then you just have to switch the values of these two tags.
The CreationDate tag (line 6) is optional.
Error Message
The last XML message is the format of the Error message that the MEA will generate. You will get one of these messages for each record that is in error.
1: <?xml version=”1.0″ encoding=”UTF-8″?>
2: <ERROR>
3: <ERRORMESSAGE>Error occurred while processing ITEM ( IR number 1, Integration Object number 1 ). Error is: Not a valid Yes or No value.</ERRORMESSAGE>
4: <ER>
5: <MXITEMInterface xmlns=”http://www.mro.com/mx/integration” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” language=”EN”>
6: <Header operation=”Notify” event=”0″>
7: <SenderID>EXTSYS1</SenderID>
8: <RecipientID>MX</RecipientID>
9:
10: </Header>
11: <Content>
12: <MXITEM>
13: <ITEM>
14: <ITEMNUM>6I-2500</ITEMNUM>
15: <DESCRIPTION langenabled=”1″>AIR FILTER -SECONDARY2</DESCRIPTION>
16: <ROTATING>0</ROTATING>
17: <LOTTYPE maxvalue=”NOLOT”>NOLOT</LOTTYPE>
18: <CAPITALIZED>2</CAPITALIZED>
19: <MSDSNUM />
20: <OUTSIDE>0</OUTSIDE>
21: <IN19 />
22: <IN20 />
23: <IN21 />
24: <IN22 xsi:nil=”true” />
25: <IN23 xsi:nil=”true” />
26: <SPAREPARTAUTOADD>1</SPAREPARTAUTOADD>
27: <INSPECTIONREQUIRED>0</INSPECTIONREQUIRED>
28: <SOURCESYSID />
29: <OWNERSYSID />
30: <EXTERNALREFID />
31: <IN24 />
32: <IN25 />
33: <IN26 />
34: <IN27 />
35: <SENDERSYSID>MX</SENDERSYSID>
36: <ITEMSETID>SET1</ITEMSETID>
37: <ORDERUNIT />
38: <ISSUEUNIT />
39: <DESCRIPTION_LONGDESCRIPTION langenabled=”1″ />
40: <CONDITIONENABLED>0</CONDITIONENABLED>
41: <GROUPNAME />
42: <METERNAME />
43: <COMMODITYGROUP>FILTERS</COMMODITYGROUP>
44: <COMMODITY />
45: <ITEMTYPE>ITEM</ITEMTYPE>
46: <PRORATE>0</PRORATE>
47: <ITEMID>228</ITEMID>
48: <ISKIT>0</ISKIT>
49: <ATTACHONISSUE>0</ATTACHONISSUE>
50: <TRANS_LANGCODE>EN</TRANS_LANGCODE>
51:
52: </ITEM>
53:
54: </MXITEM>
55:
56: </Content>
57:
58: </MXITEMInterface>
59: </ER>
60: <IR>
61: <MXITEMIN xmlns=”http://www.mro.com/mx/integration” xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” language=”EN”>
62: <Header operation=”Notify” event=”0″>
63: <SenderID>EXTSYS1</SenderID>
64: <RecipientID>MX</RecipientID>
65:
66: </Header>
67: <Content>
68: <MXITEM>
69: <ITEM>
70: <ITEMNUM>6I-2500</ITEMNUM>
71: <DESCRIPTION langenabled=”1″>AIR FILTER -SECONDARY2</DESCRIPTION>
72: <ROTATING>0</ROTATING>
73: <LOTTYPE maxvalue=”NOLOT”>NOLOT</LOTTYPE>
74: <CAPITALIZED>2</CAPITALIZED>
75: <MSDSNUM />
76: <OUTSIDE>0</OUTSIDE>
77: <IN19 />
78: <IN20 />
79: <IN21 />
80: <IN22 xsi:nil=”true” />
81: <IN23 xsi:nil=”true” />
82: <SPAREPARTAUTOADD>1</SPAREPARTAUTOADD>
83: <INSPECTIONREQUIRED>0</INSPECTIONREQUIRED>
84: <SOURCESYSID />
85: <OWNERSYSID />
86: <EXTERNALREFID />
87: <IN24 />
88: <IN25 />
89: <IN26 />
90: <IN27 />
91: <SENDERSYSID>MX</SENDERSYSID>
92: <ITEMSETID>SET1</ITEMSETID>
93: <ORDERUNIT />
94: <ISSUEUNIT />
95: <DESCRIPTION_LONGDESCRIPTION langenabled=”1″ />
96: <CONDITIONENABLED>0</CONDITIONENABLED>
97: <GROUPNAME />
98: <METERNAME />
99: <COMMODITYGROUP>FILTERS</COMMODITYGROUP>
100: <COMMODITY />
101: <ITEMTYPE>ITEM</ITEMTYPE>
102: <PRORATE>0</PRORATE>
103: <ITEMID>228</ITEMID>
104: <ISKIT>0</ISKIT>
105: <ATTACHONISSUE>0</ATTACHONISSUE>
106: <TRANS_LANGCODE>EN</TRANS_LANGCODE>
107:
108: </ITEM>
109:
110: </MXITEM>
111:
112: </Content>
113:
114: </MXITEMIN>
115: </IR>
116: </ERROR>
117:
The base tag is an ERROR tag. Line 3 is the error message that was generated. If you look close you will see that the Interface message in here twice in the message. The first is from line 6 thru line 58 and is encased by an ER tag while the second from line 1 thru 114 is encased in an IR tag. Basically, the IR section is the original incoming message (record) while the ER section is the message that cause the error. In this example they are the same, but if you have any processing rules or custom exit class that changes the data, then this will be what the data looked like after those changes were made.
Permalink
06.18.08
Posted in Humor at 5:47 pm by Mike
I found this posted at :http://geekswithblogs.net/KirstinJ/archive/2008/06/17/you-may-be-a-geek-if.aspx but liked it so much I just had to re-post it here. Full credit belongs to “I [heart] TFS” blog for the list. BTW: I found the Google one more scary than funny…
- You know that Fibonacci is not a fine wine or type of bread.
- Your Christmas list is a color-coded spreadsheet with sort capabilities on person, store, and price.
- The last party you attended was a slide deck check.
- Your MP3 player contains more .NET podcasts than music.
- The average shelf life of the books you purchase is 3 months.
- You have more email addresses than you have digits in your phone number.
- That’s ok, because you have linked them all together with single sign-on from your smart phone.
- You think that Facebook and MySpace are so-o-o 2007.
- You know more people by their twitter handle than by their real names.
- You can’t multitask worth @%&@ in the real world, but you can handle a debugging session, a SQL window, three IM windows, and a twitter client simultaneously.
- If Google went down, your productivity would plummet.
- When you hear the acronym “MVP” you don’t think “Most Valuable Player”.
- When you hear “waterfall”, you don’t think of Niagara, and you need to restrain yourself from running away screaming.
- When your boss asks you “When was the last time you worked with COM?”, he doesn’t mean communications, and you do run away screaming.
- A night of drinking involves everyone consulting their GPS before proceeding to the next venue.
- A night of drinking ends up at the office where everyone can fire up their laptops and swap MP3 files.
- When you’re feeling old, you give your age in base-11.
- You divide the world into 10 types of people - the ones that understand binary, and the ones that don’t.
- You laughed at at least half the items on this list.
Permalink
06.15.08
Posted in Uncategorized at 4:54 am by Mike
Please welcome a new blogger to KISS Programming. Jennifer Schwartz is an IT professional who has done it all from programming to managing very large project. I look forward to her insights and perspective on the world of IT.
Permalink
06.12.08
Posted in Maximo at 9:23 pm by Mike
Let’s look at the External Systems screen. External system is a way to group together interfaces that 1) go to the same external application and 2) have the same end point (more on this later) and 3) will be run on the same schedule. Every Integration Interface MUST be assigned to an external system.
Main Tab
Let’s have a look at the screen.
Let’s have a look at the fields
System: This is the name of the external application. For Outbound interfaces, unless the external application cares (Maximo is an example that cares), then this can be just about anything. For Inbound, the external application needs to put this value in the SendSysID field or Maximo will reject the message.
Description: this is a friendly description of the External System.
Adapter: This is the name of the adapter to use. By default, the only adapter that exists is Maximo and it should work just fine. You can create your own Adapter, but you need to do a bit of programming for it. To deploy a web service, this MUST be Maximo.
End Point: This is name of the end point to use. And end point is where the message is going to/coming from. By default, Maximo has 3 preset End Points: MXXMLFILE, MXFLATFILE, and MXIFACTTABLE. However, Maximo does come with handlers for other end points and it is pretty easy to add other End Points.
Enabled?: This flag allows you to turn on and off the all the interfaces attached at once.
Outbound Sequential Queue: This is the name of the queue to use for Outbound Sequential records. In a base MEA installation, there is only one option presented on the lookup screen.
Inbound Sequential Queue: This is the name of the queue to use for Inbound Sequential records. In a base MEA installation, there is only one option presented on the lookup screen.
Inbound Continuous Queue: This is the name of the queue to use for Inbound Continuous records. In a base MEA installation, there is only one option presented on the lookup screen.
The bottom part of the screen will be for any extra fields you can fill out based on the End Point chosen.
Outbound Interface Tab
The next tab is the Outbound Interfaces tab:
This tab is where you added all Outbound Interface for the External System. Click the “new row” button to add an Interface.
Interface: This is the name of the Outbound Interface. The lookup will only present a list of outbound interfaces.
Description: This is autofilled from the Interface
Enabled?: This flag turns on/off the individual interface.
You can also press the “Data Export” button to send data out on the End Point.
This allows you to send all or some of the data in the table. You start by first selecting the Interface you want to export and then click “Data export”.
Interface: this is filled in by Maximo, based on the currently selected Interface on the Outbound interface screen.
Integration Point: This is the integration point you want to use.
Export Condition: This is the where clause (without the word ‘where’) that you want to use to restrict the records exports. If you leave this blank, then you will get every record in the Integration Object.
Inbound Tab
The next tab is the Inbound Interfaces tab:
This tab is where you added all Inbound Interface for the External System. Click the “new row” button to add an Interface.
Interface: This is the name of the Outbound Interface. The lookup will only present a list of outbound interfaces.
Description: This is auto-filled from the Interface
Enabled?: This flag turns on/off the individual interface.
Use Continuous Queue: this flag denotes if Maximo should use the Continuous or Sequential queue for the interface.
Interface Controls
The last tab is the Interface Controls tab:
There are four different types of controls you can setup: Value, Boolean, List and Crossover.
The “Select Action” menu has many other options for this screen. Let’s look at those.
Add/Modify Handlers
A handler is the actual point that data will either come in or go out on. An End Point is really a handler with parameter fields filled in (like directory name, userID/password, etc.). Although Maximo comes with only three End points pre-built, it does come with many more handlers for you to use. This screen would be for adding your own handler or modifying and existing.
Handler: This is a unique name for the handler.
Handler Class Name: this is the name of the java class for the handler.
User Defined?: This flag is automatically filled in by Maximo. Basically, you created (clicked the “new row” button) or modified and existing handler, then this will be checked.
Add/Modify Queues
This screen is where you add or modify queues that will be available to the MEA. When you installed the MEA, it creates 3 queue that will be listed. To add a new queue you will 1) open the console on the application server and create the queue. 2) open this screen and add it here.
Queue JNDI Name: This is the name of the JNDI Queue.
Queue Connection Factory: This is the name of the Connection Factory.
Initial Context Factory: This is the name of the context factory. This field is optional.
Provider URL: This is the URL for accessing the JMS Server. Blank assume current Maximo application server.
User ID/Password: these two fields are used for accessing the JMS Server, if security is enabled.
Email Address: Maximo will send an email to this address if an error occurs in the queue. If blank, then it will send an email to the Administrator email address as set in the Maximo.Properties file.
Sequential?: This flag denotes if the queue is Sequential or Continuous.
Inbound?: This flag denotes if the queue is for Inbound or Outbound.
User Defined?: this flag is set by Maximo and denotes if a user created or modified the queue.
Maximum Try Count: The number of time Maximo will try to process a message before it puts the error in the error log and sends an email. The value cannot be less than 0.
Enable/Disable Integration Events
Some Outbound Integration Points are Event Enabled. If you are trying to use an Event enabled outbound integration point, then you have to go into this screen and enable that event. Basically, you just find the event you want and check the “Event Enabled?” box.
Integration Administration Setup
This screen has some setup values for the MEA in general.
Maximo user name for inbound processing: This is the user ID that will be attached to all inbound records.
Global Directory Location: This is the locatoin on the server where the MEA Global directory should bee. See More on Maximo MEA Setup for more information on this.
Update SENDERSYSID on Data Export?: This flag denotes if Maximo should add its ID to the SenderSysId in the exported records. This only affects data that has been exported using the “data export” button.
Interface Create Domain Values?: This flag tells Maximo if an inbound transaction will add domain values during processing. With this checked, if a value is imported that does not exist in a domain, it will be added. With this not checked, it would generate an error.
Administrator E-Mail Address: this is the email address Maximo should send error messages to.
Sender E-Mail Address: This is the email address that will appear as the “from” on all emails generated by Maximo.
Add/Modify End Points
This screen is where you create new End Points. An end point is based on a handler.
End Point: A unique name for the End point
Description: A description of the End point.
Handler: The handler for this End Point.
The bottom half of the screen is where you fill in specific details for each End point. These parameter are from the handlers. For example. The FLATFILE handler lets you specify a directory and a separator. If you needed to have two FLATFILE interfaces, but each has to go into a different directory, then you create two End points, both with the Handler of FLATFILE, but you would specify a different directory on each one. Then set up an external system for each end point.
Data Import
For flat file and XML data, the MEA will not automatically read in data (you have to create your own cron task for that). You can use this screen to load flat file and XML data.
File Type: Select either XML or Flat File. If you select Flat File, then you can also specify the delimiter.
Server Directory: This is the directory on the server where the file to import is located. Yes, this means that the files must be accessible as a local drive letter.
File Name: This is the name of the file to import. You can click the lookup icon to see a list of files in the Server Directory.
Create Interface Tables
If you are using the MXIFACETABLE End Point (or an End Point that uses the IFACETABLE Handler), they you have to create the interface tables).
End Point: This is the name of the end point you want. The lookup is restricted to those end points that use the IFACETABLE Handler). Selecting a value will populate the bottom of the screen.
Description: This is the description of the End Point (filled in by Maximo).
URL: this is the URL for accessing the database where the interface tables are to be. This field is filled in by Maximo. The default is the same database as Maximo.
Create Backup?: This flag tells Maximo to first create a back of the table before creating a new one. The create process is destructive and will wipe out any data you have in the table. This gives you the option to make a backup of the existing table first.
Now all you have to do is place a check by each table to create and click “Create”. If the table does not already exist, then you should uncheck the “Create Backup?” as I have had Maximo throw an error trying to do the backup.
You might be wondering why, once you created an interface table, would you need to re-create it? Well, if you made any changes to the Integration Object (added a field or MBO), then you will have to re-create the table to show those changes.
For more information on Interface tables, see Maximo(MXES) MEA Part 2: Programming Interface Tables.
Install Product/Updates
I am not really sure when you would use this screen. I suspect this would be for special interfaces from vendors (like IBM) and would come with instructions. If you happen to know more, please add a comment and share with the rest of us.
The other options are the standard Maximo fair (duplication, bookmark, etc). That pretty much covers the External System screen. Happy Coding.
Permalink
06.05.08
Posted in Maximo at 3:35 pm by Mike
As a developer in Maximo, it can be a bit of a pain, after any change to the classes you make, you have to 1) stop the application server 2) rebuild the Ear 3) restart the application server so it will auto-redeploy the ear. As it turns out, if you are using Weblogic, you can cut this down to just stopping and restarting the application server. (I have never seen directions for doing this in WebSphere, but if you know any, please let me know.)
I would only recommend this for development servers. For production, it is better to deploy the ear.
It is actually pretty easy to setup. You will have to log into the Weblogic console. First, if you already have Maximo deployed as an Ear, delete it. Now select to deploy a new application, but instead of navigating to the C:\Maximo\Deployment\Default, navigate to C:\Maximo\Applications and select Maximo.
Now press Continue a couple of times. And that is the entire process. Now, when you make a change to a class file, all you have to do is “bounce” (stop and start) the Weblogic server. Happy coding!
Permalink
Posted in Maximo at 2:01 am by Mike
Now that I have covered how to setup processing rules, I thought it would be good to give some samples on when to use what type of rule.
Situation: say you have to have to convert lookup data from system X to Maximo lookup data. You know that each value from system X will correspond to a value in Maximo.
Solution: Create a Cross Domain in Maximo, then create a Replace rule on the field using the Cross Domain with no condition (so it would always run).
Situation: System X has a field that is not in Maximo. Based on this field, you need to populate other fields.
Solution: Create a User Field on the Integration Object with the name of the field from System X. Then for each possible value of the field, add a SET processing rule where the condition checks the value of the field for one of the possible values and the sub-record fields sets all the other fields to the needed values.
Situation: The AssetNum values from System Y have an extra two characters attached to the front of them. This this two character value needs to be converted to the Site ID.
Solution: First create a Cross Domain for the two character code to Site IDs. Now create two rules. The first is Split rule that takes the first two characters for the SiteID and the rest of the Characters for the AssetNum. The second rule is a Set rule for SiteID using the Cross Domain.
Situation: System Z uses four 256K fields for comments that you need to put in the Long Description field.
Solution: First add 4 user fields on the Integration Object for the comment lines. Next create a Combine rule for the Description_LongDescription field and select the 4 user defined fields for combining.
Situation: You are bringing in PO data, but if the PO is for SiteID “X” and is less than $100, you don’t want to import the record.
Solution: Create a Skip rule and in the condition check for both SiteID = “X” and Amount < $100.
Situation: The column names coming from System Q do are not the same as column names in Maximo.
Solution: In the Integration Object, create Aliases for each column name.
Well, I hope you begin to see how you can use the processing rules.
Permalink
06.04.08
Posted in Maximo at 2:24 am by Mike
In my last post, I talked about setting up Stop/Skip rules. In this post I will be talking about the other types of rules. There are two basic types of rules. The first type are rules that either skip a record or stop processing. The other type are rules that lets you manipulate the data. There are rules that allow you to merge data into one field, split a field into two, set a field to a value, etc.
These Rule Actions are:
Set: sets a field to a value
Combine: combines two fields into one field
Split: splits a field into two fields
Replace: replaces data in a field (think cross reference)
You start by creating a rule just like we did in the last entry. With these rules, you can set criteria for when the rule should run. The difference is you would set the Action to one of the above. The other difference that you have to use the “Sub-Record Fields” screen. The Sub-Record Fields screen is where you do all the work for these actions, and this screen will be different for each action.
SET Action
Let’s look at the Sub-Record Fields Screen for the “SET” action.
Fields:
Field: name of the field you want to set
Replace When Null: check this box if you want the system to set the field, even if it is null.
Interface Control: Set the field to the value of the select Interface Control.
Value: Set the field to value you enter.
MAXVAR: set the field to the selected MaxVar (values stored in the MAXVAR table).
Field: set the field to the select value of the field (which is part of the current record)
MBO/Relationship/MBO Field: set the field to the value in another table/field.
COMBINE Action
Now let’s look at the Sub-Record Fields Screen for the Combine action
This screen is divided into two sections. The top section is the target, that is, what field will the combined data be stored in.
Field: This is the field that will receive the combined data.
Separator Interface Control: This is the Separator control you want to use.
The bottom section is where you define what fields to combine and what order.You would normally have at least two rows in this sections (if you only had one, then you could just use a “Set” action).
Sequence: This denote the order the fields should be in.
Field: This is the name of a field.
Interface Control: the name of a interface control.
The “Select Field” button is a short cut. It let lets you select one or more fields and adds them each as a row.
SPLIT Action
Now let’s look at the Sub-Record Fields Screen for the Split action
This screen is divided into two sections. The top section is the source, that is, what field that will be split.
Field: This is the field that will be used for splitting.
Separator Interface Control: This is the Separator control you want to use.
The bottom section is where you define what fields get what part of the source field.
Sequence: This denote the order the fields should be in.
Field: This is the name of a field.
Field Length: length of character from the source field.
The target section work sequencally. The first field will start with the first character in the source field and run for the “length”. The next record will start with the next character and run for its length. Etc…
The “Select Field” button is a short cut. It let lets you select one or more fields and adds them each as a row.
REPLACE Action
Lastly, let’s have a look at the Sub-Record Fields screen for the Replace Action. To use this type, you must first create the Cross-Reference Lookup Interface Control that contains both the old and new value.
Fields
Field: Name of the field
Interface Control: name of the interface control.
When this rule runs, it will use the current value in the field to lookup, using the Cross-Reference lookup, and replace it with the return value of the lookup.
Well, that is pretty much it for processing rules. I only covered XML fields, but you will find the MBO and MBO sets are pretty much the same.
Permalink
« Previous entries
