Janne Mattila's blog : 2007 Office system

Simple Outlook Add-in with VSTO 3.0

jannemattila — Sun, 06 Apr 2008 22:56:37 GMT

Creating add-ins with Visual Studio 2008 and VSTO 3.0 (Visual Studio Tools for Office) is easy and fast… Just use File –> New –> Project –> Select correct add-in i.e. Outlook 2007 Add-in and you project template is created. And you can run you add-in in debug by just hitting F5! So the basic setup is just few clicks and then you’re ready to start implementing your actual functionality i.e. extending ribbon etc.

In this post I’m going to create simple add-in that demonstrates how you can send emails on behalf of someone else and the selection for doing that is done automatically. Let’s go through the scenario since it’s easier to understand the functionality that way.

I have users John, Jane and Administrator. John wants to contact Jane but doesn’t know how to contact her so he sends out email to the administrator:

Administrator receives mail from John:

Since Administrator knows Jane’s home phone he can contact her in urgent matters and get her message back to John. In this case Administrator just presses Reply to John’s email and writes the message as Jane dictates it over the phone:

John receives email that appears to be written by Jane:

Okay that was our scenario and now let’s see how it was created.

Step 1: Well this is pretty obviously :-)

Step 2: Write following code (and as always.. use this at your own risk :-). This should be extended with better error handling, sanity checks etc.):

using Microsoft.Office.Interop.Outlook;
using System.Windows.Forms;

namespace My_Outlook_2007_Add_in
{
  public partial class ThisAddIn
  {
    MailItem _mailItem = null;
    private void ThisAddIn_Startup(object sender, System.EventArgs e)
    {
      this.Application.ItemLoad += new
        ApplicationEvents_11_ItemLoadEventHandler(Application_ItemLoad);
    }

    void Application_ItemLoad(object Item)
    {
      if (Item is MailItem)
      {
        try
        {
          MailItem mailItem = Item as MailItem;
          mailItem.Open += new 
            ItemEvents_10_OpenEventHandler(mailItem_Open);
          _mailItem = mailItem;
        }
        catch (System.Exception ex)
        {
          MessageBox.Show(ex.ToString(), 
            "Exception", 
            MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
      }
    }

    void mailItem_Open(ref bool Cancel)
    {
      if (_mailItem.Subject.Contains("Jane") == true)
      {
        // This requires "Send As" privileges at the AD:
        _mailItem.SentOnBehalfOfName = "jane@contoso.com";
      }
    }

    private void ThisAddIn_Shutdown(object sender, System.EventArgs e)
    {
    }

    #region VSTO generated code
    /// <summary>
    /// Required method for Designer support - do not modify
    /// the contents of this method with the code editor.
    /// </summary>
    private void InternalStartup()
    {
      this.Startup += new System.EventHandler(ThisAddIn_Startup);
      this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);
    }
    
    #endregion
  }
}

Code works so that we first trap events from ItemLoad (on line 11). In Application_ItemLoad we check that is this current item MailItem and if it is we then hook Open event of that Item. And when mail item is opened we’ll check that does that contain Jane at the subject. And if it does then we set the SentOnBehalfOfName property for the mail item. You need to modify contents between lines 37 and 41 to make this work in real life. I just made this as simple as possible. So probably adding few more checks isn’t bad idea :-)

Step 3: Build, Test and when everything is working then Publish:

Publishing wizard asks the location for the published files:

After that published location contains following files:

Setup.exe installs the add-in. Application Files folder contains subfolder for each version of the add-in (since it will be published to same location on update). You can actually control the check for new versions from VS (by default add-in checks for update once per week):

Now you can install the add-in for all the necassary users. Setup also knows about prerequisites (.NET framework 3.5 and VSTO 3.0 Runtime) and knows how to get them during install:

And when prereqs are ok we’re ready to install our app (this screenshot is from Windows Server 2003):

After the installation add-in can be seen in Add Remove Programs (and removed if needed):

Now your Outlook will work as described at the beginning of the post.

