NAV 2017: Wizard pages now supported in Web Client

Standard

As of October 2016, NAV 2017 is the latest version of the popular ERP system. To complement the brand new features, NAV team worked on enhancing current features.

A list of the features not supported in NAV 2016 is located here.  Among them, NavigatePage was not supported in NAV 2016 Web Client, but it is now supported in NAV 2017 Web Client.

Let’s delve into creating a simple (yet fit for starting your own) NavigatePage and check it in the Web Client. Additionally, I will suggest a few cases when a NavigatePage is a good candidate to collect data from users and perform some processing in one screen.

The NavigatePage assumes the existence of the following objects (included in the demo):

  • Table 90001 “Generic Entity” with the following fields:
    • field_1 (Code10)
    • field_2(Code10)
    • field_3(Code10)

PK: field_1,field_2,field_3

  • Table 90002 “Generic Entity Comment” with the following fields:
    • field_1 (Code10)
    • field_2(Code10)
    • field_3(Code10)
    • Entry No.(integer)
    • Comment(Text80)

PK: field_1,field_2,field_3,Entry No.

  • Page 90001 “Generic Entity Card”
    • An action to launch the NavigatePage will be located on this page

NavigatePage details:

navigatepage

And the actions:

navigatepageactions

Note: To make the actions appear as buttons on the toolbar and the groups as tabs set each action’s InFooterBar property to Yes.

This simple NavigatePage will collect data(the comment) from the user in Step1 and when the user clicks Next will insert a comment and make visible Step2.

When user clicks Next, the system will:

  • validate the fields in Step1
  • Hide the fields in Step1 group
  • Perform Wizard action (generate the comment)
  • Show Step2 group

When the user clicks on Finish the page closes.

A few snapshots of the NavigatePage as it appears on the Web Client:

genericentitycardpage

Launching Comment – Wizard action:

genericentitycommentwizzard

Click on Next will move the wizard into Step 2:

wizzardsummarystep

Standard NAV has a few NavigatePage pages. Check them out:

  • 5077 -> Create Interact
  • 5097 -> Create To-do
  • 5126 -> Create opportunity

If you have processes in which the users need to go through a few pages to enter data and create different entities, then NavigatePages are a great candidate for improving user efficiency and experience.

I used recently NavigatePages in two instances. Once, when I needed an unified screen to allow users to attach files (word docs, excel files, pdfs) in a Property Management AddOn. The documents were collected and attached to an email sent to the owner at month-end.

Another example was more recent when, with one NavigatePage, I was able to create records similar to a fixed asset, collect mandatory data for a purchase invoice and generate the purchase invoice for that record. Of course you need methods that will take care of generating the purchase invoice, its lines, general ledgers, vendor ledgers, dimensions. Moreover, assertiveness is needed to not end up with half-performed processes … But it’s possible to run your processes through a wizard page with an overall improved user experience and efficiency.

Sample code available here.

NAV Upgrade Notes – Turning Comments into Notes using .NET

Standard

Upgrading a NAV AddOn is not solely merging code and upgrading the database through all NAV versions in between source and target. It involves analysis and prototyping of present AddOn features into features existent in the latest NAV versions. We often ask ourselves how can we replace feature X in our AddOn hosted on a NAV 2009 installation with the new feature Y in NAV 2017?

Sometimes the answer is Yes: we can merge AddOn functionality with existent features in standard. The benefit is major.

Take Comment Line table for example. Almost any AddOn has a storage place for AddOn entities to record comments or notes.

Why keep them recorded in a table in ISV’s range when we could take advantage of an existent standard table perfect for this purpose? Table Record Link was introduced in NAV 2013 and can keep track of notes and links.

The short demo below assumes the existence of:

  • a table “Generic Entity”
  • a table “Generic Entity Comment”
  • a card page “Generic Entity Card”
  • a list page “Generic Entity Comments”
  •  codeunit “Upgrade Notes 1”

To generate notes for each comment in table “Generic Entity Comment” run the codeunit 90003″Upgrade Note 1″.

The text itself resides in a Text field in “Generic Entity Comment”, but “Record Link” table has a BLOB field for recording the text. Therefore I needed to move text from “Generic Entity Comment”Comment field into a BLOB field in “Record Link”.

text2blob

I wanted to use .NET here not only for exercising my rusty .NET muscles, but recording Danish characters in a BLOB proved to be a non-trivial job. So I used MemoryStream class with BinaryWriter which comes equipped with character encoding capabilities.

For a simple demo follow steps 1-4 below:

capture

Code used is available for download here.

Building a NAV server performance baseline using Logman and Perfmon Windows utilities

Standard

More and more NAV servers are being deployed to the cloud, yet a large number of NAV customers are keeping their NAV installations on premise (either on a physical server or a VM). Those that choose cloud(and if you didn’t please read this) get the benefit of cloud specific tools for measuring the hardware and database performance.

