Recent News

ThreeWill had several associates attend the SharePoint 2009 Conference in Las Vegas and we also had associates at both the first SharePoint 2010 Ignite for IT Pros and the first SharePoint 2010 Ignite for IT Developers training in Atlanta.

We wanted to share the most important technologies in SharePoint 2010 as we see them, so we thought it would be fun to try to prioritize them. This is obviously quite subjective so we would love to hear your thoughts on this by commenting on this blog post.

The Top Ten

10. Powershell for SharePoint Administration - SharePoint now enables administration, diagnostics, log searching, configuration and so much more. If you can think of it, you can probably do it with SharePoint cmdlets. For developers SharePoint cmdlets can enable build enhancements, prototyping, test data generation and more. For IT Pros, PowerShell will help manage and diagnose issues with SharePoint farms. If you haven't learned PowerShell yet, now is the time to start!

9. Search - There have been several improvements in search including results refinement (aka faceted search, parametric search - it's about time!!!), OOTB wildcard search, new query terms (AND, OR, etc.), index redundancy (finally no more single point of failure in SharePoint!), and improved people search (nicknames and misspellings work, for example). FAST, an additional SKU, adds things like search enhancements based on user context, deep results refinement, and previewers.

8. SharePoint Workspace - We knew this was coming, Groove turning into a first class offline citizen of SharePoint. The support for pulling down metadata and InfoPath forms tied to a list is awesome. There will also be a mobile version of SharePoint Workspace - imagine the possibilities!

7. SharePoint Designer - SharePoint Designer is getting richer with being a viable mini-application builder. There is richer support for workflow. SharePoint Designer is now a first class citizen of the development life cycle - you can package up your changes into a WSP and import them into Visual Studio!

6. InfoPath Improvements and InfoPath for SharePoint UI - InfoPath forms as native SharePoint forms both on the web and when offline from within the SharePoint Workspace client. InfoPath is becoming the common form designer for forms that can be ported to SharePoint and SharePoint Workspace. Some other improvements include the ability to call REST services as a data connection and having "cascading dropdowns". There was plenty of room for improvement with InfoPath - we look forward to making use of them.

5. Service Application Architecture - Custom services as well as SharePoint OOTB services can now be shared among one more web applications, scaled out across one or more servers, and even shared across farms. Cross-farm services can be a great way to provide "services in the cloud" to SharePoint farms. As a company that does a lot of product integration with SharePoint, we see this as a big feature.

4. Sandboxed Solutions - The ability for IT to control SharePoint applications across the farm will allow for centralizing custom and OOTB SharePoint solutions to the same SharePoint Farm. This is not just for development environments - it is intended for production - and remove a lot of IT barriers to custom solutions by giving IT more control without sacrificing capability.

3. Reusable Workflows - Workflows can now be deployed independent of lists so they can be reused across lists and content types. This opens up a whole new world of possibilities for Workflow and SharePoint.

2. Enterprise Metadata & Social Feedback - Great to have concept of Open (bottoms up) and Closed (top down) tags. Ability to manage tags across all of SharePoint as either a formal taxonomy (closed tags) and/or a community driven folksonomy (open tags) allows an Enterprise to choose an appropriate strategy for tagging content in their enterprise so information can be searched and filtered appropriately. There are bookmarks, tagging, and ratings on content that will allow for building better social computing solutions.

1. BCS - Business Connectivity Services (formally BDC) is now part of the core of SharePoint Services. The capabilities are much deeper than the BDC of old. It allows for all CRUD operations and this is the answer to having a list stored in its own table (halleluiah!). It is really slick to see how a database table can look and act just like a list in SharePoint. This is what we all wanted to the BDC in MOSS 2007 to be - and now it is part of WSF (Windows SharePoint Foundation - the new name for WSS).

Honorable Mentions

• Operations Management - Developer dashboard can be enabled to provide page level statistics.
• Development on Windows 7 - Now you can use a standard client 64 bit OS for SharePoint development (Windows 7 and Vista SP1). This allows for trying things out without having to pull up a Virtual Machine or requiring to install a Server OS as your host OS.
• Visual Studio 2010 Support - Includes visual designers for creating most SharePoint objects, can import SharePoint Designer WSP files for customization, can explore SharePoint servers using the server explorer, project template for creating custom business connectivity services connectors, supports sandboxed solution development, and developers can extend Visual Studio using the Managed Extensibility Framework (MEF)
• AJAX, Silverlight, REST, and LINQ are all OOTB - this is huge! (dang, why didn't it make the list above???)
• Claims Based Identity Management - single sign-on with other applications will get easier with claims based identity management. SAML is supported and there is a provider model to allow OpenID and others to be plugged in. SharePoint Online will use this to support Windows Live IDs.
• Gemini - Sorting to 100 million rows in Excel in a few seconds... what else do I have to say. Not exactly a SharePoint technology, but definitely related.
• External Data Exchange workflow activities allow direct interaction with external systems.
• The client object model greatly simplifies access to SharePoint data for Silverlight, Windows, and JavaScript clients.

Thanks to Tommy, Eric, and Pete for heavily contributing to this post!

I recently suffered through an issue with VSeWSS 1.3 that is very frustrating. When building and doing a "deploy" from inside VS.NET, if you run in to the following error, here are two options that worked for me.

The Error:
No language-neutral solution exists in the store.

The Theory:
Somehow the feature and or solution guid's become orphaned in the config/content db's

Simple Fix: (worked the first two times I saw this issue)
Run "setup -u" from the bin\debug\ directory of the project(s) which build a WSP. This uninstalls the Feature defined in the setup.bat file using the GUID generated by VSeWSS during the packaging.

Drastic Fix: (worked when Simple Fix did not)
Run the MissingFeature.exe utility and clean the SharePoint. The utility can be found here http://cid-06457d244696ab3c.skydrive.live.com/self.aspx/WSS/MissingFeature.exe.

Via Reflector: The MissingFeature.exe utility checks both the features in the Content DB and the local file system features GUIDs and notes missing file system GUIDs. This then uses "delete from dbo.Features where FeatureId = @FeatureId" to remove the orphaned items, so use this with caution.

For some details of the issues, here is a good description of the issue(s): http://menuke.spaces.live.com/blog/?fl=cat

Hopefully, this helps someone else!

A couple of weeks back, I showed how you can use the DataFormWebPart to display video content in a list item edit form (see Video Review via the DataFormWebPart). This week, we use the simple power provided by the DataFormWebPart to bridge in Silverlight!



Switching out the Windows Media Player control used previously with Silverlight has many advantages. For one, using Silverlight adds in greater video capabilities such as support for H.264 encoded media so that our Video Review Page can now support WMV, MP3, MP4, and WMA (see supported formats for more details); but more importantly, we've now bridged into SharePoint the realm of client side capabilities provided by custom app dev in Silverlight. Another important advantage is that we have now provided in support for our Mac users.

Below walks through a simple POC; next steps can include deep customizations to the Silverlight control and also packaging and deployment of the solution.

If you are new to Silverlight, the Get Started page at http://silverlight.net is a great place to begin. The site will guide you through overview, installation, and some great tutorials.

You will need to have installed the following in order to follow along:

• Visual Studio 2008 SP1
• Microsoft® Silverlight™ 3 Tools for Visual Studio 2008 SP1
• Microsoft Expression Encoder 3

To begin, we need to create the Silverlight video player binary (xap).

Fire up Visual Studio and create a new Silverlight project...



Visual Studio will create the Silverlight project for you as well as create an asp.net project which will host your Silverlight control for testing.



Once the project has been created, you will need to add a reference to the MediaPlayer assembly provided by Expression Encoder. The assembly can be found at C:\Program Files\Microsoft Expression\Encoder 3\BlendMediaPlayer\MediaPlayer.dll.

Next, open the MainPage.xaml and add a namespace reference for the Expression MediaPlayer assembly and add an instance of the Media Player to the page.



Now, open the code behind for App.xaml. We need to add code to the application startup handler to store the "InitParams" for use later. The InitParams are used to send parameters into our Silverlight application from the object tag on the SharePoint page (shown later).



Next, we need to open the code behind for Main.xaml and consume the parameters which were stored at application startup. Notice we are using "mediaUrl". We will see that parameter name included in the object tag further below.



Rebuild your project. Assuming all is well, open the test htm file which has been created for you and add in the "initParams" parameter to the object tag. Include a link to your favorite video file. One note, the file must be retrieved via http or streaming server. You cannot use a file share or local path.



You should now be able to right-click on the html file and choose View in browser to test your creation.

Assuming all is well, we are ready to update our item edit form to include the new object tag. Here is where you may want to review my previous post Video Review via the DataFormWebPart.

Open EditFormWithVideo.aspx and replace the existing object tag code with the object code from the html test page in your Silverlight project.

You will need to make the following changes:

• Remove the onError parameter (this is POC fun, we are not expecting any errors
  • Kidding aside, you can copy over the error handling script as well and then leave the onError tag as is
• Add a forward-slash to the front of ClientBin so that the xap will be loaded from a web application relative path
• Replace the path to your video file with the URL from the list item (see syntax in the snap below)

The final step is to deploy the xap file over to SharePoint.

To do this, navigate on the file system to the folder used by the SharePoint web application (e.g. C:\inetpub\wwwroot\wss\VirtualDirectories\80) and create a ClientBin folder. Copy the xap file created by the Visual Studio project, found in a folder called ClientBin beneath the test web application, over to the ClientBin folder you have just created. Last, you will need to modify the Execute Permissions for the ClientBin folder to Scripts Only.

You should now be ready to roll! Your Video Review Page now supports more video formats and can be more deeply customized thanks to Silverlight (and the workhorse, DataFormWebPart).

Cheers!

Content Types in SharePoint are hierarchical and can even be called object oriented. Each has a parent content type such that a content type can have not only its own behaviors (e.g., workflows, information management policies) and metadata (fields), but it also inherits its parent's behaviors and metadata.

What you may assume is that you can take the current content type and look at it's parents recursively until the parent is null, like so:

DoStuff(mySpListItem.ContentType);

public void DoStuff(SPContentType contentType)
{
   // Do some stuff with the content type
   // ...

   if (contentType.Parent != null)
   {
      // Recurse and do some more stuff with the parent content type
      DoStuff(contentType.Parent);
   }
}

Unfortunately, if you try the above within SharePoint server-side code you will likely cause your application pool to be terminated. Then, if you are like me, you will spend several minutes trying to figure out why SharePoint doesn't respond .

You see, the root content type is "System" and its parent is itself (seems like this is breaking some universal law of biology). So, you will go into an infinite loop if you try the code above. Instead, try the following:

DoStuff(mySpListItem.ContentType);

public void DoStuff(SPContentType contentType)
{
   // Do some stuff with the content type
   // ...

   if (contentType.Parent != null && contentType.Parent.Id != contentType.Id)
   {
      // Recurse and do some more stuff with the parent content type
      DoStuff(contentType.Parent);
   }
}

Now we simply make sure that we aren't going to continue if the parent points to ourself.

The DataFormWebPart is quite the swiss army knife of SharePoint development. Check out the video player/review page below.



For this simple, but effective solution, I combined SharePoint Designer, the DataFormWebPart, and WSS 3.0. Granted, I've used this same concept now on several projects, so I've got the process down pretty good, but, nonetheless, this took about an hour to put together. This type of solution is a great example of how developers can get big bang functionality out of SharePoint without cracking open Visual Studio.

This same concept can be used to support a "review" pattern for many different types of content. A common usage for me on projects has been to allow users to view PDF documents from within the browser window; I've also incorporated an iframe to bring in related page content from external applications or other related content in SharePoint.

So, here's how you do it....

First create a list. My example is a Video list. The important column is the Video URL. Insert at least one row in the list.



Next, you need to open SharePoint Designer and create a copy of the existing EditForm for the video list.



Now, let's open the page in SharePoint Designer. The page by default will include an instance of the ListFormWebPart. The ListFormWebPart is responsible for displaying the default edit presentation of the list. We are going to leave the ListFormWebPart in place, but are going to add the DataFormWebPart to the left side of the page for our video player. So, add a new <td></td> before the existing td.



Now that there is a landing spot for the DataFormWebPart, place your cursor within the new <td></td> and select Show Data from the Videos list in the Data Source Library pane in SharePoint Designer.



Next, you will see the Data Source Details pane. Select the URL field and choose Insert Selected Fields as...Single Item View. This will insert a DataFormWebPart which displays the URL.



Now, we have the basics of what we are after. But, it's not so great yet huh? The snap below shows the simple video URL is being displayed. We're getting there!

Next, we need to set a filter on the DataViewWebPart so that it will display the correct row from the list. The item edit form, by default, includes a query string parameter 'ID' which we can use in our DataFormWebPart to select the correct list item.



Now, let's format the display to present the URL as a video player. Scroll down to the .rowview section of the XSL used by the DataFormWebPart. This is where the item of the view is formatted. See the before/after screen snaps below for how I changed the default format to build in the object/embed code needed for windows media player. Brush up on your XSL

Before...



After...



Last step. We need to modify the Video List to use our new Edit Form. To do this, right click on the list in SharePoint Designer and select Properties. Navigate to the Supporting Files tab and cahnge the Edit item form to point the new form you have been working on.



Now, invoke the item edit form in SharePoint, and voila! You have your video review page.

Eric

If you were there, when I lost access to my Picture Library in my at-home SharePoint site last weekend, you might have redirected me to this blog post listing out code which can help you retrieve data directly from a SharePoint content database. See, my son is "student of the week" this week, and part of this honor is that he brings in his favorite pictures to post on the classroom bulletin board. And since we rarely actually "print" our photots, I needed to gather these together and submit to our favorite but rarely used online printer (Wolf Camera) for printing and then pickup that same day.

But, as luck would have it, I had accidentally shut down that server while an update was being applied. The server was running 'headless' (no monitor) and I didn't realize it was installing updates when I killed the power. Hey, its an home sandbox really and takes a lot of abuse! The end result was that the Windows SharePoint Services Web Application service would not start. I tried a handful of repair steps but it seemed to be getting worse instead of better, and I was running out of time on a Sunday afternoon.

Anyways, I've attached the source code which includes the most recently compiled exe which saved the the day.

To use:

restorefiles.exe [connectionString]
restorefiles.exe Server=[ServerName];Database=[DatabaseName];Trusted_Connection=True
restorefiles.exe Server=\\.\pipe\MSSQL$MICROSOFT##SSEE\sql\query;Database=wss_content_bowden3;Trusted_Connection=True;

The utility will extract all documents from all document libraries in the specified content database. It will place these in folders, if you used a folder structure in your document libraries (which I did). Files are placed in the current working directory, where the exe is fired off, so be sure that you have space available. Be sure to test this utility on a small, simple database before going after a larger more important piece of work.

One curve ball was figuring out the correct [ServerName] to use for the SQL Server Express instance I'm using. To remedy, I installed SQL Server Management Studio Express (v9.00.2047) and used the SQL Server Configuration Manager to first enable Named Pipes and also to retrieve the exact name of the ...named pipe (see snap below).

Hope that is helpful!

A few weeks ago I ran a MOSS Governance Workshop for one of our clients and I wanted to share a little about how it went.

What is Governance?

First off, what is Governance? I'm sure there are several definitions out there, but since we are talking about governing SharePoint, I'll provide a definition I found from Microsoft:

"Governance is the set of processes, procedures, policies, guidelines and tools affecting the way people direct, administer or use a specific IT service within a corporation. IT Service governance defines the relationships among how the many players involved with an IT service work together and how they collectively support the vision/goals originally defined for that service." -Microsoft

Structure of the Workshop

The goal of our workshop was to guide the client in what steps are necessary to create a governance plan so that they can offer IT services across their enterprise on SharePoint. In a two day workshop we could not write a governance plan, but we could get the client started. Here's the structure of our workshop.

Day 1 - MOSS Overview

The purpose of this is to get everyone on roughly the same page on what SharePoint can do. Many of the attendees represent IT and several of them know SharePoint fairly well. However, many attendees also represent the business and may not know what SharePoint can do. It is key to have this business representation, but before you can govern SharePoint you need to understand what is it you are governing. During the first day we focused on the following:

• Collaboration
• Enterprise Search
• Content Management
• MOSS Enterprise Capabilities

We started off with a high level overview and Platform Services, then dove down into the functionality provided in several areas of the SharePoint/MOSS Pie. Each section had an extensive demo with the exception of the MOSS Enterprise capabilities. This client did not have MOSS Enterprise so we didn't want to focus on it, but it turned out they really wanted to see a demo on Excel Services, so we provided one the next day.

Day 2 - Governance Overview & Infrastructure, Architecture and Security

On this day we went into the what makes up a Governance plan. This includes things like Information Architecture, Roles and Responsibilities, Services Offerings, and Training and Support. Interspersed through the discussion I show "Governance in Action" demos to demonstrate how some some pieces of SharePoint can be governed. For this particular client we had created a Governance site within SharePoint where we had already started to document their governance needs using lists, wikis, and content editors on list view pages. The day ended with a discussion on Infrastructure, Architecture and Security which gets more into the deployment and maintenance aspects of SharePoint.

Feedback and Next Steps

The feedback we received from the workshop was very positive. Some individuals got more out of the first day and some thought the second day was better. During the workshop we kept a parking lot of issues or challenges that will be focal points for the governance plan going forward. The only improvement request was to make sure that everyone recognizes that this workshop is not intended to build your governance plan, only to get it kick-started.

The attendees of the workshop basically became the governance committee for this client. Their next steps are to start formulating their plan using the building blocks we provided focusing on the service offerings that are important to them while keeping track of the roles and responsibilities necessary to provide quality service.

Acknowledgments and Links

I would like to thank Microsoft and Tommy Ryan for the support they provided in this workshop.

To learn more about our workshop, take a look at the ThreeWill Services Catalog and our Governance Wiki.

Cross posted with Microsoft SharePoint Team Blog - http://blogs.msdn.com/sharepoint/archive/2008/11/14/how-we-did-it-automating-service-requests-using-infopath-forms-services.aspx

Overview

Today's guest blog post is from ThreeWill, a Microsoft Managed Gold Partner located in Alpharetta, Georgia that focuses on SharePoint development and integration. ThreeWill recently worked with Microsoft to build a generic Service Request Office Business Application (OBA) using InfoPath Forms Services. The application addresses the need for enterprises to have a no-code way to quickly turn around service request based SharePoint sites (i.e. sites that are using electronic forms to initiate a request and tie that request to a workflow).

Some Service Request examples are:

• Request for Marketing Funds
• Request for Laptops or other equipment
• Request for Project Site Creation

The solution is packaged up as a SharePoint Feature to enable deployment to a Server Farm and standard SharePoint provisioning. The application supports integration with Active Directory to pre-populate user information and provides easy access to Web Services from InfoPath using Data Connections. Finally, configuration information is stored in a SharePoint List for secure yet convenient access to Site Administrators. Over to ThreeWill on how they did it.

Pej Javaheri, SharePoint Product Manager.

In Figure 1 you see the home page for the site. As you can see from in the Quick Launch navigation, users can create, edit, and view requests. This enables self service applications that can be easily configured for a multitude of purposes.

Figure 1 – Home Page for the Service Request Application

Core Usability Features

One of the main goals for the project was to make some key changes to standard InfoPath Forms behavior to improve the user's experience. For example, when you go to create a request from the "Create Request" link in the Quick Launch navigation, it brings you to the "Create/Edit Request" page with the InfoPath Form embedded as a Web Part Page. When the user saves the request, it is saved with an auto-generated name and the user is brought back to the Home page of the Service Request site. These "tweaks" to the interaction with the Form improved the overall user experience of the site.

To implement these features, the team wrapped an instance of the XML Form Viewer in a Web Part.

To apply the standard naming convention we overrode the SubmitToHost event to save the form with a naming convention based on the user name and the current time.

void _xmlFormViewControl_SubmitToHost(object sender, SubmitToHostEventArgs e)
{
const string formLibraryName = "Requests";
SPWeb currentWeb = SPContext.Current.Web;
// Get the contents of the form and put them into a byte array
XPathNavigator nav = _xmlFormViewControl.XmlForm.MainDataSource.CreateNavigator();
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
byte[] contents = enc.GetBytes(nav.OuterXml);
//load in the xml document so we can extract out fields by name
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(nav.OuterXml);
Dictionary<string, ArrayList> documentFields = Utility.GetNameValuePairs(xmlDocument);
//retrieve InfoPath form keys from the Configuration list
Dictionary<string, string> configuration = Utility.GetConfiguration(SPContext.Current.Web);
string [] formKeyFields = string.IsNullOrEmpty (configuration[Utility.ConstInfoPathFormKeysParameterColumn])?
new string [0]:
configuration[Utility.ConstInfoPathFormKeysParameterColumn].Split(',');
//begin to build the filename
string filename = "";
//iterate through each form key field
foreach (string formKeyField in formKeyFields)
{
//if the form key field is found in the InfoPath form, add it to the filename
if (documentFields.ContainsKey(formKeyField.Trim().ToUpper()))
{
foreach (string fieldValue in documentFields[formKeyField.Trim().ToUpper()])
{  filename += fieldValue;  filename += "_";  }
}
}
//name files using the user name and date if the infopath form keys could not be found
if (string.IsNullOrEmpty(filename))
{  filename = SPEncode.UrlEncode(currentWeb.CurrentUser.Name.Replace('\\', '-')) + "_" + DateTime.Now.ToString("yyyyMMdd_hhmmss") + ".xml";  }
else
{
//trim any training underscores, add the file extension
filename = SPEncode.UrlEncode(filename.Trim(new char\[\]
{ '_' }
)) + ".xml";
}
// Determine the URL of the new file
string saveUrl = currentWeb.Url + "/" + formLibraryName + "/" + filename;
// open document library as a folder
SPFolder docLibFolder = currentWeb.GetFolder(formLibraryName);
// Save the form by adding its contents to the document library
if (string.IsNullOrEmpty (_xmlLocation) == false && docLibFolder.Files[_xmlLocation] \!= null)
docLibFolder.Files[_xmlLocation].SaveBinary(contents);
else
docLibFolder.Files.Add(saveUrl, contents);
}

The Close event is where we handled sending the user back to the home page.

void _xmlFormViewControl_Close(object sender, EventArgs e)
{
// Inspect the QueryString
if (this.Page.Request.QueryString["Source"] != null)
{  SPUtility.Redirect("", SPRedirectFlags.UseSource, this.Context);  }
else
{  SPUtility.Redirect(SPContext.Current.Web.Url + "/default.aspx", SPRedirectFlags.CheckUrl, this.Context);  }
}

Also, the "Edit My Request" link included some usability improvements. When a user clicks this link and they have only one request for the site, that request is loaded. If they have no requests, it is like creating a new request. And if they have multiple requests they are brought to the list of requests. A Service Request Redirector class was created to handle these cases.

public class ServiceRequestRedirector : LayoutsPageBase
{
private const string FORMS_LIST_NAME = "Requests";
private const string QUERY_DEF = "<Where><Or><Eq><FieldRef Name='Author'/><Value Type='User'>
{0}{0}
</Value></Eq></Or></Where>";
\\
protected override void OnLoad(EventArgs e)
{
// get current site, web and user
SPSite siteCollection = this.Site;
SPWeb site = this.Web;
SPUser currentUser = site.CurrentUser;
//get list of fields to return "<Where><Or><Eq><FieldRef Name='Author'/><Value Type='User'>
{0}{0}
</Value></Eq></Or></Where>"
\\
string viewFields = GetViewFields();
//build the query string for querying the Request list
//to retrieve any item created or modified by the current user
string requestQueryFields = string.Format(QUERY_DEF, currentUser.Name);
string redirectUrl = default(string);
try
{
SPListCollection lists = site.Lists;
SPList timesheetList = site.Lists[FORMS_LIST_NAME];
SPQuery requestQuery = new SPQuery();
requestQuery.ViewFields = viewFields;
requestQuery.Query = requestQueryFields;
SPListItemCollection listItems = timesheetList.GetItems(requestQuery);
if (listItems.Count == 0)
{  redirectUrl = site.Url + "/SitePages/norequests.aspx";  }
if (listItems.Count == 1)
{  string url = Request.RawUrl;  redirectUrl = site.Url + "/SitePages/editrequest.aspx?XmlLocation=" + site.Url + "/Requests/" + SPEncode.UrlEncode(listItems[0].Title) + "&Source=" + SPEncode.UrlEncode(site.Url + "/default.aspx");  }
if (listItems.Count > 1)
{
try
{
if (Request.QueryString["Title"].ToString() != "")
{  redirectUrl = site.Url + "/SitePages/editrequest.aspx?XmlLocation=" + site.Url + "/Requests/" + Request.QueryString["Title"] + "&Source=" + SPEncode.UrlEncode(site.Url + "/default.aspx");  }
}
catch (System.ArgumentOutOfRangeException)
{  //no Title in QueryString, just continue to display all items  redirectUrl = site.Url + "/Requests/Forms/MyItems.aspx";  }
catch (Exception ex)
{ //no Title in QueryString, just continue to display all items redirectUrl = site.Url + "/Requests/Forms/MyItems.aspx"; }
}
}
}

catch (SPException spe)
{  System.Diagnostics.Debug.Print(spe.Message);  }
//redirect to the correct page for the number of requests
SPUtility.Redirect(redirectUrl, SPRedirectFlags.CheckUrl, HttpContext.Current);
}

Other Key Features Implemented

The solution also included the provisioning of reusable web services that are consumed through Data Connections in InfoPath and a SharePoint Designer Custom Action. Therefore, the Site Designer just needs to know how to use InfoPath to design some pretty sophisticated forms.

Some web service features are:

• Connection to AD to pre-populate user profile information into a form based on the logged in user
• Retrieve SharePoint Group (if available) - used to simulate "role-based" functionality in a browser-enabled form.
• Cascading Filtering of List based data – allowing users to consume list data that is related by master/child relationship (e.g. State drop down driving the automatic filtering of a City drop down)
• SharePoint Custom Actions included a new custom action in SharePoint Designer (runtime approvers) that provides the SharePoint Approval workflow with the list of approvers at run-time.
• Form is pre-populated with information from Active Directory
• User can select item in drop down list and other fields are updated based on that selection
• Form can show master/child relationships

Figure 2 - Create/Edit Service Request Example

We had some key lessons learned when simplifying these services. Kirk ran into a gotcha when accessing a web service with anonymous access and trying to work with the current user. We also learned more about registering a Windows SharePoint Services 3.0 Hosted Web Service on the project and Pete followed up with a blog post to address the problem. Also, because some SharePoint web service calls do not have well defined schema for input and output parameters and/or the input/output schema is not easily consumed by tools such as InfoPath, we created a simplified Web Service class.

private SPList GetList(SPWeb site, string listName)
{
// Get the list
SPList list = null;
try
{  list = site.Lists[listName];  }
catch (Exception ex)
{
throw new Exception(String.Format("List {0}] does not exist within site [{1}].", listName, site.Url), ex);
}
return list;
}
private ListExecuteQuery(SPList list, SPQuery spQuery, string fields, bool unique)
{
// Run the query
SPListItemCollection items = null;
try
{
items = list.GetItems(spQuery);
}
catch (Exception ex)
{
throw new Exception("Unable to execute query.", ex);
}
// Turn the output into our format
Listresponse = new List();
DictionaryuniqueItems = new Dictionary();
foreach (SPListItem item in items)
{
StringBuilder uniqueSb = new StringBuilder();
// Populate a response item
ListItem responseItem = new ListItem();
responseItem.ID = item.ID;
responseItem.Title = item.Title;
responseItem.Fields = new List();
// Populate the fields for the response
foreach (string field in fields.Split(','))
{
string fieldName = field.Trim();
if (!item.Fields.ContainsField(fieldName))
{
throw new Exception(String.Format("Field [{0}"  class="createlink"linktype="raw" linktext="{0}] does not exist within site [{1}].", listName, site.Url), ex);
}
return list;
}
private ListExecuteQuery(SPList list, SPQuery spQuery, string fields, bool unique)
{
// Run the query
SPListItemCollection items = null;
try
{
items = list.GetItems(spQuery);
}
catch (Exception ex)
{
throw new Exception("Unable to execute query.", ex);
}
// Turn the output into our format
Listresponse = new List();
DictionaryuniqueItems = new Dictionary();
foreach (SPListItem item in items)
{
StringBuilder uniqueSb = new StringBuilder();
// Populate a response item
ListItem responseItem = new ListItem();
responseItem.ID = item.ID;
responseItem.Title = item.Title;
responseItem.Fields = new List();
// Populate the fields for the response
foreach (string field in fields.Split(','))
{
string fieldName = field.Trim();
if (!item.Fields.ContainsField(fieldName))
{
throw new Exception(String.Format("Field [{0}">
{0}] does not exist within site [{1}].", listName, site.Url), ex);
}
return list;
}
private ListExecuteQuery(SPList list, SPQuery spQuery, string fields, bool unique)
{
// Run the query
SPListItemCollection items = null;
try
{
items = list.GetItems(spQuery);
}
catch (Exception ex)
{
throw new Exception("Unable to execute query.", ex);
}
// Turn the output into our format
Listresponse = new List();
DictionaryuniqueItems = new Dictionary();
foreach (SPListItem item in items)
{
StringBuilder uniqueSb = new StringBuilder();
// Populate a response item
ListItem responseItem = new ListItem();
responseItem.ID = item.ID;
responseItem.Title = item.Title;
responseItem.Fields = new List();
// Populate the fields for the response
foreach (string field in fields.Split(','))
{
string fieldName = field.Trim();
if (!item.Fields.ContainsField(fieldName))
{
throw new Exception(String.Format("Field [{0}
does not exist within list {1}"  class="createlink"linktype="raw" linktext="
{1}
">
{1}
.", fieldName, list.Title));
}
Field responseField = new Field();
responseField.Name = fieldName;
object fieldValue = item[fieldName];
responseField.Value = (fieldValue \!= null ? fieldValue.ToString() : String.Empty);
responseItem.Fields.Add(responseField);
// Keep track of a unique key if we care about uniqueness
if (unique)
{  uniqueSb.Append(responseField.Value).Append('\0');  }
}
// Include the list item in the responses
// But don't include it if the user requested unique values and this item is not unique
if (!unique)
{  response.Add(responseItem);  }
else
{
string uniqueKey = uniqueSb.ToString();
if (!uniqueItems.ContainsKey(uniqueKey))
{  response.Add(responseItem);  uniqueItems.Add(uniqueKey, null);  }
}
}
return response;
}

List Based Configuration

To simplify administration of the sites the configuration is stored in a SharePoint list that is only accessible to the Site Administrator. The configuration parameters are stored as name/value pairs and allow the Site Administrator convenient access to configuration data through the familiar SharePoint interface.

Figure 3 - Configuration of Service Request Application

Summary

The benefit of this solution is an enterprise class Services Request application that requires no coding and can be configured for a number of purposes. The application has a number of key usability enhancements like auto generating form names and simplifying the process of working with forms. You can easily build the forms for the application using InfoPath and there are a number of key services that you can use like pre-populating information from Active Directory or building forms based on SharePoint list data. Configuration information for the application is stored in a SharePoint list to make it easy and secure to access.

Project Team Members

The team members who worked on this project included Pete Skelly, Eric Bowden, Kirk Liemohn, Chris Edwards, and Jerry Rasmussen. We would also like to thank Donna Hodges of Microsoft for her innovative enthusiasm to drive the concepts behind this project to reality. Finally, we want to thank Kern Sutton from Microsoft who was the business liaison that helped refine the business requirements and ensured that the necessary resources from the client and Microsoft were provided to effectively solve the business problem.

About the Authors

Pete Skelly – Pete is a Senior Consultant with ThreeWill. Pete is certified as a MCSD using Microsoft .NET, a MCTS: SharePoint Services 3.0, Application Development and is a Certified Scrum Master. Pete would prefer to play golf for a living, but playing with his two sons and paying bills always seem to get in the way.

Eric Bowden – Eric is a Senior Consultant with ThreeWill and enjoys recreational running (yes, there is such a thing), camping, outdoors with family, and optimizing commute times. Eric is certified as an MCSD as well but don't let that fool you, he's actually a strong coder with mad SharePoint developer skills.

Danny Ryan - Danny is a co-founder of ThreeWill and enjoys chasing his two little girls around the house when he is not talking to enterprises about how SharePoint slices bread. Danny writes a monthly newsletter, called SharePoint for the Enterprise, which covers key topics about successfully building "enterprise class" SharePoint applications – http://www.threewill.com/newsletter/ .

Cross posted with Microsoft SharePoint Team Blog - http://blogs.msdn.com/sharepoint/archive/2008/11/03/how-we-did-it-allowing-connections-to-multiple-ssrs-servers-with-report-viewer-and-explorer-web-parts.aspx

Overview

Today's guest blog post is from ThreeWill, a Microsoft Managed Gold Partner located in Alpharetta, Georgia that focuses on SharePoint development and integration. You might remember them from a previous article about the SharePoint Connector for Confluence. They worked with Microsoft on a recent project to extend some of the features of SSRS Web Parts to meet the needs of the enterprise.

In this project, ThreeWill helped a large telecommunications organization address their concern of being bound to one SSRS Reporting Server with the web parts. This concern was primarily because they did not have the luxury of combining all reports into one scaled SSRS environment. Of course, like so many other projects, the client needed a solution today, not months from now... this article has the details behind what they did on a week by week basis. Over to ThreeWill.

Pej Javaheri, SharePoint Product Manager.

First, a little bit more background. The core requirements of the solution were to enable SSRS web parts in SharePoint Server 2007 to point to multiple SSRS environments, a capability available in SSRS web parts for SharePoint 2003, with parameterization capability with the filter framework in SharePoint Server 2007. In essence, combine the best qualities of SSRS web parts from 2003 with 2007, as well ensuring usability was easy for end-users with minimal or no training required.

Here's how we did it and our approach.

Week 1

Getting Started

The obvious starting point for the project was to evaluate existing SSRS Web Parts available from Microsoft. We took a look at the v2 and v3 SSRS Web Parts available for SharePoint. We had a technology spike to determine whether to extend or rewrite either version of the Web Parts. After discussing the options with the SQL Server Product Team, we decided to implement two new Web Parts that use a similar design pattern used by the v2 Web Parts. From that foundation, we added additional features like managing Reporting Parameters either through the Web Part Editor or through Web Part Connections. Below is a comparison of the existing SSRS Web Parts compared to what was custom built.

The objective of the project was to build the following Web Parts:

• Report Explorer (Top Web Part) - allows you to browse existing reports on a SSRS Server and eventually select a report that is passed to the Report Viewer
• Report Viewer (Bottom Web Part) - allows you to display a preconfigured report (or a report determined at runtime through Web Part Connections).

Requirements Baseline

Due to budget and timeline, we had to make a judgment of what was appropriate to reuse from the architecture of SSRS and the existing SSRS Web Parts. We found the architecture of the v2 Web Parts were the best place to start to allow for code reuse and connection to multiple servers. The v2 Web Parts leverage the use of IFrames to an ASPX page hosted on the SSRS Server. This allowed the end user's security credentials to pass through from the browser to the Report Server vs. a double hop through custom code in the Web Part. This also saved time with not having to recreate the UI elements and behaviors needed for a Report Explorer and Viewer. We extended the v2 capabilities in the Report Viewer by giving support for report parameters through Web Part Properties. The properties for the parameters leveraged the Web Services interface of the Report Server to, at runtime, render labels and controls for each available parameter on the report. By the end of the first week we finalized the product backlog - see below table for a sampling the product backlog items for each of the Feature Groups.

Week 2-3

Implementing the Report Explorer Web Part

To start the second week, we hit the ground running on building the new Web Parts that included a new Report Viewer and Report Explorer. In the interest of time, we did our best to leverage patterns and assets used by the v2 and v3 SSRS Web Parts. Note that SSRS Server natively hosts an ASPX page that contains the Report Explorer UI that is found in the v2 SSRS Web Part and leveraged by the SSRS built-in Report Manager. The Custom Report Explorer Web Part uses an IFrame to host this ASPX page. There are two parameters that are used to configure the Web Part - the "Reporting Server URL" and the "Starting Path" (screen shot of the Web Part Properties can be seen below). Note that the UI of the Report Explorer Web Part renders a view much like Windows Explorer (as shown earlier in this post). The "Report Server URL" points to the location of the SSRS Reporting Server. The "Starting Path" describes where to start in the view in case you wish to start in a subfolder. For example, you can configure the Web Part to start in the "HR Reports" folder when configuring for a HR SharePoint Site.

Adding Web Part Connections

To make Web Parts more useful, you can develop a Web Part to accept connections from other Web Parts on the same page. By creating connectable Web Parts, you have the ability to create new and more meaningful ways to view data and interact with a Web Part Page. In the case of the Report Explorer and Report Viewer, we want to pass the id of the SSRS Report Viewer Web Part back to the Report Explorer Web Part. The SSRS Report Explorer uses this id to specify which Report Viewer Web Part instance should be the "target" when a report link in the Report Explorer Web Part is clicked. In the screen shot below, we are setting the Web Part connection on the Report Explorer Web Part to connect to the Report Viewer Web Part.

The IWebPartField, shown below, is one of several standard interfaces used to create connectable Web Parts. As the name implies, IWebPartField is intended to pass a "field" of data while IWebPartRow and IWebPartTable are meant to pass a row and table respectively. Connections are enabled through the use of ConnectionProvider and ConnectionConsumer attributes.

Report Explorer Implementation

[ConnectionProvider("Report Explorer")]
public IWebPartField GetConnectionInterface()
{  _isWebPartConnected = true;  return this;  }

Report Viewer Implementation

//Get the connection
[ConnectionConsumer("Report Viewer", "ReportViewer",AllowsMultipleConnections=false)]

public void SetConnectionInterface(IWebPartField fieldProvider)
{  CustomReportExplorer reportExplorer = fieldProvider as  CustomReportExplorer;  if (reportExplorer \!= null) {  reportExplorer.ConsumerId = this.ID;  _isWebPartConnected = true;  }
}

To learn more about Web Part Connections, see documentation on the SPWebPartConnection Class.

Implementing the Report Viewer Web Part

Like the Report Explorer Web Part, the Report Viewer Web Part renders content provided by the SSRS server through use of an IFrame for the ASPX page. Key features implemented to manage the interaction with the ASPX page are: a) a connection to the Report Explorer Web Part to allow a report to be passed to the Report Viewer, b) support for MOSS Filter Web Parts to be able to pass in reporting parameters through Web Part Connections, and c) ability for report parameters to be specified in the Web Part properties.

The Report Viewer Web Part uses the GetReportParameters method of the ReportServices2005 Web Service to retrieve report parameters. The Report Parameters from this method call are used for two purposes.

1. The parameter prompt (i.e. Display Name) is used in the IFIlterValues Interface so that the connecting MOSS Filter Web Part can choose which report parameter is receiving data.
2. The parameter display name and default values are used to build the list of parameters in the Web Part editor.

   If parameters are not supplied to the Report Viewer Web Part the ASPX page provided by SSRS Server renders input boxes at the top of the report as seen below.

   

Our client required that the reporting parameters also be provided through the Web Part Properties Editor and through Web Part Connections. Below is a view of supporting the parameters through the Web Part Properties Editor. This required dynamically discovering and rendering the label and input controls for the report parameters.

From a programmatic standpoint, the first step is to retrieve and store the report parameters so that we can use these for Web Part Connections and Web Part Properties. A CustomReportParameter class is used to store report parameter name/value pairs that are retrieved by an SSRS Web Services call.

ReportingService2005 svc = new ReportingService2005();
parameters = svc.GetReportParameters(ReportPath, historyID, forRendering, values, credentials);
if (parameters != null)
{
//look through each report parameter returned, and add to our list if not
//already in the list
foreach (ReportParameter rp in parameters)
{
if (!_customReportParameters.ContainsKey(rp.Name))
_customReportParameters.Add(rp.Name, new CustomReportParameter(rp));
}

Now that we know the parameters that are available in the report, we can use these parameters for Web Part Connections and Web Part Properties. We implemented the IFilterValues interface to support MOSS Filter Web Parts (Web Parts used to filter other Web Parts see MSDN for more details). To implement the IFilterValues interface, the Report Viewer Web Part must provide the filter value provider (e.g. Choice Filter Web Part) with a list of parameters which can be used to filter the report. Here is a simplified version of filling those parameters:

List<IFilterValues> _providers = new List<IFilterValues>();
[ConnectionConsumer("Parameters", "IFilterValues", AllowsMultipleConnections = true)]

public void SetConnectionInterface(IFilterValues provider)
{
if (provider != null)
{
//add this provider to our collection of providers
_providers.Add(provider);
//Call the ReportServices2005 web service to build a list of parameters
FillParameters();
//create a ConsumerParameter for each of our Report Parameters
Listl = new List();
//iterate over each ReportParameter and fill the list of
//ConsumerParameters
foreach (CustomReportParameter crp in _customReportParameters.Values)
{
//Note: We are adding parameters by "Prompt" and not by
//parameter name
l.Add(new ConsumerParameter(crp.ReportParameter.Prompt,
ConsumerParameterCapabilities.SupportsAllValue |
ConsumerParameterCapabilities.SupportsMultipleValues |
ConsumerParameterCapabilities.SupportsEmptyValue |
ConsumerParameterCapabilities.SupportsSingleValue));
}
provider.SetConsumerParameters(new
ReadOnlyCollection<ConsumerParameter>(l));
}
}

Below is a Web Part Configuration dialog for the Web Part Connection between a Filter Web Part and the Report Viewer Web Part. Note, the code above provides the "Filtered Parameter" list. This particular report has both "Customer ID" and "Account ID" as available reporting parameters that can participate in a Web Part Connection.

Once the Web Part connection has been established, the Report Viewer Web Part retrieves the filter values from the IFilterValues provider. Below the FillParametersFromWebpartConnection method is called each time the Web Part is rendered to retrieve parameter values from the filter provider in order to build a query string. The query string is used to pass parameter values to the SSRS ASPX page, which is then rendered in the Web Part.

private void FillParametersFromWebpartConnection ()
{
//iterate through each provider
foreach (IFilterValues provider in \_providers)
{
//now find our parameter and populate the values
//remember though, we have to search for it by Prompt
foreach (CustomReportParameter crp in _customReportParameters.Values)
{
//match up the provider with the report parameter by prompt
if (crp.ReportParameter.Prompt == provider.ParameterName)
{
if (provider.ParameterValues == null)
{
break;
}
else if (crp.ReportParameter.MultiValue)
{
crp.Value = "";
foreach (string val in provider.ParameterValues)
{
//encode to account for semi-colons in
//mutli-value selects
crp.Value += val.Replace (";",@"\;");  crp.Value += ";";
}
}
else if (provider.ParameterValues.Count > 0)
{
crp.Value = provider.ParameterValues[0];
}
//break out of the foreach loop;
//we have found the parameter
break;
}
}
}
}

Here is an abbreviated sample of building out the query string.

//fill parameters from web part connection, if any
FillParametersFromWebpartConnection();
//loop through each report parameter and build parameters on the query string
foreach (string paramName in _customReportParameters.Keys)
{
if (_customReportParameters[paramName].Value != null)
{
reportUrl += "&" + paramName;  reportUrl += "=";  reportUrl += _customReportParameters[paramName].Value;
}
}

Below are a series of screen shots showing the use of a MOSS Filter Web Part where it is connected to and providing parameters to the Report View Web Part. Below shows a Filter Web Part with preconfigured name/value pairs

Next, we use the Filter Web Part to the select a Customer

And after a customer is selected, you see the filtered report that uses the filter's value.

Summary

In Summary, this solution leveraged the following to allow a quick turnaround:

• Use of existing Report Explorer and Report Viewer UI provided by SSRS Server through use of IFrames.
• Use of the SharePoint Web Part Framework to leverage Web Part Connections for connecting the Report Explorer to the Report Viewer and for passing in report parameters from Filter Web Parts yielding a richer user experience.
• Use of Web Services within Web Part Properties to dynamically provide configuration of Report Parameters.
• Use of Agile development techniques to build weekly solutions that could be tested and adapted to an enterprise grade solution in 3 weeks.

Key tools that helped in the Web Part Development were:

STS Dev - The STSDev tool is an excellent tool used to quickly create base SharePoint features which can be easily packaged into SharePoint solution files.

SharePoint Solution Installer - The SharePoint Solution Installer is a terrific alternative to stsadm commands. This tool checks for basic SharePoint prerequisites and will deploy or retract your solution using a friendly wizard based interface.

About the Team and Authors

Eric Bowden is a Senior Consultant with ThreeWill who implemented the Report Viewer features.

Tim Coalson is a Senior Consultant with ThreeWill who implemented the Report Explorer features.

Donna Hodges from Microsoft was the technical decision maker that was able to keep the team focused on getting the most bang for the buck.

Audie Wright from Microsoft was the business liaison that defined the business requirements, and ensured that the necessary resources from the client, and Microsoft were provided to effectively solve the business problem.

Tommy Ryan is a co-founder of ThreeWill who helped pull together the article with assistance from the project team and Danny Ryan.

SharePoint applications are made up goodies such as custom web parts, lists,  list event handlers, site definitions, site pages, application pages, and on and  on. We package our SharePoint applications as features in order to maximize  reusability and ease deployment. Then we add more deployment-ease by packaging  our features and their resources as SharePoint solution (.wsp) files. The SharePoint Solution Installer provides the final touch by providing a nice wizard based  interface for solution deployment. Once our SharePoint administrators complete  the SharePoint Solution Installer wizard (or use the equivalent STSADM  commands), our features are "deployed". All is good.

But wait.... What does it mean to "deploy" a feature in a solution package?

Simply put, the feature is installed to the *farm* at the  scope specified for the feature in the feature.xml.

This means that the feature(s) within the solution will appear in the list of  features available for activation in all cases of that scope. For example, if  the feature is scoped to "web", it will appear for activation in all sites for  all site collections across all web applications on your farm.

The code which displays the list of features, for example, on the Site  Features page, iterates over the SPFeatureDefinitions held in  SPFarm.Local.FeatureDefinitions and filters out those which are not scoped to  web, those which are hidden, and those which have AutoActivateInCentralAdmin  flag set. In short, this means that a feature that you develop is available for  activation across the entire farm.

This presents a problem in some environments where a feature may have been  developed for use on one specific site in the farm. Site administrators for  other sites in the farm may be confused when they see features in the list of  site features which have no application to their site. One work around is to set  the hidden attribute to True in the feature.xml. This will remove the feature  from the Site Features list on all sites requiring use of STSADM to activate and  deactivate the feature. Unfortunately I have not found a cleaner solution.

Many though have wondered, "Why is it that I can *deploy* my  feature to a specific web application while this blog post is telling me that  the feature list is the same across all web applications in the farm?"

There are several ways to deploy your solution to a specific web application.

The STSADM command deploysolution accepts a URL

The SharePoint Solution Installer also allows you to choose a web application  target for solution deployment.

Last, Operations-Solution Mangement in Central Administration will allow you  to deploy and retract solutions from specific web applications.

So, what does it mean to deploy a solution to a specific web application?

The web application deployment target is used as the destination for the  following application scope resources which may appear in your solution manifest. These are physical changes to files within your web application  (IIS web site).
* ApplicationResourceFiles - Ex: MyFiles\My.resx. See the comment at the  bottom of the solution manifest schema for some more detail.
* Assemblies (if the DeploymentTarget is set to WebApplication) - Ex:  [web]\80\bin\MyAssembly.dll
* CodeAccessSecurity - Changes to <securitypolicy> section in  [web]\web.config to point to a new custom policy file in [12]\config
* DWPFiles - .webpart and .dwp files for custom web parts
* SafeControls - Additional entries in <SafeControls> section in  [web]\web.config.

*[web] = your IIS web site folder, e.g.,  C:\inetpub\wwwroot\wss\VirtualDirectories\80
*[12] = your 12 Hive, e.g., C:\Program  Files\Common Files\Microsoft Shared\web server extensions\12\

The deployment methods listed above will not allow deployment to a web application if the solution package (.wsp) does not contain any resources scoped  to web application.

For example, STSADM --o deploysolution will give the following error in this case:

This solution contains no resources scoped for a Web Application and cannot be deployed to a particular Web application.

In summary, the deployment of a solution package to a specific web application pertains to resources included in the solution package and not to the installation of the feature itself. Interestingly, the feature is installed across the entire farm even though resources required for that feature may have  only been deployed to select web applications. Activating a feature at a scope  beneath a web application in which the solution package has not been deployed will result in missing resources exceptions for sure!

Hopefully this sheds some light on the subject of feature deployment and  installation scope.

Yesterday I needed to have several instances of the same site collection available in a SharePoint farm. The purpose was to have the same SharePoint content available and then manually configuring each slightly differently for testing purposes. In this case I was doing some automated testing against different instances of Confluence for the SharePoint Connector for Confluence and wanted a different SharePoint site collection for each.

I manually created a site collection just the way I wanted it. In this case the site collection URL was http://csisp/sites/test26 (going against a 2.6 version of Confluence) so I'm using the standard "sites" wildcard managed path. I created a backup of the site collection. Then my next inclination was to create an empty site collection for my next site and simply restore the backup there. If you try that, you'll get the following error:

No content databases are available for this operation. Create a content database, and then try the operation again. To create a content database, click "Content databases" on the Application Management page, select the Web application to use, and then click "Add a content database".

After it fails, your site collection will be gone.

With a little searching I found several blogs on this such as Robert Bogue's blog and Ryan McIntyre's blog. Some information you may find will basically say that you need to delete your original site collection first. I didn't want to do this, however, since I wanted several nearly identical environments available at the same time. Other blogs will give you a little more information, but I didn't see any that went into much detail so I'll try to provide some more here.

The issue is that a site collection backup has GUIDs in it that must be unique for the content database in which it is stored. The simple solution is to create a content database per site collection. Here is how to do this:

First create your site collection backup using a command such as:

stsadm -o backup -url http://csisp/sites/test26 -filename C:\csiTestSpBackup.bak

For each restoration of the backup do the following:

• Create a new content database within your target web application. Go to Central Admin -> Application Management -> Content databases. Make sure you have your web application set properly. When setting the name of the content database I recommend modifying it slightly so that it is more readable (remove the GUID and put something else there).

• Create your new site collection. Outside of the URL, most settings of this site collection don't matter since they will be overwritten by your restoration (next step). The new site collection should use your new content database, but it's not entirely clear what the algorithm is. You can check if it did by going back to the "Content databases" link and looking at the "Current Number of Sites" column (it really means site collections, not sites). A way to ensure that it goes to your new content database may be to modify all others to be "Offline" (which appears to mean that they can be used but do not accept any new site collections) or to modify the "Maximum Number of Sites" to 1.

• Restore your site collection backup to your new site collection URL.

stsadm -o restore -url http://csisp/sites/test29 -filename C:\csiTestSpBackup.bak -overwrite

If you have registered a search security trimmer with a crawl rule and then prevented SharePoint from accessing the security trimmer (such as removing it from the GAC), you will get a nasty error when trying to execute a search that has results that meet your crawl rule.

To aid those searching for this error I'll restate it:

Your search cannot be completed because of a service error. Try your search again or contact your administrator for more information.

To fix this simply make sure the security trimmer assembly is available (put it back in the GAC). You'll likely have to do an IISRESET for things to work again. If you don't have access to the security trimmer you may need to reset your index (hopefully there is another option, but I suspect not).

I had to dig through the SharePoint ULS logs to figure this out:

09/18/2008 11:15:42.01 w3wp.exe (0x0EB0) 0x0EF4 Search Server Common MS Search Query Processor 97zu Unexpected Error occurred when executing pluggable security trimmer with Id 33402:

09/18/2008 11:15:42.14 w3wp.exe (0x0EB0) 0x0EF4 Search Server Common MS Search Query Processor 97zv Exception System.IO.FileNotFoundException: Could not load file or assembly 'Atlassian.Confluence.SharePoint.Search, Version=1.0.0.0, Culture=neutral, PublicKeyToken=96f82bd35ec392e7' or one of its dependencies. The system cannot find the file specified. File name: 'Atlassian.Confluence.SharePoint.Search, Version=1.0.0.0, Culture=neutral, PublicKeyToken=96f82bd35ec392e7' at System.RuntimeTypeHandle._GetTypeByName(String name, Boolean throwOnError, Boolean ignoreCase, Boolean reflectionOnly, StackCrawlMark& stackMark, Boolean loadTypeFromPartialName) at System.RuntimeTypeHandle.GetTypeByName(String name, Boolean throwOnError, Boolean ignoreCase, Boolean reflectionOnly, StackCrawlMark& stackMark) at System.RuntimeType.PrivateGetType(String typeName, Boolean throwOnError, Boolean ignoreCas...

09/18/2008 11:15:42.14* w3wp.exe (0x0EB0) 0x0EF4 Search Server Common MS Search Query Processor 97zv Exception ...e, Boolean reflectionOnly, StackCrawlMark& stackMark) at System.Type.GetType(String typeName, Boolean throwOnError) at Microsoft.Office.Server.Search.Administration.Security.PluggableSecurityTrimmerManager.Instantia

09/18/2008 11:15:42.18 w3wp.exe (0x0EB0) 0x0EF4 Windows SharePoint Services Web Parts 89a1 Monitorable Error while executing web part: Microsoft.Office.Server.Search.WebControls.SrhdcGenericException: Your search cannot be completed because of a service error. Try your search again or contact your administrator for more information. ---> System.IO.FileNotFoundException: Could not load file or assembly 'Atlassian.Confluence.SharePoint.Search, Version=1.0.0.0, Culture=neutral, PublicKeyToken=96f82bd35ec392e7' or one of its dependencies. The system cannot find the file specified. File name: 'Atlassian.Confluence.SharePoint.Search, Version=1.0.0.0, Culture=neutral, PublicKeyToken=96f82bd35ec392e7' at System.RuntimeTypeHandle._GetTypeByName(String name, Boolean throwOnError, Boolean ignoreCase, Boolean reflectionOnly, StackCrawlMark& stackMark, Boolean loadTypeFromPartialName) at System...

Hopefully this post saves others the time of trying to dig through the ULS logs.

Recently I needed to disable a SharePoint Form's Submit button until a checkbox on the form was checked. Sounds pretty simple and straightforward, doesn't it? Well, here's a little description of why it was NOT so easy for me to do this. The form required a user to indicate that they understood what they were submitting in a form, a sort of consent checkbox, by checking a check box which toggled the Submit button's Disabled property. And finally, the initial state of the SaveButton should be disabled.

You might be saying (in your best Fletch voice),

"Awww, come on Pete, it's so simple. Maybe you need a refresher course?"

Just set Disabled on the button control to false, add some JavaScript to toggle the Enabled property when the user checks or unchecks the CheckBox control. Silly me, I thought the same thing. I'll just disable the underlying Button control using the TemplateContainer.FindControl to find the Button control and set the Disabled property to true. Well, apparently the "ASP.NET runtime will not recognize a post back initiated by a disabled button". So, my first attempt at simply disabling the Button control in the SaveButton template failed miserably. The JavaScript to control the toggle worked great, but the Submit button, being disabled when rendered, would never submit, even when Disabled was false on the client.

The short answer to the problem, which took me a little longer to figure out, is to use Page.ClientScript.RegisterClientScriptBlock to register a script that will run when the page is loaded and set Button.Disabled to true. The trick here is that SharePoint registers it's _spBodyOnLoadWrapper function, found in C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\LAYOUTS\1033\INIT.JS, to load scripts added to the _spBodyOnLoadFunctionNames array. Once your code loads a function into the _spBodyOnLoadFunctionNames and the page starts to load, the page onload event is handled by SharePoint's _spBodyOnLoadWrapper function which then calls the list of functions listed in the _spBodyOnLoadFunctionNames array.

To solve my problem, I simply had to create a script which would be called when the check box was checked or unchecked, and add that same function to the _spBodyOnLoadFunctionNames array to be called when the page onload event was handled by SharePoint. Here they are.

string CONSENT_SCRIPT_BLOCK = @"function validateConsentChecked(checkBoxID, submitButtonID)\\

{
var consentCheckBox = document.getElementById(checkBoxID);
var submitButton = document.getElementById(submitButtonID);
submitButton.disabled = !consentCheckBox.checked;
}

string DISABLE_SUBMIT_SCRIPT_BLOCK = "_spBodyOnLoadFunctionNames.push(\"validateConsentChecked('{0}','{1}')\")";

To register the function itself, I used the following code:

Page.ClientScript.RegisterStartupScript(this.GetType(), "ValidateSubmission", CONSENT_SCRIPT_BLOCK, true);

And to register the onload function call, I used this code:

\\
Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "DisableSubmitButton", string.Format(DISABLE_SUBMIT_SCRIPT_BLOCK, checkBoxID, submitButtonID), true);
\\

Hopefully this will help someone else out in the future and save you some time. If anyone has a different way to handle this problem, let me know. I am more than willing to do away with writing JavaScript if I don't have to.

The SharePoint Connector for Confluence, a connector ThreeWill co-developed with Atlassian that integrates SharePoint and Confluence, has been in production for a few weeks, but not announced until yesterday. See the announcement here.

There are plenty of articles on the differences between MOSS 2007 and WSS v3, but I still get questions on this so here is a summary of what I have provided for clients in the past. Most of this is simply a compilation of data from different sources (referenced at the end of this post). This was originally compiled about a year ago, so there may be some tweaks necessary, but it should be a good start. It shows the features that MOSS provides above and beyond what is in WSS.

Sometimes I have taken the table below and added a column or two that is particular to my client's needs. Then I discuss whether each feature is important to them and why.

Unfortunately, this does not differentiate between MOSS Standard and MOSS Enterprise. That will have to come later.

Sources / References:

• .NET Developer's Journal - Windows SharePoint Services v3.0 vs Microsoft Office SharePoint Server 2007 - Good description of high level features.
• Ian Morrish - WSSDemo Blog - To MOSS or not to MOSS, Web Parts may be the answer- - Good description of web parts. Well, that link no longer works and there may not be a good way to get it anymore. If you go to here and scroll down you will see 3 blog entries starting with a title of "To Moss or not to Moss" and you can read them.
• Microsoft Office SharePoint Server 2007 products comparison download- Very detailed, but you have to be careful with this one. Microsoft leaves out the fact that WSS v3 has some of the capabilities. Which SharePoint technology is right for you? - this appears to be a prettier version of the above Excel document.
• FrontPages - Compare WSS vs. MOSS- - yet another comparison list. This appears to be very similar to the Microsoft ones immediately above. It appears that this link has been moved to here.
• Andre Connell's Blog - What's a MOSS 2007 vs. WSS v3 Feature? - Lists the additional "features" in MOSS. This was not used in compiling the list above, but most of the details should be mentioned in there.