TCSC Blog

Custom Error Page with Log Support Ticket Link for SharePoint 2010

Adam Preston — Fri, 10 Feb 2012 22:00:13 +0000

We’ve all seen it; the SharePoint 2010 error message with its bold red X yelling at us that we have done something terribly wrong (like it’s our fault!). Every time I see it I think of the Tommy Boy line “What’d you do!!?”

Now, I like the Correlation ID and being able to track the error down. However, in real world scenarios it’s unlikely that our users will leave this screen up and copy/paste to our support group. Wouldn’t it be nice to have a warmer error message with our company logo and a link that will ask the user to send the error details? If not, then you have come to the wrong article!

Error message we start with

Error message we end with

The user can click the “Log SharePoint Support Ticket” link and their email client will load with the prefilled body message asking them to copy and paste the Error Gibberish.

Let’s see how we make the magic happen.

Locate and copy the error.aspx file in Layouts folder of the 14 Hive (%PROGRAM FILES%\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\LAYOUTS). Never never never ever touch the system files…make copies and use those.

Create a new folder in the Layouts folder (ex. CustomError) and then paste the copied error.aspx file. Now, I’m not going to go through each line item and explain how I got the company logo or added the link. I’ve included my custom error in a zip file at the end of this blog post for you to dissect. We are going to assume that you have one edited to your liking and are ready to replace the default error message.

Open up your best friend, SharePoint 2010 Management Shell, and perform the following command:

Set-SPCustomLayoutPage -Identity Error -RelativePath “/_layouts/CustomError/error.aspx” -WebApplication

Then perform an IISRESET. Next, do something to break SharePoint (how many time will you here that request?) and test out your error message.

At any point, you can set the error page back to the default by running the following command and then IISRESET:

Set-SPCustomLayoutPage -Identity Error -WebApplication -Reset

Pretty cool stuff. Check out the other custom layout pages you can set like AccessDenied, Login, WebDeleted and more!

Download the Custom Error Page

Missing EXE Extension for IE Downloads

Rick Matherly — Thu, 09 Feb 2012 13:16:28 +0000

I was recently working with one of our client’s websites to switch their downloads to an external Content Delivery Network (CDN). After making the transition, we started seeing a strange behavior in IE when downloading an EXE file… the extension was missing. The odd thing was that all the other browsers we tested worked correctly.

After several hours of troubleshooting and research, I determined the following conditions are necessary to reproduce this behavior:

The download URL contains a query string.
The download response does not contain a Content-Disposition header.

Without the Content-Disposition header to tell IE the filename, it looks at the URL, but when there is a query string, it ignores the extension from the base URL. One common scenario where this could happen is if you have a download handler that takes an ID and looks up a file to return, probably from some type of database or secure storeage. In our case, the query string value was used as an authorization token.

There are 3 possible solutions to this issue:

Remove the query string. This is probably not an option in most cases.
Add a Content-Disposition header to the response that looks something like this: Content-Disposition: attachment; filename=myfile.exe. This is the best option if you are able to make changes to the download response.
Add another query string value to the end of the URL such that it ends in “.exe”. For example: http://www.mysite.com/download.aspx?id=5&filename=test.exe. IE will see the “.exe” at the end of the URL and set the extension correctly.

See the following Microsoft KB article for more information: http://support.microsoft.com/kb/221805. This is a very old article, but it seems to apply. The behavior is described as a bug that has been fixed, but if you read the last sentance it says that the behavior has remained unchanged for EXE and DLL files.

SharePoint Feature Receiver code for bin deployments

Jim Brocato — Thu, 09 Feb 2012 01:45:27 +0000

NOTE: If your feature receiver code needs to access the main Presentation assembly, you will receiver an error saying that the assembly UNOS.[app].Presentation cannot be loaded- this happens because the assembly is added to the bin, then the feature receiver code runs before the app pool recycles, so the assembly is never loaded into context. To work around this, add this line to your feature receiver code:

Assembly.LoadFrom(@”C:\inetpub\wwwroot\wss\VirtualDirectories\[app]\bin\TCSC.Assembly.Name.dll”);

which will use Reflection to load the assembly into context for the duraction of the feature receiver activation method.

Adding to a SharePoint 2010 List with Lookups

Rick Matherly — Tue, 31 Jan 2012 23:06:55 +0000

I had a situation recently where I was building a form in SharePoint 2010. I used a main list for the form and several other lists as lookup values for some of the fields. I used a .NET User Control for the UI, and SPMetal and LINQ to interact with SharePoint. This was my first time using SPMetal, and I had trouble adding items to the main list. The error was coming from the lookup fields. I eventually figured out that you can’t assign lookup field values to an item while you are adding it. You have to create the item first without the lookup values, then go back and add them.

