SharePoint - notes from the field

How to Check if SPGroup Exists

LEONID LYUBLINSKI — Thu, 11 Jun 2009 18:24:04 GMT

The SharePoint API lacks methods to check for the security group existence. Here is utilities that do the job:

public static bool GroupExists(SPGroupCollection groups, string name)

{

if (string.IsNullOrEmpty(name) ||

(name.Length > 255) ||

(groups == null) ||

(groups.Count == 0))

return false;

else

return (groups.GetCollection(new String[] { name }).Count > 0);

}

public static bool GroupExists(SPGroupCollection groups, int id)

{

if ((id < 0) ||

(groups == null) ||

(groups.Count == 0))

return false;

else

return (groups.GetCollection(new Int32[] { id }).Count > 0);

}

How to be in sync with Lookup when it changes

LEONID LYUBLINSKI — Fri, 29 May 2009 23:07:03 GMT

One of the biggest puzles of inconsistency is keeping a page that using Lookup column uptodate to all the changes that happened to underlying list. Image you have a web page in a Documents library. That page has a column say Type which is a lookup to a list Types below.

ID	Type
1	Document
2	Article
3	Podcast

Imagine you’ve chosen a Podcast for a type. Then, later on you’ve changed the “Podacst” value in theTypes to “Webcast”. The problem is that you page still thinks that its type is “Podcast”. Furthermore, the pagae isn’t updated speaking of its LastDateModfied property. The incremental crawler will not even include the page, and full crawl will extract the same “Podcast” value.

ID	Type
1	Document
2	Article
3	Webcast

if you dig deep enough you’ll see that it’s a problem with the ItemFieldValue implementation of the lookup field. When the value changed, it is persisted on the Field level but not persisted in the ListItem scope. Knowing this helps to find a way out.

So, how do you make sure that the search gets the correct values for lookups. Obviously, we don’t want to browse all the pages to update them.
Here is the elegant solutiuon. Have a batch or custom action on the list that updates the list itself. You’ll have to use SystemUpdate() on the list item to avoid LastModified stamp changed.

Here is the whole class that makes the job. Enjoy!

using System;

using System.Collections;

using System.Collections.Specialized;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Reflection;

using System.Linq;

using System.Text;

using System.Globalization;

using System.Web.UI;

using System.Web.UI.WebControls;

using Microsoft.SharePoint.WebControls;

using Microsoft.SharePoint;

using Microsoft.SharePoint.Utilities;

namespace LookupUpdater

