Josh Gaffey's Blog

How to index the PublishingRollupImage field and map a metadata property in SharePoint 2007

2009-12-14T22:29:00Z

The title of this post is a bit misleading because it’s actually not possible to index this field. You can map it to a metadata property but you won’t ever get any results back. The fact is, indexing this field is by design not supported in SharePoint 2007. The good news is I have a solution to work around this problem. What you can do is create a second text only field, I’ve called it “ThumbnailImageURL”, and make sure to always sync that field up with the URL of the image in the “PublishingRollupImage” field. You can do this using a custom event receiver which was actually the topic of my last post. I’ll paste the code here again to make it easy:

   1: try   2: {   3:     this.DisableEventFiring();   4:     5:     SPListItem item = properties.ListItem;   6:     string imageUrl = string.Empty;   7:     if (item["PublishingRollupImage"] != null)   8:     {   9:         imageUrl = ((Microsoft.SharePoint.Publishing.Fields.ImageFieldValue)(item["PublishingRollupImage"])).ImageUrl;  10:         if (imageUrl != null && imageUrl.StartsWith("/"))  11:             imageUrl = item.Web.Site.Url.AsDomain() + imageUrl;  12:         item["ThumbnailImageURL"] = imageUrl;  13:         item.SystemUpdate();  14:     }                  15: }  16: catch (Exception ex)  17: {  18:     Utilities.LogError(properties.ListItem.Web, ex);  19: }  20: finally  21: {  22:     this.EnableEventFiring();  23: }

There is a method included in here called “AsDomain()”. This method makes sure to append the correct URL onto the beginning of the image URL in case we want to access this image from a different site collection. The image URL’s SharePoint returns from the ImageFieldValue field is a relative URL, which can cause broken images across site collections. Here is the code for the “AsDomain()” extension method:

   1: /// <summary>   2: /// Parses the domain from a URL string or returns the string if no URL was found   3: /// </summary>   4: /// <param name="url"></param>   5: /// <returns></returns>   6: public static string AsDomain(this string url)   7: {   8:     if (string.IsNullOrEmpty(url))   9:         return url;  10:    11:     var match = Regex.Match(url, @"^http[s]?[:/]+[^/]+");  12:     if (match.Success)  13:         return match.Captures[0].Value;  14:     else  15:         return url;  16: }

After you have created the ThumbnailImageURL field you will need to populate it in at least one place and run a full crawl before you will be able to map your metadata property to it. That is about all it takes in order to be able to index Image URL’s from the PublishingRollupImage field, or any field for that matter. If you have other solutions to this problem I’d love to hear about them.

Updating an item using ItemUpdating, ItemUpdated or any event receiver in SharePoint 2007

2009-12-14T22:09:00Z

When using the Event Receivers in SharePoint a common scenario is to update a property on the item the event was fired on. I’ve heard of people running into this issue a few times and it’s not all that obvious what the proper way is to do this. A general software development principle is to suspend or temporarily disable events from firing that you may trigger unintentionally from your code. It is particularly difficult to do this yourself in an event receiver in SharePoint because you typically don’t have any context to work with. It turns out there is actually a very simple way to accomplish this, but it’s not clearly documented in the places you would expect it. The MSDN documentation on the ItemUpdated and ItemUpdating event make no mention of a method called DisableEventFiring. It turns out that by calling this method at the beginning of your event receiver you can prevent yourself from getting into an infinite loop. You do want to make sure to call EnableEventFiring when you are done however. Here is some sample code:

   1: try   2: {   3:     this.DisableEventFiring();   4:     5:     SPListItem item = properties.ListItem;   6:     string imageUrl = string.Empty;   7:     if (item["PublishingRollupImage"] != null)   8:     {   9:         imageUrl = ((Microsoft.SharePoint.Publishing.Fields.ImageFieldValue)(item["PublishingRollupImage"])).ImageUrl;  10:         item["ThumbnailImageURL"] = imageUrl;  11:         item.SystemUpdate();  12:     }                  13: }  14: catch (Exception ex)  15: {  16:     Utilities.LogError(properties.ListItem.Web, ex);  17: }  18: finally  19: {  20:     this.EnableEventFiring();  21: }

