SharePoint 2010: Configuring incoming emails on a Production Environment (non-Exchange Server)

September 17, 2012 1 comment

Recently I needed to setup incoming emails on a SharePoint 2010 site sadly, after researching this subject a lot, I was not able to find a blog that provided a complete answer of how to set this up on a Production Environment. There are some variations in the way this can be setup but the method I will be explaining in this blog involves a non-Exchange Server method.

Assumptions

I am assuming that:

  • You have setup an SMTP server on one of your SharePoint WFE’s (Web Front End) if you are not sure on how to do this then please check out this post.
  • You have a domain name registered and that you can modify the DNS records

The Solution

The solution involves:

  • Setting up the DNS Records
  • Configuring the SMTP Server
  • Configuring Central Administration
  • Configuring a SharePoint List

Setting up the DNS Records

In this example I am using a domain name: http://www.shareheaven.co.uk that is registered with GoDaddy.com.

Login to your domain name’s control panel and add a DNS A (Host) record in the following format:

Setting up a DNS A (Host) Record

Where the host (‘notify’ in this example) can be anything of your liking. The IP address should be the IP address of the server that hosts the SMTP Server.

Next we need to add a DNS MX Record in the following format:

Setting up the MX Record

Wait for the DNS changes to take effect, you can use this website to check if the changes have taken effect.

Configuring the SMTP Server

On the SMTP Server we will need to add an alias. Open IIS 6.0 Manager > Expand your SMTP Server in the list on the left hand side > Right click on ‘Domains’ > New > Domains.

SMTP Alias Setup

On this screen (screen shot above) select Alias and click Next and then fill it out as below (based on your domain name):

Creating an alias

Configuring Central Administration

Next we need to setup Central Administration to enable incoming emails in our SharePoint Farm, in Central Admin browse to System Settings > Configure incoming e-mail settings and set it up as below:

Central Administration Setup

Configuring a SharePoint List

Finally, we can now setup a SharePoint List to receive incoming emails. In this example I will be setting up a Document Library to receive incoming emails. Browse to Library Settings > Incoming e-mail settings of the SharePoint List you would like to setup to receive incoming emails. Fill out the form as below and click ‘OK’:

Configure the SharePoint List

Testing the Solution

To test the solution send an email to the email address we setup to receieve incoming emails which in our example was: test@shareheaven.co.uk (replace shareheaven with your domain name of course!):

Sending the email

Screen shot below shows the .eml file arriving in the drop folder of the SMTP Server:

Mail drop folder

A SharePoint Timer Job picks up this email, processes it and then adds an item in the Document Library:

Document Library Item Added

Advertisements
Categories: SharePoint 2010 Tags: , , , , , , , , , , ,

Archiving documents in SharePoint 2010 OTB

September 13, 2012 1 comment

There might be other ways of setting this up but I thought I should write about a way of achieving this by purely utilising SharePoint 2010 out-of-the-box features.

Scenario

You have a document library, we will call it Documents, that has a custom Content Type (we will call it ER Documents). Based on a certain criteria, lets say 6 months after a document has been approved, you would like to archive the document by moving it to another document library called ‘ER Compliance Archived Documents’.

Assumptions

You have two identical document libraries setup with the same content type enabled.

The Solution

The solution involves:

  • Enabling the Content Organizer Feature
  • Creating a Content Organizer Rule
  • Configuring a ‘send to’ connection
  • Configuring the Document Library

Enabling the Content Organizer Feature

On the root web of your Site Collection browse to Site Actions > Site Settings > Manage Site Features and activate the ‘Content Organizer’ Feature.

After this feature is activated you will notice two new options in Site Settings (highlighted in the screenshot below) and a new document library called ‘Drop Off Library’:

Content Organizor Options

Click on ‘Content Organizer Settings’ and make a note of the Web Service URL:

Web Service URL

Creating a Content Organizer Rule