Hmm… you might start wondering that isn’t there few security issues in this approach? How can administrator act as Jane and how that isn’t displayed at his Outlook? Well by default security forbids this kind of scenario but if this kind of approach is needed then you need to give permission to the users at the AD (Important note: I gave Everyone permissions to “Send As” but that is not the way to go in real life):

And what does Outlook do then? In previous screenshots Outlook didn’t notify administrator about the SentOnBehalfOfName property change. However if you add more email addresses to your email then Outlook refreshes the view to this:

So Outlook added From… field and it now clearly indicates that this message will be send as Jane. Outlook just makes sure that user is aware of the senders change. Obviously our add-in could inform the end user with some kind of tooltip or something like that but I’ll leave those details to you.

Well here was small example of Outlook add-in. I’ll probably come back to add-ins in near future so stay tuned…

Anyways… Happy hacking!

J

From InfoPath to Database via Web Service

jannemattila — Thu, 25 Oct 2007 15:09:17 GMT

I have been asked to build this kind of example sooooo many times that now I really need to write this down :-) This stuff isn't rocket science but I have got so many emails about this so I just want to answer all those questions at once.

So I have previously written about getting data from web service to the InfoPath. Now I'm going to show you how can you create web service that stores the data from InfoPath to the database. Nothing fancy but just to give you some starting points if your planning to do this.

I'm not going to create new InfoPath form for this so I'll just re-use the previously created example.

I just added new method to my web service to handle insert of new employee:

[WebMethod]
public int AddNewEmployee(Employee employee)
{
  int rowsAffected = 0;
  using (SqlConnection conn = new SqlConnection("..."))
  {
    SqlCommand cmd = new SqlCommand("INSERT INTO Employees " +
      "(EmployeeNumber, Title, FirstName, LastName, Salary) " +
      "VALUES(@EmployeeNumber, @Title, @FirstName, @LastName, @Salary)", conn);

    cmd.Parameters.AddWithValue("@EmployeeNumber", employee.EmployeeNumber);
    cmd.Parameters.AddWithValue("@Title", employee.Title);
    cmd.Parameters.AddWithValue("@FirstName", employee.FirstName);
    cmd.Parameters.AddWithValue("@LastName", employee.LastName);
    cmd.Parameters.AddWithValue("@Salary", employee.Salary);

    conn.Open();
    rowsAffected = cmd.ExecuteNonQuery();
  }

  return rowsAffected;
}

It accepts the previously defined struct as parameter and it then just puts it into the database. It can't be any simpler right :-) Just add your own connections string and create new database+table and you're good to go.

In my InfoPath form I change the label of button from Get employee data to Insert new employee. Then I added new web service of type "Retrieve data"... and not type "Submit data". Why? Well because "Retrieve data" has more ways to modify the parameters. I think that "Submit data" type is quite limited on that.

Of course I also needed to change the rule of the button too:

Notice that last action is Show dialog box expression.. I just that to display the return value but of course that isn't necessary (and it's not supported by InfoPath Form Services anyway).

Now I'm ready to take this for a test spin:

Pressing button will then give me this dialog:

And if I go to the database I'll see something like this:

Database verifies our story. So 1 new row with the data that I have typed into the InfoPath form has come up...

This was quick intro how you can create whole chain from InfoPath to web service and then to database.

Anyways... Happy hacking!

J

Transferring attachment file from Web Service to InfoPath

jannemattila — Thu, 08 Feb 2007 09:21:27 GMT

I previously posted about InfoPath and Web Service data connections. Back then I didn't mention that you could use the same method to transfer InfoPath attachments as well. It's actually pretty straightforward thing. All you need to do at the web service is wrap up you existing file data to InfoPath file attachment format and return it as BASE64 encoded. It sounds easy and it really is. Well enough talking... let's checkout the code!

