Steve Fox's OBA Ramblings : OBA

Sharepoint 2010 development using bcs

Steve Fox — Sat, 26 Dec 2009 02:15:28 GMT

One of the big features for SharePoint 2010 (and for building OBAs) is the Business Connectivity Services (BCS). I’ve written a few posts on this, but wanted to follow up on these early posts with some additional detail on how to create a solution leveraging web services. I see many customers trying to tie together SharePoint with external systems using a service-oriented design.

In this post, I’ll walk through how you can leverage a web service using the BCS (specifically employing the BDC Model project template in VS 2010) to create a read-only relationship with an external data source. This will be the first post in a series that will eventually cover the broad CRUD spectrum. So, let’s get down to it.

The high-level process you will want to go through is as follows:

Create the data source;
Create a service that interacts with your data source;
Create the external content type using VS 2010; and
Use the external content type in SP 2010 to create a web-service enabled external list.

Creating the Data Source

In this example, the data source is a SQL Server db with a single table with five records—see figure below. The number of records are less important than the structure of the columns.

You can choose to use something similar or create something different. If you use the code in this blog-post and you’re new to this, then create a db table with a similar structure. The following shows the data types in this simple table.

You create the new data source in SQL Server 2008 by right-clicking the Databases node and selecting New Database. Design your columns as per the above and then save the db when complete.

Creating the Web Service

With your db created, you now want to create a web service to interact with that db. We’ll create an ASP.NET service in this example to again keep things simple. (Note that you could equally apply much of the code to a WCF service.)

Open Visual Studio 2010 and create a new ASP.NET service application. You’ll want to add a new data source as an entity model. You can do this by click Data and then Add Data Source and then walking through the new data source wizard. I called my new data model CustomerSale—see the figure below to understand how Visual Studio interprets the data types.

You’ll need an in-memory object, so right-click your project and click Add and then select Class. Call your class CustomerSalesInfo.cs (or <name>.vb) and then click OK. You want to map the properties of your object to that of the data source. Here is the code for that object. You’ll note that I didn’t map the data types exactly. I do some in-code translation of data types.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace CustomerServiceBCSApp
{
    public class CustomerSalesInfo
    {
        public string custID { get; set; }
        public string custName { get; set; }
        public string custEmail { get; set; }
        public string custRegion { get; set; }
        public string custFY08Sales { get; set; }
        public string custFY09Sales { get; set; }
    }
}

Now you can write some code in your core service class. As this blog post is about read only, it will cover two web methods: one for reading the entire list and another for reading one item in a list. You’ll note that you require these two methods to create an external content type using BCS. In the code below, note that I’m creating a data context for my entity model called myCustomerData and there’s a class-level list collection I’m also creating called myCustomerList. The list collection is what I use to build out and populate my in-memory object (which I’ll return in the getAllCustomers() method. In fact, in the getAllCustomers() method I simply use a LINQ statement to query and get all of the data in the data context, and then I iterate through the members of the var returnListOfData object to creater my in-memory object. You may choose another method here (maybe even foregoing the in-memory object) to optimize your code. I pass no parameters to the getAllCustomers method as this is my, so to speak, “SELECT *” statement.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;

namespace CustomerServiceBCSApp
{

    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]

    public class Service1 : System.Web.Services.WebService
    {
        CustomersEntities myCustomerData = new CustomersEntities();
        List<CustomerSalesInfo> myCustomerList = new List<CustomerSalesInfo>();

        [WebMethod]
        public List<CustomerSalesInfo> getAllCustomers()
        {
                var returnListOfData = (from customer in myCustomerData.CustomerSales
                                  select customer).ToArray();

                foreach (var cust in returnListOfData)
                {
                    CustomerSalesInfo tempCustomer = new CustomerSalesInfo();
                    tempCustomer.custID = cust.CustomerID.ToString();
                    tempCustomer.custName = cust.CustomerName.ToString();
                    tempCustomer.custEmail = cust.CustomerEmail.ToString();
                    tempCustomer.custRegion = cust.CustomerRegion.ToString();
                    tempCustomer.custFY08Sales = cust.CustomerFY08Sales.ToString();
                    tempCustomer.custFY09Sales = cust.CustomerFY09Sales.ToString();
                    myCustomerList.Add(tempCustomer);
                };

return myCustomerList;
}

        [WebMethod]
        public string[] getACustomer(string strparamCustomerID)
        {
            int tempIntCustomerIDParam = Int32.Parse(strparamCustomerID);
            string[] myCustomerList = new string[6];

            var returnIndiviualDataItem = (from customer in myCustomerData.CustomerSales
                                .Where(x => x.CustomerID == tempIntCustomerIDParam)
                                           select customer);

            foreach (var cust in returnIndiviualDataItem)
            {
                myCustomerList[0] = cust.CustomerID.ToString();
                myCustomerList[1] = cust.CustomerName.ToString();
                myCustomerList[2] = cust.CustomerEmail.ToString();
                myCustomerList[3] = cust.CustomerRegion.ToString();
                myCustomerList[4] = cust.CustomerFY08Sales.ToString();
                myCustomerList[5] = cust.CustomerFY09Sales.ToString();
            }

return myCustomerList;
}

}
}

The second method takes a string parameter (a customer ID) and then builds a LINQ query based on that parameter. In this instance, I wanted to use a string array that I can easily parse on the other side. I do prefer to leverage generics wherever possible because I like the flexibility of dynamic collections as opposed to hard-coded lengths, but for this sample I though it interesting enough to show both examples.

Once you’ve gotten this far, you can test out the web service to make sure it runs. Test it from VS 2010 and then deploy it to IIS. To do this, create a new folder in your wwwroot folder (I called mine SPConnections) and then publish your service to that directory.

To publish the service, right-click your web service project select Publish and complete the options in the Publish Web dialog. Specifically, change the Publish Method to File System and then point the Target Location to the folder you just created under wwwroot.

Click Publish to publish the service to that directory. Now, any time you make changes you can simply click Publish and your service definition and code will be updated.

Since you’ve published your service to the file system, you’ll now want to create a web application in IIS that points to this service. To do this, open IIS and right-click the Sites node and select Add Web Site. Provide a name for the site, map the physical path to the folder under wwwroot (where you published your service to), give the site a unique port (e.g. 1111), click the Connect As button to provide the appropriate permissions for the service. (Note that you may have issues accessing the SQL Server if you have not configured the App Pool correctly—e.g. you can access using Local System or Network Service as opposed to the native Application Pool Identity.) Enable Windows Forms authentication by clicking Authentication and then clicking Windows and then Enable.

To test the service from IIS, click the Content tab and then right-click Service1.asmx and select Browse. You should be able to execute both methods—one to get all of the customers in your db and the other (by passing a customer ID that exists within your db) to get a specific customer.

Creating the External Content Type (ECT)

You’ll create the ECT using the new BDC Model project. To find this, click File, New, Project, and then in the SharePoint 2010 folder select Business Data Connectivity Model. Provide a name for your project and click OK.

Using this template is a little different from SharePoint Designer (SPD) 2010, which also enables you to build out ECTs. My personal feeling is that SPD is a little easier to create the ECTs, but then if you want to have more complex projects that perhaps leverage other parts of the .NET Framework then using the VS project is better. Note that VS also deploys the ECT (and all associated code) as a feature as opposed to an XML file to the Metadata Store (as is the case with SPD 2010).