Click on the ‘Content Organizer Rules’ link and add a new item to create a new rule and set it up as below (click on the image if it appears a bit blurred):

Content organizer rule

This rule basically specifies where and how to route the archived documents.

Configuring a ‘send to’ connection

Browse to Central Administration > General Application Settings > Configure send to connections. Select the correct Web Application and create a new send to connection by filling out the form as below pasting the Web Service URL you copied earlier:

Send To Connection

Click on ‘Add Connection’ and then ‘OK’.

Configuring the Document Library

Browse to the main ‘Documents’ document library > Library Settings > Information management policy settings > ER Documents (this is our content type) > Check ‘Enable Retention’ and fill the form out as below:

Enable Retention

Testing the solution

Add a document that matches the archiving criteria (i.e. Approval Date more than 6 months ago).

Go to Central Administration > Monitoring > Review job definitions > select your Web Application and manually run the ‘Information management policy’ timer job. This job process and marks the documents, that match the criteria we have setup, for transfer. After the job has completed manually run the ‘Expiration policy’ timer job this timer job does the actual transfer of the marked documents.

After this the relevant documents that match the Information management policy criteria will be moved to the archived library.

You can also test this manually by browsing to the ‘Documents’ document library> Accessing the context menu > Send to > ER Compliance Archive (screenshot below).

Manually archive document

The document should then appear in the archive document library. Please note that the manual send to method moves the document immediately but it is a useful way of testing whether you have configured the routing correctly.

Categories: MOSS 2007, SharePoint, SharePoint 2010 Tags: , , , , , , , , , , , , ,

SharePoint 2010: Basic List search / filter WebPart

April 19, 2012 89 comments

I have created a very simple SharePoint list search / filter WebPart which was inspired by the following blog post. This WebPart allows you to search records in a list where a selected field contains a specified text. It is useful in scenarios where you dont have SharePoint Search setup and just need a simple way of performing some search operations in a SharePoint List.

Adding the web part to SharePoint List View

Simply drop this web part on top of a page that contains a SharePoint View and it will allow you to apply a very simple search criteria.

The screenshot below shows the WebPart in action:

Main view of the List Search WebPart

The field name DropDownList allows you to select from the fields that are present in the view. Once you select the field and add the text to search by, the relevant results are displayed:

Screenshot showing search results

You can also specify multiple text values by seperating the text with a semi-colon (;):

Screenshot showing search results, multiple text criteria

In the above example the specified criteria will display all the records where the manufacturer’s name contains ‘Honda’ OR ‘Audi’. The screenshot below shows the pagination working as expected:

Screenshot showing search results, multiple text criteria

Adding the web part to a page with an XsltListViewWebPart

You can also add this web part to a page that contains an XsltListViewWebPart. The web part will automatically detect that it has been added to a page (rather than a List View) and display a message asking you to select an XsltListViewWebPart that you would like to apply the filters to:

The screen shot below shows how to select the XsltListViewWebPart:

You can download the solution by clicking on the link below:

SharePoint WSP Download link

You can view the codeplex project site by clicking on the link below:

Codeplex Project Site

Please note that this is setup as a Farm Solution and not a Sandboxed Solution therefore it will not work if you deploy it to the SharePoint Solutions Gallery, you need to deploy the SharePoint Solution via Central Administration, via stsadm commands or via PowerShell commands.

How to it works

On a page that contains a ListViewWebPart you can apply filter by adding a couple of query strings:

  • FilterName
  • FilterMultiValue

In our example, when a user types ‘honda’ and then clicks on the search button we simply append ‘?FilterName=LinkTitle&FilterMultiValue=*honda*;’ to the query string and redirect the user to that page. Please note that ‘LinkTitle’ is the internal name of the ‘Manufacturer’ field.

