Saturday, June 22, 2024

Dependency publishing Option - Optimize your deployment for big projects

 Hello Frieds,

Well – you do have the “dependencyPublishingOption” in the launch.json, which has 3 options:

Consider the scenario where you have multiple applications within an environment, designated as the Parent app and Child App A.

 

  • Parent App: This application does not have any dependencies.
  • Child App A: This application depends on the Parent app.

 

Problem Statement:

When deploying the Parent app in Business Central, should you reinstall all dependent apps (like Child App A)? If so, how can this process be configured to occur automatically?









Solution: 

Using the dependencyPublishingOption Property in launch.json

The dependencyPublishingOption property in the launch.json file is used to manage how dependent apps are handled during deployment. It offers three options:

 

  1. Default: Rebuilds and publishes all dependent apps.
  2. Ignore: Skips dependency publishing. Use this option cautiously, as it may break interdependent apps.
  3. Strict: Fails the publishing process if there are any installed extensions dependent on the root folder. (Publishing will fail if the project has apps that not part of the workspace and depend on it) - Not applicable at in case where we are not using workspace option.

I like the default setting – something it takes a little longer to include all dependencies in the compile – but at least you’re checking all dependencies .. So that must be good ðŸ™‚But, in some cases – especially in case of big apps with many objects – you might want to avoid unnecessary recompiles of dependent apps.. .  (for big project we can use Ignore option in dependency publish to avoid more wait time)

Friday, June 21, 2024

ErrorInfo Object Variable - Show the action message on error message

Hello Friends,

Developers can now set the Title property on Error dialogs that are presented to the user to enrich issue description. On top of that, using the ErrorInfo object, developers can add up to three custom actions that will be displayed on the Error dialog to provide users with corrective actions. This can be achieved by calling the AddAction method on the ErrorInfo object, which can be passed to AL methods that support ErrorInfo such as Error, TestField, FieldError, and others.

The AddAction method accepts three parameters:

  • Caption: The text string that appears as the caption of the action in the error UI.
  • CodeunitID: The ID of the Codeunit to run when the action is initiated from the error UI. The codeunit should contain at least one global method to be called by the error action. The global method must have an ErrorInfo data type parameter for accepting the ErrorInfo object.
  • Method Name: The name of the method in the Codeunit, which is specified by the CodeunitID parameter, that you want to run for the action.


One more useful ErrorInfo variable we can use for provide ERROR Message with actions

we can have multiple actions on error message itself to open relevant setup or master page

this will very convenient for user to Navigate to correct page for fixing any issue
















in above error there are two action showing Open Gen. Journal Template & Open Source Code Setup
 
this can possible using ErrorInfo variable
 
Sample Code:

codeunit 75030 INT_Sample_ErrorInfo
{


    trigger OnRun()
    var
        GenJournalLine: Record "Gen. Journal Line";
        ErrorInfo: ErrorInfo;
        SameSourceCodeErr: Label 'Journal Source Code %1 is same as Source Code set
for Purcase/Sales documents. This is not allowed when using deferrals.
If you want to use this journal for deferrals, please update Source Codes
on Gen Journal Template and generate line again.', Comment = '%1->Source Code';
        OpenGenJournalTemplateDescTxt: Label 'Open Gen. Journal Template page to
update Source code.';
        OpenSourceCodeSetupDescTxt: Label 'Open Source Code Setup page to check
Source code setup.';
    begin
        ErrorInfo.ErrorType(ErrorType::Client);
        ErrorInfo.Verbosity(Verbosity::Error);
        ErrorInfo.Message(StrSubstNo(SameSourceCodeErr, GenJournalLine."Source Code"));
        ErrorInfo.TableId(GenJournalLine.RecordId.TableNo);
        ErrorInfo.RecordId(GenJournalLine.RecordId);
        ErrorInfo.AddAction('Open Gen. Journal Template', Codeunit::"INT_Sample_ErrorInfo",
'ShowGenJournalTemplate', OpenGenJournalTemplateDescTxt);
        ErrorInfo.AddAction('Open Source Code Setup', Codeunit::"INT_Sample_ErrorInfo",
'ShowSourceCodeSetup', OpenSourceCodeSetupDescTxt);
        Error(ErrorInfo);
    end;

    procedure ShowGenJournalTemplate(ErrorInfo: ErrorInfo)
    var
        GenJournalTemplate: Record "Gen. Journal Template";
        GenJournalLine: Record "Gen. Journal Line";
        GeneralJournalTemplates: Page "General Journal Templates";
        RecordRef: RecordRef;
    begin
        RecordRef := ErrorInfo.RecordId.GetRecord();
        RecordRef.SetTable(GenJournalLine);
        GenJournalTemplate.SetRange(Name, GenJournalLine."Journal Template Name");
        GeneralJournalTemplates.SetTableView(GenJournalTemplate);
        GeneralJournalTemplates.RunModal();
    end;

    procedure ShowSourceCodeSetup(ErrorInfo: ErrorInfo)
    var
        SourceCodeSetup: Page "Source Code Setup";
    begin
        SourceCodeSetup.RunModal();
    end;
}


