Importing SharePoint List Data into Project Server 2007 Custom Fields

Open Visual Studio 2008.

Create a Microsoft .NET Framework 3.5 Class Library project named ActiveIssuesHealth.

Edit the properties for the ActiveIssuesHealth project, enable assembly signing, and create a keyfile.

In Solution Explorer, rename Class1.cs to ActiveIssuesHealthHandler.cs.

In the Add Reference dialog box, add references to the Microsoft.Office.Project.Server.Events.Recievers.dll assembly and the Microsoft.Office.Project.Server.Library.dll assembly. Following is the default location:

%ProgramFiles%\Microsoft Office Servers\12.0\Bin\

Note

If you are developing on a 64-bit server, you should manually browse to drive\Program Files instead of using the %ProgramFiles% environment variable. Because Visual Studio 2008 is a 32-bit application running under the WOW64 x86 emulator, %ProgramFiles% resolves to drive\Program Files (x86) in a 64-bit environment.

Add a reference to Microsoft.SharePoint.dll. Following is the default file location:

%ProgramFiles%\Common Files\Microsoft Shared\Web Server Extensions\12\ISAPI\

In the Add Reference dialog box, add a reference to System.Web.Services.dll, listed under the .NET tab.

Add the following lines to the global references section of ActiveIssuesHealthHandler.cs.

using System.Net;
using System.Web.Services.Protocols;
using Microsoft.Office.Project.Server.Events;
using Microsoft.Office.Project.Server.Library;
using Microsoft.SharePoint;

In the Add Web Reference dialog box, add a Web reference to the WssInterop PSI Web service named WssInteropSvc. Following is the default Web service location:

http://servername/instancename/_vti_bin/psi/wssinterop.asmx

Note

To access the Add Web Reference dialog box in Visual Studio 2008, in the Solution Explorer Add Service Reference dialog box, click Advanced.

Add a Web reference to the Project PSI Web service named ProjectSvc. Following is the default Web service location:

http://servername/instancename/_vti_bin/psi/project.asmx

Add a Web reference to the CustomFields PSI Web service named CustomFieldsSvc. Following is the default Web service location:

http://servername/instancename/_vti_bin/psi/customfields.asmx

Add a Web reference to the CustomFields PSI Web service named EventsSvc. Following is the default Web service location:

http://servername/instancename/_vti_bin/psi/events.asmx

Add the following global constants to the ActiveIssuesHealthHandler class.

// Constants.
private const int _sspHttpPort = 56737;
private const int _sspHttpsPort = 56738;
private const string _customFieldsSvcPath =
    "/vti_bin/PSI/CustomFields.asmx";
private const string _projectImpPath = "/PSI/Project.asmx";
private const string _projectSvcPath = 
    "/vti_bin/PSI/Project.asmx";
private const string _wssInteropSvcPath = 
    "/vti_bin/PSI/WssInterop.asmx";
private const string _sessionDesc = "ActiveIssuesHealth";
private const string _statusFieldName = "Status";

Modify the ActiveIssuesHealthHandler class to inherit the ProjectEventReceiver base abstract event receiver class.

using System; 
using System.Linq;
using System.Net;
using System.Text;
using System.Web.Services.Protocols;
using Microsoft.Office.Project.Server.Events;
using Microsoft.Office.Project.Server.Library;
using Microsoft.SharePoint;

namespace ActiveIssuesHealth
{
   // Constants.
    private const int _sspHttpPort = 56737;
    private const int _sspHttpsPort = 56738;
    private const string _customFieldsSvcPath =
        "/_vti_bin/PSI/CustomFields.asmx";
    private const string _projectImpPath = "/PSI/Project.asmx";
    private const string _projectSvcPath = 
        "/_vti_bin/PSI/Project.asmx";
    private const string _wssInteropSvcPath = 
        "/_vti_bin/PSI/WssInterop.asmx";
    private const string _sessionDesc = "ActiveIssuesHealth";
    private const string _statusFieldName = "Status";

    public class ActiveIssuesHealthHandler : ProjectEventReceiver
    {
    }
}

For more information about the ProjectEventReceiver class, see ProjectEventReceiver Class (Microsoft.Office.Project.Server.Events).

Create an override method for the OnPublished base method.

public override void OnPublished(PSContextInfo contextInfo, 
    ProjectPostPublishEventArgs e)
{
   base.OnPublished(contextInfo, e);
}

For more information about the OnPublished event, see ProjectEventReceiver.OnPublished Method (Microsoft.Office.Project.Server.Events).

Delete the base.OnPublished(contextInfo, e); statement from the OnPublished method.

Add a try…catch block to the OnPublished method.

public override void OnPublished(PSContextInfo contextInfo, 
    ProjectPostPublishEventArgs e)
{
    try
    {
    }

    catch (SoapException ex)
    {
    }
}

In ActiveIssuesHealthHandler.cs, create a method named ExpandPsiException.

private static Exception ExpandPsiException(SoapException ex)
{
}

Develop the ExpandPsiException method. This method uses the PSClientError class to extract detailed error information from a SoapException exception thrown by the PSI.

// Declarations.
StringBuilder _errorMessage = new StringBuilder();
PSClientError _psiError = new PSClientError(ex);
PSErrorInfo[] _errors = _psiError.GetAllErrors();
PSErrorInfo _error = null;

if (_errors.Length == 0)
    return ex;

_errorMessage.AppendLine("".PadRight(30, '='));
_errorMessage.AppendLine("Error:");
_errorMessage.AppendLine();

// Loop through and extract all errors.
for (int i = 0; i < _errors.Length; i++)
{
    _error = _errors[i];
    _errorMessage.AppendLine(ex.Message.ToString());
    _errorMessage.AppendLine("".PadRight(30, '='));
    _errorMessage.AppendLine("PSClientErrorOutput:");
    _errorMessage.AppendLine();
    _errorMessage.AppendLine(_error.ErrId.ToString());
    _errorMessage.AppendLine();

    for (int j = 0; j < _error.ErrorAttributes.Length; j++)
    {
        _errorMessage.Append("\t");
        _errorMessage.Append(_error.ErrorAttributeNames()[j]);
        _errorMessage.Append(": ");
        _errorMessage.Append(_error.ErrorAttributes[j]);
    }

    _errorMessage.AppendLine();
    _errorMessage.AppendLine("Exception InnerXML:");
    _errorMessage.AppendLine();
    _errorMessage.Append(ex.Detail.InnerXml);
    _errorMessage.Append("\r\n".PadRight(30, '='));
}

return new Exception(_errorMessage.ToString(), ex);

For more information about the PSClientError class, see PSClientError Class (Microsoft.Office.Project.Server.Library).

Add the following line to the OnPublished method's catch block.

// Expand SoapExceptions from the PSI.
throw ExpandPsiException(ex);

In Solution Explorer, add a new class named PwaSiteInfo.cs to the project.

Modify the class declaration of PwaSiteInfo.cs to add an internal access modifier.

using System;

namespace ActiveIssuesHealth
{
    internal class PwaSiteInfo
    {
    }
}

Add the following line to the global references section of the class.

using Microsoft.SharePoint;

Add three automatic properties to the class: one to store the hostname, one to store the protocol, and one to store the PWA URL.

internal string Hostname { get; set; }
internal string Protocol { get; set; } 
internal string PwaUrl { get; set; } 

Add the following constructor to the class. This constructor uses the SiteGuid from ProjectPostPublishEventArgs to create an SPSite object from which it populates the new instance of PwaSiteInfo with the PWA site's hostname, protocol, and URL.

