in this video I walk you through the reports which are available out of the box in Sites&Reports category of Nintex Analytics 2010.

one of the best thing about Nintex Analytics 2010 is the installation experience. like other Nintex products, the installation experience is fast and easy. you just need to let Nintex Analytics know a few settings and it will take care of the rest.

in the following video I’ll show how to install Nintex Analytics 2010 on your environment.

well we all know that Nintex Analytics provides a great insight to our SharePoint environments through the vast number of reports it provides out of the box.

But how can we turn these information into some actions? the good news is that Nintex Analytics 2010 integrates well with Nintex Workflow which would enable us to make some decision and execute a set up process based on the outcome of a report.

Nintex Analytics 2010 has got the capability to trigger a Nintex Workflow as part of report schedule. the report will pass all the information to the workflow and leaves it upto the workflow to take some action –if required- based on the data.

for example there is report avaiable out of the box in Nintex Analytics 2010 called Content Storage by Site which displays total disk storage used by each site.

let’s say that in your organization a each site belongs to a department and IT department bills them based on their disk usage.

to automate this you can easily create a workflow which generates and emails the bill for each department once the report schedule is ran.

The workflow need to be a site workflow. so let’s create a Nintex Workflow called Bill Departments by clicking Site Actions => Nintex Workflow 2010 => Create Site Workflow. the next step is to define the variables that report will pass to the workflow.

By default, the following five report columns will passed by the report to the workflow as a Workflow variable.

· ScheduleInfo – The run schedule of the report e.g. Once per month

· ReportID – The report ID

· ScheduleStartTime – The start time of the schedule

· ScheduleEndTime – The end time of the schedule

· ExecutionID – The execution ID for the schedule that triggers the workflow

And if you chose to run the workflow for each result, then report will prefix all the columns in the result with “ReportData” and passes them to the workflow as workflow variable. to find out what are columns available in the the report you can click the chart/table designer in the report design mode and then click on Data Settings tab. you will see all available columns in this tab.  for example our report has got the following columns:

If you chose to run the workflow for each result which we want so, then report will prefix all the columns in the result with “ReportData” and passes them to the workflow as workflow variable. for example the this report will pass the following parameters to the workflow:
ReportDataSiteId, ReportDataWebId, ReportDataFiles, ReportDataFilesRelative, ReportDataSizeRelative, ReportDataSize etc..

in this case we just need to use ReportDataSiteId and ReportDataSize. so we need to create a variable for each of them in the workflow:

Please note that, the name of the variable created in the workflow is case sensitive and should be ReportData followed by column name and NOT column display name.

we can proceed and design our workflow using these two parameters. please note that the workflow will be executed per each record in the result which in this case is a site.

once we are done with designing the workflow we need to publish it and make it ready to be triggered by the report schedule.

let’s assume that you need to bill departments each month. so we would configure the report schedule to run first of each month

and that’s all we needed to do. next time the report schedule runs it will trigger the workflow for each record in the result of the report execution.

Support for Ioc containers is backed into ASP.NET WEB API and uses the service locator pattern dependency resolver by default.

the default service locator implements the IDependencyResolver interface. This interface has two methods.

• GetService: Creates one instance of a specified type.
• GetServices: Create a collection of objects of a specified type.

in order to use Microsoft Unity framework with ASP.NET WEB API we need to map these to methods to Resolve and ResolveAll methods of Utity. to do so first add the following method to your global.asax.cs or your bootstrapper class

        Public static void RegisterDependencies(IUnityContainer container)

        {

            GlobalConfiguration.Configuration.ServiceResolver.SetResolver(

                t =>

                {

                    try

                    {

                        return container.Resolve(t);

                    }

                    catch (ResolutionFailedException)

                    {

                        return null;

                    }

                },

                t =>

                {

                    try

                    {

                        return container.ResolveAll(t);

                    }

                    catch (ResolutionFailedException)

                    {

                        return new List<object>();

                    }

                });

        }

this is the method which maps the GetService and GetServices methods to Resolve and ResolveAll methods.

the next and final step is to plug in this method to the framework. to do so you just need to call this method from the method in which you construct your unity container. in my case I create a separate method to take care of this:

        private static IUnityContainer BuildUnityContainer()

        {

            var container = new UnityContainer();

            RegisterMappers(container);

            RegisterDependencies(container);

            container.RegisterControllers();

            DependencyResolver.SetResolver(new UnityDependencyResolver(container));

            return container;

        }

and you are done. you should be able to use your Ioc container with ASP.NET WEB API now.

