The old “friend” was a problem with the Danish letter Ø. The letter was displayed as Ȼ which is not the right sign (actually the data was also corrupt ). At first side everything looked fine in the regional settings and the language was set to Danish – but then I looked on the Advance page and voilá there we had the answer. Code Page 850 was not selected.

After a selection of the code page and a reboot of the server, the letter Ø was now displayed correctly. Yeah!

This did though not solve all my problems. Unfortunately the data was been corrupted, due to the wrong code page. Luckily this was a new installation of Navision, so all I had to do was restore my locally build database again.

This was a new installation of Navision and not an Upgrade. If this had not been the case, it would have been necessary to correct the data “manually”. DOH! Not an ideal situation.

This time I was Lucky – next time I might not be so lucky. So in the future, I will personally check the regional settings before restoring the database.

So – always remember to check the regional settings, before you are restoring a localized Navision Database. You might else run into the same problems as I did.

Therefore I did some testing and here is what a figured out:

1. Open a fresh client
2. Add shortcuts to a menu item or a menu group
3. Check shortcuts – they were created fine
4. Check menu items – they are also still here
5. Now close the client
6. Open a fresh client
7. Check shortcuts – they are still there
8. Check menu items and they are now disappeared…  huh what happenend here???

If I now want to restore the missing menu item – I unfortunately has to clear the users record in “User Menu Level”. Not a ideal situation!

So what to do? Don’t bother looking into you code; it is not a code error. After some searching I did find out that this a known error Navision.

This error affects NAV 2009 and NAV 5.0 SP1 and you can get a hot fix from Microsoft. Just locate the article with id. 970545 – here the problem is described and you will also be able to get a hot fix.

Well… it is actually pretty easy
 

1) What is the default page? The default page is usually page 9006 “Order Processor Role Center”.

So how did I find it out? Well I think like a developer – so why use forms, when you can go straight into tables

In table 2000000072 Profile you can locate the different profiles. Each profile has a startup Page attached. Furthermore you can also locate a field called “Default Role Center”. All you now have to do is set a filter on this field and viola you have discovered the default page.

Btw. the correct way would properly be Administration -> Application Setup -> RoleTailored Client -> Profiles
 

2) Where do I set it up?

Well haven’t I already answered it??? If not – all I have to say is Profiles….
 

3) How to give a user a different start up page? Use Profiles and “User Personalization”

Ok – I have in 1) already described Profiles – so before going into “User Personalization” be sure, that you have defined a new (or reused) a user specific profile. 

Next go into “User Personalization” and attach a profile to your user by filling “Profile ID” – that’s all, now has the specific user a new start up page.

Where to find “User Personalization”? Go into either table 2000000073 “User Personalization” or the clean way Administration -> Application Setup -> RoleTailored Client -> User Personalization

First we must make it possible for navision to see it. This is done by adding the dll’s information to the table 2000000069 Client Add-in.

Before we are doing this we need to be sure that the dll is in the add-ins folder and we need to know the public key for the dll.

Okay – first locate the folder C:\Program Files\Microsoft Dynamics NAV\60\RoleTailored Client\Add-ins and make sure the file naviRss.dll is located there.

Next we have to find the public key. This is done by using the Visual Studio Command Prompt. Change to the Add-ins directory and run the command sn -T naviRss.dll

This command returns the public key – which is c172ecf10f26d3ea.

Next is to add the DLL to the table 2000000069 Client Add-in in navision. You only have to fill Control Add-in Name and Public Key Token

By adding the DLL to the table, we are now able to call it from a page.

Create a new page – ex. naviRss. The sourcetable for the page is RSS – it is a new table, that contains the different RSS urls

The Page could look like this:

If we take a look on the Feed control – you can see that it is bound to the variable Parameters, which is set in OnAfterGetrecord:

Parameters := 'rss_url='+"Rss Feed Url"+
              '¤no_feeds='+FORMAT("No Feeds")+
              '¤show_description='+FORMAT("Show Description");

Until now the Feed is still not linked to the naviRss.dll – this is done in the properties for the Feed control.

In the properties locate ControlAddIn, here you should add naviRss.

That’s all – now the page is ready for testing

I have previous written about a ASP.NET RSS reader – in that article, the collection of feeds was a C# function, so why not use this function to extend the RoleTailored Client.

I will be using Visual Studio 2008 to write a Dynamic Link Library (dll), but you can also use the free Express version of Visual C#.

Let’s start by creating a new project – a class library. I have chosen to call it naviRSS.

Add-In libraries must be strong signed, therefor go into properties -> Signing. Here we are going to create a new key.

• Mark Sign the assemply
• Chose to create a new strong key
• Fill the Key file name
  

Now the signing page should look something like this:

We have now signed the project, so next is to add the needed references to the project. Add the following references:

• System.Windows.Forms
• System.Drawing
• Microsoft.Dynamics.Framework.UI.Extensibility