internal PwaSiteInfo(Guid pwaSiteGuid)
{
    // Declarations.
    SPSite _pwaSite = null;

    try
    {
        if (pwaSiteGuid == Guid.Empty)
            throw new ArgumentException("Empty Guid",
                                        "pwaSiteGuid");

        // Use the SiteGuid from PSContextInfo to get the hostname.
        _pwaSite = new SPSite(pwaSiteGuid);

        Hostname = _pwaSite.HostName;
        Protocol = _pwaSite.Protocol;
        PwaUrl = _pwaSite.Url;
    }

    finally
    {
        if (_pwaSite != null) _pwaSite.Dispose();
    }
}

Note

Many of the methods in this article use classes that implement IDisposable. Although the common language runtime (CLR) contains garbage collection features, Microsoft best practices state that you should not rely upon the garbage collector to release memory allocated to objects that implement IDisposable in a timely manner, if at all. For more information, see Best Practices: Using Disposable Windows SharePoint Services Objects and IDisposable Interface. For more information about the SPSite class, see SPSite Class (Microsoft.SharePoint).

Add a call to the PwaSiteInfo constructor in the OnPublished method's try block.

// Retrieve PWA site information.
PwaSiteInfo _pwaInfo = new PwaSiteInfo(contextInfo.SiteGuid);

In Solution Explorer, add a new class named ProjectWssInfo.cs to the project.

Modify the class declaration of ProjectWssInfo.cs to add an internal access modifier.

using System;

namespace ActiveIssuesHealth
{
    internal class ProjectWssInfo
    {
    }
}

Add two automatic properties to the class: one to store the name of the Issues list, and another to store the name of the project workspace.

internal string IssueListName { get; set; }
internal string WorkspaceName { get; set; } 

Add an empty default constructor to the class.

internal ProjectWssInfo()
{
}

In ActiveIssuesHealthHandler.cs, create a method named GetPwsInfo.

private static ProjectWssInfo GetPwsInfo(string pwaUrl, 
    Guid projectUid)
    {
    }

Develop the GetPwsInfo method by using the WssInterop PSI Web service. This method retrieves the workspace and Issues list URLs by calling ReadWssData for the project GUID that raised the OnPublished event. These URLs are then stripped down to the workspace and Issues list names and returned in the ProjectWssInfo class that you created earlier.

// Declarations.
ProjectWssInfo _info = new ProjectWssInfo();
WssInteropSvc.WssInterop _wssInteropPsi = null;
WssInteropSvc.ProjectWSSInfoDataSet _wssInfoDs = null;

try
{
    if (String.IsNullOrEmpty(pwaUrl))
        throw new ArgumentNullException("pwaUrl");

    if (projectUid == Guid.Empty)
        throw new ArgumentException("Empty Guid", "projectUid");

    // Initialize and configure Web reference.
    _wssInteropPsi = new WssInteropSvc.WssInterop();
    _wssInteropPsi.Credentials =
        CredentialCache.DefaultCredentials;
    _wssInteropPsi.Url = pwaUrl + _wssInteropSvcPath;

    _wssInfoDs = _wssInteropPsi.ReadWssData(projectUid);

    if (_wssInfoDs == null)
    {
        throw new Exception(
            "Unable to retrieve workspace for project " +
            projectUid);
    }

    if (_wssInfoDs.ProjWssInfo.Count < 1)
    {
        throw new Exception("No WSS information for project " +
                            projectUid);
    }

    if (_wssInfoDs.ProjWssInfo[0].PROJECT_WORKSPACE_URL.GetType() == 
        typeof(DBNull))
    {
        throw new Exception(
            "No workspace found for project " + 
            projectUid);
    }

    if (_wssInfoDs.ProjWssInfo[0].PROJECT_ISSUES_URL.GetType() ==
        typeof(DBNull))
    {
        throw new Exception("No issues list found for project " +
                            projectUid);
    }

    string _workspaceName =
        _wssInfoDs.ProjWssInfo[0].PROJECT_WORKSPACE_URL;

    string _issuesListName =
        _wssInfoDs.ProjWssInfo[0].PROJECT_ISSUES_URL;

    if (String.IsNullOrEmpty(_workspaceName))
    {
        throw new Exception("No workspace URL for project " +
                            projectUid);
    }

    if (String.IsNullOrEmpty(_issuesListName))
    {
        throw new Exception("No issues list URL for project " +
                            projectUid);
    }

    // Strip the URLs down to only names.
    // Strip the beginning of the URL.
    _workspaceName = 
        _workspaceName.Remove(0, 
            (_workspaceName.LastIndexOf("/") + 1));

    // Remove /AllItems.aspx from the Issues list URL.
    _issuesListName = _issuesListName.Remove(
        _issuesListName.IndexOf("/AllItems.aspx"), 14);

    // Strip everything before the list name.
    _issuesListName = 
        _issuesListName.Remove(0, 
            (_issuesListName.LastIndexOf("/") + 1));

    _info.IssueListName = _issuesListName;
    _info.WorkspaceName = _workspaceName;

    return _info;
}

finally
{
    if (_wssInteropPsi != null) _wssInteropPsi.Dispose();
    if (_wssInfoDs != null) _wssInfoDs.Dispose();
}

For more information about the WssInterop class, see WssInterop Class (WebSvcWssInterop).

In the OnPublished method's try block, add a call to GetPwsInfo.

// Retrieve project workspace info for project being published.
ProjectWssInfo _pwsInfo = GetPwsInfo(_pwaUrl, e.ProjectGuid);

In Solution Explorer, add a new class named HandlerSettings.cs to the project.

Add the following lines to the global references section of the class.

using Microsoft.SharePoint;
using Microsoft.SharePoint.Utilities;

Modify the class declaration of HandlerSettings.cs to add a public access modifier.

using System;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Utilities;

namespace ActiveIssuesHealth
{
    public class HandlerSettings
    {
    }
}

Add three automatic properties to the class: one to store the value that qualifies an issue as active, one to store the SSP name, and another to store the name of the custom field the handler should populate with the count of active issues.

public string ActiveStatusValue { get; set;}
public string SspName { get; set; }
public string TargetCustomField { get; set; }

Add an empty default constructor to the class.

public HandlerSettings()
{           
}

Add the following constants to the HandlerSettings class.

public const string ActiveStatusValueKey =
    "ActiveIssuesHealth.ActiveStatusValue";
public const string SspNameKey = "ActiveIssuesHealth.SspName";
public const string TargetCustomFieldKey =
    "ActiveIssuesHealth.TargetCustomField";

Create a method named GetKeyValue.

private static string GetKeyValue(SPWeb pwaWeb, string keyName)
{
}

Develop the GetKeyValue method. This method uses an SPWeb object to retrieve values from and return values to the PWA SPPropertyBag class.

if (pwaWeb == null)
    throw new ArgumentNullException("pwaWeb");

if (String.IsNullOrEmpty(keyName))
    throw new ArgumentNullException("keyName");

SPPropertyBag _pwaWebProperties = pwaWeb.Properties;

if (!_pwaWebProperties.ContainsKey(keyName))
    throw new ArgumentException("Key not found: " + keyName);

return _pwaWebProperties[keyName]; 

For more information about the SPPropertyBag class, see SPPropertyBag Class (Microsoft.SharePoint.Utilities). For more information about the SPWeb class, see SPWeb Class (Microsoft.SharePoint).

Create a new method named GetHandlerSettings.

internal static HandlerSettings GetHandlerSettings(Guid pwaSiteGuid)
{
}

Develop the GetHandlerSettings method. This method retrieves multiple settings by using the GetKeyValue method and bundles them into a HandlerSettings object for return.

// Declarations.
SPSite _pwaSite = null;
SPWeb _pwaWeb = null;

