LockTar's Blog

Connect SoapUI to WCF service certificate authentication

30/12/201630/12/2016 Ralph Jansen 8 Comments

Is it possible to connect SoapUI to WCF Service certificate authentication, the answer is yes! If you search on the internet, there is little information about this topic but it is really possible!

Adding security to your WCF service is a best practice. Not only when your creating services connected by the internet but also inside your company.

One way for securing your WCF service is adding certificates for authentication. But also signing your message is good way to preserve the integrity of your message. So to use a secure service we can enable transport and message security. See a list of common security scenarios with WCF for a good reference. In that way we can use SSL in IIS.

Service configuration

Add a service to your application with a WsHttpBinding. See for an example the following config:

<?xml version="1.0" encoding="utf-8" ?>
<system.serviceModel>
  <services>
    <service name="SampleService">
      <endpoint binding="wsHttpBinding" contract="ISampleService" bindingNamespace="http://your/binding/namespace"/>
    </service>
  </services>
  <behaviors>
    <serviceBehaviors>
      <behavior name="">
        <serviceMetadata httpsGetEnabled="true" />
        <serviceCredentials>
          <serviceCertificate findValue="YourThumbprint" storeName="My" storeLocation="LocalMachine" x509FindType="FindByThumbprint" />
          <clientCertificate>
            <certificate findValue="YourThumbprint" storeName="My" storeLocation="LocalMachine" x509FindType="FindByThumbprint" />
            <authentication certificateValidationMode="ChainTrust" revocationMode="NoCheck" />
            <!-- Check revocationMode for production -->
          </clientCertificate>
        </serviceCredentials>
        <serviceDebug includeExceptionDetailInFaults="true" />
      </behavior>
    </serviceBehaviors>
  </behaviors>
  <bindings>
    <wsHttpBinding>
      <binding maxReceivedMessageSize="10485760">
        <readerQuotas maxDepth="32" maxStringContentLength="2147483647" maxArrayLength="2147483647" maxBytesPerRead="4096" maxNameTableCharCount="16384" />
        <security mode="TransportWithMessageCredential">
          <message clientCredentialType="Certificate" algorithmSuite="Basic256Sha256Rsa15" negotiateServiceCredential="false" establishSecurityContext="false" />
        </security>
      </binding>
    </wsHttpBinding>
  </bindings>
  <serviceHostingEnvironment aspNetCompatibilityEnabled="true" multipleSiteBindingsEnabled="true" />
</system.serviceModel>

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

<system.serviceModel>

</service>

</services>

</clientCertificate>

</serviceCredentials>

</behavior>

</serviceBehaviors>

</behaviors>

</security>

</binding>

</wsHttpBinding>

</bindings>

</system.serviceModel>

Client Configurations

Configuration .NET

Then use in your .NET client the following config. The assumption is that you already know how to add a service.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <bindings>
      <wsHttpBinding>
        <binding name="WsHttpBinding_ISampleService">
          <security mode="TransportWithMessageCredential">
            <message clientCredentialType="Certificate" algorithmSuite="Basic256Sha256Rsa15"/>
          </security>
        </binding>
      </wsHttpBinding>
    </bindings>
    <behaviors>
      <endpointBehaviors>
        <behavior name="">
          <clientCredentials>
            <clientCertificate findValue="your thumbprint" storeName="My" storeLocation="LocalMachine" x509FindType="FindByThumbprint" />

            <serviceCertificate>
              <defaultCertificate findValue="your thumbprint" storeName="My" storeLocation="LocalMachine" x509FindType="FindByThumbprint" />
              <authentication certificateValidationMode="ChainTrust" revocationMode="NoCheck" /><!-- Check revocationMode for production -->
            </serviceCertificate>
          </clientCredentials>
        </behavior>
      </endpointBehaviors>
    </behaviors>
    <client>
      <endpoint address="https://url/SampleService.svc"
          binding="wsHttpBinding" bindingConfiguration="WsHttpBinding_ISampleService"
          contract="ISampleService" name="WsHttpBinding_ISampleService1">
        <identity>
          <dns value="IngHubServerTest"/>
        </identity>
      </endpoint>
    </client>
  </system.serviceModel>
</configuration>

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

<system.serviceModel>

</security>

</binding>

</wsHttpBinding>

</bindings>

</serviceCertificate>

</clientCredentials>

</behavior>

</endpointBehaviors>

</behaviors>

<endpoint address="https://url/SampleService.svc"

binding="wsHttpBinding" bindingConfiguration="WsHttpBinding_ISampleService"

contract="ISampleService" name="WsHttpBinding_ISampleService1">

</identity>

</endpoint>

</client>

</system.serviceModel>

</configuration>

Configuration SoapUI

If you want to connect to this service with SoapUI it is more difficult. I’m not a Java developer so I use SoapUI for an easier understanding of connecting to our WCF Service in a different language. For this example I use the curret latest version 5.3. See for an overview of WS-Security the following help page.

Follow the steps below for adding a new project to SoapUI with the right configuration.

Project configuration

First of all create a new project and add the url to the wsdl. A new project is generated with a sample request for your service.
Now double click the project or use right click of the mouse to open the “Project view”.
Navigate to the “WS-Security Configurations” tab
Select the “Keystores” tab and add the certificate with private key so we can sign the request.
Go to the “Outgoing WS-Security Configurations” and add a new configuration with the name that you like.
Add in the newly created configuration a “Signature”.
Configure the keystore that you’ve added.
Use “Binary Security Token” as Key Identifier Type.
Set the right Algorithms that you have configured in the service. I change the configuration to a higher security because the default uses SHA1 and that is not a best practice anymore. I changed the configuration in my WCF service to algorithmSuite=”Basic256Sha256Rsa15″ in the message element of the binding. See this page for more information. Then it uses RSA-SHA256 for signature algorithm, XML-EXC-C14n# for Signature Canonicalization and XMLENC#SHA256 for the Digest Algorithm.
Check the “Use single certificate” checkbox.
By default SoapUI signs the whole request but that isn’t the default by WCF so we have to set the parts that we want to sign. So add as Name “To”, Namespace “http://www.w3.org/2005/08/addressing” (this is my namespace but check yours) and set Encode to “Element”.
Add a timestamp and set it to 300. Use milisecond precision.
Check the order on the left. So first signature and then timestamp!

Request configuration

Adjust the sample request body so it is a valid request.
Go back to your request.
Under the request open the “Auth” panel. Add Basic security. Leave everything blank except the “Outgoing WSS” configuration. Select the configuration that you have created.
Go to the WS-A panel and check the “Enable WS-A addressing” checkbox.
Finally the last thing that you have to do is check the checkbox “Add default wsa:To”. This in combination with the signature parts “To” configuration passes the right header values to the server. If you don’t do this you will get the following exception “The message received over Transport security has unsigned ‘To’ header”. See this StackOverflow post for simulair issue.