Using SQL Management Studio as a domain user from a machine that is not on the domain in Windows Server 2008 R2

2009-10-29T14:46:00Z

My main development machine is not domain joined, but I often need to use it to access domain resources. Usually this isn’t an issue as I have the option to enter my credentials through some type of login box. In SQL Management Studio this option doesn’t exist if you are using Windows Authentication, you will always default to the user you are currently logged on as with no option to change. The only way I can see to get around this is to use the command line to specify the following command:

runas /noprofile /netonly /user:<domain>\<username> <program>

A typical usage of this would look like:

runas /noprofile /netonly /user:CXDMN\gaffeyj "C:\Program Files (x86)\Microsoft SQL Server\90\Tools\Binn\VSShell\Common7\IDE\SqlWb.exe"

I assume this would work in any other apps but this is the only one I’ve tried so far. Hope this helps someone avoid searching for this answer.

Crawling Large Lists in SharePoint 2007

2009-10-05T13:32:00Z

There is a lot of information out there on working with large lists in SharePoint 2007. There is some good info here and here and Steve Peschka has a great whitepaper on working with large lists in SharePoint 2007 that has been out for a while now. One thing that I haven’t seen a lot of information on is crawling large lists. Steve’s whitepaper has a quick reference in his whitepaper saying “If the indexer is timing out when crawling large lists, you can increase the time-out value”. We had been experiencing issues crawling a large pages library of over 4,000 items. We were getting the error “The item may be too large or corrupt.” Increasing the time out seemed to help, but many times the indexer would still not make it through the whole library, we were still looking for a better solution. After working with Microsoft Support we were told to modify three registry values:

Key	Default Value	New Value
HKLM\SOFTWARE\Microsoft\Office Server\12\Search\Global\GatheringManager\DedicatedFilterProcessMemoryQuota	104,857,600	209,715,200
HKLM\SOFTWARE\Microsoft\Office Server\12\Search\Global\GatheringManager\FilterProcessMemoryQuota	104,857,600	209,715,200
HKLM\SOFTWARE\Microsoft\Office Server\12\Search\Global\GatheringManager\FolderHighPriority	50	500

Modifying these registry values has definitely seemed to do the trick for us so far. This was for x64 machines with a lot of RAM, so this might not be a good idea if you are still on x86 and are RAM constrained. I’d like to hear your results, did this work for you? What are your experiences crawling large pages libraries in SharePoint 2007?

SPWeb.GetFile Hangs when retrieving a publishing page

2009-09-29T20:38:00Z

I’ve been working on a utility for the past few days to manipulate some data on a SharePoint server. This code got the “works on my machine” stamp of approval, but every time we ran it against a backup of production data it would hang after processing a certain number of pages with no errors to be found anywhere. Since this was a backup of production data I tried deleting the file it was hanging on to see if that specific file was the issue…no luck. After a few hours of trying to track down the problem I eventually switched from using SPWeb.GetFile to SPWeb.GetFileOrFolderObject. The only impact this had on my code was I then had to cast the object type returned from GetFileOrFolderObject to SPFile. Magically the hang disappeared. I’m throwing this one in the SharePoint believe it or not bucket and moving on, in case you run into the same issue I’ve shown the difference in code below.

Here is the original code

   1: SPFile article = web.GetFile(articleUrl);   2: articleGuid = article.UniqueId;

And the version that worked

   1: object spObject = web.GetFileOrFolderObject(articleUrl);   2: articleGuid = ((SPFile)spObject).UniqueId;

I’ve shortened these for clarity, obviously you should be checking if you actually got a SPFile object back, but you get the idea.

