Clint Covington: Software design, Microsoft Office Access : Samples

How to pull in Amazon web service data into Access 2007

Clint Covington — Tue, 13 Mar 2007 09:01:00 GMT

Today’s guest writer is Ric Lewis. Several weeks ago he started a general discussion about web services which turned out to be a popular post. This week he is providing the details of the books sample database.

It would be sweet if someone takes this project and details it out a bit further. For example, you could imagine using the title to search for titles and popping up a list of search results to choose from. The ISBN number is a bit awkward. If you do make improvements to the project—send me an email and I will share it with the community.

Clint

Amazon Web Service Code Sample

As a note before you dig in, the code presented in this post consists of excerpts from the full project code. In other words, if you’re going to copy and paste my stuff, do it from the project, not from this post. You can grab the code for this project from here: Code Project.

For those of you who want to compile and run the plugin, here are the steps:

You can grab the code for this project from here: Code Project.
Get a new Amazon Web Service key from the Amazon Developer Center.
Replace the “############” in the DataCollector.cs code file with your new AmazonWS key (the code won't compile until you complete this step).
Build the AmazonDemoAddinSetup project.
Run the setup.exe file generated (this will install the plugin so Access can see it).
Visual Studio will generate an AmazonDemoAddIn.dll.config file in the build directory. Copy this file “\program files\microsoft office\office12” and rename it “msaccess.exe.config”

Also, this post has no pictures. Not one. So if you like pictures, look elsewhere, if you like code snippets, venture on. Okay, with that out of the way, let’s talk about this application.

Form Load

I’m all about flow-of-control discussions, so let’s trek through the app in that manner.

When you load up Access, it determines which, if any, add-ins have been installed and should be loaded. Thereafter you can reference those add-ins by name from your form’s VBA code.

Load up the Book database (from the previous post or the code project above), and you can click on the “New Book” button. This triggers a call to the Form_Load event handler in VBA code. There’s not too much VBA, so let’s step you through the code:

This first bit of code opens the form, checking first to see if it’s a new form, or an existing record.

Private Sub Form_Load()

If (Not IsNull(Me.OpenArgs)) Then

DoCmd.GoToRecord , "", acNewRec

Me.Title = Me.OpenArgs

End If

If this is a new form, or there’s just no name, then set a title for the book. This form requires a title to be set, so it’s nice to get this out of the way upfront.

If (IsNull(Me.Title)) Then

Me.Title = "Untitled"

End If

This just places the cursor in the ISBN field. You probably knew that.

Me.ISBN.SetFocus

This last bit of code is the interesting part. It connects to my addin (AmazonDemoAddIn) and calls the PrepareObject function of my add-in. We won’t go into this function too much, but it warms up the web proxy that we’ll be using later.

With COMAddIns("AmazonDemoAddIn.Connect")

' make sure the COM add-in is loaded

.Connect = True

'warm up the web proxy object--this may take a few seconds

.Object.PrepareObject

End With

End Sub

(This PrepareObject call is why the form is so slow when loading for the first time)

ISBN AfterUpdate

So, now the “New Book” form is up, with an eager cursor, blinking away, waiting for you to enter an ISBN. Type in an ISBN, leave the ISBN text box and it will trigger the ISBN_AfterUpdate code back in our VBA macros

Up to this point, we have a form for a new record, but we have not yet generated a new recordset in the database. The Me.Form.Refresh call will generate an actual recordset in the database, so we have something to pass into our add-in.

Private Sub ISBN_AfterUpdate()

Me.Title = "Retrieving from Amazon..."
Me.Dirty = False

Up to this point, we have a form for a new record, but we have not yet generated a new recordset in the database. The Me.Dirty call will generate an actual recordset in the database, so we have a recordset we can pass into our add-in.

With COMAddIns("AmazonDemoAddIn.Connect")

.Connect = True

' Hook up the desired objects

        If Not .Object.FillInBookForm(Me.ISBN, Me.Recordset) Then
            Me.Title = "Failed to retrieve from Amazon."
        End If

End With

Me.Form.Refresh

End Sub

This bit of code brings up an important point.

There are two ways to manipulate your form from your managed add-in:

Top-down: Pass in a control from your form (e.g. Me.ISBN) and manipulate its properties in your managed add-in.
Bottom-up: Pass in your form’s recordset and manipulate the record set.

For reasons too complex to get into here, if you’re adding complex data (for example, a new attachment) you’ll need to pass in the recordset. However, if your forms only contain textual data, most of that can (and probably should) be handled by manipulation of the controls.

