DataBatrix » Web Services

Populate TreeView From Custom Object Using Serializer

Eric — Tue, 21 Dec 2010 17:40:41 +0000

From time to time I need to spit out the public properties of an object for various reasons. A typical use would be to show user friendly results from a web service that returns a complex object. There could be tons of other uses! After doing this a few times, I finially decided to post this so I can always reference it. Anytime I do any recursive methods, it always takes me a couple of tweaks before getting it right.

The idea is that I have a custom object that I need to spin through to populate a TreeView. I created a couple of simple methods to do such. I though about using Reflection, but my method starting getting larger and larger because I was having to put in special code to handle certain Types (i.e. String, ICollection, etc). Since my typical Use Case was to spit out the results of a complex object returned from a ASMX or WCF service, I decided to go the Serialize route. My DTO class was typically already decorated with the [Serializable] attribute, if not, it was simple enought to add.

So first we serialize the object into a string of XML, then stuff that into a XmlDocument. Then you can loop through the elements while creating each TreeViewNode. That’s it!

        public void PopulateTreeView(object obj, TreeView tv)
        {
            System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(obj.GetType());
            System.Text.StringBuilder sb = new System.Text.StringBuilder();  // StringBuilder to hold the XML
            using (System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(sb))
            {
                serializer.Serialize(writer, obj); // Serialize the object to XML
                System.Xml.XmlDocument xDoc = new System.Xml.XmlDocument();
                xDoc.LoadXml(sb.ToString());  // Shove it in a XmlDocument
                tv.Nodes.Add(PopulateNode(xDoc));  // Add the Nodes to the TreeView
            }
        }

        public TreeNode PopulateNode(System.Xml.XmlNode node)
        {
            TreeNode treenode = new TreeNode(node.Name);  // Add the Name to the Node
            if (node.ChildNodes.Count == 1) //Prevents ParentNode from displaying all of the InnerText
                treenode.Text += "=" + node.InnerText; // If only 1 ChildNode then add the InnerText

            for (int i = 0; i < node.ChildNodes.Count; i++)
            {
                if (node.ChildNodes[i].HasChildNodes)
                {
                    treenode.ChildNodes.Add(PopulateNode(node.ChildNodes[i]));
                }
            }
            return treenode;
        }

Then call the method to populate where “customObject” is the object you want displayed in your TreeView:

            PopulateTreeView(customObject, TreeView1);

A .NET Bit.ly API Helper Class (Visual Basic.NET)

Eric — Mon, 24 Aug 2009 21:19:19 +0000

I decided to write a helper class for using the Bit.ly API for creating short urls. You know, those tiny links that you see all over Facebook, Twitter, etc. The snippet below shows how you would use the helper class. Not only can you shorten an url, you can shorted multiple urls in a single call as well as get stats and info about a bit.ly url. If you are looking to incorporate bit.ly short urls in your application using their API access, this will save you some time. The class uses the XmlSerializer for reading bit.ly’s response.

        ' Pass username and API key to instantiate
        Dim newbitlyAPI As New DataBatrix.bitlyAPI.bitlyAPI("bitlyapidemo", "R_0da49e0a9118ff35f52f629d2d71bf07")

        ' Sample of creating 1 short URL
        Dim shortenResponse As DataBatrix.bitlyAPI.bitlyShortenResponse = newbitlyAPI.Shorten("http://www.databatrix.com")
        Dim shortURL As String = ""
        If shortenResponse.results.Count > 0 Then
            shortURL = shortenResponse.results(0).shortUrl
        End If

        ' Sample of creating multiple short URLs
        Dim longUrls() As String = {"http://www.databatrix.com", "http://www.google.com"}
        Dim shortenResponses As DataBatrix.bitlyAPI.bitlyShortenResponse = newbitlyAPI.Shorten(longUrls)
        Dim shortURLs(1) As String
        For i As Integer = 0 To shortenResponses.results.Count - 1
            shortURLs(i) = shortenResponses.results(i).shortUrl

        Next

        ' Sample of getting bit.ly info...
        Dim info As DataBatrix.bitlyAPI.bitlyInfoResponse = newbitlyAPI.Info("2bYgqR")

        ' Sample of getting bit.ly stats...
        Dim stats As DataBatrix.bitlyAPI.bitlyStatsResponse = newbitlyAPI.Stats("http://bit.ly/1RmnUT")