I’ve got my SharePoint development environment setup, now what?

2009-08-17T23:38:00Z

There are a bunch of posts out there on how to get your SharePoint development environment up and running. A quick search on “Setting up your SharePoint development environment” will yield plenty of results to skim through to fit your needs. However, not many of these articles focus on tips and tricks to make day to day development in SharePoint easier. I’ve compiled some useful tips over the past few years that I wanted to share.

Software

SP Dispose Check – This is a tool release by Microsoft to check for un-disposed SPSite and SPWeb objects. You should run this on a regular basis, and always before deployment to production.

SharePoint Designer – A lot of people overlook SharePoint designer claiming it’s not for “real developers”, but it can be invaluable for quickly manipulating existing SharePoint sites. Real developers know how to use the tools available to them, and this is just another tool.

Red Gate .NET Reflector – This is great for digging into SharePoint assemblies when you want to get intimate with how something works.

U2U Caml Query Builder – If you are developing for SharePoint you need this, no exceptions. It will make writing CAML queries much, much easier

Fiddler – Great tool for HTTP Request/Response debugging. This comes in handy when debugging AJAX web service calls. Firebug also works good here.

Firefox and Firebug – Firebug is an extremely useful tool for HTML, CSS and Javascript. If you are doing SharePoint development you are inherently going to be working with these things a lot, hands down Firebug is the best tool for this.

IE Developer Toolbar – When you need to troubleshoot rendering issues in IE, this tool comes in handy. IE8 has these built in, but anything before that you will need to download the add on.

WSPBuilder – Absolutely invaluable tool for building solution packages, otherwise known as .wsp’s.

OS Modifications

Environment Variables

First thing you should do is add stsadm to your “Path” variable. This will allow you to execute stsadm from anywhere in your command prompt. You can do this by adding the following to your “Path” variable in environment variables. Don’t delete what is already there, just add to the end.

c:\Program Files\Common Files\microsoft shared\Web Server Extensions\12\BIN;

I would also add SPDispose check if you installed above (I highly recommend it).

C:\Program Files\Microsoft\SharePoint Dispose Check\;

I also like to add my bin directory as a new variable to make copying assemblies easier, this works well for team development when not everyone has the same VM as you can all use the same post build steps.

If you are looking to squeeze every bit of performance out of your VM you can stop the following services:

Windows SharePoint Timer Service – this runs scheduled jobs for SharePoint. If you shut this off some things may not function as you would expect. For example, you need to manually execute .wsp deployments. You can manually run the timer service by calling stsadm –o execadmsvcjobs. This can consume quite a bit of resources, I have always developed with mine off, but be warned, you should understand what this does.

Windows SharePoint Services Search – If you don’t need search and aren’t developing any components using search on your VM you can turn this service off.

Office SharePoint Server Search – Same as above.

Quick Access

In my quick launch bar I like to add:

A shortcut to the 12 hive and virtual directory root

"C:\Program Files\Common Files\microsoft shared\Web Server Extensions\12"
C:\inetpub\wwwroot\wss\VirtualDirectories\80

A shortcut to recycle the app pool

Windows 2008
%windir%\System32\inetsrv\appcmd.exe recycle apppool "SharePoint - 80"
Windows 2003
cscript %windir%\system32\iisapp.vbs /a "SharePointDefaultAppPool" /r

Visual Studio

Add Guid Generator to Tools menu – this used to be there by default, not sure why they removed it, but you really need it for SharePoint development

Tools / External Tools / Add - c:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\guidgen.exe

That’s all I can think of for now. What tools do you like to use? What did I miss and more importantly what am I missing out on?

Using custom web services in SharePoint

2009-08-17T20:57:00Z