Okay, on to the managed add-in code.

Managed Add-in

Over-simplified data flow of my AddIn.Connect class is as follows:

Grab ISBN control and Recordset passed in from VBA form code
Send ISBN value to a DataCollector object (Amazon, in this case)
DataCollector returns a Book object
Populate Recordset with information from Book object

So let’s, look at how each of those parts happens:

Grab parameters from VBA form code

Remember this call from our form VBA?

.Object.FillInBookForm Me.ISBN, Me.Recordset

This calls the following function in our AddIn:

public void FillInBookForm(Access.TextBoxClass ISBNTextBox,

Access.Dao.Recordset2 FormRS)

Send ISBN to a DataCollector (Amazon, in this case)

From here, we call CollectInfoFromWeb. This function checks if we have a DataCollector setup (we do), makes sure that the ISBN isn’t empty, and sends the ISBN on to the DataCollector.

Note that we’re accessing the .Text property of the ISBNTextBox control. This returns the text that’s currently occupies the ISBN control back in our form.

Book tempBook = CollectBookInfoFromWeb(ISBNTextBox.Text);

DataCollector returns a Book object

This is where lots of magic happens.

The DataCollector always sends back “Book” objects. You should be able to extend the DataCollector class to gather data from any Web Service you’d like (eBay comes to mind), as long as you somehow squeeze all the return data into a “Book” object.

If you’ve installed the .NET 3.0 extensions for Visual Studio 2005 (here: http://www.microsoft.com/downloads/details.aspx?FamilyId=F54F5537-CC86-4BF5-AE44-F5A1E805680D) from within Visual Studio you can add a reference to any WSDL-based Web Service just by pointing it to the WSDL. Simply right-click on your project, select “Add Service Reference” and type your WSDL into the form and Visual Studio will auto-generate a bunch of code for interacting with the service.

Once you’ve got the Service Reference added to your project, you’ll have a proxy class which you can instantiate to interact with the web service.

AmazonClient = new AWSECommerceServicePortTypeClient();

Note: all the configuration, binding and connection info for this proxy client is put in your project’s app.config file. This becomes the AmazonAddInDemo.dll.config file at build time, and needs to be renamed msaccess.exe.config copied to the directory alongside your MSACCESS.exe.

One of the methods on this proxy is ItemLookup. This call takes an ItemLookupRequest object as a parameter, so you’ll need to generate and fill out the properties of that object:

ItemLookupRequest lookupRequest = new ItemLookupRequest();

lookupRequest.ItemId[0] = myISBNString;

lookupRequest.SearchIndex = "Books";

Then make your call to ClientProxy.ItemLookup, and store the result as an ItemLookupResponse object:

ItemLookupResponse myResponse =

mAmazonClient.ItemLookup(itemLookup);

Then, lastly, we’ll map the properties from the response object into a new Book object.

newBook = new Book(currentItem.ItemAttributes.Title,

Author,

currentItem.ItemAttributes.Genre,

…);

return newBook;

Populate Recordset with information from Book object

We call .Edit() on the recordset we were sent (FormRS), and start plugging values into fields

FormRS.Edit();

FormRS.Fields["Author"].Value = tempBook.author;

FormRS.Fields["Title"].Value = tempBook.title;

…

Then for some real magic, we embed the cover art data into the recordset.

Internally, Access sees Attachments (like our cover art field), as embedded child recordsets (sub-tables). So, we’ll need to create a new record in the “Attachments” child recordset.

Access.Dao.Field2 fld =

Access.Dao.Field2)FormRS.Fields["Attachments"];

Access.Dao.Recordset2 rstChild =

(Access.Dao.Recordset2)fld.Value;

rstChild.AddNew();

And then dump our binary image data into the “FileData” field of this new record (from the URL of the image data), update the “Attachments”sub-recordset, the form’s recordset, and we’re good to go.

Access.Dao.Field2 fldChild =

Access.Dao.Field2)rstChild.Fields["FileData"];

fldChild.LoadFromFile(tempBook.coverImageURL);

rstChild.Update(1, false);

FormRS.Update(1, false);

Of course, everything you just spent 20 minutes reading about happens in less than the blink of an eye, and your when you update your Form’s recordset, the form will have all the data collected from the Web Service and you’re done (or at least I am, if you’re really into this kind of thing, you can now click “Save and New” button on your form and do the whole mess all over again).

Conclusion

Phew, I think that’s about it. Congrats if you actually made it this far. If you skipped ahead to this paragraph, I’m not going to gratify your laziness with some kind of all-summing conclusion. Hopefully, you now understand enough to know how to twist my project to explore your own wildly cool Web Service + Access intentions.

