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

Instructions to use for Incident Date and Status fields:

The correct instruction is "Incident Date" := Workdate(); "Status" := Status::Open;. This ensures that when a new record is created, the Incident Date is set to the current work date, and the Status field is initialized to 'Open'. This is essential for ensuring that the incident data is always timestamped and correctly marked upon creation.

Trigger to introduce the function:

The correct trigger is Trigger OnModify. This trigger ensures that when a record is modified, such as when an update to the status is made (e.g., from Open to Closed), the necessary logic will be executed to handle the update of fields like Incident Date and Status.

Step-by-Step References:

Workdate Function in AL

Triggers in AL

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

For the requirements provided, the appropriate page types should be selected as follows:

Display relevant insights in the Housekeeping Role Center: HeadlinePart

Display the additional information for the Room table: FactBox

Configure the first installation: StandardDialog

Comprehensive Detailed ExplanationIn the context of Microsoft Dynamics 365 Business Central, page types are crucial for determining how information is presented to the user.

HeadlinePart: This page type is designed to display key data and insights in a concise and visually appealing manner, often used in Role Centers to highlight important information. It is suitable for the Housekeeping Role Center to display relevant insights.

FactBox: This page type is used to display supplementary information related to a selected record in the main part of the page. It's often used to show additional details about a record in a list, card, or document page. In this scenario, it is suitable for showing additional information about a specific Room when viewing the Room table.

StandardDialog: This is a page type that provides a modal dialog for user interaction, commonly used for setup wizards, confirmations, and input forms that require user action before proceeding. This is appropriate for configuring the first installation, where a step-by-step guided interaction is necessary.

In Business Central development using AL (the language for Business Central extensions), the use of access modifiers defines how variables and procedures are accessed within and outside of an object or codeunit.

Access Modifiers in AL:

Public: A public variable can be accessed from any object or codeunit within the same module or extension.

Protected: This restricts access to the current object and objects that inherit from the current object. However, in AL (at least in versions used for Business Central), the Protected access modifier is used with methods but not variables.

Internal: This modifier restricts the visibility to the current extension. This means that variables or methods declared as internal can only be accessed from within the same extension. This is appropriate when you want to provide functionality that is shared within the extension but not exposed externally.

Local: This restricts the variable or method to the current object or method where it is declared. It cannot be accessed from anywhere else, even within the same extension.

Scenario Justification:

In the scenario for Contoso, Ltd., IssueTotal is a global variable in the ISSUE BASE extension, and the ISSUE EXT extension needs to access it. Therefore, the variable cannot be declared as Local, because this would restrict access to just the current object (or method).

Using Public would expose the variable outside of the extension, which is unnecessary because you only want other parts of the extension (specifically the ISSUE EXT extension) to have access.

The best choice in this case is Internal because it restricts access to the variable to within the same extension, which includes the base extension and any dependent extensions like ISSUE EXT. It strikes the right balance between visibility and encapsulation.

Microsoft Dynamics 365 Business Central Developer References:

Access Modifiers in AL: Microsoft's documentation on AL provides the details on access modifiers, where it is specified that internal variables can be accessed within the extension, and the public variable is accessible across all extensions【source: Microsoft Learn on AL Programming】.

Best Practices for AL Development: Business Central development best practices suggest keeping variables internal unless they need to be accessed outside of the current extension【source: Microsoft Learn on AL development guidelines】.

ï‚· 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.

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.

To correctly write the code to call the subcontractor's REST API, you would need to set the Authorization header with the base64 encoded username and password for basic authentication. The code segment indicates the use of the Base64Convert codeunit to convert the username and password to base64 format, which is then prefixed with "Basic " to form the proper Authorization header value.

The correct method to add the Authorization header to the RequestHeaders would be:

RequestHeaders.Add('Authorization', 'Basic ' + Base64Convert.ToBase64(Username + ':' + Password));

And the correct method to set the httpContent with the body of the request would be:

httpContent.WriteFrom(Body);

These are the necessary steps to form a well-structured HTTP request for basic authentication and to include the body of the request in the API call.

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).

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 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.