The * in the *honda* is used to do a wildcard search (contains). If you would like to search for multiple texts you can seperate them by a semi-colon for example ‘FilterMultiValue=*honda*;*audi*;’ will search for records where the ‘Manufacturer’ name either contains ‘honda’ or ‘audi’. If you would like to search for an exact match rather than apply a contains filter then simply remove the *’s from the filter value text.

Although, this WebPart does not allow you to filter / search by more than one field this is very much possible. To apply filters on additional fields you simply need to append ‘FilterField1=Model&FilterValue1=Accord’ to the URL. You can apply further filters by incrementing the number i.e. FilterField2, FilterField3 …. and so on. I am not sure if there is a limit on this.

Please note that I haven’t found a way to get the wildcard search to work with this (multiple filters) approach.

Building the WebPart

In your Visual Studio solution (assuming you have created a Blank SharePoint Project) add a ‘Visual WebPart’. A Visual WebPart loads a UserControl that contains most of the code. Below is the code of the .ascx file:

<%@ Assembly Name="$SharePoint.Project.AssemblyFullName$" %>
<%@ Assembly Name="Microsoft.Web.CommandUI, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register TagPrefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls"
    Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register TagPrefix="Utilities" Namespace="Microsoft.SharePoint.Utilities" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Register TagPrefix="asp" Namespace="System.Web.UI" Assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" %>
<%@ Import Namespace="Microsoft.SharePoint" %>
<%@ Register TagPrefix="WebPartPages" Namespace="Microsoft.SharePoint.WebPartPages"
    Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>
<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="ListSearchUserControl.ascx.cs"
    Inherits="Exaction.ListSearch.WebParts.ListSearch.ListSearchUserControl" %>
<script type="text/javascript" src="/_layouts/Exaction.ListSearch.Javascripts/jquery.min.js"></script>
<table>
    <tr>
        <td>
            <strong>Search Criteria:</strong>
        </td>
        <td>
            <asp:TextBox ID="TbSearchText" runat="server" Width="300px"></asp:TextBox>
        </td>
        <td>
            &nbsp;
        </td>
        <td>
            <strong>Field name:</strong>
        </td>
        <td>
            <asp:DropDownList ID="DdlListFields" runat="server">
            </asp:DropDownList>
        </td>
        <td>
            &nbsp;
        </td>
        <td>
            <div align="right">
                <asp:Button ID="BtnSearch" runat="server" OnClick="BtnSearch_Click" Text="Search" />
                <asp:Button ID="BtnClearFilter" runat="server" Visible="false" OnClick="BtnClearFilter_Click"
                    Text="Clear Criteria" />
            </div>
        </td>
    </tr>
</table>
<script type="text/javascript">
    $(document).ready(function () {
        var base_RefreshPageTo = RefreshPageTo;
        RefreshPageTo = function (event, url) {

            var filterName = getQuerystring('FilterName');
            var filterValue = getQuerystring('FilterMultiValue');
            var newUrl = url + '&FilterName=' + filterName + '&FilterMultiValue=' + filterValue;
            if (filterName != '' && filterValue != '') {
                base_RefreshPageTo(event, newUrl);
            }
            else {
                base_RefreshPageTo(event, url);
            }
            return;
        }
    });
    function getQuerystring(key, default_) {
        if (default_ == null) default_ = "";
        key = key.replace(/[\[]/, "\\\[").replace(/[\]]/, "\\\]");
        var regex = new RegExp("[\\?&]" + key + "=([^&#]*)");
        var qs = regex.exec(window.location.href);
        if (qs == null)
            return default_;
        else
            return qs[1];
    }
</script>

The code above is pretty self-explanatory but very briefly it contains the UI elements (TextBox, Labels, DropDownList and Buttons) and some jQuery. The jQuery code overrides the ‘RefreshPageTo’ SharePoint javascript function. This is basically to get our filtering to work with pagination. If you have a SharePoint List View that is displaying paginated date to you then clicking on the next or previous page calls the ‘RefreshPageTo’ JavaScript function. The problem is that when this function is called it clears the querystrings we use to filter the data. To ensure that the filtering is maintained we override this function, modify the URL ensuring the filtering querystrings are present and then pass it in as the second parameter to the function.