The resulting code looks something like this:

demoData = new DemoDataContext(SPContext.Current.Site.Url);
var demoItem = new DemoItem();
demoItem.Title = “New Demo Item”;
// Set other properties here… except lookups
demoData.DemoItems.InsertOnSubmit(demoItem);
demoData.SubmitChanges();
var demoItemID = (int)demoItem.Id;
// Get a new context and load the item back up using the ID
demoData = new DemoDataContext(SPContext.Current.Site.Url);
demoItem = (from demoItem
            in demoData.DemoItems
            where demoItem.Id == demoItemID
            select demoItem).Single();
// Set the lookup properties here
demoData.SubmitChanges();

I welcome your feedback if anyone knows a better way to do this, but this was the only way I could get it to work.

Team Foundation Server: Unshelving another user’s changes across branches

Tom Becker — Mon, 23 Jan 2012 13:14:44 +0000

Unshelving code between branches can be difficult enough on its own but once you add another developer into the mix things can get a bit dicey since Visual Studio does not have a built-in wizard to do this.

To unshelve into a different branch you have to use the TFS PowerTools PowerShell Console. The MSDN article has all of the details of the unshelve command but I’m just going to give you the command to unshelve someone else’s changes across branches since that is where it threw me. In order to unshelve someone else’s changes you must include their username as a part of the shelf name, but you cannot forget the quotes around it or else TFS will think the shelf is yours.

PS C:\MyTargetRoot\> tfpt unshelve “ShelfSetName;UserName” /migrate /source:”$/source branch root” /target:”$/target branch root”

Please note that in order for the command to work correctly you must be in the root directory of the target branch. So once you open up the command line utility you have to just “cd” to the correct directory.

Insert JavaScript into a Content Editor Web Part (CEWP)

Adam Preston — Tue, 17 Jan 2012 20:21:34 +0000

In the 2007 version of SharePoint, we had the Source Editor included in the Content Editor Web Part (CEWP) as our way of inputting JavaScript directly onto a page. The process on how to do this has changed a little bit in the new 2010 version. Follow below on how to successfully perform the same task.

Instead of having a Source Editor to directly paste in our code, we need to first create a simple text file and save our code there. Once saved, upload that file to SharePoint. I am using the Site Assets library for this demo and a JavaScript that displays today’s date. After you have uploaded the file, right click on the file and select Copy Shortcut.

Now, go to your desired page and put the page in edit mode. Add in the Content Editor Web Part located under the Media and Content category. Once added select the web part and use the ribbon UI to navigate to the Web Part Properties screen.

On the web part properties screen, paste in the URL link to your uploaded JavaScript file. Click OK on the properties screen and, if your JavaScript is valid, it should display the desired results! Simple and easy!

Add Top Link Bar Inheritance using PowerShell for SharePoint 2010

Adam Preston — Sun, 01 Jan 2012 14:53:37 +0000

I would like to kick off the New Year with perhaps my shortest blog entry for 2012!

I had a client that created several subsites without selecting to use the same navigation as its parent. The decision was later made to add this back in order to provide some consistency throughout the environment. To easily resolve this, open up the SharePoint 2010 Management Shell and perform the following:

For one site:

$web = Get-SPWeb -Identity http://portal.company.com

$web.Navigation.UseShared = $true

For every site in the Site Collection:

Get-SPSite -Identity http://portal.company.com | Get-SPWeb -Limit All | %{$_.Navigation.UseShared=$true}

Yes, it’s THAT simple!

Developing a Webpart with a Dynamic UI

Mike Polen — Thu, 22 Dec 2011 16:26:32 +0000

One of the problems I run into when writing web parts that display SharePoint data is when the UI is dependent on dynamic content. In the past I have generated the HTML on the server-side. This works but it not the best solution as C# is not the best language to code HTML in. Also separation of concerns is an important principle to me and I want my UI separated from my server-side logic so that server changes are isolated from UI changes and vice versa. The the solution I came up with utilized several different technologies and has shown to be flexible and robust to changes.

The high level approach is:

Use server-side to collect SharePoint information
Use Json.NET to turn the List into JSON
Use jQuery UI Tabs
Use jsrender templates to generate HTML from JSON

For my particular web part I was reading information from different lists and placing the contents into a generic list based on the Category (also sourced by a list). The SharePoint information was collected, sorted and trimmed to a customizable limit. Next it was made into JSON and placed on the control as a JavaScript variable. The server-side code was simple:

Listcategories = GetNewsByCategory();
litJsonDat.Text = JsonConvert.SerializeObject(categories);