If you are developing custom SharePoint applications there is a good chance that you are going to need some custom web services at some point, especially if you are making use of AJAX and JSON. There is a great walkthrough over on MSDN on how to do this, but if you just need a web service to enable AJAX on a page it is a bit of overkill, especially since there is no way to automate deployment on some of the steps they detail. I also recently saw a presentation where the presenter put his custom web service in a separate web application, I’m going to show that this really isn’t necessary, and you can fully automate your web service deployments through solution packages. In the long run this method of deployment will make your life much easier.

I use WSPBuilder for all my SharePoint development. I know there are other tools out there but I’ve been using WSPBuilder since 2007 and it hasn’t failed me yet (Thanks Carsten!). Why fix it if it ain’t broke? For this reason I always structure my SharePoint projects in the WSPBuilder method, which mirrors the SharePoint 12 Hive.

The first thing you want to do is create a new class library and build out your folder structure. You can use “wspbuilder – createfolders” to do this, but it will give you a bunch of folders you won’t need for this. I opted to create mine by hand.

You should then add a folder under “LAYOUTS” to separate your custom code from SharePoint out of the box code.

In the “LAYOUTS” folder you can add your .asmx file. Unfortunately Visual Studio won’t let you add web services to a class library project, so I usually just add a text file, rename the extension, and add the appropriate markup inside the file.

You’ll also want to add the code behind file. For the purposes of this sample I’ve kept them both in the same assembly, but they don’t have to be. Here is what my project looks like so far.

Inside ServiceSample.asmx I have the following single line which tells the web service which code behind assembly and class to use:

<%@ WebService Language="C#" Class="CustomWebServiceSample.ServiceSample,CustomWebServiceSample,Version=1.0.0.0,Culture=neutral" %>

Inside ServiceSample.cs I have the following code:

public class ServiceSample : System.Web.Services.WebService
    {
        [WebMethod]
        public string GetServerName()
        {
            return HttpContext.Current.Server.MachineName; 
        }
        [WebMethod]
        public string GetCurrentSiteUrl()
        {
            return SPContext.Current.Web.Url.ToString();
        }
        
    }

The important thing to note here is that your SPContext will still be valid, as long as you enter the web service through the appropriate URL. My development machine is named wssdev, so if I go to the web service through http://wssdev, I’ll get the context for the root site collection. If I go to the service through http://wssdev/sites/<sitename>, I’ll get the context for that site collection.

I have a post build script that copies my assembly and .asmx file to the appropriate location, if you package this using wspbuilder you won’t have to do this step, but it helps during development. Here is the script:

@SET TEMPLATEDIR=c:\program files\common files\microsoft shared\web server extensions\12
xcopy /e /y bin\debug\CustomWebServiceSample.dll %BINDIR%
xcopy /e /y /q 12\* "%TEMPLATEDIR%"

Compile, build/deploy your wsp, or run the post build script, and you should be ready to go.

It really is that simple to deploy your custom SharePoint web services. The important take aways here is that this works with standard solution package deployment and is very simple as opposed to some of the much more complex ways I have seen people doing this.

Why cheap developers will cost you

2009-04-10T22:25:26Z

I’m going to take a break from the normal techno-speak ASP.NET and SharePoint for a minute because I was recently reading something that really struck a chord with me as I’ve been experiencing a lot of it lately. I was reading this article on The Daily WTF today, mainly because I had just submitted an item for their Code Snippet of the Date (CodeSOD) section. For those of you who don’t know The Daily WTF and CodeSOD contain articles about real issues developers and IT professionals encounter on a daily basis. I was reading this article on “Spaced Out” and I came across a comment by someone named Captain Kirk

As a customer your choices are:

1. Hire an experienced competent developer who understands the library functions, knows how to write properly structured code with appropriate variable scope and data types, or

2. Hire someone who will produce what appears to be exactly the same output.

As a customer who doesn't happen to be a developer himself, the above two options translate as:

1. Hire an expensive expensive expensive who expensive the expensive expensive, knows how to write expensive expensive code with expensive expensive expensive and expensive expensive, or

2. Save a bunch of money and get exactly the same thing.