try
{
    if (pwaSiteGuid == Guid.Empty)
        throw new ArgumentException("Empty Guid", "pwaSiteGuid");

    HandlerSettings _retrievedSettings = new HandlerSettings();

    _pwaSite = new SPSite(pwaSiteGuid);
    _pwaWeb = _pwaSite.RootWeb;

    if (_pwaWeb == null)
        throw new Exception("Unable to load SPWeb for PWA site.");

    _retrievedSettings.ActiveStatusValue =
        GetKeyValue(_pwaWeb, ActiveStatusValueKey);
    _retrievedSettings.SspName =
        GetKeyValue(_pwaWeb, SspNameKey);
    _retrievedSettings.TargetCustomField =
        GetKeyValue(_pwaWeb, TargetCustomFieldKey);

    return _retrievedSettings;
}

finally
{
    if (_pwaSite != null) _pwaSite.Dispose();
    if (_pwaWeb != null) _pwaWeb.Dispose();
}

Create a new method named SetKeyValue.

private static void SetKeyValue(SPWeb pwaWeb,
    string keyName, string value)
{
}

Develop the SetKeyValue method. This method uses an SPWeb object to set key-value pairs on the PWA Web's SPPropertyBag class.

if (pwaWeb == null)
    throw new ArgumentNullException("pwaWeb");

if (String.IsNullOrEmpty(keyName))
    throw new ArgumentNullException("keyName");

SPPropertyBag _pwaWebProperties = pwaWeb.Properties;

pwaWeb.AllowUnsafeUpdates = true;

if (!_pwaWebProperties.ContainsKey(keyName) && 
    !String.IsNullOrEmpty(value))
    _pwaWebProperties.Add(keyName, value);

else
    _pwaWebProperties[keyName] = value;

_pwaWebProperties.Update();
pwaWeb.Update();
pwaWeb.AllowUnsafeUpdates = false;

Create a new method named SetHandlerSettings.

internal static void HandlerSettings(Guid pwaSiteGuid,
                                     string key,
                                     string value)
{
}

Develop the SetHandlerSettings method. This method instantiates the necessary SharePoint classes and encapsulates the SetKeyValue method that you just created.

// Declarations.
SPSite _pwaSite = null;
SPWeb _pwaWeb = null;

try
{
    if (String.IsNullOrEmpty(key))
        throw new ArgumentNullException("key");

    if (pwaSiteGuid == Guid.Empty)
        throw new ArgumentException("Empty Guid", "pwaSiteGuid");

    _pwaSite = new SPSite(pwaSiteGuid);
    _pwaWeb = _pwaSite.RootWeb;

    if (_pwaWeb == null)
        throw new Exception("Unable to load SPWeb for PWA site.");

    SetKeyValue(_pwaWeb, key, value);                
}            
 
finally
{
    if (_pwaSite != null) _pwaSite.Dispose();
    if (_pwaWeb != null) _pwaWeb.Dispose();
}

In the OnPublished method's try block, add a call to GetHandlerSettings.

// Retrieve handler settings from PWA Web's SPPropertyBag.
HandlerSettings _handlerSettings =
    HandlerSettings.GetHandlerSettings(contextInfo.SiteGuid);

In ActiveIssuesHealthHandler.cs, create a method named GetActiveIssuesHealth.

private static int GetActiveIssuesHealth(HandlerSettings settings, 
    ProjectWssInfo pwsInfo, Guid pwaSiteGuid)
{
}

Develop the GetActiveIssuesHealth method. This method creates an SPWeb by using the workspace name retrieved earlier, builds an SPQuery object to retrieve only active issues, and returns a count.

// Declarations.
SPSite _pwaSite = null;
SPWeb _workspaceWeb = null;

try
{
    if (settings == null)
        throw new ArgumentNullException("settings");

    if (pwsInfo == null)
        throw new ArgumentNullException("pwsInfo");

    if (pwaSiteGuid == Guid.Empty)
        throw new ArgumentException("Empty Guid", "pwaSiteGuid");

    _pwaSite = new SPSite(pwaSiteGuid);
        
    _workspaceWeb = _pwaSite.OpenWeb(pwsInfo.WorkspaceName);

    if (_workspaceWeb == null)
        throw new Exception("Unable to load workspace.");

    // Use LINQ instead of a Lists.Exists() method
    // to determine whether a list exists.
    if (_workspaceWeb.Lists.Cast<SPList>().Any(
        list => string.Equals(
            list.Title, pwsInfo.IssueListName)))
        throw new Exception("Issues list not found in workspace.");
        
    // Build a query to retrieve only active issues.
    StringBuilder _querySb = new StringBuilder();
    _querySb.Append("<Where><Eq><FieldRef Name='");
    _querySb.Append(_statusFieldName);
    _querySb.Append("'/><Value Type='Text'>");
    _querySb.Append(settings.ActiveStatusValue);
    _querySb.Append("</Value></Eq></Where>");

    // Convert query into an SPQuery.
    SPQuery _query = new SPQuery();
    _query.Query = _querySb.ToString();

    // Execute query.
    int _activeIssuesHealth =
        _workspaceWeb.Lists[pwsInfo.IssueListName].
            GetItems(_query).Count;

    return _activeIssuesHealth;
}

finally
{
    if (_pwaSite != null) _pwaSite.Dispose();
    if (_workspaceWeb != null) _workspaceWeb.Dispose();
}

For more information about the SPQuery class, see SPQuery Class (Microsoft.SharePoint).

In the OnPublished method's try block, add a call to GetActiveIssuesHealth.

// Retrieve custom field GUID by using name.
int _activeIssuesHealth = 
    GetActiveIssuesHealth(_handlerSettings, _pwsInfo, 
        contextInfo.SiteGuid);

In ActiveIssuesHealthHandler.cs, create a method named GetCustomFieldGuid.

private static Guid GetCustomFieldGuid(string pwaUrl, 
    string fieldName, Guid entityType, int fieldType)
{
}

Develop the GetCustomFieldGuid method by using the CustomFields PSI Web service. This method uses a filter parameter to find a custom field by name and return its GUID.

// Declarations.
CustomFieldsSvc.CustomFields _customFieldsPsi = null;
CustomFieldsSvc.CustomFieldDataSet _fieldDs = 
    new CustomFieldsSvc.CustomFieldDataSet();