using System;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Collections.Specialized;
using Microsoft.SharePoint;
using System.Collections.Generic;
using Exaction.ListSearch.UI.Entities;
using System.Text;

namespace Exaction.ListSearch.WebParts.ListSearch
{

    /// <summary>
    /// User control that deals with the registration process
    /// </summary>
    public partial class ListSearchUserControl : UserControl
    {

        /// <summary>
        /// Gets the share point list field items.
        /// </summary>
        /// <param name="filterCriteria">The filter criteria.</param>
        private List<OptionEntity> GetSharePointListFieldItems()
        {
            List<OptionEntity> fieldItems = new List<OptionEntity>();
            fieldItems = new List<OptionEntity>();
            OptionEntity item;
            SPField field;
            StringCollection viewFieldCollection = SPContext.Current.ViewContext.View.ViewFields.ToStringCollection();
            foreach (string viewField in viewFieldCollection)
            {
                field = SPContext.Current.List.Fields.GetFieldByInternalName(viewField);
                item = new OptionEntity();
                item.Id = field.InternalName;
                item.Title = field.Title;
                fieldItems.Add(item);
            }
            return fieldItems;
        }
        protected override void CreateChildControls()
        {
            base.CreateChildControls();
            List<OptionEntity> items = GetSharePointListFieldItems();
            DdlListFields.DataSource = items;
            DdlListFields.DataTextField = "Title";
            DdlListFields.DataValueField = "Id";
            DdlListFields.DataBind();
        }
        /// <summary>
        /// Raises the <see cref="E:System.Web.UI.Control.Load"/> event.
        /// </summary>
        /// <param name="e">The <see cref="T:System.EventArgs"/> object that contains the event data.</param>
        protected override void  OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            if (!IsPostBack)
            {
                if (Request.QueryString["FilterName"] != null)
                {
                    DdlListFields.SelectedValue = Request.QueryString["FilterName"].ToString();
                }

                if (Request.QueryString["FilterMultiValue"] != null)
                {
                    TbSearchText.Text = Request.QueryString["FilterMultiValue"].ToString().Replace("*", "");
                    BtnClearFilter.Visible = true;
                }
            }
        }
        /// <summary>
        /// Handles the Click event of the BtnSearch control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        protected void BtnSearch_Click(object sender, EventArgs e)
        {
            string redirectUrlFormat = "{0}?FilterName={1}&FilterMultiValue={2}";
            string[] selectionCollection = TbSearchText.Text.ToString().Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
            StringBuilder sbValues = new StringBuilder();
            foreach (string selection in selectionCollection)
            {
                sbValues.Append("*" + selection.Trim() + "*;");
            }

            string urlToRedirectTo = string.Format(redirectUrlFormat, Request.Url.GetLeftPart(UriPartial.Path), DdlListFields.SelectedValue, sbValues.ToString());
            Response.Redirect(urlToRedirectTo);
        }
        /// <summary>
        /// Handles the Click event of the BtnClearFilter control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        protected void BtnClearFilter_Click(object sender, EventArgs e)
        {
            Response.Redirect(Request.Url.GetLeftPart(UriPartial.Path));
        }
    }
}

The code behind above initialises the controls and handles the Search and Clear Search Criteria Button click events.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Exaction.ListSearch.UI.Entities
{
    public class OptionEntity
    {
        #region "Fields"
        public string Id { get; set; }
        /// <summary>
        /// Gets or sets the title.
        /// </summary>
        /// <value>The title.</value>
        public string Title { get; set; }
        #endregion

        #region "Constructor"
        public OptionEntity()
        {
        }
        #endregion
    }
}

We set a collection of the OptionEntity items as the DataSource of the Field name DropDownList.

