When working with Electronic Reporting (ER) configurations, grouping records is often essential. The LISTJOIN function enables you to consolidate data from multiple lists, which is especially useful when managing data from various sources with common fields. Here’s how to make the most of the LISTJOIN function in your ER configurations.

Using LISTJOIN in Electronic reporting

When displaying a repeating section in a template, you typically work with a single list (e.g., showing all lines of a sales invoice on a document). However, sometimes you need to combine records from multiple lists. This is helpful when data is spread across different sources that share common fields, like transactions in a project invoice. In this scenario, a project invoice might include multiple types of transactions, such as expenses, fees, items, and hourly charges.

Different lists may contain distinct fields, as seen in the example below.

• The Expenses container has fields for Amount, Description, Quantity, and Type.
• The Items container has fields for Amount, Description, ItemId, Quantity, and Unit.

Below is the formula which allows us to join our two lists in our ER format’s mapping in a new calculated field:

LISTJOIN(@.Expenses, @.Items)

The resulting list will only include the fields that are common across both lists, in this case, Amount, Description, and Quantity.

Field Requirements

To join records from different lists, ensure that any fields you want in the final, consolidated list exist in all the lists you’re combining. If a field is missing from even one of the lists, it won’t appear in the final joined list, potentially leaving gaps in your data.

Handling Missing Fields

If some lists lack the required fields, you can add those fields to make the list join work seamlessly. Ensure the new fields have the same name and type as in the other lists. You can set placeholders in your model mapping for these new fields to prevent errors from empty fields.

Steps to Implement the Solution

1. Identify Missing Fields: Determine which fields are missing in each list.
2. Create Missing Fields: Add these fields with the same names and types to lists where they are missing. In our example, Expenses list is missing the ItemId and Unit fields, while the Items list is missing the Type field.
3. Set Placeholders: Use placeholders in your model mapping for these fields to handle errors caused by empty fields.

The result is a consolidated list with all the required fields from both lists.

By following these steps, you can use the LISTJOIN function in an ER configuration effectively. This approach ensures your data is easily combined in single data source and is easy to display.

Image by freepik

The post How to combine multiple data sources into one in electronic reporting (ER) configurations first appeared on Kodeqa.

In Microsoft Word, customizing the layout of complex document templates requires careful attention to detail, especially when it comes to ensuring a clean print. One of the most common challenges is controlling how specific sections are displayed across pages. For example, if a table is slightly too large to fit at the end of one page, Word may split it across two pages by default, which can interrupt the visual flow and readability of the document.

In this post, we’ll explore practical techniques for keeping entire sections or tables together on a single page when printing. This guide will walk you through setting up Word’s pagination options to ensure your content displays exactly as intended. Let’s dive into how you can make sure your content maintains its structure from screen to print.

Create and setup a Parent Content Control

To start, set up a parent content control around the entire section you want to keep on a single page. This is essential to ensure that Word treats the section as a single block.

1. Select the Location for the Content Control: Place your cursor at the position in the document where the section begins. This will serve as the starting point for the content control.
2. Insert the Parent Content Control:
   • Navigate to the Developer tab in the Word ribbon. (If the Developer tab is not visible, enable it by going to File > Options > Customize Ribbon and checking “Developer.”)
   • Under Controls, click on Rich Text Content Control or Plain Text Content Control, depending on your content needs.

Adjust Paragraph Settings for the Content Control

Now that you’ve created the parent content control, adjust its paragraph settings to prevent page breaks within the section.

1. Open Paragraph Settings: With the content control selected, go to Home > Paragraph > Paragraph settings, or simply right-click on the control and select Paragraph.
   
2. Enable “Keep Lines Together” and “Keep with Next”: Under the Line and Page Breaks tab, check both “Keep lines together” and “Keep with next.” These settings ensure that Word will move the entire section to the next page if there isn’t enough space on the current page.

Create Your Table

Now that the content control is set up, you can create the table within it. While the content control is still selected, insert your table.

This action nests the table within the content control.

Apply Line and Page Break Settings to Table Rows

Finally, apply the same settings to the rows within the table to keep them together.

1. Select all the rows within the table (or any additional elements in the content control).
   
2. Right-click the selection, go to Paragraph settings, and enable Keep lines together and Keep with next again under Line and Page Breaks.

Final Result

With this setup, Word will automatically move the entire section to the next page if there’s not enough room for it on the current one. This approach preserves the integrity of the layout, ensuring that no table or section is split across pages unexpectedly.

Image by storyset on Freepik

The post How to keep rows from a section on the same page in a CBD (ER) report Word template first appeared on Kodeqa.

Format Design for Nested Ranges

To properly display invoice lines and their associated charges on a sales invoice, you need to structure the format as follows:

1. Create a Range for Invoice Lines: Start by defining a record range for the sales invoice lines in your format design.
2. Create a Nested Range for Charges: Inside the range for invoice lines, add a second nested range to contain markup charges specific to each line.

The resulting format structure should resemble the following:

Set Up the Word Template

To implement the format structure in your Word template, create a basic table that organizes the data as follows:

Step 1: Create the Table Structure

1. Add a row for column headers at the top.
2. Set the InvoiceLines_Values record range as a repeating content control spanning the second to the last row of the table.

Step 2: Map Invoice Line Fields

1. Use the first row of the repeating section to display fields like Item ID, Description, Quantity, Unit, and Amount.
2. In the second row of the repeating section (third row of the table), set the record range for the charges using InvoiceLines_MarkupTrans .

Step 3: Add a Placeholder Row

1. Include a placeholder row as the last row of the InvoiceLines_Values repeating section. This row prevents layout issues during printing caused by overlapping start/end tags of the parent and child repeating content controls.
2. To minimize unwanted spacing, select the placeholder row and set its font size to 1 pt.

The resulting table should look something like this:

Handling Empty Charges Rows

When some invoice lines have no charges while others have multiple charge lines, the default setup can create empty rows for lines without charges. For example:

• Line 1: 2 charge lines.
• Line 2 and Line 3: No charges. This would then result in a table output where we have 2 empty rows on each invoice line.

The example might look something like this:

Solution

One solution that you might think of is to use the removed property on the InvoiceLines_MarkupTrans record list, however that will not work as you might imagine. Instead, it will only check if the first invoice line has any charges on it, and if it does not then the whole InvoiceLines_MarkupTrans content control will be removed and no charges will be shown for any other invoice line.

To minimize empty space and ensure proper formatting of charges rows in your Word template, follow these detailed steps to create a style and apply it to content controls.

Step 1: Create a New Style

1. Open the Styles Pane:
   • Go to the Home tab in Word.
   • Click the small arrow in the Styles section to open the Styles pane.
2. Create a New Style:
   • In the Styles pane, click on the New Style button (usually a small icon at the bottom of the pane).
   • In the Create New Style from Formatting dialog box:
     • Enter a name for your style, e.g., “ConditionalFormattingStyle.”
     • Set the font size to your preferred value (e.g., 10 pt or 11 pt).
     • Choose other formatting options as needed (e.g., bold, italic, or font color).
   • Click OK to save the style.

Step 2: Apply the Style to Content Controls

1. Select the Content Control:
   • In your Word template, click on the content control you want to format (e.g., a field in the charges row).
2. Open Content Control Properties:
   • Right-click the selected content control and choose Properties.
3. Enable Conditional Display:
   • In the Content Control Properties dialog box, check the option Use a style to format text typed into the empty control.
4. Apply the Style:
   • Click on the newly created style (“ConditionalFormattingStyle”) to apply it.

Final Output

After these adjustments, your template will produce a clean and professional output:

• Invoice lines without charges will have minimal empty space.
• Invoice lines with charges will display charges correctly.

By following these steps, you can effectively manage nested ranges in a CBD report, ensuring that your Word templates are both functional and visually appealing.

The post How to use nested ranges in a CBD (ER) report first appeared on Kodeqa.

In Dynamics 365 Finance and Operations, the Electronic Reporting (ER) framework offers robust tools for creating Configurable Business Document (CBD) reports tailored to your specific needs. Continuing from our previous blog post describing How to add a custom electronic reporting (ER) CBD report to print management, we will now explore how to develop and execute these custom reports using ER.

We will cover the steps needed to create a dedicated data provider class, setting up parameters for report customization, and executing custom CBD reports through the UI. 

Creating our CBD configurations

We are going to start off by creating our CBD configurations which consist of a model, a model mapping and a report format. 

For our example, we will have a model configuration named Custom Document model, out of which we will derive two new configurations, a model mapping and a report format.  

In our model, we have created a root node with a few Record and Record list nodes which additionally themselves contain a couple of data fields. 

After the creation of the model mapping configuration (which is based on a completed version of our model), we are still missing the mappings between our model and our data sources. We will get to that step later in this blog post. 

As the last step of this section we will need to do the initial setup of our report format. Here we will need to create a root node which will link to our template attachment and its parameters. 

Create the data contract, controller and service classes 

To execute our custom CBD report in code, we will need to create a new data contract, a controller and a service class. We will start with our data contract which will extend the standard ERFormatMappingRunBaseContract. 

[DataContract] 
public class CustomDocumentERContract  extends ERFormatMappingRunBaseContract 
{ 
} 

Here we can add additional parm methods which can be used to pass information such as specific fields or whole datasets to our CBD model mapping. We can achieve this by using the following code sample:

SalesId salesId; 
[DataMemberAttribute('SalesOrder')] 
public SalesId parmSalesId(SalesId _salesId = salesId) 
{ 
    salesId = _salesId; 
    return salesId; 
} 

Our next step would be to create the service class and for that purpose we will need to extend the SysOperationServiceBase class. Here we are defining a few variables which will later be used to initialize and run the report: 

• ER Model Data Source name – set this as “model” 
• The default file name for when we are exporting the report 
• Parameter data source name – this will be the name of our contract object when we add it to the model mapping 

using Microsoft.Dynamics365.LocalizationFramework; 
class CustomDocumentERService  extends SysOperationServiceBase 
{ 
    public const str ERModelDataSourceName = 'model'; 
    public const str DefaultExportedFileName = 'Custom document printout'; 
    public const str ParametersDataSourceName = 'RuntimeParameters'; 
} 

The second part that we will need in our service class is a method which will return the RecId value for our custom CBD report format.

public static ERFormatMappingId getFormatMapping() 
{ 
    return (select ERFormatMappingTable where ERFormatMappingTable.Name == 'Custom Document format').RecId; 
}

The above formatMappingId will be used in our main service class method to initialize the ERFormatMappingRun object to which we send the above created parameters and then use to run the report. 

public void executeOperation(CustomDocumentERContract _contract) 
{ 
    ERFormatMappingId formatMappingId; 
    formatMappingId = CustomDocumentERService::getFormatMapping(); 
    if(formatMappingId) 
    { 
        try 
        { 
            ERIModelDefinitionParamsAction parameters = new ERModelDefinitionParamsUIActionComposite()             
.add(new ERModelDefinitionObjectParameterAction(ERModelDataSourceName, ParametersDataSourceName, _contract, true)); 
            ERIFormatMappingRun formatMappingRun = ERObjectsFactory::createFormatMappingRunByFormatMappingId(formatMappingId); 
            formatMappingRun.withParameter(parameters); 
            formatMappingRun.parmFileName(DefaultExportedFileName); 
            formatMappingRun.withFileDestination(_contract.getFileDestination()); 
            formatMappingRun.parmShowPromptDialog(true); 
            formatMappingRun.run(); 
        } 
        catch 
        { 
            error("@SYP4861341"); 
        } 
    } 
    else 
    { 
        info("@SYS300117"); 
    }     
} 

The last part we need to modify is the controller class which is used when the menu item is triggered. This class contains the main method in which we will call the executeOperation method from the service class.

class CustomDocumentERController extends ERFormatMappingRunBaseController 
{ 
    public static void main(Args _args) 
    { 
        CustomDocumentERController operation; 
        CustomDocumentERContract   contract; 
        operation = new CustomDocumentERController(classStr(CustomDocumentERService), methodStr(CustomDocumentERService, executeOperation), SysOperationExecutionMode::Synchronous); 
        contract = operation.getDataContractObject(); 
        operation.parmShowDialog(true); 
        operation.startOperation(); 
    } 
} 

Create the menu item

Next, we will need to create an output menu item and setup some properties.  

• Object Type should be set to Class  
• In the Object property we will select our controller class (CustomDocumentERController) 

Fill in the data contract 

Either from the controller or from the service class, we can use the parm methods we have created in our contract class to pass information to our report format/model mapping. 

contract.parmSalesId(salesId); 

Add the data contract to the model mapping 

After we have made all the necessary code setup in the controller, service, and contract classes, we will return to the model mapping configuration to finish up with the mapping of the data sources. We will add a new data source which will be of type Object and then set up several of its parameters. 

It is important to note here that the Name parameter should be the same as the ParametersDataSourceName parameter in the service class. For the Class parameter we should select our previously created contract class.

After we’ve added the data source, all of the details that are passed in code will now be available for our use, such as specific fields or whole datasets that can be used for mapping to the fields in our model. 

Create and set up an ER destination 

To be able to print our report we will need to create and setup a new destination in the Electronic Reporting destinations form.  

For our example, we’ll add a new file destination and we’ll then in the Reference parameter select our report format that we’ve created earlier.  

After the file destination is created, we then need to select our template in the File component name parameter. 

In the end we will need to select our destination in the Settings menu which will determine where the report will be printed to. For our example, we will select File as the destination. 

Extra step 1: Set a file name for our CBD report 

We have two ways of setting up the file name for our report. We can either do it through code by sending the file name as a string to the format mapping run object (see the following code example): 

public const str DefaultExportedFileName = 'Custom document export name'; 
formatMappingRun.parmFileName(DefaultExportedFileName); 

Or, the other option would be to setup our file name in the File name field available under the Mapping section of our root node in the CBD report format configuration:

Keep in mind that you can use the file name setup from the report format configuration only if you are not sending a file name through code, otherwise the code will overwrite whatever setup you have done here. 