try
{
    if (String.IsNullOrEmpty(pwaUrl))
        throw new ArgumentNullException("pwaUrl");

    if (String.IsNullOrEmpty(fieldName))
        throw new ArgumentNullException("fieldName");

    // Initialize and configure Web reference.
    _customFieldsPsi = new CustomFieldsSvc.CustomFields();
    _customFieldsPsi.Credentials = 
        CredentialCache.DefaultCredentials;
    _customFieldsPsi.Url = pwaUrl + _wssInteropSvcPath;

    // Set up objects and strings needed for the filter.
    EntityCollection _entityType = new EntityCollection();
    Filter _cfFilter = new Filter();
    Filter.FieldOperationType _equal = 
        Filter.FieldOperationType.Equal;

    string _entityTypeColumnName =
        _fieldDs.CustomFields.MD_PROP_TYPE_ENUMColumn.ColumnName;
    string _entityUidColumnName = 
        _fieldDs.CustomFields.MD_ENT_TYPE_UIDColumn.ColumnName;
    string _nameColumnName =
        _fieldDs.CustomFields.MD_PROP_NAMEColumn.ColumnName;
    string _tableName = _fieldDs.CustomFields.TableName;
    string _uidColumnName = 
        _fieldDs.CustomFields.MD_PROP_UIDColumn.ColumnName;

    // Compose the filter.
    _cfFilter.FilterTableName = _tableName;
    _cfFilter.Fields.Add(new Filter.Field(
                             _tableName, _nameColumnName));
    _cfFilter.Fields.Add(new Filter.Field(_uidColumnName));
    _cfFilter.Criteria =
        new Filter.LogicalOperator(
            Filter.LogicalOperationType.And,
            new Filter.FieldOperator(_equal, _entityUidColumnName,
                                     entityType),
            new Filter.FieldOperator(_equal,
                                     _nameColumnName, fieldName),
            new Filter.FieldOperator(_equal,
                                     _entityTypeColumnName, 
                                     fieldType));

    _fieldDs = _customFieldsPsi.ReadCustomFields(
        _cfFilter.GetXml(), false);

    if (_fieldDs == null)
    {
        throw new Exception("Custom field '" + fieldName +
            "' of type '" + (CustomField.Type)fieldType + 
            "' could not be found.");
    }

    // One result only should be returned.
    if (_fieldDs.CustomFields.Rows.Count == 0)
    {
        throw new Exception("Custom field '" + fieldName +
            "' of type '" + (CustomField.Type)fieldType +
            "' could not be found.");
    }

    if (_fieldDs.CustomFields.Rows.Count > 1)
    {
        throw new Exception("Multiple entries for " + 
            "custom field '" + fieldName +
            "' of type '" + (CustomField.Type)fieldType +
            "' were found.");
    }

    return _fieldDs.CustomFields[0].MD_PROP_UID;
}

finally
{
    if (_customFieldsPsi != null) _customFieldsPsi.Dispose();
    if (_fieldDs != null) _fieldDs.Dispose();
}

For more information about the CustomFields Web service, see CustomFields Class (WebSvcCustomFields). For more information about filter parameters, see How to: Use a Filter Parameter with PSI Methods.

In the OnPublished method's try block, add a call to GetCustomFieldGuid.

// Retrieve custom field GUID by using name.
Guid _targetFieldGuid =
    GetCustomFieldGuid(_pwaUrl,
                       _handlerSettings.TargetCustomField,
                       new Guid(EntityCollection.Entities.ProjectEntity.UniqueId),
                       (int)CustomField.Type.NUMBER);

In ActiveIssuesHealthHandler.cs, create a method named CreateUpdate.

private static ProjectSvc.ProjectDataSet CreateUpdate(string pwaUrl, 
    Guid targetFieldUid, int activeIssuesHealth, Guid projectUid)
{
}

Develop the CreateUpdate method by using the Project PSI Web service. This method retrieves the current custom field data for the project, verifies whether the custom field is already defined, and either adds the custom field to the project with the retrieved active issue count or updates the existing custom field with the new active issue count. The dataset containing the modifications is returned by the method.

if (String.IsNullOrEmpty(pwaUrl))
    throw new ArgumentNullException("pwaUrl");

if (projectUid == Guid.Empty)
    throw new ArgumentException("Empty Guid", "projectUid");

if (targetFieldUid == Guid.Empty)
    throw new ArgumentException("Empty Guid",
                                "targetFieldUid");

// Declarations.
ProjectSvc.Project _projectPsi = null;
ProjectSvc.ProjectDataSet _projCfDs = null;
ProjectSvc.ProjectDataSet _updateDs = null;

try
{
    if (String.IsNullOrEmpty(pwaUrl))
        throw new ArgumentNullException("pwaUrl");

    if (projectUid == Guid.Empty)
        throw new ArgumentException("Empty Guid", "projectUid");

    // Initialize and configure Web reference.
    _projectPsi = new ProjectSvc.Project();
    _projectPsi.Credentials =
        CredentialCache.DefaultCredentials;
    _projectPsi.Url = pwaUrl + _projectSvcPath;


    // Retrieve project custom fields to ensure that
    // we are not duplicating a custom field row.
    _projCfDs = _projectPsi.ReadProjectEntities
        (projectUid, 32, ProjectSvc.DataStoreEnum.WorkingStore);

    if (_projCfDs == null)
    {
        throw new Exception("Unable to retrieve project " +
                            projectUid);
    }

    // Make a copy of the retrieved ProjectDataSet for update.
    _updateDs = _projCfDs.Copy() as ProjectSvc.ProjectDataSet;

    if (_updateDs == null)
    {
        throw new Exception("Unable to retrieve project " +
                            projectUid);
    }

    if (_updateDs.ProjectCustomFields.Count > 0)
    {
        foreach (
            ProjectSvc.ProjectDataSet.ProjectCustomFieldsRow _row
            in _updateDs.ProjectCustomFields)
        {
            if (_row.MD_PROP_UID == targetFieldUid)
            {
                // Avoid recursion loops by terminating if
                // the current value is unchanged from
                // the stored value.
                if (_row.NUM_VALUE == activeIssuesHealth)
                    return null;

                _row.NUM_VALUE = activeIssuesHealth;
                
                return _updateDs;
            }
        }
    }

    ProjectSvc.ProjectDataSet.ProjectCustomFieldsRow _newRow =
        _updateDs.ProjectCustomFields.NewProjectCustomFieldsRow();

    _newRow.CUSTOM_FIELD_UID = Guid.NewGuid();
    _newRow.MD_PROP_UID = targetFieldUid;
    _newRow.NUM_VALUE = activeIssuesHealth;
    _newRow.PROJ_UID = projectUid;
    _updateDs.ProjectCustomFields.AddProjectCustomFieldsRow(
        _newRow);

    return _updateDs;
}

finally
{
    if (_projectPsi != null) _projectPsi.Dispose();
    if (_projCfDs != null) _projCfDs.Dispose();
    if (_updateDs != null) _updateDs.Dispose();
}

Note

You must always verify that a custom field is not already defined on a project before you add a new custom field row to the project's ProjectCustomFields table.

For more information about the rows in the ProjectCustomFields table, see ProjectDataSet.ProjectCustomFieldsRow Class (WebSvcProject).

In Solution Explorer, add a new class named ProjectDerived.cs to the project.

Replace the contents of ProjectDerived.cs with the following code.

using System;
using System.Net;
using PSLibrary = Microsoft.Office.Project.Server.Library;

namespace ActiveIssuesHealth
{
    class ProjectDerived : ProjectSvc.Project
    {
        private static String _contextString = String.Empty;

        protected override WebRequest GetWebRequest(Uri uri)
        {
            // Override the GetWebRequest method and 
            // add the two webRequest headers.
            WebRequest _webRequest = base.GetWebRequest(uri);
            if (_contextString != String.Empty)
            {
                _webRequest.UseDefaultCredentials = true;

                _webRequest.Credentials = 
                    CredentialCache.DefaultNetworkCredentials;

                _webRequest.Headers.Add("PjAuth", _contextString);
                _webRequest.Headers.Add(
                    "ForwardFrom", "/_vti_bin/psi/project.asmx");

                _webRequest.PreAuthenticate = true;
            }
            return _webRequest;
        }

        public static void SetImpersonationContext(
            bool isWindowsUser, String userAccount, 
            Guid userGuid, Guid trackingGuid, 
            Guid pwaSiteId, String lcid)
        {
            _contextString = GetImpersonationContext(isWindowsUser, 
                userAccount, userGuid, trackingGuid, 
                pwaSiteId, lcid);
        }