Okay, now you have your project set up you need to edit the Entity1 object to map to your external data source entity. You’ll note that I’ve kept a lot of the default namespaces and objects in this example. I’ll change these in future posts and keep you apprised as to the places you’ll need to look out for when trying to update/change these. To follow is what your Entity1 should now look like.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace WroxTestBDC.BdcModel1
{
        public partial class Entity1
    {
        public string Identifier1 { get; set; }
        public string custName { get; set; }
        public string custEmail { get; set; }
        public string custRegion { get; set; }
        public string custFY08Sales { get; set; }
        public string custFY09Sales { get; set; }
    }
}

As a general rule of thumb, as soon as you’ve made the change to your Entity1 object go immediately to your .bdcm (the ECT model) and amend the entity structure there as well, or your deploy will fail. Also note that the way in which you edit your methods should actually correspond to the code-behind. For example, the structure of my ReadItem method (which is where I’ll call my getACustomer web method) passes the Identifier1 parameter and returns an object from my database via the web method. Similarly, the ReadList method will return a list of objects, and it defines this return object through the Entity1List object in the taxonomy below.

Now, note again I’m only doing a read-only transaction—mostly because this is a good jumping off point but also because these two methods are created by default for you.

Okay, before we jump to the code behind add a reference to the web service. To do this, right-click the BCS project and select Add Service Reference. Add the URL to the service (copy and paste the URL from your IIS browse) in the Service field, provide a name for your service and click OK.

At this point, you are now ready to implement the service (i.e. the two web methods you created) in the VS project.

Navigate to the Entity1Service.cs file and make sure your code looks like the following code snippet. You can see that I create an instance of the service and then call the appropriate method on that service to return the code from my external data source. Note that in the case of the ReadItem method, it takes a string parameter (which would get activated when you click on a record in the external list). I’ve changed the default IEnumerable return object to use my preferred List<> object (which is essentially a list collection of the Entity1 object).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using WroxTestBDC.CustomerSalesWS;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.Linq;

namespace WroxTestBDC.BdcModel1
{
    public class Entity1Service
    {
        public static Entity1 ReadItem(string id)
        {
            CustomerSalesWS.Service1SoapClient myWSProxy = new CustomerSalesWS.Service1SoapClient();
            string[] returnedData = new string[6];
            returnedData = myWSProxy.getACustomer(id).ToArray();

Entity1 entity1 = new Entity1();

            entity1.Identifier1 = id;
            entity1.custName = returnedData[1];
            entity1.custEmail = returnedData[2];
            entity1.custRegion = returnedData[3];
            entity1.custFY08Sales = returnedData[4];
            entity1.custFY09Sales = returnedData[5];

return entity1;
}

        public static List<Entity1> ReadList()
        {
            CustomerSalesWS.Service1SoapClient myWSProxy = new CustomerSalesWS.Service1SoapClient();
            var salesData = myWSProxy.getAllCustomers();

List<Entity1> mySalesInfoList = new List<Entity1>();

            foreach (var item in salesData)
            {
                Entity1 tempEntity = new Entity1();
                tempEntity.Identifier1 = item.custID.ToString();
                tempEntity.custName = item.custName.ToString();
                tempEntity.custEmail = item.custEmail.ToString();
                tempEntity.custRegion = item.custRegion.ToString();
                tempEntity.custFY08Sales = item.custFY08Sales.ToString();
                tempEntity.custFY09Sales = item.custFY09Sales.ToString();
                mySalesInfoList.Add(tempEntity);
            }

return mySalesInfoList;
}

}
}

At this point, you can build and deploy the ECT by right-clicking the project and selecting Deploy.

Before you go to SharePoint, one thing you’ll need to make sure you do is to copy the property settings for your system.serviceModel in your app.config file to your SharePoint’s web.config file—else you will get nasty web configuration errors.

<system.serviceModel>
        <bindings>
            <basicHttpBinding>
                <binding name="Service1Soap" closeTimeout="00:01:00" openTimeout="00:01:00"
                    receiveTimeout="00:10:00" sendTimeout="00:01:00" allowCookies="false"
                    bypassProxyOnLocal="false" hostNameComparisonMode="StrongWildcard"
                    maxBufferSize="65536" maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
                    messageEncoding="Text" textEncoding="utf-8" transferMode="Buffered"
                    useDefaultWebProxy="true">
                    <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
                        maxBytesPerRead="4096" maxNameTableCharCount="16384" />
                    <security mode="None">
                        <transport clientCredentialType="None" proxyCredentialType="None"
                            realm="" />
                        <message clientCredentialType="UserName" algorithmSuite="Default" />
                    </security>
                </binding>
            </basicHttpBinding>
        </bindings>
        <client>
            <endpoint address="http://localhost:289/Service1.asmx" binding="basicHttpBinding"
                bindingConfiguration="Service1Soap" contract="CustomerSalesWS.Service1Soap"
                name="Service1Soap" />
        </client>
    </system.serviceModel>

After this, you are now ready to create the external list in SharePoint 2010 using your newly create web-service enabled ECT.

Creating the External List

You can now create the external list in SharePoint. To do this, click the All Site Content link and click Create. Then in the Create options, click List and click External List. Click Create.

When the External List page opens, provide a name for the list and then in the External Content Type field click the right-most icon to browse for external content types that have been deployed to SharePoint. Click Create when complete.

At this point, your external list will have been created. The two read operations will enable you to have the full list of your records in the Customers database (via web service) rendered in the list—see below.

And if you click on one of the records it will display the individual record—see below.

And there you have it. You now have a web-service enabled external list.

In future posts, I will show you how to add new web methods to handle update, create and delete and then add the corresponding code in the BDC project you just created.

But for now, enjoy your holiday dinners!

Steve

get trained with Sharepoint 2010 and office 2010 videos

Steve Fox — Sat, 05 Dec 2009 17:01:11 GMT

One of the charters of my team is to make sure that we provide collateral for developers to get up and running with a program called Metro—an early adoption program for ISVs (to sign up for Metro or get more information, you can email metroreq@microsoft.com). Part of this program is creating things like training videos, Hands-on labs, and source-code; all for the developer to get up to speed quickly and efficiently with SharePoint and Office 2010. (We also cover CRM and UC.)

