"Fetcher" patter

[mazhelez]

Hey AL devs!

I have been working on extracting and defining a pattern that could be useful in several cases. I call it "Fetcher" pattern. Please read on and share your feedback.

Fetcher patter

Description

Fill-in data for internal table from one or more apps without exposing the table.

The pattern works for other cases as well. Doesn't have to be an internal table that needs to be filled in.

Outline

• Public: codeunit with an event OnFetchData() that includes the publisher and a public AddData procedure.
• Internal: FetchData() called when data needs to be fetched.

Definition

codeunit 1 Fetcher
{
    Access = Public;
    Permissions = tabledata "Internal Table" = rid;

    #region Public

    /// <summary>
    /// An event to populate data. To add an entry, call <see cref="AddData" />
    /// </summary>
    [IntegrationEvent(true, false)]
    internal procedure OnFetchData()
    begin
    end;

    /// <summary>
    /// Adds data.
    /// </summary>
    /// <param name="SomeValue">Some value</param>
    /// <param name="OtherValue">Other value</param>
    /// <param name="ThirdValue">Third Value</param>
    procedure AddData(SomeValue: Interger; OtherValue: Text; ThirdValue: Double)
    begin
        // Validate the entry does not exist
        InternalTable.SetRange(FirstField, SomeValue);
        InternalTable.SetRange(SecondField, OtherValue);
        InternalTable.SetRange(ThirdField, ThirdValue);

        if InternalTable.FindFirst() then
            exit;

        InternalTable.Init();

        InternalTable.FirstField := SomeValue;
        InternalTable.SecondField := OtherValue;
        InternalTable.ThirdField := ThirdValue;

        InternalTable.Insert();
    end;
    #endregion

    #region Internal

    internal procedure FetchData(var Result: Record "Internal Table")
    begin
        InternalTable.DeleteAll();

        OnFetchData();

        // Transfer data from InternalTable to Result
    end;

    var
        InternalTable: Record "Internal Table" temporary;

    #endregion
}

Usage

• In your app. Call Fetcher.FetchData() when you need to populate the data.

procedure DoSomethingWithData()
var
    InternalTable: Record "Internal Table"; 
    Fetcher: Codeunit Fetcher;
begin
    Fetcher.FetchData(InternalTable);

    // Do something with data stored in InternalTable
end;

• As a subscriber. Add your data by subscribing to OnFetchData and calling AddData.

    [EventSubscriber(ObjectType::Codeunit, Codeunit::Fetcher, 'OnFetchData', '', false, false)]
    local procedure AddData(var Sender: Codeunit Fetcher)
    begin
        Fetcher.AddData(1, 'My data', 3.14);
    end;

Advantages

• The table is encapsulated and does not have to be exposed as public. That makes moving the data out of the table way easier.
• There is a centralized place to validate the input.
• There could be extra validations.
  
  Consider the need to import data only through certain extensions:

    procedure AddData(SomeValue: Integer; OtherValue: Text; ThirdValue: Double)
    var
        CallerModuleInfo: ModuleInfo;
    begin
        NavApp.GetCallerModuleInfo(CallerModuleInfo);
        if CallerModuleInfo.Publisher <> 'Microsoft' then
            exit;
        
        ...
    end;

or

    procedure AddData(SomeValue: Integer; OtherValue: Text; ThirdValue: Double)
    var
        SomeOtherTable: Record "Some Other Table";
    begin
        if not SomeOtherTable.WritePermissions() then
            exit;
        
        ...
    end;

Examples

System Application:

• Telemetry Loggers
  This is an example where the fetcher doesn't need to be populating data.
  Register is used as AddData and OnRegisterTelemetryLogger is used for OnFetchData().
  In that example the "Fetcher" codeunit even has a state (CurrentPublisher) which comes to show how powerful the pattern can be. State in this case is used to fetch the telemetry logger defined for the publisher who calls the procedure.

• Default Permission Set in Plan
  Classic example of the Fetcher pattern.
  In this case, another useful aspect is shown: OnFetchData can come with parameters (OnGetDefaultPermissions(PlanId: Guid)).
  The parameter in this case is used to get the default permissions only for a certain plan.