Extra step 2: Execute the report with and without a dialog 

When executing the CBD report, a show dialog parameter can be specified on the controller:

operation.parmShowDialog(true);

If this is specified as true, then the following form with open up when trying to print the report: 

The dialog shown would then list the parameters from our contract class as UI fields in which we can select specific records or data to be used for executing the the report. 

Final notes

By following the steps we’ve described in this blog post, you’ll be able to execute your custom developed CBD reports from any location in D365FO that can host menu items. This allows for a better user experience when using custom ER CBD reports as part of your daily routine and is a vast improvement on the default option of executing the reports only from the Electronic Reporting workspace.

Image by iconicbestiary on Freepik

The post How to create and execute custom electronic reporting (ER) CBD reports in X++  first appeared on Kodeqa.

In the standard D365FO print management form, we have a number of predefined document types which can be setup to print different reports, however it is not an uncommon requirement to create one or multiple custom electronic reporting CBD formats for a document which does not exist in print management.

In this post we are going to see how we can add a new document type to print management that we can use to configure and run custom CBD formats.

 

Adding a new document type

Firstly, we are going to start off by adding our document type to the print management form of an existing or a custom module.

The steps we need to take are as follows:

1. We extend the PrintMgmtDocumentType enum:
   • Add a new element with a relevant name for your report.
     
   • Create an extension of the PrintMgmtNode class specific to your module. If for example, we are working with a standard module, we are going to modify the WhsPrintMgmtNode_WHS class which applies to the Warehouse management module. Modify the getDocumentTypes method of the class and add our document type to this print management node. We can do this with the following code:
   •  

public List getDocumentTypes()
{
    List docTypes = next getDocumentTypes();
    docTypes.addEnd(PrintMgmtDocumentType::CustomDocument);
    return docTypes;
}

Associate our CBD report with a document type

After finishing the above steps, we will be able to see our custom document type added to the specific module’s print management screen. However, we will still not able to see our custom CBD format in the Report format field in print management.

To achieve this, our next step would be to extend the PrintMgmtReportFormatPopulator class, which will allow us to associate our custom CBD formats to our newly created document type. For this purpose, we can use the addOther method which takes 4 arguments:             

• PrintMgmtDocumentType enum – we send our newly added document type
• CBD format name
• CBD format description
• CBD format country/region code

[ExtensionOf(classStr(PrintMgmtReportFormatPopulator))]
final class PrintMgmtReportFormatPopulator_Extension
{ 
    protected void addDocuments()
    {
        this.addOther(PrintMgmtDocumentType::CustomDocument, 'Custom format name’, 'Custom format 
        description', 'Custom format country code');
 
        next addDocuments();
    }
}

Fetching our CBD format

Lastly, we need to get the CBD format which is selected for our document type in the print management setup.

public static ERFormatMappingId getFormatMapping()
{
    PrintMgmtDocInstance  printMgmtDocInstance;
    PrintMgmtReportFormat printMgmtReportFormat;
    PrintMgmtSettings     printMgmtSettings;
    ERFormatMappingTable  erFormatMappingTable;

    DataAreaId currentCompany = curExt();

    select firstonly RecId from printMgmtDocInstance
        where printMgmtDocInstance.DocumentType == PrintMgmtDocumentType::CustomDocument
            && printMgmtDocInstance.PrintType == PrintMgmtDocInstanceType::Original
            && printMgmtDocInstance.DataAreaId == currentCompany;

    select firstonly Name from printMgmtReportFormat
        where printMgmtReportFormat.DocumentType == PrintMgmtDocumentType::CustomDocument
            exists join printMgmtSettings
               	where printMgmtSettings.ReportFormat == printMgmtReportFormat.RecId
               	    && printMgmtSettings.ParentId == printMgmtDocInstance.RecId
                    && printMgmtSettings.DataAreaId == currentCompany;

    select firstonly RecId from erFormatMappingTable
        where erFormatMappingTable.Guid == 
            str2Guid(subStr(printMgmtReportFormat.Name, 21, strLen(printMgmtReportFormat.Name)-1));

    return erFormatMappingTable.RecId;
}

The above method will return the format mapping object of the CBD format that is set up for our document type. The returned RecId can now be used with the following code to create a format mapping object:

ERObjectsFactory::createFormatMappingRunByFormatMappingId(formatMappingId);

These methods can be now used in your electronic reporting classes (service/controller/contract) to run the report.

Final thoughts

After following the steps above steps, we have the framework setup to use a custom CBD with print management:

 

In case we have a custom module where we want to add a new report to print management, we will have to extend the PrintMgmtNode class and implement its methods. This will be described in more details in a future post.

The post How to add a custom electronic reporting (ER) CBD report to print management first appeared on Kodeqa.