You can grab the Visual Studio project from here: Code Project.

It’s important to mention that I can’t take full credit for the generation of this demo. I leaned heavily on Ken Gatz’s excellent “Managed Add-in in Access 2007” white paper, as well as the debugging and VB skills of my fellow teammates. And frankly, the whole thing was Clint’s idea in the first place, so kudos to him as well.

If you’ve got additional, specific questions, first read Ken Getz’s whitepaper on “Managed Add-in in Access 2007” because his is a great article. If you have additional questions, feel free to post your questions here on the blog.

Web service and sample book database that uses Amazon's Web Services

Clint Covington — Tue, 20 Feb 2007 22:33:00 GMT

Today’s guest writer is Access Program Manager Ric Lewis. Ric spent the last couple years with the Indigo team and just took an Access PM job. He is looking for some customer feedback on interesting web services scenarios. To start the conversation—he created an interesting and useful sample book database that uses the Amazon web service.

Clint

Media Players

For a few years now, there has been a slowly developing convergence of databases and Web Services. Perhaps one of the best examples of this is your standard media player.

A media player is a specialized case of asset management (with the assets in this case being digital data). Of course, the biggest barrier to tracking assets in a database is manually entering the information. Remember the first time you ripped a CD and had to manually enter all the album and track info? Now we take for granted that when we rip a CD, our media player will call the Gracenote (or some other) CDDB web service and automatically fill in all the information for us.

Nowadays, most media players will even go the extra mile of calling Amazon or Wal-mart to grab a high quality cover-art pic.

A media player is a great example of a widely used database-as-asset manager. And without you really noticing it, over the last few years, between calls to CDDBs and online-music stores, your media player has increasingly become a web application.

Databases and Web Services

Web services are all about distributing information, and databases are all about organizing and visualizing that data. Internally, we talk about Access databases being a landing pad for data. Using ODBC Access databases connect in rich ways to a number of different data sources.

Access 2007 Sample Books Database

Until then, I’ve thrown together a hack-ish example of a book-asset management system in Access 2007 which calls through the Amazon web service to collect book information when you type in an ISBN number.

Installation instructions:

- Download the zip file file (right click on zip and choose Save Target As).

- Unzip it.

- Run setup.exe (install for “Just Me”)

- Copy the msaccess.exe.config file into \Program Files\Office12

- Open the Books.accdb file

You’ll also want to make sure you’ve got macros fully enabled in Access. Then just hit “New Book” (wait a few seconds if it’s the first time), type in an ISBN (ISBN-10 only, AmazonWS doesn’t like ISBN-13), tab out of the ISBN field, and watch your data get filled in!

In a later post, I’ll talk a bit more about the behind-the-scenes of how this app was developed, and share out the Visual Studio project for the add-in. Download it, play with it, break it (that shouldn’t be too hard) and let your brain start spinning up about the possibilities.

The program should “just work” on Vista, but on WinXP you’d certainly need WCF installed, which is included in the .NET 3.0 runtime.

Moving Forward

As part of investigating many areas for future work we are researching Web Services. The best way is to always start with identifying useful customer scenarios. What scenarios would you find interesting connecting to web data?

Interactive chart/form filtering code sample

Clint Covington — Fri, 22 Dec 2006 16:45:00 GMT

One of the most enjoyable design challenges I have had over the last couple of years was redesigning how users can filter inside Access and Excel. The new filter dropdown menu and context menus were lots of fun to explore different designs and think creatively about how users interact with data. I wanted to make filtering simple for everyone to use but powerful enough to answer most hard questions. One of my key goals was to build a system where users could create 90% of WHERE clauses without using the query designer. It was really fun to watch users be successful use the features in the usability lab.

Recently, I have been hunting the web and rich applications looking for different ways to visualize and interact with data. I noticed in the Microsoft Access 2003 Conversion Toolkit that a chart was used to filter tabular data. I thought it would be interesting to create a view that showed trends and data but yet was also useful. The Sales Pipeline template is an example of an application where trend-lines excite users. With a little code and a chart sub-form you can sprinkle a dab of visualization with a pinch of interactivity.

Clicking on a year, month label, or bar in the chart above will filter the Est Closed Date to the year or month selected. For example if you click on Jun you will see all sales opportunities in the month of June. Clicking on the 2007 label will show all the sales opportunities with an expected closed date in 2007. It is even smart enough to maintain filters on other columns as you filter. for example, if you filter where category = hot and click on the April month you will see all records where category = hot and in the month of April.

