MB-820 Microsoft Dynamics 365 Business Central Developer Questions and Answers

https://api.businesscentral.dynamics.com/v2.6/myTenant/myEnvironment/api/alpine/integration/rooms

field(3; "Receipt No."; Code[20])

{

DataClassification = CustomerContent;

TableRelation = "Purch. Rcpt. Header"."No." where ("Buy-from Vendor No." = field("Vendor No."));

}

Field Declaration:

The field(3; "Receipt No."; Code[20]) part defines the field in the table with ID 3 and type Code with a length of 20. This field will hold the receipt number.

DataClassification:

CustomerContent is selected for the DataClassification property, which categorizes the data for privacy and compliance management. This aligns with Business Central's recommendations for handling sensitive data in customer-related tables.

TableRelation Property:

The TableRelation property links the "Receipt No." field to another table, which in this case is the "Purch. Rcpt. Header" table. This ensures that only valid receipt numbers from the Purchase Receipt Header table can be selected or entered in this field.

Relation Filter:

The filter condition is applied using the where clause. It ensures that the Receipt No. is only from the Purchase Receipt Header records where the "Buy-from Vendor No." matches the "Vendor No." of the current record.

The condition field("Vendor No.") is selected from the drop-down as shown in the image. This links the vendor information in the non-conformity table to the receipt in the Purchase Receipt Header table.

By linking the "Vendor No." fields, you ensure that only receipt numbers from the correct vendor are available, which improves data consistency and reduces errors during data entry.

References to AL Language:

The TableRelation property is frequently used to create references between tables in Business Central. In this case, the correct relationship between the "Purch. Rcpt. Header" and the Non-conformity table is established using the TableRelation and filter.

Reference Documentation:

AL TableRelation Property

AL Field Syntax

For the Install codeunit required for the extension used for installing or updating the Housekeeping app, you should use the following data type and declaration:

Data type for information: ModuleInfo

Start of the declaration of the method or procedure to perform the tasks: local procedure

In AL language, which is used for developing extensions in Business Central, an Install codeunit is a special type of codeunit that is used to handle installation or upgrade logic for an extension.

ModuleInfo is a data type that contains information about the current extension, such as its version. It is typically used within the OnInstallAppPerCompany or OnUpgradePerCompany triggers of an Install codeunit to determine if the app is being installed for the first time or upgraded.

A local procedure within an Install codeunit is a method that is only accessible within the codeunit itself. It is not visible to other objects or extensions. This is suitable for tasks that are internal to the installation process and should not be exposed globally.

These selections align with the requirements of handling installation and update procedures in a controlled and encapsulated manner within Business Central extensions.

 Upgrade codeunit trigger: OnValidateUpgradePerDatabase

Since the question specifies that you are handling data upgrades, and you need to use validation before upgrading at the database level, the correct choice is OnValidateUpgradePerDatabase. This method ensures that the upgrade process is validated before applying to the entire database, making it more efficient when data affects multiple companies or structures.

 DataTransfer method to use: CopyRows

CopyRows is the appropriate method when you are handling large data transfers between tables, especially in an upgrade scenario where you are migrating or transferring data from one table to another. It copies entire rows of data and is optimal for bulk data operations during upgrades.

In Microsoft Dynamics 365 Business Central, when configuring snapshot debugging, it is crucial that the parameters in the configuration file are correctly set. From the options provided, the issue with the debugger not starting correctly is most likely due to an incorrect "userId" parameter.

Option A is the cause of the problem. The "userId" parameter must be the GUID of the user, not the username. The snapshot debugger needs the exact GUID to attach to the right session for debugging.

Option B is incorrect because "breakOnNext" set to "WebClient" is a valid setting. This tells the debugger to break on the next client action in the web client, which is a typical scenario.

Option C is not the cause of the problem. The "userId" parameter is meant to specify which user session to debug, and this works in conjunction with the "breakOnNext" parameter.

Option D is incorrect as the "executionContext" parameter does not need to be set to "Debug" for snapshot debugging to work. "DebugAndProfile" is a valid value for the "executionContext" parameter, as it allows for debugging and collecting performance information.

Therefore, the reason why the debugger does not start correctly is due to Option A: The "userId" parameter must have the GUID of the user specified, not the username.

The correct sequence of actions to configure telemetry for the SaaS tenant and test whether the ingested signals are displayed would be:

Create an Azure Application Insights instance by using the Azure Portal in the Customer's subscription.

Select the environment in the Admin Center and place the connection string in the Application Insights Connection String field.

Select the Application Insights instance, select Logs and then inspect the Traces table.

To set up telemetry for a SaaS tenant using Azure Application Insights, you need to follow these steps:

Create an Azure Application Insights instance: This is the first step where you create an instance in Azure that will collect the telemetry data. This should be done in the customer's Azure subscription because it's their data that you're monitoring.

Configure the SaaS tenant to use the created Application Insights instance: This involves entering the correct connection string in the Business Central Admin Center so that telemetry data from the tenant is sent to the Application Insights instance.

Verify that telemetry is being collected: After configuring, you would check if the telemetry is arriving as expected by inspecting the Traces table in the Azure Application Insights instance. The 'Traces' table holds the telemetry data, which you can query to verify that the correct signals are being ingested.

In Business Central, when you need to handle the removal of fields and procedures to ensure that other extensions are not affected by these changes, you typically follow a two-step deprecation process. This allows other developers and users to adapt to the changes before they are fully enforced. Here are the steps to handle the removal:

Mark as Obsolete: In the first version where the decision to remove the field or procedure is made, you set the ObsoleteState to Pending and provide an ObsoleteReason. This doesn't remove the feature but indicates to users and developers that it will be removed in the future. This step is crucial for backward compatibility.

Removal: In a subsequent version, after users have had time to adapt to the deprecation warning, you can then remove the field or procedure or set the ObsoleteState to Removed.

Based on these guidelines, here are the three actions you should perform in sequence:

Set the Description field as ObsoleteState = Pending and ObsoleteReason = 'Not in use' in version 2.0.0.0.

Set the Clone procedure as ObsoleteState = Pending and ObsoleteReason = 'Not in use' in version 2.0.0.0.

Remove the Description field from the Issue table in version 2.0.0.1.

These steps will ensure that anyone using the Description field or Clone procedure will receive a warning about the pending deprecation before it is actually removed, thereby minimizing the impact on other extensions and providing a clear path for migration.

When handling the removal of fields and procedures in Microsoft Dynamics 365 Business Central, the process should be carried out in a way that allows other extensions or dependent features to adapt to the changes without causing immediate failures.

Set Obsolete State and Reason for Description Field (Version 2.0.0.0): The first step involves marking the Description field as obsolete by setting the ObsoleteState to 'Pending'. This is a non-breaking change, signaling to other developers and users that the field is planned for removal in a future version. An ObsoleteReason should also be provided to explain why the field is being deprecated.

Set Obsolete State and Reason for Clone Procedure (Version 2.0.0.0): Similarly, the Clone procedure should be marked as obsolete with the ObsoleteState set to 'Pending'. This indicates that the procedure is no longer in use and will be removed in the future. Providing an ObsoleteReason is best practice as it explains the rationale behind the decision.

Remove the Description Field (Version 2.0.0.1): In the subsequent version, after the developers and users have been given time to adapt to the deprecation notice, the Description field can be safely removed from the Issue table. This is considered a breaking change, hence it is done after the field has been marked as obsolete in a previous version.

The reason for not removing the Description field and Clone procedure immediately in version 2.0.0.0 is to avoid causing runtime errors for any extensions or integrations that may depend on these components. By following this sequence, you provide a clear deprecation path that helps maintain the stability of the overall system while evolving the schema.

 Verbosity::Critical: This ensures that the telemetry logs the failure as a critical event.

 DataClassification::CustomerContent: This helps classify the error as related to customer data.

 TelemetryScope::All: This ensures that the error is visible across all relevant telemetry scopes, making it easier to monitor the issue in real-time.

Code Segment Analysis:

The AL code is trying to read JSON data from a response and process it to extract subcontracting order numbers. It uses JsonToken, JsonObject, and JsonArray to work with the JSON data.

JToken.ReadFrom(Data): This line reads the incoming JSON data and converts it into a token. It processes the full JSON body so you can start working with it.

JToken.SelectToken("results"): This line selects the part of the JSON containing the results array. The key "results" is where the JSON response data is expected to be found.

JsonArray: Once the results are extracted, they are stored as an array, and each element in the array (which is expected to contain subcontracting order numbers) is processed.

SubcontractingOrderNo: The extracted order_no from the JSON is stored in this variable.

Breakdown of Steps:

JToken.ReadFrom(Data): This step reads the entire JSON response.

JToken.SelectToken("results"): This step selects the results array from the JSON response.

JArray.AsArray(): This step converts the selected results token into a JSON array that can be iterated over.

GetValueAsText(JToken, 'order_no'): This step retrieves the order_no from each element in the array.

Correct Code Completion:

JToken.ReadFrom(Data): This is the correct method to read the incoming JSON response, as it will convert the string into a JsonToken that can be further processed.

JToken.SelectToken("results"): This is the correct method to extract the results array from the token. This method looks for the key "results" in the JSON and retrieves the relevant array.

