TechBlog » .NET

RSS Reader Add-In for the RoleTailored Client

iby — Wed, 14 Oct 2009 20:36:27 +0000

Add-Ins are used to add new features to the RoleTailored Client and was introduced with NAV 2009 SP1.

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 = "";
 
        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 = "";
                    }
                    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 += "" + title + "
";
 
            }
 
            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:

4.0 Transitional//EN">

	
		
	
 
	
        	%feeds%

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.

Building a RSS reader in ASP.Net

iby — Tue, 13 Oct 2009 14:52:03 +0000

RSS Feeds are just XMLs – so building a RSS reader is not so difficult, first you know how to do it

Let’s start with looking at C# function that reads the RSS Feeds.

First step is to collect the feeds. This is done by using WebRequest:

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

Now that we have collected the feeds, we are able to process the XML (rssDoc). In my example I would like to run though the items and then write the title.

This would look something like this:

System.Xml.XmlNodeList rssItems = rssDoc.SelectNodes("rss/channel/item");
 
string title = "";
string link = "";
 
for (int i = 0; i < rssItems.Count; i++)
{            
    title    = rssItems.Item(i).SelectSingleNode("title").InnerText;
    link     = rssItems.Item(i).SelectSingleNode("link").InnerText;            
 
    Response.Write("" + title + "
");
 
    Response.Write("
");
}

That’s all, now you have a function that can collect the Feeds.

Please Notice – not all Feeds have the same XML format. They can/will differ from Feed provider to Feed provider.

Now lets take a closer look on the ASP.Net page.

<%@ Page Language="C#" %>
 

 



    mibuso Feeds    


    
                
            <%                
                rssUrl = "http://www.mibuso.com/forum/smartfeed.php?forum=23&firstpostonly=1&limit=NO_LIMIT&count_limit=10&sort_by=postdate_desc&feed_type=RSS2.0&feed_style=HTML";
 
                Response.Write("mibuso Feeds
");
                GetFeed(rssUrl);
            %>

Here we assume, that the above C# function is called GetFeed. This function must be added in a script section and can afterwards be called from the body section.

Next you place the asp.net page on the internet server. When calling it – you should get a result like this:

That’s all, now you have a ASP.Net page, that collects the feeds and show the title.

Expanding the FTP automation

iby — Thu, 19 Mar 2009 22:14:43 +0000

In the previous post I have started the development of FTP automation. The first post did only include some basic functions such as download, upload and list. Now it’s time for some more functionality.

So now let us add the possibility to delete and rename files.

Deleting a file from the FTP server is actually pretty simple. All you have to know is the filename and where it is place. Once you have this information you can use the WebRequestMethods to delete the file.

We will start with making a connection to the FTP Server:

 string ConnectionString = "ftp://" + strFTPServer + ':' + intFTPPort + "/" + strFtpDirectory + @FileName;
 
FtpWebRequest FtpRequest = (FtpWebRequest)FtpWebRequest.Create(ConnectionString);
FtpRequest.Credentials = new NetworkCredential(strUsername, strPassword);
FtpRequest.KeepAlive = false;

Now we are ready to delete the file:

FtpRequest.Method = WebRequestMethods.Ftp.DeleteFile;
FtpRequest.GetResponse().Close();

This is done by using WebRequestMethods to set the DeleteFile Method and then afterwards executing the deletion with GetResponse.

Remember to catch Execeptions, to see if the deletion went well.

So now you can delete files from the FTP server.

This was easy. So let us continue with the renaming.

Renaming a file is similar to the deletion of a file. Again all you need to know is the filename & path and then you can use WebRequestMethods to rename the file.

As in the deletion of a file you will start with making the server connection:

string ConnectionString = "ftp://" + strFTPServer + ':' + intFTPPort + "/" + strFtpDirectory + @FileName;
 
FtpWebRequest FtpRequest = (FtpWebRequest)FtpWebRequest.Create(ConnectionString);
FtpRequest.Credentials = new NetworkCredential(strUsername, strPassword);
FtpRequest.KeepAlive = false;

Now that the server connection is in place – you are ready to perform the renaming:


FtpRequest.Method = WebRequestMethods.Ftp.Rename;
FtpRequest.RenameTo = NewFileName;
FtpRequest.GetResponse().Close();

As you can see, we are also here using WebRequestMethods to set Rename Method. First the Method is chosen; you set the new filename with FtpRequest.RenameTo and then afterwards execute the rename with GetResponse.

So the only difference to the deletion is the Method and the RenameTo command.

That’s all folks! Now you can delete and rename files on an Ftp.

Writing a FTP automation

iby — Mon, 15 Dec 2008 22:25:36 +0000

Over some time I have been using a plain dos ftp from Navision. There is some advantages and some disadvantage combined with it.

A advantage is, that this use does not require any third part products; but a disadvantage is that you does not have the fully control over the file transfer, so you have to build your own kind of file log and parsing it to know if everything went well.

Therefor I decided to build my own automation for Navision in c#.

My first version of the automation should only contain some basic functions.
Which are:
- Upload File
- Download File
- List

To upload a file we will be using FTPWebRequest, which is a part of System.Net and FileInfo,
which is a part of System.IO.

We will start with making a connection to the FTP Server:

string ConnectionString =
……“ftp://” + strFTPServer + ‘:’ +intFTPPort + “/” +strFtpDirectory +FileName;

FtpWebRequest FtpRequest =
……(FtpWebRequest)FtpWebRequest.Create(new Uri(ConnectionString));

FtpRequest.Credentials = new NetworkCredential(strUsername, strPassword);

If the connection went well, we are ready for to upload the file. The upload is done by
creating a File Stream and then writing the file byte by byte to the Ftp Server.

FtpRequest.Method = WebRequestMethods.Ftp.UploadFile;
FtpRequest.ContentLength = FileInf.Length;

FileInfo FileInf = new FileInfo(FileName);

int BufferLength = 2048;
byte[] Buffer = new byte[BufferLength];
int ContentLength;

FileStream UpStream = FileInf.OpenRead();
Stream FtpStream = FtpRequest.GetRequestStream();

ContentLength = UpStream.Read(Buffer, 0, BufferLength);
while (ContentLength != 0)
{
……FtpStream.Write(Buffer, 0, ContentLength);
……ContentLength = UpStream.Read(Buffer, 0, BufferLength);
}

FtpStream.Close();
FtpStream.Dispose();

UpStream.Close();
UpStream.Dispose();

To download a file is pretty similar to upload a file.

First we start with making a connection to the Server:

FtpWebRequest FtpRequest =
……(FtpWebRequest)FtpWebRequest.Create(new Uri(ConnectionString));

FtpRequest.Credentials = new NetworkCredential(strUsername, strPassword);

and then we downloads the file by using a stream:

System.IO.Stream ResponseStream = null;
System.IO.FileStream DownStream = null;

FtpRequest.Method = WebRequestMethods.Ftp.DownloadFile;
FtpWebResponse WebResponse = (FtpWebResponse)FtpRequest.GetResponse();
ResponseStream = WebResponse.GetResponseStream();
DownStream = System.IO.File.Open(DownFileName + “.tmp”, System.IO.FileMode.Create);

while (((iWork = ResponseStream.Read(buf, 0, buf.Length)) > 0))
……DownStream.Write(buf, 0, iWork);

ResponseStream.Close();
ResponseStream.Dispose();

DownStream.Flush();

If you want to check that the download went well – you can always check the return response
from the FtpRequest:

FtpWebResponse ReturnResponse = ((FtpWebResponse)FtpRequest.GetResponse());
if (StatusOk(ReturnResponse))
{
……DownloadSucceeded = true;
}

And then finally the List functionality. This function will be useful when downloading files.

Again we start with making a connection to the Server:

FtpWebRequest FtpRequest =
……(FtpWebRequest)FtpWebRequest.Create(new Uri(ConnectionString));

FtpRequest.Credentials = new NetworkCredential(strUsername, strPassword);

Then we use the ListDirectoryDetails funtion to find the files.

FtpRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
FtpWebResponse Response = (FtpWebResponse)FtpRequest.GetResponse();

As you can see, where are again using the stream functionality.

StringBuilder Result = new StringBuilder();
StreamReader Reader = new StreamReader(Response.GetResponseStream());
string Line = Reader.ReadLine();
string tmpLine;
while (Line != null)
{
……tmpLine = Line;

……//Lines starting with d is directories – everything else is file
……if (!tmpLine.StartsWith(“d”))
……{
………..tmpLine = Line.Substring(Line.LastIndexOf(‘ ‘) + 1);
………..Result.Append(tmpLine);
………..Result.Append(“\n”);
……}
……Line = Reader.ReadLine();
}

Reader.Close();
Response.Close();

string[] FileList
FileList = Result.ToString().Split(‘\n’);

Thats all – now you can upload, download and list files.

Writing an automation for Navision in C#

iby — Sun, 12 Oct 2008 20:12:57 +0000

Writing a automation for Navision is pretty simple, when you first know how to do it

First of all, I assume that you already know about C#.

So here are the basic steps for creating an automation:

1. Create a new Class Library project.

Chose File -> New -> Project and then chose Class Library and save it as myAutomation (or use you own name)

2. Before making any changes – setup the Properties

Chose Project -> myAutomation Properties
Select tab Application and then the button Assembly Information
- In the Assembly Information window, mark “Make assembly COM-Visible” and chose Ok
Select tab Build
- Mark “Register for COM interop”
Select tab Signing
- Mark “Sign the assembly” and create a key files (or chose an existing one)

Now everything is setup and you can close the property setup.

3. Add the namespace for InteropServices

This is done by adding using System.Runtime.InteropServices

You should now have a code similar to the following:

using System;
using System.Text;
using System.Runtime.InteropServices;

namespace myAutomation
{
……public class myAutomation
……{
……}
}

4. Declare the interface

First you have to decide if the class should be visible or not. In this case we want it to be visible, so that we can use it with the automation.

[ComVisible(true)]

Next you can choose to set the Guid and ProgId.

[Guid("41E646B3-F65C-4d8e-8539-499FA56C7076")]
[ProgId("myAutomation")]

Then decide the Class Interface Type. You can choose between None and Autodual.

[ClassInterface(ClassInterfaceType.AutoDual)]

For now we will be using Autodual, because None requires the use of Interface and class’es – where as Autodual only uses class.

You should now have a code similar to the following:

using System;
using System.Text;
using System.Runtime.InteropServices;

namespace myAutomation
{
……[ComVisible(true)]
……[Guid("41E646B3-F65C-4d8e-8539-499FA56C7076")]
……[ClassInterface(ClassInterfaceType.AutoDual)]
……[ProgId("myAutomation")]
……public class myAutomation
……{
……}
}

Now you can add all the functions that you need.

Notice, you can hide functions and classes from the automation by using Private or [ComVisible(false)]

Here is a code example for an automation with visible and invisible methods.

using System;
using System.Text;
using System.Runtime.InteropServices;

namespace myAutomation
{
……[ComVisible(true)]
……[Guid("41E646B3-F65C-4d8e-8539-499FA56C7076")]
……[ClassInterface(ClassInterfaceType.AutoDual)]
……[ProgId("myAutomation")]
……public class myAutomation
……{
………..public Int16 Add(Int16 X, Int16 Y)
………..{
…………….Int16 Result = (Int16)(X + Y);
…………….return Result;
………..}

………..//Is hidden in the Automation because of Private
………..private Int16 PrivateAdd(Int16 X, Int16 Y)
………..{
…………….Int16 Result = (Int16)(X + Y);
…………….return Result;
………..}

………..//Is hidden in the Automation because of ComVisible
………..[ComVisible(false)]
………..public Int16 InvisibleAdd(Int16 X, Int16 Y)
………..{
…………….Int16 Result = (Int16)(X + Y);
…………….return Result;
………..}
……}
}

Functions are in the automation presented as Methods, where as C# properties (public set; get;) are presented as properties.

Please note, that I am using Visual Studio C# 2008 (you can download the Express version from Microsoft here.)

C# and Dns.GetHostEntry

iby — Fri, 03 Oct 2008 21:19:30 +0000

I am currently building a new FTP automation for Navision.

During this I discovered that Dns.GetHostEntry is not always stable.

So I did some testing. Here are some of the results:

Dns.GetHostEntry(localhost) Ok

Dns.GetHostEntry(127.0.0.1) Ok

Dns.GetHostEntry(192.168.1.147) No Such Host is Known

The funny side is that its all to the same ftp server.

It seams, that Dns.GetHostEntry often throws the exception (No Such Host is Known).

So, what to do? Well I have chosen to use the command Dns.GetHostAddresses instead of Dns.GetHostEntry.

The difference between GetHostEntry and GetHostAddresses is that GetHostEntry will attempt a DNS reverse resolve before giving you the IP address back, where as GetHostAddress just returns the IP address.

Dns.GetHostEntry(localhost)	Ok
Dns.GetHostEntry(127.0.0.1)	Ok
Dns.GetHostEntry(192.168.1.147)	No Such Host is Known