One of the first publicly-facing things we’ve done is to begin posting our PowerPoint decks and SharePoint and Office 2010 developer videos on Channel 9 in our new Learning Centers as a complement to other collateral that is out there today. There are some great videos here that you can watch for 10-15 minutes at a time. To get them, navigate to the top-level learning center on Channel 9 (http://channel9.msdn.com/learn/ or go straight to the either of the learning centers:

SharePoint 2010: http://channel9.msdn.com/learn/courses/SharePoint2010Developer/

Office 2010:

http://channel9.msdn.com/learn/courses/Office2010/

There are some great videos here, and the guys (Donovan Follette and Paul Stubbs) have done a fantastic job rallying this content.

There’ll be more to come with full downloadable packages coming next week and hands-on labs and source code coming at the beginning of January.

Happy Coding!

Steve

OBA Sample Application Kit for SAP & Siebel Released to Web

Steve Fox — Tue, 09 Jun 2009 00:57:09 GMT

Over the past few months, we’ve received some very positive feedback on the OBA Sample Application Kits that we’ve released. Well, today we release to web the latest in the family of kits, the OBA Sample Application Kit for SAP & Siebel. Included in this kit are:

Overview whitepaper
Source code
Installation guide
Developer guide

As per the diagram below, this latest OBA kit provides guidance on how developers can integrate Outlook and MOSS 2007 with Siebel and SAP. It integrates a variety of key MS technologies (e.g. BizTalk LOB adapters, WCF, VSTO, and so on) to help you understand how you can integrate LOB systems such as Siebel and SAP into your Office and SharePoint solutions.

The actual developer kit can be found here: http://code.msdn.microsoft.com/sapsiebel. And for more information on other OBA developer kits, you can go here: http://msdn.microsoft.com/en-us/office/cc442491.aspx.

Enjoy!

Steve

Web Services and SharePoint: How do I do it?

Steve Fox — Sun, 08 Feb 2009 08:03:00 GMT

When building an OBA, you’re often going to want to either integrate with the native Web services for SharePoint (when I say SharePoint, in this instance I’m referring to both the WSS and the MOSS services) or you’ll want to create your own custom services. The question often comes up is how? In this post, I’ll show you a couple of different ways of doing this by creating a custom client app that achieves the same thing (i.e., inserts a record into a SharePoint list). Before we get to the client app, though, let’s quickly review a few of the more common ways that we can deploy a service:

ASMX Web service that is deployed into the SharePoint hive (e.g. deployed into the _vti_bin or _layouts folder;
ASMX Web service deployed to its own Web application domain;
WCF service deployed into the _vti_bin or _layouts folder; and
WCF service deployed into its own Web application domain.

When deploying an ASMX service into the _vti_bin, there are a few things that you need to do in order to prepare your service to be supportable by SharePoint. While based on VS 2005, you can apply the same methods for VS 2008 by using the article here: http://msdn.microsoft.com/en-us/library/ms464040.aspx. Most important to remember are:

Add DLL to GAC;
Run Disco tool against ASMX file;
Add the appropriate amendments to the .dsco and .wsdl files (see the aforementioned article);
Rename the x.dsco and x.wsdl files to be xdsco.aspx and xwsdl.aspx;
Copy the .asmx file, xwsdl.aspx and xdisco.aspx files to the _vti_bin folder.

When deploying a service (ASMX or WCF) to its own web app domain, you need to first make sure you create and publish your web service to a folder on your application server and then map that folder to an IIS web site. To do this:

Open IIS;
Create a New Web Site;
Map the Path to the folder where your service is published;
Set Permissions (use either ASP.NET Impersonation or Windows Authentication and set to Enabled); and
Refresh the view of your site.

Now you’ll likely need what is called a client access policy or cross-domain policy file, which are files that are required for cross-domain calls into SharePoint. You may also need to have the files in your published web site root folder as well as having them in your SharePoint site root folder. Note: While you can copy and paste the policy files into your IIS web site, remember that you should use SharePoint Designer to open the SharePoint site and then copy the policy files to the root directory of the site. Here is a snapshot of what the root folder in my Content View of IIS (7.0) looks like:

When deploying a WCF service to SharePoint, you need to remember that you must create a VirtualPathProvider because SharePoint doesn’t support the loading of .svc files. A good summary of how to do this is here: http://blah.winsmarts.com/2008-5-SharePoint_2007_as_a_WCF_host_-_Step_-4,_Write_a_Virtual_Path_Provider.aspx.

If you use the native Web services that ship with SharePoint (e.g. Lists, Excel Services, or BDC), you can simply open up a VS project and add these to your project. To discover the services, click Add a Web Reference and then click the Web services on this local machine (presumably you’ve got SharePoint on that machine), and then all of the SharePoint services will be listed.

In my example, I’ll show you how to call a custom web service (that uses WCF and ASMX deployed to their own IIS web sites) and a native SharePoint web service that does the same thing as the custom code. The custom code in my service that I’m using to insert the record into a SharePoint list called “TR8” is listed as follows (at least this is how it looks for the ASMX service):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Services;
using Microsoft.SharePoint;

[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
// To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.
// [System.Web.Script.Services.ScriptService]
public class UpdateSharePointList : System.Web.Services.WebService
{
public UpdateSharePointList () {

        //Uncomment the following line if using designed components
        //InitializeComponent();
    }

    [WebMethod]
    public void useNormalMOSSApi(string SalesSPSite, string productName, string productNumber, string FY08Sales)
    {
        string strDashListRoot = SalesSPSite;

        using (SPSite site = new SPSite(strDashListRoot))
        {
            using (SPWeb web = site.OpenWeb())
            {
                web.AllowUnsafeUpdates = true;

                SPList list = web.Lists["TR8"];
                SPListItem Item = list.Items.Add();
                Item["Title"] = productName;
                Item["ProductNum"] = productNumber;
                Item["Sales"] = FY08Sales;
                Item.Update();
            }
        }

}
}

The core code is similar for the WCF service; however, the major differences are standard WCF/ASMX differences—e.g. uses contracts as opposed to Web method declarations, and so on. After I created the services, I then added them to a VS 2008 project using the Add Service and Add Web Reference functions within VS. Here’s a snapshot of my project, so you can see all of the standard references, WCF reference and ASMX references (both the native SharePoint Lists.asmx reference and the custom ASMX service I built).

Okay, enough on the service side; let’s take a look at the client code.

In this example, I built a simple client UI to test out a couple of different services. The following UI shows the form:

You can see that the form accepts a SharePoint site (selected from a combo-box), three separate user entries from textboxes (product name, product number, and sales), and then another input (type of service to call when executing the insertion of the record into SharePoint) from the other combo-box.

In the code-behind my WinForm app, I’ve first got four key class-level variables that I’ll use to contain the input from the above form:

string productName = "";
string productNumber = "";
string FY08Sales = "";
string SalesSPSite = "";

Then, when the user clicks the Add button (which corresponds to the btnGetSPLists_Click event), the application looks at the Type of Service control entry and then calls a specific method to handle the specific type of service.

private void btnGetSPLists_Click(object sender, EventArgs e)
{
     //Setting the variables to link to specific site
     SalesSPSite = cmboBxSPSite.SelectedItem.ToString();
     productName = txtBxProduct.Text;
     productNumber = txtBxProductNum.Text;
     FY08Sales = txtBoxSales.Text;

     //User can set whether they can call the service or not.
     if (cmbBxService.SelectedItem.ToString() == "Native SharePoint Web Service")
     {
         useSPListWebService(
             SalesSPSite, productName, productNumber, FY08Sales);
     }
     else if (cmbBxService.SelectedItem.ToString() == "Standard SharePoint API")
     {
         useNormalMOSSApi(
             SalesSPSite, productName, productNumber, FY08Sales);
     }
                 else if (cmbBxService.SelectedItem.ToString() == "WCF Service")
     {
         useWCFService(
             SalesSPSite, productName, productNumber, FY08Sales);
     }
     else if (cmbBxService.SelectedItem.ToString() == "ASP.NET Web Service")
     {
         useASMXService(
             SalesSPSite, productName, productNumber, FY08Sales);
     }

}

The conditional code in the btnGetSPLists_Click event sets the class-level variables and then calls one of four different methods depending on what the user has selected.

One of the selections calls the ASMX code (which is the native Lists.asmx web service):

//1. Using the Native SP Web Service.
private void useSPListWebService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
{
// Declare and initialize a variable for the Lists Web Service.
TR8_ListServiceCall.SPListService.Lists listService = new TR8_ListServiceCall.SPListService.Lists();

//Authenticate to the current user.
listService.Credentials = System.Net.CredentialCache.DefaultCredentials;

//Set the Url property of the service for the path to a subsite.
listService.Url = SalesSPSite + "/_vti_bin/Lists.asmx";

      //Get Name attribute values (GUIDs) for list and view.
      System.Xml.XmlNode ndListView = listService.GetListAndView("TR8", "");
      string strListID = ndListView.ChildNodes[0].Attributes["Name"].Value;
      string strViewID = ndListView.ChildNodes[1].Attributes["Name"].Value;

      //Create an XmlDocument object and construct a Batch element
      //and its attributes.
      System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
      System.Xml.XmlElement batchElement = doc.CreateElement("Batch");

//Create a CAML construct to insert data into the field into the TR8 list.
batchElement.InnerXml = "<Method ID='1' Cmd='New'><Field Name='Title'>" + productName + "</Field><Field Name='ProductNum'>" + productNumber + "</Field><Field Name='Sales'>" + FY08Sales + "</Field>" + "</Method>";

      //Call the UpdateListItems method to insert the record into the list.
      XmlNode ndReturn = listService.UpdateListItems(strListID, batchElement);
      MessageBox.Show("Record Added (Via Web Service)");

}

One of the selections calls the normal MOSS API (which is essentially the custom code that runs directly against my SharePoint server):

//2. Using the Normal SP API.
private void useNormalMOSSApi(string SalesSPSite, string productName, string productNumber, string FY08Sales)
{

string strDashListRoot = SalesSPSite;

           using (SPSite site = new SPSite(strDashListRoot))
           {
               using (SPWeb web = site.OpenWeb())
               {
                   web.AllowUnsafeUpdates = true;

                   SPList list = web.Lists["TR8"];
                   SPListItem Item = list.Items.Add();
                   Item["Title"] = productName;
                   Item["ProductNum"] = productNumber;
                   Item["Sales"] = FY08Sales;
                   Item.Update();
                   MessageBox.Show("Record Added (Via API)");
               }
           }

}

One of the selections calls my custom ASMX service:

//3. Using the ASMX Service.
private void useASMXService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
{
    TR8_ListServiceCall.ASMX_WebService.TR8ASPWebService myService = new TR8_ListServiceCall.ASMX_WebService.TR8ASPWebService();
    myService.UseDefaultCredentials = true;
    myService.useNormalMOSSApi(SalesSPSite, productName, productNumber, FY08Sales);
    MessageBox.Show("Record Added (Via ASMX)");
    myService.Dispose();

}

And the last of the selections calls my custom WCF service:

//4. Using the WCF Service.
private void useWCFService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
{
    TR8_ListServiceCall.WCF_SPListService.InsertItemsClient proxy = new TR8_ListServiceCall.WCF_SPListService.InsertItemsClient();
    proxy.useNormalMOSSApi(SalesSPSite, productName, productNumber, FY08Sales);
    MessageBox.Show("Record Added (Via WCF)");
    proxy.Close();

}

Each of these calls does exactly the same thing: inserts a record using the data from the input form into the SharePoint list called “TR8.” Note, though, that there are syntactical differences. For example, for the custom services we are really executing the code inside the custom service so we need the proxy, the default windows credentials, and the calling of the specific web method (useNormalMOSSApi) to add the entries. And of course don’t forget to dispose/close the service to clean up your sessions.

The biggest syntactical difference from the above, though, is the native Lists.asmx web service. Note the use of the CAML construct to create the XML ‘document’ that represents the data we’re inserting into the list. A tip here is if you’re going to use this method, the ‘field’ attribute in the CAML construct is not the column display name. To get the proper attribute, go to your SharePoint site, click List Settings, and then click the column in question. Note at the end of the URL is the field name. In the below figure, you can see ‘Field=Sales’ – this is the correct field attribute to use. (Hopefully, this will save you troubleshooting XML errors.)

So, the only remaining code is that which corresponds to the other buttons, which is fairly self-explanatory.

//Events to handle the clearing of the controls.
private void ctnClear_Click(object sender, EventArgs e)
{
     txtBoxSales.Clear();
     txtBxProduct.Clear();
     txtBxProductNum.Clear();
}

//Event to exit the application.
private void btnExit_Click(object sender, EventArgs e)
{
Application.Exit();
}

When executing the code, what will happen is that you can insert records from the client app via a service that then update the SharePoint list. So, why is this cool? Because you can use the same method described above to interact with many different areas of SharePoint—expanding the breadth of your OBA to include OM calls and data management with SharePoint. Here’s a final view of what the end result of the above code (selecting and executing each of the services in my Type of Service combo-box) looks like:

Note that I’ve added the complete code-behind for my sample app below.

Hope this helps you in your quest!

Steve

Complete Code-Behind for the WinForm App

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.SharePoint;
using System.Collections;
using System.Data.SqlClient;
using System.Xml.Linq;
using System.Xml;
using System.Xml.Serialization;
using Microsoft.SharePoint.SoapServer;
using System.ServiceModel;

namespace TR8_ListServiceCall
{
    public partial class Form1 : Form
    {
        //Class-level variables
       string productName = "";
       string productNumber = "";
       string FY08Sales = "";
       string SalesSPSite = "";

        public Form1()
        {
            InitializeComponent();
        }

        private void btnGetSPLists_Click(object sender, EventArgs e)
        {
            //Setting the variables to link to specific site
            SalesSPSite = cmboBxSPSite.SelectedItem.ToString();
            productName = txtBxProduct.Text;
            productNumber = txtBxProductNum.Text;
            FY08Sales = txtBoxSales.Text;

            //User can set whether they can call the service or not.
            if (cmbBxService.SelectedItem.ToString() == "Native SharePoint Web Service")
            {
                useSPListWebService(
                    SalesSPSite, productName, productNumber, FY08Sales);
            }
            else if (cmbBxService.SelectedItem.ToString() == "Standard SharePoint API")
            {
                useNormalMOSSApi(
                    SalesSPSite, productName, productNumber, FY08Sales);
            }
                        else if (cmbBxService.SelectedItem.ToString() == "WCF Service")
            {
                useWCFService(
                    SalesSPSite, productName, productNumber, FY08Sales);
            }
            else if (cmbBxService.SelectedItem.ToString() == "ASP.NET Web Service")
            {
                useASMXService(
                    SalesSPSite, productName, productNumber, FY08Sales);
            }

}

        //1. Using the Normal SP API.
        private void useNormalMOSSApi(string SalesSPSite, string productName, string productNumber, string FY08Sales)
        {

string strDashListRoot = SalesSPSite;

            using (SPSite site = new SPSite(strDashListRoot))
            {
                using (SPWeb web = site.OpenWeb())
                {
                    web.AllowUnsafeUpdates = true;

                    SPList list = web.Lists["TR8"];
                    SPListItem Item = list.Items.Add();
                    Item["Title"] = productName;
                    Item["ProductNum"] = productNumber;
                    Item["Sales"] = FY08Sales;
                    Item.Update();
                    MessageBox.Show("Record Added (Via API)");
                }
            }

}

        //2. Using the Native SP Web Service.
        private void useSPListWebService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
        {
            // Declare and initialize a variable for the Lists Web Service.
            TR8_ListServiceCall.SPListService.Lists listService = new TR8_ListServiceCall.SPListService.Lists();

//Authenticate to the current user.
listService.Credentials = System.Net.CredentialCache.DefaultCredentials;

//Set the Url property of the service for the path to a subsite.
listService.Url = SalesSPSite + "/_vti_bin/Lists.asmx";

            //Get Name attribute values (GUIDs) for list and view.
            System.Xml.XmlNode ndListView = listService.GetListAndView("TR8", "");
            string strListID = ndListView.ChildNodes[0].Attributes["Name"].Value;
            string strViewID = ndListView.ChildNodes[1].Attributes["Name"].Value;

            //Create an XmlDocument object and construct a Batch element
            //and its attributes.
            System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
            System.Xml.XmlElement batchElement = doc.CreateElement("Batch");

            //Call the UpdateListItems method to insert the record into the list.
            XmlNode ndReturn = listService.UpdateListItems(strListID, batchElement);
            MessageBox.Show("Record Added (Via Web Service)");

}

        //3. Using the ASMX Service.
        private void useASMXService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
        {
            TR8_ListServiceCall.ASMX_WebService.TR8ASPWebService myService = new TR8_ListServiceCall.ASMX_WebService.TR8ASPWebService();
            myService.UseDefaultCredentials = true;
            myService.useNormalMOSSApi(SalesSPSite, productName, productNumber, FY08Sales);
            MessageBox.Show("Record Added (Via ASMX)");
            myService.Dispose();

}

        //4. Using the WCF Service.
        private void useWCFService(string SalesSPSite, string productName, string productNumber, string FY08Sales)
        {
            TR8_ListServiceCall.WCF_SPListService.InsertItemsClient proxy = new TR8_ListServiceCall.WCF_SPListService.InsertItemsClient();
            proxy.useNormalMOSSApi(SalesSPSite, productName, productNumber, FY08Sales);
            MessageBox.Show("Record Added (Via WCF)");
            proxy.Close();

}

        //Events to handle the clearing of the controls.
        private void ctnClear_Click(object sender, EventArgs e)
        {
            txtBoxSales.Clear();
            txtBxProduct.Clear();
            txtBxProductNum.Clear();
        }

        //Event to exit the application.
        private void btnExit_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }
    }
}

Learn how to integrate PeopleSoft, Outlook and MOSS

Steve Fox — Sun, 08 Feb 2009 06:51:09 GMT

Office Business Application (OBA) development is growing in importance thus continues to be an integral part of the Office platform developer story. To that end, we recently completed a new resource that could be used for OBA training specific to PeopleSoft and Office integration. This HOL uses the OBA Starter Kit for PeopleSoft as the demo environment and provides a comprehensive walkthrough on how to a) create web services that wrap around PeopleSoft components (both native and custom), b) consume those services in a custom Outlook client (the design can be extrapolated to other Office custom clients), and c) integrate the service with the MOSS Business Data Catalog.