First we need method that creates InfoPath attachment from byte array. It could be something like this:

 1  static public String CreateInfoPathAttachment(String fileName, byte[] fileData)
 2  {
 3      // This memory stream for InfoPath attachment buffer before Base64 encoding.
 4      using (MemoryStream ms = new MemoryStream())
 5      {
 6          uint fileNameLength = (uint)fileName.Length + 1;
 7          byte[] fileNameBytes = Encoding.Unicode.GetBytes(fileName);
 8
 9          using (BinaryWriter bw = new BinaryWriter(ms))
10          {
11              // Write the InfoPath attachment signature. 
12              bw.Write(new byte[] { 0xC7, 0x49, 0x46, 0x41 });
13
14              // Write the default header information.
15              bw.Write((uint)0x14); // size
16              bw.Write((uint)0x01); // version
17              bw.Write((uint)0x00); // reserved
18
19              // Write the file size.
20              bw.Write((uint)fileData.Length);
21  
22              // Write the size of the file name.
23              bw.Write((uint)fileNameLength);
24  
25              // Write the file name (Unicode encoded).
26              bw.Write(fileNameBytes);
27  
28              // Write the file name terminator. This is two nulls in Unicode.
29              bw.Write(new byte[] { 0, 0 });
30              bw.Write(fileData);
31          }
32          return Convert.ToBase64String(ms.ToArray());
33      }
34  }

This code has been "copy-pasted" mainly from this source. However there is unnecessary code (=my opinion) so I have changed it a little bit. I prefer using the existing ToBase64String method (unlike in original code sample).

Now all you need to do at you web service is to pass filename and data to the method and it creates BASE64 encoded string that can be returned to the InfoPath.

1  ...
2  String fileName;
3  DocumentContainer myDocument;
4  ...
5  byte[] fileData = File.ReadAllBytes(fileName);
6  myDocument.Size = fileData.Length;
7  myDocument.Document = CreateInfoPathAttachment(fileName, fileData);
8  return myDocument;

In my example I use similar approach as in my previous example. I have Document struct that has (in this case) at least to fields: size and document. And in InfoPath I could map those fields exactly as I explained in my earlier post. Now you just map Document field to your InfoPath attachment and that's it:

And what makes this really nice... it works also with Forms Services as well! Of course this idea could be also otherway around... so you could sent file from InfoPath to web service using the same underlying idea. In that case you should only parse the InfoPath attachment so that you get the original filename and filedata. Read more about this case in here.

Anyways... Happy hacking!

J

InfoPath and Web Service data connection

jannemattila — Sun, 21 Jan 2007 14:08:27 GMT

I have used InfoPath mainly with SharePoint and my experiences have been quite good. However I have always felt like something was missing... something that would really warm my developer heart. And I have found it! It's nice integration with Web Services. InfoPath can retrieve and submit data to the Web Services with just few lines of code for Web Service and few button clicks at the InfoPath. But if you're creating serious application you should definitely create XML Schema that is shared with applications. It would be easy to use ready-made schema at the InfoPath and in your other applications as well. I'm just going to create small example that uses web services to get data to few fields at the InfoPath. In my experience it's fairly common that you have a lot of fields at the InfoPath and then you would like to autopopulate some of the fields based on some other fields. You probably want to get your employee/customer/product data from some of the back-end systems like ERP, CRM, etc. So this example demonstrates simple way of achieving that kind of functionality. I'm going to present this development process in "real world scenario". So it means that developer creates web service and UI Designer creates the InfoPath form (Warning! It may contain sarcasm!). But enough talking... Let's start hacking!

1. Create web service to return employee data

First we're going to create simple web service that returns some employee data (and now 'we' stands for person in developer role):

 1: using System;
 2: using System.Web;
 3: using System.Web.Services;
 4: 
 5: public class Service : System.Web.Services.WebService {
 6:     public struct Employee {
 7:         public int EmployeeNumber;
 8:         public String Title;
 9:         public String FirstName;
10:         public String LastName;
11:         public Decimal Salary;
12:     }
13: 
14:     [WebMethod]
15:     public Employee GetEmployee(int employeeNumber) {
16:         Employee employee = new Employee();
17:         employee.EmployeeNumber = employeeNumber;
18:         employee.Title = "Developer";
19:         employee.FirstName = "John";
20:         employee.LastName = "Doe";
21:         employee.Salary = 12345;
22:         return employee;
23:     }
24: }