Unless you have a specialized tool, to monitor the performance of your server you need to establish a baseline. During server’s deployment, administrators can  still tweak (especially if it’s a VM or part of a hyper-v infrastructure) the server hardware until the server reaches a satisfactory performance level.

Regular recordings of server’s performance can uncover problems in their early stages, sometimes long before they become obvious in production.

Windows Server 2008 and later server versions as well as Windows 8/8.1/10 come with two easy to use tools for measuring (and scheduling) the performance of the system: perfmon and logman.

With perfmon we get a graphical interface in which we can manually create our alerts or counters, run them and analyze the results.

With logman we can manage the counters from command line.

On my system I created two counters, one for measuring SQL server counters, the other was targeted at the hardware performance:perfmon

Double-clicking on HardwareBaseline we can manage the counters:

hardware

To create these two counters I ran the following script:

install-counters

To start and stop the counters, run:

start-counters

Or manually, in Performance Monitor, right click on the counter and choose Start or Stop.

A few “logman” command switches I use:

-b and -e switches to allow the performance counters to run in a specific time period.

-v switch to add a timestamp for when the output file is created

-f specifies the file format used for collecting data

After a few minutes the performance counters graph will look like this:

graph

With a Task Scheduler entry you can control when to start and stop the performance counters collection.

As for the analysis of collected data, there are lots of places online where you can find valuable information on counter’s results interpretation.

Download the package with hardware and SQL counters and  a sample script from here.

A  baseline case study

One of the processes that is pressing all resources on a NAV server instance in our solution is the running of a report that posts sales invoices for all customers for a specific Due Date. I’ll run the report and record and discuss the counters recorded.

With the installation of MS Dynamics server you get out of the box a few counters NAV specific:

nav-specific-counters I created a new data collector with the following counters:

my-nav-counters

In Performance Monitor right click on your new Data Collector Set and Start.

Next I went to RTC and ran the report.

After the report finished I came back to Performance monitor and stopped the Data Collector Set.

reporton-counters

Microsoft Dynamics NAV\.NET CLR\% Time  in GC:

If RAM is insufficient for MS Dynamics NAV Server instance, you might see a spike in the “% Time in GC” – which measures the .NET memory garbage collection activity. My process shows a maximum of 7% nd an average of a bit over 2%  – numbers that do not show that NAV is looking for more RAM.

Microsoft Dynamics NAV\% Primary key cache hit rate:

This counter should be above 90% – otherwise your cache might be too small because either your cache settings are set too low or the cache is shared between tenants and might need to be increased. I my case is above 99%:

cachehits

% Calculated fields cache hit rate  averages 63% which means that in 63% of the cases when we launched a CALCFIELDS command we hit the cache – decent number!

calcfieldsjpg

# Open Connections is 5, and refers to the number of open connections made from the service tier to the database hosted on SQL Server. You might be interested in the counter “# Active Sessions” which keeps track of the number of concurrent connections  the service tier manages.

openconn

The rest of the counters give numbers of rows, which might or might not be too relevant considering that in time the number of rows increases.

Having a baseline and comparing regular performance counters log against it, is not just a proactive measure in order to keep a NAV server healthy. It is fairly easy to use and cheap (logman and perfmon are both builtin Windows), qualities that appeal to NAV customers and Dynamics VARs.

 

 

 

 

An asynchronous processing solution for MS Dynamics NAV

Standard

From the earliest to the newest NAV versions, long-running tasks are usually accompanied by a progress bar or windows with multiple progress bars. It’s developer’s preferred choice to inform the user with the progress of the launched task – an obvious choice to an hourglass cursor. There are plenty of business processes in any NAV database that do heavy processing. If we look into a posting task, NAV generates Add-On specific ledger entries, standard specific ledger entries, creates invoices and lines, adjacent records and so on. Therefore these tasks  can take a while and can keep the user session busy.

asyncThis blog is about a solution, my boss and I designed and used it on a few target processes, to allow users to immediately regain control of their session after the launch of a long-running task, while assigning the processing to a NAV background session. The results of the processing are recorded and easily retrievable by the calling page automatically by using PingPong Control AddIn.

PingPong info: msdnGunnar’s and Olof Simren ‘s blog.

How does our solution get implemented?

A table with entities to be processed named in the code sample “Generic Entity”. At the minimum the table should have PK fields. Our sample has three fields that are part of the PK: Field_1, Field_2, Field_3.

asynchronous-processing-in-nav

A card page for “Generic Entity” table named “Generic Entity Card” whose only action will launch the async process.

A factbox “Queue Summary Factbox” used on the “Generic Entity Card” to reflect the status of the last queued record processed. The status gets updated by using a PingPong Control AddIn.

A new table “Processing Queue”. At the minimum add enough fields to be able to locate later the record(“Generic Entity”) that launched the process. Additionally, an Option field, “Status” with at least 4 values: Queued, Processing, Error and Success and a Text field “Error Message” to record the errors that prevented the process to finish successfully.