The new resource, a hands-on lab that is now publicly available, is a great way for you or your customers to get ramped up on how to integrate Office and PeopleSoft.

The OBA Starter Kit for PeopleSoft is available here: http://msdn.microsoft.com/en-us/office/cc442491.aspx

The new OBA PeopleSoft Hands-on Lab is available here: http://www.microsoft.com/isv/oracle/

Enjoy!

Steve

End-to-End Sales Forecast OBA Released To Web!

Steve Fox — Sat, 25 Oct 2008 05:28:00 GMT

It's been a while, but I wanted to let all you OBA developers out there know of something cool that we recently released, which is the End-to-End (E2E) Sales Forecast OBA. As you know from reading this blog, you know that OBA is an Office Business Application and involves mutltiple technologies within the Office platform. The E2E Sales Forecast OBA is a solution that walks you through a scenario where a salesperson creates and submits a quarterly sales forecast. Using a customized Excel template (built using VS 2008/VSTO), our salesperson has the ability to navigate to the team Sales Forecast portal (SharePoint portal), invoke a custom Excel sales forecast template from the New button (content type mapping to a custom template), load line-of-business sales data into the document (via WPF custom actions pane), generate executive reports for the forecast (via Open XML), and submit the document for approval (through SharePoint workflow). It essentially uses all of the concepts and technologies that I've discussed thus far in this blog--plus a few that I haven't.