Microsoft.Dynamics.Framework.UI.Extensibility is a dll file that usually can be located here: C:\Program Files\Microsoft Dynamics NAV\60\RoleTailored Client.

Finally we have the initial settings in place and are ready to handle the “real” code.

We will be using 3 items:

• RssControl.cs
• RssFeeds.html
• RssFeeds.cs

Rename the default class1.cs to RssControl.cs (or delete it and create a new one )

The RssControl will be containing the following functions:

• public RssControl(string template)
  • is the constructor to handle the integration with RSS Feeds
• void RssControl_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e)
  • what should happend when the html document is loaded
• public override string Text
  • updates some variables in the html document
• private string GetParameter(string parm, string defaultvalue)
  • gets the paramenters which are set from navision
• private string GetFeed(string rssURL, int maxItems, int showDesc)
  • is the GetFeed functions, that already is known from a earlier article

The complete RssControl.cs will look like this:

using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.Dynamics.Framework.UI.Extensibility;
using Microsoft.Dynamics.Framework.UI.Extensibility.WinForms;
 
 
namespace naviRss
{
 
    public class RssControl : WebBrowser
    {
        private string template;
        private string text;
        private string html = "<html><body></body></html>";
 
        public RssControl(string template)
        {
            this.template = template;
            this.DocumentCompleted += new WebBrowserDocumentCompletedEventHandler(RssControl_DocumentCompleted);
        }
 
        void RssControl_DocumentCompleted(object sender, WebBrowserDocumentCompletedEventArgs e)
        {
            if (this.DocumentText != this.html)
            {
                this.DocumentText = this.html;
            }
        }
 
        public override string Text
        {
            get
            {
                return text;
            }
            set
            {
                if (text != value)
                {
                    text = value;
                    if (string.IsNullOrEmpty(value))
                    {
                        html = "<html><body></body></html>";
                    }
                    else
                    {
                        string rss_url = GetParameter("rss_url", "0");
 
                        Int16 no_feeds = 0;
                        Int16.TryParse(GetParameter("no_feeds", "0"), out no_feeds);
 
                        string show_desc = GetParameter("show_description", "1");
 
                        string feeds = "";
                        if (show_desc == "true" || show_desc == "1")
                            feeds = GetFeed(rss_url, no_feeds, 1);
                        else
                            feeds = GetFeed(rss_url, no_feeds, 0);
 
                        html = this.template;
                        html = html.Replace("%rss_url%", rss_url);
                        html = html.Replace("%no_feeds%", no_feeds.ToString());
                        html = html.Replace("%show_description%", show_desc);
                        html = html.Replace("%feeds%", feeds);
                    }
                    this.DocumentText = html;
                }
            }
        }
 
        private string GetParameter(string parm, string defaultvalue)
        {
            foreach (string parameter in text.Split('¤'))
            {
                if (parameter.StartsWith(parm + "="))
                {
                    return parameter.Substring(parm.Length + 1);
                }
            }
            return defaultvalue;
        }
 
        private string GetFeed(string rssURL, int maxItems, int showDesc)
        {
            string FeedsCollected = "";
 
            System.Net.WebRequest myRequest = System.Net.WebRequest.Create(rssURL);
            System.Net.WebResponse myResponse = myRequest.GetResponse();
 
            System.IO.Stream rssStream = myResponse.GetResponseStream();
            System.Xml.XmlDocument rssDoc = new System.Xml.XmlDocument();
            rssDoc.Load(rssStream);
 
            System.Xml.XmlNodeList rssItems = rssDoc.SelectNodes("rss/channel/item");
 
            string title = "";
            string link = "";
            string pub_date = "";
            string desc = "";
 
            if (maxItems == 0)
                maxItems = rssItems.Count;
 
            if ((maxItems > 0) && (rssItems.Count < maxItems))
            {
                maxItems = rssItems.Count;
            }
 
            for (int i = 0; i < maxItems; i++)
            {
                title = rssItems.Item(i).SelectSingleNode("title").InnerText;
                link = rssItems.Item(i).SelectSingleNode("link").InnerText;
                pub_date = rssItems.Item(i).SelectSingleNode("pubDate").InnerText;
                desc = rssItems.Item(i).SelectSingleNode("description").InnerText;
 
                FeedsCollected += "<a href='" + link + "' target='new'>" + title + "</a><br/>";
 
            }
 
            return FeedsCollected;
        }
    }
 
}

Ok – now we have all the info we need about the feeds. Next is to create a html page, which we will be using to present the feeds with. Add a new item RssFeeds.html to the project.

It is a pretty simple page and could look like this:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
	<head>
		<title></title>
	</head>
 
	<body>
        	%feeds%
	</body>
</html>

Notice that we have a variable %feeds%. This variable will be updated by the function Text, that is located in the RssControl.cs.

To be able to use the html page from the RoleTailored Client, we have to embed the file. This is done by adding the resource file Resources.resx to the project.

Then afterwards open Resources.resx and drop (drag & drop) the RssFeeds.html file on it.