        private static String GetImpersonationContext(
            bool isWindowsUser, String userAccount, 
            Guid userGuid, Guid trackingGuid, 
            Guid pwaSiteId, String lcid)
        {
            PSLibrary.PSContextInfo _contextInfo =
                new PSLibrary.PSContextInfo(isWindowsUser, 
                                            userAccount,
                                            userGuid, 
                                            trackingGuid, 
                                            pwaSiteId, lcid);
            String _contextString =
                PSLibrary.PSContextInfo.SerializeToString(
                    _contextInfo);
            return _contextString;
        }
    }
}

In ActiveIssuesHealthHandler.cs, create a method named GetSessionUid.

private static Guid GetSessionUid(string pwaUrl, Guid projectUid)
{
}

Develop the GetSessionUid method by using the Project PSI Web service. This method retrieves the current project's information and extracts the session identifier.

if (String.IsNullOrEmpty(pwaUrl))
    throw new ArgumentNullException("pwaUrl");

if (projectUid == Guid.Empty)
    throw new ArgumentException("Empty Guid", "projectUid");

// Declarations.
ProjectSvc.Project _projectPsi = null;
ProjectSvc.ProjectDataSet _projDs = null;

try
{
    // Initialize and configure Web reference.
    _projectPsi = new ProjectSvc.Project();
    _projectPsi.Credentials =
        CredentialCache.DefaultCredentials;
    _projectPsi.Url = pwaUrl + _projectSvcPath;

    _projDs = _projectPsi.ReadProjectEntities
        (projectUid, 1, ProjectSvc.DataStoreEnum.WorkingStore);

    if (_projDs == null)
    {
        throw new Exception("Unable to retrieve project " +
                            projectUid);
    }

    // Should have only one row.
    if (_projDs.Project.Rows.Count == 0)
    {
        throw new Exception("Unable to retrieve project " +
                            projectUid);
    }

    if (_projDs.Project.Rows.Count > 1)
    {
        throw new Exception("Multiple entries for project " +
                            projectUid);
    }

    // PROJ_SESSION_UID is either DBNull or the session UID.
    if (_projDs.Project[0].PROJ_SESSION_UID.GetType() !=
        typeof(DBNull))
    {
        return _projDs.Project[0].PROJ_SESSION_UID;
    }

    // If this event handler is running and the project is
    // not checked out, then something is wrong and we should
    // stop processing immediately.
    throw new Exception("Project " + projectUid +
                        "is no longer checked out. Terminating.");
}

finally
{
    if (_projectPsi != null) _projectPsi.Dispose();
    if (_projDs != null) _projDs.Dispose();
}

For more information about the session identifier, see ProjectDataSet.ProjectRow.PROJ_SESSION_UID Property (WebSvcProject).

In ActiveIssuesHealthHandler.cs, create a method named UpdateProject.

private static void UpdateProject(string sspName, string userName,
    Guid userUid, bool isWindowsUser, Guid siteUid, string lcid, 
    string hostname, string protocol, string pwaUrl, 
    Guid projectUid, ProjectSvc.ProjectDataSet updateDataSet)
{
}

Develop the UpdateProject method. If the project was not checked out when Project Server invoked the event handler, you must check it out by using the CheckOutProject method before you can update it. Then, transmit the update for enqueueing by using impersonation and the QueueUpdateProject method. After the update payload is transmitted, republish the project by using the QueuePublish method. Finally, if the project was not checked out when Project Server invoked the event handler, you must check it back in by using the QueueCheckInProject method.

if (String.IsNullOrEmpty(sspName))
    throw new ArgumentNullException("sspName");

if (String.IsNullOrEmpty(userName))
    throw new ArgumentNullException("userName");

if (userUid == Guid.Empty)
    throw new ArgumentException("Empty Guid", "userUid");

if (siteUid == Guid.Empty)
    throw new ArgumentException("Empty Guid", "siteUid");

if (String.IsNullOrEmpty(lcid))
    throw new ArgumentNullException("lcid");

if (String.IsNullOrEmpty(hostname))
    throw new ArgumentNullException("hostname");

if (String.IsNullOrEmpty(protocol))
    throw new ArgumentNullException("protocol");

if (projectUid == Guid.Empty)
    throw new ArgumentException("Empty Guid", "projectUid");

// This is the second half of the anti-infinite loop logic.
if (updateDataSet == null)
    return;

if (updateDataSet.ProjectCustomFields.Rows.Count < 1)
    throw new ArgumentException("Empty Update", "updateDataSet");

// Declarations.
ProjectDerived _projectImp = null;

try
{
    // Initialize and configure Web reference.
    _projectImp = new ProjectDerived();
    _projectImp.Credentials = CredentialCache.DefaultCredentials;

    string _tempUrl;

    // Replace the port placeholder.
    if (protocol.Equals("http:"))
    {
        _tempUrl = protocol + "//" + hostname + ":" +
                          _sspHttpPort + "/" + sspName +
                          _projectImpPath;
    }

    else
    {
        _tempUrl = protocol + "//" + hostname + ":" +
                          _sspHttpsPort + "/" + sspName + 
                          _projectImpPath;
    }

    _projectImp.Url = _tempUrl;

    ProjectDerived.SetImpersonationContext(isWindowsUser,
                                           userName, userUid, 
                                           Guid.NewGuid(), 
                                           siteUid, lcid);

    bool _wasProjectCheckedOut = true;

    // Retrieve the sessionUid if checked out or 
    // Guid.Empty if not.
    Guid _sessionUid = GetSessionUid(pwaUrl, projectUid);

    // Determine whether the project was checked out.
    if (_sessionUid == Guid.Empty)
    {
        _wasProjectCheckedOut = false;
        _sessionUid = Guid.NewGuid();

        _projectImp.CheckOutProject(projectUid, _sessionUid,
                                    _sessionDesc);
    }

    Guid _jobUid = Guid.NewGuid();

    // Queue the update.
    _projectImp.QueueUpdateProject(_jobUid, _sessionUid,
                                   updateDataSet, false);

    // Republish the project.
    _jobUid = Guid.NewGuid();
    _projectImp.QueuePublish(_jobUid, projectUid, false, null);

    // If the project was not checked out, check it in
    if (!_wasProjectCheckedOut)
    {
        _jobUid = Guid.NewGuid();
        _projectImp.QueueCheckInProject(_jobUid, projectUid,
            false, _sessionUid, _sessionDesc);
    }
}

finally
{
    if (_projectImp != null) _projectImp.Dispose();
}

For more information about the methods used in this procedure, see Project Methods (WebSvcProject).

In the OnPublished method's try block, add a call to UpdateProject.

// If the username begins with AspNetSqlMembershipProvider,
// they are not a Windows user.
// Use logical negation to invert the StartsWith result.
bool _isWindowsUser = !(contextInfo.UserName.StartsWith
    ("AspNetSqlMembershipProvider"));

// Update and publish project.
UpdateProject(_handlerSettings.SspName, contextInfo.UserName,
              contextInfo.UserGuid, _isWindowsUser,
              contextInfo.SiteGuid, contextInfo.Lcid,
              _pwaInfo.Hostname, _pwaInfo.Protocol,
              _pwaInfo.PwaUrl, e.ProjectGuid,
              CreateUpdate(_pwaInfo.PwaUrl,
                           _targetFieldGuid,
                           _activeIssuesHealth,
                           e.ProjectGuid));

To use impersonation, you must know whether the user you are impersonating is a Windows Authentication user or not. Although the ContextInfo parameter passed into the event handler contains an IsWindowsUser property, I have observed some erratic behavior with this value. To avoid a call to the Resource PSI Web service, check the UserName property of the ContextInfo parameter. If it starts with a prefix associated with a custom MembershipProvider, the user is not a Windows Authentication user.

In Solution Explorer, add a new class named ActiveIssuesHealthInstaller.cs to the ActiveIssuesHealth project.

