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

When exporting data from Business Central and the requirement is for the data to be in a non-fixed length and width CSV format, the Format property of the XMLport should be set to VariableText (B). The VariableText format is designed for handling data exports where the fields are separated by a delimiter, such as a comma or tab, which is typical of CSV (Comma-Separated Values) files. This format allows for the flexibility needed when dealing with varying field lengths, as it does not enforce a fixed width for each field, making it ideal for CSV data exports. Setting the Format property to FixedText (C) would enforce a fixed width for each field, which is not suitable for CSV files, while the XML format (A) is used for exporting data in an XML structure, which is different from the CSV format requirements.

To enable debugging in an extension and allow the source code to be viewed, the allowDebugging property should be specified in the app.json file (C). The app.json file serves as the manifest for an AL project in Microsoft Dynamics 365 Business Central, defining the project's properties, dependencies, and features. By setting the allowDebugging property to true in this file, developers enable the debugging of the extension's source code, facilitating troubleshooting and development. This is essential for analyzing the behavior of the extension and identifying issues during the development process.

To ensure that the values inserted on the Request page of a Business Central report are saved for the next time the report is run, the SaveValues property (D) should be set to true. This property is available on the Request page of the report and, when set to true, allows the system to remember the values entered by the user, so they do not have to re-enter them each time they run the report. This feature enhances user experience by reducing repetitive data entry and ensuring consistency in report parameters across multiple executions. The other options mentioned, such as setting the Transaction Type property to Update (A) or declaring a Savevalues variable in the OnOpenPage trigger (B), are not directly related to saving user input on a report's Request page.

Specify the value of the post options as Invoice:

Test

Perform calculations and values checking:

Handler

In the context of Microsoft Dynamics 365 Business Central testing, the 'Test' attribute is used to mark a method as a test method. This is where you would specify the action or the behavior you're testing – in this case, setting the post options as Invoice. It's within these test methods that you would simulate setting the posting option to "Invoice" programmatically.

For performing calculations and checking values, you would use 'Handler' methods to handle specific business events or conditions that occur within the system, such as before or after posting a document. These handlers can ensure that calculations are done correctly and that all validation checks pass before the document is posted.

The 'Normal' method would be a standard method that could be involved in the posting process, ensuring that all business logic is correctly applied and that the calculations and value checks are as expected.

In a test codeunit, you would typically have test methods that call these handler and normal methods to verify the business logic in various scenarios, such as posting with different options or checking the results of calculations under different conditions.

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

Statements:

Replace line 16 with ResponseText := ResponseMessage

Answer: NoThe correct way to handle the response is to use ReadAs or similar methods to read the content from the response, not just assign the ResponseMessage directly to ResponseText. Hence, this statement is incorrect.

In line 13, change the 'text/plain' value to 'application/json'

Answer: YesSince the procedure is expected to send a POST request with JSON content, changing the content type to 'application/json' is correct. This ensures that the server understands the content is in JSON format.

Replace line 14 with Client.DefaultRequestHeaders.Add('Authorization', 'Bearer ' + Token);

Answer: NoIn AL, the authorization headers are managed through HttpHeaders, and the Client.DefaultRequestHeaders method is not available in AL. Therefore, this statement is incorrect.

In line 10, replace WriteFrom with ReadAs

Answer: NoWriteFrom is the correct method for sending the request content, as it writes data from the RequestText variable to the HttpContent. ReadAs is used for reading the response, not for writing the request content.

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

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.

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

In the context provided by the case study, when calling an API action from a mobile application, the correct format for a POST request to an action in Business Central typically involves specifying the entity (/issues), the ID of the entity (88122e0e-5796-ec11-bb87-000d3a392eb5), and the action to be called (/Copy). The action name should match the exact name as defined in the AL code, which is case-sensitive.

Option A is incorrect because it uses a non-standard format for the action call.

Option B uses the PATCH method, which is generally used for update operations, not for calling actions.

Option C is correct as it uses the POST method, which is appropriate for calling actions, and correctly specifies the entity, ID, and action name.

Option D is incorrect because the action name /copy is in lowercase, while AL is case-sensitive, and it should match the case exactly as defined in the code.

Option E incorrectly adds 'MicrosoftNAV' before the action name, which is not standard for calling actions in Business Central APIs.

Hence, the correct action to use when calling the Issue API action from the mobile application is given in Option C.

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.

API Publishing for Extensions:

In Business Central, when creating custom APIs like RoomsAPI, it is important to ensure that they are automatically published during the installation or upgrade of the extension.

To achieve this, you can include a codeunit of type Install in the extension that explicitly publishes the custom API (RoomsAPI) as a web service. This ensures that it is available for use immediately after the extension is deployed without requiring manual intervention.

Codeunit Type:

A codeunit of type Install runs when the extension is installed or upgraded. This type of codeunit can be used to perform setup tasks such as publishing web services or APIs like RoomsAPI.

Why Not Other Options?

Option A (default API configuration): This would not automatically publish the RoomsAPI. Default APIs do not cover custom APIs.

Option B (enable APIs for the environment): Enabling APIs in Business Central allows the standard APIs to be used, but custom APIs still need to be manually published.