That is basically it. In this simple manner you have a WebPart that you can drop on top of any List View and apply some basic free text Filterting.

Known issues

There are two minor known issues which I haven’t found a solution for yet:

  • Adding the WebPart on top of the page of a List View takes the focus away from the ListViewWebPart which in turn hides the ribbon. Once you click on the ListViewWebPart and focus on it then the ribbon becomes visible.
  • This WebPart does not work properly with Views that use groupings that are collapsed by default, it works if the groupings are expanded by default
  • As pointed out by Goran (see comments) it might not work with External SharePoint Lists

I hope you find this WebPart useful. Please post your comments and feedback and it would be helpful if you can rate this post.

Categories: C#, MOSS 2007, SharePoint, SharePoint 2010 Tags: , , , , , , , , ,

SharePoint 2010 FBA: Enable search by part or full name in People Picker

March 18, 2012 4 comments

 
Please refer to this post of mine on how to configure Forms Based Authentication (FBA) on a SharePoint Web Application using ASP.NET SQL Membership Provider.

After you setup FBA the People Picker control by default will only search for user’s by using the username. However, if you would like to search for users by part or full display name then you will need to carry out the following changes to the Membership Database:

  • Add a column “ProfileNames” of type nvarchar(255) in the table: aspnet_Users
  • Update the stored procedure: aspnet_Membership_FindUsersByName by replacing the following where clause: 
    WHERE  u.ApplicationId = @ApplicationId AND m.UserId = u.UserId AND u.LoweredUserName LIKE LOWER(@UserNameToMatch)

    with:
     

    WHERE  u.ApplicationId = @ApplicationId AND m.UserId = u.UserId AND u.ProfileNames LIKE '%' + LOWER(@UserNameToMatch) + '%'
  • Create the following Trigger on the “aspnet_Profile” table: 
    CREATE TRIGGER [dbo].[ProfileProperty_Trigger] 
   ON   [dbo].[aspnet_Profile] 
   AFTER INSERT,UPDATE
AS 
BEGIN
SET NOCOUNT ON;
DECLARE @Names nvarchar(50)
DECLARE @UID nvarchar(50)

SELECT 
@Names = p.PropertyValuesString,
@UID = p.UserId
FROM aspnet_Profile p
INNER JOIN inserted i
ON p.UserId = i.UserId

UPDATE aspnet_Users SET ProfileNames = @Names WHERE aspnet_Users.UserId = @UID
END
      •  
      That is it, after making these changes the People Picker control should now match by username as well as display name.

Categories: SharePoint 2010 Tags: , , , , , , , , , , ,

SharePoint 2010: Limit People Picker to search only FBA Users

March 16, 2012 5 comments

 
Please refer to this post of mine on how to configure Forms Based Authentication (FBA) on a SharePoint Web Application.

Consider the following scenario:

You have configured FBA on a Web Application and created a Site Collection that uses FBA. Your Web Application uses mixed mode authentication (FBA and Windows Authentication). When you search for users in People Picker it shows you matches for both FBA and AD users. You would like to restrict People Picker to only show matches for FBA Users.

You can achieve this by running the following stsadm command:

stsadm -o setproperty -pn peoplepicker-onlysearchwithinsitecollection -url http://www.nameOfMySiteCollection.co.uk/ -pv yes

The ‘peoplepicker-onlysearchwithinsitecollection’ part in there is misleading and doesnt really do what it implies, however, it does get rid of the AD user mataches from People Picker.

Before running the stsadm command:
 
People picker showing AD users
 
People picker showing AD users
 
After running the stsadm command:
 
People Picker after running stsadm command
 
People Picker after running stsadm

Please note that if you type in the full username of an AD user and click on the Check Names icon it will still resolve the user.

Categories: SharePoint 2010 Tags: , , , , , , , , , , , , ,

