SharePoint and .Net Fun

Kerberos Debugging Tool

2011-02-01T09:55:00.001-08:00

DelegConfig

http://blogs.iis.net/bretb/archive/2008/03/27/How-to-Use-DelegConfig.aspx

ASP.NET 2.0 Tag Mapping

2010-05-04T08:18:00.002-07:00

http://community.bamboosolutions.com/blogs/bambooteamblog/archive/2009/06/20/sharepoint-people-picker-override-validation-logic.aspx

SharePoint auth provider web.config settings

2010-05-04T08:18:00.000-07:00

Check this out:
http://blogs.msdn.com/harsh/archive/2007/01/10/forms-based-authentication-in-moss.aspx
http://technet.microsoft.com/en-us/library/cc262069.aspx

Automatic NTLM auth with Firefox

2010-04-29T08:45:00.000-07:00

Being a dedicated Firefox user, one of the few things that was still thwarting me was SharePoint. We use SharePoint internally for a ton of stuff, and it was a drag to have to fall back to that other browser. SharePoint pages look and work fine in Firefox, but I was having to reauthenticate on every single page, which really hindered my enjoyment of the experience.
I finally figured out how to get Firefox to do NTLM, which means I don’t have to deal with the authentication dialogs, thereby reducing my dependence on IE to one and only one application (Oddpost).
It’s not at all obvious how to make it work, and it took me a few tries. You have to go to your Firefox address bar and type about:config. This will bring up the internal config editor, which allows you to set all kinds of properties that influence Firefox’s behavior. Look for the key called network.automatic-ntlm-auth.trusted-uris. Set that key’s value to a comma separated list of servers you want NTLM auth for. So if your internal SharePoint sites are on servers called Larry and Mo, use “larry,mo”. You can also add the same value to the key network.negotiate-auth.trusted-uris. It’s unclear to me if that second one is required, but I set it, and everything works. Now SharePoint works like a champ, and authenticates automatically.

Update Site Quota for existing sites- Tips & Tricks

2010-04-28T09:11:00.000-07:00

There is a little known discrepancy in the SharePoint 2007 Site Quota Templates; they are not easily updated. You see Site Quotas are based upon a template model that is disconnected in nature. That means that all new sites that have the template applied will get the updated version but any existing sites for which it was previously applied retain the previous values.

Unfortunately when you make changes to the template in Central Administration and then check the site quota of an existing site it does appear that the changes have taken effect. This is because the page is simply pulling the settings from the new Quota Template instead of pulling the settings applied at the site level. If you use StsAdm.exe to enumerate through the sites you will see that the site quota retains the previous values. I'll demonstrate.

Lets edit an existing Quota Template for Personal Sites. You navigate to Central Administration and click on Quota Templates. You can see that the existing values are set to allow a maximum storage limit of 100 MB.

Now change the Storage Limit Maximum to 200 MB as below.

If we navigate to Site Quotas and Locks and choose the MySites web application we can see that our changes have taken effect. Or so it would appear.

However, if we use Stsadm.exe and Enumerate through the sites in the web application though we can see that our initial value of 100 MB still applies.

This is because the Quota Template is just that, a template, it only applies to new sites that are assigned the quota from that point forward. It does not propagate its changes. Actually there really is no way to propagate these changes and of course we can't have that, so I wrote a little extension to Stsadm.exe to make that possible.

Rather than bore you with the specifics of how I did this I'll refer you to the blog that I used for references on extending Stsadm.exe. John Holiday has a great article here. And of course there is the trusty SDK with which I could not live without.

Below is a screen shot of the help for the Update Quota command that I wrote for Stsadm.exe.

As you can see it takes 2 parameters, one for the URL and another for the Quota Template Name. The command would be stsadm -o updatequota -url "http://my.demo.com" -quotaname "Personal Site".

After running the command we can go back and use stsadm to enumerate through the sites and see that our changes have taken effect.

Most everything in MOSS 2007 is extensible in one way or another and Stsadm is no exceptions. Actually extending stsadm is quite simple. In this blog entry I am going to walk through creating a custom extension for stsadm that I use in a real life scenario. This extension is called Quota Updater and you can read a little history about how this came about in my post here.

The first thing we do is create a new VS project and add a new class called quotaupdater.cs and implement the ISPStsadmCommand interface. Now we have to implement the Run and GetHelpMessage methods. These look like this:

public int Run(string command, StringDictionary keyValues, out string output)
        {
          //logic here
        }

public string GetHelpMessage(string command)
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("-url <url>\t\tthe url of the site to process");
            sb.AppendLine("\t-quotaname <quotaname>\tthe template to process");
            return sb.ToString();
        }

The second thing we have to do is create an XML file that describes our commands and add it to the 12/config directory. This looks as follows:

<?xml version="1.0" encoding="utf-8" ?>
<commands>
    <command name="updatequotas"

          class="STSAdmExtensions.QuotaUpdater, STSAdmExtensions, 
      Version=1.0.0.0, Culture=neutral, PublicKeyToken=86a65a77eee85b51">
  </command>
</commands>

In the above XML file the command name is whatever you would like your user to type to activate the custom command with stsadm. This does not necessarily have to be the same as your method or class. It can literally be whatever you would like. The class section is the typical stuff you can get by using Refactor on your assembly.

Now for the meat of the application. Basically what I wanted to do was get a reference to a site collection and a quota template and force updates to the template down to the sites on which it is applied. The Run method is as follows:

public int Run(string command, StringDictionary keyValues, out string output)
{
    StringBuilder sb = new StringBuilder();
    string url = keyValues["url"], quotaName = keyValues["quotaname"];
    //if no URL specified then return 0 and message
    if (url == null || url.Length == 0)
    {
        output = "No url specified";
        return 0;
    }
    //if no Quota Template name supplied then return 0 and message
    if (quotaName == null || quotaName.Length == 0)
    {
        output = "No Quota Template specified";
        return 0;
    }
    try
    {
        SPSite site = new SPSite(url);
        SPWebApplication webApp = site.WebApplication;
        SPSiteCollection col = webApp.Sites;

        SPGlobalAdmin globalAdmin = new SPGlobalAdmin();
        SPGlobalConfig globalConfig = globalAdmin.Config;
        SPQuotaTemplate quota = globalConfig.QuotaTemplates[quotaName];

        UpdateQouta(col, quota);
        output = message;
        
        //clean up resources
        site.Close();
        site.Dispose();
        return 1;
    }
    catch (Exception ex)
    {
        output = ex.Message;
        return 0;
    }
}

And the UpdateQuota method is shown below.

/// <summary>
/// Updates all site quotas in a site collection with updated quota template values
/// </summary>
/// <param name="sites"></param>
/// <param name="quotaTemplate"></param>

public void UpdateQouta(SPSiteCollection sites, SPQuotaTemplate quotaTemplate)
{
    int iCount = 0;
    StringBuilder sb = new StringBuilder();

    foreach (SPSite site in sites)
    {
        //verify quota on the site against the quota template to prevent overwrite
        if (site.Quota.QuotaID == quotaTemplate.QuotaID)
        {
            iCount++;
            site.Quota.InvitedUserMaximumLevel = quotaTemplate.InvitedUserMaximumLevel;
            site.Quota.StorageMaximumLevel = quotaTemplate.StorageMaximumLevel;
            site.Quota.StorageWarningLevel = quotaTemplate.StorageWarningLevel;
        }
    }
    if (iCount == 0)
    { 
            message = "No sites were updated. Make sure you specified the correct " +_
                    "Quota Template Name.";
    }
    else
    {
        sb.AppendLine(iCount + " Sites Updated");
        sb.AppendLine("The Command Completed Successfully");
        message = sb.ToString();
    }
}

Now all you have to do is deploy the assembly to the GAC and copy your XML file to the 12/config directory and you are set to go.

Host Multiple Websites using SSL on Port 443- WildCard Server Certificate

2010-04-26T09:41:00.000-07:00

Wildcard SSL certificates can allow you to publish multiple IIS web sites--all using SSL on port 443--that are accessible by host headers. That is, if you're running on IIS 6 or above.

So you read about these things, wildcard certificates, but mostly you read about how to buy them. It is possible (and easy) to create one for yourself, however, so long as you don't mind it not being trusted by folks' browsers.

There are some really good uses for these, not least in a test environment in which you don't care about the trust. Production environments need them, too, sometimes, such as when you're using a network appliance like a Netscaler or F5 load balancer. Those devices allow you to point multiple URLs (cnames, really) to a single (or multiple) server(s). Very handy. In our case, we have several web sites that we'd like to secure using SSL. Problem is: they're all on a single server.

There are several options for dealing with such a case: assign multiple IP addresses to the server, use different SSL ports for each IIS site, or (definitely the coolest option) use a wildcard certificate on the server to allow IIS to decipher the http host header. This option, by the way, is a new feature with IIS 6, so if there's anyone out there still using IIS v5, this is another reason to upgrade.

Background
A little background on the problem might be in order: a SSL certificate is used to encrypt the http data. Normally, in setting up a IIS web site, we differentiate that site from all the others by assigning unique host headers to each site. IIS can use those host headers to determine to which site to route any given http request.
When the site is using ssl, however, the host header is encrypted, which introduces something of a chicken-and-egg thing: since the host header (along with all the rest of the data) is encrypted, IIS can't use that to determine which site to send the request to. And, since a SSL certificate is site-specific, IIS can't use a certificate to decrypt the data until it knows which site the request belongs to. Thus, it widely is reported that it isn't possible to have multiple SSL sites on a single server, all sharing the same port.

Enter wildcard SSL certificates and secure server bindings. The wildcard certificate allows IIS to use the same certificate for all of the sites on a particular port. That takes away the requirement that IIS know which site's certificate to use in decrypting the data. Secure server bindings help IIS in securing the wildcard certificate, a requirement for setting this up.
Note that a similar solution is available to apache. You can read about it here. Thus, it is very possible to have multiple SSL sites on a single server, all sharing the same port.

Configure your sites to use host headers

Host headers are the backbone of this. Open the properties window for each site in IIS and click the advanced button. There, you can add the appropriate host header on port 80.

Creating a self-signed wildcard SSL certificate:

The next step in this process is to make sure that all of the relevant sites have the same SSL port assigned to them. In IIS, go to each site's properties and enter the appropriate port number (the same one for each site) in the SSL Port field. 443 is the default SSL port.

Note that once you do this, all but one of the affected sites will stop. That is because, at this point, IIS isn't configured to allow multiple sites to share the same SSL port. That's OK; we'll take care of that in a moment.

Now, to generate the certificate: using SelfSSL, generate the certificate for one existing IIS site. SelfSSL is a tool that's a part of the Microsoft IIS Resource kit. If you haven't downloaded and installed it, you'll need to do that first. Here's the syntax:

selfssl /n:cn=*.server.edu /s:1 /P:443 /v:3650

Where *.server.edu would be your own URL. So if you had these sites:
mysite.sharepoint.com
portal.sharepoint.com
auth.sharepoint.com
you'd use this code:

selfssl /n:cn=*.sharepoint.com /s:1 /P:443 /v:3650

It's the * that makes it a wildcard certificate.

The /s:1 is the site identification. There are a variety of ways to view a site's identifier, but the easiest simply is to open the IIS manager and click on the "web sites" tree on the left. The right-hand pane will show the description and identifier. The default site has an identifier of 1; the other sites have very long identifiers.

/P: is the SSL port you're using, and /V: is the number of days for which this cert is valid. Why would you want it to expire, anyway?

Now you've generated a wildcard certificate.

Assign the Certificate to your sites

The easiest way to assign a certificate to a site, having already created it, is to view the site properties in IIS Manager. Click on Directory Security, and then on the Server Certificate button. This will start the wonderful wizard of IIS.

You already have created a certificate, so when the wizard prompts you, choose "Assign an existing certificate." When you click next, you'll see a list of available certs, including the wildcard certificate you created. Select this certificate, click next, and make sure you assign it the same port that was assigned to the first site.

That's it: once the wizard has finished its magic, you've assigned the cert to your site. Repeat this for all of the sites you want to secure on this port with SSL.

Configure Secure Server Bindings

This is the final step. It involves running a vbs script to set up secure bindings, which allows IIS to use host headers with SSL and secure the new wildcard certificate you created and installed.

The syntax is like this:

cscript adsutil.vbs set /w3svc/844934796/SecureBindings ":443:mysite.sharepoint.com"

The adsutil.vbs script, at least on my systems, is at C:\Inetpub\AdminScripts. You'll need to run the script command from that location.

The syntax breaks down like this:
844934796 is the site ID. Substitute your own site identifier there.
443, again, is the port
mysite.sharepoint.com is the host header for the site. Make sure that you have this host header configured in the site properties in IIS, as well.

Run this script for each of your IIS sites.

That should be all you need to do. Start up the stopped sites after you've run cscript, and you should be good to go.

Microsoft has a few documents that run through this, but they don't really put the pieces together for you. Here they are:

Configure SSL Host Headers (IIS 6.0)
Configuring Server Bindings for SSL Host Headers (IIS 6.0)
Obtaining and Installing a Wildcard Server Certificate

By the way: if you've done a lot of testing, and you've generated a bunch of certificates you're no longer using, you can delete them. Run mmc.exe and add the certificates snap-in. You'll want to choose the "local computer" version. Using that, you can manage all of your local certificates, including deleting the ones you no longer need.

How to create a browser cache save URL to a javascript or css file in SharePoint

2010-03-29T08:03:00.002-07:00

How to create a browser cache save URL to a javascript or css file in SharePoint

Often it is necessary to ensure that updates to files on the server get populated to the client asap. Especially when it comes to dependencies to custom javascript of CSS files and server controls.

SharePoint itself does this by adding a query string to some of its vital Javascript files. E.g.:

/_layouts/1033/core.js?rev=PQia%2B0EyudqxiQyTfOSR%2Fw%3D%3D

Whenever the core.js file changes on the server a new query string value is generated. That allows browsers to cache the file as long as the file does not change on the server.

Today I got the question if it is possible to utilize the same method for custom js and css files. The answer is yes.

SharePoint provides the functionality to generate browser cache save Urls for such files if they reside inside the _layouts directory or one of it's localized subdirectory using the following method:

public static string Microsoft.SharePoint.Utilities.SPUtility.MakeBrowserCacheSafeLayoutsUrl(string name, bool localizable)

The first parameter needs to be the filename without a path (e.g. test.css) the second defines if the file resides in a language specific subdirectory or directly in the _layouts directory.

The following code will (e.g.) create the output below for german locale:

string saveUrl = Microsoft.SharePoint.Utilities.SPUtility.MakeBrowserCacheSafeLayoutsUrl("my-own.js", true);

/_layouts/1031/my-own.js?rev=PQia%2B0EyudqxiQyTfOSR%2Fw%3D%3D

SharePoint Caching

2010-03-29T08:03:00.000-07:00

Bring Cache

Depending on your user base you may care very little about how caching works in SharePoint. But whether you plan on using it or not, you should at least know it's there and that it takes very little effort to turn it on.

Remember that almost everything in SharePoint resides in the content database. This coupled with the fact that opening a database connection is an extremely expensive operation means that there's potentially a lot more capacity to be had from a SharePoint site by simply enabling caching.

