MB-820 Questions and Answers

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.

https://learn.microsoft.com/en-us/dynamics365/business-central/dev-itpro/developer/properties/devenv-dataaccessintent-property

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.

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

LogMessage('PT001', 'Business Process is failed.', Verbosity::Critical, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, CustDimension);

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

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;

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

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

Runs when the report is loaded: OnInitReport

Runs when the data item has been iterated for the last time: OnPostDataItem

Use this function to skip the rest of the report: CurrReport.Quit()

1. Requirement: Runs when the report is loaded.

Selection: OnInitReport

Reasoning: The OnInitReport trigger is the very first event that fires when the report object is instantiated (loaded). It runs before the request page is displayed, making it the correct choice for "when the report is loaded."

Contrast: OnPreReport runs after the request page, just before the data processing starts.

2. Requirement: Runs when the data item has been iterated for the last time.

Selection: OnPostDataItem

Reasoning: The OnPostDataItem trigger executes immediately after the report has finished iterating through all records belonging to that specific data item.

Contrast: OnPreDataItem runs before the loop starts, and OnAfterGetRecord runs repeatedly during the loop (for every record).

3. Requirement: Use this function to skip the rest of the report.

Selection: CurrReport.Quit()

Reasoning: The CurrReport.Quit() function completely aborts the execution of the report, effectively "skipping" everything else remaining in the report logic.

Contrast: CurrReport.Skip() only skips the current record processing and moves to the next record. CurrReport.Break() exits the current data item loop but proceeds to the next data item (if any) or finishes the report normally.

This event occurs before posting a sales document.

PreviewMode is available in the parameters, which allows checking whether the process is being run in preview mode.

This event is typically used for sales order posting and can be used for both shipping and invoicing.

This event matches the requirements because:

You can check if PreviewMode is false.

It can run for both shipping and invoicing.

 Direction: Both

 Format: VariableText

You are configuring an XMLport for Business Central with the following requirements:

Specifies import or export on the Request page at runtime.

Formats the data in a non-fixed length CSV format.

XMLport Configuration:

Specifies import or export on the Request page at runtime.The Direction property must be set to Both.

This allows the XMLport to both import and export data depending on user selection during runtime.

Formats the data in a non-fixed length CSV format.The Format property must be set to VariableText.

VariableText is used for delimited text formats like CSV, which do not have a fixed length for fields.

In line 13, replace the Add method with Insert. = NO

In line 15, replace the WriteTo method with ReadFrom. = NO

Change the ItemObject variable type from JsonObject to JsonToken. = NO

Move line 08 in the beginning of REPEAT .. UNTIL. = YES

The provided code is intended to serialize a list of items from the Item table into a JSON array format. Here is a breakdown of the code and the necessary corrections:

In line 13, "ItemsArray.Add(ItemObject)": This line is correctly using the Add method to add the ItemObject to the ItemsArray. The Add method is the correct method to use for adding items to a JsonArray. Therefore, there is no need to replace Add with Insert.

In line 15, "ItemsArray.WriteTo(RequestText)": The WriteTo method is used correctly to serialize the ItemsArray into a JSON formatted string and store it in the RequestText variable. The ReadFrom method is used for the opposite operation, i.e., to deserialize a JSON formatted string into a JsonArray, which is not the goal in this context. Hence, no change is needed here.

Change the ItemObject variable type from JsonObject to JsonToken: The ItemObject variable is intended to hold JSON objects representing individual items, making JsonObject the appropriate type. JsonToken is not a type used in this context within AL for Business Central, and thus the variable type should remain as JsonObject.

Move line 08, "Clear(ItemObject)": This line should be moved inside the repeat loop to ensure that the ItemObject is cleared for each item in the loop. Placing it before the repeat would only clear it once before the loop starts, which could lead to incorrect serialization as the previous item's properties would not be cleared from the ItemObject.

The logic for serializing records into JSON is a common operation when interfacing with APIs or web services in Business Central, and the pattern shown in the code is typical for such operations.

 The Part Time Shop Supervisor profile will be applied only to users with "Register Time" = true on User Setup: No

 Variables, procedures, and triggers cannot be added on page customization objects: Yes

 Line 10 should use extends instead of customizes: No

 In line 18, "Unit Cost" will be moved after "Costing Method": Yes

 The Part Time Shop Supervisor profile will be applied only to users with "Register Time" = true on User Setup.

No

The code doesn't contain any reference to the User Setup table or the Register Time field, so this is not correct. Profiles are not applied conditionally based on fields like this.

 Variables, procedures, and triggers cannot be added on page customization objects.

Yes

Page customization objects are meant for UI modifications, such as moving or hiding fields. You cannot add variables, procedures, or triggers in a page customization object.

 Line 10 should use extends instead of customizes.

No

In AL, when customizing a page within a profile, you use customizes rather than extends. Extends is used when modifying base application objects, but customizes is used to customize pages within a profile.

 In line 18, "Unit Cost" will be moved after "Costing Method".

Yes

The code in line 18 is correct. The moveafter directive will move the "Unit Cost" field after the "Costing Method" field on the page layout.

Enclose line 08 into BEGIN .. END = NO

Add TopCustomerOverview.Open(); before = YES

TopCustomerOverview.SetFilter(Sales_LCY, '>10000'); in line 06.

Add TopCustomerOverview.Open(); after TopCustomerOverview.SetFilter(Sales_LCY, '>10000'); in line 06. = YES

Replace SetFilter in line 06 with SetRange. = NO

The code provided has a runtime error because the query TopCustomerOverview must be opened before it can be read from. Therefore, TopCustomerOverview.Open(); should be added before trying to read from the query, which is not present in the code.

Enclosing line 08 into a BEGIN .. END block is unnecessary because it is a single statement, and AL does not require a BEGIN .. END block for single statements within trigger or procedure bodies.

TopCustomerOverview.SetFilter(Sales_LCY, '>10000'); is a correct method to set a filter for the query, and using SetRange instead is not necessary unless the requirement is specifically to set a range of values, which is not indicated in the procedure's description.

In summary, for the procedure to run correctly, the query must be opened after setting the filter and before attempting to read from it. The SetFilter method is correct for the intended operation, and there's no requirement to use SetRange or to enclose the Message call in a BEGIN .. END block.