Below is the helper class that I created. You can download the VB file bitlyAPI.vb or a sample project TestBitly Project Files.

Imports System.Web
Imports System.Xml
Imports System.Xml.Serialization

Namespace DataBatrix.bitlyAPI
    Public Class bitlyAPI
        Const BaseAPIUrl As String = "http://api.bit.ly/"
        Const version As String = "2.0.1"
        Const format As String = "xml"

        Public login As String = String.Empty
        Public apiKey As String = String.Empty

        Sub New(ByVal login As String, ByVal apiKey As String)
            Me.login = login
            Me.apiKey = apiKey

        End Sub

        Private Function BuildBaseRequestURL(ByVal applicationName As String) As System.Text.StringBuilder
            Dim RequestUrl As New System.Text.StringBuilder()
            With RequestUrl
                .Append(BaseAPIUrl & HttpUtility.UrlEncode(applicationName) & "?")
                .Append("version=" & HttpUtility.UrlEncode(version) & "&")
                .Append("format=" & HttpUtility.UrlEncode(format) & "&")
                .Append("login=" & HttpUtility.UrlEncode(login) & "&")
                .Append("apiKey=" & HttpUtility.UrlEncode(apiKey) & "&")
            End With
            Return RequestUrl
        End Function

        Public Function Shorten(ByVal longUrl As String) As bitlyShortenResponse
            Dim logUrls() As String = {longUrl}
            Return Shorten(logUrls)
        End Function

        Public Function Shorten(ByVal longUrl() As String) As bitlyShortenResponse
            Dim RequestUrl As System.Text.StringBuilder = BuildBaseRequestURL("shorten")
            For Each s As String In longUrl
                RequestUrl.Append("&longUrl=" & HttpUtility.UrlEncode(s))

            Next
            Dim responseObj As DataBatrix.bitlyAPI.bitlyShortenResponse = Nothing
            Try
                Dim serializer = New XmlSerializer(GetType(DataBatrix.bitlyAPI.bitlyShortenResponse))
                Using reader As XmlTextReader = New XmlTextReader(RequestUrl.ToString())
                    responseObj = CType(serializer.Deserialize(reader), DataBatrix.bitlyAPI.bitlyShortenResponse)
                End Using

            Catch ex As Exception

            End Try

            If responseObj.errorCode > 0 Then
                Throw New ApplicationException("Error from bit.ly: " & responseObj.errorMessage)
            End If
            Return responseObj
        End Function
        Public Function Info(ByVal hash As String) As bitlyInfoResponse
            Dim RequestUrl As System.Text.StringBuilder = BuildBaseRequestURL("info")
            With RequestUrl
                .Append("hash=" & HttpUtility.UrlEncode(hash))
            End With

            Dim responseObj As DataBatrix.bitlyAPI.bitlyInfoResponse = Nothing
            Try
                Dim serializer = New XmlSerializer(GetType(DataBatrix.bitlyAPI.bitlyInfoResponse))
                Using reader As XmlTextReader = New XmlTextReader(RequestUrl.ToString())
                    responseObj = CType(serializer.Deserialize(reader), DataBatrix.bitlyAPI.bitlyInfoResponse)
                End Using

            Catch ex As Exception
                Throw New ApplicationException("API Error: " & ex.Message)
            End Try
            If responseObj.errorCode > 0 Then
                Throw New ApplicationException("Error from bit.ly: " & responseObj.errorMessage)
            End If
            Return responseObj
        End Function

        Public Function Stats(ByVal shortUrl As String) As bitlyStatsResponse
            Dim RequestUrl As System.Text.StringBuilder = BuildBaseRequestURL("stats")
            With RequestUrl
                .Append("shortUrl=" & HttpUtility.UrlEncode(shortUrl))

            End With

            Dim responseObj As DataBatrix.bitlyAPI.bitlyStatsResponse = Nothing
            Try
                Dim serializer = New XmlSerializer(GetType(DataBatrix.bitlyAPI.bitlyStatsResponse))
                Using reader As XmlTextReader = New XmlTextReader(RequestUrl.ToString())
                    responseObj = CType(serializer.Deserialize(reader), DataBatrix.bitlyAPI.bitlyStatsResponse)
                End Using

            Catch ex As Exception
                Throw New ApplicationException("API Error: " & ex.Message)
            End Try
            If responseObj.errorCode > 0 Then
                Throw New ApplicationException("Error from bit.ly: " & responseObj.errorMessage)
            End If
            Return responseObj
        End Function

    End Class

    Public MustInherit Class bitlyResponseBase
         _
        Public errorCode As Integer = 0

         _
        Public errorMessage As String = String.Empty

         _
        Public statusCode As String = String.Empty

    End Class

     _
    Public Class bitlyShortenResponse
        Inherits bitlyResponseBase

         _
        Public results As New List(Of KeyVal)

        Public Class KeyVal
             _
             Public userHash As String

             _
             Public shortKeywordUrl As String

             _
             Public hash As String

             _
             Public longUrl As String

             _
             Public shortUrl As String

        End Class
    End Class

     _
    Public Class bitlyInfoResponse
        Inherits bitlyResponseBase

         _
        Public results As New List(Of bitlyInfoResultItem)

        Public Class bitlyInfoResultItem
             _
            Public shortenedByUser As String
             _
            Public keywords As String
             _
            Public hash As String
             _
            Public exif As String
             _
            Public surbl As String
             _
            Public contentLength As String
             _
            Public id3 As String
             _
            Public calais As String
             _
            Public longUrl As String
             _
            Public version As String
             _
            Public htmlMetaDescription As String
             _
            Public htmlMetaKeywords As String
             _
            Public calaisId As String
             _
            Public thumbnail As thumbnailObj
             _
            Public contentType As String
             _
            Public users As List(Of String)
             _
            Public globalHash As String
             _
            Public htmlTitle As String
             _
            Public metacarta As String
             _
            Public mirrorUrl As String
             _
            Public keyword As String
             _
            Public calaisResolutions As String
             _
            Public userHash As String

            Public Class thumbnailObj
                 _
                Public large As String
                 _
                Public small As String
                 _
                Public medium As String
            End Class

        End Class
    End Class

     _