You can download a working sample of the Sales Pipeline database http://clintc.officeisp.net/Blogs/2006/43%20-%20Chart%20Filtering/Sales%20pipeline_chart_filter_demo.zip.

Using the new split-form you can resize the height of the chart and datasheet with the chart growing or shrinking to fill the view.

Add the Chart

Step 1. Open the Open Opportunities List and select all the controls. Remove them from the stack so that you can size the form window smaller. Move all the controls in the detail section up into a cramp space. Turn on the split form resize bar by selecting the form setting the Split Form Splitter Bar = true.

Step 2. Create a new chart called Filter Chart Sub-form. I won’t go into the details of polishing the chart and the chart settings. Add the chart to the form covering all the controls in the detail section. I found it useful to select the sub-form and setting Top = 0. Select the sub-form and set the Anchoring property to stretch down and across.

Step 3. The next step is to make sure the chart is always updated when the user adds, updates, or deletes records. I added three simple embedded macros on the AfterUpdate, AfterInsert, AfterDelConfirm events to refresh the chart.

Make the Chart Interactive

Step 1. Add reference to c:\program files\Microsoft Office\Office12\ offowc.dll.

Step 2. Add the following code to the chart sub form. The code should be fairly straight forward. You use an API call to change the cursor from an arrow to a hand when the user hovers over the bars, month, or year labels.

When the user clicks on a bar or label it builds an approriate filter string. The first iteration of the demo removed all filters and applied just the new filter. So if the user had filtered by category and applied a filter to Expected Closed Date they would be viewing all categories again. I fixed this bug using the ClearFilterFromSelectedField runcommand to remove just the current column filter instead of the entire form filter. This is a new command in Access 2007.

You will need to modify the variables sFilterField and sFilterControl in the BuildSQL function to point to the field name and control name you want to filter in your own app. I haven't tried it but there shouldn't be any reason why this technique doesn't work in report browse as well. If anyone out there wants to modify the buildSQL routine to support filtering on strings--send me the updated sample and I will post it to the community following this blog.

Anyways, here is the code:

Option Explicit

Private Const HandCursor = 32649&
Private Declare Function SetCursor Lib "user32" (ByVal hCursor As Long) As Long
Private Declare Function LoadCursor Lib "user32" Alias "LoadCursorA" (ByVal hInstance As Long, ByVal lpCursorName As Long) As Long

Dim WithEvents oChart As ChartSpace

Private Sub Form_Load()
    Set oChart = Me.ChartSpace
End Sub

Private Sub Form_Click()
    Dim sVal As String
    Dim sYear As String
    Dim iSeperator As Integer
    
    Select Case Me.ChartSpace.SelectionType
    Case chSelectionPoint
        sVal = Me.ChartSpace.Selection.GetValue(chDimCategories)
        iSeperator = InStr(1, sVal, "-")  'make sure we only filter for year or month and year
        If iSeperator = 0 Then 'selection is a year
        
            FilterByYear sVal
        ElseIf InStr(iSeperator + 1, sVal, "-") = 0 Then
            'selection is a month and year
            sYear = Trim$(Mid$(sVal, 1, iSeperator - 1))
            sVal = Trim$(Mid$(sVal, iSeperator + 1))
            
            FilterByMonth sYear, sVal
        Else
            Exit Sub 'selection is a day or somthing of a lower level that we don't filter for
        End If
                  
    Case chSelectionCategoryLabel
        'set the source object to the proper form
        sVal = Me.ChartSpace.Selection.Caption
        Select Case Me.ChartSpace.Selection.Level 'check to see what level was selected on the x axis
        Case 0  'year
            FilterByYear sVal
        Case 1  'month
            sYear = Me.ChartSpace.Selection.ParentLabel.Caption
            FilterByMonth sYear, sVal
        Case Else
            Exit Sub 'selection is a day or somthing of a lower level that we don't filter for
        End Select
        
    End Select
End Sub

'filters the db list by month
Private Sub FilterByMonth(sYear As String, sVal As String)
    Me.Parent.Form.Filter = BuildSQL(Trim$(sYear), Trim$(sVal))
    Me.Parent.Form.FilterOn = True
End Sub

'filters the db list by year
Private Sub FilterByYear(sVal As String)
    Me.Parent.Form.Filter = BuildSQL(Trim$(sVal), "")
    If Me.Parent.Form.FilterOn = False Then Me.Parent.Form.FilterOn = True
End Sub