You may want to host you HTTP Service i.e. ASP.NET WEB API in a console app. well it can be easily done.

to show this lets create a console app and add reference to the following assemblies:

System.Web

System.Web.Http

System.Web.Http.Common

System.Web.Http.SelfHost

System.Web.Http.WebHost

System.Net;

System.Net.Http.Formatting;

System.Net.Http.Headers;

this step is optional but for just touching on Json.net I am going to install Json.net using Nuget.

Now lets add a CarInfo class to return it in our controller

   1:      public class CarInfo

   2:      {

   3:          private readonly DateTime releaseDate = DateTime.UtcNow;

   4:          private readonly Dictionary<int, string> availableColors = new Dictionary<int, string>  

   5:            {         

   6:            { 1, "yellow"},   

   7:            { 2, "red" },   

   8:            { 3, "black" }, 

   9:            };

  10:   

  11:          public string Name

  12:          {

  13:              get

  14:              {

  15:                  return "BMW X6";

  16:              }

  17:          }

  18:          public DateTime ReleaseDate { get { return releaseDate; } }

  19:          public IDictionary<int, string> AvailableColors { get { return availableColors; } }

  20:      }

And let’s create our home controller as bellow:

   1:      public class HomeController : ApiController

   2:      {

   3:          // GET /api/<controller>

   4:          public CarInfo Get()

   5:          {

   6:              return new CarInfo();

   7:          }

   8:      }

as you see our controller has got just one method which responds to the Get request.

we also need a little helper class to integrate JSon.net to our application. please note as mentioned above using Json.net is optional.

  public class JsonNetFormatter : MediaTypeFormatter

    {

        private readonly JsonSerializerSettings jsonSerializerSettings;

        public JsonNetFormatter(JsonSerializerSettings jsonSerializerSettings)

        {

            this.jsonSerializerSettings = jsonSerializerSettings ?? new JsonSerializerSettings();

            SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));

            Encoding = new UTF8Encoding(false, true);

        }

        protected override bool CanReadType(Type type)

        {

            return type != typeof(IKeyValueModel);

        }

        protected override bool CanWriteType(Type type)

        {

            return true;

        }

        protected override Task<object> OnReadFromStreamAsync(Type type, Stream stream, 

HttpContentHeaders contentHeaders, FormatterContext formatterContext)

        {

            var serializer = JsonSerializer.Create(this.jsonSerializerSettings);

            return Task.Factory.StartNew(() =>

            {

                using (var streamReader = new StreamReader(stream, Encoding))

                {

                    using (var jsonTextReader = new JsonTextReader(streamReader))

                    {

                        return serializer.Deserialize(jsonTextReader, type);

                    }

                }

            });

        }

        protected override Task OnWriteToStreamAsync(Type type, object value, Stream stream, 

HttpContentHeaders contentHeaders, FormatterContext formatterContext, TransportContext transportContext)

        {

            var serializer = JsonSerializer.Create(this.jsonSerializerSettings);

            return Task.Factory.StartNew(() =>

            {

                using (var jsonTextWriter = 

new JsonTextWriter(new StreamWriter(stream, Encoding)) { CloseOutput = false })

                {

                    serializer.Serialize(jsonTextWriter, value);

                    jsonTextWriter.Flush();

                }

            });

        }

    }

ok it’s time to create actual host to host our service. you just need to add few lines of code to the main method of the program

        static void Main(string[] args)

        {

            // Set up server configuration    

            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost:8081");

            config.Routes.MapHttpRoute("Default", "{controller}", new { controller = "Home" });

            JsonSerializerSettings serializerSettings = new JsonSerializerSettings();

            serializerSettings.Converters.Add(new IsoDateTimeConverter());

            config.Formatters[0] = new JsonNetFormatter(serializerSettings);

            // Create server   

            var server = new HttpSelfHostServer(config);

            // Start listening   

            server.OpenAsync().Wait();

            Console.ReadLine();

        }

to test the application open Fiddler and create a request as below:

basically you need to set the address to http://localhost:8081/Home and content-type to Content-Type: application/json; charset=utf-8. once you create the request click on execute and you should be getting the following response back

as you see we get Json representation of the CarInfo object.

it was quit simple, wasn’t it?

Well it’s really pity that neither VS2010 nor SQL development studio provide SQL syntax formatter. but anyway there good news is that there are sites like http://www.tsqltidy.com  out there which would this for you for free.

but that was not enough for me. i wanted to have tool with me to do this even when i am not connected to the internet–although does not happen that often -

