Configure Beyond Compare as version history compare tool for Visual Studio 2010:

1. Open Visual Studio
2. Open Tools » Options…
3. In the tree on the left go to Source Control » Visual Studio Team Foundation
4. Click Configure User Tools…
5. Click Add…
6. Set the following fields
1. Extention: *
2. Operation: Compare
3. Command: C:\Program Files (x86)\Beyond Compare 3\BCompare.exe
4. Arguments: %1 %2 –readonly /lefttitle=%6 /righttitle=%7

The arguments allow you to control the behavior of Beyond Compare. Labels to use:

• %1: Original file
• %2: Modified file
• %5: Diff command-line options
• %6: Original file label
• %7: Modified file label

Because solution packages are stored in the config database, it’s possible to download/export the WSP package with PowerShell.

Get-SPSolution | ForEach-Object { $_.SolutionFile.SaveAs($_.SolutionFile.Name) }

The WSP packages are stored in the current directory.

The forth column shows the support for read-only database. You can find more information on read-only databases here: Run a farm that uses read-only databases (SharePoint Server 2010) [http://technet.microsoft.com/en-us/library/dd793608.aspx].

<configuration>
    <SharePoint>
        <SafeMode CallStack="true" />
    </SharePoint>
    <system.web>
        <customErrors mode="Off" />
        <compilation debug="true" />
    </system.web>
</configuration>

By only changing the web.config file in the web application root, located in “C:\inetpub\wwwRoot\wss\<webapp>”, will not display detailed information in application pages (a.k.a. layouts pages).

There is more than one web.config file! Check your SharePoint Root folder.

Update the configuration show above in the “…\14\TEMPLATE\LAYOUTS\web.config” file and this will result in a .NET error page for application pages.

What you need is a centralized administration, like the Central Administration, controlling your application configuration. The Central Administration in SharePoint has two sorts of pages. The homepage (default.aspx) providing an overview and pages like Application Management showing a collection of links related to Application Management.

It’s easy to build your own custom administration site. The image below shows my own administration site. Do you see the resemblance?

Creating these pages is pretty straightforward when using the FeatureLinkSections class together with “LinkSectionLevel1.ascx” and “LinkSectionLevel2.ascx” controls. This web control handles the rendering of the links based on enabled features in the current context. The links are provisioned by custom actions as part of a (enabled) feature.

<SharePoint:FeatureLinkSections Runat="server"
    Id="SettingLinksV4"
    CellPadding="4" CellSpacing="4"
    Location="Contoso.SharePoint.AdminPage"
    LinkSectionControl="LinkSectionLevel1.ascx" />

The Location attribute is an unique identifier indicating the location where links are provisioned. The location is used in the custom action XML (shown below) to point to the location in the FeatureLinkSections control.

  <!-- Admin Page - Security -->
  <CustomActionGroup
     Id="ContosoSecurity"
     Title="Contoso Security"
     Location="Contoso.SharePoint.AdminPage"
     Sequence="10"
     Description=""
     ImageUrl="/_layouts/images/
         SiteSettings_UsersAndPermissions_48x48.png" />
  <CustomAction
    Id="ContosoAdmins"
    GroupId="ContosoSecurity"
    Location="Contoso.SharePoint.AdminPage"
    Rights="EnumeratePermissions,BrowseUserInfo"
    Sequence="10"
    Title="Contoso Administrators"
    Description="...">
    <UrlAction
        Url="_layouts/people.aspx" />
  </CustomAction>

The FeatureLinkSections control uses two views controlled by the LinkSectionControl attribute.

LinkSectionLinks1.ascx

Shows a 48×48 icon for the group and links are placed below each other.

LinkSectionLinks2.ascx

Shows a 32×32 icon for the group and links are delimited by the “|” character.

Visual Studio solution

I included the Visual Studio project containing the following components:

• AdminPages_Web feature: Web scoped feature with event receiver updating the welcome page and quicklaunch. The feature contains the following components:
  • AdminPage module
  • AdminPageActions custom actions
  • PBWebTemplate element
  • Event receiver
• AdminSite_Site feature: Site collection scoped feature containing the web template for creating the web. The feature contains the following components:
  • AdminWebTemplate web template
• AdminPageActions custom actions: All custom actions containing all links displayed in the central adminstration.
• AdminPages module: Provisions the adminpage.aspx and security.aspx pages in the web root folder.
• AdminWebTemplate web template: Contains the web template for creating the web.
• PBWebTemplate element: Property bag element with unique web template id

You can download the WSP package and source code at http://sp2010admin.codeplex.com/.

I wanted to create a sandboxed solution which loops all lists and updates the field values of items. Among these field values are taxonomy fields. Normally you would use TaxonomyField.SetFieldValue() for updating the field value. But within a sandboxed solution you are not allowed to use the Microsoft.SharePoint.Taxonomy namespace.

If you are interested in the outcome: You CAN’T set the taxonomy field value for an item from a sandboxed solution. When updating a taxonomy field value always use the TaxonomyField.SetFieldValue() method. If you want to know why, enjoy reading!

Research

After reading about taxonomy and taking a closer look at what is actually stored in a list, I noticed a couple of things:

• When creating a taxonomy field, it actually creates 2 fields
• Note (SPFieldMultiLineText) field: Shown in the list as value
• TaxonomyField field: Hidden field in the list
• The actual value stored in the hidden TaxonomyField should look like “<wssid>;#<guid>|<label>”
• The WssId is the list item ID for the local stored TaxonomyHiddenList, which is located at http://<applicationurl>/sites/<sitecollection>/lists/taxonomyhiddenlist/
• When WssId is –1 it means the term is not provisioned in the TaxonomyHiddenList
• Calling TaxonomyFieldValue.ValidatedString triggers an update on the TaxonomyHiddenList to provision the term and returns the validated string “<wssid>;#<guid>|<label>”
• ‘The guid and label are those of an existing term in the Term Store
• The delimiter “;#” between wssid and guid is SPFieldMultiColumnValue.Delimiter
• The delimiter “|” between guid and label is TaxonomyField.TaxonomyGuidLabelDelimiter.

Testing approach

The general idea for figuring it this out was creating a farm solution first and get everything up and running. When successful completing the farm solution, rework everything to a sandboxed solution.

The approach for testing is split up into 2 parts and every part has 4 tests. Part 1 is updating list item properties, part 2 is updating document properties. The pre-requisite for the test is a valid term (guid and label) and the term exists in the TaxonomyHiddenList.

During the tests I’ll talk about the two fields mentioned earlier. For ease of reading let’s name the Note field “taxField” and the TaxonomyField “taxHiddenField”.

Every part consist of 4 tests:

1. TaxonomyField.SetFieldValue(item, term)
2. item[taxField.Title] with value “<wssid>;#<guid>|<label>”
3. item[taxHiddenField.Title] with value “<wssid>;#<guid>|<label>”
4. item[taxHiddenField.Title] with value “<guid>|<label>”

I’ll spare the details and focus on the outcome.

Part 1: Updating list item properties

When updating a list item the assumption is that the TaxonomyField.SetFieldValue() is the preferred way of updating a taxonomy field value. When updating a list item this results in updating both the taxField and taxHiddenField.

All four tests result in updating both fields. Although it seems to exclude the WssId in the field value of taxField and taxHiddenField for tests #1 and #4. This looks weird to me for test #1, because looking internally to the decompiled sources, Microsoft uses the ValidatedString value which includes the WssId.

The same result as test #1 is only achieved with test #4, because tests #2 & #3 includes the WssId in the taxHiddenField. This makes sense because we are explicitly updating the field value with the WssId.

For now it look like we are able to update the taxonomy field value in different ways. This is what we would like, because we could use the
item[taxField.Title] = “<wssid>;#<guid>|<label>” within a sandboxed solution. Although it’s not completely consistent behavior.

Part 2: Updating document properties

Once again the assumption is updating a document via TaxonomyField.SetFieldValue() is the preferred way of updating the taxonomy field value. This results in both updating the taxField and taxHiddenField.

When running tests #2, #3 and #4 we run into issues. After the first run of the test everything looks OK. When running the test for a second and third time the taxField and taxHiddenField are out of sync. Both contain different values resulting in unexpected behavior!

Conclusion

I had planned to test the sandboxed solution, but didn’t got to it because the results of updating the document properties (part 2) from a farm solution were pretty clear. I could not find out what magic happens during the TaxonomyField.SetFieldValue(). But I did find out that something is happening, which is important for updating the list item or document properties!

In other words there is no other way of updating the document properties for taxonomy fields than
TaxonomyField.SetFieldValue().

Remember don’t ever use the item[“<taxonomy field name”] = “<wssid>;#<guid>|<label>” statement for updating a taxonomy field value because you can’t rely on it!

Simply start Word and type =lorem(3,10) and press Enter. 

This results in:

There are some options you can use:

• =lorem(p, l) where p is the number of paragraphs and l the number of lines per paragraph.
• =rand(p,l) provides the same functionality but using different text “On the Insert tab, the galleries include items that are designed …”
• =rand.old(p,l) also provides the same functionality using different text “The quick brown fox jumps over the lazy dog. The quick brown fox …”

Maybe you already knew, maybe not. I was looking for the “The quick brown fox jumps over the lazy dog. The quick brown fox …” text and thought lets share!

When working on a “Yet Another SharePoint Gem” as Robin Meure called it. I stumbled on the SPBuiltInFieldId class and SPBuiltInContentTypeId class. When retrieving information like the CreatedBy field (also known as Author) it is very useful. Also when checking whether a item is based on a out-of-the-box (OOTB) content type. See exaples below.

Update: in addition to both SharePoint 2010 Foundation classes SharePoint Server has ContentTypeId class and FieldId class. Both are part of the Microsoft.SharePoint.Publishing namespace. Thanks to Jeffrey Schmitz (@DJeffa).

Here an example for the extension of the SPListItem class to retrieve the Author:

public static class SPListItemExtentions
{
    /// <summary>
    /// Gets the author of a list item.
    /// </summary>
    /// <param name="item">Extended class.</param>
    /// <returns>Returns the author of the list item.</returns>
    public static SPUser GetAuthor(this SPListItem item)
    {
        string user = item[SPBuiltInFieldId.Author].ToString();
        int userId = Convert.ToInt16(user.Split(';')[0]);
        return item.Web.AllUsers.GetByID(userId);
    }
}

Another example for checking the base content type:

SPListItem item = list.GetItemById(1);
SPListItem topic = item;

// If item isn't the dicussion topic, get topic!
if (!item.ContentType.Id.IsChildOf(SPBuiltInContentTypeId.Discussion))
    topic = GetTopicItem(item);

Microsoft has provided a solution described in KB 2484317. The root cause of the issue is described as:

With Microsoft Office SharePoint Server 2007 we stored new Publishing Pages in a library called Pages. In SharePoint 2010 it has been translated to Paginas as the default for Dutch. The navigation code assumes that any changes from the default are noted in a specific property, which is not the case for upgraded Dutch sites that have been created with the 2007 default name.

The solution to this problem is pretty easy, a simple PowerShell script will restore your navigation.

$site = Get-SPSite("http://WebApplicationURL")
foreach ($web in $site.AllWebs)
{
    Write-Output("web:" + $web.ServerRelativeUrl);
    $pageslistid = $web.AllProperties["__PagesListId"]

    if ([String]::IsNullOrEmpty($pageslistid))
    {
        Write-Output($web.ServerRelativeUrl +" doesn't have a pages list id set - skipping");
    }
    else
    {
        $pageslistguid = new-object System.Guid($pageslistid)
        $pageslist = $web.Lists[$pageslistguid]
        $pagesurl = $pageslist.RootFolder.Url
        $pb = $web.Properties;
        $pb.Add("__PagesListName", $pagesurl);
        $pb.Update();
        Write-Output($web.ServerRelativeUrl +" set pages list to " + $pagesurl);
    }
}

This script reads a TXT-file with 1 users’ display name per line. Per user it searches the local directory and outputs the displayName and sAMAccountName in a semicolon separated line (easy for Excel extraction).

PowerShell script:

function ConvertUser($user)
{
    $search = New-Object DirectoryServices.DirectorySearcher([ADSI]“”)
    $search.filter = “(&(objectClass=user)(displayName=$user))”
    $results = $search.Findall()

    foreach($result in $results){
        $userEntry = $result.GetDirectoryEntry()
        Write-Output('' + $userEntry.displayName + ';' + $userEntry.sAMAccountName)
    }
}

function ConvertUsers
{
    process{
        foreach($user In $_){
            ConvertUser($user)
        }
    }
}

Get-Content “.\Users.txt” | ConvertUsers 

TXT-file with users (filename: “Users.txt”):

Aaron Painter
Adam Barr
Alan Brewer
Alan Steiner

Make a TXT-file with users display name (see example below). Then copy, paste and run the script above should do the trick.

My colleague needed to remove the properties, this PowerShell script removes both properties:

# Remove properties
$wa = Get-SPWebApplication -Identity "<WebApplication>"
$wa.Properties.Remove("portalsuperuseraccount")
$wa.Properties.Remove("portalsuperreaderaccount")
$wa.Update()

Write-Host("Properties count for " + $wa.Url +  ": " + $wa.Properties.Count)

I hope it helps those who want to undo their settings. To complete the script:

# Get current properties
$wa = Get-SPWebApplication -Identity "<WebApplication>"
$user = $wa.Properties["portalsuperuseraccount"]
$reader = $wa.Properties["portalsuperreaderaccount"]

# Write current properties
Write-Host("Properties count for " + $wa.Url +  ": " + $wa.Properties.Count)
Write-Host("Super user (" + $wa.Url +  "): '" + $user + "'")
Write-Host("Super reader (" + $wa.Url +  "): '" + $reader + "'")

SharePoint features and solution upgrading

This was a level 300 session about SharePoint features and solutions upgrading.

The feature and solution framework used for the deployment of custom SharePoint solutions was introduced in SharePoint 2007. With SharePoint 2010 some major improvements have been made to the framework to allow for feature versioning and upgradability. This provides new ways to deal with application lifecycle management.

This presentation covers the feature and solution framework, explains when to use the feature upgrade and talks about upgrading existing activated and non-activated features. During the session different demos will be build supporting the different scenarios.

You can download the slide deck here:

DevDays 2011 – Bram de Jager – SharePoint Feature and Solution upgrading.pptx

 Enjoy the video on my session on Channel 9!

Important note: This is (probably) not supported and I can’t guarantee your virtual machine is recovered. Please only use this how-to as your last resort! It might help you

What happened?: When the virtual machine (VM) crashed it needed a forced shutdown. When restarting the VM it came back with Recovery mode. I wasn’t able to start Windows normally!

Solution: Within VirtualBox (I’m currently using Oracle VM VirtualBox), or any other virtualization software, you are able to mount multiple hard disks. You need to mount the hard disk of the crashed VM to another healthy VM (which works normally). Pay attention to snapshots, mount the latest snapshot! Start the healthy VM.

What happens?: The healthy VM will pick up the crashed hard disk and starts scanning and repairing the hard disk. After repairing Windows will start normally and you are able to browse the hard disk and retrieve your files.

If you are having a lucky day? You could try to shutdown the healthy VM. Unmount the hard disk (which was repaired). And try starting your crashed VM. Now you know whether you are really lucky! It might start!? Good luck!

The following elements.xml is packaged in a feature.

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
  <CustomAction
    Location="ScriptLink"
    ScriptSrc="~site/_layouts/project_name/js/custom-1.0.0.js?rev=20110413" />
  <CustomAction
    Location="ScriptLink"
    ScriptSrc="~sitecollection/_layouts/project_name/js/ jquery_query-2_1_7.js?rev=20110413" />
  <CustomAction
    Location="ScriptLink"
    ScriptSrc="~site/_layouts/project_name/js/jquery-1.5.1.min.js?rev=20110413" />
</Elements>

This results in the following HTML in your pages.

document.write('<script type="text/javascript" src="/_layouts/project_name/js/jquery-1.5.1.min.js?rev=20110413"></' + 'script>');
document.write('<script type="text/javascript" src="/_layouts/project_name/js/jquery_query-2_1_7.js?rev=20110413"></' + 'script>');
document.write('<script type="text/javascript" src="/_layouts/project_name/js/custom-1.0.0.js?rev=20110413"></' + 'script>');

Important to know is the order in the elements.xml is the opposite sequence in the HTML. Meaning the script “jquery_query-2_1_7.js” is depending on “jquery-1.5.1.min.js” and needs to be the last item in the elements.xml.

In the script link I’m using “~site” and “~sitecollection” tokens to change the link according to the site or site collection where the user is located. This is important when creating a generic feature used on multiple sites.

By using the “?rev=20110413” at the end of your link you can force the browser to refresh its local cache. A (script) file is downloaded the first time accessing the page. As long as the link does not change the browser does not download the file. By changing the query string you can force a download of the script when changes are made. The actual value “20110413” is todays date, but can be your own versioning logic.

The example above also has a version number in the file name, this is another way of forcing a download. I simply wanted to illustrate the possibilities, you probably will use either query string or version number.

Lessons learned / best practices:

• Order in elements.xml for <CustomAction /> elements is of influence of the order of script links in the resulting HTML.
• Use “~site” and “~sitecollection” tokens to control the script link.
• Use “?rev=20110413” query string or version number in filename to force a download of the file.

Session abstract: SharePoint Features en Solution Upgrading

The session is held in Dutch:

Het feature en solution framework dat gebruikt wordt voor deployment van custom SharePoint solutions is geïntroduceerd als onderdeel van SharePoint 2007. In SharePoint 2010 is dit onderdeel verder uitgebreid met feature versioning en upgradability. Dit is van invloed op de application lifecycle management strategie.
Deze presentatie gaat in op het feature en solution framework, wanneer pas je feature upgrade toe en hoe ga je om met het upgraden van bestaande geactiveerde en niet-geactiveerde features. Tijdens de sessie worden meerdere demo’s gebouwd op basis van verschillende scenario’s.

You can delete all keywords manually, but removing 100+ keyword results in a bad humor. With a nice PowerShell script the sun shines within seconds!

The script retrieves the MMS and loops the keywords and deletes them. When all keywords are deleted a Commit is needed to push all changes. Made a mistake? Rollback is also an option .

#Connect to Central Admin 
$taxonomySite = Get-SPSite "http://CA-url/"

#Connect to Term Store in the Managed Metadata Service Application 
$taxonomySession = Get-SPTaxonomySession -site $taxonomySite
$termStore = $taxonomySession.TermStores["Managed Metadata Service Application"]
Write-Host "Connection made with term store -"$termStore.Name 

#Connect to the Group and Term Set 
$termStoreGroup = $termStore.Groups["System"]
$termSet = $termStoreGroup.TermSets["Keywords"] 

#Loop all keywords and delete
foreach($keyWord in $termSet.Terms) {
    $keyWord.Delete()
    Write-Host "Deleted keyword:" $keyWord.Name
}

#Update the Term Store 
$termStore.CommitAll()

When I placed the JavaScript in the web part I got a null reference error. The problem originated from the SP.UI object model not being loaded. Especially because it did work when I executed the script on the OnClick event of a button.

The solution is provided by the SP.SOD.executeOrDelayUntilScriptLoaded method. It will wait to execute the function you provide until the script you refer is completely loaded.

ExecuteOrDelayUntilScriptLoaded(ShowDialog, "sp.js");

Within my project I added a JavaScript file containing my method “ShowDialog()” to show the dialog. Within my web part I perform the validation and call the CreateDialog() method.

/// <summary>
/// Registers the javascript supporting showing dialog.
/// </summary>
/// <remarks>
/// When calling this method, the dialog is shown
/// to the user and blocks the page below.
/// </remarks>
private void CreateDialog()
{
    // Define the name and type of the client scripts on the page.
    string csname = "ShowDialogScript";
    Type cstype = this.GetType();

    // Get a ClientScriptManager reference from the Page class.
    ClientScriptManager cs = Page.ClientScript;

    // Check to see if the startup script is already registered.
    if (!cs.IsStartupScriptRegistered(cstype, csname))
    {
        StringBuilder js = new StringBuilder();
        js.Append("<script type='text/javascript'>");
        js.Append("ExecuteOrDelayUntilScriptLoaded(ShowDialog, 'sp.js');");
        js.Append("</script>");

        cs.RegisterStartupScript(cstype, csname, js.ToString());
    }
}

Access is denied. Verify that either the Default Content Access Account has access to this repository, or add a crawl rule to crawl this repository. If the repository being crawled is a SharePoint repository, verify that the account you are using has "Full Read" permissions on the SharePoint Web Application being crawled. ( HttpStatusCode Unauthorized The request failed with HTTP status 401: Unauthorized. )

This most likely has to do with the default content access account not having access to the user profile service application. The default content access account needs “Retrieve People Data for Search Crawlers” permissions on the user profile service application.

Solving this is rather easy. See steps below:

1. Navigate to the Central Administration
2. Click on Manage Service Applications
3. Select the “User Profile Service Application” (note: do not click the name of the service application, because you will be redirected to management page)
4. Click in the ribbon on the Administrators button
5. Add the “Default content access account” to the accounts list
6. Select the “Default content access account” in the list
7. Check the “Retrieve People Data for Search Crawlers” permission
8. Click OK

The agenda:

• Visio 2010 & Visio Services
• Linking data and web parts
• Real-life examples
• Summary

Today I needed the out-of-the-box (OOB) list of all profile properties. Below the full list of all properties.

[Update: link to TechNet article Default user profile properties (SharePoint Server 2010) and Default user profile property mappings (SharePoint Server 2010)]

You can’t install Visio 2010 32-bit version when a 64-bit Office application is already installed on the system.

Conclusion, if there is no specific reason for installing a 64-bit version of Office. Simply install the 32-bit version.

This can be achieved by developing a webpart which loops the user profile properties and retrieves per property the value of an user profile. The user profile which is displayed can be set in the webpart properties pane.

The C# code which drives the webpart is shown below. It is pretty straight forward and shows only the retrieval of the user profile properties and values of the user profile.

System.Security.PermissionSet ps = new System.Security.PermissionSet(System.Security.Permissions.PermissionState.Unrestricted);
ps.Assert();

Microsoft.SharePoint.SPServiceContext serviceContext = Microsoft.SharePoint.SPServiceContext.Current;
UserProfileManager upm = new Microsoft.Office.Server.UserProfiles.UserProfileManager(serviceContext);
ProfileSubtypePropertyManager pspm = upm.DefaultProfileSubtypeProperties;

UserProfile profile = upm.GetUserProfile("CONTOSO\AaronP");

this.Controls.Add(new Literal() { Text = "<table border='0' > <tr><td>Displayname</td><td>Name</td><td>Value</td></tr>" });
foreach (ProfileSubtypeProperty prop in pspm.PropertiesWithSection)
{
    if (prop.IsSection)
        this.Controls.Add(new Literal() { Text = string.Format("<tr><td colspan='3'><b>Section: {0}</b></td></tr>", prop.DisplayName) });
    else
    {
        string text = string.Format("<tr><td>{0}</td><td>{1}</td><td>{2}</td></tr>",
            prop.DisplayName,
            prop.Name,
            profile[prop.Name].Value);

        this.Controls.Add(new Literal() { Text = text });
    }
}
this.Controls.Add(new Literal() { Text = "</table>" });

You can download the WSP package and source code at http://sp2010userprofilewp.codeplex.com/.

I created a site-collection based on the out-of-the-box Team Site template (STS#1). Made changes to the site by adding a new list FAQs, added a task to the Task list and added the Tasks list on the homepage. This is the basics for my template.

Next step is to save the team site as a template.

1. Click Site Actions » Site Settings
2. Click Save site as template
3. Fill in the fields
   • File name: TeamSiteTemplate
   • Template name: Team Site Template
   • Check the Include Content checkbox
4. Click OK
5. Click the link Solution Gallery in the “Operation Completed Successfully” window
6. Click the “TeamSiteTemplate” name to download the WSP solution file, save on your desktop

At this point we have a WSP solution file containing a template for a new site. We want to create a new site-collection based on this template. But we do not want to upload the WSP solution as a Farm Solution. We can create the new site-collection based a sandbox solution containing the template.

1. Open SharePoint 2010 Central Administration via Start Menu
2. Click Application Management » Create Site Collections
3. Select a web application
4. Fill in the fields
5. When selecting a template, click the Custom tab and select “< Select template later… >”
6. Click OK

The site-collection is created but has no template. Meaning it is also not provisioned with lists and libraries. We want the site-collection to be based on our sandboxed solution template. Next steps will explain!

1. Open the new site-collection URL
2. The “Template Selection” page is shown
   
3. Click Solution Gallery
4. Upload the sandboxed solution by click the Solutions tab in the ribbon
5. When uploaded, activate the solution by clicking Activate in the Solution Gallery – Activate Solution window
6. Go back to the Template Selection page (_layouts/templatepick.aspx) by using the Back-button
7. Refresh the page, the Custom tab should show up
   
8. Select the Custom tab and select our “TeamSiteTemplate”
9. Click OK

Now the site-collection is provisioned based on the sandboxed solution. The site is provisioned with the FAQs list and one task in the Task list which is shown on the homepage.

“Your client does not support opening this list with Windows Explorer”

This looks like:

A workaround is opening the document library in Windows Explorer. You would need a different link than the one in the browser otherwise Windows will use your browser for opening the link.

\\webapplicationurl@SSL\DavWWWRoot\sites\sitecollection 

For example we want to open the document library “Shared Documents” in the site collection https://teamsite.sharepoint.com/sites/teamsite1. The direct link would be \\teamsite.sharepoint.com@SSL\DavWWWRoot\sites\teamsite1\Shared Documents.

This is also useful when you want to look at attachments from a list. You can change the link and navigate the complete site collection folder structure.

“The form cannot be rendered. This may be due to a misconfiguration of the Microsoft SharePoint Server State Service. For more information, contact your server administrator.”

This is likely caused because the State Service Application is not turned on. You can check this in the Central Administration » Application Management » Manage Service Applications. If the State Service Application is not listed you know why the message is showing.

There are two ways for activating the State Service Application. One is using the Farm Configuration Wizard (FCW). But I prefer via PowerShell, below the script for creating the new service application and add to default proxy group. If you like you can choose your own name parameters.

$serviceApp = New-SPStateServiceApplication -Name "State Service Application"
New-SPStateServiceDatabase -Name "StateService_DB" -ServiceApplication $serviceApp
New-SPStateServiceApplicationProxy -Name "State Service Application Proxy" -ServiceApplication $serviceApp –DefaultProxyGroup

More on TechNet on State Service:

http://technet.microsoft.com/en-us/library/ee704548.aspx