Now all we need is to add the item RssFeeds.cs to the project (new item -> class). In RssFeeds.cs we will be handling CreateControl and AllowCaptionControl.

When the NAV Client needs to create the actual winforms control, it will be calling the CreateControl. By having our own CreateControl in the RssFeeds.cs – we are overriding the default method and giving it a html template instead.

AllowCaptionControl is used the override the default handling of captions.

RssFeeds.cs will look like this:

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using Microsoft.Dynamics.Framework.UI.Extensibility;
using Microsoft.Dynamics.Framework.UI.Extensibility.WinForms;
using System.Windows.Forms;
 
namespace naviRss
{
 
    [ControlAddInExport("naviRss")]
    public class RssFeeds : StringControlAddInBase, IStringControlAddInDefinition
    {
        protected override Control CreateControl()
        {
            //System.Diagnostics.Debugger.Launch();
            var RssWeb = new RssControl(Resources.RssFeeds);
 
            RssWeb.MinimumSize = new Size(600, 200);
            RssWeb.MaximumSize = new Size(600, 200);
            RssWeb.ScrollBarsEnabled = false;
            RssWeb.ScriptErrorsSuppressed = true;
            RssWeb.WebBrowserShortcutsEnabled = false;
 
            return RssWeb;
        }
 
        public override bool AllowCaptionControl
        {
            get
            {
                return false;
            }
        }
    }
}

[ControlAddInExport("naviRss")] is used to set the “control name” for navision. In this case the Control will be known as naviRss.

Everything is now in place and we are ready to build our project.

Build the project and place the naviRss.dll in the Add-Ins directory under the RoleTailored Client.

A little tip – if you don’t want to copy the dll yourself into the Add-Ins directory, then add the following commandline to post-build event commandline in the project properties under “build events”:

copy naviRss.dll “C:\Program Files\Microsoft Dynamics NAV\60\RoleTailored Client\Add-ins”

All you know have to do is setting up the dll in navision and build a page to use it. This will be described in the next article.

First, let us a add simple test message function to the previous created “doTest” codeunit. The function could look this:

PROCEDURE TestMessage@1112800001(useWrong@1112800000 : Boolean) : Boolean;
BEGIN

  IF useWrong THEN
    MESSAGE('Wrong Message')
  ELSE
    MESSAGE('Test Ok');

  EXIT(TRUE);
END;

Now we must add the handling of the Message Box to the codeunit “Handler Test Functions”. Here we will be adding the functions:

• Message_Ok
• TestMessage_Ok
• TestMessage_Ok_Error

Message_Ok is the actual MessageHandler. Message_Ok is created in this way:

1. First add the function to the Global Vars
2. Change the property “FunctionType” for the Message_Ok function to MessageHandler.

The properties for the Message_Ok function should now look like this:

Function ( : Text[1024])

Therefore we will add the parameter msg. Next is to add code, that can handle the message. It could look like this:

[MessageHandler]
PROCEDURE Message_Ok@1112800002(Msg@1112800000 : Text[1024]);
BEGIN

  IF Msg <> 'Test Ok' THEN
    ERROR('Unexpected Msg');
END;

Now you can see why i added 2 different messages to the test function. This is because I would like to test the handling of an unexpected message box.

Ok – the MessageHandler is now in place, so lets look on the functions to handle the Tests.
Let us start by testing an Ok message – which the function TestMessage_Ok will handle.
TestMessage_Ok is created in this way:

1. First add the function to the Global Vars
2. Change the property “FunctionType” for the TestMessage_Ok function to Test.
3. Change the property “HandlerFunctions” to “Message_Ok”

The properties for the TestMessage_Ok function should now look like this:

[Test]
[HandlerFunctions(Message_Ok)]
PROCEDURE TestMessage_Ok@1112800006();
VAR
  doTest@1112800000 : Codeunit 50001;
BEGIN

  IF NOT doTest.TestMessage(FALSE) THEN
    ERROR('Error in test - Ok');
END;

If you repeats these steps to create the function TestMessage_Ok_Error – you could end up with a function like this:

[Test]
[HandlerFunctions(Message_Ok)]
PROCEDURE TestMessage_Ok_Error@1112800007();
VAR
  doTest@1112800000 : Codeunit 50001;
BEGIN

  IF NOT doTest.TestMessage(TRUE) THEN
    ERROR('Error in Test - Ok Error');
END;

When you now run the “Test Runner” codeunit – the TestMessage function in to codeunit doTest will be tested.

If you have noticed, you can see that the function TestMessage_Ok_Error sends in a TRUE – which means, that the doTest.TestMessage will show the Message Box containing the message “Wrong Message”. The MessageHandler function though, only handles the message “Test Ok”. Therefor you will in the log see, that the first function TestMessage_Ok went well and that the second function TestMessage_Ok_Error failed.

The Log could look like this:

That’s all folks – now you also can handle Message Boxes