Final Code Segment:

al

Copy code

procedure ReadJsonData(Data: text)

var

JToken: JsonToken;

JObject: JsonObject;

JArray: JsonArray;

SubcontractingOrderNo: Code[20];

begin

if Data = '' then

exit;

JToken := JToken.ReadFrom(Data); // Step 1: Read the JSON response data.

JToken := JToken.SelectToken('results'); // Step 2: Select the "results" array.

JArray := JToken.AsArray(); // Convert the token into a JSON array.

foreach JToken in JArray do begin

SubcontractingOrderNo := GetValueAsText(JToken, 'order_no'); // Retrieve the order number.

end;

end;

JToken.ReadFrom(Data): This reads the raw JSON data string and converts it into a JSON token that can be processed.

JToken.SelectToken("results"): This extracts the results array from the JSON data.

JArray.AsArray(): Converts the token into an array so we can iterate over it.

GetValueAsText(JToken, 'order_no'): Extracts the order_no value from each item in the array.

Here is the most logical sequence of actions for implementing the Issue Management module in Business Central and exposing the PostIssue method:

Correct Order:

Create a codeunit named "Issue Management Impl." and set the value of Access property to Internal.

This is the first step because Issue Management Impl. is the implementation layer where the actual business logic resides, and setting it to Internal ensures that it is only accessible from within the module, following best practices in encapsulation.

Create a local procedure named PostIssueImpl in the "Issue Management Impl." codeunit.

This step adds the actual PostIssueImpl method, which contains the core logic of posting an issue.

Create a codeunit named "Issue Management" and set the value of Access property to Public.

After defining the implementation logic, you need to create a public-facing Issue Management codeunit to expose the service externally.

Create a PostIssue procedure in the "Issue Management" codeunit, and in it call the PostIssueImpl method.

Lastly, expose the PostIssue method in the Issue Management codeunit, which will internally call the PostIssueImpl method, completing the chain.

A: In Business Central, wizard pages are created using the NavigatePage type because it allows step-by-step navigation, which is perfect for wizard-like user experiences.

B: The group control organizes the content for each step in the guide, and it’s essential to add these controls to the layout's Content area for each step of the wizard.

C: Worksheet is used for pages designed to handle larger datasets, not for wizard or step-by-step flows.

D: Repeater controls are used for displaying multiple records, not for guiding users through steps, so it’s incorrect for this scenario.

For more information, you can refer to Assisted Setup in Business Central.

To roll back changes to a test method after run time, you should:

Set the TransactionModel attribute to AutoRollback.

To run an approve action on a test page named TestPageA, you should:

Configure TestPageA.Approve.Invoke().

In Business Central's testing framework, the TransactionModel attribute can be set to AutoRollback. This ensures that any changes made during the test are rolled back after the test is complete, leaving the database in its original state.

For running an action on a test page, you would use the 'Invoke' method on the action you wish to perform. In this case, to run an approve action on TestPageA, you would use TestPageA.Approve.Invoke() within your test codeunit. This simulates the user action of approving something on the page.

These actions ensure that the testing environment is properly set up to test specific functionalities without persisting test data and to invoke actions as part of the test scenarios.

In the context of Microsoft Dynamics 365 Business Central, an extension may not appear in the tenant for several reasons, particularly after an upgrade to a new major version.

Option A suggests that the extension was published as a DEV extension, which typically would not cause it to disappear after an upgrade because DEV extensions are intended for development and testing within sandbox environments.

Option B indicates that the extension was not compatible with the new version within 60 days of the first notification. This is a likely reason because Microsoft enforces compatibility rules, and extensions that are not made compatible within the specified timeframe might be removed or disabled.

Option C refers to the extension being published as a PTE (Per-Tenant Extension) and mentions the Platform parameter not being updated. This could cause issues, but not specifically the disappearance of the extension after an upgrade.

Option D expands on Option C by adding that both the Platform and Runtime parameters were not updated in the application file. This is a critical aspect because if these parameters are not correctly set to indicate compatibility with the new version of Business Central, the extension could be disabled or removed.

Option E is similar to Option B but mentions a 90-day period. This option does not align with standard Business Central practices for version compatibility requirements.

Therefore, the two possible reasons for the disappearance of the extension in the tenant after an upgrade are that the extension was not compatible with the new version within the required timeframe (Option B) and that the extension was published as a PTE without the Platform and Runtime parameters being updated (Option D).

StrMenuHandler is used to simulate the selection of an option from a string-based menu, such as the "Ship," "Invoice," or "Ship & Invoice" options when posting a sales order. This handler allows you to programmatically select an option during automated testing.