' builds the SQL that will filter the form
Private Function BuildSQL(sYear As String, sMonth As String) As String
    Dim sFilterField As String
    Dim sFilterControl As String
    
    sFilterField = "[Est Closed Date]"
    sFilterControl = "Est Closed Date"

    If sMonth <> "" Then 'passed in year and month
        BuildSQL = "(" & sFilterField & " >= #" & FormatDateTime(sMonth & " - " & sYear) & "#) AND (" & sFilterField & " <= #" & DateAdd("m", 1, FormatDateTime(sMonth & " - " & sYear)) - 1 & "#)"
    Else 'just passed in the year
        BuildSQL = "(" & sFilterField & " >= #1/1/" & sYear & "#) AND (" & sFilterField & " <= #12/31/" & sYear & "#)"
    End If
    
    'Clear the filter from the field the chart is filtered on.
    'If you want to clear the entire filter, just set Me.Parent.Filter = "".
    RemoveFilterFromField Me.Parent, sFilterControl
    
    ' If there is still something left of the filter
    If Me.Parent.Filter <> "" Then
        ' Append
        BuildSQL = BuildSQL & " AND (" & Me.Parent.Filter & ")"
    End If
End Function

Private Sub RemoveFilterFromField(frm As Form, strControlName As String)
    frm.SetFocus
    frm.Controls(strControlName).SetFocus
    
    On Error Resume Next
    DoCmd.RunCommand acCmdRemoveFilterFromCurrentColumn  ' This command is new to Access 2007.
    
    Debug.Assert Err.Number = 0 Or Err.Number = 2046 ' 2046 is thrown when there was no filter on the column
    Err.Clear
End Sub

Private Sub Form_CommandBeforeExecute(ByVal Command As Variant, ByVal Cancel As Object)
    ' Cancel the ability to drill into days and hours.
    If Command = chCommandDrill Then
        Cancel = True
    End If
End Sub

Private Sub oChart_MouseMove(ByVal Button As Long, ByVal Shift As Long, ByVal x As Long, ByVal y As Long)
    Select Case TypeName(Me.ChartSpace.RangeFromPoint(x, y))
    Case "ChCategoryLabel", "ChPoint"
        'display hand cursor if pointer is over a label or bar
        SetCursor LoadCursor(0, HandCursor)
    Case Else
        'display the normal cursor
        Screen.MousePointer = 0
    End Select
End Sub

Design for filter favorites functionality in forms

Clint Covington — Sat, 09 Dec 2006 04:04:00 GMT

Access 2007 introduces a ton of new filtering tools that make it much easier to cut and slice data in different ways. I’m very happy about the new experience and think developers will spend far less time building filtering functionality because of the built in functionality. However, in all releases there are always one or two features round out the scenario that don’t fit into the milestones. One of the ideas we had planned to implement was the notion of filter favorites for any view. The basic idea is to allow users to save common or complex filters and sorts. Unfortunately, that feature was one of the last cuts we made.

Earlier this summer when I was home on paternity leave I had the chance to play around adding filter favorites to our templates. A key goal for the feature was to make it so simple that most users would be successful using and managing filters/sorts.

One of the goals of our templates is that they don’t have VBA code. We want them to run in sandbox mode without requiring users to enable code. The new functionality is all written in macros without VBA code. You can download a working sample from http://clintc.officeisp.net/Blogs/2006/44%20-%20Filter%20Favorites/Filter_Favorite_Sample.zip.

Let me describe how it works. There is a dropdown control in the upper right corner with a command for saving a filter.

The dropdown control provides users with the ability to clear filters, manage filters, and any saved filters. Selecting Clear Filter will remove the forms filter. Selecting any of the other filters will change the current filter of the document.

It is pretty easy to add new filters to the dropdown. Simply filter the list and click on the Add Filter button. This takes a copy of the current filter and sort and saved it in the Filters table. The user is asked to provide a name and description:

The Show details >> link shows the actual filter and sort SQL strings. I believe it is important to hide unnecessary complexity but provide intuitive ways for advanced users to find it. Most users simply don't need to see that kind of gunk.

If you want to add this functionality to your form it is pretty simple. Import the Filters table, Filters macro, and Filter Details form. Copy and paste the dropdown control and Save Filter button to your form.

As I was writing this blog post I realized you can't delete filters without going to the table. We will get that fixed before the templates are updated. You will also notice icons an all the form buttons--they make it all look much nicer.

If anyone wants to make filter favorites work in report browse with custom ribbons--send me the code and I will post it. Anyone have other suggestions how we can make it better?