In the demo solution (which is available on CodePlex--see link below), the approving manager can interact directly with SharePoint or choose to approve the workflow via a custom Outlook Form Region (built using VS 2008/VSTO). Messaging of the workflow is marshaled by SharePoint, and Open XML enables the solution to parse out the necessary data and attach to workflow and to the custom Outlook from region. This is a great starter solution if you're looking to get your hands on some code, and includes the technologies below:

- SharePoint

- Office Client Ribbon and Action Pane Customizations (VS 2008/VSTO)

- Outlook Custom Form Regions

- Open XML

- Unified Communications (UC)

- SharePoint Workflow

- Windows Presentation Foundation (WPF)

- ++

For the community source-code download and accompanying book, you can check out the following resources:

Sales Forecast Codeplex Source Code Site

http://www.codeplex.com/obasales

Sales Forecast Wrox Book Accompaniment

http://www.wiley.com/WileyCDA/WileyTitle/productCd-0470377313.html

The goal of the book is to walk you through all of the code and you would set up and deploy the sales forecast OBA.

Enjoy!!

Steve

Use Silverlight to Enhance your SharePoint-Based OBAs with the Silverlight Blueprints for SharePoint

Steve Fox — Tue, 19 Aug 2008 18:00:00 GMT

Silverlight Blueprints for SharePoint Released to CodePlex!

Today we released the source code for the Silverlight Blueprints for SharePoint—based on the Silverlight Beta 2 release. The Silverlight Blueprints for SharePoint provide a way for developers to better understand how to integrate Silverlight applications with SharePoint. Silverlight is an incredibly popular technology and with the increase in SharePoint adoption we’re finding an increased call for integrating technologies like Silverlight with SharePoint.

In this release, you’ll find five blueprint samples:

1. Hello World

2. Media Player

3. Slider Control

4. Custom Navigation

5. Colleague Viewer

Included in the release are documentation for each of the samples and the source code (go to the Releases tab of the CodePlex site). Also posted to the site is an FAQ document. In the coming days and week, we’ll publish additional screen-casts and any other supporting documentation we create or that is provided to us through the developer community.

The links to get to the Silverlight Blueprints for SharePoint are:

1. http://www.ssblueprints.net/sharepoint/ --or direct at the CodePlex site

2. http://www.codeplex.com/SL4SP

Enjoy!

Steve

Create Your First OBA: Part 5

Steve Fox — Tue, 12 Aug 2008 23:29:00 GMT

Hey gang,

It's been a while since I've posted, but I've been on the road. I attended TechEd 2008 (USA), our internal field conference TechReady 7, and then travelled to South Africa to TechEd 2008 (S. Africa). Now, I'm back in Seattle--albeit a little jet-lagged. Over the past few weeks, I've continued to give talks on OBA, but have been doing a lot more SharePoint lately--especially Silverlight and SharePoint (I'll put some blog posts up about this in the near future).