Add the following line to the global references section of ActiveIssuesHealthInstaller.cs.

using Microsoft.SharePoint;

Add the following global constants to the ActiveIssuesHealthInstaller class.

private const string _eventsSvcPath = "/_vti_bin/PSI/Events.asmx";
private const string _handlerName = "ActiveIssuesHealth";

Modify the ActiveIssuesHealthInstaller class to inherit the SPFeatureReceiver base abstract class.

using System;
using System.Net;
using System.Reflection;
using Microsoft.SharePoint;

namespace ActiveIssuesHealth
{
    class ActiveIssuesHealthnstaller : SPFeatureReceiver
    {
        private const string _eventsSvcPath = "/_vti_bin/PSI/Events.asmx";
        private const string _handlerName = "ActiveIssuesHealth";


        public override void FeatureActivated(
            SPFeatureReceiverProperties properties)
        {
            throw new NotImplementedException();
        }

        public override void FeatureDeactivating(
            SPFeatureReceiverProperties properties)
        {
            throw new NotImplementedException();
        }

        public override void FeatureInstalled(
            SPFeatureReceiverProperties properties)
        {
            throw new NotImplementedException();
        }

        public override void FeatureUninstalling(
            SPFeatureReceiverProperties properties)
        {
            throw new NotImplementedException();
        }
    }
}

For more information about the SPFeatureReceiver class, see SPFeatureReceiver Class (Microsoft.SharePoint).

Remove the throw new NotImplementedException() statement from all four methods.

Develop the FeatureActivated method. This method uses the Events PSI Web service to register the ActiveIssuesHealth event handler with the Project Server OnPublished event.

// Declarations.
Assembly _thisAssembly = null;
EventsSvc.Events _eventsPsi = null;
EventsSvc.EventHandlersDataSet _handlersDs = null;
EventsSvc.EventHandlersDataSet _handlersUpdateDs = null;
SPWeb _pwaWeb = null;

try
{
    // Initializations.
    _pwaWeb = properties.Feature.Parent as SPWeb;
    _eventsPsi = new EventsSvc.Events();
    _thisAssembly = Assembly.GetExecutingAssembly();

    if (_pwaWeb == null)
        throw new Exception("Unable to load SPWeb.");

    // Initialize and configure Web reference.
    _eventsPsi = new EventsSvc.Events();
    _eventsPsi.Credentials =
        CredentialCache.DefaultCredentials;
    _eventsPsi.Url = _pwaWeb.Url + _eventsSvcPath;

    // Get a list of event handlers.
    _handlersDs =
        _eventsPsi.ReadEventHandlerAssociationsForEvent(
            EventsSvc.PSEventID.ProjectPublished);

    _handlersUpdateDs = 
        _handlersDs.Copy() as EventsSvc.EventHandlersDataSet;

    bool _handlerAlreadyExists = false;

    // Ensure that the event handler does not already exist.
    foreach (
        EventsSvc.EventHandlersDataSet.EventHandlersRow _row
        in _handlersUpdateDs.EventHandlers)
    {
        if (_row.Name == _handlerName)
            _handlerAlreadyExists = true;
    }

    if (!_handlerAlreadyExists)
    {
        _handlersUpdateDs.EventHandlers.AddEventHandlersRow(
            Guid.NewGuid(), _handlerName, _thisAssembly.FullName,
            (_handlerName + ".ActiveIssuesHealthHandler"),
            (int)EventsSvc.PSEventID.ProjectPublished,
            "ActiveIssuesHealth Handler", 0);

        // Associate the event handler.
        _eventsPsi.CreateEventHandlerAssociations(
            _handlersUpdateDs);

        // Create custom settings in Web's SPPropertyBag.
        HandlerSettings.SetHandlerSettings(
            _pwaWeb.Site.ID,
            HandlerSettings.ActiveStatusValueKey, "(1) Active");

        HandlerSettings.SetHandlerSettings(
            _pwaWeb.Site.ID,
            HandlerSettings.SspNameKey, "EPM_SSP");

        HandlerSettings.SetHandlerSettings(
            _pwaWeb.Site.ID,
            HandlerSettings.TargetCustomFieldKey, "Active Issues Health");
    }
}

finally
{
    if (_eventsPsi != null) _eventsPsi.Dispose();
    if (_handlersDs != null) _handlersDs.Dispose();
    if (_handlersUpdateDs != null) _handlersUpdateDs.Dispose();
    if (_pwaWeb != null) _pwaWeb.Dispose();
}

For more information about the Events PSI Web service, see Events Class (WebSvcEvents).

For more information about the Assembly class used in this procedure, see Assembly Class.

Develop the FeatureDeactivated method. This method uses the Events PSI Web service to remove the registration of the ActiveIssuesHealth event handler from the Project Server OnPublished event.

// Declarations.
EventsSvc.Events _eventsPsi = null;
EventsSvc.EventHandlersDataSet _handlersDs = null;
EventsSvc.EventHandlersDataSet _handlersUpdateDs = null;
SPWeb _pwaWeb = null;

try
{
    // Initializations.
    _pwaWeb = properties.Feature.Parent as SPWeb;
    _eventsPsi = new EventsSvc.Events();
    Guid[] _eventHandlerGuids = new Guid[1];

    if (_pwaWeb == null)
        throw new Exception("Unable to load SPWeb.");

    // Initialize and configure Web reference.
    _eventsPsi = new EventsSvc.Events();
    _eventsPsi.Credentials =
        CredentialCache.DefaultCredentials;
    _eventsPsi.Url = _pwaWeb.Url + _eventsSvcPath;

    // Get a list of event handlers.
    _handlersDs =
        _eventsPsi.ReadEventHandlerAssociationsForEvent(
            EventsSvc.PSEventID.ProjectPublished);

    _handlersUpdateDs = 
        _handlersDs.Copy() as EventsSvc.EventHandlersDataSet;

    // Ensure that the event handler does not already exist.
    foreach (
        EventsSvc.EventHandlersDataSet.EventHandlersRow _row
        in _handlersUpdateDs.EventHandlers)
    {
        if (_row.Name == _handlerName)
        {
            _eventHandlerGuids[0] = _row.EventHandlerUid;
            _eventsPsi.DeleteEventHandlerAssociations(
                _eventHandlerGuids);
        }
    }

    // Create custom settings in Web's SPPropertyBag.
    HandlerSettings.SetHandlerSettings(
        _pwaWeb.Site.ID,
        HandlerSettings.ActiveStatusValueKey, "");

    HandlerSettings.SetHandlerSettings(
        _pwaWeb.Site.ID,
        HandlerSettings.SspNameKey, "");

    HandlerSettings.SetHandlerSettings(
        _pwaWeb.Site.ID,
        HandlerSettings.TargetCustomFieldKey, "");
}

finally
{
    if (_eventsPsi != null) _eventsPsi.Dispose();
    if (_handlersDs != null) _handlersDs.Dispose();
    if (_handlersUpdateDs != null) _handlersUpdateDs.Dispose();
    if (_pwaWeb != null) _pwaWeb.Dispose();
}

Add a new project of type Class Library named ActiveIssuesHealthConfig to the solution.

Rename Class1.cs to SetSspName.cs.

Edit the properties for the ActiveIssuesHealthConfig project, enable assembly signing, and create a new keyfile.

In Solution Explorer, in the Add Reference dialog box, add a reference to Microsoft.SharePoint.dll. Following is the default file location:

%ProgramFiles%\Common Files\Microsoft Shared\Web Server Extensions\12\ISAPI\

Note