Public Class bitlyStatsResponse
        Inherits bitlyResponseBase

         _
        Public hash As String
         _
        Public clicks As String

        Public Class bitlyStatsResultItem
             _
            Public None As String
             _
            Public direct As String
             _
            Public nodeKeyValue As List(Of KeyValue)
             _
            Public nodeKey As String

            Public Class KeyValue
                 _
            Public nodeValue As String
                 _
                Public nodeKey As String
            End Class
        End Class
    End Class

End Namespace

E-manage Mobile Portal

Eric — Tue, 18 Aug 2009 15:17:46 +0000

Background:

E-manage is a business management application. It is capable of managing customer databases (CRM) as well as projects, invoices, purchase orders, and inventory to name a few. The e-manage client application runs on a users desktop and uses Microsoft .NET as foundation along with a Microsoft SQL Server as the back-end.

Problem:

Getting information was easy when you were in the office at a computer. However, you were out of luck when you were out of the office. Something was needed to allow users access to crucial business data while mobile.

Solution:

I was asked to created a mobile web portal that could be used with any smart phone that had a basic Internet connection. This would allow users to access company data while out of the office.

Result:

Mobile portal landing screen with alerts and recent items.	Mobile portal company view
View/Edit/Create Service Tickets	View/Edit Projects

e-manage Mobile Portal – Create Service Ticket (Video)

e-manage Mobile Portal – Add New Company (Video)

I created a web application written in VB.NET that would connect directly with the MS SQL Server to supply the user with the data they needed. I created it to be light as possible without giving up functionality and usability. I also integrated with Yahoo Business Search API to lookup business addresses automatically to increase accuracy. From the mobile portal, you can:

View/Edit/Create a Company or Location
Create a Company with the aid of a Yahoo search
View/Edit/Create a Contact
Assign existing Company Contacts to a Project
View/Edit/Create a Project
View/Edit/Create a Service Agreement
View Service Ticket part totals when viewing a Service Agreement
Easily see a service agreement’s validity based on the agreement’s start date and agreement contact length
View/Edit/Create a Service Ticket
Assign/Re-Assign Service Tickets to Service Agreements
Add Parts to a Service Ticket by Searching the e-manage part database
View Part totals for a Service Ticket
View/Download a document/attachment that belongs to a Company, Contact, Project, Service Agreement, or Service Ticket
View/Create a Note that belongs to a Company, Contact, Project, Service Agreement, or Service Ticket
View/Reply/Acknowledge a Note that belongs to any object
Submit Project Action Items
View your Actions To Perform
View your Open Action Items
View Recent Items (syncs with the Recent Items in e-manage and updates any items that you open via the mobile portal)
Open multiple items at the same time in a tabbed environment

eManage Search for Blackberry

Eric — Tue, 18 Aug 2009 01:42:18 +0000

Background:

Our CRM software contains a huge list of contacts that are only available from within the software application.

Problem:

It becomes a challenge when a sales team member is out of the office (on the road) and needs a customer’s phone number or email address. It is typically not feasible to boot up their laptop, connect to the Internet and lookup the contact.

Solution:

The solution was to create a simple Blackberry application that will allow the team member the ability to lookup a contact against our CRM software’s database. From their Blackberry, they would then be able to call any of the listed phone numbers for the contact or send them an email.

Result:

I created a small Blackberry application designed using the Blackberry Plug-in for Microsoft Visual Studio. The applications allows the user to search by name or company (or both). The application then submits the search request to the Blackberry Enterprise Server, which then uses a web service that I created to search against our CRM database which is a SQL Server 2005 database.
Once the results are returned, you then have the ability to call any of the listed numbers, email, or add them to your Blackberry address book (which will in turn add them to your Outlook address book).
Overall basic program, but can be a lifesaver when out of the office.

Desktop Loader

Eric — Tue, 18 Aug 2009 01:34:36 +0000

Background:

As new updates or new applications come to light, they need to be installed on everyone’s machine in the company.

Problem:

It becomes a challenge to automatically install applications on everyone’s machine. At the time this was typically done using "Logon Scripts" that fire off after you log in. However, this would only work if the user was already on the network (not at home).

Solution:

The solution was to develop a small desktop application that would run at startup. The application would check to see if there was anything that needed to be installed, install them, and finally close. The application also needed to work in or out of the office.

Result:

Fig. 1

Fig. 2

I created a small VB.NET desktop application that would run at startup hidden, or you could run the GUI (viewable) version by launching the application from the Start>Programs. Since it needed to run in and out of the office, it uses a web service to check to see what updates are needed. How does it know which ones are needed? After the program installs the application it uses the web service to update a log that notes the application, logged in user name, and machine name. This was a application can be installed per machine AND user instead of just one or the other. If an application is needed, the web service sends back the folder name on a secure FTP site that contains all of the files that need to be copied to the local machine. It also passes the executable file name to run once it has finished copying the files. Applications that need to be installed can be assigned to certain users, groups, machines, or everyone. Also they can be flagged as "optional". Optional applications are not automatically installed via the hidden startup application and can only be install by manually kicking off the installation from the GUI version shown in Fig. 2. Another feature is the application has the ability to update itself.

Desktop Tools

Eric — Mon, 17 Aug 2009 23:51:09 +0000

Background:

I created a single page web page that was set as the background using the Active Desktop function of Windows XP. This web page allowed you to search the employee database for phone numbers or extensions. It also had a section to calculate shipping for certain items my company sells.

Problem:

Active Desktop started messing up when laptop users would boot without a internet connection present. Also, since the web page was hosted on the company Intranet, a login dialog box would pop-up if IE was not configured properly which was confusing to some users.

Solution:

Rebuild the web page to not use Active Desktop, but still have the tools easily accessible. Having a bookmark to the web page was not considered "easily accessible".

Result:

Fig. 1

Fig. 2

Fig. 3