SharePoint 2010: Setting up Form Based Authentication (FBA) using ASP.NET SQL Membership Provider

March 16, 2012 7 comments

 
There are a few different ways of setting up Forms Based Authentication on a Web Application using ASP.NET SQL Membership as the Provider and in this post I will explain the approach I have used time and time again over the years. Please note that the method I use involves modifying the config files manually, however, there is another approach where this is done purely via IIS which I plan to blog about some time in the future.

We can break down the setup process into 7 steps (I am assuming here that we are setting it all up from scratch):

  • Create the new Web Application
  • Set up the Membership Database
  • Modify the Web Application Web.config
  • Modify the Web.Config of the Central Admin
  • Modify the Web.Config of the STS (Security Token Service) Application
  • Add a new .NET User
  • Create the new Site Collection

1         Create the new Web Application

Go to Central Administration and create a new Web Application. Use the following information to create the Web Application:

  • For Authentication select ‘Claims Based’
  • Claims Authentication Types
    • Uncheck ‘Enable Windows Authentication’ (optional: if you purely want to use FBA)
    • Check ‘Enable Forms Based Authentication (FBA)
      • ASP.NET Membership provider name: MyMembershipProvider
      • ASP.NET Role manager name : MyRoleProvider

Fill out the rest of the form as per your requirement and create the Web Application.

Please note that the Membership provider and Role Manager names used above are just examples and you can name them according to your requirements.
 

2         Setup the Membership Database

Carry out the following steps to create the membership database:

  1. Go to C:\Windows\Microsoft.NET\Framework64\v2.0.50727 and run “aspnet_regsql.exe”
  2. Select “Configure SQL Server for Application Services”

    3. Creating the Membership Database

  3. Choose Windows Authentication
  4. Specify the Database name, this can be anything in our example we will use ‘MyWebAppUsers’

    5. Creating the Membership Database

To ensure form based authentication works smoothly it is important that the application pool identity account of SharePoint Central Admin, The Web Application we created above and the SecurityTokenServiceApplication have the appropriate rights on the Membership database (MyWebAppUsers). I usually grant them db_owner rights.
 

3         Modify the Web Application Web.Config

Add the following element after the </sharePoint> and before the <system.web> element as below and change the value of ‘DbServername’ with the relevant database server name:

<connectionStrings>
  <add name="MyDbConnectionString" connectionString="data source=DbServername;Integrated Security=SSPI;Initial Catalog=MyWebAppUsers" providerName="System.Data.SqlClient" />
</connectionStrings>

Find the <membership> element and add your own provider as below:

<membership defaultProvider="i">
<providers>
.....
<add name="MyMembershipProvider" type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" connectionStringName="MyDbConnectionString" enablePasswordReset="false" enablePasswordRetrieval="true" passwordFormat="Clear" requiresQuestionAndAnswer="false" requiresUniqueEmail="false" applicationName="/" />
</providers>
</membership>

Find the < roleManager> element and add your own provider as below:

<roleManager cacheRolesInCookie="false" defaultProvider="c" enabled="true">
<providers>
   ......
   <add name="MyRoleProvider" type="System.Web.Security.SqlRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" applicationName="/" connectionStringName="MyDbConnectionString" />
</providers>
</roleManager>

Locate the <PeoplePickerWildcards> element and add the following element as below:

<PeoplePickerWildcards>
   ......
   <add Key="MyMembershipProvider" value="*" />
</PeoplePickerWildcards>

This enables partial matches when you type in a username in a people picker control. Without this a user will only be matched if you type the exact username. We are basically telling SharePoint here the character to use (asterisk) to do the wilcard search in SQL.

4         Modify the Web.Config of the Central Admin

Add the following after </sharePoint> and before <system.web> element replacing ‘DbServername’ with the relevant database server name.

<connectionStrings>
<add name="MyDbConnectionString" connectionString="data source=DbServername;Integrated Security=SSPI;Initial Catalog=MyWebAppUsers" providerName="System.Data.SqlClient" />
</connectionStrings>

