Free and Premium Microsoft MB-820 Dumps Questions Answers

ou plan to call a web service using HttpClient from a Business Central AL extension. The web service must authenticate using a certificate that includes a password, and the password must be hidden during debugging.

Options Explanation:

The question asks for the correct implementation where the certificate and password are provided and where the password is hidden when debugging.

SecretText is a special data type in Business Central that hides sensitive data (like passwords) during debugging.

 Add Clear(PurchaseLine); as a line before line 01 of the code: No

 Add PurchaseLine.SetFilter("Line No."; '>0') as a line after line 06: Yes

 Change the filter on line 06 from a "No." field to a "Document No." field: No

 Remove "not" in line 07: No

 Add Clear(PurchaseLine); as a line before line 01 of the code.

No

You do not need to clear the PurchaseLine record before running the query, because the SetRange filters will take care of setting the correct context.

 Add PurchaseLine.SetFilter("Line No."; '>0') as a line after line 06.

Yes

Adding a SetFilter on the "Line No." field ensures that you're checking for actual purchase lines greater than 0, which are valid lines. This would fix the issue where the check might return false even when lines exist.

 Change the filter on line 06 from a "No." field to a "Document No." field.

No

The filter on the No. field is correct, as it's filtering based on the purchase order number. Changing this to Document No. is unnecessary.

 Remove "not" in line 07.

No

The not in line 07 is necessary because IsEmpty() returns true when no lines are found. To correctly return a boolean indicating whether the purchase order has lines, you need to negate the result of IsEmpty().

When updating the base application table using a table extension in Microsoft Dynamics 365 Business Central, certain properties of table fields can be modified to meet new requirements, such as regulatory changes. The DecimalPlaces property (B) is one such property that can be adjusted in a table extension. This property determines the number of decimal places that are displayed and stored for decimal fields in the table. Adjusting the DecimalPlaces property can be particularly useful when dealing with financial data and tax calculations that require precision to meet new tax tiers set by a regulator. It's important to note that not all properties can be modified in a table extension; for example, the CalcFormula property (A) cannot be changed as it affects how the field's value is calculated, which could have significant implications on the base application's logic.

To create the Approver field in the Item table using an AL extension, perform the following actions in sequence:

Create an enum object named Approver and include all options.

Create a table extension object for an Item table with an Approver field of enum type named Approver in the fields section.

Create a page extension object that extends the Item Card object. Add the field to the fields section.

Build and extend tables:

To add a new field to an existing table in Business Central using AL extension, you need to define an enumeration (enum) with the possible values for the new field. Then, you create a table extension object where you add the new field and specify its type as the enum you created. This adds the field to the Item table. Finally, you modify the user interface to display the new field by creating a page extension for the Item Card page and adding the new field to it.

 No AL command in User Settings:

The correct solution is to Install the AL Language extension.

This issue arises when the AL Language extension is not installed in Visual Studio Code, which is required to work with AL projects in Business Central.

 Error in the Problems tab:

The correct solution is to Download Symbols.

This error typically occurs when the symbols (metadata for pages, tables, etc.) are not downloaded, and Visual Studio Code cannot resolve the reference to the Customer List page. Downloading symbols should fix the problem.

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.

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 property InherentPermissions is used to automatically grant permissions to the table object it is applied to, but setting it to Rl (which seems to be a typo and should likely be 'RL' for Read and Insert permissions) is not sufficient in this scenario. The issues reported by the users suggest that they need more than just read and insert permissions on MyTable. Since users are unable to post sales orders, they likely need Modify, Delete, or Execute permissions on certain tables or objects related to the sales order process. Additionally, the inability to access the list page created in MyTable could be due to lacking Read permissions on other related objects or pages. Therefore, merely setting InherentPermissions = RL on MyTable does not comprehensively address the users' permission issues, especially when considering the principle of least privilege. A more tailored approach to permissions, potentially involving adjustments to the app's code or configuration to ensure proper permissions are applied where necessary, would be needed.

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

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

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

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

The task is to identify unwanted incoming web service calls during the last seven days. To do this, we need to look at KQL (Kusto Query Language) queries that would filter out web service calls based on the timestamp (to ensure the calls are within the last seven days) and by certain characteristics that would indicate they are unwanted, such as the wrong type of protocol (SOAP in this case, as Contoso Ltd. plans to dismiss using it).

Looking at the options:

Option A: This query selects all traces where the timestamp is within the last 7 days and where the custom dimension has a value of 'RT0008', and where the category is either 'ODataV4', 'ODataV3', or 'Api'. This query would show all API calls except SOAP, so it does not directly answer the question about unwanted calls.

Option B: This query filters for traces with a timestamp within the last 7 days, where 'RT0008' is present, and specifically looks for the category 'SOAP'. This query is correct because it directly targets SOAP calls, which are the unwanted calls according to Contoso Ltd.'s plans.

Option C: Similar to option B, this query filters for traces within the last 7 days and looks for 'RT0008' but uses the equality operator for the category 'SOAP'. This would also correctly return the unwanted SOAP calls.

Option D: This query also filters for traces within the last 7 days, but it excludes the 'ODataV4' category, which doesn't necessarily target the unwanted SOAP calls.

Option E: This query selects traces where the timestamp is within the last 7 days and the custom dimension has 'RT0008'. However, it filters out categories 'ODataV4' and 'Api', which does not directly help in identifying the unwanted SOAP calls.

Therefore, the queries that should be used to determine if there are unwanted incoming web service calls (SOAP calls) in the tenant during the last seven days are Options B and C. These queries are specific to identifying SOAP protocol usage, which is what Contoso Ltd. considers unwanted.

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.

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

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;

}

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;

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.

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

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

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