{

/// <summary>

/// Utility serves the purpose of updating the SharePoint list or library to refresh all Lookups .

/// </summary>

/// <owner alias="leonidly"></owner>

internal sealed class MetatagHelper

{

#region Methods

/// <summary>

/// Updates the list checking all list items and all fields

/// </summary>

/// <param name="siteUrl">Url to the site</param>

/// <param name="listName">Name of the list or library</param>

public static void Update(string siteUrl, string listName)

{

WriteMessage("Updating Lookup values in {0} at {1} ...", listName, siteUrl);

try

{

using (SPSite rootSite = new SPSite(siteUrl))

{

Uri uri = new Uri(siteUrl);

using (SPWeb web = rootSite.OpenWeb(uri.AbsolutePath, false))

{

SPList targetList = web.Lists[listName];

if (targetList.ItemCount > 0)

{

bool listUpdated = false; // flag to update the list / library

foreach (SPField field in targetList.Fields)

{

SPFieldLookup fieldLookup = field as SPFieldLookup;

if (fieldLookup == null) continue;

if (fieldLookup.LookupField == null) continue; // no User lookups

if (fieldLookup.ReadOnlyField) continue;

if (fieldLookup.Hidden) continue;

WriteMessage("Processing field {0}", field.Title);

string internalName = fieldLookup.InternalName;

foreach (SPListItem item in targetList.Items) // looping all

{

if (item[internalName] is SPFieldLookupValueCollection)

{

SPFieldLookupValueCollection itemValues = item[internalName] as SPFieldLookupValueCollection;

bool itemChanged = false;

SPFieldLookupValueCollection colValues = new SPFieldLookupValueCollection();

foreach (SPFieldLookupValue itemValue in itemValues)

{

int lookupId = itemValue.LookupId;

string lookupValueSaved = itemValue.LookupValue;

string lookupValueCurrent = GetLookupValue(rootSite, fieldLookup, lookupId);

if (string.Compare(lookupValueSaved, lookupValueCurrent, CultureInfo.CurrentCulture, CompareOptions.None) > 0)

{

colValues.Add(itemValue);

item[internalName] = lookupValueCurrent;

itemChanged = true; // and flag list to update item

}

if (itemChanged)

{

item[internalName] = colValues;

item.SystemUpdate(); // updating the SPListItem

listUpdated = true; // and flag list to update list

WriteMessage("SPListItem {0} updated <multiple values>", item.Url);

}

else if (item[internalName] is String && item[internalName].ToString().Contains(SPFieldMultiChoiceValue.Delimiter))

{

SPFieldLookupValue itemValue = new SPFieldLookupValue(item[internalName].ToString());

int lookupId = itemValue.LookupId;

string lookupValueSaved = itemValue.LookupValue;

string lookupValueCurrent = GetLookupValue(rootSite, fieldLookup, lookupId);

if (string.Compare(lookupValueSaved, lookupValueCurrent, CultureInfo.CurrentCulture, CompareOptions.None) > 0)

{

item[internalName] = lookupValueCurrent;

item.SystemUpdate(); // updating the SPListItem

listUpdated = true; // and flag list to update

WriteMessage("SPListItem {0} updated", item.Url);

}

else continue;

}

if (listUpdated) // final touch: change the list LastModified date so crawler picks it up.

{

targetList.Update();

}

catch (Exception ex)

{

WriteMessage(ex.Message);

}

#endregion

#region Utility

/// <summary>

/// Returns lookup value for a given field and item

/// </summary>

/// <param name="site">SPSite</param>

/// <param name="field">SPFieldLookup</param>

/// <param name="id">int</param>

/// <returns>string</returns>

private static string GetLookupValue(SPSite site, SPFieldLookup field, int id)

{

using (SPWeb lookupWeb = site.OpenWeb(field.LookupWebId))

{

SPList lookupList = lookupWeb.Lists[new Guid(field.LookupList)];

SPField lookupField = lookupList.Fields[field.LookupField];

SPListItem lookupItem = lookupList.GetItemById(id);

object result = lookupItem[field.LookupField];

return (result != null) ? result.ToString() : null;

}

/// <summary>

/// Wrapper for logging messages

/// </summary>

/// <param name="msg"></param>

/// <param name="args"></param>

internal static void WriteMessage(string msg, params object[] args)

{

System.Console.WriteLine(msg, args);

}

#endregion

}

Faceted Search 3.0 – implementation of Search Suggestions

LEONID LYUBLINSKI — Fri, 01 May 2009 05:05:05 GMT

Background

MOSS Faceted Search provides search refinement to the SharePoint search. In September 2007 I’ve published 1.0 release as an open source on CodePlex. Since then the solution was successfully implemented by small businesses and Fortune 100 corporations in the US and by many companies around the globe.

The latest release of the Faceted Search on CodePlex just came in Version 3.0 Beta. Along with numerous enhancements this release offers:

o Full support of advanced search

o Support of range searches

o Built-in refinement of DateTime and Numeric facets

o A new 3-column layout for publishing

o A new Search Hint web part

In this post I will show the key design decisions and implementation of the Search Hint web part.

Introduction

Search Hint feature also known as search suggestions, popular searches, historical searches etc. by now is one of the must have features for any search engine. It allows the user to preview the most popular searches as the one type in the search criteria. Google, Live, Yahoo in one way or another are offering this functionality. The quest to have such done for SharePoint is still ongoing.

The fundamental challenges for the SharePoint implementation are:

where to get past searches from along with their counters
what to do with the MOSS out-of-the-box search box

Design

Where to get the data

In December 2008 Microsoft published SharePoint Products and Technologies Protocol Documents. The significance of this event is yet to be fully measured. As for the search suggestions, the [MS-SQLPQ]: Search Service Database Query Protocol Specification outlined the backend schema used by MOSS for storing the usage data. The Search Hint web part uses exactly that, MOSS natural data to provide search suggestions, using very own MOSS SQL artifacts.

As far as Faceted Search uses Enterprise Library for caching, logging and exception handling, the same design is in place for getting usage data from MOSS.

What to do with the Search Box

The Search Hint web part doesn’t replace MOSS Search Box. It is designed to be an invisible droplet. When dropped onto the page it is instructed to look around and detect the MOSS Search Box, assess its position and seamlessly attach the search suggestions to it.

Implementation

SQL query

The web part goes to the MOSS Shared Services database using SQL connection defined in the web.config. The T-SQL doesn’t have any direct clause STARTSWITH, so I build the dynamic query using following logic:

SELECT TOP {0} queryString, scope, numScopes, numQueries,
FROM ...
WHERE LEFT([queryString], ?) = ? ORDER BY ?

Parameters allow managing the number of records in 1 transaction, the match criteria along with the number of characters to match, and the sort order.

Finding Search Box

There are 2 ways in which Search Box exist on the page.

It can appear as a web part in one of the web part zones, e.g. on the search results page.

private static WebPart FindWebPartByType<T>(Page page)

{

WebPartManager wpm = WebPartManager.GetCurrentWebPartManager(page);

if (wpm == null) return null;

WebPartCollection wpc = wpm.WebParts;

foreach (WebPart wp in wpc)

{

if (wp is T) return wp;

}

return null;

}

The search box can be used as ASP.NET control outside web part zone, e.g. in the header of the .master pages.

private static Control FindControlByType<T>(Control control)

{

Control result = null;

foreach (Control ctrl in control.Controls)

{

if (ctrl is T)

return ctrl;

else

{

if (ctrl.HasControls())

{

result = FindControlByType<T>(ctrl);

if (result != null)

return result;

}

continue;

}

return result;

}

In either case the finder loops through all the artifacts comparing their types to Microsoft.SharePoint.Portal.WebControls.SearchBoxEx. When found, the web part extracts its ClientID and builds all the positioning in the HTML DOM.

After the Search Box found most of the action occurs on the client side. The control coordinates are extracted using getBoundingClientRect() method and the Search Hint panel is aligned to the search box.

Performance considerations

This functionality can be resource intensive. As such, the 1^st thing that was implemented is asynchronous processing of usage data. Implemented, as all over in Faceted Search, using ICallbackEventHandler interface.

Additionally, Search Hint tracks actual keywords while being typed by the user. If previously extracted usage data cover new keyword, no extra call to the server performed. Contrary, the search suggestions are extrapolated from the previously received data feed.

Imagine user searches for “sharepoint” and types “share”. The Search Hint requests all the matching to “share” previous searches, builds resulting table of them and display the polished outcome back to the user. User can choose one of the offered suggestions of course. Say the use keeps typing and produces “sharepo”. The Search Hint doesn’t interrogate the server again because “sharepo” is a subset to “share”. Instead, a very fast filtering of previous data feed occurs and the refined search suggestions are displayed.

Security notion

Getting data from the SQL server requires read permission on the tables. The Search Hint uses SPSecurity.RunWithElevatedPrivileges() wrapper which implies running the process under identity of the current app pool account. In tighten medium- or large- farm deployments, the account in question should be granted DATAREADER privileges to MSSQLog… tables or Shared Services database as a whole.

Small things

User accessibility and interface friendliness are frequently overlooked in programming. Here are few nice-to-have things that I’ve implemented in the Search Hint.

Basic settings

The web part allows defining the number of search suggestions to display as well as the sort order. The latter can be alphabetical or by frequency of use. Furthermore, that number (hits) will be shown as a tooltip, should the user hold the mouse on the suggestion.

Timeouts and startup

Firing client events on every client click can be exhausting and often annoying. The Search Hint offered a set of timeouts and settings that in fact can be edited directly in FacetedSearch.js library.

var delayKeyWait = 500; - (ms) how long to wait for the next key stroke

var delayHintRetire = 20000; - (ms) how long to keep hint display if no user action

var minKeywordLength = 3; - the minimal number of characters to fire off the search suggestions

Styling

The web part allows tuning of CSS styles for a regular, mouse-over and clicked search suggestions. The interface is consistent with other Faceted Search web parts.

Operations

The Search Hint supports both mouse and keyboard interactions. For example, after the user typed a keyword in the Search Box and search suggestions displayed, clicking arrow down/up on a keyboard will scroll through the suggestions. Naturally, the scroll will loop:)

Conclusion

More cool features are coming. Stand by

About the author

Leonid Lyublinski is a Microsoft consultant leading SharePoint Architecture and Development projects at our biggest clients. He is an author of several CodePlex solutions, a speaker at internal, public and international conferences.

Making Rich TextBoxes work in web enabled InfoPath forms

LEONID LYUBLINSKI — Tue, 31 Mar 2009 16:50:50 GMT

Technorati Tags: InfoPath 2007,rich text box,web enabled forms,InfoPath SharePoint,InfoPath WCF

Introduction

The rich-text boxes provide InfoPath forms with functionality that sometimes is crucial to the end users. However, there is not much information on the web with the tips on implementation. In this post I will skip reference to the RTB performance, which is known to be not that good. This blog will provide you with key steps to implement solution that delivers:

Web-enabled InfoPath form with RTB hosted in SharePoint
Support for the WCF service that ia bi-directionally connected to the database
Read and Write RTB fields

Solution

In this sample solution the InfoPath form displays a list of records from the database. The form is hosted in the SharePoint. The user is able to edit a record (EDIT button)and create a new one (CREATE button). Each record has 2 fields that must provide Rich Text box functionality.

WCF design

The web service will return and accept a STRING field, not XmlNode. That is a key difference to the solution you can find at http://support.microsoft.com/kb/826996

NOTE: make sure that you have a TEXT field on the receiving end in the database. XHTML generated by RTB can be quite large.

Implementation

Step 1

Create fields for each the RTB in the main data-source. Only RTB in main XML tree will be able to handle both read and write functionality. You will end up with 2 fields per RTB.

Step 2

Bind plain fields fldNotes and fldDescription to the corresponding columns provided by the WCF service. One of the ways to accomplish that is to define Rule on the button. Here is how it was done for the editing functionality.

This logic insures that fldNotes has the Notes value of the edited record.

Step 3

Add code-behind to the same Edit button to parse text into XHTML. Code will be responsible for doing all the hard work on validation and parsing text into Xml.

public void btnEdit_Clicked(object sender, ClickedEventArgs e)

{

XPathNavigator root = MainDataSource.CreateNavigator();

PopulateRTB(root,

"/my:myFields/my:SubmitData/my:fldNotes",

"/my:myFields/my:SubmitData/my:richNotes");

PopulateRTB(root,

"/my:myFields/my:SubmitData/my:fldDescription",

"/my:myFields/my:SubmitData/my:richDescription");

}

private void PopulateRTB(XPathNavigator root, string fldPath, string richPath)

{

XPathNavigator rich =

root.SelectSingleNode(richPath, NamespaceManager);

XPathNavigator fld =

root.SelectSingleNode(fldPath, NamespaceManager);

try

{

rich.InnerXml = GetXHTML(fld.Value).OuterXml;

}

catch

{

rich.SetValue(string.Empty);

}

private XmlNode GetXHTML(string text)

{

XmlDocument doc = new XmlDocument();

try

{

doc.LoadXml(text);

return doc.DocumentElement;

}

catch (XmlException)

{

XmlNode node = doc.CreateNode(

XmlNodeType.Element,

"DIV",

"http://www.w3.org/1999/xhtml");

if (!string.IsNullOrEmpty(text))

{

node.InnerText = text;

}

return node;

}

The methods account for having plain text returned by WCF, that is not Xml-structured.

Step 4

Add code-behind to the Submit button. This code insures writing Xml-structured text back to fldNotes and fldDescription.

private void PopulateField(XPathNavigator root, string fldPath, string richPath)

{

XPathNavigator rich =

root.SelectSingleNode(richPath, NamespaceManager);

XPathNavigator fld =

root.SelectSingleNode(fldPath, NamespaceManager);

fld.SetValue(rich.InnerXml);

}

public void FormEvents_Submit(object sender, SubmitEventArgs e)

{

XPathNavigator root = MainDataSource.CreateNavigator();

PopulateField(root,

"/my:myFields/my:SubmitData/my:fldNotes",

"/my:myFields/my:SubmitData/my:richNotes");

PopulateField(root,

"/my:myFields/my:SubmitData/my:fldDescription",

"/my:myFields/my:SubmitData/my:richDescription");

}

Step 5

In your Update and Create connections make sure that fldNotes and fldDescription are bound to corresponding WCF services.

Run the form and enjoy rich text boxes in action!

Conclusion

Now, after you made RTB work and enjoyed all the richness it offers, remember! RTB impacts performance. Run your stress/scalability/performance tests before go for production.

Usage Analysis Processing logs

LEONID LYUBLINSKI — Wed, 31 Oct 2007 02:26:00 GMT

Here is a simple utility I wrote to process the MOSS usage logs (when turned on at Central Administration >> Operations >> Usage Analysis Processing ). Sometimes it's useful to have alternate source for the user activity, than the usage reports offered in MOSS OOB through the Site Settings.

I have slightly modified the Parser class found at http://www.sharepointblogs.com/wpowell/archive/2007/06/22/moss-usage-log-processing-file-processing.aspx . The MOSSLogParser.exe utility loops through all log files and creates a single CSV file, ready for Excel pivot tables.

the syntax: MOSSLogParser.exe <start_path> <search_pattern>

start_path - path to the folder where logs files are defined. The parser will look down, traversing sub-folder structure. Default value is: "C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\Logs" Note the absense of ending slash
search_pattern - the pattern used to filter the logs. Default value is "0*.log"

samples:

MOSSLogParser.exe
MOSSLogParser.exe \\share\logs
MOSSLogParser.exe E:\usage "*.log"

Connected Lookup Field

LEONID LYUBLINSKI — Sun, 24 Jun 2007 16:29:00 GMT

Introduction

The attached code demonstrates the extended lookup field. Such field can be used to display any hierarchical structures, such as org charts, city-stat-country chains etc.

The biggest challenge and advantage of implemented design was to build a Connected Lookup Field as a listener to other Connected Lookup Fields. In contrast with multi-value column, each field is a separate column itself. That allows use of built-in WSS functionality such as filtering and sorting by column.

This version will work for lists <1000 items.

Install

run setup.exe

Configuration

In the current release all connected columns must be sourced within the same SharePoint list. The list can be loaded from a different SP Site though. I used a built-in Contacts list with populated geographical locations.

Add Connected Lookup Fields to your list. “Get Information From” should point to your source list (above).

“Value Column” is the actual column this field will display. “Parent Column” when is not empty, indicates that the “Value Column“ depends on another column. This implies that the list will contain another Connected Lookup Field, where the Parent column is a Value column.

“Broadcast Value” should be checked on the Parent Connected Lookup Field. It indicates that the column value will be published, thus listeners can watch for it.

Adding 3 columns in my example as:

Field name	Parent column	Value column	Broadcast value
Country	N/a	Country	Yes
State	Country	Sate/Province	Yes
City	Sate/Province	City	No

The desired functionality as connected dropdowns is shown in New and Edit forms .

After the target list populated, each of the Connected Lookup Fields renders as a separate column.

TBD