Stop using the Error() function in Business Central - Error Message Handler & Error Message Management

 Hello Friends,

Stop using the Error() function in Business Central.


A better approach when working with long processes, like posting, is to use these codeunits:

- "Error Message Handler".
- "Error Message Management".

They allow to log every error in a process and show them at the end.

Benefits.

1) Modern error.

It’s not just an error message. It can show related records to the error and add recommended actions.

2) Different message types.

You can show errors, warnings, messages, testfields, fielderrors, and more.

3) List of errors.

By showing a list of errors at the end, users don’t have to fix them one at a time.

Have a look at the base app for more examples:

Sales Header → SendToPosting
E-Invoice Mgt. → CheckSalesDocument

PS. Did you know about this approach?




Monday, January 1, 2024

Interface in Business Central

Hello Friends,

Interfaces are a tricky concept that can be difficult to understand. In this article, you will learn how to use interfaces in Business Central step by step. By following an existing interface, you will understand how to implement it to create your own interfaces.

  • What Is An Interface
  • How To Use An Existing Interface
  • Example Setup and Test
  • How To Call An Interface
  • Summary

What Is An Interface


An Interface is a concept that defines a set of methods that codeunits can implement. It does not contain any logic or implementation itself but specifies methods that must be implemented by a codeunit that implements the interface.

Business Central interfaces were introduced in 2020. They are a way of extending Business Central functionality without the need for events. Their benefits are that they enable abstraction, decoupling, and scalability.

How To Use An Existing Interface


Interfaces can be a bit difficult to understand at first. I’ve found that the best way to learn how to create an interface is to use an existing one. This way, you will understand the concept and the steps to follow.

E-Document Core is a new application introduced in BC23. We will be using an interface in this application for this example. We will follow this link to implement the interface.

Extending e-documents functionality – Business Central | Microsoft Learn

First, we need to identify the interface to implement. The “AL Explorer” can help with it. As you can see, there are two interfaces for this module. For simplicity, we will just implement the interface called “E-Document”.

To use the interface we have to “implement” it. You can do it by creating a codeunit like this one. When you hover over “E-Document” you will see that all these methods are needed:

You can create them manually. However, you can do it automatically using the tooltip “Implement Interface”.

And all the procedures will be created empty for you.

If you drill down on “E-Document” you will be able to see the interface with all its methods.

Finally, create an enumextension extending “E-Documet Format” and using our implementation.

The key here is that the enum can be extended with more values where each of them can have a completely different implementation. Giving the flexibility mentioned above.

The enum “E-Document Format” just implements the interface “E-Document”

At this point, the foundation is established. But there is no logic in our implementation yet. Let’s create a simple example.

Inside the “Check” function we will do a Testfield in “Your Reference” field like this:


Example Setup And Test


Let’s set it up in Business Central. We have to follow 4 steps:

  • Create an E-Document Service
  • Create an E-Document Workflow
  • Create a Document Sending Profile
  • Assign the Document Sending Profile to the customer

At this point, we can go ahead and create a new “E-Document Service” and select our enum value.

Create a very simple workflow like the following. Choosing the service just created.

Create a new Document Sending Profile by choosing the workflow just created:

Finally, assign it to the customer:

Now, when you try to release a sales document for this customer without “Your Reference” you will get an error:

This is just a simple example of an interface where we only created logic for one procedure.

How To Call An Interface


This interface, in particular, is called from this event in “E-Document Subscription” codeunit in E-Document core app:

We arrive at this procedure in which we can see that the interface is called with these two lines:

EDocumentInterface := EDocumentService."Document Format";
EDocumentInterface.Check(EDocSourceRecRef, EDocumentService, EDocumentProcessingPhase);

You can find another example in “E-Doc. Import” codeunit.


Summary


In short, what you need to use an interface is:

  1. Identify the interface to implement
  2. Implement it using a codeunit with its methods
  3. Identify the enum implementing the interface
  4. Extend the enum with your custom codeunit implemented

I hope this help someone to understand Interface

Thank you for reading.

Keep Sharing....Keep Growing...