Hopefully this helped somebody. I spend to much time to this issue with SoapUI. Just to show that SoapUI works with a WCF soap service and high security configuration. The conclusion is that it works! It’s just soap… why wouldn’t…

Web API load testing with Visual Studio webtest

14/09/201516/02/2018 Ralph Jansen 3 Comments

This is the first post about load testing with Visual Studio webtest. This series of posts is describing load testing on a Visual Studio Web API.

This first post is about setting up the Visual Studio webtest for the demo Web API project with Visual Studio 2015. We’re using the latest version of the .NET Framework so we can use all the latest cool stuff in our code.

Setup the project

Create a new WebApi project and don’t forget to set the .NET Framework version to 4.6. Remember, I use the new Visual Studio 2015 RTM version.
Create a new class library and call it “Extensions”.
In the Extensions project, add a reference to “Microsoft.VisualStudio.QualityTools.WebTestFramework”. This project is for creating custom extension for Visual Studio webtests.
Add again a new project. Choose a “Web Performance and Load test Project” project. I called mine “WebApiTest”.
Add a reference from the test project to the Extensions project so we can use the extensions in the webtests.

So, the first thing is done. Setting up the project is the easy part. Now comes the testing part.

When you created the test project, a new empty webtest is created. We are now going to change the request so we can test it.

Rename the webtest to ValuesTest because we are going to test the ValuesController of the Web Api project.
Right click your ValuesTest and add a “Web Service Request”. Change the url to “http://localhost:26159/api/values” (your portnumber can be different).
Change the method from POST to GET.
Run your test and you will get a 401 unauthorized request back.
Remove the Authorize attribute on the ValuesController
Run the webtest again and now you will get a status 200 with as response “Binary Data”. This is off course your JSON response message.

Now we have to validate your response message because we don’t know if your test is sending the correct message.

Right click your web request and select “Add Validation Rule”.
A window appears. Select the “Find text” validation rule.
Enter in the “Find text” property the value “value3”.
Run your test and your test will fail on the validation rule.
Change the “Find text” property to “value2”.
Run the test again and now your test will be valid.

Ok. The foundation is done for the testing part. We have a test project and a source project that must be validated. The extensions part isn’t used yet. This will be done in the next part. In that part we are going to create a more detailed ValidationRule that really understand JSON reponses. Then we don’t have to “find text” in the reponse but we can search for a property that we want to validate.

Create custom code analysis rules in Visual Studio 2013

05/03/201505/03/2015 Ralph Jansen 4 Comments

This blog explains how to create custom code analysis rules in Visual Studio 2013 and how to debug them in Visual Studio 2013.

Create a custom code analysis rule

Start with creating a new class library. Rename the generated ‘Class1’ to ‘BaseRule’.
Add references in your class library to:

FxCopSdk
C:\Program Files (x86)\Microsoft Visual Studio 12.0\Team Tools\Static Analysis Tools\FxCop\\FxCopSdk.dll
Microsoft.Cci
C:\Program Files (x86)\Microsoft Visual Studio 12.0\Team Tools\Static Analysis Tools\FxCop\\Microsoft.Cci.dll
Microsoft.VisualStudio.CodeAnalysis
C:\Program Files (x86)\Microsoft Visual Studio 12.0\Team Tools\Static Analysis Tools\FxCop\\Microsoft.VisualStudio.CodeAnalysis.dll

In the BaseRule class we have to identify how the rules are named and where they could be found. To do this change the code in the BaseRule class.

using Microsoft.FxCop.Sdk;

namespace CustomCodeAnalysisRules
{
	public abstract class BaseRule : BaseIntrospectionRule
	{
		protected BaseRule(string name)
			: base(

				// The name of the rule (must match exactly to an entry
				// in the manifest XML)
				name,

				// The name of the manifest XML file, qualified with the
				// namespace and missing the extension
				typeof(BaseRule).Assembly.GetName().Name + ".Rules",

				// The assembly to find the manifest XML in
				typeof(BaseRule).Assembly)
		{

		}
	}
}

using Microsoft.FxCop.Sdk;

namespace CustomCodeAnalysisRules

{

public abstract class BaseRule : BaseIntrospectionRule

{

protected BaseRule(string name)

: base(

// The name of the rule (must match exactly to an entry

// in the manifest XML)

name,

// The name of the manifest XML file, qualified with the

// namespace and missing the extension

typeof(BaseRule).Assembly.GetName().Name + ".Rules",

// The assembly to find the manifest XML in

typeof(BaseRule).Assembly)

{

}

Now we have the framework for our new custom code analysis rules. In this example we are creating a custom rule that says that fields are not allowed. We are creating this rule because our team doesn’t want any fields in Data Transfer Objects (DTO).

We name the custom rule ‘NoFieldsAllowed’, so create a class with the name ‘NoFieldsAllowed’. The rule is inherit from our BaseRule so we can give the name of the rule to the base class.

using Microsoft.FxCop.Sdk;

namespace CustomCodeAnalysisRules
{
	internal sealed class NoFieldsAllowed : BaseRule
	{