Since i use Notepad++ as my text editor, i tought there might be a plug in for it. so searching online i found T-SQL formatter plug in.

it’s not still a perfect formatter but in almost 90% of the times it’s done a great job for me.

so if you also need a SQL formatter you may want to try this.

To install it, open Notepad++, click on Plugins Menu and from the Plugin Manager menu click on Mange Plugins sub menu.

then from the Plugin Manager dialog box, select Poor Man’s T_Sql Formatter can click on install

it will ask you to restart the application click yes and next time you run Notepad++ you’ll have good SQL formatter plugin installed:

Today we faced a crazy situation. we have a piece of code in one of our applications which parses date and time value entered into a text box. Being lazy/smart developers we normally copy paste the sample value from the help file in order to test it. but crazy part was that when we copy paste it, .net could not parse the value throwing exception saying that the string was not in correct format. but if we typed exactly the same value it would work! aha let me copy paste both values into notepad and compare them char by char. ok they are exactly the same.

to cut the story short after spending some times on the issue we noticed that there is an invisible character at the beginning of the value copied from the help file. then we quickly created a console app to get the char code of the character. and yes that’s a valid unicode character with 8203 code called “Zero Width Space (U+200B)”.

having found the problem we could easily fix our help files and remove this character from them.

here is the small piece of code to remove the Zero Width Space character from a string.

   1: string pattern = @"\u200B";

   2: Regex regex = new Regex(pattern);

   3: var matches = regex.Matches(content);

   4: Console.WriteLine("Found {0} Matches", matches.Count);

   5: content = regex.Replace(content, "");

Hope this saves you some time in future.

There is plenty of articles out there on how to make a ajax call to a asp.net web api service. but what if you want to make a call to the same service from a server code? this can happen because of various reasons like when you want to offer a service and use IP validation.

anyway this is quite simple to call a service exposed by ASP.net WEB API either using JSON or XML. and it is like calling a WCF or XML web service from a server side code without adding a reference to the service.

Lets assume that our ASP.net WEB API provide a service to and and return flights using a given FlightSearchRequest object.

FlightSearchRequest

 1:     public class FlightSearchRequest

 2:     {

 3:         public string DepartureAirportCode { get; set; }

 4:  

 5:         public string ArrivalAirportCode { get; set; }

 6:     }

WEB API Method

 1:         [HttpPost]

 2:         public IEnumerable<Flight> GetFlights(FlightSearchRequest flightRequest)

 3:         {

 4:  

 5:             return new List<Flight>

 6:                 {

 7:                     new Flight { Id=1, AirlineCode = "EK", Price = 350 }, 

 8:                     new Flight { Id=2, AirlineCode = "LX", Price = 280 },

 9:                 };

 10:         }

and here is the code to call the service:

Using JSON

 1:             HttpWebRequest request;

 2:             HttpWebResponse hwResponse;

 3:             string url = "http://127.0.0.1:26030/api/MyAPI/GetFlights";

 4:             string responseBody = string.Empty;

 5:             string requestBody = 

			"[{\"DepartureAirportCode\":\"MEL\",\"ArrivalAirportCode\":\"LHR\"}]";

 6:            

 7:                 byte[] byteData = UTF8Encoding.UTF8.GetBytes(requestBody.ToString());

 8:                 request = (HttpWebRequest)HttpWebRequest.Create(url);

 9:                 request.ContentType = "application/json;charset=utf-8";

 10:                 request.UserAgent = 

	"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; BOIE9;ENUS)";

 11:                 request.Accept = "*/*";

 12:                 request.Method = "POST";

 13:                 request.ContentLength = byteData.Length;

 14:                 

 15:                 // Write data 

 16:                 using (Stream postStream = request.GetRequestStream())

 17:                 {

 18:                     postStream.Write(byteData, 0, byteData.Length);

 19:                 }

 20:  

 21:                 // Get response 

 22:                 using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)

 23:                 {

 24:                     // Get the response stream 

 25:                     using (var reader = new StreamReader(response.GetResponseStream()))

 26:                     {

 27:                         responseBody = reader.ReadToEnd();

 28:                     }

 29:                 }

to make the same call using XML you just need to change the ContentType to application/xml and also change the request body to an xml format