I decided to created a small application that runs in the system tray. Right-clicking the icon in the tray would expand a menu of available tools. Fig. 1 shows the menu and the employee search box that appears after clicking "People Finder". Certain menu items are shown/hidden depending on the user’s login. For example, my login shows 6 items, but "Support Ticket" and "Cams" are not show for others. Rights are stored in the SQL database and not in the application so allowing access is simple and does not require an application update. Since we are on the subject of databases…how should the application connect to it? I decided to not connect directly to the database since the user would have to be on the network or have their VPN connected, but instead indirectly by using web services. Using web services allowed the application to work as long as any Internet connection was present. If a connection was not present, the application hides menu items that require a connection or certain rights. I created a separate web site that hosted the web service application that basically would act as a proxy for my application.
Since I knew I would be updating the application as time went by, I wanted the application to be able to update itself. I accomplished this by using some of the "Click Once" features of Visual Studio. Instead of using the default settings, I handled the Click Once part programmatically so that I could force the update.
I added a "Sales Links" item that expands into a limitless list of links and sub-links. The links can be URLs, local folders, or anything that you can type into the Start>Run box! Users with permission can easily modify and add links. The application refreshes the links from the database every 30 minutes.
Lets talk security…
Since only a standard Internet connection is needed for the application to work, there were a couple of security concerns. The web service application was open to the public! That’s okay, lots of web service applications are open to the public…that’s kind of the point of them. I decided to use "keys" that had to be passed each time the application consumed a web service. In other words, a password (or key) is passed to the web service and every method (function) the web service has requires a password. What about updates? The application needs to look in a public place for updates. If its public then everyone could download the program. That’s okay too! I just had to put some security measures in place with the application is launched. Let’s just say that when the program starts it knows if it is suppose to be on that computer, if the check fails the application quits.

Custom Conversion Application

Eric — Mon, 17 Aug 2009 23:39:18 +0000

Background:

One of the many things my company does is file room conversions. To make this short and sweet, a file folder may need to be moved to a new location. In the process the folder may need a new label applied to the folder. This is simplistic example of a conversion. A client requested this type of service from us.

Problem:

This was a large conversion and the client required several specific "checks" to be in place. The original folder needed to be scanned by a barcode reader to rule out data entry errors. The barcode data would then need to be sent to the client so that other various information could be added. The data would then need to come back to us so that we could print new labels. Since this was a daily process for approximately 3 months, some tracking was needed so that at any given time a folder could be found.

Solution:

I was to create several applications to aid in the conversion process. Starting with one to handle the barcode scanning in the first stage. Next a secure web site needed to be created to allow files to be received from scanning, downloaded by the client, and re-uploaded.

Result:

Fig. 1

Fig. 2

Fig. 3

I created 2 desktop applications and 1 web application that included a web service. The first desktop application was installed on laptop with barcode scanners attached. This application would be used to gather file label barcode. Fig. 1 show the screen of the laptop with the application running. The screen provided various information and also included visual and audible verification of scanned barcodes. Because of the barcode situation on the folders, the application needed to check to make sure the barcode was in fact valid.
I provided 2 different way to get the scanned data back to the main office. One way was by using a web site upload utility. The other way was to have the barcode scanning application automatically send the file via a web service that I created. Either way, the file was placed in the same folder back at the main office. This folder was being watched my another desktop application that I made that ran on a separate machine. Once a file was uploaded, the desktop application would grab the file, import all of the data into a SQL Server, and post the file on the secure web site where the client could download the file. The client would add various information to the data and re-upload it via the web site. Date and time stamps were noted of all of the transactions. The re-uploaded file was placed in a different folder that was also watched by the desktop application. Once this file was uploaded, it was checked for certain required data, checked for the correct sort order, imported into the SQL Server, and marked as "OK" so the client would know that everything was good.
Up until now, everything was automated and only required routine checkups to make sure everything was okay. The last step was to print out the labels (sample shown in Fig. 2). The step to print the labels was simplified into dragging and dropping the file that was re-uploaded from the client into a separate watched folder. Once the file was dropped there, it was sorted into a special sort order since their sheets were later to be cut into single labels. Then a cover sheet was printed followed by the label print job. After the labels are sent to the printer the printed date and time is noted in the database and viewable from the web site.
Fig. 3 show the landing page of the web site application which allows access to several tools and lookups.