In the past, I've been doing a lot of writing in my blogs, so for this blog I put together a short screen-cast to go along with the blog. Essentially, in this blog I'm going to show you how you can create a Business Data Catalog (BDC) web part in SharePoint using the Business Data Catalog Definition Editor. Specifically, the web part will actually implement a couple of web methods from a Web service. I get this question a lot, so I really wanted to make this a part of the OBA series. (Plus, the BDC is one of the more common objects that SharePoint developers use.) This is part 5 of the Create Your First OBA series (Customizing SharePoint (BDC)):

1.       Creating the VSTO document-level solution (i.e. the custom document);
2.       Deploying the VSTO document-level solution;
3.       Integrating the VSTO with SharePoint content type;
4.       Associating SharePoint workflow with VSTO document-level solution;
5.       Customizing SharePoint (BDC);
6.       Customizing SharePoint (Excel Services).

Before you get started, a couple of notes on your environment. You can download the MOSS 2007 SDK from here: http://www.microsoft.com/downloads/details.aspx?familyid=6D94E307-67D9-41AC-B2D6-0074D6286FA9&displaylang=en. The SDK contains the BDC Definition Editor, which you will use to create the application definition file (ADF)--a metadata representation of the data source that you're connecting to with the BDC web part. I also used VS 2008 to create my Web service, which I deployed to my local Win 2003 Server which was also running MOSS (Enterprise edition). The BDC is available in the MOSS Enterprise Edition, so if you're looking to use the BDC you'll need to make sure you have this MOSS SKU installed.

Okay, so below I've added a Silverlight video player with the WMV screencast embedded in it:

If you have any problems with this, you can also get the WMV directly here: http://silverlight.services.live.com/75885/How%20to%20Create%20a%20BDC%20Web%20Part%20that%20Consumes%20a%20Web%20Method/video.wmv.

Have a great day!

Steve

Create Your First OBA: Part 4

Steve Fox — Wed, 18 Jun 2008 05:17:00 GMT

Wow, it's been a while since I blogged on this...time flies. If you've been following along with my previous posts, you'll have seen some of the other Create Your First OBA posts. Here they are if you haven’t seen them:

This post describes how you can add workflow to your OBA.

First, let me say that I can’t believe the amount of people who are asking me about this. I’ve presented at a number of conferences over the last few months and I’ve been getting more questions around this particular subject. That said, a specific walkthrough on exactly how to do this is quite long so I’ll walk through at a high level what you need to do, and then I’ve added a few references for you and also attached a hands-on lab that you can use as well to walk through—complete with code samples.

You’ll also note that the code samples cover other areas of OBA development—mainly covering client-side development using VS 2008 (specifically VSTO 3.0). Some great code samples and walkthroughs, so enjoy.

Okay, back to workflow. To create a SharePoint (SP) workflow you first need to make sure you have an ‘object’ within SP against which you’ll build the workflow. A Word document might be an example or an InfoPath can be another example. You then need to figure out what type of workflow you’re going to build and what the workflow will do. The SP workflow derives from the Windows Workflow Foundation (WF) workflow types in the .NET Framework 3.0, so the two main types are Sequential and State Machine. Sequential being as it sounds: a workflow that follows a particular sequence. And State Machine being a workflow that moves along to the next ‘activity’ depending on the state of the workflow. An activity are the individual actions that make up a workflow. If you’d like more details on SP WF, you can check out these links here:

1. Book excerpt from Programming Office Business Applications: http://msdn.microsoft.com/en-us/library/cc534997.aspx.

2. You can also find some articles here in the VSTO 3.0 documentation: http://msdn.microsoft.com/en-us/library/bb386211.aspx.