Each category contains “Listnews” that caused the JSON to be two levels deep. The first level was the category and the second level was news items by category.

My project required the ability to use tabs in the UI to display different content. I chose to use jQuery UI Tabs as I believe in reusing working solutions whenever possible. jQuery Tabs requires the following HTML:

Tab 1

Tab 2

Tab 3

Tab 1 content

Tab 2 content

Tab 3 content

And the following script:

$( “#tabs” ).tabs();

In order to generate the tabs dynamically I chose to use jsrender in order to use HTML templates driven by JSON data. My tab list template looks like:

“{{=” starts a template variable and “}}” ends it. “$itemNumber” is a variable kept by jsrender that starts at 1 and auto increments for each element. “{{=name}}” tells the template to look for “name” in the JSON element.

To utilize the template first create a destination:

Then call render like so:

$(“#tabList”).html($(“#tabTemplate”).render(tabData));

For the content I needed a template that dove one level deeper and this is easily supported in jsrender with “each”. Here is a simplified version of my template:

And here is the newsDetailsTemplate:

The destination is in the same div as the tabList but needs to be appended for the jQuery UI Tabs to work so the script is:

$(“#tabDiv”).append($(“#tabDivTemplate”).render(tabData));

When you wrap this all together you get the following in the control (I have example JSON data inserted):

This results in a nice tab interface with dynamic content that is both modular and fairly easy to change. The UI is seperated from the server side and the coupling is a JSON object which is dictated by the underlying business objects. This method has worked well for me and I hope others improve upon it.

ASP.NET Dynamic HTML with HTML Controls

Rick Matherly — Mon, 12 Dec 2011 22:32:08 +0000

There are many times that you need to process a data list and generate HTML to output to an ASP.NET page. Most of the time, a Repeater is the best choice for this, but sometimes using a Repeater is not practical because the HTML has too many levels or is built with too many conditionals. In these cases, you could use a StringBuilder and output the result to a Literal control, but working with strings can be error prone. My preferred method to add a Placeholder control to the page and then just add Controls to its Controls collection in the code behind.

This works out well if you want to use web controls, but not if you want to use HTML controls. One of the goals with web controls was to make the properties more consistent accross controls, but if you are familiar with HTML, then using the HTML controls might be more natural because the properties match the attributes you are already familiar with.

The issue with HTML Controls is that they are not as friendly to work with. For many elements, such as divs, you will have to use the HtmlGenericControl class. Although web controls have a property for CssClass, this is not available for HTML controls. If you want to add a new div control with a CSS class, you will end up with something like this:

var divContainer = new HtmlGenericControl(“div”);
divContainer.Attributes.Add(“class”, “div-class”);

To improve on this syntax, I added a derived control with a CSSClass property:

public class HtmlClassedControl : HtmlGenericControl
{
  public HtmlClassedControl(string tag) : base(tag)
  {
  }

  public string CssClass
  {
    get { return GetAttribute(“class”); }
    set { Attributes.Add(“class”, value); }
  }
}

Next, I added another derived class for the div control to eliminate the constructor parameter:

public class HtmlDiv : HtmlClassedControl
{
  public HtmlDiv() : base(“div”)
  {
  }
}

With these changes, the sytax becomes:

var divContainer = new HtmlDiv {CssClass = “div-class”};

That may not seem like much of a change, but if you are adding 20 or 30 controls with nesting and looping, it makes a huge difference in readability and maintainabiliy… not to mention less code to write. You could easily add classes for other HTML elemnts such as unorderded list, list item, etc.

Debugging a T4 Template

Tom Becker — Thu, 08 Dec 2011 17:39:09 +0000

T4 templates are extremely useful for generating repetitive code quickly and reliably. Getting them to produce good code can prove to be tricky for anything less than a trivial example. If you are having issues, stepping through the template to see what is going awry can prove difficult as there is little debugging support right out of the box.

Luckily some methods do exist to add more basic debugging functionality to your template. MSDN has a good article that goes a bit more in depth, but here are the basic steps to get you going.

Step 1:

Modify the declaration to enable debugging

<#@ template language=”C#” debug=”true” hostspecific=”true” #>

Step 2:

Add the following line to launch the debugger.

System.Diagnostics.Debugger.Launch();

You can have this line anywhere in template as long as it is between the scripting braces (<# #>).

After you have added the line, simply re-run your T4 template and you should see a Visual Studio Just-In-Time debugger window pop up asking if you want to debug the error. Choose a new instance of VS and you should be able to debug the TT file just as you would in a normal debugging session.

After you have finished debugging and are ready to run your T4 template, don’t forget to set debug back to false, as well as remove the call to the debugger.