Other handlers, such as SessionSettingsHandler or SendNotificationHandler, do not simulate the selection of menu choices, which is specifically required in this scenario.

For more details on StrMenuHandler and how it simulates user interaction with menu choices, refer to the Test Handlers in Business Central.

To properly apply the No. Series Design Pattern in the OnInsert() trigger, the correct sequence of actions should be as follows:

ContosoSetup.Get();

First, retrieve the Contoso Setup record using the Get method. This ensures that the necessary setup information is available, including the No. Series.

if "No." = '' then begin

Next, check if the No. field is empty. If it is, a new number from the No. Series should be assigned.

NoSeriesManagement.InitSeries(ContosoSetup."Vendor Nos.", "No. Series", 0D, "No.", "No. Series");

Call the InitSeries function to assign a new number from the No. Series. This initializes the No. Series for the Vendor Nos. field.

ContosoSetup.TestField("Vendor Nos.");

Lastly, ensure that the Vendor Nos. field is populated and valid by calling TestField.

Correct Order for Code Segments:

ContosoSetup.Get();

if "No." = '' then begin

NoSeriesManagement.InitSeries(ContosoSetup."Vendor Nos.", "No. Series", 0D, "No.", "No. Series");

ContosoSetup.TestField("Vendor Nos.");

To create a query that assigns vendors to items in Business Central, use the following code blocks in sequence:

dataitem(Vendor; Vendor)

dataitem(Item; Item)

DataItemLink = "Vendor No." = Item.Vendor_No;

Creating a query:In Business Central, a query object is used to combine data from multiple tables. You start by specifying each table as a data item. In this case, you would start with the Vendor table and then the Item table. After specifying the data items, you need to link them together. The DataItemLink property is used to establish a relationship between two data items based on a common field. Here, you are linking the Vendor and Item tables on the "Vendor No." field, which is present in both tables. This link ensures that the query will return a dataset that includes related records from both tables based on the vendor number. The order of the code blocks ensures the logical flow and relationships between tables as required for the query.

To round up a decimal variable to four decimal places in Microsoft Dynamics 365 Business Central, you should use the Round function with specific parameters. The correct formula is Result := Round(AmountLCY, 0.0001, '=') (B). This function rounds the AmountLCY variable to the nearest value based on the second parameter, which is 0.0001 in this case, representing four decimal places. The third parameter, '=', specifies that the function should round to the nearest value, which effectively rounds up the value when it's halfway between two possible rounded values. This approach ensures that the AmountLCY variable is accurately rounded to four decimal places, which is essential for financial calculations and reporting to maintain precision.

 Subtype: Install

 Trigger: OnInstallAppPerCompany

You are developing a codeunit that should only run during the installation of an extension package.

Options:

Subtype: The correct subtype is Install, as it indicates that the codeunit runs only when the extension is being installed.

Trigger: The correct trigger for running during installation is OnInstallAppPerCompany, which handles code execution when the app is installed for a specific company.

For the given requirements, you should configure the following actions:

For child data items not to be displayed on the request page for some master-detail reports, set the DataItemLinkReference property to the parent data item.

To decrease the amount of time to select key filter fields, specify the RequestFilterHeading property.

In Dynamics 365 Business Central, when customizing report request pages, certain properties can be set to control the behavior and display of the report options:

Hiding Child Data Items:The DataItemLinkReference property is used to link a child data item to a parent data item in the data model of a report. Setting this property correctly will ensure that the child data items are related to the correct parent data item and will be displayed or hidden accordingly on the request page. If the goal is to prevent child data items from being displayed, you need to make sure they are correctly linked and configured to not appear.

Optimizing Filter Field Selection:The RequestFilterHeading property is used to group filter fields on the request page. By specifying this property, you can create a more organized and user-friendly interface, which can significantly speed up the process of selecting filters. This property allows you to categorize filters into headings, making it quicker and easier for users to find and set the necessary filters for the report.

By adjusting these properties on the report request page as part of the per tenant extension customization, you will address the company's requirements to optimize the user experience when running reports.

When creating a page with the PageType property set to RoleCenter in Microsoft Dynamics 365 Business Central, it's essential to organize the functionalities and actions in a manner that enhances user experience and efficiency. The best practice is to define actions in the area (reporting) before actions in the area (creation) (A). This organization allows users to access reporting and analytical features quickly, which are commonly used in Role Centers for overview and insight purposes, before moving on to creation or transactional tasks. This logical flow aligns with typical user workflows, where analysis and review precede the creation of new records or transactions. The other options, such as defining the navigation menu in the area(processing) (B), defining the navigation bar in the area (embedding) (C), or adding a source table on the Role Center page (D), do not directly address the need to add functionalities to the Role Center page in a user-friendly manner.