Of course your data should be retrieved from your favorite back-end system, but I'll just return some dummy data. Okay now we just compile (and deploy if necessary) our web service so it can be used by InfoPath. And copy the WSDL url because you need it later when dealing with the InfoPath form.

2. Create InfoPath form

If I would be really lazy I would use Design a form template -> Web Service since it's really straightforward if you want to retrieve and submit data with Web Services. But I'm just going to take Design a form template -> Blank. Because in many cases the UI designer doesn't know much about programming. Designer just drag & drops the controls to the template and stops working with the template when it looks good (Note: this form is my handwriting so it hasn't even seen any UI design experience :-).

After that designer gives the template to the developer. And developer sees right away that designer didn't think about those pretty important things like schemas and data sources.

Developer doesn't want to do any extra work so he just renames the controls so that they're are easily understandable.

After that developer changes the Form Template Properties at the File -> Properties. And now developer is ready to add web service datasource to the InfoPath form.

3. Create Web Service datasource

Under Tools -> Data Connections add new data connection:

Select Receive data and press Next.

Select Web service and press Next.

Paste the url of the WSDL and press Next.

Select GetEmployee method from the list (it's the only one so easy selection :) and press Next.

Take away selection from Automatically retrieve data when form is opened and press Finish.

4. Create Rule to the button that uses the new datasource

Now we have managed to create connection to our web service. Let's add the Rule to the button so that web service is called when user clicks the button. The Rule will contain following phases:

Set parameter for the Web Service Call
Make the Web Service Call
Set field values for each field from the secondary datasource (=Web Service)

Right click on the button and select Properties. Click on the Rules button and then click Add button from the Rules dialog. Write name of this new rule (like Get employee data from Web Service).

Then we need to add some actions to the rule. Just click Add action button:

Verify that your checkbox is Set a field's value and then press button next to the Field textbox. Then you can select the employeeNumber from the GetEmployee data source.

After that you do the same for the Value field. That was phase 1.

Phase 2 is really simple... just add new action for Query using a data connection: GetEmployee.

Phase 3 contains quite many button clicks... just create Set a field's value actions for each value return from the Web Service field:

Finally we have following Actions in our Rule:

And now we're ready to test our form. Just press Preview toolbar item. When form opens you can fill Number field with some number and populate the other fields by pressing the Get employee data button:

Fields are filled with the retrieved data from the Web Service.

Summary

Now you know howto create simple Web Service call from InfoPath. But you may wonder that how did those field names come from the web service struct into the InfoPath form? Well if you look at the services WSDL you can see, that it contains definitions for the Employee data structure:

So it's really easy to create small struct that contain the necessary datas you want to expose from your service. It's easy and fast, but more correct way would be using the schemas. See Creating a web service for InfoPath from in 25 easy steps article from the links below. And of course posting the data to the web service would be exactly the same as this example. Just create new Rule that first copies all values from the fields in the form to the datasource fields. And after that you just call the correct method from the datasource. Isn't it easy... I think it is.

That was my InfoPath post this time. And maybe next time something completely different stuff :)

Anyways... Happy hacking!

J

Links to similar resources

Build a Custom SharePoint Web Service for Your InfoPath 2003 Documents
-- Howto retrieve and submit data with XmlDocument

Creating a web service for an InfoPath form in 25 easy steps
-- Creates InfoPath form and then extracts XML Schema out of it (Note: Exporting source files in InfoPath 2007: File->Save as Source Files). Then xsd.exe is used to create .cs -file. It's then added to Visual Studio and used when creating the web service. And developer can enjoy full support from IntelliSense.

Querying and Updating a Database Using Web Services in InfoPath and ASP.NET
-- Example that uses DataSets with InfoPath.