Eddie@Blog

Protecting WCF Data Services using OAuth

Fri, 20 May 2011 02:00:00 -0400

Regarding this topic, there is a nice post hereby Alex James. One thing that I am wondering after reading the article, is that the demo rely on HttpModule and HttpContext.Current directly. For the purpose of test automation, I would like to avoid this if at all possible. And Andrew Arnott ships an example of securing WCF service using OAuth, in his DotNetOpenAuth library, which use ServiceAuthorizationManager and IAuthorizationPolicy to inject identities. This approach is more flexible in my case, and I don’t have to worry about combining this with Form authentication, which is used by the existing part of the application.

In this post, I am going to build a demo WCF Data Service which is protected by OAuth using ServiceAuthorizationManager.

Since this post is focus on gaining access to protected resources, I will start from the point that the client already has the access token. First, let’s take a look at what’s needed before coding.

DotNetOpenAuth, used to validate OAuth tokens;
A pair of valid OAuth access token and secret;
Simple WCF Data Service to be protected;

Before setting up the authorization, we need a simple entity model to backup the Data Service. The EDM is created using Code-First, as shown in the following diagram.

And the WCF Data Service.

public class SimpleDbService : DataService<SimpleDbContext>
{
    public static void InitializeService(DataServiceConfiguration config)
    {
        config.SetEntitySetAccessRule("Contacts", EntitySetRights.AllRead);
        config.SetEntitySetAccessRule("Employees", EntitySetRights.AllRead);
        config.DataServiceBehavior.MaxProtocolVersion = DataServiceProtocolVersion.V3;
        config.UseVerboseErrors = true;
    }
}

The next is to implement a custom OAuthAuthorizationManager. In the CheckAccessCore method, it will try to extract the access token from the authorization header, which is available from the request message. And then issue the corresponding identity if the request containing a valid access token.

protected override bool CheckAccessCore(OperationContext operationContext)
{
    if (!base.CheckAccessCore(operationContext))
    {
        return false;
    }

    // Resolve OAuth service provider.
    var oAuthProvider = SessionContext.Container.Resolve<ServiceProvider>();

    // Extract authorization data.
    var requestMessage = operationContext.RequestContext.RequestMessage;
    var httpDetails = requestMessage.Properties[HttpRequestMessageProperty.Name] 
        as HttpRequestMessageProperty;
    var requestUri = requestMessage.Properties.Via;

    // Validate the access token.
    var authorizedRequest = oAuthProvider.ReadRequest(
        new HttpRequestInfo(httpDetails, requestUri)) as AccessProtectedResourceRequest;

    IIdentity identity;
    ServiceSecurityContext securityContext;

    if (authorizedRequest != null)
    {
        // Create OAuth principal and identity from the access token.
        var principal = oAuthProvider.CreatePrincipal(authorizedRequest);

        // Initialize the security context, which will then issued the name claim in the policy.
        securityContext = new ServiceSecurityContext(
            new List<IAuthorizationPolicy>()
            {
                new OAuthPrincipalAuthorizationPolicy(principal) 
            }.AsReadOnly());

        identity = principal.Identity;
    }
    else
    {
        // Issue anonymous principal and identity.
        securityContext = ServiceSecurityContext.Anonymous;
        var principal = new GenericPrincipal(new GenericIdentity(String.Empty), new string[0]);
        securityContext.AuthorizationContext.Properties["Principal"] = principal;

        identity = principal.Identity;
    }

    // Setup the security context and identity.
    operationContext.IncomingMessageProperties.Security.ServiceSecurityContext = securityContext;
    securityContext.AuthorizationContext.Properties["Identities"] = new List<IIdentity> { identity };
            
    // The service will handle security, so allow the process continue here regardless.
    return true;
}

The OAuthPrincipalAuthorizationPolicy used above is the same as the one in Andrew’s example, which sets the name claim and principal.

public bool Evaluate(EvaluationContext evaluationContext, ref object state)
{
    evaluationContext.AddClaimSet(
        this, new DefaultClaimSet(Claim.CreateNameClaim(this.principal.Identity.Name)));
    evaluationContext.Properties["Principal"] = this.principal;
    return true;
}

The implementation here will allow anonymous access, so that our WCF Data Service can response selectively. For instance, I want to allow anonymous to query Contact entries, but only authorized request are allowed to query Employee entries. To grad operations, we can use QueryIntercepter and ChangeIntercepter to monitor the requests, and response with 401 if the contextual identity is not authenticated.

[QueryInterceptor("Employees")]
public Expression<Func<Employee, bool>> OnQueryEmployees()
{
    if (ServiceSecurityContext.Current == null || 
        !ServiceSecurityContext.Current.PrimaryIdentity.IsAuthenticated)
    {
        throw new DataServiceException(401, "Access is denied.");
    }

    return e => true;
}

Finally, to tie all of these things together, we need to configure the custom authorization manger via service behaviour. The following will set the custom authorization manager as default.

<behavior name="">
  <serviceDebug includeExceptionDetailInFaults="true"/>
  <serviceAuthorization serviceAuthorizationManagerType="Dymetis.Security.Authorization.OAuthAuthorizationManager, Dymetis.Security" principalPermissionMode="Custom" />
</behavior>

Now, if querying Contact entries using browser, you should see the data feed, as shown in the following screen shot.

While accessing the Employee entries will receive 401 Unauthorized.

So how can we attach the authorization header when sending requests using Data Service Client? First, we need to turn the access token into authorization header. The following sample simply get the header from a request prepared using DotNetOpenAuth.

var consumerClient = new WebConsumer(description, consumerTokenManager);
var serviceEndpoint = new MessageReceivingEndpoint(
    new Uri(baseAddress, "Contacts"),
    HttpDeliveryMethods.AuthorizationHeaderRequest | HttpDeliveryMethods.PostRequest);
var httpRequest = consumerClient.PrepareAuthorizedRequest(serviceEndpoint, accessToken.Token);
var authHeader = httpRequest.Headers[HttpRequestHeader.Authorization];

Not like regular WCF service client, which use OperationContextScope to modify the headers, when using data service client, we can inject our header by listening SendingRequest event.

var dataContext = new SimpleDbContext(baseAddress);
dataContext.SendingRequest += (sender, e) => e.RequestHeaders[HttpRequestHeader.Authorization] = authHeader;

Now we’re good for publishing and accessing WCF Data Service using OAuth. Even though the above example is using OAuth 1.0, the same principals should work for any authorization flow that using HTTP header to send security tokens. In the next post, I am going to automated the tests for this demo, which is one of my major concern.

Screen Capturing with Silverlight Applications

Thu, 05 May 2011 00:29:00 -0400

The user of a Silverlight application is keep complaining about he couldn't capture pictures of the application. I navigate to the web site, press print screen, paste into Paint.NET, and everything works as expected. After sitting with the user, it turns out that he is using a Firefox extension Screengrab to capture the web page.