Using InherentPermissions in an event subscriber with the specified syntax could potentially resolve the permission issues related to MyTable, provided that the permissions specified (in this case, 'R' for Read) align with the minimum necessary for the users to perform their tasks. This approach allows the app to grant permissions dynamically based on the context of the event subscriber, which in this case is involved with inserting data into MyTable. By granting Read permission at the event level, it ensures that users have the necessary permissions to interact with MyTable in the context of the operations facilitated by the event subscriber, without needing to alter existing permission sets or grant broader permissions than necessary. This solution adheres to the principle of least privilege by ensuring that permissions are granted only within the narrow scope needed for specific operations, thereby potentially resolving the reported user issues in a secure and controlled manner.

The telemetry trace sends custom signals to an Application Insights resource specified in the extension's app.json file and on the tenant. = YES

Dictionary keys for the extension name and version must be specified to identify the extension during analysis. = YES

The telemetry trace sends events to Application Insights resources set up on the tenant. = YES

Telemetry in Business Central allows developers to collect custom telemetry for extensions using Application Insights. The telemetry trace is used to send custom signals to an Application Insights resource. This resource is typically specified in the app.json file of the extension and must be configured on the tenant where the extension is installed.

The use of dictionary keys for the extension name and version is a best practice to identify the extension during analysis in Application Insights. These keys can be added to the telemetry trace to ensure that when the data is collected, it's clear which extension the data is associated with.

Finally, it is correct that the telemetry trace sends events to Application Insights resources that are set up on the tenant, enabling the collection and analysis of telemetry at the tenant level.

ï‚· B. Include extension translation files with the submission.

AppSource submissions require that the extension be localized to different languages, and including translation files is part of the requirement.

ï‚· C. Ensure the app file is digitally signed.

Digitally signing the app file is a security requirement for AppSource submissions to ensure the integrity and authenticity of the app.

ï‚· E. Use data classification on all tables and extension fields.

Microsoft requires that all data, especially personal data, be classified using the data classification feature to comply with GDPR and other data privacy regulations.

To hide the field "Unit Price" from the Resource Card page in Microsoft Dynamics 365 Business Central, you need to modify the visibility property of the field using the modify keyword, which allows you to change the properties of an existing field on a page.

modify("Unit Price") is the correct way to target an existing field on a page (like the Resource Card page).

The line Visible = false; makes the field invisible on the page.

Here's a breakdown of why each option is right or wrong:

Option A:

Uses addlast("Unit Price"), which is incorrect because you are not adding a new field; you're modifying an existing one. Also, Visible = false is correct for hiding a field, but the wrong method (addlast) is used.

Option B:

Uses modify("Unit Price") with Enabled = false;. This would disable the field (make it non-editable), not hide it. The field would still be visible, so this does not meet the requirement.

Option C:

Uses addlast("Unit Price"), which is incorrect, and Enabled = false;, which would disable the field, not hide it.

Option D:

modify("Unit Price") { Visible = false; } is the correct syntax for hiding the field on the page.

Correct Code Snippet:

modify("Unit Price")

{

Visible = false;

}

This hides the "Unit Price" field from the Resource Card page.

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.");

Handler methods are used in tests to simulate user interactions, such as responding to dialogs, confirmation messages, or option selections. Since you need to simulate the user interaction of selecting a posting option (Ship, Invoice, Ship & Invoice), a Handler method would be the appropriate choice for capturing this kind of user input.

Normal attribute and Test attribute are used for marking methods for test execution, but they do not simulate user interaction, making Handler method the correct answer.

For more details, see the Microsoft Docs on Test Codeunits and Handler Methods.

When developing an app for Microsoft AppSource, it is essential to use an object range that is specifically designated by Microsoft to avoid conflicts with other apps and the base application. The correct object range to use is:

An object range within the range of 70000000 to 74999999 that is requested from Microsoft (D): This range is reserved for AppSource apps. Developers need to request this range from Microsoft to ensure that the objects used in their extension do not conflict with those used by other extensions or by the base application. Using this reserved range helps maintain the integrity and compatibility of extensions published on AppSource.

It's important to note that the other ranges mentioned (A, B, C, and E) are not suitable for apps intended for AppSource. Ranges 50000 to 59999 and 50000 to 99999 are typically reserved for per-tenant customizations or partner solutions, not for distribution on AppSource. The standard range 1 to 49999 is reserved for the base application objects, and using an object range divided by countries (C) is not a standard practice for AppSource apps.

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.