		public NoFieldsAllowed()
			: base("NoFieldsAllowed")
		{

		}
	}
}

using Microsoft.FxCop.Sdk;

namespace CustomCodeAnalysisRules

{

internal sealed class NoFieldsAllowed : BaseRule

{

public NoFieldsAllowed()

: base("NoFieldsAllowed")

{

}

Next we have to say for which type of access modifiers the rule is made for. We can do this be overriding the ‘TargetVisibility’ property. We want to make this rule for all access modifiers so we have to use ‘TargetVisibilities.All’.

// TargetVisibilities 'All' will give you rule violations about public, internal, protected and private access modifiers.
public override TargetVisibilities TargetVisibility
{
	get
	{
		return TargetVisibilities.All;
	}
}

// TargetVisibilities 'All' will give you rule violations about public, internal, protected and private access modifiers.

public override TargetVisibilities TargetVisibility

{

get

{

return TargetVisibilities.All;

}

The setup for the rule is complete so we can write the implementation. Override the ‘Check’ method for a ‘Member’. Cast the member that you get as parameter to a ‘Field’. Check if the Field is ‘null’. If so, the check is not for this member.

public override ProblemCollection Check(Member member)
{
	Field field = member as Field;
	if (field == null)
	{
		// This rule only applies to fields.
		// Return a null ProblemCollection so no violations are reported for this member.
		return null;
	}
}

public override ProblemCollection Check(Member member)

{

Field field = member as Field;

if (field == null)

{

// This rule only applies to fields.

// Return a null ProblemCollection so no violations are reported for this member.

return null;

}

If this member is a field we have to create a ‘Problem’ and a ‘Resolution’. To create a resolution you must create a ‘Rules.xml’ file in your project.

<?xml version="1.0" encoding="utf-8" ?>
<Rules FriendlyName="My Custom Rules">
	<Rule TypeName="NoFieldsAllowed" Category="CustomRules.DTO" CheckId="CR1011">
		<Name>No Fields allowed</Name>
		<Description>Check if fields are used in a class.</Description>
		<Resolution>Field {0} is not allowed. Field must be removed from this class.</Resolution>
		<MessageLevel Certainty="100">Warning</MessageLevel>
		<FixCategories>NonBreaking</FixCategories>
		<Url />
		<Owner />
		<Email />
	</Rule>
</Rules>

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

<Name>No Fields allowed</Name>

<Description>Check if fields are used in a class.</Description>

<Resolution>Field {0} is not allowed. Field must be removed from this class.</Resolution>

<MessageLevel Certainty="100">Warning</MessageLevel>

<FixCategories>NonBreaking</FixCategories>

<Url />

</Rule>

</Rules>

You can add the following information to the ‘Resolution’:

Display name of the rule.
Rule description.
One or more rule resolutions.
The MessageLevel (severity) of the rule. This can be set to one of the following:
- CriticalError
- Error
- CriticalWarning
- Warning
- Information
The certainty of the violation. This field represents the accuracy percentage of the rule. In other words this field describes the rule author’s confidence in how accurate this rule is.
The FixCategory of this rule. This field describes if fixing this rule would require a breaking change, ie a change that could break other assemblies referencing the one being analyzed.
The help url for this rule.
The name of the owner of this rule.
The support email to contact about this rule.

Now we have the information to show as a Resolution. We only have to show it to the user in Visual Studio. So expand the ‘Check’ method by creating a ‘Resolution’ and add it to the ‘Problems’ list of the base class.

public override ProblemCollection Check(Member member)
{
	Field field = member as Field;
	if (field == null)
	{
		// This rule only applies to fields.
		// Return a null ProblemCollection so no violations are reported for this member.
		return null;
	}

	Resolution resolution = GetResolution(
		  field  // Field {0} is not allowed. Field must be removed from this class.
		  );
	Problem problem = new Problem(resolution);
	Problems.Add(problem);

	// By default the Problems collection is empty so no violations will be reported
	// unless CheckFieldName found and added a problem.
	return Problems;
}

public override ProblemCollection Check(Member member)

{

Field field = member as Field;

if (field == null)

{

// This rule only applies to fields.

// Return a null ProblemCollection so no violations are reported for this member.

return null;

}

Resolution resolution = GetResolution(

field // Field {0} is not allowed. Field must be removed from this class.

);

Problem problem = new Problem(resolution);

Problems.Add(problem);

// By default the Problems collection is empty so no violations will be reported

// unless CheckFieldName found and added a problem.

return Problems;

}

Test your Custom code analysis rule

To test your custom rule we can add some fields to your custom rule class. So add under the ‘Check’ method the following fields.

private string testField1 = "This should give an error!!!";
private const string testFieldconst1 = "This should give an error!!!";
protected string testField2 = "This should give an error!!!";
internal string testField3 = "This should give an error!!!";
public string testField4 = "This should give an error!!!";
public const string testFieldconst4 = "This should give an error!!!";

private string testField1 = "This should give an error!!!";

private const string testFieldconst1 = "This should give an error!!!";

protected string testField2 = "This should give an error!!!";

internal string testField3 = "This should give an error!!!";

public string testField4 = "This should give an error!!!";

public const string testFieldconst4 = "This should give an error!!!";

To test this we are going to change the “Start Action” of your class library. Open the properties of your class library and navigate to the ‘Debug’ tab.

Change the ‘Start Action’ to ‘Start external program’. Use as external program ‘FxCopCmd.exe’ from your Visual Studio directory. For me it is: ‘C:\Program Files (x86)\Microsoft Visual Studio 12.0\Team Tools\Static Analysis Tools\FxCop\FxCopCmd.exe’.

Use as Command line arguments: ‘/out:”results.xml” /file:”WebCommBack.CustomCodeAnalysisRules.dll” /rule:”WebCommBack.CustomCodeAnalysisRules.dll” /D:”C:\Program Files (x86)\Microsoft Visual Studio 12.0\Team Tools\Static Analysis Tools\FxCop”‘.

Use as working directory your debug folder in the bin folder of this class library.

Now run your application with Debug. You will see a command prompt showing up. This will check your fields with your rules. The outcome of the test will be written in your debug folder. There you will find a ‘results.xml’ file. If you open it in ‘Internet Explorer’ you will see the information. Of course you can open it in every xml tool.

If your test is what you’ve expected, you can use your custom code analysis dll in your ruleset for your application. See here the outcome an application that uses the custom dll.

Best Visual Studio extensions and applications

05/12/201405/12/2014 Ralph Jansen Leave a comment

The list of tools beneath are tools that I use every day! Some are extensions for Team Foundation Server but also extensions for Visual Studio, awesome Nuget packages or general tools.
It are the best Visual Studio extension and applications that I could find.

Visual Studio Extensions

EnterpriseLibrary.Config
This is a handy tool for your Enterprise Library packages. With this tool you can edit your config with an interface.
GhostDoc
I use the free version of this but you also have a payed version of this. With this tool you can generate your summaries above your code. It will also generate documentation for parameters, properties, field, methods etc.
NuGet Package Manager
I think there is no explanation needed for this…
Target Framework Migrator
With this extension, you can change all (if you want) your projects to a specific version of the .NET Framework with just one click.
Team Foundation Server Power Tools
Extra handy things for getting some information out of your TFS server.
Web Essentials
Handy tools for developing web applications. This allows you to minify and bundle your Javascript code and gives you other things like intellisence for extra languages in Visual Studio.
Wix Toolset
There is no MSI installer anymore in Visual Studio 2012. You can still use Wix to create your MSI installers.
Recent workitems
Show a list of last 5 associated workitems in your pending changes window
Last workitem
Select your last associated workitem
AutoMerge
AutoMerge your changeset over branches in TFS.
Code Review Checkin policy
A checkin policy for checking you have requested a code review.
DevExpress CodeRush
Faster coding and shortcuts in Visual Studio
My History
Your last history items like workitems or changesets
Sandcastle
Help file generator for your code.

Applications

TFS Team Project Manager
Manage your TFS team projects.

NuGet packages

StyleCop
Create defaults for your team about documentation and code formats.
StyleCop Checkin Policy
My own checkin policy for validating your StyleCop rules.
Ninject
Very easy dependency container for fast building applications.
CuttingEdge.Conditions
Small syntax for creating validation of your objects.
NBuilder
Generate test data based on your own POCO class.
AutoMapper
Map your classes from type A to B with just own line of code.

MVC localization validation

15/10/201416/01/2015 Ralph Jansen Leave a comment

This is not the first time that I write about mvc localization validation. The last time that I wrote about this was back in 2012 when I wrote the blog “Localization validation in MVC“. This blog post helped a lot of people with this question on StackOverflow.

In this blog post I create a website with localization for English and Dutch. I will use a DateTime as an example property to display and edit this property for validating the localization. This because the Dutch localization is dd-MM-yyyy and in English we have MM\dd\yyyy.

Technology used

Now I want to write a new post that uses all the latest technology in the MVC world at this moment. At this moment the latest version of Visual Studio is Visual Studio 2013 Update 3. The latest version of MVC is: 5.2.2. This is also the version that we use in combination with .NET Framework 4.5.1.

Setup MVC localization validation

New project

Create a new MVC 5 ASP.NET Web Application in Visual Studio with the use of the .NET Framework 4.5.1. When it is created, update all your Nuget packages about MVC.

Web.config

Some people say that you have to alter the web.config to use localization. This is true when you create a website for a particular localization. In this tutorial I want to create a website that is compatible with multiple cultures from all over the world. Of course you can create a website in English but some people prefer their own language. In this tutorial I will create a website in English and Dutch (I’m from the Netherlands).

So we don’t edit the web.config. We don’t set any culture or UI culture in the web.config. In that way, the default culture is the culture of the pc or (if set) the culture of the browser.

Culture selector

The user should be able to overwrite the default culture from his browser or pc. Maybe the user wants to use another culture than his default culture for your website. So we create some code to create a list with the cultures that you have setup to support in your website.

Code for creating the list of cultures and select a culture different to your browser culture. Add this code in your “_Layout” page in example your menu or footer:

@{
	System.Globalization.CultureInfo currentCulture;
	var supportedCultures = Website.Helpers.CultureHelper.GetSwitchCultures(out currentCulture);
	string currentCultureDisplayName = currentCulture.Parent.NativeName;
}

	<ul>
		@foreach (var culture in supportedCultures)
		{
            string url = Url.Action("SetPreferredCulture", "Culture", new { culture = culture.Name, returnUrl = Request.RawUrl });
            string urlName = culture.Parent.NativeName;
            
			if (culture.Name == currentCulture.Name)
			{
				<li class="active"><a href="@url">@urlName <i class="fa fa-check"></i></a></li>
            }
            else
            {
                <li><a href="@url">@urlName</a></li>
            }
		}
	</ul>

System.Globalization.CultureInfo currentCulture;

var supportedCultures = Website.Helpers.CultureHelper.GetSwitchCultures(out currentCulture);

string currentCultureDisplayName = currentCulture.Parent.NativeName;

}

<ul>

@foreach (var culture in supportedCultures)

{

string url = Url.Action("SetPreferredCulture", "Culture", new { culture = culture.Name, returnUrl = Request.RawUrl });

string urlName = culture.Parent.NativeName;

if (culture.Name == currentCulture.Name)

{

<li class="active"><a href="@url">@urlName <i class="fa fa-check"></i></a></li>

}

else

{

<li><a href="@url">@urlName</a></li>

}

</ul>

Create a static class called CultureHelper and past the following code:

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Web;

namespace Website.Helpers
{
	/// <summary>
	/// Set the culture of the user for the rest of the application. The culture can be overridden by the user. 
	/// If it is overridden a cookie is set with the selected culture. For testing don't forget to remove the cookie for selecting the default browser language again.
	/// </summary>
	public static class CultureHelper
	{

		#region Constants

		/// <summary>
		/// The cookie name of the selected culture. By default there isn't any cookie but only the culture of the browser. 
		/// If the user selects a specific culture, the cookie is added.
		/// </summary>
		const string CookieName = "PreferredCulture";

		#endregion

		#region Fields

		/// <summary>
		/// The supported cultures of this application. If a new localization file is added to the application, the cultureinfo must be added as well.
		/// </summary>
		public static readonly CultureInfo[] SupportedCultures = new CultureInfo[] 
		{ 
			CultureInfo.GetCultureInfo("en-US"), 
			CultureInfo.GetCultureInfo("nl-NL"),
			//CultureInfo.GetCultureInfo("de-DE"), 
			//CultureInfo.GetCultureInfo("fr-FR"), 
			//CultureInfo.GetCultureInfo("es-ES"), 
		};

		#endregion

		#region Public Methods

		public static void ApplyUserCulture(this HttpRequest request)
		{
			ApplyUserCulture(request.Headers, request.Cookies);
		}

		public static CultureInfo GetMatch(CultureInfo[] acceptedCultures, CultureInfo[] supportedCultures, Func<CultureInfo, CultureInfo, bool> predicate)
		{
			foreach (var acceptedCulture in acceptedCultures)
			{
				var match = supportedCultures
					.Where(supportedCulture => predicate(acceptedCulture, supportedCulture))
					.FirstOrDefault();

				if (match != null)
				{
					return match;
				}
			}

			return null;
		}

		public static CultureInfo GetMatchingCulture(CultureInfo[] acceptedCultures, CultureInfo[] supportedCultures)
		{
			return
				// first pass: exact matches as well as requested neutral matching supported region 
				// supported: en-US, de-DE 
				// requested: de, en-US;q=0.8 
				// => de-DE! (de has precendence over en-US) 
				GetMatch(acceptedCultures, supportedCultures, MatchesCompletely)
				// second pass: look for requested neutral matching supported _neutral_ region 
				// supported: en-US, de-DE 
				// requested: de-AT, en-GB;q=0.8 
				// => de-DE! (no exact match, but de-AT has better fit than en-GB) 
				?? GetMatch(acceptedCultures, supportedCultures, MatchesPartly);
		}

		public static void GetSwitchCultures(out CultureInfo currentCulture, out CultureInfo nextCulture)
		{
			currentCulture = Thread.CurrentThread.CurrentUICulture;
			var currentIndex = Array.IndexOf(SupportedCultures.Select(ci => ci.Name).ToArray(), currentCulture.Name);
			int nextIndex = (currentIndex + 1) % SupportedCultures.Length;
			nextCulture = SupportedCultures[nextIndex];
		}

		public static CultureInfo[] GetSwitchCultures(out CultureInfo currentCulture)
		{
			currentCulture = Thread.CurrentThread.CurrentUICulture;

			return SupportedCultures;
		}

		public static CultureInfo GetUserCulture(NameValueCollection headers)
		{
			var acceptedCultures = GetUserCultures(headers["Accept-Language"]);
			var culture = GetMatchingCulture(acceptedCultures, SupportedCultures);

			return culture;
		}

		public static CultureInfo[] GetUserCultures(string acceptLanguage)
		{
			// Accept-Language: fr-FR , en;q=0.8 , en-us;q=0.5 , de;q=0.3 
			if (string.IsNullOrWhiteSpace(acceptLanguage))
				return new CultureInfo[] { };

			var cultures = acceptLanguage
				.Split(',')
				.Select(s => WeightedLanguage.Parse(s))
				.OrderByDescending(w => w.Weight)
				 .Select(w => GetCultureInfo(w.Language))
				 .Where(ci => ci != null)
				 .ToArray();

			return cultures;
		}

		public static void SetPreferredCulture(this HttpResponseBase response, string cultureName)
		{
			SetPreferredCulture(response.Cookies, cultureName);
		}

		#endregion

		#region Private Methods

		private static void ApplyUserCulture(NameValueCollection headers, HttpCookieCollection cookies)
		{
			var culture = GetPreferredCulture(cookies)
				?? GetUserCulture(headers)
				?? SupportedCultures[0];

			var t = Thread.CurrentThread;
			t.CurrentCulture = culture;
			t.CurrentUICulture = culture;

			Debug.WriteLine("Culture: " + culture.Name);
		}

		private static CultureInfo GetCultureInfo(string language)
		{
			try
			{
				return CultureInfo.GetCultureInfo(language);
			}
			catch (CultureNotFoundException)
			{
				return null;
			}
		}

		private static CultureInfo GetPreferredCulture(HttpCookieCollection cookies)
		{
			var cookie = cookies[CookieName];
			if (cookie == null)
				return null;

			var culture = GetCultureInfo((string)cookie.Value);
			if (culture == null)
				return null;

			if (!SupportedCultures.Where(ci => ci.Name == culture.Name).Any())
				return null;

			return culture;
		}

		private static bool MatchesCompletely(CultureInfo acceptedCulture, CultureInfo supportedCulture)
		{
			if (supportedCulture.Name == acceptedCulture.Name)
			{
				return true;
			}

			// acceptedCulture could be neutral and supportedCulture specific, but this is still a match (de matches de-DE, de-AT, …) 
			if (acceptedCulture.IsNeutralCulture)
			{
				if (supportedCulture.Parent.Name == acceptedCulture.Name)
				{
					return true;
				}
			}

			return false;
		}

		private static bool MatchesPartly(CultureInfo acceptedCulture, CultureInfo supportedCulture)
		{
			supportedCulture = supportedCulture.Parent;
			if (!acceptedCulture.IsNeutralCulture)
			{
				acceptedCulture = acceptedCulture.Parent;
			}

			if (supportedCulture.Name == acceptedCulture.Name)
			{
				return true;
			}

			return false;
		}

		private static void SetPreferredCulture(HttpCookieCollection cookies, string cultureName)
		{
			var cookie = new HttpCookie(CookieName, cultureName)
			{
				Expires = DateTime.Now.AddDays(30)
			};

			cookies.Set(cookie);

			Debug.WriteLine("SetPreferredCulture: " + cultureName);
		}

		#endregion

	}

	[DebuggerDisplay("Language = {Language} Weight = {Weight}")]
	internal class WeightedLanguage
	{
		public string Language { get; set; }

		public double Weight { get; set; }

		public static WeightedLanguage Parse(string weightedLanguageString)
		{
			// de 
			// en;q=0.8 
			var parts = weightedLanguageString.Split(';');
			var result = new WeightedLanguage { Language = parts[0].Trim(), Weight = 1.0 };

			if (parts.Length > 1)
			{
				parts[1] = parts[1].Replace("q=", "").Trim();
				double d;
				if (double.TryParse(parts[1], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out d))
					result.Weight = d;
			}

			return result;
		}
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

using System;

using System.Collections.Generic;

using System.Collections.Specialized;

using System.Diagnostics;

using System.Globalization;

using System.Linq;

using System.Threading;

using System.Web;

namespace Website.Helpers

{

/// <summary>

/// Set the culture of the user for the rest of the application. The culture can be overridden by the user.

/// If it is overridden a cookie is set with the selected culture. For testing don't forget to remove the cookie for selecting the default browser language again.

/// </summary>

public static class CultureHelper

{

#region Constants

/// <summary>

/// The cookie name of the selected culture. By default there isn't any cookie but only the culture of the browser.

/// If the user selects a specific culture, the cookie is added.

/// </summary>

const string CookieName = "PreferredCulture";

#endregion

#region Fields

/// <summary>

/// The supported cultures of this application. If a new localization file is added to the application, the cultureinfo must be added as well.

/// </summary>

public static readonly CultureInfo[] SupportedCultures = new CultureInfo[]

{

CultureInfo.GetCultureInfo("en-US"),

CultureInfo.GetCultureInfo("nl-NL"),

//CultureInfo.GetCultureInfo("de-DE"),

//CultureInfo.GetCultureInfo("fr-FR"),

//CultureInfo.GetCultureInfo("es-ES"),

};

#endregion

#region Public Methods

public static void ApplyUserCulture(this HttpRequest request)

{

ApplyUserCulture(request.Headers, request.Cookies);

}

public static CultureInfo GetMatch(CultureInfo[] acceptedCultures, CultureInfo[] supportedCultures, Func<CultureInfo, CultureInfo, bool> predicate)

{

foreach (var acceptedCulture in acceptedCultures)

{

var match = supportedCultures

.Where(supportedCulture => predicate(acceptedCulture, supportedCulture))

.FirstOrDefault();

if (match != null)

{

return match;

}

return null;

}

public static CultureInfo GetMatchingCulture(CultureInfo[] acceptedCultures, CultureInfo[] supportedCultures)

{

return

// first pass: exact matches as well as requested neutral matching supported region

// supported: en-US, de-DE

// requested: de, en-US;q=0.8

// => de-DE! (de has precendence over en-US)

GetMatch(acceptedCultures, supportedCultures, MatchesCompletely)

// second pass: look for requested neutral matching supported _neutral_ region

// supported: en-US, de-DE

// requested: de-AT, en-GB;q=0.8

// => de-DE! (no exact match, but de-AT has better fit than en-GB)

?? GetMatch(acceptedCultures, supportedCultures, MatchesPartly);

}

public static void GetSwitchCultures(out CultureInfo currentCulture, out CultureInfo nextCulture)

{

currentCulture = Thread.CurrentThread.CurrentUICulture;

var currentIndex = Array.IndexOf(SupportedCultures.Select(ci => ci.Name).ToArray(), currentCulture.Name);

int nextIndex = (currentIndex + 1) % SupportedCultures.Length;

nextCulture = SupportedCultures[nextIndex];

}

public static CultureInfo[] GetSwitchCultures(out CultureInfo currentCulture)

{

currentCulture = Thread.CurrentThread.CurrentUICulture;

return SupportedCultures;

}

public static CultureInfo GetUserCulture(NameValueCollection headers)

{

var acceptedCultures = GetUserCultures(headers["Accept-Language"]);

var culture = GetMatchingCulture(acceptedCultures, SupportedCultures);

return culture;

}

public static CultureInfo[] GetUserCultures(string acceptLanguage)

{

// Accept-Language: fr-FR , en;q=0.8 , en-us;q=0.5 , de;q=0.3

if (string.IsNullOrWhiteSpace(acceptLanguage))

return new CultureInfo[] { };

var cultures = acceptLanguage

.Split(',')

.Select(s => WeightedLanguage.Parse(s))

.OrderByDescending(w => w.Weight)

.Select(w => GetCultureInfo(w.Language))

.Where(ci => ci != null)

.ToArray();

return cultures;

}

public static void SetPreferredCulture(this HttpResponseBase response, string cultureName)

{

SetPreferredCulture(response.Cookies, cultureName);

}

#endregion

#region Private Methods

private static void ApplyUserCulture(NameValueCollection headers, HttpCookieCollection cookies)

{

var culture = GetPreferredCulture(cookies)

?? GetUserCulture(headers)

?? SupportedCultures[0];

var t = Thread.CurrentThread;

t.CurrentCulture = culture;

t.CurrentUICulture = culture;

Debug.WriteLine("Culture: " + culture.Name);

}

private static CultureInfo GetCultureInfo(string language)

{

try

{

return CultureInfo.GetCultureInfo(language);

}

catch (CultureNotFoundException)

{

return null;

}

private static CultureInfo GetPreferredCulture(HttpCookieCollection cookies)

{

var cookie = cookies[CookieName];

if (cookie == null)

return null;

var culture = GetCultureInfo((string)cookie.Value);

if (culture == null)

return null;

if (!SupportedCultures.Where(ci => ci.Name == culture.Name).Any())

return null;

return culture;

}

private static bool MatchesCompletely(CultureInfo acceptedCulture, CultureInfo supportedCulture)

{

if (supportedCulture.Name == acceptedCulture.Name)

{

return true;

}

// acceptedCulture could be neutral and supportedCulture specific, but this is still a match (de matches de-DE, de-AT, …)

if (acceptedCulture.IsNeutralCulture)

{

if (supportedCulture.Parent.Name == acceptedCulture.Name)

{

return true;

}

return false;

}

private static bool MatchesPartly(CultureInfo acceptedCulture, CultureInfo supportedCulture)

{

supportedCulture = supportedCulture.Parent;

if (!acceptedCulture.IsNeutralCulture)

{

acceptedCulture = acceptedCulture.Parent;

}

if (supportedCulture.Name == acceptedCulture.Name)

{

return true;

}

return false;

}

private static void SetPreferredCulture(HttpCookieCollection cookies, string cultureName)

{

var cookie = new HttpCookie(CookieName, cultureName)

{

Expires = DateTime.Now.AddDays(30)

};

cookies.Set(cookie);

Debug.WriteLine("SetPreferredCulture: " + cultureName);

}

#endregion

}

[DebuggerDisplay("Language = {Language} Weight = {Weight}")]

internal class WeightedLanguage

{

public string Language { get; set; }

public double Weight { get; set; }

public static WeightedLanguage Parse(string weightedLanguageString)

{

// de

// en;q=0.8

var parts = weightedLanguageString.Split(';');

var result = new WeightedLanguage { Language = parts[0].Trim(), Weight = 1.0 };

if (parts.Length > 1)

{

parts[1] = parts[1].Replace("q=", "").Trim();

double d;

if (double.TryParse(parts[1], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out d))

result.Weight = d;

}

return result;

}

The “SupportedCultures” field contains the list of supported cultures for your website.

We must also make the Culture of the client available in your project. You have to do this in every request. So go to your Global.asax and add the following event:

/// <summary>
/// Fire on each request.
/// </summary>
protected void Application_OnBeginRequest()
{
    // Get the culture of the client
    CultureHelper.ApplyUserCulture(Request);
}

/// <summary>

/// Fire on each request.

/// </summary>

protected void Application_OnBeginRequest()

{

// Get the culture of the client

CultureHelper.ApplyUserCulture(Request);

}

Create a new CultureController in your project and paste the following code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using Website.Helpers;

namespace Website.Controllers
{
    public class CultureController : Controller
    {
		// GET: /SetPreferredCulture/de-DE 
		[AllowAnonymous]
		public ActionResult SetPreferredCulture(string culture, string returnUrl)
		{
			Response.SetPreferredCulture(culture);
			
			if (string.IsNullOrEmpty(returnUrl))
				return RedirectToAction("Index", "Home");

			return Redirect(returnUrl);
		}
				
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web.Mvc;

using Website.Helpers;

namespace Website.Controllers

{

public class CultureController : Controller

{

// GET: /SetPreferredCulture/de-DE

[AllowAnonymous]

public ActionResult SetPreferredCulture(string culture, string returnUrl)

{

Response.SetPreferredCulture(culture);

if (string.IsNullOrEmpty(returnUrl))

return RedirectToAction("Index", "Home");

return Redirect(returnUrl);

}

Add a new route above the default route in your RouteConfig.cs.

// Set culture route
routes.MapRoute(
    name: "SetPreferredCulture",
    url: "SetPreferredCulture/{culture}",
    defaults: new { controller = "Culture", action = "SetPreferredCulture", culture = UrlParameter.Optional }
);

// Set culture route

routes.MapRoute(

name: "SetPreferredCulture",

url: "SetPreferredCulture/{culture}",

defaults: new { controller = "Culture", action = "SetPreferredCulture", culture = UrlParameter.Optional }

);

Create a folder in the root of your project called “Localizations”. Add a Resource file called “Labels.resx” in that folder. This is your English resource file so the default language is the English language. Set the Access Modifier to Public. Copy the Labels resource file for the other languages. For Dutch is this: Labels.nl-NL.resx. So when the user switches from culture or the browser has another culture set, the right resource file is automatically chosen.

DateTime Example

Now we have the right culture of the user, we need an example so we can prove it actually works. So we create an object with a DateTime property. In that way we can display and edit that property in the different cultures. Remember that the Dutch language has a different date format than the English language.

Because all the browser are displaying date textboxes different, we create our own until the HTML 5 specification is finally done. Also, the older browsers don’t support HTML 5 so we must create our own textbox with jQuery UI datepicker.

To do this, we create a new EditorTemplate. If you never done this before, don’t worry it is very easy. Create a new folder called “EditorTemplates” in your “Shared” folder in the “Views” folder. In the EditorTemplates folder, create a new view called “Date”.

Now when a Date field is used for editing, the editortemplate is automatically used. Paste the following code in the Date editortemplate.

@model DateTime?

@if (Model.HasValue)
{
    @Html.TextBox("", Model.Value.ToShortDateString(), new { @class = "date form-control" })
}
else
{
    @Html.TextBox("", Model, new { @class = "date form-control" })
}

@model DateTime?

@if (Model.HasValue)

{

@Html.TextBox("", Model.Value.ToShortDateString(), new { @class = "date form-control" })

}

else

{

@Html.TextBox("", Model, new { @class = "date form-control" })

}

Initialize the Datepicker

Now we have created an editor for editing, the jQuery datepicker should be created. Because we also create the datepicker for a specific culture, the right language file of the jQuery datepicker should be selected as well. You can find the url of the language file in the documentation/source code from the jQuery datepicker documentation page.

Add the following code in the _Layout page just after setting up jQuery and jQuery UI.

@if (!string.IsNullOrWhiteSpace(UICulture))
{
	string shortCulture = UICulture.Substring(0, 2);
	if (shortCulture != "en")
	{
		// Only set culture script if it isn't en because en is the default
		string url = string.Format("/Scripts/datepicker-{0}.js", shortCulture);
		<script src="@url"></script>
	}
}

@if (!string.IsNullOrWhiteSpace(UICulture))

{

string shortCulture = UICulture.Substring(0, 2);

if (shortCulture != "en")

{

// Only set culture script if it isn't en because en is the default

string url = string.Format("/Scripts/datepicker-{0}.js", shortCulture);

}

This code finds the right language file and add it to the page for the current (selected) culture.

<script type="text/javascript">
	$(document).ready(function () {
		$('.date').datepicker({
			showOtherMonths: true,
			selectOtherMonths: true,
			changeMonth: true,
			changeYear: true,
			numberOfMonths: 1,
			showButtonPanel: true
		});
	});
</script>

$(document).ready(function () {

$('.date').datepicker({

showOtherMonths: true,

selectOtherMonths: true,

changeMonth: true,

changeYear: true,

numberOfMonths: 1,

showButtonPanel: true

});

</script>

This code creates the datepicker in the right culture.

Test the editor

To test the editor, create an object with a DateTime property. See the following example for the class “Member”:

public class Member
{
    [Key]
    public int Id { get; set; }
		
    [Display(Name = "Voornaam")]
    [Required]
    [StringLength(50)]
    public string FirstName { get; set; }

    [Display(Name = "Achternaam")]
    [Required]
    [StringLength(50)]
    public string LastName { get; set; }
        
    [Display(Name = "Geboortedatum")]
    [Required]
    [DataType(DataType.Date)]
    public DateTime BirthDay { get; set; }
}

public class Member

{

[Key]

public int Id { get; set; }

[Display(Name = "Voornaam")]

[Required]

[StringLength(50)]

public string FirstName { get; set; }

[Display(Name = "Achternaam")]

[Required]

[StringLength(50)]

public string LastName { get; set; }

[Display(Name = "Geboortedatum")]

[Required]

[DataType(DataType.Date)]

public DateTime BirthDay { get; set; }

}

The EditorTemplate is selected because we have used the “DataType” attribute with the “DataType.Date” value. You could also use the “UIHint” attribute.

If you generate (scaffold) a new Edit or Create view, change the code for the Birthday property to:

<div class="form-group">
    @Html.LabelFor(model => model.BirthDay, new { @class = "control-label col-md-2" })
    <div class="col-md-10">
        @Html.EditorFor(model => model.BirthDay, new { htmlAttributes = new { @class = "form-control" }, })
        @Html.ValidationMessageFor(model => model.BirthDay)
    </div>
</div>

@Html.LabelFor(model => model.BirthDay, new { @class = "control-label col-md-2" })

@Html.EditorFor(model => model.BirthDay, new { htmlAttributes = new { @class = "form-control" }, })

@Html.ValidationMessageFor(model => model.BirthDay)

</div>

Now run your project and try to edit or create a member object. You now should see a textbox with a jQuery UI datepicker inside. When you select a date from the datepicker, the format of the date should be the format of the culture you requested. Also the validation should be right for the Culture you have selected.

Conclusion

Now you have a culture independent website with a jQuery datepicker in the culture that the user wants. You can upload this website to every server you want. You don’t have to set any culture on the server because this solution is culture independent. This is easy for me in the Netherlands because now I can create a Dutch website that I can upload to Microsoft Azure (in azure you have en-US culture) without any problems.

Trigger a CI build after a gated checkin

02/09/201403/09/2014 Ralph Jansen 6 Comments

We want to trigger a CI build after a gated checkin because we have two builds in our company. One with a gated checkin for fast building and very important test. The other build is for code analysis and long running tests. Because we don’t want to wait very long on our CI build we have created that QM build. The problem is that the QM isn’t triggered anymore after changing the CI build to a Gated checkin build.

I found a blogpost for TFS 2010. Because TFS 2013 is slightly different, I thought I would give it an update.

This is how to fix it for TFS 2013

Create an argument called “NoCIOption” of the type boolean with default True.
Set the metadata information so you understand the argument in your build definition.
Use the argument in the TFS 2013 build template. You can find the property under “Run on agent” and then “Get sources from Team Foundation Version Control”. Go to the properties window and change the hard coded “True” in the NoCIOption property to the argument you just created.

Now checkin your changes of the teamplate and use (if you don’t already have) the template in your CI build (the one with the gated checkin). Change the new argument to “false”.

Now your second build (our QM) is also triggered again.

Add image to sandcastle

18/08/201418/08/2014 Ralph Jansen 1 Comment

I wanted to know how to add image to sandcastle. The documentation of sandcastle is long but I didn’t found a good sample of how to add an image to the welcome page.

I use Sandcastle Help File Builder to generate documentation for my applications. I also have a nice welcome page called “Welcome.aml”.

In the welcome page I have a section of the architecture of the application. I wanted to add an image of the architecture schema. The problem was that I didn’t found anywhere how to do this. The problem was that I didn’t use the id of the image but the name of the image. The solution was just to just use the id.

The solution

So to add an image from the “Media” folder into a new section:

<section>
	<title>Architectuur</title>
	<content>
		<mediaLink>
			<caption>Architectuurschema</caption>
			<image placement="center" xlink:href="Architectuurschema"/>
		</mediaLink>				
	</content>
</section>

<title>Architectuur</title>

<caption>Architectuurschema</caption>

</mediaLink>

</content>

</section>

Edit outlook.com contacts in android

28/05/201417/01/2017 Ralph Jansen 41 Comments

Updated 2017-01-17: Updated the blogpost to the new outlook.com experience (on the office 365 platform).

Edit outlook.com contacts in android is a real pain. But in this post I will explain to you have to fix this.

Because Google and Microsoft are in some kind of war in what the best way is to edit contacts, you could be having troubling with editing your Outlook.com contacts in Android. Follow these steps to edit your Outlook.com contacts again.

If you have installed the Outlook.com application out of the play store, remove it from your device. It has been replaced by the new Outlook application some time ago.
Setup the new Outlook application and disable contact sync. Contacts do get synced to your device very nice but you can’t edit them. So they are useless to use. We disable the sync so we can sync them another way. If you leave this enabled you will end up with dupplicates on your phone.
On your phone, go to Settings -> Accounts & Sync
Add an Exchange ActiveSync account. Do not use the outlook.com account. some phones will display an outlook.com sync possibility but that is an old obsolete one. If you can’t find an Exchange account, try to use the default email application on your phone. It should have one build in.
1. Account name: whatever you want
2. email adres: your outlook.com email adres (could also be hotmail, msn, live etc)
3. Server adres: eas.outlook.com
4. username: again your full email-address
5. password: your outlook.com email-address password
6. Enable SSL
7. Leave the rest default
Click next and select only to sync the Contacts.
Finish the setup (wait a while to finish the syncing of your contacts). Now you can edit your contacts and they are synced to your outlook.com account.

Download files from TFS server with PowerShell

21/05/201421/05/2014 Ralph Jansen 4 Comments

If you want to download files from TFS with PowerShell, you will need to write a script that can access the TFS Server and access the folder on your drive.

This script uses a server path in the TFS server and download some files under that server path to the drop folder of your build. If you don’t use a build, you can change then environment variables. This script is created because of an original question on StackOverflow.

# The deploy directory for all the msi, zip etc.
$AutoDeployDir = "Your TFS Directory Server Path"
$deployDirectory = $($Env:TF_BUILD_DROPLOCATION + "\Deploy\" + $Env:TF_BUILD_BUILDNUMBER)

# Add TFS 2013 dlls so we can download some files
Add-Type -AssemblyName 'Microsoft.TeamFoundation.Client, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'
Add-Type -AssemblyName 'Microsoft.TeamFoundation.VersionControl.Client, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'
$tfsCollectionUrl = 'http://YourServer:8080/tfs/YourCollection' 
$tfsCollection = New-Object -TypeName Microsoft.TeamFoundation.Client.TfsTeamProjectCollection -ArgumentList $tfsCollectionUrl
$tfsVersionControl = $tfsCollection.GetService([Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer])

# Register PowerShell commands
Add-PSSnapin Microsoft.TeamFoundation.PowerShell

# Get all directories and files in the AutoDeploy directory
$items = Get-TfsChildItem $AutoDeployDir -Recurse

# Download each item to a specific destination
foreach ($item in $items) {
    # Serverpath of the item
    Write-Host "TFS item to download:" $($item.ServerItem) -ForegroundColor Blue

    $destinationPath = $item.ServerItem.Replace($AutoDeployDir, $deployDirectory)
    Write-Host "Download to" $([IO.Path]::GetFullPath($destinationPath)) -ForegroundColor Blue

    if ($item.ItemType -eq "Folder") {
        New-Item $([IO.Path]::GetFullPath($destinationPath)) -ItemType Directory -Force
    }
    else {
        # Download the file (not folder) to destination directory
        $tfsVersionControl.DownloadFile($item.ServerItem, $([IO.Path]::GetFullPath($destinationPath)))
    }
}

# The deploy directory for all the msi, zip etc.

$AutoDeployDir = "Your TFS Directory Server Path"

$deployDirectory = $($Env:TF_BUILD_DROPLOCATION + "\Deploy\" + $Env:TF_BUILD_BUILDNUMBER)

# Add TFS 2013 dlls so we can download some files

Add-Type -AssemblyName 'Microsoft.TeamFoundation.Client, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'

Add-Type -AssemblyName 'Microsoft.TeamFoundation.VersionControl.Client, Version=12.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'

$tfsCollectionUrl = 'http://YourServer:8080/tfs/YourCollection'

$tfsCollection = New-Object -TypeName Microsoft.TeamFoundation.Client.TfsTeamProjectCollection -ArgumentList $tfsCollectionUrl

$tfsVersionControl = $tfsCollection.GetService([Microsoft.TeamFoundation.VersionControl.Client.VersionControlServer])

# Register PowerShell commands

Add-PSSnapin Microsoft.TeamFoundation.PowerShell

# Get all directories and files in the AutoDeploy directory

$items = Get-TfsChildItem $AutoDeployDir -Recurse

# Download each item to a specific destination

foreach ($item in $items) {

# Serverpath of the item

Write-Host "TFS item to download:" $($item.ServerItem) -ForegroundColor Blue

$destinationPath = $item.ServerItem.Replace($AutoDeployDir, $deployDirectory)

Write-Host "Download to" $([IO.Path]::GetFullPath($destinationPath)) -ForegroundColor Blue

if ($item.ItemType -eq "Folder") {

New-Item $([IO.Path]::GetFullPath($destinationPath)) -ItemType Directory -Force

}

else {

# Download the file (not folder) to destination directory

$tfsVersionControl.DownloadFile($item.ServerItem, $([IO.Path]::GetFullPath($destinationPath)))

}

TFS Power tools 2013 update 2 are released

16/05/201416/05/2014 Ralph Jansen Leave a comment

The TFS Power tools 2013 update 2 are released a few days ago. Strange that there isn’t any notification in your Visual Studio 2013 environment. This update gives you better support for the new features in TFS 2013 Update 2.

You first have to uninstall the old version before installing the new version. If you want PowerShell support, you have to choose the custom installer in the wizard.

Download

You can download the update in the Visual Studio gallery by following this link:
http://visualstudiogallery.msdn.microsoft.com/f017b10c-02b4-4d6d-9845-58a06545627f