At this time I thought to myself, been there, done that. I kept reading and came across this comment

Cpt Kirk: who are you? Why don't you put this in a blog and post a link to it so we can all share it? Seriously, the sarcasm & wit may have made my day, but the point is actually very insightful...

That second comment was enough to make me write this post.

Captain Kirk’s comment was sarcastic in nature, but he was echoing the sentiment of the mistake I’ve seen many of my customers make time and time again. A project I was recently on made the same mistake, hence why I was at The Daily WTF in the first place :). My goal here is to illustrate why you should care about code quality, and how the upfront cost never really translates to the bottom line.

Software never ends at version 1.0

Anyone who has ever designed, developed or used any piece of software knows that software is never done at version 1.0. There will always be another version. Users are inherently unhappy with any software that is delivered to them (including myself) and good software just takes longer for users to be unhappy about. A sign of a good developer is his ability to isolate pieces of functionality into neat and tiny boxes. Low quality code ALWAYS is the opposite of this. Imagine you are in a large department store, like Macy’s, and you want to buy a white t-shirt. The only problem is, this “department” store has no departments. Everything is just thrown together all over the place. Some on racks, some in boxes, etc. How much longer would it take you to find that white t-shirt? The same issue applies to low quality code. Anytime you need to make a bug fix or feature change/addition it’s going to take at least five times as long because the code is such a mess. Something that seems like it should take 1 hour to fix could end up taking 2 weeks. This same issue actually applies during development as well because we all know there are always bugs and changes before you even launch the first version.

Inconsistencies

Good developers also do another thing that bad developers don’t, they know how to write re-useable, centralized code. This means that with bad developers you will get inconsistent behavior across your application because the same thing is done in different ways throughout the application. Have you ever come across a sink where the hot water was on the right and the cold water was on the left? This probably bothered you because the standard is to have the hot on the left, cold on the right. When you are writing a custom application this inconsistency translates into bugs, and to compound the problem, when you fix these bugs you usually have to update the code in many places instead of just one. So in many cases you can introduce more bugs by fixing the original ones. In turn this results in longer development and test cycles.

Performance

This is a big one because most customers I come across don’t give this a thought. They think that developers just build applications and they are going to work and respond well. Good developers think about performance all the time, they don’t obsess over it, but it’s always in their mind. Bad developers don’t even flirt with the topic, if they even understand the performance implications of what they are doing. This means that unless your application is very small and for a very small set of users, you are going to spend a good amount of time at the end of your project doing performance tuning that you probably didn’t plan for.

Maintenance and Operations

Bad developers write the kind of code that your IT department loathes. This is the application that is always breaking and causing them heartache. In the long run this application is going to cost you a whole lot more to support and maintain then a well written one would. Your users will have disdain for it as well, is that the kind of legacy you want to leave behind?

Get what you want

In the end the bad developers will probably satisfy the requirements, and they may or may not end up delivering the first version for cheaper than the good developers would have. The reality is, you aren’t going to get what you want, they never are going to deliver more than expected and give you something that really blows people away. Do you want something that just makes the grade, or do you want something that was better than you expected? If you have a health problem and are looking for a doctor, do you look for the cheapest one that does what you need? Or do you look for the one that will do the best job?

Writing this may not have any impact, but it did make me feel a little better :). If I save just one project manager from this mistake then it was worth it. Happy coding!

DataFormWebPart Parameters and ParameterBindings

2009-04-07T01:47:40Z

Since my post on Easily Making the DataFormWebPart Reuseable, I’ve had a couple questions on the parameters and how to make use of them. I’m going to attempt to document some of the more useful parameters, but hopefully provide a framework for you to be able to figure out how to do anything you may need with the DFWP.

The first thing you need inside your DFWP is a data source. This goes inside the <DataSources> node in the DFWP markup. You’ll notice I put some “DataFormParameters” inside the <SelectParameters> node.