If you are developing on a 64-bit server, you should manually browse to drive\Program Files instead of using the %ProgramFiles% environment variable. Because Visual Studio 2008 is a 32-bit application running under the WOW64 emulator, %ProgramFiles% resolves to drive\Program Files (x86) in a 64-bit environment.

Add a reference to the ActiveIssuesHealth project to the ActiveIssuesHealthConfigproject.

Add the following lines to the global references section of SetSspName.cs.

using System.Collections.Specialized;
using Microsoft.SharePoint;
using Microsoft.SharePoint.StsAdmin;
using ActiveIssuesHealth;

Add the following constant to the SetSspName class.

private const int _pwaSiteTemplateId = 6221;

Modify the SetSspName class to implement the ISPStsadmCommand interface.

using System;
using System.Collections.Specialized;
using System.Text;
using Microsoft.SharePoint;
using Microsoft.SharePoint.StsAdmin;
using ActiveIssuesHealth;

namespace ActiveIssuesHealthConfig
{
    public class SetSspName : ISPStsadmCommand
    {
        private const int _pwaSiteTemplateId = 6221;

        #region ISPStsadmCommand Members
        public string GetHelpMessage(string command)
        {
            throw new NotImplementedException();
        }

        public int Run(string command, 
            StringDictionary keyValues, out string output)
        {
            throw new NotImplementedException();
        }
        #endregion
    }
}

Remove the throw new NotImplementedException() statement from both methods.

Develop the GetHelpMessage method. This method simply prints out a help message for the extension.

StringBuilder _helpSb = new StringBuilder();
_helpSb.AppendLine();
_helpSb.AppendLine();
_helpSb.AppendLine("ActiveIssuesHealth - SetSspName Operation");
_helpSb.AppendLine();
_helpSb.AppendLine();
_helpSb.AppendLine("Parameters:");
_helpSb.AppendLine();
_helpSb.AppendLine("\t-url <PWA Site URL>");
_helpSb.AppendLine("\t-sspname <Name of PWA Site's SSP>");
_helpSb.AppendLine();
_helpSb.AppendLine();
_helpSb.AppendLine("Example:");
_helpSb.Append("\tstsadm -o setsspname");
_helpSb.Append(" -url http://projserv/pwa");
_helpSb.AppendLine(" -sspname SharedServices1");

return _helpSb.ToString();

Create a method named SspName.

private static int SspName(StringDictionary keyValues)
{
}

Develop the SspName method. This method instantiates the necessary SharePoint classes, validates that the user is attempting to configure a PWA site, and passes the parameters specified on the command line to the HandlerSettings class that you created earlier, for storage in the SPPropertyBag.

SPSite _pwaSite = null;
SPWeb _pwaWeb = null;

try
{
    _pwaSite = new SPSite(keyValues["url"]);
    _pwaWeb = _pwaSite.RootWeb;

    if (_pwaWeb == null)
        throw new Exception("Could not load the specified URL.");

    if (_pwaWeb.WebTemplateId != _pwaSiteTemplateId)
        throw new Exception("You may only configure PWA Sites.");

    HandlerSettings.SetHandlerSettings(_pwaSite.ID,
        HandlerSettings.SspNameKey, keyValues["sspname"]);

    return 0;
}

finally
{
    if (_pwaSite != null) _pwaSite.Dispose();
    if (_pwaWeb != null) _pwaWeb.Dispose();
}

Develop the Run method. This method validates the syntax and calls the SspName method that you created earlier.

string _commandLower = command.ToLowerInvariant();

output = String.Empty;

if (!keyValues.ContainsKey("url"))
    throw new InvalidOperationException(
        "A URL was not specified.");

if (!keyValues.ContainsKey("sspname"))
    throw new InvalidOperationException(
        "A SSP Name was not specified.");

switch (_commandLower)
{
    case "setsspname":
        return SspName(keyValues);
        
    default:
        throw new InvalidOperationException();
}

In Solution Explorer, add a new class named SetActiveStatusValue.cs to the ActiveIssuesHealthConfig project.

Add the following lines to the global references section of SetActiveStatusValue.cs.

using System.Collections.Specialized;
using Microsoft.SharePoint;
using Microsoft.SharePoint.StsAdmin;
using ActiveIssuesHealth;

Add the following constant to the SetActiveStatusValue class.

private const int _pwaSiteTemplateId = 6221;

Modify the SetActiveStatusValue class to implement the ISPStsadmCommand interface.

using System;
using System.Collections.Specialized;
using System.Text;
using Microsoft.SharePoint;
using Microsoft.SharePoint.StsAdmin;
using ActiveIssuesHealth;

namespace ActiveIssuesHealthConfig
{
    public class SetActiveStatusValue : ISPStsadmCommand
    {
        private const int _pwaSiteTemplateId = 6221;

        #region ISPStsadmCommand Members
        public string GetHelpMessage(string command)
        {
            throw new NotImplementedException();
        }

        public int Run(string command, 
            StringDictionary keyValues, out string output)
        {
            throw new NotImplementedException();
        }
        #endregion
    }
}

Remove the throw new NotImplementedException() statement from both methods.

Develop the GetHelpMessage method. This method simply prints out a help message for the extension.

StringBuilder _helpSb = new StringBuilder();
_helpSb.AppendLine();
_helpSb.AppendLine();
_helpSb.AppendLine(
    "ActiveIssuesHealth - SetActiveStatusValue Operation");
_helpSb.AppendLine();
_helpSb.AppendLine();
_helpSb.AppendLine("Parameters:");
_helpSb.AppendLine();
_helpSb.AppendLine("\t-url <PWA Site URL>");
_helpSb.AppendLine("\t-activestatusvalue <Active Status Value>");
_helpSb.AppendLine();
_helpSb.AppendLine();
_helpSb.AppendLine("Example:");
_helpSb.Append("\tstsadm -o setactivestatusvalue");
_helpSb.Append(" -url http://projserv/pwa");
_helpSb.AppendLine(@" -activestatusvalue ""(1) Active""");

return _helpSb.ToString();

Create a method named ActiveStatusValue.

private static int ActiveStatusValue(StringDictionary keyValues)
{
}

Develop the ActiveStatusValue method. This method instantiates the necessary SharePoint classes, validates that the user is attempting to configure a PWA site, and passes the parameters specified on the command line to the HandlerSettings class that you created earlier, for storage in the SPPropertyBag.

SPSite _pwaSite = null;
SPWeb _pwaWeb = null;

try
{
    _pwaSite = new SPSite(keyValues["url"]);
    _pwaWeb = _pwaSite.RootWeb;

    if (_pwaWeb == null)
        throw new Exception("Could not load the specified URL.");

    if (_pwaWeb.WebTemplateId != _pwaSiteTemplateId)
        throw new Exception("You may only configure PWA Sites.");

    HandlerSettings.SetHandlerSettings(_pwaSite.ID,
        HandlerSettings.ActiveStatusValueKey, 
        keyValues["activestatusvalue"]);

    return 0;
}

finally
{
    if (_pwaSite != null) _pwaSite.Dispose();
    if (_pwaWeb != null) _pwaWeb.Dispose();
}

Develop the Run method. This method validates the syntax and calls the ActiveStatusValue method that you created earlier.

string _commandLower = command.ToLowerInvariant();

output = String.Empty;

if (!keyValues.ContainsKey("url"))
    throw new InvalidOperationException(
        "A URL was not specified.");

if (!keyValues.ContainsKey("activestatusvalue"))
    throw new InvalidOperationException(
        "An Active Status Value was not specified.");

switch (_commandLower)
{
    case "setactivestatusvalue":
        return ActiveStatusValue(keyValues);
        
    default:
        throw new InvalidOperationException();
}