Using XML

 1:             HttpWebRequest request;

 2:             HttpWebResponse hwResponse;

 3:             string url = "http://127.0.0.1:26030/api/MyAPI/GetFlights";

 4:             string responseBody = string.Empty;

 5:             string requestBody = 

				"<Product><Id>6</Id><Name>Jackson</Name></Product>";         

 6:                 byte[] byteData = UTF8Encoding.UTF8.GetBytes(requestBody.ToString());

 7:                 request = (HttpWebRequest)HttpWebRequest.Create(url);

 8:                 request.ContentType = "application/xml;charset=utf-8";

 9:                 request.UserAgent = 

	"Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0; BOIE9;ENUS)";

 10:                 request.Accept = "*/*";

 11:                 request.Method = "POST";

 12:                 request.ContentLength = byteData.Length;

 13:                 

 14:                 // Write data 

 15:                 using (Stream postStream = request.GetRequestStream())

 16:                 {

 17:                     postStream.Write(byteData, 0, byteData.Length);

 18:                 }

 19:  

 20:                 // Get response 

 21:                 using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)

 22:                 {

 23:                     // Get the response stream 

 24:                     using (var reader = new StreamReader(response.GetResponseStream()))

 25:                     {

 26:                         responseBody = reader.ReadToEnd();

 27:                     }

 28:                 }

now the more I play with WEP API the more I like it

Well as soon as i heard and read about asp.net web api, i was very excited about it but in between i had that mmmmm moment. i was like, this is great but what about WCF? I am not going to create any WCF services anymore?

so I had think again about it but could not find any concrete answer as these two are overlapping in many areas. so I had to do a bit more R&D about the differences and I came across this blog post from Matt Milner.

the post has got very fair point on when to use WCF services and when to use ASP.net web api. but in nutshell I think for most of our feature service development for web –over http-, we are going to use ASP.net web api and it kind of make sense as it’s much easier to setup and use.

here is blog post address:

http://mattmilner.com/Milner/Blog/post/2012/02/28/WebAPI-or-WCF.aspx

I was just reading this blog post about Unit Testing Improvement in Visual Studio 2011 and noticed that there is something new called Fakes Framework.

I didn’t get it first time so I had to read it again and also had to read this MSDN article to get my head around it. I mean I was getting so excited about it that I had to read it twice to make sure I have understood it properly. then I went like wow that’s great. now I can test old SharePoint code without TypeMock.

basically according to MSDN there are two new feature in the Fakes Framework:

Stub

types Stub types make it easy to test code that consumes interfaces or non-sealed classes with overridable methods. A stub of the type T provides a default implementation of each virtual member of T, that is, any non-sealed virtual or abstract method, property, or event. The default behavior can be dynamically customized for each member by attaching a delegate to a corresponding property of the stub. A stub is realized by a distinct type which is generated by the Fakes Framework. As a result, all stubs are strongly typed.

Although stub types can be generated for interfaces and non-sealed classes with overridable methods, they cannot be used for static or non-overridable methods. To address these cases, the Fakes Framework also generates shim types.

Shim

types Shim types allow detouring of hard-coded dependencies on static or non-overridable methods. A shim of type T can provide an alternative implementation for each non-abstract member of T. The Fakes Framework will redirect method calls to members of T to the alternative shim implementation. The shim types rely on runtime code rewriting that is provided by a custom profiler.

according to the blog post mentioned above the Stubs are not like Mocking framework but I am still not sure why I would need a Mocking framework when I can use Stub feature! will spend some more time on this and will update this post.

but the Wow part for me was the Shim. it seems Microsoft Pex and Molls has given the required motivation for the VS team to include the Shim feature. it has always been a very difficult task to test non abstract classes like the ones provided in SharePoint. even using TypeMock or Pex was not an easy task.

but Shim sounds very promising. although the syntax is not still quite easy to use-or at least I have not figured it out in last few hours- but it’s a great start.

here is a small code sample which should throw an Application Exception if it’s first day of year 2000.

   1:  public static class Y2KChecker {

   2:      public static void Check() {

   3:          if (DateTime.Now == new DateTime(2000, 1, 1))

   4:              throw new ApplicationException("y2kbug!");

   5:      }

   6:  }

lets say we want to make sure that the following code will throw an Application Exception if current date is 01/01/2000.  but to test this we need to provide an alternative implementation for DateTime.Now as DateTime.Now will always return current system date and time which would never satisfies the if condition.

as you know we cannot Mock DateTime.Now with mocking framework and here is where Shim comes to picture to provide an alternative return value for DateTime.Now:

   1:  using (ShimsContext.Create()

   2:      // hook delegate to the shim method to redirect DateTime.Now

   3:      // to return January 1st of 2000

   4:      ShimDateTime.NowGet = () => new DateTime(2000, 1, 1);

   5:      Y2KChecker.Check();

   6:  }

now I see the light at the end of all those old SharePoint code which are dying to be unit tested.