In my experience running the Microsoft Web Application Stress Tool on test SharePoint sites, most sites running caching profiles were able to achieve 33% more requests per second that those using no caching at all. That's a LOT more capacity to be had, and best of all it's free (you know...you've already paid a lot of money for MOSS).

To enable Page Output Caching you need to turn on both the Office SharePoint Server Publishing Infrastructure feature in the Site Collection and the Office SharePoint Server Publishing in the sub site. Disk Caching is turned on through the web.config.

Page Output Caching

Page Output Caching works a lot like ASP.NET page output caching, allowing you to cache pages in memory for a certain period of time and also maintain many cached versions of pages based off of Browser Type, Query String, HTTP Header, or some custom function that you write and implement in your pages. It's quite flexible.

You start off by defining Caching Profiles in Site Settings (that is, how you want to determined if something should be cached) and then assigning profiles to either of Authenticated or Anonymous users as they visit your site. For instance, you could choose to cache pages for anonymous users and not cache pages for authenticated users.

By default Cache Profiles inherit down to sub sites just like security, and like security you can change the inheritance at any sub site along the way.

Disk Caching

The other type of caching is Disk Caching which simply stores assets that you would normally fetch from the content database on disk. Disk Caching and Page Output Caching aren't mutually exclusive and actually marry quite well together. To enable disk output caching all you really need to do is open up the web.config for the site and change the BlobCache key to look like below:

It's worth mentioning that path is a regular expressions of file types to cache to disk and maxSize is measured in gigabytes. The location is of course where these files will be persisted to disk.

Some Thoughts

I would strongly encourage you to enable caching schemes one or more of your SharePoint sites to try it out. Those that make the best candidates (stand to gain the most performance) are those that have a lot of users and have anonymous access turned on for the entire site collection (usually synonymous with public facing sites). If you think you're viewing a cached version of a page and you want to see the real content you can always suffix the query string with a nocache=1. IE. http://somedomain/Pages/default.aspx?nocache=1 displays the non cached version of default.aspx for the somedomain site.

So there it is. Enjoy your free performance gains. Like G.I. Joe says: "Knowing is half the battle."

Hide New Icon or Change the Duration SharePoint

2010-03-19T14:15:00.000-07:00

Use the command

Hide the Icon
stsadm -o setproperty -pn days-to-show-new-icon -pv 0 -url http://machinename/sites/teamsite.

Change the duration from default "2" days to "10"

stsadm -o setproperty -pn days-to-show-new-icon -pv 10 -url http://machinename/sites/teamsite.

Get All the Checkedout documents sharepoint

2010-03-15T13:55:00.000-07:00

using Microsoft.Office.Server.Search.Query;



 



ResultTableCollection rtc = null;

DataTable retResults = new DataTable();



           



string fullTextSql = "SELECT ModifiedBy,Title,owsCheckoutUser,FileExtension,owsFileLeafRef,Path FROM SCOPE() WHERE owsCheckoutUser IS NOT NULL"



 



 using (SPSite site = new SPSite(http://servername))



                {

                    using (FullTextSqlQuery query = new FullTextSqlQuery(site))

                    {



                       

                        query.QueryText = fullTextSql;

                        query.ResultTypes = ResultType.RelevantResults;



                        query.RowLimit = rowLimit;

                       

                        rtc = query.Execute();



                        if (rtc.Count > 0)

                        {

                                             

                            using(ResultTable relevantResults = rtc[ResultType.RelevantResults])



                                retResults.Load(relevantResults, LoadOption.OverwriteChanges);

          

                        }



           }

Mange WebPart Resources (Linked vs Embedded)

2010-03-12T13:25:00.000-08:00

One of the most common questions I get in class and see in the forums is how best to deal with Web Part resources. By resources, I mean those necessary files that your Web Part depends on. These include JavaScript files, images, CSS, Flash, or even Silverlight apps. With the packaging and deployment model of SharePoint, it may be challenging to figure out where to store and how to reference these files. This article will overview your deployment options and give you enough information to make the best choice for your resource needs.

Linked or Embedded

With resource files, you have two basic options: linked or embedded. Linked means your Web Part will point to the file that lives somewhere in the file system. This is the most common approach. Embedded means you store the actual resource file inside your Web Part assembly. While less common, this can be very useful in many cases. We’ll look at each of these in more detail.

Linked Resources

Linked resources work best if you’ll need to modify the resource file separately from the Web Part. For example, say your Web Part references a JavaScript file and you continually need to tweak it and don’t want to recompile and redeploy the Web Part. If you link to it, it’s easy to change, and no changes to your Web Part are necessary. When working with linked resources, SharePoint provides you two primary options.

Store the resource in a virtual directory such as _wpresources (this points to C:\Program Files\Common Files\microsoft shared\Web Server Extensions\wpresources)
Store the resource with the Web Application inside the inetpub\wwwroot\wss\VirtualDirectories\<80>\wpresources

For option 1, you should make sure your Web Part assembly is deployed into the GAC. This is necessary since the _wpresoures virtual directory is used across each SharePoint Web Application. We call this Farm-level scope.

For option 2, you should make sure your Web Web Part assembly is deployed in to the bin folder for the Web Application. We call this Web-Application scope.

That said, you choose which wpresources folder based on the scope of your Web Part. For both options, you’ll be placing your files inside a sub folder to keep them separate from other files in other Web Parts. The sub folder name needs to be the namespace of your project. For example, with Web-Application scope, it might go here: inetpub\wwwroot\wss\VirtualDirectories\80\wpresources\namespace.

Ok, so you’ve chosen the appropriate folder based on the scope. How would you then reference this file within your Web Part code? It’s actually pretty easy and would look like this for a JavaScript file. (Note: this code can be placed in the CreateChildControls method for the Web Part.)

//Path to resource.  This is used for a web part deployed into the GAC (Option 1)
string scriptUrl = "~/_wpresources/namespace/file.js";

//Path to resource.  This is used for a web part deployed into the bin folder (Option 2)

string scriptUrl = "~/wpresources/namespace/file.js";

//Reference Script for web page
Page.ClientScript.RegisterClientScriptInclude ("file.js", scriptUrl);

Be careful, as these are very similar. You’ll notice for the first one, that you specify _wpresources (with an underscore). Also, make sure you replace namespace with the actual namespace for your Web Part project. For an image, it would work like this:

Image myImage = new Image();
myImage.ImageUrl = "~/wpresources/namespace/image.jpg";

this.Controls.Add(myImage);

The last important detail when using linked resources is how should you deploy these files? First off, you should be using SharePoint Solutions to deploy your code. You are doing this, right? Inside the Solution manifest.xml file, there are specific tags to deploy these kinds of resources. The schema looks like this:

<Assembly Location="Namespace.dll" DeploymentTarget="WebApplication">   
   ...
   <ClassResources>

      <ClassResource Location="file.js"/>
      <ClassResource Location="image.jpg"/>
   </ClassResources>

</Assembly>

Here is where you can see that the DeploymentTarget attribute matches the scoping option. In this sample above, it is WebApplication scoped (option 2). To deploy into the GAC, replace this with GlobalAssemblyCache. To learn more about the schema inside this file, see this link.

Now that you have a good grasp on linked resources, let’s take a closer look at those that are embedded.

Embedded Resources

Embedded resources are physically stored within the Web Part .DLL file. In one way, this is nice as you can always be assured that the resources and the Web Part stay together. The drawback is that if you need to change a resource, you must recompile and deploy an updated version of your Web Part. When the client needs the resource, it is dynamically extracted from the .DLL and provided. You’ll see how.

To use an embedded resource, there are three things you need to do. The first is that you need to add the resource file to the project and mark is as an Embedded Resource. This is done via the Build Action setting inside Visual Studio as shown here.

The second thing you need to do is declare this resource inside the AssemblyInfo.cs file for your Web Part project. This is an easy one-liner as shown:

[assembly: System.Web.UI.WebResource("namespace.file.js", "text/javascript")]

The parameter string that is used consists of the Web Part namespace followed by the filename of the resource. The next parameter is just the MIME type. If this were an image, it could be image/jpg.

The third thing step is make sure you extract the Url to the resource. This is also one line of code as shown:

string scriptUrl = Page.ClientScript.GetWebResourceUrl(this.GetType(), "namespace.file.js");

As with linked resources, you’ll then deliver this script to the page with a call to RegisterClientScriptInclude within CreateChildControls. As you would probably guess, the string here must match the name in the AssemblyInfo.cs file. As written here, the resource files need to exist in the root folder of the Web Part project. (Note: technically you don’t need to precede the file with the namespace as long as the string is unique within the project. The common convention, however, is with the namespace).

You might be curious how this actually works from the browser’s perspective. Well, what gets delivered to the browser is a link to a special, in-memory page called WebResource.axd along with a querystring to uniquely identify this specific resource. In HTML, it looks something like this:

<script src="/WebResource.axd?d=ZPJuqJGGI6qgSKsEa2PfIw2&amp;t=633527425956801634" 
        type="text/javascript">
</script>

This is how it dynamically finds the resource file, extracts it from the Web Part DLL, sets the content type, and then delivers it to the browser. Pretty cool.

Conclusion

In this post, you have seen how to both link to and embed Web Part resources. Each has its own advantages and disadvantages, mostly boiling down to whether you need to maintain the resource separately from the Web Part. In both cases, the resource file can be cached, so there is little performance difference from each option. Feel free to use one of these two approaches for your next web part.

SharePoint Usage Report using Object Model

2010-03-12T06:41:00.000-08:00

Introduction

It is a common requirement to gather information around the Windows SharePoint site usage. Organizations prefer to find out the popular sites in their organizations are or what external WSS sites attract the most number of visitors. This will provide information necessary for an organization to identify the important sites in their environment and properly manage them with extra resources if necessary.

One of the common complains around accessing theses data are the inflexibility of gathering information in a central location. The administrator will have to navigate to the selected SharePoint site administration pages to access the data. This will become a more time consuming exercise when the administrator need to collect usage data from larger number of SharePoint sites.

In this article, I am looking at creating an ASP.NET web application that will populate a collection of SharePoint sites in a drop down list for a given SharePoint site collection. The web application will display the usage details of the selected SharePoint site from the list. This will help the SharePoint administrator to gather all SharePoint usage data from a central location with out have to navigate many different SharePoint site locations.

Usage Analysis Data Web Report

Figure 1 display a Usage Analysis data for a Windows SharePoint site. The users have the option of selecting a monthly or a daily report.

Figure 1: Monthly Usage Analysis Report

Usage Analysis Processing Reports

First of all let's have a look at what is Usage Analysis Reports in SharePoint. Theses reports will help the organizations to determine how the web sites are used in their environment. The data is taken from IIS Logs on the front end web servers and stored in to temporary files. The data is merged in to the content database on the back end SQL Servers when the daily log processing takes place.

The Usage Analysis is not enabled by default when the organization deploys the Windows SharePoint Services Sites. Organizations should enable the Usage Analysis logging process on the servers when they require gathering usage information. The logs files are created daily and a flag is attached to mark that it has been processed.

These logs files are not automatically deleted, they are preserved in "local_drive (C) :\Windows\system32\LogFiles\W3SVC*" where * indicates the Internet Information Server (IIS) instance number of the virtual server as displayed in Figure2. Organizations should consider the advantages against the disk space storage before enabling the Usage Analysis service in their environment. The organization can stop logging process' any time they require to do so.

Figure 2: Preserved log files folder structure with W3SVC* format

By default the log files are located at "local_drive (C) :\Windows\system32\LogFiles\STS" directory. Separate folders are created under above directory for each virtual server and separate folders for each day as displayed in the Figure 3.

Figure 3: Separate directories for each virtual server and for each day

Organizations can configure the above Log file store path for their own preferred path and create up to 30 log files.
(Please look at Setting up Usage Analysis process for more details.) If an organization decides to store the log
files in their preferred location, they should grant Read, Write and Update rights permissions for STS_WPG user
group for the specified folder. Without the permissions, the usage log files cannot be created or updated by IIS.

Setting up Usage Analysis Processing

Administrators can control the setting of Usage Analysis process using the SharePoint Central Administration page. The user must be an administrator on the local server or a member of the SharePoint Administrators group to configure the analysis processing. If the organization adds a new virtual server after the analysis service been configured, they will need to reconfigure the analysis service to collect the data on the newly added virtual server.

Click "Start -> All Programs -> Administrative Tools -> SharePoint Central Administration"
This will open the "Windows SharePoint Services Central Administration" page
Select the "Configure usage analysis processing" from the "Component Configuration" section as displayed in figure 4

Figure 4: Component Configuration section on the central administration page
The Configure Usage Analysis Processing page will open as displayed in Figure 5

Figure 5: Configure Usage Analysis Processing page
Select "Enable logging" check box in "Logging Settings" section
The administrator can select a preferred file locations for the log files in "Log file location" box or use the default location C:\WINDOWS\system32\logfiles\STS
Enter the number of log files to create in the "Number of log files to create" box. This can be between 1 and 30.
Select "Enable usage analysis processing" check box in "Processing Settings" section.
Select the time range that analysis process should run from "Run processing between these times daily". By default this is set to start at 1am daily. The administrator can allocate a time period that won't affect the demand on the site.
Click "OK" to finish the configuration.

View Usage Analysis Reports

The user must be an administrator or have the View Usage Data right for a site to view the site usage reports. The reports are available through Site Administration page.

The usage data is collected and stored for the entire site collection on a server at a time. The users can see the total number of hits for a site collection on the Site Collection Usage Summary page and for more detailed information, Site Usage Report page for individual sites or sub sites usage information.

View Site Usage Report

Navigate to the site you prefer to view the report.
Click Site Settings on top tool bar.
Click Go to Site Administration link under Administration section as displayed in Figure 6

Figure 6: Site Settings page
Click View site usage data link under Management and Statistic section in Top-Level Site Administration page as displayed in Figure 7

Figure 7: Top-Level Site Administration page
The Site Usage Report page will open as displayed in Figure 8

Figure 8: Site Usage Report page

Site usage reports are useful for identifying which content on Windows SharePoint Services sites are being heavily used or used very little. This will help organizations to understand which sites are candidates for archiving and which sites should be kept online. In addition, this report contains information regarding how much storage space WSS sites are using. This page provides a report that contains following information:

Pages that have been accessed on that site, including document libraries
Users that have access the site
Operating system of the user accessing the site
Browser type
Referrer URL
Data can be displayed by monthly or daily summary format

Figure 9: Different reports available

The users can select a report option and a daily or monthly option to generate a report. Figure 9 displays a monthly report of all the pages accessed and different kind of reports options available.

Code Example

The web page contains a text box to enter the SharePoint site collection URL. The appropriate sub site will be listed in a dropdown list when user clicks the Submit button. The user then have the option of viewing the daily or monthly usage report of a selected site.

First of all you will need to add the Microsoft.SharePoint.dll to your web application reference list.
This will give us the access to the SharePoint Object Model.

Then instantiate the SPSite object as displayed below. The absolute URL is passed in through
the txtWSSSiteUrl text box. This will populate site collection for the given URL.

//Get the site collection SPSite mySiteCollection = new SPSite(txtWSSSiteUrl.Text);

Then to access an individual site, instantiate the SPWeb object as displayed below. I am passing in the site name as a parameter.

//Get the details of the selected WSS site SPWeb site = mySiteCollection.AllWebs[siteName];

After constructing the site SPWeb object, developers can access the information of the site usage data using the public method "GetUsageData" of the SPWeb object as displayed in code example.

GetUsageData(Microsoft.SharePoint.Administration.SPUsageReportType, Microsoft.SharePoint.Administration.SPUsagePeriodType) Method.

The GetUsageData method of the SPWeb class returns a data table that contains information about the usage of a Web site based on the specified type of report and time interval.

SPUsageReportType Enumeration

The SPUsageReportType enumeration specifies the type of information returned in a usage report for a SharePoint site.

The following table shows the members of the SPUsageReportType enumeration and a brief description

Name	Description
browser	The type of Web browser used to visit the SharePoint site. All usage data refers specifically to visits from referring URLs external to the site.
os	The operating system used on the client computer. All usage data refers specifically to visits from referring URLs external to the site.
refUr	External URLs through which users navigated to the SharePoint site.
url	URLs of pages that are visited or of pages for lists that are updated. Discussions about a page are counted as hits on that page.
user	Users who visited the site.

SPUsagePeriodType Enumeration

The SPUsagePeriodType enumeration specifies the time interval on which a usage report for a Web site is based.

The following table shows the members of the SPUsagePeriodType enumeration and a brief description

Name	Description
day	Returns usage information for each day during the past 31 days starting from the previous day
lastMonth	Summarizes usage information for the last 31 days relative to the previous day

I am binding the data table return from GetUsageData property to a DataGrid control to display the information.

Accessing User daily report

//Users who visited the site DGUsers.DataSource = site.GetUsageData(SPUsageReportType.user, SPUsagePeriodType.day);

Accessing User monthly report

//Users who visited the site DGUsers.DataSource = site.GetUsageData(SPUsageReportType.user, SPUsagePeriodType.lastMonth);

Accessing Browser daily report

//The type of browsers used to visit the site DGBrowser.DataSource = site.GetUsageData(SPUsageReportType.browser, SPUsagePeriodType.day);

Accessing Browser monthly report

//The type of browsers used to visit the site DGBrowser.DataSource = site.GetUsageData(SPUsageReportType.browser, SPUsagePeriodType.lastMonth);

Accessing Operating System daily report

//The Operating System used in client computer DGOs.DataSource = site.GetUsageData(SPUsageReportType.os, SPUsagePeriodType.day);

Accessing Operating System monthly report

//The Operating System used in client computer DGOs.DataSource = site.GetUsageData(SPUsageReportType.os, SPUsagePeriodType.lastMonth);

Accessing refUrl daily report

//External URL client used to navigate to SharePoint site DGRefUrl.DataSource = site.GetUsageData(SPUsageReportType.refUrl, SPUsagePeriodType.day);

Accessing refUrl monthly report

//External URL client used to navigate to SharePoint site DGRefUrl.DataSource = site.GetUsageData(SPUsageReportType.refUrl, SPUsagePeriodType.lastMonth);

Accessing url daily report

//URL's of pages visited DGUrls.DataSource = site.GetUsageData(SPUsageReportType.url, SPUsagePeriodType.day);

Accessing url monthly report

//URL's of pages visited DGUrls.DataSource = site.GetUsageData(SPUsageReportType.url, SPUsagePeriodType.lastMonth);

Deploying the Web Application to the SharePoint Portal Server

Create the "UsageAnalysisData" Virtual directory under the portal web site in IIS
Map the virtual directory to the physical file path (this should be done as apart of above step)
Open the SharePoint Central Administration pages by clicking "Start > Administration tools > SharePoint Central Administration"
Click "Windows SharePoint Services" link on the left hand side
Select "Configure Virtual server setting" link from "Virtual Server Configuration" group
Select your Portal server from the list
Click "Defined managed path" link under Virtual Server Management group in Virtual Server setting page
Type name of the virtual directory you created in first step in the Path section of Add new Path section
Select "Exclude path" radio button under the type section
Click "Ok"
Then navigate to http://portal_site_name/UsageAnalysisData/MonitoringPage.aspx

Figure 10: A list of sub sites of the site collection

Figure 11: Daily Usage Analysis Report of a Windows SharePoint Site

Conclusion

SharePoint Administrators should be able to use this article as a starting point and develop their SharePoint Usage Analysis data gatherer web application according to their requirements.

Print ListData SharePoint

2010-03-11T15:17:00.003-08:00

Solution Architecture

The solution will be deployed as a wss feature, which allows us an easy way to add a menu item to the sharepoint menus. The feature will define that the item we want to add will be added to the actions menu of all lists, in a site collection. You can ofcourse change it so that it behaves differently and connects only to lists of a certain type if you so wish, or maybe move the menu item to a different place. I recommend reviewing the msdn article on the possible configurations.
The solution is based on 3 files:

feature.xml
Defines the feature, its scope and its title that you will see in the "site features" (or site collection features or farm features - depending on the scope)

PrintList.xml
Defines what action we want to add to what menu and what will happen when the user clicks the menu item. This is where you configure the text of the item, and the link to the page that will print the list. which just happens to be the last file:

PrintList.aspx
Contains the code that shows the list in a print-friendly view. This file should be deployed to the layouts folder and must be called with the site's context (more about that shortly).

To the Code!

note - when I talk about the "12 hive" I am referring to the folder C:\Program Files\Common Files\Microsoft Shared\web server extensions\12

Create the page that prints a list:

Log on to the server, and open the template\layouts folder in the 12 hive.

Create a new text file in the folder, and name it "PrintList.aspx"

Open the empty file in your editor of choice (notepad is fine) and paste the following code into it:

<%@ Page Language="C#" Inherits="System.Web.UI.Page" %>

<%@ Register TagPrefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls"

Assembly="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

<%@ Import Namespace="Microsoft.SharePoint" %>

<html>

<head>

<title>SharePoint List Print</title>

<link rel="stylesheet" type="text/css" href="/_layouts/1033/styles/core.css" />

<script type="text/javascript" language="javascript" src="/_layouts/1033/init.js"></script>

<script type="text/javascript" language="javascript" src="/_layouts/1033/core.js"

defer></script>

<script type="text/javascript" language="javascript" src="/_layouts/1033/ie55up.js"></script>

<script type="text/javascript" language="javascript" src="/_layouts/1033/search.js"

defer></script>

</head>

<body>

<%

string listId = "";

string referrer = "";

//get the list id (guid in a string format) from the query string

listId = Page.Request.QueryString["list"];

//get the http referrer (for the back button\action)

referrer = Page.Request.ServerVariables["http_referer"];

//make sure the list parameter was passed

if (listId == null)

{

//if a referrer url exists (since the page may have been opened from a direct link, this is not always the case) redirect the user back

if (referrer != null && referrer.Trim().Length != 0)

{

Page.Response.Write("<p>The list ID parameter ('list') is missing from the address.<br>Please go to the list you want to print and try again.</p>");

Page.Response.Write("<p><a href=\"" + referrer + "\" title=\"Go Back\">Click here to go back to the page you came from</p>");

}

else

{

Page.Response.Write("<p>The list ID parameter ('list') is missing from the address.<br>Please go to the list you want to print and try again.</p>");

}

}

else

{

try

{

//load the web object for the site that the page is now in context of

using (SPWeb web = SPControl.GetContextWeb(Context))

{

//load the list that was passed in the 'list' querystring parameter to the page

SPList list = web.Lists[new Guid(listId)];

//load the query of the default view. note - need to modify code in the future to enable multiple view printing

SPQuery query = new SPQuery(list.DefaultView);

//write the list to the page

Page.Response.Write(list.RenderAsHtml(query));

//add the print script

%>

<script type="text/javascript" language="javascript">

window.print();

</script>

<%

}

}

catch (Exception ex)

{

Page.Response.Write("<p>There was an error loading the list information:<br />");

Page.Response.Write(ex.ToString());

Page.Response.Write("</p>");

}

}

%>

</body>

</html>

Install the feature

Open the \TEMPLATE\FEATURES folder under the 12 hive

Create a folder called PrintListMenuAction

In that folder, create 2 text files, one called feature.xml and the second printlist.xml

In your editor of choice (notepad is fine) open the feature.xml file and paste into it the following:

<?xml version="1.0" encoding="utf-8" ?>

<Feature Id="769826dd-9dd2-11db-96ca-005056c00008"

Title="Print List"

Description="This feature adds a print command in the Actions menu for Windows SharePoint Services lists."

Version="1.0.0.0"

Scope="Site"

xmlns="http://schemas.microsoft.com/sharepoint/">

<ElementManifests>

<ElementManifest Location="PrintList.xml" />

</ElementManifests>

</Feature>

In your editor of choice open the printlist.xml and paste the following:

<?xml version="1.0" encoding="utf-8" ?>

<Elements xmlns="http://schemas.microsoft.com/sharepoint/">



<CustomAction Id="SPSTIPS.PrintListActionsToolbar"

RegistrationType="List"

GroupId="ActionsMenu"

Location="Microsoft.SharePoint.StandardMenu"

Sequence="1000"

Title="Print List">

<UrlAction Url="{SiteUrl}/_layouts/PrintList.aspx?list={ListId}"/>

</CustomAction>

</Elements>

Almost done - install the feature and test it!

To install the feature, open command line (start>run>cmd) and navigate to the bin folder in the 12 hive.

Once there, run the following command to install the feature:

stsadm -o installfeature -name PrintListMenuAction -force

After you ran that command successfuly, you can activate the feature in the site collection either using the user interface (site actions> site settings> site collection features):

or you can (more easily since you are already in the command line) just run the following command, entering the site path:

stsadm -o activatefeature -name PrintListMenuAction -url [your site url here] -force

That's it! if you now go to any list in that site, you should have the print menu action.

Convert Word to PDF

2010-03-11T14:59:00.000-08:00

I would highly recoomend ASPOSE.WORDS product to convert word documents into PDF in SharePoint.It is not a free product but is good for the functionality.

http://www.aspose.com/categories/product-family-packs/aspose.words-product-family/default.aspx

Branding Notes for SharePoint

2010-03-11T14:39:00.001-08:00

I thought I would run through some of the tools that have helped me when branding a MOSS intranet. SharePoint Designer or perhaps better yet Studio can be the primary tool for creating master pages, themes, and page layouts, but your gonna need some help when trying to dig through all the CSS in the core.css file, and all it’s crazy inheritance. Combing through the css is a big chunk of your effort when you are starting with the default master or the default or classic theme. Most corporate organizations that I have worked with take the approach of “skinning” the SharePoint default look to match there colors and branding as opposed to starting from the ground up. So odds are your starting with the default look : -(

A couple of prerequisite tips before I get to the tools…..

When creating or modify styles - always, always, always put them in a new stylesheet. If you just update core.css, you will have a lot of pain in your life when your discover some goofy UI thing happening on a page, and you have to comb through the 4,000+ lines of styles in core.

Be cautious of overwriting or adding images directly in the _layouts/Images directory (C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\IMAGES) . If the box has to have MOSS reinstalled or perhaps some obscure patch occurs - you can kiss those image updates goodbye. However, I know that sometimes this is unavoidable….or at least a huge time saver. If your implementing a larger project, then put the images you added or modified in source control, and have a build script that will push the images. This way all the customization can be automatically pushed. OR if is a small implementation, at least document the image changes :- )

So…..oh yeah……The Tools:

IE Developer Toolbar

Certainly the biggest challenge in modifying the UI of MOSS is trying to figure out which style does what…and where is does it. And a good way to discover what MOSS is doing with it’s ginormous style sheet is to look at the rendered pages in the site. The IE Developer toolbar will provide 2 great features that will aid in this discovery process. 1. From the menu select ‘Find’ and ‘Select Element by Click’ which will allow you to click on any element in the page, and see the class used as well as all of the style attributes. So even if you see the class you modified, but say it is still show a incorrect style value (like color, padding, or whatever) then you know your style is being overwritten somewhere else. 2. As you select an element is also gives you a window with the html of the page that is much easier to comb though than viewing source in Notepad - That way you can crawl up and down the html tags to see what styles are being applied at the div, td, tr, table, etc. and……OK #3 - you can also disable scripts with a click so you can see styles without the hover state kicking in (i.e. - Menus)

CSS Finder Code (courtesy of msdn)

Similar to the IE Developer toolbar, you can throw this snippet into a content editor web part, which will allow you to roll over elements on the page and have the css style show up in a div tag on the screen. It is handy and quick, but will not give you as much information as the IE Developer toolbar. I would click on the link above because this page has a css reference chart that is fairly useful - also see Heather Solomon’s CSS Reference to get and idea for some of the major styles.

<script language="jscript">
function ClassInfo()
{
    if (window.event.srcElement.className != null)
    {
        stsclass.innerText = window.event.srcElement.className;
    }
    else

    {
        stsclass.innerText = "";
    }
}

window.document.body.onmouseover = ClassInfo;</script>

<div style="border-style:solid;border-width:1px; width: 281px; height: 34px;
position: absolute; left: 286px; top: 41px; z-index:15; padding-left:4px;
padding-right:4px; padding-top:2px; padding-bottom:2px; background-color:#EEEEF4">
<p id="stsclasstitle"><font face="Tahoma" id="stsclasstitle">Classname: </font>

<font face="Tahoma"id="stsclass">&#xa0;</font>
</p></div>

Just Color Picker

Again another tool for style discovery (are you getting that this is a pain) I will use this little piece of freeware to quickly identify the hex color of an element on a page. Sometimes when you swear up and down that you have changed a color but it just wont show, I will get the hex off the screen, and start start seeing where that color shows up in the various style sheets.

SharePoint Skinner

This is a handy tool when you need to create a down and dirty theme - quickly. I’ll admit I have not played with this too much, but it will allow you so change colors and images with a few clicks, and export out a theme. This may also help you get an understanding of what css classes effect what styles, but I find the developer toolbar more efficient for that task.

Features and Deployment

The easiest way to deploy your look and feel to SharePoint is to utilize the Solution Framework MOSS provides. Especially in a farm environment where files need to be pushed to multiple servers. Features are also what I would recommend when including look and feel into site definitions. Many people have posted adding master pages to a Module Element in the ONET file of a site definition, but that will deploy a copy of the master page file to every site provisioned based on your definition. To me, this defeats the point of a template as it can not be globally changed now that you have copies stored in every web. You can create features that utilize receiver classes to programmatically apply a master page or theme when a feature is activated. You can also auto-activate these types of features in a custom site definition. Some good examples of how this is done are here:

Graham Sibley shows how to write a feature that deploys a theme to a site
Paul Papanek Stork shows how to write a feature that apply’s a master page to a site. This feature will apply a mater page from the /_catalogs directory at the root of the site collection.

Now that you are writing all these crazy features you may want a way to take some of the legwork out of the process. My friend Rich Finn has created a WSP Project Template for Visual Studio that will create the wsp along with the manifest.xml, and .ddf files for you. It also has deployment and upgrade scripts built in to deploy your look and feel to the portal. There is another one on CodePlex called SharePoint Feature Packager that will also do the trick, but Rich’s template has less manual steps to get rolling.

These tools definitely make life easier, but before implementing a portal look and feel, be sure to take all the proper planning steps to ensure that what you are implementing will best suit the long term needs of the business. SharePoint has made a lot of headway in how things can be packaged, deployed, and templated, but there are still a lot of gotchas - you don’t want to deploy a look and feel to a ton of pages and later find out something drastic has to change. You may find yourself rebuilding pages manually or basically undergoing a site migration. Each organization needs to consider things like:

Site Definitions vs. Site Templates
Themes vs. Masterpages - one or the other or both
Features and scope of those features
What meta data will be applied in our templates

Carefully document the pros and cons of each of these decisions so that the business can understand the potential impacts of the decisions being made during the design phase of a project.

WSS 3.0 vs MOSS Standard vs MOSS Enterprise

2010-03-10T19:03:00.000-08:00

There's still plenty of confusion out there about SharePoint, particularly around what is included in WSS versus MOSS. Part of the problem is that there is soooo much information about SharePoint that the simple details get lost…

So, let's go through the various options, comparing WSS with MOSS Standard and MOSS Enterprise as simply as possible. I'll exclude technicalities (eg that you need R2 of W2K3 etc) and just focus on the main points.

Windows SharePoint Services (WSS)

Currently in version 3.0, WSS is a free add-on to Windows 2003 Server. WSS is the foundation of SharePoint. It provides a stack of features (or services), including document management & collaboration, Wikis, Blogs, RSS feeds, strong Office integration (Word, Excel, Outlook, Access, PowerPoint) including alerts and synchronisation, basic workflow and some search capabilities. It has the foundational elements such as security and storage services.

Many intranet requirements are completely catered for with WSS. And WSS can be used quite effectively as a web site too.

[I've seen discussions about storage limits within WSS being set at 4GB*, but my current understanding is that this is not the case - ie there is no set limit.]

Microsoft Office SharePoint Services (MOSS) Standard

MOSS** sits on top of WSS and comes in two main versions: Standard and Enterprise.

MOSS Standard has stacks of features of course (including Enterprise Content Management, Portals and comprehensive Workflow), but the main ones to consider are:

Enterprise Search (which allows you to crawl a number of data sources)
People management (which includes all the My Site stuff, Personalisation features, Single Sign On and more)
Analytics (which includes all the usage and auditing functions for example: you can audit who is searching for what)

Point to note: Enterprise Search IS included in the Standard version.

Microsoft Office SharePoint Services (MOSS) Enterprise

Moving on to MOSS Enterprise, we get everything in Standard, plus a few more features added, the most important of which are:

Business Data Catalog or BDC (which is a means of linking SharePoint to basically anything including SQL Servers, Oracle Servers, Microsoft CRM, SAP and more, and providing the BI functions including dashboards and KPIs)
Excel 2007 Services (which allow Excel spreadsheets to be 'hosted' and rendered, and even accessed as web services)
Forms server (see below)

Point to note: People sometimes confuse BDC with Enterprise Search. To clarify: BDC can be considered an extra source of data feeds into Enterprise Search.

Other versions

There also used to be various flavours of MOSS for Search, and these can best be summed up as WSS plus Enterprise Search (ie they lack some of the other MOSS features such as ECM etc). They have recently been re-branded as Microsoft Search Server 2008 and come in a free 'Express' version and the Standard version.

Aside: There is another SharePoint pseudo-version known as the Office Forms Server 2007 which basically allows InfoPath forms to be rendered in the browser. It can be added to just WSS if required, and is included by default in the MOSS Enterprise version.

Comment

Microsoft hasn't gone out of its way to make all this clear I have to admit – the hype around SharePoint is usually focused on the MOSS side of things – and why not? After all that's where the big dollars are. Speaking of big dollars, it may not be as big as everyone keeps making out.

Licensing

Sure enough the Internet facing licensing is off with the fairies (at around the USD 40K per server mark!), but inside the company it can be significantly cheaper.

I don't claim to understand the SharePoint licensing intimately, but this link will give you an overview of licensing (eg a basic intranet MOSS license is under $5K, although moving to Enterprise will get you into $60K level – Yikes!). However, the real kicker comes when you have to weigh up all the CALs you need (and for Enterprise you need to buy both the Standard CALs and the Enterprise CALS on top).

Getting confused yet? Yep, and to top it off you also need to factor in SQL Server licenses if you don't already have those in place.

Summary: You need MOSS Server license + CALs + SQL Server licenses

Point to note: If you want to expose your intranet on the internet (eg via your web site) then you are in for a headache

This barely helpful link from Microsoft attempts to make it clearer, but requires about five readings before it starts to make sense.

This Excel spreadsheet is a great SharePoint feature comparison for those wanting to get into the nitty-gritty (well worth the download).

Consider this…

Here's the main takeaway… if you are considering SharePoint for your intranet but have been worried about licensing costs, then start with WSS. It has stacks of collaboration features and may be all you need. And it's free. Plus you can always build on it, adding MOSS features later.

If you did move to MOSS, start with MOSS Standard and think carefully about whether you need the Enterprise features.

And think very, very carefully about making your web site MOSS based

References

References: Inside Microsoft Office SharePoint Server 2007 by Patrick Tisseghem

Notes

* 4GB limitation – MOSS running on SQL Express will be limited to 4GB (due to the SQL Express limitations), but WSS seems to run on a special version of SQL that is not limited. MOSS is never recommended to be run on SQL Express. Disclaimer: I am not sure of these details.

** MOSS is technically MOSS 2007, as there has not been any previous MOSS versions. The previous version of SharePoint was SharePoint Portal Server 2003, usually referred to as SPS or SPS 2003.

WSS 3.0 Search vs MOSS Search

2010-03-10T18:48:00.001-08:00

We have spent some time comparing MOSS search and WSS search in our lab. For those who are interested in the differences between MOSS search and WSS search, this blog post might clear things up.

WSS 3.0 Search

Single Site collection, automatically scoped to current site (and subsites):

Only SharePoint content in the site collection can be crawled. You cannot configure Search to crawl databases, mail servers, application servers, or Web sites and file shares outside of the site collection. In a deployment with more than one site collection, each site collection provides Search only for content on that site collection, and there is no aggregation of search results across site collections.

MOSS Search

MOSS uses an enhanced relevance algorithm for its search engine, and is able to crawl content from multiple sites within an enterprise, as well as non-sharepoint web sites. In short, the MOSS search engine is a powerful enterprise search engine with a relevance algorithm, while the WSS site-local search engine is actually pretty useless beyond simple "dumb keyword" search.

Site Directory

Site Directory MOSS provides a new site template called "Site Directory". When you create your first portal via MOSS, it comes with a Site Directory. This site template is designed specifically for tracking links to sites, displaying site maps and site navigation lists, as well as searching through the site directory. With a Site Directory in your portal, you will be asked if you want to publish a link to your new site every time you create a new site within the portal, regardless of its depth within the hierarchy. This single feature is, in my opinion, absolutely required for any kind of Intranet deployment of SharePoint. And yes, that means I think MOSS is a requirement for any real Intranet deployment of SharePoint on any kind of meaningful scale.

Customizing BestBets SharePoint

2010-03-10T10:10:00.000-08:00

One of the things that people are not aware of is that you can customize the search results coming from the SharePoint search engine. The results, which is XML, given by the engine are styled using XSLT. If you create your own XSLT you can customize/restyle your results page.

There is a 'Visual How To' by Patrick Tisseghem explaining the steps you need to do to customize the search page.

You can do the same trick with the Best Bets meaning, you can customize them by applying your own XSLT. Before we are going to customize the Best Bets, let me explain what they do an how you can use them.

Best Bets are used to promote some results depending on your search keywords. If you look at the screenshot below you see that when I type SharePoint in the search box, U2U and Microsoft are pushed forward as results where you definitely can find something about SharePoint. So if you think about it, Best Bets is a way for an administrator to earn some extra money, the one who pays the most gets on top of the list J.

To create these Best Bets, you need to go to the settings page of your top level site and you need to click on the 'Search keywords' linkbutton where you can create the Best Bets by clicking on the create button.

After filling in a keyword you can add Best Bets by clicking on the Add Best Bet button, type in a url, title and description for your best bet.

Now that the Best Bets are created we can test them by typing SharePoint in the search textbox. You will see the results at the right side of the page.

Because they are displayed in a webpart you can drag the webpart into another webpartzone to ,for example, have your best bets before the search results.

Okay, now let's customize our Best Bets. These are basically the same steps as in the 'Visual How To', so you can follow the steps there as well, the only difference is that in the video they customize the search results.

Because the Best Bets webpart is using XSLT to show the results getting from the search engine (which is XML ) we can apply our own XSLT. So if you go to the properties of the webpart you can click on the XSL Editor to replace the existing XSLT with your personal XSLT.

As said, the best bests is nothing more than XML which is styled using XSLT. Because it is not easy to create XSLT, We are going to let SharePoint Designer create the XSLT for us. The only thing that we need to do is saving the XML returned from the search engine so we can use it in the Designer.

To see the XML returned from the engine we need to use following XSLT. Copy it in the XSLT dialog box.

<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
<xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes" />
<xsl:template match="/">
<xmp><xsl:copy-of select="*"/></xmp>
</xsl:template>
</xsl:stylesheet>

After saving your new XSLT you can copy the XML and paste it temporarily in an XML file, so we can import this file and use it as a Data Source in SharePoint Designer.

Speaking about the devil, lets open up SharePoint designer to do some customization magic. The first thing that we need to do is using our XML as a Data Source. You can manage your data sources by choosing Manage Data Sources which you can find in the Data View on the menu bar.

Once you've done this, you get an overview of all the available data sources in the toolbox. One of the data source categories is 'XML Files'. In that category you can click on Add an Xml File to add your XML file as a data source.

You can browse to your file and add it to your Data Sources . Once the file is added,you can see the available data by right-clicking on it and pick Show Data from the dropdownlist.

Once the data is shown you can specify what data you want to show for your best bets. Select title, url, description and drag this to your design surface.

Once you've dragged your data on the design surface, you see a menu where you can do some additional settings like adding more columns, allow paging and sorting …. In our case it is more useful to apply another layout so click on change layout and pick one that fit your needs.

Next thing that we need to do is make sure that we can click on the url.

Okay, that's it for now (you can off course customize as much or as advanced if you want), let's go to code view and copy the generated XSLT. Make sure that you copy everything between and including the <xsl:stylesheet> tags.

Copy the XSLT in the XSL Editor in the properties of the Best Bets webpart and save it.

Publish your page and try it out.

SharePoint Keyword and Property Search in SharePoint Server

2010-03-10T09:35:00.000-08:00

Powerful Keyword and Property Search in SharePoint Server

MSDN has the best resources for understanding the keyword sytax and property searches. You'll notice a lot of these are common across search platforms making it easy to adopt by end users. Property search is extremly powerful for filtering down your results and worth your time to learn.

MSDN - Enterprise Search Keywords and Inclusion and Exlusion Rules
MSDN - Enterprise Search Property Filters
Robert Bogue MVP does a great job of describing properties from end to end in his "Harnesing Properties in SharePoint Search" article. The applies to SPS 2003, but offers a lot of insight into how you'd do it in 2007.

If I'm searching for more data about content types using a keyword simple term, a great way to associate a template, workflow and meta data capture, I might search for content types. Words following the ">" are example searches.

>content types

If that doesn't return the result I'm looking for I could add an keyword included term with a plus such as +sharepoint. Maybe I want to exclude exchange terms, so I can use an excluded term.

>+sharepoint content types -exchange

To narrow down my search I could add a property such as title:"content types." Property searches support quote phrases:

>+sharepoint title:"content types"

If I know that William Devo authored the document I could do a property search based on author for example:

>+sharepoint +title:"content types" author:"william devo"

If I know that the document should be on the office portal, I could search

>+sharepoint title:"content types" author:"william devo" site:http://office

Note: (no trailing slash on URLs.) The prefix property similar to a wild card search search described below applies to property searches where I can search for properties where I want to include multiple spellings. Maybe I don't know if he was Will or William.

>+sharepoint title:"content types" author:will site:http://office

I may want to do another property search to restrict it even more since I know I only want word docs.

>+sharepoint title:content types" author:will site:http://office filetype:doc

How do you do an OR? Simply include multiple property filters maybe it's bill or will/william.

>+sharepoint title:content types" author:will author:bill site:http://office filetype:doc

If all this seems like a lot to do on the simple search query box, you can use advanced search. Using this same last example I could use the following:

Find Documents with:

All of these words:	sharepoint
The exact phrase:	content types
Any of these words:
None of these words:	exchange

Narrow:

Result type: Word documents

Property Restrictions

Where the property... Author Contains Will or

Author Contains Bill and

URL Contains http://office

Find out storage space allocation for site through code

2010-03-09T18:58:00.000-08:00

SPSite oSite = new SPSite("http://mpacificomoss/");

                        Console.WriteLine("SITE URL:" +oSite.Url);
                        DataTable oDtRawData = null;

                        // this line of code will return the stroage information of all the document lirbaries in this site
                        oDtRawData = oSite.StorageManagementInformation(SPSite.StorageManagementInformationType.DocumentLibrary
, SPSite.StorageManagementSortOrder.Increasing, SPSite.StorageManagementSortedOn.Size, 100);

                        // this line of code will return the stroage information of all the lists in this site
                        oDtRawData = oSite.StorageManagementInformation(SPSite.StorageManagementInformationType.List
, SPSite.StorageManagementSortOrder.Increasing, SPSite.StorageManagementSortedOn.Size, 100);

                        // this line of code will return the stroage information of all the Documents in this site
                        oDtRawData = oSite.StorageManagementInformation(SPSite.StorageManagementInformationType.Document
, SPSite.StorageManagementSortOrder.Increasing, SPSite.StorageManagementSortedOn.Size, 10000);

                        // if you wan to see column names, loop through all the columns and find out the names and grab the needed one. 

                        foreach (DataColumn oColumn in oDtRawData.Columns)
                        {
                            Console.WriteLine(oColumn.ColumnName);

                        }

                        

                        // loop through all the rows and find out the values. Here the size will be return in bytes (size/1024 = size in KBs)

                        foreach (DataRow oRow in oDtRawData.Rows)
                        {

                            Console.WriteLine(oRow["TotalSize"].ToString() + " : " + oRow["Size"].ToString() +
 " : " + oRow["SizeOfVersions"].ToString() + " : " + oRow["LeafName"].ToString());

                        }

Find out Farm wide Broken permission inheritance

2010-03-09T17:59:00.000-08:00

SPWebService webAppServices = (from webService in SPFarm.Local.Services.OfType<SPWebService>()



                                               where !webService.TypeName.Contains("Central")

                                               select webService).SingleOrDefault();    

                    

                

                                                    

                foreach (SPWebApplication webApp in webAppServices.WebApplications)

                {



                    Console.WriteLine(webApp.Name);

                    foreach (SPSite site in webApp.Sites)

                    {



                        Console.WriteLine("SITE URL:" +site.Url);

                        foreach (SPWeb web in site.AllWebs)

                        {



                            Console.WriteLine("Web URL" + web.Url);

                            //Use HasUniqueRoleAssignments property to check if the RoleInheritance is broken or not

                            Console.WriteLine("Role inheritance " + (web.HasUniqueRoleAssignments ==true ? "Broken" : "Not Broken")); 

                        }

                    }

                }

Display List Data From one site to another site

2010-03-05T10:25:00.001-08:00

A pretty common request is the ability to display content from one site on another site. For example, you might have a blog sub site, and want to show those posts on the home page of the parent site.

In WSS V3, this is easy to do with SharePoint Designer.

First, we'll open the site and page we where we want to display the list in SharePoint Designer. One way to do this is to open SharePoint Designer and choose "Open Site..." from the File menu. Another way is to browse to the page and then click the "Edit with Microsoft Office SharePoint Designer" option in Internet Explorer:

Inside SharePoint Designer, in the design view of the page, click where you want the list to go, and then select "Insert Data View" from the Data View menu:

In the Data Source Library Task Pane, select "Connect to another library...", since we want to display a list that is not in this site:

Click Add, then choose a display name, and type in the URL to the site where the list is:

Click OK in both dialogs, and then expand the new Library until you find the list you want:

Next, click on the list and select "Show Data":

Now the task pane shows the columns from the list:

You can now insert the items by selecting "Multiple Item View" from the insert menu:

Let's start by changing the layout:

The Repeating Form layout is close to the blog layout:

Text fields are HTML encoded by default. To fix this, click on the arrow near the body field, and change the Format as: to Rich Text:

You can now remove column headers and edit any styles that you like:

To make a field into a link, set the format to be Hyperlink. In the popup box, you can set the URL, and you can include values from the item by clicking the "fx" button:

When you're done, save the page, and view it in the browser:

Site Quotas in SharePoint

2010-03-04T10:53:00.000-08:00

Repeatedly I have come across a SharePoint implementation that was not well planned out in regards to data storage. When you are planning the taxonomy and information architecture of your sites, a good amount of effort and thought should be put into Site Quotas. Site Quotas are a key component for SharePoint Administrators to be able to properly manage and administer data restrictions on your site collections.
To better understand site collections, I highly recommend reading the white papers made available on the Microsoft SharePoint Team’s blog.

White Paper: Windows SharePoint Services Manageability Controls

Set quotas at a level that balances the need to manage storage with increasing numbers of support calls from site owners who are being told their site is out of space. Do the math in your organization by understanding the current and anticipated storage needs for sites and determining how many calls you want to get. Don’t set your quota at the expected average site collection size, or you will get support calls for quota increases for half of your sites. Instead, set quota size toward the top end of the acceptable level of storage and consider how much the storage costs versus the support call or the cost of time involved in increasing the quota. Although storage has become very cheap, quotas will encourage users to be responsible with their data.
If, for example, you anticipate having 1,000 site collections supporting team collaboration, and you anticipate that site collections will require between 100 MB and 600 MB of storage, evenly distributed across that 500 MB range, then by setting a quota of 550 MB, you can anticipate that 10 percent of the site collections will end up over quota. That means you can expect, over time, approximately 100 support calls requesting “exception” from the policy.
[view more of the white paper]

Here are some key things you should know when it comes to administering site collection quotas and quota templates.

Quotas are only applied to Site Collections
- They are not applied to one team site, or an entire web application (which hosts multiple site collections)
You can create a default quota template at the web application level, which will be used by new site collections created moving forward.
Everything in a site encompasses the Quota space: files in document libraries, items in your lists, all web parts, all images, form templates, etc…
- The content/data in the Recycle Bin is also included in the Quota space (it’s part of the site)
Site Collection Quotas and Quota templates are managed in Central Administration
- Central Administration > Application Management > Site Collection Quotas and Locks

New Site Collection: Assign a Quota during Site Collection creation
During the process of creating a site collection, you’ll select a Quota template, or not limit the collection at all:

Existing Site Collection: Determine if a Site Collection has a Quota
While browsing the site collection’s site settings, you may see Storage space allocation – this lets you know the site has a quota limitation set on it.To see this menu you have to enable Quotas for the Site Collection. Select this link to see how the quota is currently being utilized.
When you click this link you would see the Quota usage page like below.

Existing Site Collection: Determining current Quota
To view what current quota template a site is using, navigate to the Site Collection Quotas and Locks in Central Administration. Select the site site collection that you are viewing the Quota for.
Central Administration > Application Management > Site Collection Quotas and Locks

Side Note

When viewing your site collection list, it will not show all collections on one page if you have a large amount (more than 10). To see the other collections, use the pagination in the header.

With the proper site collection selected, you will site the current quota template and the corresponding settings for that quota. In this case, Large Team Site is the quota template with 500mb of storage.
If a site was created without a Quota Template applied, you will see the following information (which is currently not limited at all):

Existing Site Collection: Change Current Quota
To change the Quota Template of the site collection:
Central Administration > Application Management > Site Collection Quotas and Locks
Select which site collection that you are editing the Quota for.
Select a Quota Template, and click OK.

To set a quota that is not template based, select individual quota and enter your values.

When setting a quota template on an existing site collection, your quota needs to exceed the current storage used, or else the site will immediately be exceeding it’s storage and be locked.

Hide SearchDropdown using DelegateControl

2010-03-03T10:53:00.001-08:00

Super Simple Feature for Hiding the Search Scope DropDown

So I need to hide the scope drop down that shows up next to the search box in my SharePoint MasterPage.

Me: "That's gotta be simple… Just open up SharePoint designer and set some property on the search control."

SharePoint: "Silly little boy! Say hello to my little friend…err… DelegateControl!"

<Enter Jesse into world of SharePoint delegate controls>

Foolishness aside, the concept behind the DelegateControl is actually pretty useful, and because of it I was able to roll a very straightforward feature permitting me to hide the scope drop down in my MasterPage. And I didn't even have to write one line of code… a true ode to developer sloth.

The feature….

<?xml version="1.0" encoding="utf-8" ?>
<!-- Copyright (c) Microsoft Corporation. All rights reserved. -->   3: <Feature  Id="085B7E09-1D3E-41a7-9FEE-0C88F4394920"   4:           Title="Custom Basic Search Control Feature"
          Description="A feature for a search control that hides the Scope drop-down."   6:           DefaultResourceFile="spscore"   7:           Version="1.0.0.0"
          Scope="WebApplication"   9:           xmlns="http://schemas.microsoft.com/sharepoint/">  10:     <ElementManifests>
        <ElementManifest Location="searcharea.xml"/>  12:     </ElementManifests>  13: </Feature>

SearchArea.xml…

<?xml version="1.0" encoding="utf-8" ?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">   3:     <Control    4:         Id="CustomSmallSearchInputBox" 
        Sequence="1"   6:         ControlClass="Microsoft.SharePoint.Portal.WebControls.SearchBoxEx" ControlAssembly="Microsoft.SharePoint.Portal, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c">
    <Property Name="GoImageUrl">/_layouts/images/gosearch.gif</Property>   8:     <Property Name="GoImageUrlRTL">/_layouts/images/goRTL.gif</Property>
    <Property Name="GoImageActiveUrl">/_layouts/images/gosearch.gif</Property>  10:     <Property Name="GoImageActiveUrlRTL">/_layouts/images/goRTL.gif</Property>
    <Property Name="DropDownMode">HideScopeDD</Property>  12:     <Property Name="SearchResultPageURL">/_layouts/osssearchresults.aspx</Property>
    <Property Name="ScopeDisplayGroupName"></Property>  14:     <Property Name="FrameType">None</Property>
    </Control>  16: </Elements>

Two important things to note here… the Id of the control (CustomSmallSearchInputBox) and the DropDownMode (there are actually a bunch of different values you can set here). So, install your feature, reference the CustomSmallSearchInputBox in your MasterPage and you're ret' to go:

   1: <asp:ContentPlaceHolder id="PlaceHolderSearchArea" runat="server">   2:       <SharePoint:DelegateControl runat="server" ControlId="CustomSmallSearchInputBox"/>
   3: </asp:ContentPlaceHolder>

Theoretically speaking, you could roll your feature with the same ID as the SharePoint feature (SmallSearchInputBox), set the Sequence attribute to something super low, install your feature, and have your customized version start showing up throughout the site. I myself prefer to keep my changes more modular.

Custom WebPart Page Template with Navigation

2010-03-02T14:10:00.000-08:00

Steps to add Custom Web Part Page Templates

Download custom creation page (custspcf.aspx) from here and copy it 12 hive on your Web front end servers. The file should be copied to the following directory Local_drive:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\60\TEMPLATE\LAYOUTS\1033. (Note: If you are running on a server installed in a language other than English replace 1033 with the Language Code Identifier for your language.)
Open the new custspcf.aspx file in Visual Studio or another suitable text/html editor.
Search for onetidWebPartPageTemplate in the custspcf.aspx file. This is the ID of the selection list for the Web Part Page templates. There are two selections already included for the file, one for Custom1.aspx (set to be the default selection) and the other for Custom2.aspx. If you only want two custom templates skip step 4.
To add additional templates increment the size attribute of the Select element to the number of choices in the list and duplicate the second Option element in the list. Change the name value of the Option element using a pattern of Custom#, where # is the next index in the list of selections.
Search for onetidPreviewImage in the custspcf.aspx file.Specify the image in the src attribute for the template which will be selected by default.Name each image file the same as webpart template name. For example if the webpart template name is custom1.aspx then image name should be custom1.gif

Add the new custom Web Part Page template, named Custom# to match the entry in step 4, to the Local_drive:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\60\TEMPLATE\1033\STS\DOCTEMP\SMARTPGS directory.
Copy an image file named Custom#.gif for each of the Web Part Page templates you wish to add where # is the number of the template in the list to Local_drive:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\60\TEMPLATE\LAYOUTS\1033\IMAGES
Add a Link to custspcf.aspx to the Create.aspx page stored in the Local_drive:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\60\TEMPLATE\LAYOUTS directory. The custspcf.aspx needs to be deployed to layouts page and the image files needs to be deployed to template\\layouts\images folder. You can use wsp to deploy these files to these folders.

Disable MySites and MyLinks in SharePoint

2010-03-02T10:26:00.001-08:00

In order to turn off or disable the MySite or MyLinks functionality you need to be an Sharepoint administrator.

Go to the Central Administration Web Page
Click on the link for Shared Services Administration
--If you have more than one SSP, select the one that is running the MySites functionality
Under "User Profiles and My Sites" click Personalization Services Permissions

Select the group you want to limit the functionality for. More than likely you will just have NTAuthority\Authenticated Users.

In the next screen you will see a list of checkboxes,
--To disable MySites uncheck "Create Personal Site"
--To disable MyLinks uncheck "Use Personal Features"

Content Deployment explained

2010-03-02T10:22:00.001-08:00

In this post, I’ll cover how a particular WCM feature called Content Deployment supports multi-farm topologies and can be used to enable authoring -> staging -> production scenarios. I’ll talk a little about previous solutions to the problem, give you an overview of the Content Deployment feature, and discuss the architecture of the feature in-depth.

I would like to point out before we get started that even though I will be discussing the Content Deployment feature’s application in Internet-facing scenarios, the feature is most definitely useable for intranet sites as well. Because content is deployed from site collection to site collection, it can even be used to deploy content to another location on the same machine. Bottom line: the Content Deployment feature is very flexible and has uses beyond the scenarios that I’ll be discussing in this post.

First, let’s make sure we’re all on the same page by presenting a typical IT scenario. If you’re running an Internet-facing site that contains content authored by people on your internal network, chances are that you have a network separation (i.e. firewall(s)) between the intranet and the Internet-facing network. You want your internal authors to have access to the site so they can author, edit, and approve content, but you want that network (the intranet) shielded from incoming Internet traffic for security purposes. After all, the Internet is a big scary place no doubt populated with people who’d like nothing better than to get onto your internal network and wreak havoc. However, if Internet users can’t access your site, then what good is it?

The most common solution to this problem is to have two server farms: one internal farm (in the intranet) dedicated to your authors/editors/designers and a second farm (in the Internet-facing network) that hosts your production site. Your internal farm is read/write, while your production farm is most likely read-only. If you have this sort of topology though, you need a way to get the authored content from your authoring farm to your production farm. This is where Content Deployment comes in. In a nutshell, deployment allows you to push out your content from one server farm to another. For the purposes of this post, I’m going to focus on a two-tier topology (authoring -> production), but you can also have a three-tier topology (authoring -> staging -> production) or even an n-tier topology if you need it.

If you have used Content Management Server (CMS) 2002, then you’re somewhat familiar with Content Deployment already. In CMS, you would export your content from the authoring farm to an .sdo file, transport it via your own method to the production farm, then initiate an import of the .sdo file on the production farm. There were three basic steps: export, transport, and import, but there wasn’t any UI to help you configure this process – it was all manual.

In MOSS, things work in much the same way. The three basic phases of the process remain the same; however, Content Deployment takes care of transporting the content across the wire for you and instantiates the remote import as well. We even provide a UI in the SharePoint Central Administration site that allows you to configure, run, and monitor the deployment of your content.

So how exactly does this all work? So glad you asked! :-) There are two core conceptual objects to understand: paths and jobs. A path is basically a connection between a source farm and a destination farm. The path contains information about which source web application and site collection you are deploying, authentication information for the destination farm, and the web application and site collection on the destination farm. In short, a path represents the mapping between your authoring and production site collections.

However, a path by itself doesn’t actually deploy any content. In order to do that, you create a job. A job is associated with a path, and it determines exactly which sites in the source site collection will be deployed and on what schedule. You can have many different jobs for a given path, each running on different schedules and deploying specific sections of your site. That’s right – a job has a schedule and can deploy content updates regularly without the need to manually kick it off every time. For example, let’s say you have a Press Releases site that needs to be updated every hour, and an Employee Bios site that only needs to be updated every month. You would create two different jobs, one that runs every hour and deploys the Press Releases site, and another that runs monthly and deploys the Employee Bios site.

Let’s say you also need to push out your data to a third farm, perhaps a read-only extranet. No problem! You simply create another path that maps your authoring site to the extranet site, and create jobs that deploy the appropriate content on the appropriate schedule. One important thing to note is that deployment is always one way: source -> destination. It’s a “single-master” system.

Deployment is also pretty smart. By default, it only deploys the changes since the last successful deployment, which saves bandwidth and time. And if there aren’t any changes, the deployment will complete without redoing any unnecessary work. Of course, full deployments every time can be configured if that’s what you really want.

What about dependencies? What if a page is dependent on a page layout or image that has been updated? No cause for concern; deployment automatically picks up the dependent page layout and packages it up along with the page itself – even if the dependent resources aren’t in the same site. Let me clarify what that means. In the above scenario with the Press Releases and Employee Bios sites, let’s say you configured the two jobs I talked about on two different schedules. Whenever the Press Releases job runs, it will check to see if any of the content it’s deploying is dependent on other resources, and will pick those resources regardless of where they live in your site collection. This ultimately means that you don’t have to worry about content not rendering on your production environment because your jobs run on different schedules and have interdependent content – Content Deployment takes care of it all for you!

As I alluded to earlier, Content Deployment is configured and managed in the SharePoint Central Administration site, so the person configuring it is a Central Administrator. Usually this is OK, but there might be instances where a page needs to be deployed from authoring to production as quickly as possible. The site owner, who probably isn’t a Central Administrator, needs to get that content out ASAP, and doesn’t have time to wait for the next scheduled deployment. What does the site owner do?

For scenarios like this, Content Deployment has a special job called “Quick Deploy” that is automatically created for every path in any site collection with the Publishing Resources feature enabled. This job, once enabled in a path, wakes up every few minutes (15 minutes, by default) and checks a special list for content that should be deployed. If the site owner has rights, he or she can deploy pages quickly to production by using the “Quick Deploy” link on the Page Editing toolbar. This adds that page to the special list, which the Quick Deploy job will check the next time it wakes up. Pretty nifty, eh? By default, only the site owner has the Quick Deploy right. In order to give other users the same privileges, you simply add them to the Quick Deploy Users group.

And that, ladies and gents, is Content Deployment in a nutshell – albeit a fairly large nutshell. :-) I should also mention that if the Content Deployment feature doesn’t meet your needs for some reason (perhaps you have physically separated networks and require an alternative transport method such as “sneaker-net”), you can always use our APIs, which are well documented in the MOSS SDK, to craft a custom solution that meets your exact needs. I think that you’ll find this feature compelling and exciting, especially if your IT infrastructure leverages a multi-farm topology.

Content Deployment Step by Step

2010-03-02T10:09:00.000-08:00

I was looking around and realized that I couldn't find an easy set of instructions to set up Content Deployment in Microsoft Office SharePoint Server.

In this post, I'll show you how to set up content deployment from a staging site collection to a production site collection. For simplicity, I will host both site collections on the same server.

For a background on content deployment, see: http://blogs.msdn.com/sharepoint/archive/2006/05/02/588140.aspx

Create Production Site Collection

When setting up a content deployment path, the site collections must be in separate content databases so that the unique identifiers (GUIDs) do not conflict. The easiest way to ensure that the production site collection is in a different content database is to create it in a new web application.

Open Central Administration:

Under Application Management:

Select Create or extend Web application:

Choose an easy to remember port number, such as 12345:

Type in a user name and credentials to create a new app pool:

Type in a descriptive database name such as MOSS_PRODUCTION:

Leave all other settings at the default and click OK, then wait for the Web application to be created:

Click Create Site Collection:

Ensure that your new Web Application is selected:

Type in any name for the Title (it will be overwritten later):

Select "Blank Site" as the template. This step is IMPORTANT, because Blank Site is the only template that you can import any other template into:

Type in the names for the site collection owners:

Click OK.

Allow Incoming Content Deployment Jobs on the Production Site

Select Operation:

Select Content deployment settings:

Select Accept incoming content deployment jobs:

Select Do not require encryption and click OK:

Create Content Deployment Path from Staging to Production

Select Content deployment paths and jobs:

Click New Path:

Type a descriptive name for the path. Select the web application and site collection for the staging site. Then type in the URL of the Central Administration web site of the production site. Since we are putting both of our sites on the same server farm, the URL is the farm that we are on now.

Click Connect:

Once you see "Connection succeeded", select the web application and site collection that you created for production. You can also choose to deploy user names and security if you want the new site to have the same users and permissions.

Click OK.

Create Content Deployment Job

Click New Job:

Type a name, and then select the path you created:

Keep all other default values, and click OK.

Run Content Deployment Job

From the context menu on the job, select Run Now:

Refresh the page, and then click on the text Running:

Watch the status of the job:

When the status changes to Succeeded, you can click on the URL to the production site to verify that the content was deployed.

Run Quick Deploy Job.

Note:Quick Deploy Job gets created only when source and destination both sitecollection has Publishing features enabled.

In "Manage Content Deployment Paths and Jobs" Select Quick Deploy Settings from the Quick Deploy Job context menu:

Select Allow Quick Deploy jobs along this path, and set the schedule to check every 10 minutes, then click OK:

Visit the staging site and edit a page:

Make some changes:

Publish the page:

Show the page editing toolbar:

From the Tools menu, select Quick Deploy:

The changes will be picked up and deployed to production within 10 minute:

Farm wide: Hiding Site Templates

2010-03-01T07:18:00.001-08:00

Problem

You need to customize what site creators see when they choose site templates.

Answer

There are XML manifest files found on the file system of the web front end.

The file you can change is found here:

C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\1033\XML\WEBTEMP.XML

In it, you'll find reference to the site templates.

You'll see a TEMPLATE NAME tag which will identify the site template.

Then look for the HIDDEN attribute.

If you can see it in the template list then HIDDEN is set FALSE. If you want to hide it, change HIDDEN to TRUE.

Example

You want to hide the Wiki template from the Select a Template list:

Open WEBTEMP.XML in notepad
Find the tag TEMPLATE NAME="Wiki"
Find the nested HIDDEN tag. Change the value to TRUE.
Save the file.
Recycle the relevant application pool or do an IISRESET.
Repeat 1 to 5 on each web front end .

NOTE:

This is a farm wide hide so it will make the change everywhere. It will also hide the template from the Site Collection creation page as well.

SharePoint: How to prevent your content from being crawled

2010-02-26T15:33:00.000-08:00

A client of mine did not want parts of their Intranet based on MOSS 2007 to be searched; now that’s quite easy to do with Crawl rules. As they wanted strict control over the content that can be crawled I trained them on how to control ‘the crawl’ behaviour for content within SharePoint.

There are three places within SharePoint where end users can change search visibility setting or exclude content for search.

Change Visibility for a Web site: In the Site Settings page, site owners can click the Search Visibility link to go to the Search Visibility page SharePoint. In the Indexing Site Content group, selecting the No option to will exclude all content within the site. The crawler will in turn simply skip the site and not include any of its content in the index.
Exclude Site Columns: In the Site Settings page, site owners can click the Searchable Columns link to go to the Search Settings for Fields page in SharePoint. This page will enumerate all the site columns defined at the current site level. Selecting the NoCrawl check box for the site columns will exclude them from future crawls.
Exclude Lists: The last option for excluding content exists at the level of the SharePoint list settings. It enables list owners to exclude the list and all the content within it from crawls. In the settings page of the list, click the Advanced Settings link. Selecting the No option under Search Available for crawl tells the crawler to exclude the specific list from a crawl.

Also if there are certain pages or entire site content that site designers don’t want to be crawled, simply putting the no index directive in the head section of the master page or layout page’s mark-up will stop the SharePoint crawler from crawling the pages:

<META NAME=” ROBOTS” CONTENT=” NOHTMLINDEX”/>

Why do my changes not show in other sites?

2010-02-25T11:40:00.000-08:00

A detailed look at how the Sync works

I was asked recently to advise on how to configure a MOSS 2007 installation to allow end users to update their display name as they had previously been able to do in 2003. My initial thoughts on this were that its a simple update of the profile properties to allow them to edit the Name field, however the results achieved in testing appeared inconsistent.

In this article I will show

How to setup the profile properties
What the user sees and can edit
What services/timer jobs are involved in the Sync and how to speed this up for testing
The conditions that need to be met to trigger the profile information to be replicated.

Setting Up Profile Properties

The first step is to setup the profile properties. In this example I will be looking at enabling users to edit the display name (”PreferredName”) field. This example assumes that you have MOSS 2007 and a Shared Service Provider has been setup and configured.

From Central Admin choose the Shared Service Provider from the left hand menu. This should display a screen similar to the one below.

Select the User profiles and properties option as highlighted. This will allow you to add new properties or as in this example edit an existing property.

Scroll to the bottom of the page and click View profile properties. On the list of properties select the Name field and choose Edit.

The profile properties page allows you to configure the profile property. Ensure that the field selected is the PreferredName field, this has default Display Name of Name.

Check that the field is checked for replication. You will note that the text suggests that properties that can be replicated cannot be edited by the user, however this does not appear to be the case.

Choose Allow users to edit values for this property, this will allow the user to change the value via MySite.

Change the mapping to ‘not mapped’. If you do not change this any modification the user makes will be overwritten at the next profile import.

Note: When a user firsts accesses a site the User Info is extracted directly from AD (or your provider, not tested) and it still pulls the AD based display name into this field as it is not related to the profile mapping.

We will look at the different states for the User Info and profile imports below.

The properties page should show the PreferredName field is no longer mapped.

That is all of the changes required to make the display name editable by the user.

What The User Sees and Can Edit

When the user navigates to a SharePoint site the initial view will show the information contained in AD (I assume this is the same for other providers but you will need to test) including the display name.

AD user with defined Display Name, this will be used initially when the user accesses a SharePoint site as shown below.

To edit the display name navigate to your My Site, this will initially look like the image below, notice that the Welcome message is not based on the display name from AD but the users account name. In this example I have blurred the domain name.

Click on the Details option under the My Profile Quick Launch and edit the Name field.

In order to test this I have used a time stamp so I could repeat the tests and identify what had changed.

Clicking on Save will take you back to the My Site home page and will show some of the fields have updated but others have not. The fields that have not updated are based on the User Info table and is updated by the Quick Profile Synchronization timer job (see below).

The Quick Profile Synchronization timer job is scheduled too run regularly (minutes) but I have found in testing, and this will increase as your number of users and sites increase, it can take a while for the changes to take place. You can force this timer job by running the STSADM operation SYNC.

stsadm -o sync

Note: this starts the job, the changes will not appear instantly.

After the sync has been performed the User Info table will be updated with the values from the My Profile details.

Why do some Team Sites not update with my details

The main reason for confusion around the updating (sync’ing) of My Profile details into team sites is that it is now based on if the user is Active. As part of the upgrade to V3 Microsoft introduced the idea of users being active in a site rather than just having access.

When you first visit a site a record is recorded in the UserInfo table of the sites Content Database. The field tp_IsActive is defaulted to false, which means you have visited but have not interacted with the site.

The Sync process uses this value to determine if the user info should be replicated from the My Profile details as edited above.

Following on from the example above you should be able to refresh your team site that you had only visited and see the user name is still the same, it was not updated when the My Site was updated.

If you now interact with the site, either add a document or edit a link, in effect become an active user of the site, and then run the stsadm -o sync command as above the My Profile changes to the user name will be replicated to the site.

Sync Timer Jobs and STSADM

The synchronisation of the profile properties and information are based on two timer jobs, and one stsadm command (as used above). These jobs are per web application so you may see multiple of these configured in your environment. Access to these is via Centra Admin -> Operations.

These timer jobs are part of the Microsoft.Office.Server.UserProfiles namespace and specifically

WSSProfileSynch

Handles the synchronization of user profile data in the Windows SharePoint Services user information list on each site, and the synchronization of Windows SharePoint Services members group membership in the user profile memberships. This class is not intended to be used directly from your code; use stsadm.exe instead.

WSSSweepSynch

Handles the incremental synchronization of user profile data in the Windows SharePoint Services user information list on each site. This class is not intended to be used directly from your code; use stsadm.exe instead.

I have yet to determine exactly which of these processes are triggered using the stsadm -o sync command.

Additional Information

Profile Synchronisation on MSDN

Sahil Malik has a good post on the high level information flow within MOSS here.

I have also included below some sample code that I used to try and speed up the timer jobs. You may want to use these to help understand what each timer job does. Note, changing the Profile Synchronization schedule will not remain, another time job appears to reset this to the installed defaults.

static void Main(string[] args){ List<System.Uri> urls = new List<System.Uri>(); urls.Add(new System.Uri(“http://mysite_webapplication”)); urls.Add(new System.Uri(“http://portal_webapplication”)); for (int i = 0; i < urls.Count; i++) { SPWebApplication webApp = SPWebApplication.Lookup(urls[i]); foreach (SPJobDefinition job in webApp.JobDefinitions) { // “profsynch” = Profile Syncronisation // “sweepsync” = Quick Profile Syncronisation if (job.Name == “profsynch”) { SPMinuteSchedule schedule = new SPMinuteSchedule(); schedule.BeginSecond = 0; schedule.EndSecond = 59; schedule.Interval = 1; job.Schedule = schedule; job.Update(); Console.WriteLine(“Temporarily Updated Profile Sync for Web Application {0}”, webApp.Name); } } } Console.ReadLine();}

Error and Omissions

Warning: Access to the database directly is not supported, I performed this in my test environment to understand why things worked the way they did.

Using a famous Todd Bleeker line from TechEd Orlando – I reserve the right to be wrong! This is what I have found so far, but my knowledge and understanding of this may change over time.

Everything about SharePoint UserProfiles

2010-02-25T10:54:00.000-08:00

There are two kinds of User Profile information stored within SharePoint. One is WSS Profile which gets stored in UserInfo table in the content database for each site collection.The other is MOSS Profile which gets stored in SSP database and that gets sync with AD at regular intervals by Profile Synchronisation job. There are two profile sync jobs

The profsynch (Profile Synchronization) timer job which runs every hour
The sweepsync (Quick Profile Synchronization) timer job which runs each minute

To run the Profile sync jobs yourself you can execute below command.
stsadm -o sync

-excludewebapps <Web applications>

-synctiming <schedule>

-sweeptiming <schedule>

-listolddatabases <days>

-deleteolddatabases <days>

-IgnoreIsActive <0/1>

Parameters

Parameter	Value	Required?	Description
excludewebapps	A valid URL, such as "http://server_name"	Yes	Comma-delimited list of Web application URLs to exclude from consideration in the synchronization process. The values specified delete any existing values set.
synctiming		Yes	Sets the schedule for the main synchronization job. "M" denotes every n minutes (for example, “m:5” means every 5 minutes). "H" denotes every n hours (for example, “h:1” means every 1 hour). "D" denotes the number of times per day (for example, “D:3” means three times per day). The default is once per hour. Note: You can use the SPSchedule.FromString() string method to pass in the strings, “every 5 minutes” or “weekly xxxxxxx”. For additional information about the SPSchedule.FromString method, see SPSchedule.FromString method (http://go.microsoft.com/fwlink/?LinkId=85966&clcid=0x409).
sweeptiming	A valid time value in the form of minutes, such as "1"	Yes	Performs the same tasks as the synctiming parameter. However, the sweeptiming parameter sets the schedule for the “sweep” job. The sweep job is driven by the Windows SharePoint Services 3.0 change log and is used as a lightweight way to capture new users added. For example, you might have a fully synchronized site, but then a user is added to the site. The sweep job ensures that the incremental newly added user gets the user profile properties replicated quickly. The default value is every 1 minute.
listolddatabases	A valid number of days, such as "2"	Yes	Lists content databases that have not been synchronized since n days. The presumption is that they have been deleted or moved.
deleteolddatabases	A valid number of days	Yes	Performs the same operation as the listolddatabases parameter, except it deletes old records corresponding to these databases. It does not delete the databases themselves.
IgnoreIsActive	Boolean 0 or 1(Default 0)	No	The IgnoreIsActive flag allows you to choose which profiles to sync. By default, only the active profiles in a content database get sync'ed. An active profile is one of a user who has contributed something to the site. If you want to sync all users in the site, you can choose to trigger the execution of the sync job via STSADM with the IgnoreIsActive flag set to 1, and it will sync every profile.

This is something that a few people know about but a lot of people don’t so I thought I would take a few minutes to explain it. As most of you will know, WSS and MOSS are two seperate products, with MOSS extending WSS. User profile management is a MOSS feature that you get in your Shared Service Provider, which means that WSS won’t have it. To keep track of users in WSS each user will have a user profile that exists in each site collection (this is called the WSS profile). So what this means for a MOSS implementation is that your users will have at least two user profiles, a WSS user profile for each site collection they are a member of, as well as the main user profile that is stored in the SSP (the MOSS user profile).

The thing that sorta confused me with this though is that the two don’t instantly sync up. If you make a change in Active Directory and let the SSP import the new data, you will immediately see the change in the MOSS profile (so in the SSP and the user My Site) but you will not see it in the WSS profiles for the user (which you can see by browsing to a site and choose “My Settings” in the user menu). MOSS does have a timer job that will run to do this synchronisation but I’m not too sure how often it is meant to run.

However I did find a great post that talked about the issues with having the multiple profile sources, as well as how to fix it. Basically you can use the “stsadm -o sync” command to increase the schedule of a timer job that does the synchronisation of the details between the SSP and the site collections. I did that and got it updating great. So perhaps what would be a good idea would be to set this to run as often as your user profile imports are running from the AD, to ensure that when new information is sucked in from the AD it gets updated in your site collections. But definitely read that blog post, its got a lot of good information.

Quick Launch Bar Navigation Missing From Web Part Pages in SharePoint

2010-02-25T09:10:00.001-08:00

It's rather disturbing that the Left Side Navigation (Quick Launch) by default, does not display on new web part pages created in SharePoint. There are a number of workarounds on the web which include hacking each newly created page, or hacking an existing document template.

I like to use this approach, which modifies only the master page (inherited by each web part page). I only need to touch one file and be done with it.

In SharePoint Designer, find your master page.
Find the line :
<asp:ContentPlaceHolder id="PlaceHolderLeftNavBar" runat="server">
Directly beneath it add:
</asp:ContentPlaceHolder>
Find the real closing </asp:ContentPlaceHolder> element and remark it out like

Find the line:
<asp:ContentPlaceHolder id="PlaceHolderNavSpacer" runat="server">
Directly after it add:
</asp:ContentPlaceHolder>
Find the real closing tag and remark it out

Save the file

Essentially, we're letting HTML render the Quick Launch control on each page rather than let ASP manage it for us from the server. It's no longer conditional.

stsadm export/import vs Backup/Restore vs ExportWeb

2010-02-24T12:05:00.000-08:00

There are 4 ways to Backup/Restore different sharepoint entities.

stsadm export/import:

You can import single web(including all subwebs) using export method.
It can also export sitecollection and webapplication as well.
It exports data using Object Model and generated new GUID for every object.
It does not copy any information related to workflows. If import creates new lists and a workflow was associated to them, you must recreate it manually. Additionally, it does not copy workflow history and tasks lists.
You can run import operation on the same content database from which the export of the web was done as all the GUIDs are generated again, which you can't do in backup/restore.
It also activates all the features.

ExportWeb method(sites.asmx web service Object Model):

You should use this method if you would want to backup only single subweb without any child subwebs.

public int ExportWeb (string jobName,
    string webUrl,
    string dataPath,
    bool includeSubwebs,
    bool includeUserSecurity,
    bool overWrite,
    int cabSize)


Parameters:

jobName

The file name to use for content migration packages. 
webUrl

The URL of the site to export.
dataPath

The directory location where content migration packages are placed.
includeSubwebs

true to include subwebs; otherwise, false.
includeUserSecurity

true to include site security groups and group membership information; otherwise, false. 
overWrite

true to overwrite the content migration package if it exists; otherwise, false. 
cabSize

Indicates the maximum size for the CMP (content migration package) file.

Content Deployment

Content deployment copies content from a source Microsoft Office SharePoint Server 2007 site collection to a destination site collection. The entire source site collection can be copied (full), or a subset of sites can be copied (incremental). In either case, content deployment is incremental by default, deploying only changed pages and related assets (such as images). You can also do a full deployment of all content; however, you should only run a full deployment job on an empty site collection. Also, a Quick Deploy feature supports deployment of a single page by authors.

Central Admin Backup/Restore(stsadm -backup/-restore):

You can backup sitecollection,webapplication,farm using this.
It keeps every GUIDs except one (and the most important): when you restore the file, it generates a new GUID for the site collections.
This was done on purpose because Sites table of configuration database uses SiteID as primary key.
This is very important because it allows you to restore the backup in the same farm in which you did the backup. You can even restore the same backup several times in the same farm, but you must always restore in a different content database, because all others GUIDs remain unchanged.
This operation is probably more designed for SharePoint administrators that want to backup data. Because it does not do anything else than dumping the SQL content database, dministrators can be sure no data will be changed, transformed or lost.
Any Custom solutions deployed (be sure to keep the solutions so they can be easily re-deployed).
- Alternate access mappings
- The Central Administrator Web Application
- The Central Administrator content database
- The Internet Information Services metabase

Code Access Security and SharePoint

2010-02-19T12:40:00.000-08:00

Hi,
Don't change the trust level to Full in web.config and deploy your web parts to GAC as it is not recommended practise in most of the cases. Instead you should create CAS policy.

Example to add a CAS Policy for a sample WebPart.

Strong name the webpart and find out it's public key blob using sn -Tp assembly name.

Then in manifest.xml file for the Solution(WSP) put following entry.

<Solution
SolutionId="b172f003-d6c7-3e13-f737-a5d84a02e3e5" xmlns="http://schemas.microsoft.com/sharepoint/">

<!--Solution 
created by InstallAssemblies.exe on 8/15/2006 7:03:53 PM-->

<Assemblies>

<Assembly Location="MyCustomWebParts.dll" DeploymentTarget="WebApplication">

<ClassResources>

<ClassResource Location="MyCustomWebParts.pdb" 
/>
<ClassResource Location="en\two\generic.txt" />

<ClassResource Location="de\two\specific.txt" />
<ClassResource Location="header.html" />

</ClassResources>
<SafeControls>

<SafeControl Assembly="MyCustomWebParts, 
	version=1.0.0.0, Culture=neutral, PublicKeyToken=636addc00401d15b" Namespace="Example.CodeAccessSecurity" TypeName="*" />

</SafeControls>

</Assembly>

</Assemblies>
<DwpFiles>

<DwpFile Location="StandardAspNetWebPart.webpart" />
<DwpFile Location="HybridWSSWebPart.webpart" />

<DwpFile Location="StandardWSSWebPart.dwp" />
</DwpFiles>

<CodeAccessSecurity>

<PolicyItem>

<PermissionSet class="NamedPermissionSet" 
	version="1" Description="Permission 
set for custom test WebParts">

<IPermission class="AspNetHostingPermission" 
	version="1" Level="Minimal" />

<IPermission class="SecurityPermission" 
	version="1" Flags="Execution" />

<IPermission class="Microsoft.SharePoint.Security.SharePointPermission, 
Microsoft.SharePoint.Security, version=11.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" 
	version="1" ObjectModel="True" />

<IPermission class="System.Net.WebPermission, 
System, version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 
	version="1">
<ConnectAccess>
<URI uri="https?://.*" />


</ConnectAccess>
</IPermission>
<IPermission class="System.Security.Permissions.SecurityPermission, 
mscorlib, version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 
	version="1" Flags="ControlThread, 
UnmanagedCode" />

<IPermission class="System.Security.Permissions.EnvironmentPermission, 
mscorlib, version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 
	version="1" Read="UserName" 
/>

</PermissionSet>
<Assemblies>

<Assembly 
	PublicKeyBlob="hexadecimalValueTruncatedForClarity" 
/>


</Assemblies>
</PolicyItem>
</CodeAccessSecurity>
</Solution>

Schema rules:

There can only be 1 CodeAccessSecurity node per Solution manifest.
There can be any number of PolicyItem nodes.
Each PolicyItem node can contain only 1 PermissionSer and Assemblies
node.
Each PermissionSet node can contain any number of IPermission nodes
Schema of IPermission nodes are defined by the .NET framework
Each Assemblies node can contain any number of Assembly nodes.
The CodeAccessSecurity/PolicyItem/Assemblies/Assembly node is different
than the Solution/Assemblies/Assembly node.
The Assembly node can contain any of the following attributes:
- Name
- Version
- PublicKeyBlob

SharePoint - Register an assembly as a safe control in the Web.config file

2010-02-19T07:43:00.001-08:00

In order for you to use your own custom assembly with your web parts and other little bits, you will need to add your safe control to the web.config file. However, you need to think "WEB FARM" with many servers hosting the web application so I will show you a couple ways to do this.

The entry in the web.config

You need to place a SaveControl element entry into the web.config file of the web application. The entry looks like the following:

   1: <configuration>

   2:   <SharePoint>

   3:     <SafeControls>

   4:       <SafeControl Assembly="[Assembly Name]" Namespace="[Namespace]" TypeName="*" Safe="True" />

   5:     </SafeControls>

   6:   </SharePoint>

   7: </configuration>

Assembly The name of your assembly needs to added to this section. Although you can simply type the name of the DLL hosting the control into the Assembly element, it is important to not that this is not the recommended practice. Rather, use a full four part name; i.e. [assembly], version=[version], culture=[culture], publickeytoken=[publickeytoken]Namespace The namespace that your web controls are in. If you have your controls in multiple namespaces, you will need to add one <SafeContol ...> element for each control.TypeName The name of the web control which is allowed to be executed with the SharePoint web application. Should your namespace have multiple web controls, you do not need to register each control. You can simply use * (asterisk) to indicate the dll.Safe A boolean flag, indicating whether the control is treated as safe (true) or unsafe (false). AllowRemoteDesignerA boolean flag, indicating whether the control can be loaded by a remote designer, such as SharePoint Designer.

Sample

   1: <SafeControl Assembly="Brett.DemoParts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f03e5f7a44d50a3a"

   2:              Namespace="Brett.SharePoint.WebParts"

   3:              TypeName="*"

   4:              Safe="True"

   5:              AllowRemoteDesigner="True" />

Methods of updating the web.config file

There are three ways you can update the web.config file,

Manually adding the SafeControl to the web.config
Adding the SafeControl to the web.config with code
Deploy the assembly using a solution package

Manually editing the web.config (bad)

This approach may sound the easiest and quickest way as you simply open up your favourite xml editor, find the <SafeControls> element and add your own control into it.

WARNING!

If you do it this way, you are looking for trouble in a farm as you will need to remember to change the web.config modification for all your servers in the farm as well as all the web applications on the farm that use the custom control. So should you have a really awsome web part that is used within 5 web applications hosted on your farm of 3 servers, you will need to make the modification to 15 web.config's .. have fun.

Also should you add a new server to your farm, please remember to add the entry the web.config.

Bottom line, this is the worst possible way you can do it and stay away from doing it this way

Adding the SafeControl to the web.config with code (good)

SharePoint provides a class called SPWebConfigModification which has a set of modification commands in a collection. These modification commands are applied to the default web.config of the Web Application. These configuration modification commands will also be added and applied to all servers in a farm. Finally, should a new server be added to the farm, these modifications will also be applied.

The following code could be added to the FeatureActivated override method in your feature that deploys the web part.

   1: public override void FeatureActivated(SPFeatureReceiverProperties properties)

   2: {

   3:     // A reference to the features Site Collection

   4:     SPSite site = null;

5:

   6:     // Get a reference to the Site Collection of the feature

   7:     if (properties.Feature is SPWeb)

   8:     { site = ((SPWeb)properties.Feature.Parent).Site; }

   9:     else if (properties.Feature.Parent is SPSite)

  10:     { site = properties.Feature.Parent as SPSite; }

11:

  12:     if (site != null)

  13:     {

  14:         SPWebApplication webApp = site.WebApplication;

15:

  16:         // Create a modification

  17:         SPWebConfigModification mod = new SPWebConfigModification(

  18:             "SafeControl[@Assembly=\"MyAssembly\"][@Namespace=\"My.Namespace\"]"

  19:                 + "[@TypeName=\"*\"][@Safe=\"True\"][@AllowRemoteDesigner=\"True\"]"

  20:             , "/configuration/SharePoint/SafeControls"

  21:             );

22:

  23:         // Add the modification to the collection of modifications

  24:         webApp.WebConfigModifications.Add(mod);

25:

  26:         // Apply the modification

  27:         webApp.Farm.Services.GetValue<SPWebService>().ApplyWebConfigModifications();

  28:     }

  29: }

Deploy the assembly using a solution package (best)

The preferred way to provision your features, web parts and assemblies is by creating a Solution Package (.wsp file). You will add add your assembly, the manifest.xml file and all your other components and resources into the cabinet.

You will need to add the following entry into the manifest.xml

   1: <Solution SolutionId="{1E0FDA58-6611-423a-92EC-8E7355810CEE}"

   2:           xmlns="http://schemas.microsoft.com/sharepoint/">

   3:   <FeatureManifests  />

   4:   <ApplicationResourceFiles />

   5:   <CodeAccessSecurity />

   6:   <DwpFiles />

   7:   <Resources />

   8:   <RootFiles />

   9:   <SiteDefinitionManifests />

  10:   <TemplateFiles />

11:

  12:    <Assemblies>

  13:       <Assembly DeploymentTarget="WebApplication" Location="Brett.DemoParts.dll">

  14:          <SafeControls>

  15:             <SafeControl Assembly="Brett.DemoParts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f03e5f7a44d50a3a"

  16:                          Namespace="LitwareWebParts"

  17:                          TypeName="*"

  18:                          Safe="True"

  19:                          />

  20:          </SafeControls>

  21:       </Assembly>

  22:    </Assemblies>

  23: </Solution>

24:

Key highlights

DeploymentTarget The depoloyment target is location where the assembly will be copied to and can ether be the bin folder of the WebApplication or it could be the GlobalAssemblyCache (GAC)Location The location of the assembly within the cabinet file. SafeControl A SafeControl element entry as described at the beginning of the post.

Using this method, your assembly will be correctly deployed the servers in the farm as well as added to the safe controls of the web application. Again any new server added to the farm will automatically get all the solution packages deployed.

Site Pages & PageParserPath

2010-02-18T13:48:00.000-08:00

Hi,

You can have two kind of Site Pages.
1. Uncustomized(Ghosted) which resides in the file system.
2. Customized which are stored in the Content Database.

UnCustomized Pages can be created using visual studio and can be deployed using features.

Sample ASPX Page

<%@ Page Language="C#" MasterPageFile="~masterurl/default.master" meta:progid="SharePoint.WebPartPage.Document" Inherits="CustomizedPageLibrary.PageTemplate,CustomizedPageLibrary, Version=1.0.0.0, Culture=neutral, PublicKeyToken=fa90fd1d7c28abf3" %>

<asp:Content ID="Content2" runat="server" ContentPlaceHolderID="PlaceHolderMain">
<asp:Label ID="lblHello" runat="server" BackColor=Red></asp:Label>
<asp:Button ID="btnHello" runat="server" OnClick="btnHello_Click"/>
</asp:Content>

Code Behind

Create a class library project and add System.Web and Microsoft.SharePoint.Publishing dll references.
Then add following class and strong name the dll.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SharePoint.Publishing;
using System.Web.UI.WebControls;

namespace CustomizedPageLibrary
{
    public class PageTemplate : PublishingLayoutPage
    {
        protected System.Web.UI.WebControls.Label lblHello;
        protected Button btnHello;
        void Page_Load(object sender, EventArgs e)
        {
            lblHello.Text = "Hello1";
        }
        protected void btnHello_Click(object sender, EventArgs e)
        {
            lblHello.Text = "Hello" + DateTime.Now.ToString();
        }
    }

}

Install the assembly in the GAC

To deploy the site page into the site's Shared Documents library
feature.xml

<?xml version="1.0" encoding="utf-8" ?>
<Feature xmlns="http://schemas.microsoft.com/sharepoint/"
         Id="597D8309-C964-48ef-8D24-D5C60C94A832"
         Title="MSDN Uncustomized Page Feature"
         Scope="Web">
<ElementManifests>
    <ElementManifest Location="elements.xml"/>
    <ElementFile Location="PageTemplate.aspx" />
</ElementManifests>
</Feature>

elements.xml
<?xml version="1.0" encoding="utf-8" ?>
<Elements xmlns="http://schemas.microsoft.com/sharepoint/">
<Module Url="Shared Documents">
    <File Url="PageTemplate.aspx" Name="SamplePage.aspx" Type="GhostableInLibrary" />
</Module>
</Elements>

Note: If you don't want to deploy it to Some doclib then you can use Type="Ghostable" as well.

Customized Pages

The aspx file above can be uploaded into some document library and the page is ready to be used if you don't have any inline code or any server side code to execute. If you want to execute some serverside code then you need to add following entry in the web.config in <PageParserPaths> element. Any page in the content database that needs to execute server side code needs to have the PareParserPath entry in web.config file.

<PageParserPaths>
        <PageParserPath VirtualPath="/Shared Documents/*" CompilationMode="Always"
AllowServerSideScript="true" IncludeSubFolders="true"/>
</PageParserPaths>

Move SiteCollections between WebApplications

2010-01-26T08:05:00.001-08:00

edit: Please read this blog post before using 'mergecontentdb' data corruption may occur

On multiple occasions as a SharePoint administrator I have needed to move a Site Collection from one Content Database to another one. In the past this process was very painful and very manual. In this blog post I will show you how to move Site Collections between Content Databases with a single STSADM command using the "mergedbs" operation that was introduced in KB934525.

Why would I need to move a Site Collection to a different Content DB? This comes up for a variety of reasons. For instance, because of restore times, I like to keep my databases under a certain size. While I try to work with my Site Collections owners to plan accordingly sometimes they grow larger than we had imagined. When this happens I need to shuffle Site Collections around to keep my databases in harmony. There are other times when I would do it if it were more convenient. If Site Collections are not growing as expected, I may want to consolidate several into a smaller Content DB. I may also want to move less active Site Collections to Content DBs on slower discs, or move Site Collections to Content DBs that reflect geographic regions. Whatever the reason, in the past to move a Site Collection you had to go through the following steps manually;

Lock the Site Collection
Back the Site Collection up
Delete the Site Collection
Set all your Content Databases' maximum allowed sites to the number of current sites.
Set the Content Database you want the Site Collection to go into to allow one more Site Collection.
Restore the Site Collection
Unlock the Site Collection
Adjust your Content Database maximums to allow new sites to be created.

All of these steps could be done with STSADM so you could build scripts and move through the process quickly. In one of the recent security patches (KB934525) for WSS and MOSS Microsoft slipped in a new STSADM operation, mergecontentdbs. I assume this operation was added with the intention of merging Content DBs, but it can also be used to split them. This blog post will walk you through both uses. Let's start with the configuration below:

You can see in this screenshot that I have three Site Collections in two Content DBs; WSSContent and WSSContent2. Let's move http://barcelona/sites/stsadm from WSS_Content to WSS_Content2. If you get the help for the mergecontentdbs operation it looks like this:

We want to use operation 3, Read from file. STSADM has given us a clue about the file needed, it is generated from stsadm –o enumsites. I'll go ahead and run that and pipe it to a file like this:

This will produce a file, mysites.xml, that contains my site collections. To move http://barcelona/sites/stsadm we'll remove all of the other Site Collections except for that one from mysites.xml and save it. You don't need to worry about changing the Site Count at the top, or any of the other Site Collection information in the file, STSADM only grabs the URLs out. I only have two Content Databases so the decision of which database to move the Site Collection to is easy. What if I had many Content Databases? You can use the first operation, Analyze, to get an idea of how your Content Databases are laid out. Let's see how that looks:

You can see here where I got the idea to use the filename mysites.xml. The thing I love best about this screen is that you can just cut and paste the final command into your Command Prompt if you'd like. I think Microsoft did a great job with the usage on this command. One thing to note is that the –url parameter is NOT the URL of the Site Collection you want to move, it's the URL of the Web Application that the Site Collection is in. Since we've already created our file and edited it, let's go ahead and run the command.

That's all there is to it. After an iisreset we see that the Site Collection http://barcelona/sites/stsadm is now in WSS_Content2. You can confirm it by looking in Central Administration > Applications > Content Databases before and after you run the command.

I have one final thing to show you, what I imagine is the intended usage of mergecontentdbs, merging two Content Databases. If we use the second operation STSADM will simply move all the Site Collections from the Source database to the Destination database. Let's move all of the sites in WSS_Content2 back into WSS_Content.

I think that picture pretty well sums it all up. Now all the Site Collections in the http://barcelona Web Application are in WSS_Content, right where we want them. I think Microsoft did a pretty good job with this addition to STSADM. Enjoy it.

I'd like to give a special shout out to Joel Oleson for telling me to look for this little gem.

Move Site between site collections

2010-01-26T07:57:00.000-08:00

How To: Move a single Site between Site Collections

Hey,

I'm hearing a lot of this question in many variations and I figured it's time to solve it once and for all. The problem is well known: trying to move a WSS Site between 2 different places (such as Site Collections) is still not something we're doing with a click of a button. There is no real and easy of doing so and I've heard about many "nasty" solutions (such as Backup/Restore for entire Site Collection, Copy-Pasting everything with the Explorer View and many other messy evils).

It looks like multiple teams in Microsoft have been tasked with this issue since we actually got 3 different ways to solve it:

SharePoint Designer Backup/Restore - Definitely the easiest way to move sites around but only WHEN IT WORKS (since that's not a very consistent feature in SPD). To use this method, simply go to Menu --> Site --> Administration --> Backup Web Site and enter the URL of the WSS site you want to move. You can also include/exclude other subsites in the archive you're creating. Restoring it to the new Site Collection is done with the Restore Web Site feature in SPD. Again, remember this is not too consistent so always try to restore before deleting an original site (Even when you get the "Backup Operation was completed successfully" message!).
Stsadm.exe export/import - The stsadm.exe admin utility is not a new tool but in the 2007 it has many improvements. Now, we can use stsadm as a way to import and export single sites. By the way, this is actually how Share Point Designer creates the archive in the mentioned SPD method. Don't get confused with the backup/restore operations in stsadm.exe - those operations were already available in 2003 but they are used for entire Site Collections rather than a single site (and in our case it's a major overkill). Sounds great huh? Well, just like the SharePoint Designer way, it could easily become a MAJOR NIGHTMARE when it's not working so let me give you some tips. I hope this will reduce the amount of time spent CURSING THE HELL of our beloved stsadm's command line window and the its log file.

The default cabsize value is 25 Mb which is VERY lame for big sites! Always define ur own cabsize (up to 1 GB...)
It is highly recommended to add the “-haltonwarning” or “-haltonfatalerror” parameters. You'll be able to see a list of possible problems before proceeding with the creating on the archive.
If still encounter failures and you don't understand WTF that could be, You might want to try the –nofilecompression switch. Somehow, exports tend to fail in much bigger numbers when you try to compress them.
And to sum it all up, here's the complete command with all of the available switches for exporting/importing with stsadm.exe:
stsadm -o export -url <URL to be exported> -filename <export file name> [-overwrite] [-includeusersecurity] [-haltonwarning] [-haltonfatalerror] [-nologfile] [-versions <1-4> 1= Last major version for files and list items (default), 2= The current version, either the last major or the last minor, 3= Last major and last minor version for files and list items, 4= All versions for files and list items] [-cabsize <integer from 1-1024 megabytes> (default: 25)] [-nofilecompression] [-quiet]
stsadm -o import -url <URL to import to> -filename <import file name> [-includeusersecurity] [-haltonwarning] [-haltonfatalerror] [-nologfile] [-updateversions <1-3> 1= Add new versions to the current file (default), 2= Overwrite the file and all its versions (delete then insert),3= Ignore the file if it exists on the destination] [-nofilecompression] [-quiet]

Content Deplyoment - Ok, now we're really talking! Let the real fun begin! This is probably the coolest and by far the most elegant way for synchronizing content between Site Collections. Although this is for a Site Collection level - it's a great way to make a lasting connection and keep moving new content between environments. Before using this method, you need to be familiar with two core conceptual objects: Paths and Jobs. A Path is set of definitions that represents a connection between the source environment and the destination environment. The path contains information about which source web application and site collection you are deploying, authentication information for the destination environment, and the web application and site collection on the destination MOSS. However, a path by itself doesn’t actually deploy any content - it's only a set of definitions. In order to sync the environment, you must create a Job. Each job is associated with a path, and determines exactly which sites in the source site collection will be deployed and on what schedule.

Now the really cool thing about this method: It uses the same logic and internal audit/log files as the Index jobs. That means that you can define a job that only deploys the changes since the last successful deployment and this could for a single item/document level. Great for saving bandwidth and time. Furthermore, if there are no changes since the previous job, the deployment will complete without redoing any unnecessary work. Of course, full deployments every time can be configured if that’s what you really want but this is not necessary in most cases.

Awesome hug? Although this is for Site Collection level, I think it addresses the main scenario that is main reason for wanting to move a list or a whole site between places: Replication between the Testing environment to the real Production environment. Using this method, you can define it once and deploy testing versions whenever you think you're done playing and it's time to publish your changes. You can find the Content Deployment management interface under the SharePoint Central Administration site. One aspect of content deployment that you should be aware of is that it will only deploy content, not any dependent assemblies/controls/webparts, etc. Administrator is responsible for moving the assemblies for controls and webparts to the destination farm.

In conclusion - We're dealing here with 2 types of scenarios: If we're talking about moving an entire site ONCE between Site Collections - the SPD and stsadm.exe ways are preferred and you should just use them. If you're talking about synchronization between two environments and it's something that should happen every once in a while - we'll need that lasting connection that is provided through Content Deplyoment.

Impersonate another user c#

2009-12-04T17:03:00.000-08:00

public class Impersonator
{
public const int LOGON32_LOGON_INTERACTIVE = 2;
public const int LOGON32_PROVIDER_DEFAULT = 0;

WindowsImpersonationContext impersonationContext;

[DllImport("advapi32.dll")]
public static extern int LogonUserA(String lpszUserName,
String lpszDomain,
String lpszPassword,
int dwLogonType,
int dwLogonProvider,
ref IntPtr phToken);
[DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern int DuplicateToken(IntPtr hToken,
int impersonationLevel,
ref IntPtr hNewToken);

[DllImport("advapi32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern bool RevertToSelf();

[DllImport("kernel32.dll", CharSet = CharSet.Auto)]
public static extern bool CloseHandle(IntPtr handle);

public bool impersonate(String userName, String domain, String password)
{
WindowsIdentity tempWindowsIdentity;
IntPtr token = IntPtr.Zero;
IntPtr tokenDuplicate = IntPtr.Zero;

if (RevertToSelf())
{
if (LogonUserA(userName, domain, password, LOGON32_LOGON_INTERACTIVE,
LOGON32_PROVIDER_DEFAULT, ref token) != 0)
{
if (DuplicateToken(token, 2, ref tokenDuplicate) != 0)
{
tempWindowsIdentity = new WindowsIdentity(tokenDuplicate);
impersonationContext = tempWindowsIdentity.Impersonate();
if (impersonationContext != null)
{
CloseHandle(token);
CloseHandle(tokenDuplicate);
return true;
}
}
}
}
if (token != IntPtr.Zero)
CloseHandle(token);
if (tokenDuplicate != IntPtr.Zero)
CloseHandle(tokenDuplicate);
return false;
}

public void undoImpersonation()
{
impersonationContext.Undo();
}
}

//Sample Code

Impersonator imp = new Impersonator();
bool isTrue=imp.impersonate("testuser1", "buildmachine", "password");
if (isTrue)
{
items = testDocLib.GetItems(query);

Console.WriteLine(items.Count);
imp.undoImpersonation();
}

SharePoint Hard Limits and Recommendation

2009-12-03T07:06:00.000-08:00

Entity	Max Permissible Size
Site Name	128 characters
Site URL	255 characters
Display name	128 characters
Connection string	384 characters
Email address	128 characters
Version numbers	064 characters
Virtual Server Friendly Name	064 characters
SQL Database Name	123 characters
SQL Database Column	128 characters
SQL Database Table Name	128 characters
SQL Role Name	128 characters
Server Name	128 characters
Windows User Name	300 characters
Windows Password	300 characters
Dependencies per object	032 objects
Zone enumeration value	004 zones
Default SQL command timeout	300 seconds
Number of simultaneous workflows that can be run	015

Site object	Guidelines for acceptable performance	Notes	Scope of impact when performance degrades
Site collection	50,000 per Web application	Total farm throughput degrades as the number of site collections increases.	Farm
Web site	250,000 per site collection	You can create a very large total number of Web sites by nesting the subsites. For example, 100 sites, each with 1000 subsites, is 100,000 Web sites. The maximum recommended number of sites and subsites is 125 sites with 2,000 subsites each, for a total of 250,000 sites.	Site collection
Subsite	2,000 per Web site	The interface for enumerating subsites of a given Web site does not perform well as the number of subsites surpasses 2,000.	Site view
Document	5 million per library	You can create very large document libraries by nesting folders, using standard views and site hierarchy. This value may vary depending on how documents and folders are organized, and by the type and size of documents stored.	Library
Item	2,000 per view	Testing indicates a reduction in performance beyond two thousand items. Using indexing on a flat folder view can improve performance.	List view
Document file size	50MB (2GB max*)	File save performance is proportional to the size of the file. The default maximum is 50 MB. This maximum is enforced by the system, but you can change it to any value up to 2 GB.	Library, file save performance
List	2,000 per Web site	Testing indicates a reduction in list view performance beyond two thousand entries.	List view
Field type	256 per list	This is not a hard limit, but you might experience list view performance degradation as the number of field types in a list increases.	List view
Column	2,000 per document library4,096 per list	This is not a hard limit, but you might experience library and list view performance degradation as the number of columns in a document library or list increases.	Library and list view
Web Part	50 per page	This figure is an estimate based on simple Web Parts. The complexity of the Web Parts dictates how many Web Parts can be used on a page before performance is affected.	Page

The following table lists the recommended guidelines for people objects.

People object	Guidelines for acceptable performance	Notes
Users in groups	2 million per Web site	You can add millions of people to your Web site by using Microsoft Windows security groups to manage security instead of using individual users.
User profile	5 million per farm	This number represents the number of profiles which can be imported from a directory service, such as Active Directory, into the people profile store.
Security principal	2,000 per Web site	The size of the access control list is limited to a few thousand security principals (users and groups in the Web site).

The following table lists the recommended guidelines for search objects.

Search object	Guidelines for acceptable performance	Notes
Search indexes	One per SSPMaximum of 20 per farm	Office SharePoint Server 2007 supports one content index per SSP. Given that we recommend a maximum of 20 SSPs per farm, a maximum of 20 content indexes is supported. Note that an SSP can be associated with only one index server and one content index. However, an index server can be associated with multiple SSPs and have a content index for each SSP.
Indexed documents	50,000,000 per content index	Office SharePoint Server 2007 supports 50 million documents per index server. This could be divided up into multiple content indexes based on the number of SSPs associated with an index server.
Content sources	500 per SSP*	This is a hard limit enforced by the system.
Start Addresses	500 per content source*	This is a hard limit enforced by the system.
Alerts	1,000,000 per SSP	This is the tested limit.
Scopes	200 per site	This is a recommended limit per site. We recommend a maximum of 100 scope rules per scope.
Display groups	25 per site	These are used for a grouped display of scopes through the user interface.
Crawl rules	10,000 per SSP	We recommend a maximum 10,000 crawl rules irrespective of type.
Keywords	15,000 per site	We recommend a maximum of 10 Best Bets and five synonyms per keyword.
Crawled properties	500,000 per SSP	These are properties that are discovered during a crawl.
Managed properties	100,000 per SSP	These are properties used by the search system in queries. Crawled properties are mapped to managed properties. We recommend a maximum of 100 mappings per managed property.
Authoritative pages	200 per relevance level	This is the maximum number of sites in each of the four relevance levels.
Results removal	100	This is the maximum recommended number of URLs that should be removed from the system in one operation.
Crawl logs	50,000,000	Number of individual log entries in the crawl log.

The following table lists the recommended guidelines for logical architecture objects.

Logical architecture object	Guidelines for acceptable performance	Notes
Shared Services Provider (SSP)	3 per farm (20 per farm maximum)
Zone	5* per farm	The number of zones defined for a farm is hard coded to 5.
Web application	99 per SSP	This limit includes the number of Web applications on child farms consuming resources on this SSP.
Internet Information Services (IIS) application pool	8 per Web server	Maximum number is determined by hardware capabilities.
Site collection	50,000 per Web application
Content database	100 per Web application
Site collection	50,000 per database

The following table lists the recommended guidelines for physical objects.

Physical object	Guidelines for acceptable performance	Notes
Index servers	1 per SSP*
Application servers running Excel Calculation Services	No limit
Query servers	No limit	Because 100 content databases are supported for each query server, the number of query servers required per farm is based on the number of content databases in the farm. For example, if there are 500 content databases in your farm, you will need at least 5 query servers.
Web server/database server ratio	8 Web servers per database server	The scale out factor is dependent upon the mix of operations.
Web server/domain controller ratio	3 Web servers per domain controller	Depending on how much authentication traffic is generated, your environment may support a greater number of Web servers per domain controller.

SPSiteDataQuery example

2009-12-02T14:50:00.001-08:00

I have been playing with the SPSiteDataQuery a fair bit recently and thought it would be interesting to post some of the results.

When using the SPSiteDataQuery to perform a search there are four main properties you are going to set which determine the results you will get. If you have seen my previous post (XML results using SPSiteDataQuery in SharePoint) you will have seen that they are Lists, Query, Webs and ViewFields.

If you read nothing else then remember this...If you make a mistake in the Webs or Lists properties, invalid XML or invalid attributes, the SPSiteDataQuery will fall back to it's default behavior and will not throw an error!! Knowing this can save a lot of time...ensure your properties are correctly formatted.

So, assuming the basic setup is

SPSiteDataQuery q = new SPSiteDataQuery();
q.Lists = "<Lists BaseType='1'/>";
q.Query = "<Where><Gt><FieldRef Name='ID' /><Value Type='Number'>0</Value></Gt></Where>";
q.Webs = "<Webs Scope='SiteCollection' />";
q.ViewFields = "<FieldRef Name='Title' /><FieldRef Name='ID' />"';
q.RowLimit = 10;

Here are the changes you can make to achieve different result sets and tips as to why the query could be failing.

The Webs Property

There are basically three different values for this...

"<Webs Scope='SiteCollection' />" This will search the entire site collection no matter which web you use to execute the query.
"<Webs Scope='Recursive' />" This will search the web on which you execute the query and recurse through any child webs.

"" If you leave it blank then it will only search the web on which you execute the query. No child webs will be queried. This is important as I have read on several other sites that this is not possible with SPSiteDataQuery, but it is!!

I would also point out that that if you get anything wrong with this property SharePoint will not throw an error, it will just default to the blank behavior...It will only search the web on which you executed the query. This is an important point as "<Webs scope='Recursive' />" or "<Webs Scope='recursive' />" (small 's' in Scope and small 'r' in recursive) look OK but are actually invalid and the query will default to only the current web.

The Lists Property

This defines what type of document libraries and lists WSS will search for your items. You can specify the exact type of list, the base type or even specific lists. Examples of the Lists property are...

"<Lists BaseType='1'/>" As above, this will search all lists which are based on a 'Document Library. This is useful if you only want to find documents. Other values for BaseType include...

0 - Generic list - This will search all lists and not document libraries.
1 - Document Library
3 - Discussion Forum
4 - Vote or Survey
5 - Issues list

(no, I don't know what happened to number 2!!)

I should also point out that the default is to search BaseType = '0' , and so if you do not set or make a mistake in the XML only lists will be searched.

"<Lists ServerTemplate='850'/>" This will limit the search to only a particular list template (850 is the Pages template in a publishing site). The number is fairly random and is defined in the list definition. I haven't needed to look at them as yet so I don't know a better way than looking in the definitions in the FEATURES folder for SharePoint. If you make a mistake with this property it will revert to the default.

Another options is Hidden, which determines if hidden lists or document libraries are searched. This an additional attribute and would be used like this...

"<Lists ServerTemplate='850' Hidden='TRUE'/>"

The MaxListLimit attribute specifies the total number of lists to search. You will receive an exception if the query exceeds the MaxListLimit. The default amount is 1000 and by setting this to 0 you can search everything. So the following would only search the first 50 lists...

"<Lists BaseType='1' MaxListsLimit='50'/>"

Another thing you can do with the Lists property is to query specific lists. This can be done by specifying the Guid of the list you want to search. An example would be...

"<Lists><List ID="129AB4CAE-12EF-9871-DE45-F34A180D3EAB5"/></Lists>"

You would obviously need to know the Guid of the lists you wish to query before creating this property.

The ViewFields property

The ViewFields property specifies the fields (columns), that will be returned in the query. This is very similar to SQL and you should ensure that you specify any fields that you may wish to use in you Where or OrderBy part of the query.

Things to point out here is that that you can specify the ID(Guid) of the property or the name of the property...this is the Internal Name, not the name you may see in the UI. For example the standard publishing field "Image Caption" would become "PublishingImageCaption" as that is it's internal name.

So, to add the "Image Caption" filed to the results we would need...

"<FieldRef Name='Title' /><FieldRef Name='ID' /><FieldRef Name='PublishingImageCaption' />"

Another thing to remember is that not all lists or documents libraries contain the same fields. If you are not worried about a particular field and want the item returned whether the field (column) exists or not the you can set Nullable to true. So if we have some items which may not have an 'Image Caption' column then we could use...

"<FieldRef Name='Title' /><FieldRef Name='ID' /><FieldRef Name='PublishingImageCaption' Nullable='TRUE'/>"

and this would still find those items without an 'Image Caption' column (field).

The Query Property

This property will allow you to bot limit and order you results. You can do both or just one, but it is similar to SQL in what you can do. There is a lot to this, but I will give a couple of samples...

Querying by date...

string sLastWeek = SPUtility.CreateISO8601DateTimeFromSystemDateTime(DateTime.Today.AddDays(-1));
q.Query = "<Where><Gt><FieldRef Name='Created'><Value Type='DateTime'>" + sLastWeek + "</Value></Gt></Where>";

This will find items created within the last week. The <Gt> denotes 'Greater Than', you could also use <Gte>, <Lt> or <Eq>. These can be combined to create more complex queries.

q.Query = "<OrderBy><FieldRef Name='Title' Ascending='FALSE'></OrderBy>";

This will order the items descending by the title (Z-A).

q.Query = "<Where><Gt><FieldRef Name='Created'><Value Type='DateTime'>" + sLastWeek + "</Value></Gt></Where><OrderBy><FieldRef Name='Title' Ascending='FALSE'></OrderBy>";

This is a combination of the above...items created in the last week ordered Z-A.

Finally, make sure you set the RowLimit property...you may not get any results otherwise!!

Custom PowerShell Commands

2009-11-23T17:34:00.000-08:00

To Create Custom Cmdlet, Your class can inherit from either PSCmdlet or Cmdlet class.

You could override below methods.
BeginProcessing-- Provides optional one-time, preprocessing functionality for the cmdlet.
ProcessRecord -- Provides record-by-record processing functionality for the cmdlet. It may be called any number of times or not at all, depending on the input of the cmdlet.

EndProcessing Provides optional one-time, post-processing functionality for the cmdlet.
StopProcessing Stops processing when the user stops the cmdlet asynchronously, such as by entering the key combination Ctrl+C.

To register this cmdlet you need to create a custom SnapIn by inheriting from PSSnapIn or CustomPSSnapin
You have to override below property.
Description: Supply short description of your Snap-in here.

Name: Supply name of your Snap-in here.
Vendor: Supply vendor information for your Snap-in here.
Cmdlets: This is where you provide collection of Cmdlets that need to be registered. I will discuss this in details.

Make sure you override the CmdLets property which should return all the Cmdlets that you want to register with PowerShell.
Example:
public override Collection Cmdlets

{
get
{
if (null == _cmdlets)
{
_cmdlets = new Collection();
_cmdlets.Add(new CmdletConfigurationEntry
("Get-Book", typeof(GetBookCommand), "AmazonPS.dll-Help.xml"));
}
return _cmdlets;
}
}

You need to mark the class with RunInstaller attribute

Then you have to install this snapin using installUtil 64 bit utility.
Then the snapin will be registered with the powershell.

Every time you open the powershell console. You have to run Add-PSSnapIn command.

Custom stsadm commnad in SharePoint 2007

2009-11-23T15:59:00.001-08:00

The STSADM.EXE utility enables many administrative operations in Windows SharePoint Services that cannot be done with the Central Administration application. See the article Stsadm.exe command-line tool (Office SharePoint Server) in Microsoft TechNet for details. With Windows SharePoint Services 3.0 you can extend the functionality of the STSADM utility by adding your own operations and command line parameters with simple projects using any .NET language.

Creating such a project requires two major tasks.

Create a class that implements the ISPStsadmCommand interface.
Inform STSADM about your extension by registering the class and its assembly.

Create a class that implements ISPStsadmCommand

Start a Class Library project in Visual Studio.
Add using statements for Microsoft.SharePoint and Microsoft.SharePoint.StsAdmin.
Use a namespace that follows the pattern CompanyName.TechnologyName.Feature.SubFeature. For example, AjaxInc.SharePoint.StsAdmin.CustomCommands. (See Names of Namespaces.)
Use a class name that expresses the common denominator of the new STSADM operations that you will be creating; for example, "SortCommands".
The class should inherit ISPStsadmCommand; with a declaration similar to the following.

public class SortCommands : ISPStsAdminCommand
Write the implementation of the GetHelpMessage method. See the example below.
Write the implementation of the Run method. See the example below.
Compile the project, using the namespace name as the name of the assembly.
Deploy the assembly to the global assembly cache; for example C:\Windows\Assembly.

Register the new class and assembly

Create a text file (UTF-8) named stsadmcommands.uniqueID.xml, where uniqueID is the name of your company or some other ID that ensures uniqueness on any server on which your extension of STSADM might be deployed. The XML declaration should read simply <?xml version="1.0" encoding="utf-8" ?>. The top-level element is <commands></commands>.

For each custom STSADM operation you created—that is, each possible value of the command parameter of GetHelpMessage and Run—add a <command/> element (inside the <commands> element) to your stsadmcommands file with the following syntax. (See the following example.) Change the version and culture values as needed.

<commands>

    <command 

        name="command_name" 

        class="fully_qualified_class_name, assembly_name, 

        Version=1.0.0.0, 

        Culture=neutral, 

        PublicKeyToken=value"/>

    <!-- other command elements, if any -->

</commands>

Replace command_name, fully_qualified_class_name, and assembly_name with the appropriate values. (Do not include the ".dll" extension on the assembly name.)
Replace value with the public key token for your assembly which you obtain with these steps.
1. Right-click your assembly in the global assembly cache and select Properties.
2. On the General tab, copy the Public Key Token value.
3. Paste it as the value for PublicKeyToken.
Copy the stsadmcommands.uniqueID.xml file to C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\CONFIG.

Example

The following example shows the *.cs file and, below that, the stsadmcommands.uniqueID.xml file for a custom STSADM operation, called enumfeatures, that will list the features at a site.

using System;

using System.Collections.Specialized;

using System.Text;

using Microsoft.SharePoint;

using Microsoft.SharePoint.StsAdmin;



namespace MS.Samples.SharePoint

{

    public class SimpleCommandHandler : ISPStsadmCommand

    {

        public string GetHelpMessage(string command)

        {

            return "-url <full url to a site in SharePoint>";

        }



        public int Run(string command, StringDictionary keyValues, out string output)

        {

            command = command.ToLowerInvariant();



            switch (command)

            {

                case "enumfeatures":

                    return this.EnumerateFeatures(keyValues, out output);



                default:

                    throw new InvalidOperationException();

            }

        }



        private int EnumerateFeatures(StringDictionary keyValues, out string output)

        {

            if (!keyValues.ContainsKey("url"))

            {

                throw new InvalidOperationException("The url parameter was not specified.");

            }



            String url = keyValues["url"];



            SPFeatureCollection features = null;

            SPWeb web = null;



            try

            {

                SPSite site = new SPSite(url);



                web = site.OpenWeb();



                features = web.Features;

            }

            catch (Exception e)

            {

                throw new InvalidOperationException("Error retrieving url '" + url + "'.  Please check the format of your url, and ensure that the site exists.  Details: " + e.Message);

            }



            StringBuilder sb = new StringBuilder();



            sb.AppendLine("Features at '" + web.Url + "':\n");



            foreach (SPFeature feature in features)

            {

                sb.AppendLine(feature.Definition.DisplayName + " (" + feature.DefinitionId + ")");

            }

            

            output = sb.ToString();



            return 0;

        }

    }

}

Workaround for Double Hop issue

2009-11-13T13:51:00.000-08:00

public class UnImpersonator : IDisposable
    {
        [DllImport("advapi32.dll")]
        private static extern int RevertToSelf();

        private WindowsIdentity connectedUser = null;

        public UnImpersonator()
        {
            connectedUser = WindowsIdentity.GetCurrent();
            RevertToSelf();
        }

        void IDisposable.Dispose()
        {
            connectedUser.Impersonate();
        }
    }

//Sample Usage

protected void Page_Load(object sender, EventArgs e)
        {

            if (!IsPostBack)
            {
                using (new UnImpersonator())
                {
                    SqlConnection cn = new SqlConnection("Data Source=servername;Initial Catalog=Employee;Integrated Security=true;");
                    SqlCommand cm = new SqlCommand("select empid,empname from employee", cn);
                    cn.Open();
                    ddlEmployee.DataSource = cm.ExecuteReader();
                    ddlEmployee.DataTextField = "empname";
                    ddlEmployee.DataValueField = "empid";
                    ddlEmployee.DataBind();
                    cn.Close();
                    cn.Dispose();
                }
            }

        }

ListFieldIterator Control to render the sharepoint fields the way you want.

2009-11-09T19:12:00.001-08:00

This control renders each field in a list item with an appropriate control. A single line text field will be rendered as a text box while a lookup field will be rendered as combo box. This control resides in the Microsoft.SharePoint.WebControls namespace of the Microsoft.SharePoint.dll.

In its simplest way you can declare the control as follows:

<spuc:ListFieldIterator ID="TestListFieldIterator" runat="server"

                        ControlMode="Edit" ListId="{e2886b6e-4d63-4063-a02c-eac7fb3aef79}" />

This renders the first list item as follows:

You can also set the ControlMode attribut to Display which renders the list item as follows:

If the control mode is set to New, empty controls are shown.

The way a choice field is rendered depends on the definition of the column. If you opted for a dropdown list when you created the column, the field is rendered as a dropdown. If you opted for check boxes for multi selection, the field is rendered as a list of check boxes:

You can set different properties of the ListFieldIterator control:

ListId: This property must contain the id – which is a Guid - of the list you want to display.
ControlMode: Defines whether the controls are displayed in display mode, edit mode or new mode.
ExcludeFields: Specify the fields that don’t need to be rendered. Separate each field with ;#
Item: In code behind, you can retrieve the current list item by using this property.
ItemId: in code behind, you can retrieve the id of the current list item. But you can also decide which item to render by setting this attribute declaratively.

<spuc:ListFieldIterator ID="TestListFieldIterator" runat="server"

            ControlMode="Edit" ListId="{e2886b6e-4d63-4063-a02c-eac7fb3aef79}" ItemId="2" />

List: In code behind, you can retrieve the current list by using this property.
Template: you can set this property if you have deployed your own custom template to the 12\TEMPLATE\CONTROLTEMPLATES folder.

If you first add one or more controls to render fields from the list, and then add a ListFieldIterator control, it will automatically detect the fields already rendered and will not render them anymore. This can be useful if you want to change the order in which the controls must appear, or even more if you want to change the standard rendering of one or more fields (f.e. if you want to render one of the fields using Silverlight ).

<spuc:RichTextField ID="ContactTextField" runat="server"  

      ControlMode="Edit" ListId="{e2886b6e-4d63-4063-a02c-eac7fb3aef79}" FieldName="Description"/>



<spuc:ListFieldIterator ID="TestListFieldIterator" runat="server"

      ControlMode="Edit" ListId="{e2886b6e-4d63-4063-a02c-eac7fb3aef79}" />

This does not count for controls added AFTER the ListFieldIterator control.

Don’t forget to add a page directive in order to be able to use the control:

<%@ Register TagPrefix="spuc" Namespace="Microsoft.SharePoint.WebControls"

             Assembly="Microsoft.SharePoint, Version=12.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

You can use this control in web parts and application pages but in general it is used in custom list definitions. When creating a custom list definition, the columns of the list will be rendered in a standard DisplayForm, NewForm and EditForm. If this standard rendering behavior does not satisfy your needs you can develop your own custom control templates. They need to be deployed in the 12\TEMPLATE\CONTROLTEMPLATES directory and need to be referenced in Forms element of the schema.xml of the custom list definition:

<Forms>

    <Form Type="DisplayForm" Url="DispForm.aspx" SetupPath="pages\form.aspx"  WebPartZoneID="Main"/>

    <Form Type="EditForm" Url="EditForm.aspx" SetupPath="pages\form.aspx" Template="CustomersForm" WebPartZoneID="Main"/>

    <Form Type="NewForm" Url="NewForm.aspx" SetupPath="pages\form.aspx" Template="CustomersForm" WebPartZoneID="Main"/>

</Forms>

The Template attribute must contain the name of the template that is defined in an ascx control deployed in the 12\TEMPLATE\CONTROLTEMPLATES folder.

Some Important Links

2009-11-06T20:05:00.000-08:00

http://techtrainingnotes.blogspot.com/2008/02/sharepoint-hiding-menus-not-using.html

Add Custom Actions to UI

Default Custom Action Locations and IDs

Content Types

Hide Multiple Upload menu from a Document Library

2009-11-03T21:12:00.000-08:00

Use this javascript

<script language="JavaScript">
_spBodyOnLoadFunctionNames.push("HideNewIcons");
function HideNewIcons()
{
var doc = document.getElementsByTagName('ie:menuitem');
for(var i=0;i<doc.length;i++)
{
if(doc(i).id.match('MultipleUpload'))
{
doc(i).style.visibility="hidden";
}
}
}
</script>