In Solution Explorer, add a new class named SetTargetCustomField.cs to the ActiveIssuesHealthConfig project.

Add the following lines to the global references section of SetTargetCustomField.cs.

using System.Collections.Specialized;
using Microsoft.SharePoint;
using Microsoft.SharePoint.StsAdmin;
using ActiveIssuesHealth;

Add the following constant to the SetTargetCustomField class.

private const int _pwaSiteTemplateId = 6221;

Modify the SetTargetCustomField class to implement the ISPStsadmCommand interface.

using System;
using System.Collections.Specialized;
using System.Text;
using Microsoft.SharePoint;
using Microsoft.SharePoint.StsAdmin;
using ActiveIssuesHealth;

namespace ActiveIssuesHealthConfig
{
    public class SetTargetCustomField : ISPStsadmCommand
    {
        private const int _pwaSiteTemplateId = 6221;

        #region ISPStsadmCommand Members
        public string GetHelpMessage(string command)
        {
            throw new NotImplementedException();
        }

        public int Run(string command, 
            StringDictionary keyValues, out string output)
        {
            throw new NotImplementedException();
        }
        #endregion
    }
}

Remove the throw new NotImplementedException() statement from both methods.

Develop the GetHelpMessage method. This method simply prints out a help message for the extension.

StringBuilder _helpSb = new StringBuilder();
_helpSb.AppendLine();
_helpSb.AppendLine();
_helpSb.AppendLine(
    "ActiveIssuesHealth - SetTargetCustomField Operation");
_helpSb.AppendLine();
_helpSb.AppendLine();
_helpSb.AppendLine("Parameters:");
_helpSb.AppendLine();
_helpSb.AppendLine("\t-url <PWA Site URL>");
_helpSb.AppendLine(
    "\t-targetcustomfield <Name of Target Custom Field>");
_helpSb.AppendLine();
_helpSb.AppendLine();
_helpSb.AppendLine("Example:");
_helpSb.Append("\tstsadm -o settargetcustomfield");
_helpSb.Append(" -url http://projserv/pwa");
_helpSb.AppendLine(@" -targetcustomfield ""Active Issues""");

return _helpSb.ToString();

Create a method named ActiveStatusValue.

private static int SetTargetCustomField(StringDictionary keyValues)
{
}

Develop the TargetCustomField method. This method instantiates the necessary SharePoint classes, validates that the user is attempting to configure a PWA site, and passes the parameters specified on the command line to the HandlerSettings class that you created earlier, for storage in the SPPropertyBag.

SPSite _pwaSite = null;
SPWeb _pwaWeb = null;

try
{
    _pwaSite = new SPSite(keyValues["url"]);
    _pwaWeb = _pwaSite.RootWeb;

    if (_pwaWeb == null)
        throw new Exception("Could not load the specified URL.");

    if (_pwaWeb.WebTemplateId != _pwaSiteTemplateId)
        throw new Exception("You may only configure PWA Sites.");

    HandlerSettings.SetHandlerSettings(_pwaSite.ID,
        HandlerSettings.TargetCustomFieldKey, 
        keyValues["targetcustomfield"]);

    return 0;
}

finally
{
    if (_pwaSite != null) _pwaSite.Dispose();
    if (_pwaWeb != null) _pwaWeb.Dispose();
}

Develop the Run method. This method validates the syntax and calls the TargetCustomField method that you created earlier.

string _commandLower = command.ToLowerInvariant();

output = String.Empty;

if (!keyValues.ContainsKey("url"))
    throw new InvalidOperationException(
        "A URL was not specified.");

if (!keyValues.ContainsKey("TargetCustomField"))
    throw new InvalidOperationException(
        "An Active Status Value was not specified.");

switch (_commandLower)
{
    case "setTargetCustomField":
        return TargetCustomField(keyValues);
        
    default:
        throw new InvalidOperationException();
}

Add a new SharePoint project of type Empty named ActiveIssuesHealthWsp to the solution.

In the Select Trust Level dialog box, choose Full Trust.

Add a reference to the ActiveIssuesHealth project to the ActiveIssuesHealthWspproject.

Add a reference to the ActiveIssuesHealthConfig project to the ActiveIssuesHealthWsp project.

Add a new SharePoint item of type Root File named StsAdmCommands.ActiveIssuesHealth.xml to the ActiveIssuesHealthWsp project.

In Solution Explorer, double-click StsAdmCommands.ActiveIssuesHealth.xml to open it for editing.

Delete the current contents of StsAdmCommands.ActiveIssuesHealth.xml and replace with the following.

<?xml version="1.0" encoding="utf-8" ?>
<commands>
  <command name="SetActiveStatusValue" 
           class="ActiveIssuesHealthConfig.SetActiveStatusValue, 
              ActiveIssuesHealthConfig,
              Version=1.0.0.0,
              Culture=neutral,
              PublicKeyToken=xxxxxxxxxxxxxxxx" />
  <command name="SetSspName" 
           class="ActiveIssuesHealthConfig.SetSspName, 
              ActiveIssuesHealthConfig,
              Version=1.0.0.0,
              Culture=neutral,
              PublicKeyToken=xxxxxxxxxxxxxxxx" />
  <command name="SetTargetCustomField" 
           class="ActiveIssuesHealthConfig.SetTargetCustomField, 
              ActiveIssuesHealthConfig, 
              Version=1.0.0.0, 
              Culture=neutral, 
              PublicKeyToken=xxxxxxxxxxxxxxxx" />
</commands>

Note

Replace the three PublicKeyTokens above with the correct value for your assembly.

Create a new folder named Config in the RootFiles folder of the ActiveIssuesHealthWsp project.

In Solution Explorer, drag StsAdmCommands.ActiveIssuesHealth.xml into the Config folder that you just created.

In Solution Explorer, switch to the WSP View, and then click Refresh.

Click Create New Feature.

When prompted, choose a Web scope. Ensure that the options to create a default manifest.xml and feature receiver are cleared (not selected).

Rename the feature to ActiveIssuesHealth.

Expand the feature, and then double-click feature.xml to open it for editing.

Being careful to not change the Feature Id setting, make the following modifications to the file.

Title="ActiveIssuesHealth" 
Description="ActiveIssuesHealth Sample" 
ReceiverAssembly="ActiveIssuesHealth, Version=1.0.0.0, 
    Culture=neutral, PublicKeyToken=xxxxxxxxxxxxxxxx" 
ReceiverClass="ActiveIssuesHealth.ActiveIssuesHealthInstaller" 

Note

Replace the PublicKeyToken above with the correct value for your assembly.

Save and close feature.xml.

On the Build menu, click Package Solution.

Open a Command Prompt window and browse to the bin directory in the "12 Hive". Following is the default location:

c:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\BIN\

Use the Stsadm addsolution operation to install the solution. For example, you would execute the following:

stsadm -o addsolution -filename c:\ActiveIssuesHealthWsp.wsp

After the command reports a successful completion, open Internet Explorer and browse to Central Administration.

Open the Operations section. In the Global Configuration section, click Solution Management.

On the Solution Management page, in the list of installed solutions, click ActiveIssuesHealthwsp.wsp.

Click Deploy Solution.

Specify a deployment time, if desired. Otherwise, ensure that the Now option is selected, and then click OK.

This returns you to the Solution Management page. After the status column for ActiveIssuesHealthwsp.wsp displays Deployed, browse to the PWA site where you want to install ActiveIssuesHealth.

On the Site Actions menu, click Site Settings.

On the Site Settings page, in the Site Administration section, click Site features.

For ActiveIssuesHealth, click Activate.

Use the Stsadm extensions to configure the handler's settings, and then publish a test project.