Then I browsing around the internet, and using couples of screen capturing extensions to shoot Silverlight apps. Apparently, most of Silverlight apps don’t like these extensions. The following screen shot shows what happen when using Google Capture with the Silverlight template.

This sounds like overlapping issue, and the solution is simple – setting windowless parameter to true in the Silverlight object tag. It will look like this, which is getting from silverlight.net.

But the parameter windowless comes with costs, it should be turn on only if necessary. See herefor more details.

TFS Event Filtering, Logical Expressions and Expression Tree

Tue, 19 Apr 2011 09:37:00 -0400

In TFS, we can filter the server events by using Visual Studio Event Filter Language (VSEFL). Obviously, VSEFL is a variation of logical expression. On the other hand, since C# 3.0 introduces Expression Tree, I am always seeking for a lightweight library can translate logical expressions to Expression tree, and vice versa. So that the program can manipulate the expression easily, and then evaluate it as Lambda expression. However, the VSEFL parser is hidden inside TFS’ assemblies. This post will present a way to implement a parser for translating logical expressions, which is used to support VSEFL in the this project.

First of all, let’s compare the VSEFL with C# expressions, and how we do it in C#. Note that I assume there’s no side effect when retrieving field values, hence logical AND/OR are considered the same as short-circuiting conditional AND/OR.

VSEFL	Expression Type	C#
AND	And	&&
OR	Or	\|\|
NOT	Not	!
=	Equal	==
<>	NotEqual	!=
<	LessThan	<
<=	LessThanOrEqual	<=
>	GreaterThan	>
>=	GreaterThanOrEqual	>=
UNDER		String.StartsWith
MATCH, LIKE		Regex.IsMatch
Integer Literal	Constant	Int32.ToString
String Literal	Constant	String
NULL	Constant	null
Date Expression		DateTime.Now, DateTime.Parse and DateTime.AddDays
Value by Field Name	Parameter	variables

As shown in the above table, some of the VSEVL operators have no corresponding expression, but they can be easily simulated as one or more method calls.

In the following event filter for a BuildCompletionEvent2 event, the expression will yield all non-succeed builds that belong to DemoProject.

DefinitionPath Under '\DemoProject\'
AND (
	StatusCode LIKE 'Stopped|Failed|PartiallySucceeded'
	OR (
		StatusCode = Succeeded
		AND TestStatus <> Succeeded
	)
)

As you saw, field names are presented as string literals in VSEVL. In my case, I want to have a more generic expression parser, which will need to know exactly a token is field or literal. Anyway, let’s see how the expression tree can be built in C# manually.

var paramDefinitionPath = Expression.Parameter(typeof(string), "DefinitionPath");
var paramStatusCode = Expression.Parameter(typeof(string), "StatusCode");
var paramTestStatus = Expression.Parameter(typeof(string), "TestStatus");