A new codeunit “Process Queue” (whose Rec is “Posting Queue” ). In the Run function of this codeunit wrap the processing in a TryFunction to be able to rollback if errors are encountered.

If wanted you can add more fields to the “Processing Queue”. In our environment we have “Document No.” of the resulting Posted Sales Invoice and “Elapsed Time” to record the duration of the task. You could also enable Lookup on the factbox field to open a list page for Processing Queue table.

If you want to try our solution download it from here.

NAV 2016 – Applying a new NAV Cumulative Update using Powershell cmdlets

Standard

I’ve done a few C/AL code merging for Dynamics NAV in the past, and while I don’t mind working with BeyondCompare for a few hours every now and then, the task is repetitive and prone to errors so I was searching for a cleaner and faster approach. A few days ago my boss told me about (NAV) Powershell commands and that I should give them a try. Why not?

I liked the idea of running a few Powershell commands that do the bulk of the job, from merging to compiling an entire database with minimal assistance on my side. The less “personal touch” the better. Less time spent on redundant tasks lead to less mistakes, and more time for development and trying new technologies.

And this is where I am now. The process still requires (minimal) developer’s interaction – for updating standard objects (VersionList propery) touched by AddOns objects, comparing a few conflict files and of course, running the commands. Albeit all this, the time I recorded to apply a cumulative update is at the minimum halved. Is there room for further improvement? Definitely, with a few more experiments under the belt and testing, the process can further be refined into a single script run, cutting 4-6 hours task to a few minutes.

The steps below are based on a recent task I worked on: to apply  standard NAV 2016 CU11 on top of a NAV 2016 CU5 database + my employer AddOn.

Pre-requisites:

  • A previous CU demo database (the last one you applied) – let’s call it CU(n-1)
  • The current (the one we want to apply) CU demo database – named here CU(n)
  • The current database based on CU(n-1) and your AddOns
  • A working folder Upgrade with 5 folders in it:
    • ORIGINAL
    • MODIFIED
    • TARGET
    • DELTA (used if you want to compare first the differences)
    • RESULT

Steps:

1. Create objects in text format for all objects of:

  • Demo database CU(n-1) -> in the ORIGINAL folder
  • Demo database CU(n) -> in the MODIFIED folder
  • Current database -> in the TARGET folder

Finsql command=ExportObjects, file=c:\Upgrade\Original\Orginal.txt, servername=myserver, database=Demo CU (n-1)

Finsql command=ExportObjects, file=c:\Upgrade\Modified\Orginal.txt, servername= myserver, database=Demo CU (n)

Finsql command=ExportObjects, file=c:\Upgrade\Target\Orginal.txt, servername= myserver, database=your_current_db_with_addons

2. In the NAV 2016 Development Shell run:

Merge-NAVApplicationObject -TargetPath .\TARGET -OriginalPath .\ORIGINAL -ModifiedPath .\MODIFIED -ResultPath .\RESULT -DateTimeProperty FromModified -ModifiedProperty FromModified -VersionListProperty FromModified

This will populate RESULT folder with txt files and conflict folders.

3. Merge code using BeyondCompare or any other similar tool comparing files from ConflictModified folder against correspondent files from ConflictTarget folder. Copy the merged files(overwrite existent) into the Result folder.

4. In your current database(target db) Development Environment select all standard objects that have been touched by your AddOns

5. Take each object of the list in Development Environment and manually add your AddOn version into the correspondent files from RESULT folder

Note: This is because the -VersionListProperty parameter of Merge_NAVApplicationObject cmdlet does not update the version list with the AddOn signature – need to do it manually for now.

6. Combine all text files from RESULT folder into one:

PS C:\upgrade\result> Join-NAVApplicationObjectFile -Source “*.txt” -Destination “all_objects.txt”

7. Import “all_objects.txt” in the development environment manually or using finsql’s command=importobject” parameter.

8. Compile all objects

More MSDN info here and here.

Useful Powershell commands:

  • Create Delta files

Compare-NAVApplicationObject -OriginalPath .\ORIGINAL -ModifiedPath .\MODIFIED -DeltaPath .\DELTA

  • To apply Delta files:

Update-NAVApplicationObject –DeltaPath .\DELTA -TargetPath .\TARGET\*.txt -ResultPath .\RESULT

  • Join all text files into one:

Join-NAVApplicationObjectFile -Source “*.txt” -Destination “all_objects.txt”

  • Import that single file in NAV

finsql.exe command=importobjects, file=C:\Upgrade\Result\all_objects.txt, servername=myserver, database=”merge_target”

  • Split a big text file into individual text objects

Split-NAVApplicationObjectFile -Source C:\Upgrade\ORIGINAL\*.txt -Destination C:\Upgrade\ORIGINAL\TXT\

More MSDN info on cmdlets here.