So, once you’ve figured out what your workflow will do (and let’s assume for simplicity sake that you’re going to build a Sequential workflow), you then open Visual Studio 2008, click File, New, Project, select the Office node under the language node of your choice (i.e. either VB or C#) and then select SharePoint 2007 Sequential Workflow, give it a name and click OK. This will invoke a wizard that will enable you to give the workflow a name and map the workflow template (each workflow is built and deployed as a template) to your specific SP site. Once this is done, click Next and then you can select the library or list you want to associate your SP workflow with, the History list and then the Tasks. In mine, I had a document library for the custom Word document I built earlier in the blog series (called Annual Reviews) so I built a small approval workflow (that updated a status note that corresponds to that particular document library. At this point, VS creates a project shell with a number of items in it. You can drag and drop activities onto the designer, add code behind for the activities and then map the properties of the workflow to the activities to make sure everything works. You can then press F5 to test out your workflow and it will invoke SP and run your workflow.

Now, keep in mind I just encapsulated in one paragraph what will take you an hour to walk through in the attached hands-on lab—which is why I chose the really condensed version—and even longer when you’re planning out your own SP workflow. I did this to not only save some time in writing the blog, but also because the resources I’ll provide below will help you just as much if not better.

So, here’s what I would recommend as next steps for you to get really get stuck into learning SP workflow:

1. Take a look at the attached hands-on lab and walk through lab #4. It’s an awesome and simple example of how to quickly create a simple workflow. (The lab uses VS 2008 (VSTO 3.0), and you'll need to have Office 2007 installed and a MOSS 2007 server available to build your workflow against.)

2. Take a look at the following web cast. It’s a great intro to SP workflow and provides you with some deeper-level information: http://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?culture=en-US&EventID=1032378840&CountryCode=US.

3. Take a look at following new site for SP developers; it’s got some awesome content: http://mssharepointdeveloper.com.

Okay, hopefully that will get you started.

Steve

Interesting OBA Blog on DITA...

Steve Fox — Wed, 18 Jun 2008 05:14:00 GMT

A colleague sent this to me today...thought it was interesting, so I thought I'd pass along to you all.

http://blogs.msdn.com/johnmullinax/archive/2008/06/17/democratizing-dita-dita-exchange-and-danish-beer-20-questions-with-steffen-frederiksen-of-content-technologies.aspx

Steve

SharePoint Development Conference (FireStarter) at Microsoft on June 11th

Steve Fox — Tue, 20 May 2008 19:04:00 GMT

OBA is a broad area and we're seeing an increase in the number of developers who are building SharePoint solutions--both internally to an enterprise and externally on the web. Microsoft is hosting a 1-day event for those of you interested in learning more about SharePoint development. More information on this event, how to register and who to contact for more information is below:

SharePoint Web 2.0 Fire Starter!

In typical FireStarter event style, we aim at delivering a first class experience to all attendees and make them experts on developing on SharePoint technologies before the end of the event. We have great speakers from the Microsoft rooster presenting some awesome topics that will help you build and customize websites with SharePoint and Web 2.0 technologies. You cannot miss this action packed day!

Here’s what the agenda looks like:

AGENDA
*8:00 am – 8:30 am*	*Breakfast*
8:30 am – 9:00 am	Introduction to day	Mithun Dhar
9:00 am – 10:00 am	Whirlwind SharePoint on Visual Studio - VSeWSS	Paul Andrew
*10:00* am – 10:15 am	*Break*
10:15 am – 11:15 am	Silverlight on SharePoint	Steve Fox
11:15 am – 12:15 pm	Web Parts on SharePoint	John Durant
*12:15* pm – 1:00 pm	*Lunch*
1:00 pm – 2:00 pm	Web Services on SharePoint	Paul Stubbs
2:00 pm – 3:00 pm	Workflow on SharePoint	Eilene Hao
3:00 pm – 3:15 pm	*Break*
3:15 pm – 4:15 pm	Event Handlers on SharePoint	Chris Johnson
4:15 pm – 5:00 pm	Page Branding on SharePoint	Paul Andrew
*Post Event*	*Pizza and Networking*

Where: Microsoft Conference Center (Building 33) – Kodiak Room

When: June 11^th 2008 - Wednesday

Register NOW!

If you have any questions, please contact Mithun Dhar at mithund@microsoft.com.

Create Your First OBA: Part 3

Steve Fox — Sat, 03 May 2008 00:14:00 GMT

Hey gang,

If you've been following along with the Create Your First OBA series, I've published the first two of the six parts - see below.

I was actually hedging on posting for the third item because I wrote an article for MSDN Magazine that covers it. So, I'll provide you with a link to the article which lives here: http://msdn.microsoft.com/en-us/magazine/cc507632.aspx.

I'm on the road again at Sapphire for the next few days, so if you're in Orlando at the conference look me up...I'll be dutifully hanging out at our booth. When I get back, I'll post on SharePoint workflow. As I mentioned in an earlier post, there's been a lot of requests for this so hang tight and I'll get to it soon.

Have a great weekend!

Steve

The OBA Sample Application Kits

Steve Fox — Fri, 25 Apr 2008 23:07:00 GMT

Just a quick post to check out the OBA Sample Application for Kits MSDN page. The kits provide comprehensive guidance on how to integrate Office with SAP and PeopleSoft (and we'll have others in the future). The kits include whitepaper, install guide, technical walkthrough doc, and source code. We announced the latest of the kits (the OBA Sample Application Kit for PeopleSoft) last week at Kurt DelBene's keynote at Collaborate 08.

You can get to the page here: http://msdn2.microsoft.com/en-us/office/cc442491.aspx

From this page, you can get to the individual kits.

Check it out! This is awesome stuff, and it is a rarity to find kits that provide guidance against these two very popular LOB Systems (that is PeopleSoft and SAP).

Cheers,

Steve

Conference Follow-Up Post

Steve Fox — Fri, 25 Apr 2008 22:41:00 GMT

Over the past few weeks, I've attended and presented at a number of conferences (specifically VSLive, MS CSAF, Collaborate, and DevConnections) and had some great conversations with attendees who were seeking more information or had questions in the sessions on additional OBA resources. During some of these conversations, I promised to follow up in my blog on some specific issues/questions. In this blog post, I've added some additional information on:

Deployment
SharePoint Workflow
Outlook add-in development

I'll also be following up on this post in the future with additional information, so I encourage you to check back or RSS the blog (as I'm not exactly to a schedule when posting).

Deployment

In a couple of my sessions, we had some detailed conversations around deployment. Here is a question that I was going to check on. I've also added some additional information that you can check out.

1. Can you point to the root folder assembly and have it point to the latest version of the bits? (This was in relation to mapping a content type from SharePoint and then invoking the assembly from the doc library.) The answer to the question, as I suspected, was yes--and that the deployment manifest should point you to the right location. However, the thing I forgot to mention was that you have to make sure that in your deployment properties you have "Check every time the customization runs." Also, this is not the default setting; the default setting is "Check Every 7 Days." So, once you publish a solution with that configuration, each time the custom document is opened you will get the latest version of the assembly associated with that document.

Misha Schneerson, one of the devs on VSTO, has a great multi-part post on Deployment. While we've made it easier in VS 2008 (by virtue of ClickOnce), there are still some things to keep in mind. You can check out his blog here: http://blogs.msdn.com/mshneer/archive/2008/04/24/deploying-your-vsto-add-in-to-all-users-part-iii.aspx.

SharePoint Workflow

Many of you asked me about some additional workflow guidance. I've pinged a couple of different people, and we're going to put together a blog-post with some additional information. I've also requested some web-casts to address some of the basics. I'll post pointers as these become available. Until then, here are a few things to get you started:

1. http://channel9.msdn.com/ShowPost.aspx?PostID=358685

2. http://office.microsoft.com/en-us/sharepointdesigner/HA101005911033.aspx

3. http://blogs.msdn.com/nikhil/archive/2007/09/11/vsto-and-sharepoint-workflow.aspx

4. http://msdn2.microsoft.com/en-us/library/bb386168.aspx

I'm also working on a couple of other things (whitepaper and webcast) that I'll try and get out to you soon.

Outlook Add-in Development

I'm noticing more and more developers extending Outlook. In one of my sessions, we talked a little about deployment across 2003 and 2007 instances of Outlook and we also discussed migration of OFS form regions to managed code OFRs. Here is some additional information for you guys on this:

Outlook 2007 should host an Outlook 2003 add-in. Mary Lee recently wrote a blog post about developing and testing an Outlook 2003 add-in on a computer running Outlook 2007. You can read more at this post - http://blogs.msdn.com/vsto/archive/2008/03/20/developing-an-add-in-for-multiple-versions-of-office.aspx.

Note that the deployment method isn't Office version specific; it's VSTO runtime specific. A VSTO solution that works for both O11 and O12 must be designed with the VSTO 2.0 runtime and .NET FX 2.0, so the same setup project with CASPOL deployment would apply.

There is also an interesting topic named "Creating Solutions for Multiple Versions of Office" at http://msdn2.microsoft.com/en-us/library/bb772080.aspx.

We do have topics that discuss how to import an OFS into an Outlook 2007 project. We also discuss the advantages and disadvantages of importing a form region vs. creating one fresh by using our designer. I will admit that the discussion of using an OFS file is not overly extensive. However, I don't think we missed any discussion critical to who are considering the idea of moving their OFS files to VSTO. Here are the topics that discuss using an OFS file:

· Creating Outlook Form Regions - http://msdn2.microsoft.com/en-us/library/bb386301.aspx.

· Walkthrough: Importing a Form Region that was Designed in Outlook - http://msdn2.microsoft.com/en-us/library/bb608611.aspx.

· Accessing a Form Region at Run Time - http://msdn2.microsoft.com/en-us/library/bb772084.aspx.

Note: Thanks to the VSTO dev team and UE team for providing responses to my field notes and queries.

To those of you who attended my sessions and had questions, I hope the above at least gets you started. If not, I'll be sure to post more in the coming days and weeks.

Steve

Create Your First OBA: Part 1

Steve Fox — Tue, 15 Apr 2008 03:07:00 GMT

Last week I attended VSLive and promised to post some of the sample code (I emphasize demo code J) I discussed at the conference. Specifically, in the couple of sessions that I did I discussed SharePoint integration with Word (showing a lightweight OBA) and the creation of Outlook add-ins using Visual Studio 2008 (VSTO 3.0). In an earlier post, I showed you how to create an Outlook add-in and integrate with external data using a custom task pane. I also showed you how to create an Outlook Form Region. I also published an article on this in the most recent MSDN magazine http://msdn2.microsoft.com/en-us/magazine/cc164242.aspx.

So, I’m going to focus on the OBA side of things through six posts, which I’ll break out as follows:

The Lightweight OBA scenario is essentially an annual review process that uses a custom task pane to load employee data and then map it to a set of Word content controls in the document. The data comes from a SQL server and can be updated from the custom task pane as well. Further, the document is tied to a SharePoint content type and has some workflow associated with it. (I currently have some oob workflow associated with it, but I’ll create some custom workflow in the next couple of weeks and associate that with the document-level solution). To make things a little easier to get started, I’ve posted my VSLive deck to this post so you can walk through the deck…I’ve included screenshots with the deck so you can get a sense for what my demo looked like. Note that it is a work in progress!

So, since this is the first of these five posts I’ll cover the creation of the VSTO document-level customization. Alright, here goes:

The first thing you’ll want to do is to make sure you have an employee database (keep it simple with a table) with some records in it. In my solution, I have a few records each with an employee name, ID, title, and review scores for three years. I’ve also got some fields for the comments and ratings that you’ll use when uploading the comments. Take a look at the screenshots in the attached deck to get a sense for what fields I’ve created in the SQL Server table.

After you’ve got your table created, you’ll want to now go ahead and create your VSTO project. Note that when creating a document-level solution you can either create a document and then use that as the document in your development project or you can create and edit a blank document in the VS IDE. Depending on how complex you want your template to be, you can do either…but if you’re looking to build a complex template/document, I’d consider building it first and then using it in the project. Okay, open Visual Studio 2008, click File, New, Project, and then select either Visual C# or Visual Basic, Office, and Word 2007 Document. When prompted, select whether you want to use an existing document (if you created one here’s where you would browse to it) or not (in which case you would create/edit the document in VS).

With your VSTO document-level solution created, you’ll want first add the data source (the employee table you created) to your project. To do this, click Data, Add New Data Source, select your SQL server instance, and the database within which the employee table resides.

After you’ve got your data added, you’ll now want to add a user control that will host a data view. Right click your project, click Add, User Control, and give it a name. The designer view will open by default, and you can drag over the fields that you want to load from the SQL server table (mine was called employee) onto the designer, which will automatically create a data view for you. In my custom task pane, I also created a bottom part to the custom task pane (see slide 13 for the entire custom task pane) which I mapped to the data that the manager would enter in as rating data for the annual review process. For each of the custom task pane sections I had a button which had a load event (took the currently selected data and added it to the document) and a Sync button (which mapped the completed fields in the document to the fields in the custom task pane). You could then subsequently save the data using the data view back into SQL server.

Okay, you should now have the data source added to your project and the user control created. The next thing you’ll want to do is customize the Word document. In my document, I opened the Word document in the designer view and then dragged a few content controls from the Word Controls part of the Toolbox and create a document that could then house some external data (see slide 21).

After you’ve done all of this, we now need to do a couple of things to finish Part One: 1) add some code to load an instance of the user control into a custom task pane when the assembly is loaded by the host application and 2) add some mapping code between the data from the custom task pane to and from the document.