<SharePoint:SPDataSource runat="server" 
		DataSourceMode="List" 
		UseInternalName="true" 
		selectcommand="<View><Query><Where><Eq><FieldRef Name='Meal'/>
                       <Value Type='Choice'>{MealQs}</Value></Eq></Where></Query></View>" 
		id="Cafeteria_x0020_Menu1"><SelectParameters>
                           <WebPartPages:DataFormParameter 
			Name="ListName" 
			ParameterKey="ListName" 
			PropertyName="ParameterValues" 
			DefaultValue="Cafeteria Menu"/>
                           <WebPartPages:dataformparameter 
			runat="server" 
			Name="Meal" 
			ParameterKey="Meal" 
			PropertyName="ParameterValues" 
			DefaultValue="Breakfast"/>
                           <WebPartPages:dataformparameter 
			runat="server" 
			Name="MealQs" 
			ParameterKey="MealQs" 
			PropertyName="ParameterValues" 
			DefaultValue="Breakfast"/>
		</SelectParameters>
		</SharePoint:SPDataSource>

In this example I’m using ListName, this allows me to reference the list by name instead of GUID, making this solution re-useable on other SharePoint sites since every time a list is created it get’s a new GUID.

I’ve also added two parameters to pickup the meal I’m trying to display. One of these parameters comes from a drop down list on the page, the other comes from a query string variable. More on this later.

If you want to limit the number of rows in a query you can include the “MaximumRows” parameter in your <SelectParameters> section.

<asp:Parameter Name="MaximumRows" DefaultValue="500"/>

By default, the DFWP will query the current sub site. If you are looking to query items from a list in another sub site you can include the “WebUrl” parameter. Possible options here are “{sitecollectionroot}” or the path to the actual web “/services/cafeteria”.

<asp:Parameter Name="WebUrl" DefaultValue="{sitecollectionroot}"/>

Next is the <ParameterBindings> section. This is where you can bind variables in your query to controls or the querystring.

<ParameterBinding Name="UserID" Location="CAMLVariable" DefaultValue="CurrentUserName"/>
<ParameterBinding Name="Today" Location="CAMLVariable" DefaultValue="CurrentDate"/>
<ParameterBinding Name="Meal" Location="Control(ddlMeal)" DefaultValue="Breakfast"/>
<ParameterBinding Name="MealQs" Location="QueryString(m)" DefaultValue="Breakfast"/>

“UserID” and “Today” are two variables inserted automatically by SharePoint. I’m not sure what else is available here, if anyone has any more info on that I’d love to know.

“Meal” and “MealQs” are two that I created to bind to the query above. You’ll notice in the “selectcommand” that I’m referencing “{MealQs}”. Here is where I declare that “MealQs” is a value from the querystring variable m. So adding “?m=breakfast” onto the end of my URL will give me only breakfast items.

“Meal” does the same thing as MealQs except it is bound to a drop down list I created called “ddlMeal”.

In summary, to bind to a control the syntax is “Control(id of the control)”. To bind to a querystring variable the syntax is “QueryString(variable name)”. Once you do this step you are free to use these in your “selectcommand” in your SPDataSource.

Hope that was helpful. If there are any other topics or questions you want to know about concerning the DataFormWebPart let me know, if there is interest in something I’ll write up a post about it.

Changing the SharePoint Welcome Page through code

2009-04-07T01:13:30Z

Sometimes you will have a feature that you activate on a sub site where you want to change the “Welcome Page” or landing page to be a custom one that you provision through your feature. I was doing this the other day and realized that it isn’t blatantly obvious through Intellisense because it is called “DefaultPage”. Here is a sample on how you would change default.aspx to be a file home.aspx that you have just created.

PublishingWeb pubWeb = PublishingWeb.GetPublishingWeb(rootWeb);
SPFile homePageFile = rootWeb.GetFile("Pages/Home.aspx");
pubWeb.DefaultPage = homePageFile;

Hope that comes in handy at some point.