Option C (publish via Web Services page): This would work but requires manual intervention to publish RoomsAPI, which does not fulfill the requirement of automatic publishing during installation.

Reference Documentation:

Publishing APIs in Extensions

Codeunit Types in Business Central

codeunit 52102 "POS API Management"

{

Access = Public;

Permissions = TableData "POS Information" = rwdx;

trigger OnRun()

begin

readAPI();

end;

procedure readAPI()

begin

// Your code here to read from the POS API

end;

}

Table Structure in Business Central: When creating entities such as "non-conformity" entities in Business Central, you use document tables to represent entities that have a header and line structure. In this case, the non-conformity entity has:

A header with common information (Non-conformity Number, Date, Vendor No., etc.).

One or more lines representing the detailed information for each non-conforming item.

Document Table Usage:

Document Table: A document table is the correct table type for scenarios where you have a header (with general information like vendor details) and lines (with detailed, item-specific information).

Document tables are typically used for entities such as Sales Orders, Purchase Orders, or any other transactional data where you have both header and line information.

Supplemental Table (Option C):

Supplemental tables are usually used to add supplementary information to existing data in Business Central. In this case, we need to store detailed line information, which is a core part of the entity rather than supplementary data, so a supplemental table would not be appropriate here.

Document History Table (Option A):

Document history tables are used to track changes and historical data for entities but are not suitable for the main introduction of the entity and its lines. This option is also not appropriate.

Reference Documentation:

Introduction to Business Central Tables

Document Tables in Business Central

ï‚· Design pattern for the setup table:

The correct selection here is Adapter. The Adapter design pattern is commonly used when you need to handle integration points or create a setup table that acts as an intermediary for data manipulation, which fits the requirement for the configuration of the non-conformity functionality.

ï‚· Data type of the primary key field:

The correct data type is Code. In Business Central, when creating a table with a primary key field, the Code data type is typically used for fields such as document numbers, codes, and identifiers. For a setup table, a Code field is appropriate for keys like "No." series or setup identifiers.

ï‚· Property required to prevent users from adding records:

The correct property is InitValue. This property is used to set initial values for fields and can be configured in such a way that users are prevented from adding records directly, typically enforcing control over record creation and editing in configuration scenarios.

var

TempBlob: Codeunit "Temp Blob";

IncidentOutStream: OutStream;

IncidentInStream: InStream;

ImageFilter, FileName: Text;

begin

// Initialize the TempBlob and streams

TempBlob.CreateOutStream(IncidentOutStream);

Rec.Image.ExportStream(IncidentOutStream); // 'Rec' refers to the current Room Incident record

TempBlob.CreateInStream(IncidentInStream);

// Set the filters and filename for the image

ImageFilter := 'Image Files (*.bmp,*.jpg,*.jpeg,*.gif)|*.bmp;*.jpg;*.jpeg;*.gif';

FileName := 'Customer Picture';

// Prompt the user to download the image

if not DownloadFromStream(IncidentInStream, '', 'Download Incident Picture', '', ImageFilter, FileName) then

Error('Unable to download the image.');

end;

In Business Central, fields in tables are assigned specific data types that determine the kind of data they can store. For the Non-conformity table mentioned in the case study, the following data types should be used:

Date for the Non-Conformity Date field: This is because the Non-conformity Date field is required to store only the date when the non-conformity was recorded. The Date data type is appropriate for storing dates without times.

Code for the Non-Conformity Number field: The Non-conformity Number field is described to use alphanumeric values with a format that includes "NC" and the year, like "NC24-001". In Business Central, the Code data type is used for fields that store alphanumeric keys. It is a text field with a limited length, which makes it suitable for number series that contain letters and numbers.

Other options are not suitable:

A. Integer for the Non-conformity Number field: This would not be appropriate because the Non-conformity Number includes alphanumeric characters and not just integers.

B. DateTime for the Non-Conformity Date field: This is not correct because there is no requirement to store the time alongside the date.

C. Char for the Non-Conformity Number field: Char data type is not typically used in Business Central for number series or identifiers. The Code data type is preferred for this purpose.

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.

Read Scale-Out:

Read scale-out is a feature in Business Central that allows you to improve performance by distributing read-only queries (such as the ones from the ticketAPI) across multiple read replicas in the cloud database. This reduces the load on the primary database and helps improve the response time for read-intensive operations, like analyzing POS data through the ticketAPI.

Data Access Intent - ReadOnly:

When enabling read scale-out, you can configure the DataAccessIntent property of APIs to be ReadOnly. This directs the system to use read replicas to handle read-only queries, which enhances performance by offloading such queries from the primary database.

Why Not Other Options?

Option A (ODataReadonlyGetEnabled): This parameter is unrelated to read scale-out and primarily affects OData services behavior, not API performance tuning.

Option B (AccessByPermission): Setting the permission to Read does not directly affect the performance. It only controls access based on user permissions.

Option D (DataAccessIntent ReadOnly): While setting this property to ReadOnly helps in read-only operations, enabling read scale-out (option C) ensures the underlying infrastructure is optimized to handle such read operations, which is the fundamental action required.

Reference Documentation:

Read Scale-Out in Business Central

Data Access Intent in AL

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