Manual file creation can quickly become a bottleneck, wasting time and resources. This is especially true when creating complex file formats for employee demographics, benefit interfaces, and financial records. With Infor’s File Creation Utility, those challenges can become a thing of the past.
Originally developed for HCM, this tool now extends its capabilities to streamline file generation across Infor CloudSuite’s FSM and HR Landmark applications. By minimizing the need for coding, it makes the entire file creation process faster, more efficient, and easier to manage.
To discover all that the File Creation Utility has to offer, join RPI’s Principal Technical Consultant, Jeremy Stoltzfus, as he walks through its key features and functionality.
- Explore the File Creation Utility’s key capabilities and functionality
- Learn about the tool’s tracking and troubleshooting features
- Discover parent-child relationships, multiple record layouts, and IPA/ION automations
- See how the tool can minimize development time for creating various types of interface files including delimited and fixed length files.
Transcript
Jeremy Staltus
Hello, everyone, and thanks for joining today. My name is Jeremy Staltus with RPI Consultants, and I will be discussing the File Creation Utility.
A little bit about myself: I am a principal tech consultant with RPI. I’ve got over 20 years of experience in the Infor Lawson space — over five years of that implementing Infor CloudSuite, and almost eight years now with RPI. Prior to joining RPI, I worked as a Lawson system administrator at a healthcare system in Pennsylvania, and at another client site before that.
A quick rundown of the agenda. The File Creation Utility is an interface development utility available in the Landmark applications. It was originally created for the GHR applications but has since been added into the Finance and Supply Management modules as well. Today we’ll cover a few of the key features, walk through the basics of building a file and its components, go through the process of actually generating the file, cover a couple of tips and tricks, and then open it up for Q&A at the end.
Let’s start with the key features. Why would we use the File Creation Utility? In the past, we’ve used process flows to generate files — querying data out through transaction nodes, API calls, JavaScript formatting, and so on. The File Creation Utility is designed to minimize coding so we can dramatically reduce development time. When customers come to me with an interface requirement and a file layout, it’s typically a minimum of 20 hours of work to get the process flow set up — variables, queries, formatting, extra scripting. This utility cuts that significantly. A basic employee demographic file, for example, can be built in one to two hours depending on complexity. You can obviously go more advanced and handle more complicated requirements, but the framework built into the File Creation Utility drastically reduces that development time regardless.
There are defined starting points for building your files. On the HR Talent side, those include business classes like Employee, Work Assignment, Positions, Jobs, and Benefits. This utility is particularly useful for generating benefit interface files, which tend to be some of the more complex ones. It also takes advantage of application-defined relationships — so an employee can have one or many work assignments, and you can use those existing relationships to pull all of that data into your file. Same with employees and dependents.
A few other key features: fixed-length or CSV options, with the ability to define a custom field separator — comma is the default, but you can use a pipe, a caret, or anything else. You can also specify field delimiters to wrap data in quotes, which is useful when your data contains commas and you’re using a comma separator. You can define end-of-line characters, so if you need carriage return and line feed for a Unix platform, you can specify that. And you can set segment limits — controlling how large a file can get before it splits into multiple files.
With fixed-length files, you simply specify that a field is 10 characters, and the utility automatically truncates at that length. In the past with IPA, you’d have to write JavaScript to handle that manually. The File Creation Utility does it out of the box.
Parent-child relationships are also supported. Going back to the employee-dependent example, the one-to-many relationship is maintained so that all dependent records are grouped with and sorted under their parent employee record. This is especially useful for benefit carrier files, where you send the employee record first, followed by all associated dependents.
Multiple record layouts are another key feature. You can have header records with a completely different format than the main content, footer records with counts and totals, and even different record types within the main body of the file. For example, an employee record might include 20 fields while a dependent record only needs 10. You can also define selection criteria to control which records are included and when.
Another powerful feature is change file versus full file. Similar to how replication sets work, you can configure the File Creation Utility to only include records that have changed since the last run. It uses the audit log to track the date and timestamp of the last generated file. You also have flexible record selection criteria using custom groups and subjects, which gives you powerful options for writing complex selection logic. You can further refine data at the record level — for example, a single employee record might generate three different records in the file, and you can show or hide those record layouts based on additional criteria.
There are also sorting options with multiple levels of sorting and subtotaling, and you can specify multiple count values within the file. On the formatting side, you have Java and regular expression formatting options with GUI helpers. Date formatting is the most common example — month/day/year, year/month/day, six-digit, eight-digit — all easily configurable on each date field. You can also pad numeric values with leading zeros in a fixed-length file. The GUI helpers let you select options and preview results with test data, so you don’t have to know the Java syntax directly.
Finally, post-file generation: the file needs to go somewhere once it’s created. You have two options — trigger an IPA process flow, which can use an FTP node to push the file wherever it needs to go, or send the file directly to ION and handle distribution from there. IPA also gives you additional flexibility for more complex formatting or data analysis that can’t be done within the File Creation Utility itself. I’ve done this many times — generate the file, pass it to IPA, read it back in, and apply more complex JavaScript logic, which tends to process significantly faster than looping through thousands of transaction nodes.
Now let’s walk through the basics of building a file. You start by giving it a file description and specifying the source file — the set of business classes that serve as your starting point. On the HR side, there are many options, particularly around Employee, Work Assignment, and Benefits business classes, and Infor continues to add more over time. On the Finance side, there are fewer currently, but that list is growing as the utility matures in that module.
You specify the file name and can optionally append a timestamp, with a format builder to help you configure it if you don’t know the Java syntax. If your file needs a hard-coded header — like column names — you enter that in the free text field provided.
The File Attributes and Processing tab gives you a few more options. This is where you specify fixed-length versus separated format, your end-of-line character, and segment limits. One powerful option here is threading. You can configure the utility to run in multiple threads, which is particularly valuable at large organizations. Recent updates have included significant performance improvements in how those threads analyze and process data. At the end, you can either merge all threads into a single master file or keep them as separate files.
The output options let you specify the process flow service to trigger after generation, or send the file directly to ION.
Record selection is configured through the eligibility group. This is where you get a lot of power and flexibility. I recommend always starting with an eligibility group, especially when you only need a subset of data. If you want active employees only, or terminated employees only, define that upfront — it’s much more efficient to start with a smaller set of records. Without an eligibility group, the utility pulls every employee record and then evaluates each one against your criteria, which adds significant processing time. The eligibility selection runs much more efficiently.
The last timestamp field tells the system when this file was last run, so on the next execution it only picks up records that have changed since then. If you always need a full file, you can check the all-records flag to override that behavior.
The heart of the File Creation Utility is the row and column detail configuration. This is where you define header records, source file records, and trailers. For every record that meets your eligibility group criteria, the system evaluates it against each row type. Row type Header goes automatically at the top, Trailer at the bottom, and yes — headers can include counts or totals. The system holds the header line until all records have been processed and counted, then writes it out.
Each row type can have a different set of columns. For a fixed-length file, you specify the beginning and ending position of each field, giving you precise control. You can see the source business class and source fields for each row, making it easy to find and modify specific mappings. Fields with no source business class specified use the default — whatever base business class you selected in the setup, such as Employee.
Within the row detail, there’s also the concept of linked rows. If you have a row definition in another setup that already has all the fields and mappings you need, you can link to it rather than rebuilding. You can also specify up to six different count options per row — useful for tracking counts by record type across a header, multiple row details, and so on.
Row processing conditions let you control which row types are generated for a given record. In my earlier example with a header and three row types, you might only want record type one when a specific condition is met. For conditions more complex than what the two-condition builder supports, I typically use a derived field that returns a true/false value and reference that in the condition.
Derived fields are where the File Creation Utility really shines. You can create custom relationships, pull additional data from related business classes, or build more complex logic than the native options support. Derived fields can return a blank when they’re not supposed to output anything. User-defined fields work here too, the same way they do in replication sets or IPA queries.
One-to-many options let you specify a one-to-many business class — like the employee-dependent relationship — so the utility keeps all related records grouped together properly.
When you’re mapping a specific column, you give it a name, specify the order, define the data type, and indicate whether it’s required. You can also specify a blank field or a hard-coded literal value. You then select the source business class — leave it blank to use the default starting point, or open the dropdown to see all related business classes: Address, Identification Number, Emergency Contact, Work Assignment, and others. Once you select the related class, you specify the field from it.
For fixed-length fields, you set your begin and end positions. Date fields use the Java format builder — YYMMDD, for example — and you can optionally include century for a four-digit year or add a date separator. Numeric fields let you pad with leading zeros; string fields can be padded with spaces. The format builder shows a test value at the bottom so you can verify the output before saving.
Basic data mapping is also available at the column level. For example, in the HR Talent application, gender is stored as a numeric value: 1 is unselected, 2 is Female, 3 is Male. Many demographic file layouts require an M or F instead. You can map those values directly and set a default for any unmatched cases. For anything more complex, that’s when I reach for derived fields and LPL to handle the logic.
Now let’s quickly cover the process of generating the file. There are three main actions. The first is Generate Preview Records, which evaluates your eligibility group and pulls in all matching records, storing them in the File Creation Utility setup along with date and time stamps. It then determines which row conditions each record meets — for example, record type one for terminated employees, record type two for active employees. At the end, it writes out the data file.
Make sure to activate the setup before running. When you first build it, the setup is inactive — you need to turn it on. Generate Preview Records is an instance action that kicks off the process. You have the option to automatically generate the file after creating the preview records. In production, you’ll want that option enabled so it runs end-to-end. During development, you may want to generate preview records first, inspect the results on screen, verify your selection criteria is pulling the right records, and then manually trigger file generation separately.
Once the file is generated, you’ll see a list of files with date, time, file size, and record counts for each run. This is especially useful for change files, where the output may vary each time.
A few tips and tricks to close out. Start simple — build an employee demographic file with just name, address, and phone number to get comfortable with how the utility works and how async processing behaves. For complex logic, use derived fields. The File Creation Utility makes it easy to assemble file layouts quickly, but handling complicated conditions inside the utility itself is tricky — derived fields with LPL are the right tool for that.
Increase your thread count if you’re at a larger organization. The default is two threads. For organizations with around 10,000 employees, four threads tends to work well — though it depends on how many threads are available in your async queue.
Finally, the regenerate option is a great time-saver during development. Instead of re-running Generate Preview Records — which has to go out and pull all records again — you can select the most recent file and click Regenerate. It re-evaluates all the mappings and generates a new file using the existing preview records, skipping the record-pull step entirely. Much faster when you’re just tweaking the layout.
That’s basically it. Thank you very much for your time.