Find the element <membership> and add your own provider as below:

<membership defaultProvider="MyMembershipProvider">
<providers>
   .......
   <add name="MyMembershipProvider" type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" applicationName="/" connectionStringName="MyDbConnectionString" enablePasswordReset="true" enablePasswordRetrieval="true" passwordFormat="Clear" requiresQuestionAndAnswer="false" requiresUniqueEmail="false" />
</providers>
</membership>

Find the element <roleManager> and add your own provider as below:

<roleManager defaultProvider="AspNetWindowsTokenRoleProvider" enabled="true" cacheRolesInCookie="false">
<providers>
 ......
 <add name="MyRoleProvider" type="System.Web.Security.SqlRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" applicationName="/" connectionStringName="MyDbConnectionString" />
</providers>
</roleManager>

Locate the <PeoplePickerWildcards> element and add the following element as below:

<PeoplePickerWildcards>
<clear />
   ......
   <add Key="MyMembershipProvider" value="*" />
</PeoplePickerWildcards>

 

5         Modify the Web.Config of the STS Application

Go to the root directory of the “SecurityTokenServiceApplication” which is typically located at: “C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\WebServices\SecurityToken” and open the web.config.

Just before the </configuration> element add the following ensuring you change the database server name to match the details of your database server.

  <connectionStrings>
    <add connectionString="Integrated Security=SSPI;Persist Security Info=False;Initial Catalog=MyWebAppUsers;Data Source=DbServername" name="MyDbConnectionString" providerName="System.Data.SqlClient" />
  </connectionStrings>
    <system.web>
      <membership defaultProvider="i">
            <providers>
                <add name="i" type="Microsoft.SharePoint.Administration.Claims.SPClaimsAuthMembershipProvider, Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" />
                <add name="MyMembershipProvider" type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" connectionStringName="MyDbConnectionString" enablePasswordReset="true" enablePasswordRetrieval="true" passwordFormat="Clear" requiresQuestionAndAnswer="false" requiresUniqueEmail="false" applicationName="/" />
            </providers>
        </membership>
      <roleManager defaultProvider="c" enabled="true" cacheRolesInCookie="false">
        <providers>
                <add name="c" type="Microsoft.SharePoint.Administration.Claims.SPClaimsAuthRoleProvider, Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" />
                <add name="MyRoleProvider" type="System.Web.Security.SqlRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" applicationName="/" connectionStringName="MyDbConnectionString" />
            </providers>
        </roleManager>
    </system.web>

Please note that I am making the assumption here that you dont have any other Web Applications in your farm with FBA enabled, if you do then a lot of these elements will already exist and all you need to do is to add the relevant parts from above to the relevant elements.
 

6         Add a new .NET User

Now we need to add a user that we will use to login to the FBA site. To do this we need to carry out the following steps:

  • Open up IIS (Start > Run > type inetmgr)
  • Select the SharePoint Central Administration v4 site from the list of sites
  • Double click on .NET Users from the right hand side (as in the screeshot below).

    • Add .NET user

  • From the actions menu on the right click on ‘Set Default Provider’ and select ‘MyMembershipProvider’ from the DropDownList (or whatever name you used to name the MembershipProvider)
  • From the actions menu click on ‘Add’ and fill out the form (screenshot below)

    • Adding a new .NET user

  • After adding the user reset the Default Provider to what it was originally

 

7         Create the new Site Collection

Create a new Site Collection under the Web Application we created in step 1 and set the user we created in step 6 as the Site Collection Administrator (screenshot below).

Adding a new .NET user

Once the Site Collection is created successfully, browse to it and login using the credentials of the user we created in step 6.

Login to the newly created Site Collection

Thats it! We have now successfully setup Forms Based Authentication on our Web Application.

Categories: SharePoint 2010 Tags: , , , , , , ,