var expression =
    Expression.And(
        Expression.Call(
            paramDefinitionPath,
            typeof(string).GetMethod("StartsWith", new[] { typeof(string), typeof(StringComparison) }),
            Expression.Constant(@"\DemoProject\", typeof(string)),
            Expression.Constant(StringComparison.OrdinalIgnoreCase, typeof(StringComparison))
        ),
        Expression.Or(
            Expression.Call(
                typeof(Regex).GetMethod("IsMatch",
                    new[] { typeof(string), typeof(string), typeof(RegexOptions) }),
                paramStatusCode,
                Expression.Constant("Stopped|Failed|PartiallySucceeded", typeof(string)),
                Expression.Constant(RegexOptions.IgnoreCase, typeof(RegexOptions))
            ),
            Expression.And(
                Expression.Equal(
                    paramStatusCode,
                    Expression.Constant("Succeeded", typeof(string))
                ),
                Expression.NotEqual(
                    paramTestStatus,
                    Expression.Constant("Succeeded", typeof(string))
                )
            )
        )
    );

var lambda = Expression.Lambda<Func<string, string, string, bool>>(
    expression, paramDefinitionPath, paramStatusCode, paramTestStatus);

var result = lambda.Compile().Invoke(@"\DemoProject\MyApp", "Succeeded", "Failed");
Assert.IsTrue(result);

Essentially, it a tree with various types of expression nodes. Here’s how it looks like graphically.

So far, we have everything in VSEFL mapped out to expressions, or if needed, we can always map special operations to method calls. The rest of the task is simply string parsing. For the expressions discussed here, a forward only algorithm is enough and given a time complexity of O(n), where n is the length of the input expression. If you want to handle more complicate scenario, you may want to check out DLR or ANTLR before working on your lexer.

As previously mentioned, I want to represent fields(or parameters) in a way that different from string literals. I have chosen to prefix parameters with dollar sign ($), which is the simplest I found, in terms of converting existing VSEFL expressions.

Another tricky thing is the comparisons. Due to lack of data type information, the parameters values are always supplied as objects, and this may cause confusion if a value can be implicitly converted to the other data type. See the following example which comparing Int32 and Int64 values.

int intVal = 123;
long longVal = 123;
 
// True
Console.WriteLine(intVal == longVal);
 
// False
Console.WriteLine((object)intVal == (object)longVal);

// False
Console.WriteLine(((object)intVal).Equals(longVal));

To solve this, the trick is converting the values as dynamic first, even though this way requires warping the comparisons as a method call.

Lastly, this how to evaluate the sample expression using the parser. Have a look a the source here if you are interested.

var input =
    "$DefinitionPath Under '\\DemoProject\\' " +
    "AND (" +
    "    $StatusCode LIKE 'Stopped|Failed|PartiallySucceeded' " +
    "    OR ( " +
    "        $StatusCode = Succeeded " +
    "        AND $TestStatus <> Succeeded " +     
    "    ) " +     
    ")";
 
var parameters = CreateLookup(
    Tuple.Create("DefinitionPath", @"\DemoProject\MyApp"),
    Tuple.Create("StatusCode", @"Succeeded"),
    Tuple.Create("TestStatus", @"Failed")
);
 
var expression = LogicalExpression.Parse(input, LogicalExpressionSyntax.ExtendedEventFilter);
 
var result = expression.Evaluate(parameters);
 
Assert.IsTrue(result);

Event Notification Plugin for TFS 2010

Tue, 22 Mar 2011 23:50:00 -0400

Couple days ago, I published the Team Alert project on CodePlex. It is a server side extension for TFS 2010, which allows you sending E-Mail notifications to any person field in the event, regardless the field contain a SID, account name or display name. Of course, you may configure it to send notification to fixed E-Mail addresses too.

I have described some situations that you may want to notify contextual users in my previous post. Here is a quick comparison between Project Alerts, Alert Editor and Team Alert.

	Project Alerts	Alert Editor	Team Alert
Supported Events	WIC, C, BC, BSC	BC, BRSC, C, WIC, BSC	BC, WIC
Filter Expression	Predefined	VSEFL	VSEFL(modified)
Delivery Type	Html, Plain Text, SOAP	Html, Plain Text, SOAP	Html, Plain Text
Work Item Custom Fields	Not Supported	Not Supported	Supported
Person Fields as Recipients	Not Supported	Not Supported	Supported
Configuration	Team Explorer, TFS Web Access	Team Explorer with Power Tool	Configuration File

* WIC – WorkItemChangedEvent, BC – BuildCompletionEvent, BSC – BuildStatusChangeEvent, BRSC – BuildResourceStatusChanges, C – CheckinEvent

Apparently, Team Alert is not a replacement of any of these tools. At least, it does not provide any client side subscription tool yet, but it does have additional features that I need.

Now, let's see how to configure it. Download the binary from CodePlex, and then replace the configuration file with the following. Note that we specified that we want to attach the event XML.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="teamAlert" type="Dymetis.TeamAlert.Configuration.TeamAlertConfigurationSection, Dymetis.TeamAlert"/>
  </configSections>

  <teamAlert>
    <alerts>
      <alert
        name="Debug WorkItemChangedEvent"
        event="WorkItemChangedEvent">
 
        <recipients>
          <recipient
            name="Dev"
            address="YourEmail@YourDomain.com"
            type="EmailAddress"
            allowHtml="true"
            attachRawEvent="true"/>
        </recipients>
      </alert>
    </alerts>
  </teamAlert>
 
</configuration>

Copy the assembly and configuration to the TFS Plugins folder, such as X:\Program Files\Microsoft Team Foundation Server 2010\Application Tier\Web Services\bin\Plugins. TFS will restart automatically.

Once any work item changed, you should receive an E-Mail like this:

If you open the attached XML, it should contain all core fields, changed fields, text fields, and custom fields, if there is any. Now we got the sample XML, writing the XPath for filter expression is a piece of cake. Alternately, you can check out the schema in tbl_EventType table, just keep in mind that the CustomField element is appended by Team Alert as a work around.

If you start wonder how it helps, let's say we use TFS as Bug tracking system. And in the case of a bug get updated by developers, the reporter of the bug should be notified. Normally, you may need to subscribe each reporter to the WorkItemChangedEvent, or write a custom SOAP web service for this.

Here is how you to achieve this with Team Alert. First, an expression is defined to filter events. The first half will limit the work item to bugs only, and the second half will prevent the reporter get notify for his/her own changes. The only different between this and VSEFL is a dollar sign is added in front of each field. (This may not be the only different, because it seems VSEFL doesn't allow you specify a field on the right side of Boolean operators based on its definition, but the March release of TFS power tool do put fields on both sides.)

$"CoreFields/StringFields/Field[ReferenceName='System.WorkItemType']/NewValue" 
	= Bug 
AND $"CoreFields/StringFields/Field[ReferenceName='System.AuthorizedAs']/NewValue" 
	<> $"CoreFields/StringFields/Field[ReferenceName='System.CreatedBy']/NewValue"

Then we specify the recipient to be the user of this field:

CoreFields/StringFields/Field[ReferenceName='System.CreatedBy']/NewValue

The whole alert configuration element will look like this:

<alert
  name="Bug Changes"
  event="WorkItemChangedEvent"
  filterExpression="$&quot;CoreFields/StringFields/Field[ReferenceName='System.WorkItemType']/NewValue&quot; = Bug AND $&quot;CoreFields/StringFields/Field[ReferenceName='System.AuthorizedAs']/NewValue&quot; &lt;&gt; $&quot;CoreFields/StringFields/Field[ReferenceName='System.CreatedBy']/NewValue&quot;">
  <recipients>
    <recipient
      name="Owner"
      address="CoreFields/StringFields/Field[ReferenceName='System.CreatedBy']/NewValue"
      type="DisplayNameField"
      allowHtml="true"/>
  </recipients>
</alert>

And now, all you have to do it wait for something happen, and confirm that the guys are getting notifications. If you didn't receive E-Mails, check the event log on the server of TFS, or use the first configuration to get the XML and test your XPath.

Thank you for reading. Feedbacks and suggestions are welcome.

Masking Links in Comment (BlogEngine.NET)

Sun, 20 Mar 2011 02:05:00 -0400

Recently, I start getting spam comments, and some of them are smart enough to pass the filters. As these comments have been validated, they are likely suitable to be displayed. But if they contain links in the content, I don’t want to the show the links before I checked them. In the other word, I want to mask the links before I add the corresponding domain into whitelist.

For unverified sites, they should be displayed like these:

www.affiliate.com => www.***.com
http://www.affiliate.com => http://www.***.com
https://www.affiliate.net/abc.html => https://www.***.net/abc.html

The domains in whitelist should be converted.

I created a simple extension for BlogEngine.NET to achieve this. This is the outcome:

And you may specify the masking pattern and allowed domains in the extension settings.

To create such an extension in BlogEngine.NET couldn't be easier. All it needs is register an event hander FilterLinks to BlogEngine.Core.Comment.Serving event. In the FilterLinks method, simply replace ServingEventArgs.Body, which will be displayed, with the masked content.

[Extension("Masking links in comments", "1.0", 
		"<a href=\"http://fszlin.dymetis.com\">Eddie Z. Lin</a>", 10)]
public class CommentLinkMasking
{
    static CommentLinkMasking()
    {
        Comment.Serving += FilterLinks;
 
        InitSettings();
    }
 
    private static void FilterLinks(object sender, ServingEventArgs e)
    {
        if (String.IsNullOrEmpty(e.Body))
        {
            return;
        }
 
        e.Body = linkRegex.Replace(e.Body, ReplaceLink);
    }
 
    // Other methods.
}

To install this extension in BlogEngine.NET, simply put the source file into the Extensions folder. The full source is available here.

Using WCF Data Service Operations in Silverlight

Tue, 15 Mar 2011 00:52:00 -0400

WCF Data Services use OData protocol to expose data over the Internet, which makes integrating other systems much easier. Everything looks fine, until me trying to use WCF Data Services instead of WCF RIA Services in Silverlight application - The client won’t generate and service operation. The good news is, we still able to consume service operations without writing raw HTTP requests.

This post will describes how to supply parameters to operations exposure by WCF Data Service.

Let's say we exposing the following operation via Data Service:

[WebGet]
public IQueryable<ItemCategory> Foo()
{
   return CurrentDataSource.ItemCategories;
}

This is how we can invoke it in Silverlight:

var context = new SomeContext(serviceUri);
 
var dataQuery = (DataServiceQuery<ItemCategory>)context
    .CreateQuery<ItemCategory>("Foo").Take(10);
 
dataQuery.BeginExecute(result =>
{
    var collection = new DataServiceCollection<ItemCategory>(
        dataQuery.EndExecute(result));
 
    // consume data here

}, null);

An operation doesn't do much if we cannot supply parameters. According to this, parameter can only be primitive types. Note that this doesn’t mean all primitive types are supported. Apparently, Char, IntPtr, UIntPtr, and all unsigned numeric types (except Byte) are not supported, according to the protocol.

So, let’s try the other types:

[WebGet]
public IQueryable<ItemCategory> Foo(
    bool paramBool, 
    byte paramByte,
    sbyte paramSByte,
    short paramInt16,
    int paramInt,
    long paramInt64, 
    float paramFloat,
    double paramDouble,
    string paramString
    )
{
    return CurrentDataSource.ItemCategories;
}

And this is the metadata exposed:

<FunctionImport Name="Foo" 
                EntitySet="ItemCategories" 
                ReturnType="Collection(ProductTraceModel.ItemCategory)" 
                m:HttpMethod="GET">
  <Parameter Name="paramBool" Type="Edm.Boolean" Mode="In" />
  <Parameter Name="paramByte" Type="Edm.Byte" Mode="In" />
  <Parameter Name="paramSByte" Type="Edm.SByte" Mode="In" />
  <Parameter Name="paramInt16" Type="Edm.Int16" Mode="In" />
  <Parameter Name="paramInt" Type="Edm.Int32" Mode="In" />
  <Parameter Name="paramInt64" Type="Edm.Int64" Mode="In" />
  <Parameter Name="paramFloat" Type="Edm.Single" Mode="In" />
  <Parameter Name="paramDouble" Type="Edm.Double" Mode="In" />
  <Parameter Name="paramString" Type="Edm.String" Mode="In" />
</FunctionImport>

To append parameters to the request URL, we may use DataServiceQuery.AddQueryOption method. This method will simply convert the given value to string, and the call will failed since the value is not proper converted.

The query should look like this:

var dataQuery = (DataServiceQuery<ItemCategory>)context
    .CreateQuery<ItemCategory>("Foo")
    .AddQueryOption("paramBool", "false")
    .AddQueryOption("paramByte", "120")
    .AddQueryOption("paramSByte", "99")
    .AddQueryOption("paramInt16", Int16.MaxValue)
    .AddQueryOption("paramInt", Int32.MaxValue)
    .AddQueryOption("paramInt64", Int64.MaxValue + "L")
    .AddQueryOption("paramFloat", 123.56 + "F")
    .AddQueryOption("paramDouble", 123.56)
    .AddQueryOption("paramString", "'" + "Eddie's Blog".Replace("'", "''") + "'")
    .Take(10);

Interestingly, even though Byte should be Hex as per the specification, but WCF Data Service only accepts Dec.

Despite Time and DateTimeOffset are described in the protocol, WCF Data Service does not support mapping TimeSpan and DateTimeOffset. For the Binary and DateTime, the metadata will looks like this:

<FunctionImport Name="Foo" EntitySet="ItemCategories" 
    ReturnType="Collection(ProductTraceModel.ItemCategory)" m:HttpMethod="GET">
  <Parameter Name="byteArray" Type="Edm.Binary" Mode="In" />
  <Parameter Name="dateTime" Type="Edm.DateTime" Mode="In" />
</FunctionImport>

Here is how to convert these two types:

var dataQuery = (DataServiceQuery<ItemCategory>)context
    .CreateQuery<ItemCategory>("Foo")
    .AddQueryOption("byteArray", "X'" + 
        BitConverter.ToString(new byte[] { 24, 65, 73 }).Replace("-", String.Empty) + "'")
    .AddQueryOption("dateTime", "datetime'" + DateTime.Now.ToString("yyyy-MM-ddThh:mm:ss.fffffff") + "'")
    .Take(10);

For nullable parameters, instead of issuing a null as per specification, you should ignore the parameter, otherwise you will receive a syntax error.

Here is a helper class to simplify the conversions.

// Copyright (c) 2011 Eddie Z. Lin.
//
// This source is subject to the Microsoft Public License.
// See http://www.opensource.org/licenses/ms-pl.
// All other rights reserved.
    
/// <summary>
/// Helper methods used to append parameters to WCF Data Service querys.
/// </summary>
public static class DataServiceQueryExtensions
{
    public static DataServiceQuery<TElement> AddParameter<TElement>(
        this DataServiceQuery<TElement> query, string name, bool? value)
    {
        return value.HasValue ?
            query.AddQueryOption(name, value.Value ? "true" : "false") : 
            query;
    }
 
    public static DataServiceQuery<TElement> AddParameter<TElement>(
        this DataServiceQuery<TElement> query, string name, long? value)
    {
        return value.HasValue ? 
            query.AddQueryOption(name, String.Format("{0}L", value)) :
            query;
    }
 
    public static DataServiceQuery<TElement> AddParameter<TElement>(
        this DataServiceQuery<TElement> query, string name, float? value)
    {
        return value.HasValue ?
            query.AddQueryOption(name, String.Format("{0}F", value)) :
            query;
    }
 
    public static DataServiceQuery<TElement> AddQueryParameter<TElement>(
        this DataServiceQuery<TElement> query, string name, string value)
    {
        return value != null ?
            query.AddQueryOption(name, String.Format("'{0}'", value.Replace("'", "''"))) :
            query;
    }
 
    public static DataServiceQuery<TElement> AddQueryParameter<TElement>(
        this DataServiceQuery<TElement> query, string name, byte[] value)
    {
        return value != null ?
            query.AddQueryOption(name, 
                String.Format("X'{0}'",  BitConverter.ToString(value).Replace("-", String.Empty))) :
            query;
    }
 
    public static DataServiceQuery<TElement> AddQueryParameter<TElement>(
        this DataServiceQuery<TElement> query, string name, DateTime? value)
    {
        return value != null ?
            query.AddQueryOption(name, 
                String.Format("X'{0}'", value.Value.ToString("yyyy-MM-ddThh:mm:ss.fffffff"))) :
            query;
    }
 
    public static DataServiceQuery<TElement> AddParameter<TElement>(
        this DataServiceQuery<TElement> query, string name, int? value)
    {
        return value != null ?
            query.AddQueryOption(name, value.ToString()) :
            query;
    }
 
    public static DataServiceQuery<TElement> AddParameter<TElement>(
        this DataServiceQuery<TElement> query, string name, object value)
    {
        return value != null ?
            query.AddQueryOption(name, value.ToString()) : 
            query;
    }
}

Hope this helps.

Email Alerts in Team Foundation Server

Wed, 09 Mar 2011 03:54:00 -0400

If you ever wonder how to send an E-Mail notification to a user participating in the event in TFS, the solution would be a little bit tricky for a flexible, extensible mechanism for subscription and notification. One of the easiest ways to achieve this is using the Event Service to listen to the event, and then send the notification.

These are some of the situations you may want to have this feature out of box:

Notify the developer checked in when the build is failed;
Notify the reporters when a bug work item is changed by others.

Obviously, programing a web service or event handler for each of these cases requires a lot of work. It would be nice to utilize the subscription service in TFS, so that we don't have to worry about filtering and formatting events. Here are the steps:

Listen the target event;
Find out the E-Mail address of the user;
Subscribe the user to the same event with proper filter.

In the following example, I am going to handle the WorkItemChangedEvent to notify the reporters when a bug work item is changed by others, with the helps of TeamFoundationIdentityService and TeamFoundationNotificationService. (Sadly, the documentation on MSDN doesn't actually tell you anything more than Object Browser regarding the TFS server API.)

Before performing any task, we need to get notify when the a work item has been updated. This is done by implementing the ISubscriber interface.

public sealed class EmailAlertSubscriber : ISubscriber
{

    public string Name
    {
        get { return "EmailAlertSubscriber" }
    }

    public SubscriberPriority Priority
    {
        get { return SubscriberPriority.Normal }
    }

    public EventNotificationStatus ProcessEvent(
        TeamFoundationRequestContext requestContext, 
        NotificationType notificationType, 
        object notificationEventArgs, 
        out int statusCode, 
        out string statusMessage,
        out ExceptionPropertyCollection properties) 
    {
        statusCode = 0;
        statusMessage = null;
        properties = null;

        if (notificationType == NotificationType.Notification)
        {
            var eventArgs = notificationEventArgs as WorkItemChangedEvent;
            if (eventArgs != null)
            {
                // Process event...
            }
        }

        return EventNotificationStatus.ActionPermitted;
    }

    public Type[] SubscribedTypes()
    {
        return new Type[] { typeof(WorkItemChangedEvent) };
    }
}

Next, we can retrieve the value of person field form notificationEventArgs. As per our example, I need the user who created the bug work item.

var createdByDisplayName = 
    eventArgs
    .CoreFields
    .StringFields
    .Single(
        f => f.ReferenceName.Equals(
            "System.CreatedBy", StringComparison.OrdinalIgnoreCase))
    .NewValue;

The field value may be a display name, domain account or Sid (Security Identifier), but the base steps to retrieve E-Mail address are the same - read the TeamFoundationIdentity; and then load the E-Mail address from Active Directory. Just make sure you reading the E-Mail address from the correct domain.

var identityService = requestContext.GetService<TeamFoundationIdentityService>();

// Read TFS identity by display name.
var tfsId = identityService.ReadIdentity(
    requestContext, 
    IdentitySearchFactor.DisplayName, 
    displayName, 
    MembershipQuery.None, ReadIdentityOptions.None);

// Read TFS identity by account name.
var tfsId = identityService.ReadIdentity(
    requestContext, 
    IdentitySearchFactor.AccountName, 
    accountName, 
    MembershipQuery.None, ReadIdentityOptions.None);

// Read TFS identity by Sid.
var idDescriptor = IdentityHelper.CreateDescriptorFromSid(sid);
var tfsId = identityService.ReadIdentity(
    requestContext, 
    idDescriptor, 
    MembershipQuery.None, ReadIdentityOptions.None);

var domainName = IdentityHelper.GetDomainName(identity);

using (var context = new PrincipalContext(ContextType.Domain, domainName))
{
    var userPrincipal = UserPrincipal.FindByIdentity(
        context, IdentityType.Sid, identity.Descriptor.Identifier);

    // Now we got the E-Mail address as userPrincipal.EmailAddress;
}

Now, we have all the information we need to subscribe the user to event. In the following code snippet, the classification is used to identify the subscription. It likely contains the event type and user identifier, so that the handler won't subscribe the user every time the event fired. On the other hand, we may supply a filter expression limiting the E-Mail going out.

var classification = // Identifer for the subscription.

var notificationService = requestContext.GetService<TeamFoundationNotificationService>();
var subscriptions = notificationService.GetEventSubscriptions(
    requestContext, 
    userIdentity.Descriptor,
    classification);

// Check for whether the subscription already exists.
if (subscriptions.Count == 0)
{
    var filterExpression = // Filter used to limit the E-Mail notifications.

    var perference = new DeliveryPreference()
    {
        Address = userPrincipal.EmailAddress,
        Schedule = DeliverySchedule.Immediate,
        Type = DeliveryType.EmailHtml
    };

    notificationService.SubscribeEvent(
        requestContext,
        userIdentity.Descriptor, 
        "WorkItemChangedEvent", 
        filterExpression, 
        perference, 
        classification);
}

After all these, the handler is ready to be deployed. To use it, simply compile the code to an assembly, and copy it to %Program Files%\Microsoft Team Foundation Server 2010\Application Tier\Web Services\bin\Plugins of the TFS server. The E-Mail will start filling up your mail box now.

You may want to unsubscribe the user, such as when the work item is closed. This can be done by:

if (subscriptions.Count > 0)
{
    foreach (var subscription in subscriptions)
    {
        requestContext.GetService<TeamFoundationNotificationService>()
            .UnsubscribeEvent(requestContext, subscription.ID);
    }
}

The problem here is that the E-Mail is send by the delayed job. By the time the job being executed, the subscription is removed, and the user won't get notify when the work item is closed. Interestingly, this delay is exactly what ensuring the user get notify the first time when we subscribing the user.

If you don't mind the event subscriptions table get fill up, or you willing to clean the table once a while. This approach will work quite well.

So, in order to find a better solution, I will show you how to filter events using VSEFL , and then wire up everything in other posts.

Comsuming WCF Services With Android

Mon, 10 May 2010 04:39:00 -0400

It seems processing XML is too heavy for mobile devices. Android did not provide any tool to help consuming SOAP web service. But as Android bundled with org.apache.http and org.json packages, it is relative simple to consume RESTful WCF services.

The following sections describe the steps to create RESTfule WCF services and the Android client to consume the services.

First, I created a service contract with two GET and one POST operations. Since the Android client will transfer data in JSON objects, I specify JSON as request and response format. In order to support more than one parameter, I set BodyStyle to WrappedRequest.

namespace HttpWcfWeb
{
    [ServiceContract(Namespace = "http://services.example.com")]
    public interface IVehicleService
    {
        [OperationContract]
        [WebGet(
            UriTemplate = "GetPlates",
            BodyStyle = WebMessageBodyStyle.WrappedRequest,
            ResponseFormat = WebMessageFormat.Json,
            RequestFormat = WebMessageFormat.Json)]
        IList<string> GetPlates();

        [OperationContract]
        [WebGet(UriTemplate = "GetVehicle/{plate}",
            BodyStyle = WebMessageBodyStyle.WrappedRequest,
            ResponseFormat = WebMessageFormat.Json,
            RequestFormat = WebMessageFormat.Json)]
        Vehicle GetVehicle(string plate);

        [OperationContract]
        [WebInvoke(
            Method = "POST",
            UriTemplate = "SaveVehicle",
            BodyStyle = WebMessageBodyStyle.WrappedRequest,
            ResponseFormat = WebMessageFormat.Json,
            RequestFormat = WebMessageFormat.Json)]
        void SaveVehicle(Vehicle vehicle);
    }
}

Next, I defined the composite object will be transferred between server and Android client. It is simple but enough to prove we will be able to transfer complex objects.

namespace HttpWcfWeb
{
    [DataContract]
    public class Vehicle
    {
        [DataMember(Name = "year")]
        public int Year
        {
            get;
            set;
        }

        [DataMember(Name = "plate")]
        public string Plate
        {
            get;
            set;
        }

        [DataMember(Name = "make")]
        public string Make
        {
            get;
            set;
        }

        [DataMember(Name = "model")]
        public string Model
        {
            get;
            set;
        }
    }
}

Now, expose the WCF service via webHttp behavior in web.config.

<system.serviceModel>
  <behaviors>
    <endpointBehaviors>
      <behavior name="httpBehavior">
        <webHttp />
      </behavior>
    </endpointBehaviors>
    <serviceBehaviors>
      <behavior name="">
        <serviceMetadata httpGetEnabled="true" />
        <serviceDebug includeExceptionDetailInFaults="false" />
      </behavior>
    </serviceBehaviors>
  </behaviors>
  <serviceHostingEnvironment multipleSiteBindingsEnabled="true" />
    <services>
      <service name="HttpWcfWeb.VehicleService">
        <endpoint address=""
                     behaviorConfiguration="httpBehavior"
                     binding="webHttpBinding"
                     contract="HttpWcfWeb.IVehicleService" />
    </service>
  </services>
</system.serviceModel>

It you are using Visual Studio's Development Server to test the WCF service, you may need to deploy the service to IIS. This is due to the Development Server only serve request from local machine, and the Android client won't be able to access the service hosted on it.

Further, if you are using host name (e.g. computer name) in the URL of the service, you may have to setup the DNS in you device or emulator, so that it can resolve the host name. Simply go to Settings -> Wireless Control -> Mobile Networks -> Access Point Names, click on the one that is in use, fill in Proxy and Port with your DNS server.

Now, I have my WCF service ready, and I am going to build the Android client to consume the WCF service.

During initialization, the Activity will invoke IVehicleService.GetPlates method to populate the Spinner. When the Load Vehicle button is clicked, the vehicle will be loaded from the IVehicleService.GetVehicle method and the EditText views will be populated. On the other hand, Save button will wrap the data entered and post to IVehicleService.SaveVehicle method.

The code the initialize the UI I created.

public class MainActivity extends Activity {

    private final static String SERVICE_URI = "http://lt0.studio.entail.ca:8080/VehicleService.svc";

    private Spinner plateSpinner;
    private EditText makeEdit;
    private EditText plateEdit;
    private EditText yearEdit;
    private EditText modelEdit;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        plateSpinner = (Spinner)findViewById(R.id.plate_spinner);
        makeEdit = (EditText)findViewById(R.id.make_edit);
        plateEdit = (EditText)findViewById(R.id.plate_edit);
        yearEdit = (EditText)findViewById(R.id.year_edit);
        modelEdit = (EditText)findViewById(R.id.model_edit);
    }
    
    @Override
    public void onResume() {
        super.onResume();

        // Invoke IVehicleService.GetPlates and populate plateSpinner
        refreshVehicles();
    }
}

The refreshVehicles method will be invoked when the activity is resumed or a new vehicle is saved. It send a GET request to the WCF service and retrieves a list of plates in JSON string, and the response string is parsed by JSONArray.

    private void refreshVehicles() {
        try {

            // Send GET request to <service>/GetPlates
            HttpGet request = new HttpGet(SERVICE_URI + "/GetPlates");
            request.setHeader("Accept", "application/json");
            request.setHeader("Content-type", "application/json");

            DefaultHttpClient httpClient = new DefaultHttpClient();
            HttpResponse response = httpClient.execute(request);

            HttpEntity responseEntity = response.getEntity();
            
            // Read response data into buffer
            char[] buffer = new char[(int)responseEntity.getContentLength()];
            InputStream stream = responseEntity.getContent();
            InputStreamReader reader = new InputStreamReader(stream);
            reader.read(buffer);
            stream.close();

            JSONArray plates = new JSONArray(new String(buffer));

            // Reset plate spinner
            ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, android.R.layout.simple_spinner_item);
            adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
            for (int i = 0; i < plates.length(); ++i) {
                adapter.add(plates.getString(i));
            }
            plateSpinner.setAdapter(adapter);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

The onLoadVehicleClick method is the event handler for Load Vehicle button. Just like refreshVehicles method, It send a GET request to the WCF service and retrieve the vehicle information by plate number. But instead of JSONArray, it used JSONObject to parse the response data, since the WCF service is returning an vehicle object.

    public void onLoadVehicleClick(View button) {
        try {
            // Send GET request to <service>/GetVehicle/<plate>
            DefaultHttpClient httpClient = new DefaultHttpClient();
            HttpGet request = new HttpGet(SERVICE_URI + "/GetVehicle/" + plateSpinner.getSelectedItem());

            request.setHeader("Accept", "application/json");
            request.setHeader("Content-type", "application/json");

            HttpResponse response = httpClient.execute(request);

            HttpEntity responseEntity = response.getEntity();

            // Read response data into buffer
            char[] buffer = new char[(int)responseEntity.getContentLength()];
            InputStream stream = responseEntity.getContent();
            InputStreamReader reader = new InputStreamReader(stream);
            reader.read(buffer);
            stream.close();

            JSONObject vehicle = new JSONObject(new String(buffer));

            // Populate text fields
            makeEdit.setText(vehicle.getString("make"));
            plateEdit.setText(vehicle.getString("plate"));
            modelEdit.setText(vehicle.getString("model"));
            yearEdit.setText(vehicle.getString("year"));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

When Save button is clicked, onSaveVehicleClick method will be invoked. It simply gather all text fields into a JSONObject and post it to the WCF service. Noticed that the all the data was wrapped into an object named vehicle, WCF will pass this object as parameter vehicle.

    public void onSaveVehicleClick(View button) {

        try {

            Editable make = makeEdit.getText();
            Editable plate = plateEdit.getText();
            Editable model = modelEdit.getText();
            Editable year = yearEdit.getText();

            boolean isValid = true;

            // Data validation goes here

            if (isValid) {

                // POST request to <service>/SaveVehicle
                HttpPost request = new HttpPost(SERVICE_URI + "/SaveVehicle");
                request.setHeader("Accept", "application/json");
                request.setHeader("Content-type", "application/json");

                // Build JSON string
                JSONStringer vehicle = new JSONStringer()
                    .object()
                        .key("vehicle")
                            .object()
                                .key("plate").value(plate)
                                .key("make").value(make)
                                .key("model").value(model)
                                .key("year").value(Integer.parseInt(year.toString()))
                            .endObject()
                        .endObject();
                StringEntity entity = new StringEntity(vehicle.toString());

                request.setEntity(entity);

                // Send request to WCF service
                DefaultHttpClient httpClient = new DefaultHttpClient();
                HttpResponse response = httpClient.execute(request);

                Log.d("WebInvoke", "Saving : " + response.getStatusLine().getStatusCode());
                
                // Reload plate numbers
                refreshVehicles();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

Finally, add the internet permission into AndroidManifest.xml, to allow the sample application access WCF service.

    <uses-permission android:name="android.permission.INTERNET" />

And the demo is ready to go.

A Silverlight Text Diff Control

Tue, 12 Jan 2010 12:53:00 -0400

Text diff tool is really useful for checking the updates of versioning files. On the web, it is widely used in wiki systems to see the changes of articles. It may also useful for tracing forum posts, page updates of CMS, etc.

This article will describes how to create a simple text diff control in Silverlight. Before going into the details, this is screen shot of our text diff control.

This control contains two major parts, the core algorithm to do the calculation job, and the user interface to display the result.

Diff Algoirithms

The purpose of diff algorithm is to compute the Shortest Edit Script of two list of equalable items. Hence, all of our algorithm will implement the following IDiffEngine interface.

/// <summary>
/// Supports aligning two sequences.
/// </summary>
public interface IDiffEngine
{
    IList<DiffResult> Align<T>(IList<T> from, IList<T> to, IEqualityComparer<T> comparer);
}

/// <summary>
/// Represents a particular elements alignment result.
/// </summary>
public enum DiffResult
{
    /// <summary>
    /// Two elements are considered as the same.
    /// </summary>
    Matched,

    /// <summary>
    /// The element in target sequence is inserted to the result alignment.
    /// </summary>
    Inserted,

    /// <summary>
    /// The element in original sequence is inserted to the result alignment.
    /// </summary>
    Deleted
}

Other than this, we need an interface accepting string list, in other word, lines of a text. It is because we may have extensions specified to text, i.e. spacing handling, case sensitivity, etc.

/// <summary>
/// Supports aligning two list of strings.
/// </summary>
public interface ITextDiffEngine
{
    IList<DiffResult> Algin(IList<string> from, IList<string> to);
}

Considering implementation, a widely used diff algorithm is the one described by Eugene W. Myers, in his paper, "An O(ND) Difference Algorithm and Its Variations". A simple implementation is included in the sample, which has O((N + M)D) time and space complexity. This article won't explain the details of this algorithm, but a good tutorial is available on The Code Project by Nicholas Butler.

Another algorithm in our control is Needleman-Wunsch algorithm which is commonly use for sequence alignment. This algorithm has complexity O(N + M) in both time and space. Now, we can verify both algorithms by comparing the outputs.

User Interface

As the screen shot shown previously, the control UI is similar with some text diff applications. It is using two text blocks to display the texts comparing, two scroll bars used for scrolling text blocks, and a bar on the left to summarize the diff result. Further, the text blocks is wrapping in side scroll viewer so that the scroll bar can hook on them.

Let's define a Silverlight templated control DiffViewer, with the sub controls addressed above. These controls are retrieved in OnApplyTemplate method.

/// <summary>
/// Represents the text diff control.
/// </summary>
[TemplatePart(Name = RightTextBlockElement, Type = typeof(TextBlock))]
[TemplatePart(Name = LeftTextBlockElement, Type = typeof(TextBlock))]
[TemplatePart(Name = DiffBrushElement, Type = typeof(LinearGradientBrush))]
[TemplatePart(Name = HorizontalScrollBarElement, Type = typeof(ScrollBar))]
[TemplatePart(Name = VerticalScrollBarElement, Type = typeof(ScrollBar))]
[TemplatePart(Name = RightTextScrollViewerElement, Type = typeof(ScrollViewer))]
[TemplatePart(Name = LeftTextScrollViewerElement, Type = typeof(ScrollViewer))]
public class DiffViewer : Control
{
    /// <summary> ...
    private const string RightTextBlockElement = "RightTextBlockElement";

    /// <summary> ...
    private const string LeftTextBlockElement = "LeftTextBlockElement";

    /// <summary> ...
    private const string DiffBrushElement = "DiffBrushElement";

    /// <summary> ...
    private const string HorizontalScrollBarElement = "HorizontalScrollBarElement";

    /// <summary> ...
    private const string VerticalScrollBarElement = "VerticalScrollBarElement";

    /// <summary> ...
    private const string RightTextScrollViewerElement = "RightTextScrollViewerElement";

    /// <summary> ...
    private const string LeftTextScrollViewerElement = "LeftTextScrollViewerElement";
    
    /// <summary> ...
    public override void OnApplyTemplate()
    {
        base.OnApplyTemplate();

        // Lookup template parts
        rightTextBlock = GetTemplateChild(RightTextBlockElement) as TextBlock;
        leftTextBlock = GetTemplateChild(LeftTextBlockElement) as TextBlock;
        horizontalScrollBar = GetTemplateChild(HorizontalScrollBarElement) as ScrollBar;
        verticalScrollBar = GetTemplateChild(VerticalScrollBarElement) as ScrollBar;
        leftTextScrollViewer = GetTemplateChild(LeftTextScrollViewerElement) as ScrollViewer;
        rightTextScrollViewer = GetTemplateChild(RightTextScrollViewerElement) as ScrollViewer;
        diffBrush = GetTemplateChild(DiffBrushElement) as LinearGradientBrush;
        
        leftTextBlock.SizeChanged += TextBlockSizeChanged;
        rightTextBlock.SizeChanged += TextBlockSizeChanged;

        verticalScrollBar.Scroll += VerticalScrollBarScroll;
        horizontalScrollBar.Scroll += HorizontalScrollBarScroll;

        templatedApplied = true;

        UpdateComparison();
    }
        
    /// ...
}

In OnApplyTemplate method, I also added event handlers to SizeChanged and Scroll event of text blocks and scroll bars. Essentially, the scroll bars will be adjusted according to the size of text blocks, and the viewport of text blocks will be moved according to the position of scroll bars.

public class DiffViewer : Control
{
    /// <summary> ...
    private void HorizontalScrollBarScroll(object sender, ScrollEventArgs e)
    {
        // Scroll text blocks horiontally
        leftTextScrollViewer.ScrollToHorizontalOffset(horizontalScrollBar.Value);
        rightTextScrollViewer.ScrollToHorizontalOffset(horizontalScrollBar.Value);
    }

    /// <summary> ...
    private void VerticalScrollBarScroll(object sender, ScrollEventArgs e)
    {
        // Scroll text blocks vertically
        leftTextScrollViewer.ScrollToVerticalOffset(verticalScrollBar.Value);
        rightTextScrollViewer.ScrollToVerticalOffset(verticalScrollBar.Value);
    }

    /// <summary> ...
    private void TextBlockSizeChanged(object sender, SizeChangedEventArgs e)
    {
        UpdateScrollBars();
    }

    /// <summary> ...
    private void UpdateScrollBars()
    {
        // Horizontal scroll bar
        var viewportWidth = Math.Max(leftTextScrollViewer.ViewportWidth, rightTextScrollViewer.ViewportWidth);
        var extentWidth = Math.Max(leftTextScrollViewer.ExtentWidth, rightTextScrollViewer.ExtentWidth);
        horizontalScrollBar.ViewportSize = viewportWidth;
        horizontalScrollBar.Maximum = extentWidth - viewportWidth;

        // Vertical scroll bar
        var viewportHeight = Math.Max(leftTextScrollViewer.ViewportHeight, rightTextScrollViewer.ViewportHeight);
        var extentHeight = Math.Max(leftTextScrollViewer.ExtentHeight, rightTextScrollViewer.ExtentHeight);
        verticalScrollBar.ViewportSize = viewportHeight;
        verticalScrollBar.Maximum = extentHeight - viewportHeight;
    }
        
    /// ...
}

Then, we need the dependency properties for two text inputs and the ITextDiffEngine instance to be used. A static method UpdateComparison is tracing these properties and delegates to namesake method of the DiffView instance.

public class DiffViewer : Control
{
    /// <summary> ...
    public static readonly DependencyProperty LeftTextProperty =
        DependencyProperty.Register("LeftText", typeof(string), typeof(DiffViewer), new PropertyMetadata(UpdateComparison));

    /// <summary> ...
    public static readonly DependencyProperty RightTextProperty =
        DependencyProperty.Register("RightText", typeof(string), typeof(DiffViewer), new PropertyMetadata(UpdateComparison));

    /// <summary> ...
    public static readonly DependencyProperty DiffEngineProperty =
        DependencyProperty.Register("DiffEngine", typeof(ITextDiffEngine), typeof(DiffViewer), new PropertyMetadata(UpdateComparison));

    /// <summary> ...
    public string LeftText
    {
        get { return (string)GetValue(LeftTextProperty); }
        set { SetValue(LeftTextProperty, value); }
    }

    /// <summary> ...
    public string RightText
    {
        get { return (string)GetValue(RightTextProperty); }
        set { SetValue(RightTextProperty, value); }
    }

    /// <summary> ...
    public ITextDiffEngine DiffEngine
    {
        get { return (ITextDiffEngine)GetValue(DiffEngineProperty); }
        set { SetValue(DiffEngineProperty, value); }
    }
    
    private static void UpdateComparison(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs eventArgs)
    {
        var diffView = dependencyObject as DiffViewer;
        if (diffView != null)
        {
            if (diffView.templatedApplied && diffView.AutoUpdate)
            {
                diffView.UpdateComparison();
            }
        }
    }
        
    /// ...
}

Finally, UpdateComparison method will invokes the diff engine and displaying result. Inside the method, each line in both texts will be aligned and added to text blocks as Inline objects. The color brush will be draw in the same time as well.

public class DiffViewer : Control
{
    /// <summary> ...
    public void UpdateComparison()
    {
        // ...

        // Compute alignment
        var diffSolution = engine.Algin(leftTextLines, rightTextLines);

        // ...

        for (int i = 0; i < solutionLength; ++i)
        {
            var lineResult = diffSolution[i];

            // Append inlines according to result
            switch (lineResult)
            {
                case DiffResult.Matched:
                    // ...
                    break;
                case DiffResult.Deleted:
                    // ...
                    break;
                case DiffResult.Inserted:
                    // ...
                    break;
            }


            // ...

            if (lastResult != lineResult)
            {
                // End previous color
                gradientStops.Add(CreateGradientStop(lastResult, i, solutionLength));

                // Start new color
                gradientStops.Add(CreateGradientStop(lineResult, i, solutionLength));

                lastResult = lineResult;
            }
        }
        
        // ...
    }
        
    /// ...
}

If you have Silverlight 3 installed, you should be able to see the sample application running underneath. Feel free to have a try!

Converting XPS to PDF Programmatically

Mon, 04 Jan 2010 06:02:00 -0400

I am working on a simple utility tool which pulls data from database and then generates reports as E-Mail attachments. An additional requirement is to exam the reports before sending them out. Hence, I want a document format that meets these criteria.

Easy to generate;
Can be review in Win Form program;
Widely support by client computers.

Using WPF, XPS is the best choice for first two requirements. Precisely, generating a FlowDocument is as simple as writing HTML, and XSLT can translate any XML data into XPS flow document. On the other side, FixedDocument provides the same feel as a print out.

However, XPS requires a viewer installed. Some of our recipients may not have the privilege to install the viewer. So I would like to send out a PDF instead of XPS.

Converting FlowDocument to FixedDocument

In order to review the exact same documents as the ones sending out. We need to first convert the flow document to fixed document. A easy way is simply save the flow document by setting it"s page size.

var source = (IDocumentPaginatorSource)flowDoc;
var paginator = source.DocumentPaginator;

// Letter size
paginator.PageSize = new Size(8.5 * 96, 11 * 96);

using (XpsDocument doc = new XpsDocument(tempXpsPath, FileAccess.Write))
{
    var writer = XpsDocument.CreateXpsDocumentWriter(doc);
    writer.Write(paginator);
}

Now, use a DocumentViewer to display it in WPF. Here is the result:

If you would like to do it in memory, Here is an article from Tamir Khason. But I will need the temporary XPS files for next step anyway.

Converting XPS to PDF

This part is much more challenging. I would like to do a trick to get my PDFs, rather than read through the XPS/PDF specifications. I am using GhostPCL to convert XPS to PDF. Download and build GhostXPS following the instruction, then copy gxps.exe (under xps/obj folder) to our project.

Now, we may call gxps to convert the temporary XPS to PDF.

// Convert XPS to PDF using gxps
ProcessStartInfo gxpsArguments = new ProcessStartInfo("gxps.exe", String.Format("-sDEVICE=pdfwrite -sOutputFile={0} -dNOPAUSE {1}", path, tempXpsPath));
gxpsArguments.WindowStyle = ProcessWindowStyle.Hidden;
using (var gxps = Process.Start(gxpsArguments))
{
    gxps.WaitForExit();
}

The sample program can be download here. Hope this help!