1) The code for adding the user control to the custom task pane will be added to the core ThisDocument.cs file:

using System;

using System.Collections.Generic;

using System.Data;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Xml.Linq;

using Microsoft.VisualStudio.Tools.Applications.Runtime;

using Office = Microsoft.Office.Core;

using Word = Microsoft.Office.Interop.Word;

namespace _2008AnnualReview

{

public partial class ThisDocument

{

private AnnualReviewTaskPane ctrl = new AnnualReviewTaskPane();

private void ThisDocument_Startup(object sender, System.EventArgs e)

{

this.ActionsPane.Controls.Add(ctrl);

}

private void ThisDocument_Shutdown(object sender, System.EventArgs e)

{

}

…

}

2) Mapping code between custom task pane and Word document.

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Drawing;

using System.Data;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace _2008AnnualReview

{

public partial class AnnualReviewTaskPane : UserControl

{

string empName;

string empNumber;

string empTitle;

string empReviewScore06;

string empReviewScore07;

string strWorkEthic;

string strLeadership;

string strProdKnowledge;

string strSkillsDev;

string strPromotion;

string str2008ReviewScore;

string strAdditionalComments;

string strDate;

string strSignature;

public AnnualReviewTaskPane()

{

InitializeComponent();

}

private void employeeReviewBindingNavigatorSaveItem_Click(object sender, EventArgs e)

{

this.Validate();

this.employeeReviewBindingSource.EndEdit();

//You’ll want to add some more sophisticated error-handling code here.

try

{

this.tableAdapterManager.UpdateAll(this.annualReviewDataSet);

MessageBox.Show("Records Updated.");

}

catch (Exception exceptError)

{

MessageBox.Show(exceptError.ToString());

}

private void AnnualReviewTaskPane_Load(object sender, EventArgs e)

{

employeeReviewTableAdapter.Fill(this.annualReviewDataSet.EmployeeReview);

}

private void button1_Click(object sender, EventArgs e)

{

mapTextboxData();

mapContentControls();

}

private void mapTextboxData()

{

empName = employee_NameTextBox.Text;

empNumber = employee_NumTextBox.Text;

empTitle = employee_TitleTextBox.Text;

empReviewScore06 = review_Score_06TextBox.Text;

empReviewScore07 = review_Score_07TextBox.Text;

}

private void mapContentControls()

{

Globals.ThisDocument.wccName.Text = empName;

Globals.ThisDocument.wccEmpNumber.Text = empNumber;

Globals.ThisDocument.wccTitle.Text = empTitle;

Globals.ThisDocument.wcc2006ReviewScore.Text = empReviewScore06;

Globals.ThisDocument.wcc2007ReviewScore.Text = empReviewScore07;

}

private void button3_Click(object sender, EventArgs e)

{

//You can definitely optimize this for one string mapping as opposed to a //two step process.

strWorkEthic = Globals.ThisDocument.ddlistWorkEthic.Text;

strLeadership = Globals.ThisDocument.ddlistLeadership.Text;

strProdKnowledge = Globals.ThisDocument.ddlistProdknowledge.Text;

strSkillsDev = Globals.ThisDocument.ddlistSkillsDev.Text;

strPromotion = Globals.ThisDocument.ddlistPromotion.Text;

str2008ReviewScore = Globals.ThisDocument.ddlist2008ReviewScore.Text;

strAdditionalComments = Globals.ThisDocument.wccAdditionalComments.Text;

strDate = Globals.ThisDocument.wccSignatureDate.Text;

strSignature = Globals.ThisDocument.wccManagerSignature.Text;

work_EthicTextBox.Text = strWorkEthic;

leadershipTextBox.Text = strLeadership;

prod_KnowledgeTextBox.Text = strProdKnowledge;

tech_SkillsTextBox.Text = strSkillsDev;

promotionTextBox.Text = strPromotion;

review_CommentsTextBox.Text = strAdditionalComments;

review_Score_08TextBox.Text = str2008ReviewScore;

}

…

}

Note: Where you see “…” I’ve not included this as this is auto-generated code.

So, at this point you should have a VSTO document-level solution that does the following:

1.       Loads data into a custom task pane.
2.       Enables the user to browse the data.
3.       Load the employee data into the Word document.
4.       The Word document enables you to add ratings.
5.      Sync the ratings with the custom task pane.
6.       Save the employee’s annual review data to the SQL server.

In the next post, I’ll discuss deployment.

Have fun coding!

Steve