Microsoft MB-820 Dumps

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.

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

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

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

To make the permission set visible on the Permission Sets page, perform the following actions in sequence:

Change the Assignable property value to true.

Add the ObsoleteState = No property.

Publish the app with the permission set to an environment.

Process for making permission sets visible:

In Business Central, the Assignable property determines whether a permission set is shown in the user interface for assigning to users. By default, if Assignable is set to false, the permission set is hidden. Therefore, it should be set to true to make the permission set visible.

The ObsoleteState property indicates whether an object is outdated (Obsolete) or not (No). If an object is marked as obsolete, it is typically hidden from the user interface. Therefore, setting ObsoleteState = No ensures that the permission set is not treated as outdated and remains visible.

Finally, publishing the app with the permission set to an environment updates the environment with the new or modified objects, including permission sets, making them available for assignment to users.

Permission sets control access to objects (such as pages, tables, reports) in Business Central. By creating a new permission set that specifically excludes the critical table (or page) and assigning this permission set to the users in Department A, you can prevent them from accessing the page.

Option A (creating a different role center page) is incorrect because role centers control the user interface, but do not directly restrict access to specific pages or tables.

Option B and Option C (extending the base application permission set) are not the best options because extending permission sets typically involves adding permissions, not removing access. The question requires restricting access to a critical page, so simply including or excluding permission sets won’t solve the issue at the table or page level.

Option D (creating an entitlement object) is not relevant here, as entitlements are used in more complex licensing scenarios or environments.

Summary:

Creating a permission set object that specifically excludes access to the critical table or page and assigning it to the users will solve the problem effectively.

SaveAsCsv is the correct function to export the query data to a CSV (Comma-Separated Values) file, which is a commonly used text format for data exports.

SaveAsExcel would export to an Excel file, SaveAsWord to a Word document, and SaveAsHtml to an HTML file, but since the requirement is to export to a file and the question doesn't specify any particular file format other than what fits standard data exports, CSV is the most fitting and efficient format for this scenario.

For more information, see the Query Object Functions in Business Central.

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

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.

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

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.

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.

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

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.

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;

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

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.

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.

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

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;

}

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

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