Rightpoint Consulting

Login or Logon?

Chris Domino — Wed, 16 May 2012 06:19:00 GMT

As I've been template-izing my ASP.NET MVC work (here and here) and thinking about public-facing websites holistically, I came across an interesting metaphor around users, applications, and the Internet itself. I found a bug in the code I posted (and, yes, it's been fixed) in my Account controller where a view was named "Logon" and its backing Action was named "Login." My initial reaction was of course that I simply had to follow MVC conventions and just match them up.

Since it was faster to rename the Login method in the controller to Logon than it was to rename the view's cshtml file, I went with "Logon." But that looked kinda funny. It sort of makes me think of the name of a species from a science fiction movie."The Logons are invading sector 4G7!" or whatever. So what about Login? I changed both components to this, and liked it a little better.

"Login," for whatever typographical reason, still manifests that a verb and a preposition have been smushed together into a verbosition, which is a part of speech I just invented. So from a glance at a webpage, seeing "Logon" makes me think of aliens while "Login" makes me think of passwords. So, psychologically, I'm going with the latter, both in terms of intuition and grammatical aesthetics.

But I was still curious about this metaphor. Well, it's not really a metaphor per say; it's not like saying that "Authentication is like the facial recognition region of your brain" or "Logging in/on is like falling in love" or anything like that. It's really more of a physical consideration around an ethereal action.

All these ones and zeros are floating around in the air; files, web pages, databases, etc. don't exist as physical entities. Of course, there are servers and circuit boards and chips and transistors. But there's no way to reach out and touch a web page as you would a newspaper. (Or at least not yet...) But like I said, I started thinking about this ethereal stuff more concretely anyway.

So do you log into a site or onto a site? I'm thinking about these verbs physically. When you're using a site, are you physically in side of it? Or physically on top of it? What do each of these mean? I'm going to dig into metaphorical cyber space here, and hopefully find some sort of relevance for us back in the real world.

Like I said, I prefer login to logon (neither of which interestingly offends Word's spell checker). Comparing a web site to a house: you can visit different pages (or rooms) connected by navigation links (doors) which can be locked (security). Or course there are also architectural similarities where sub systems support the rooms or pages that visitors are consuming. The word "plumbing" is used to refer to the minutia of data access layers, business objects, and other non-UI functionality. And we "wire" up event handlers just as an electrician wires up a fuse box.

So when you get invited to a house party, and you ring the bell, are you asked to "come inside" or "come onside" their place? If I showed up to a friend's apartment and was asked to "come onside" I wouldn't really know what to do. You are in the house. It is perfectly valid to be on a house, but that is nonsensical in the context of a social visit. And, living downtown Chicago, I've been on plenty of rooftop decks and patios; although they are indeed situated on top of a building, they are used as room rather than a roof. So while you're technically outside (and onside), you're logically inside; you're still constrained by floors and walls and doors.

It's the same story when you visit a web site. You are inside it. You can't see the rest of the Internet when you're on a particular site. In fact, the web is rather opaque to that extent: you are always using a page, or an FTP folder, or a network drive. There's no ubiquitous "lobby" to the Internet. You're always somewhere. You're not on a site. If you were, it would be like being on a house or apartment building.

When you're standing atop a tall building, you can't really say that you're in it, because you can see what's around it. When you're really INside something, its four walls define the extent of your current universe. It's like being in a tent in the middle of the forest. It's sort of like being in love. But when you're on something, it is elevating you to see beyONd it. It's serving you, giving you a boost, almost obsequiously.

Or think of it in terms of time. If you're "on time" then you've mastered time; you are on top of it as you are "on schedule" or "on task" or "on mark." You are perched on time's shoulders, staying just above it or ahead of it. However, if you are "in time" that generally means that you had to expedite something or in some way put yourself at disease to arrive punctually. You are in time; you are inside of time, it owns you and swallows you up.

A good web site should be immersive, starting with conveying to its users that they are "in" it, and ultimately getting to a point where they don't even realize they are using a site at all; they are simply doing the thing that your site allows them to do. It's like letting your mind wander while you jog and forgetting, for only a few seconds at a time, that you're actually running.

Compare this to being "on" a site: you're just perched up there, deciding if you want to dive in. It's like standing on the bank of a pond with your shoes and socks off. There're no walls and the water's cold. But like I said, there's no cyber-lobby; you're in or you're out. Even search engines are still just sites. Operating systems are really just programs! There's no "white room" like in The Matrix when everything's loading. You are logged into a site or an app or a computer; the only thing you're "on" is probably a chair of some sort.

There's no lobby, no starting point, no origin: just a closed system of circuit boards wired together. Much like cells in an organism, everything's specialized; some of these circuit boards are grouped into database tables and some are really good at being memory processes while others are soldered together to make network cards or threaded into Ethernet cables. These organisms form an ecosystem that is the Internet. It's the universe that all one's and zero's live in. In.

So when we think of being "on" something, the Internet itself is the lobby. Everything is the starting point. I don't want to get into quantum mechanics, but like electrons in the cells above, all websites are everywhere at once, buzzing around with no exact, permanent physical location. IP addresses change, hard drives change, and servers change; web sites live on in one layer of abstraction on top another. On.

The "on" for us being "on line" is our Internet connection. We are "on" the Internet, connected by a "line," whether it's a phone line or a fiber optic line or something in between. Once your NIC does its thing and DNS does its thing, you are online; you are on the Internet. You're connected; you have the potential to visit any resource in the whole world to which you have access, and login to it. The Internet is what you're on whenever you're in a site, but you're never actually on it; only inside of one logical piece of it at a time.

So we're online and logged in. There's really only one more positional metaphor I'd like to play with. We've talked about servers and pages and networks. But there's one more facet of being online that's really only half online and half logged in: Email. You're not on Email. You're not in Email. You're at Email. Of course, you need to be online to receive and send Email, but not to read it, compose it, sort it, delete it, etc.

And of course, you need to login to something to access Email. If you use Gmail, or any other web-based Email client, then it's pretty much the same story as any other website, except the content just happens to be listings of messages. But what about checking Email on your phone? Or via Outlook at work? These are client programs, and use your credentials the same way a login form would on a page to log you in. However, unlike the web, you can still do at least some things if you're offline. In a way, you're offline and logged in!

But the "at" component is what's interesting. Before, I said that you're not "in" your Email. And that might seem to be true at first; a lot of clients (especially in the SharePoint world) tell me that they "live in their Email." And on the surface, that's valid. However, if you dig a bit, you see that they don't live in their Email, they live in their Email client. The molecules of air that support such a life are the Email messages themselves. And these messages would never reach them and oxygenate their inboxes if they didn't know where the person was at.

So in much the same way you live at a street address, you very much so live at an Email address as well. You have a unique name at a unique location. You might live in a house...that's on a street...but at an address. If you standing on top of a sky scrapper, and fired up a mapping application on your phone, it wouldn't be able to discern your location with respect to the building. As far as your GPS is concerned, you're at the building, not in it or on it.

In the Internet universe, you're in some things, on some things, and at some things. For me, the takeaway from these metaphors is the realization that positional pronouns can help us design better systems. If you're a web person, whether you're technical or creative, (or indeed both) image your users being in your work. Is it immersive? Is it intuitive? Do people get excited about using it and feel compelled to share it with their friends? Does it make their lives easier?

If you're a hardware or network person, consider the experience of users being on your infrastructure. Is it fast? Is it really really fast? Is it reliable? Does it protect itself from outages or data loss? Does it scale? Are you doing everything you can to ensure that your corner of the Internet is a safe environment for people to store their work?

And if you're an administrator, be cognizant that users have identities at your location. This goes beyond just Email: network accounts, authentication, authorization, and all of that come into play as well when someone is at somewhere dot com. Is onboarding simple and automated? Are passwords managed well? Are permissions granted - and revoked - properly? Does everyone have everything they need?

Think about this stuff and build beautifully.

A Really Sweet MVC 3 Project Template: Part 2 – The Web Project

Chris Domino — Fri, 04 May 2012 21:11:00 GMT

In Part 1 of this series, I introduced my version of a template for ASP.NET MVC 3 projects that contains the data access layer, a common library, and some other components that I tend to reuse on every site. Before diving into the final slice of the pie, the web project itself, I want to reiterate that this template isn't supposed to be the end-all and be-all of MVC projects; it's the stuff I need 90% of the time; use the cloner (code that'll be included in this post that clones folder structures, replaces guids, and other fun stuff) and strip out what you don't need.

Starting from the Visual Studio solution we created in Part 1, add a new MVC 3 Web Application. Choose the "Empty" template, which only provisions the main MVC folders (models, views, and controllers) and pulls in the latest jQuery, ASP.NET AJAX, and modernizer JavaScript files, and a few other goodies. Next add references to our ClientB.Common and ClientB.Data projects.

I usually end up deleting the "Content" folder and all the theme crap under it in favor adding a "Styles" folder with a single Site.css stylesheet under it. All the jQuery theming stuff is cute and all, but it just feels a bit overkill to me. Besides, these assets aren't really "content;" the content is in the MVC views. But I'll leave it in the template (however, the stylesheet will be moved into the above-menioned "Styles" folder) in case you need it. Included in my CSS are a few pervasive styles that I've found useful on many sites I've done. Here they are:



	html { overflow-y:scroll; } body { margin:0px; height:100%; font-size:10pt; font-family:arial; } textarea { padding:5px; resize:none; outline:none; height:100px; font-family:arial; } textarea:focus, input:focus { outline:none; } a { font-size:10pt; text-decoration:none; } a:focus { outline:none; } a img { border:none; } input[disabled="disabled"], input.disabled { cursor:default; color:graytext; } input[type="text"] { padding:5px; } input[type="submit"] { margin:0px; border:none; padding:0px; color:#0071bc; font-size:10pt; cursor:pointer; background:transparent; } .label { color:#000000; font-size:9pt; } .labelerror { border:none; color:#ff0000; font-size:9pt; }

To round out the folder maintenance, I also create an "Images" folder at the root to store visual assets, as well as add a catch-all JavaScript file named "ClientB.js" to the "Scripts" folder. The next big chunk to tackle is the web.config file. We're going to be adding not only app settings and connection strings, but also configuring the ASP.NET Membership provider, making things easier when working with areas, and a few other miscellaneous updates.

First, the connection strings. Copy in the one for Entity Framework in the Data project's app.config file with a name "Database" and pull out the actual connection string for another entry called "Membership." This second, more conventional one will be used by our authentication provider. Here's what it should look like:



	<connectionStrings> <add name="Membership" connectionString="[dev connection string]" /> <add name="Database connectionString="metadata=res:///Entities.csdl\|res:///Entities.ssdl\|res://*/Entities.msl;provider=System.Data.SqlClient;provider connection string="[dev connection string]"" providerName="System.Data.EntityClient" /> </connectionStrings>

Next we want to use the Visual Studio 2010 feature that allows you to map web.config file modifications to build configurations. Ideally, your "Debug" settings in Configuration Manager match your local / development / staging / test servers, and "Release" mode matches production. If you have different environments or multiple developers, you might want to create additional configurations. This is way better than checking a web.config file into TFS with commented out settings blocks for each team member. Adorn each setting with the following transformation attributes where appropriate in the web.config.release file:



	<?xml version="1.0"?> <configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform"> <appSettings> <add key="URL" xdt:Transform="SetAttributes" xdt:Locator="Match(key)" value="http://clientb.com" /> </appSettings> <connectionStrings> <clear /> <add name="Membership" xdt:Transform="SetAttributes" xdt:Locator="Match(name)" connectionString="[prod connection string]" /> <add name="Database" xdt:Transform="SetAttributes" xdt:Locator="Match(name)" connectionString="metadata=res:///Entities.csdl\|res:///Entities.ssdl\|res://*/Entities.msl;provider=System.Data.SqlClient;provider connection string="[prod connection string]"" providerName="System.Data.EntityClient" /> </connectionStrings> <system.web> <compilation xdt:Transform="RemoveAttributes(debug)" /> </system.web> </configuration>

This way, when you build in release (or whatever) mode, Visual Studio will poop out the appropriately-generated web.config file. Notice that one of the app settings here is the URL to the site. Why, you might ask, would some of these settings be here while others are implemented as constants in ClientB.Utilities? Basically, if a string is dynamic (in terms of environment) it should be an app setting. A good example of this is an Email address from which automated notifications are sent. In development, you might want to use your own; in production, a generic one should be selected. However, something like the name of the site or an Id that's being used for a third party integration (like a credit card merchant account) will be constant across all configurations. I throw these in the "constants" class to avoid hard coding and allow site-wide changes (or clones for new sites) to be executed easily and safely.

Next is a tweak that makes areas able to consume assets in the "root" of the application. I'm not too versed in the details here, but it's one of those "do this and it works" kind of things. Take the following blob from the web.config file under "Views" and move it to the root one:



	<system.web.webPages.razor> <host factoryType="System.Web.Mvc.MvcWebRazorHostFactory, System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" /> <pages pageBaseType="System.Web.Mvc.WebViewPage"> <namespaces> <add namespace="System.Web.Mvc" /> <add namespace="System.Web.Mvc.Ajax" /> <add namespace="System.Web.Mvc.Html" /> <add namespace="System.Web.Routing" /> </namespaces> </pages> </system.web.webPages.razor>

Next, to make EF assemblies available application-wide, add the following under system.web/compilation/assemblies:



	<add assembly="System.Data.Entity, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />

Now let's get into the authentication stuff. First of all, here's the basic goo that's needed to wire up the membership and role providers:



	<membership> <providers> <clear /> <add name="AspNetSqlMembershipProvider" enablePasswordRetrieval="true" type="System.Web.Security.SqlMembershipProvider" connectionStringName="Membership" enablePasswordReset="true" requiresQuestionAndAnswer="true" requiresUniqueEmail="true" passwordFormat="Encrypted" maxInvalidPasswordAttempts="2147483647" minRequiredPasswordLength="7" minRequiredNonalphanumericCharacters="1" passwordAttemptWindow="1" applicationName="/" /> </providers> </membership> <roleManager enabled="true"> <providers> <clear /> <add name="AspNetSqlRoleProvider" connectionStringName="Membership" applicationName="/" type="System.Web.Security.SqlRoleProvider" /> </providers> </roleManager>

That's real basic stuff, but with a bunch of settings defaults I usually go with that are still worth mentioning. In the membership provider, I have it configured to have unique Email and encrypted passwords while allowing them to be retrieved, question and answer turned off, as well as account lockouts disabled. You can't really "disable" this, so they need to get int.MaxValue invalid attempts in one second to get locked out. Finally, I have password strengths that require six characters with at least one being non-alphanumeric.

Finally, in order to facilitate password encryption and decryption, we need to have a valid machine key in the web.config file. These should really be unique for each web app you write, so I use the following generator to get a new one. Here's an example of what an entry (in system.web along with the rest of the authentication configuration) looks like, with the encrypted bits stripped out:



	<machineKey validationKey="[encoded]" decryptionKey="[also encoded]" validation="SHA1" decryption="AES" />

Next we have the Email section. I like to wire this up in the web.config file so that the Email code I have in ClientB.Common will pick up those settings and just work. Much like with the connection strings, these settings might differ from development to production, so use your web.config.whatever files to manage them. Here's what that block looks like:



	<system.net> <mailSettings> <smtp deliveryMethod="Network"> <network host="[SMTP server URL]" userName="[Username or Email address]" password="[password]" /> </smtp> </mailSettings> </system.net>

That's it for configuration! Next up is to discuss is error handling. There are a lot of different ways to implement error handling, as well as a lot of third party tools that can take care of it for you. However, using an external component sort of goes against the grain of a generic template. I'll throw some shameless pugs out for Elmah or Log4net as they are the two I feel are used the most, and then go ahead and do my own.

There are basically three parts to error handling in my eyes: throwing errors, catching errors, and reporting errors. You won't find any examples of the former in this template, because it's more ethereal in the first place and I never encounter errors at all to any extent in the second place. Juuust kidding. Real quick though, throwing errors means deciding which exceptions are handled and which are unhandled. When you're building a particular functionality, ask yourself: "What if this bombs?" "What if there are no elements in this collection?" "What if it's null?"

Basically, if it could be null in some supported (or at least identified) use cases, I protect it with a try...catch. Or if the code is dealing with user input, and I can't anticipate every possible situation: try it and catch it. But if something should not be null, I purposely do not protect it; this exception has to be thrown so I know about it. Catching and eating is way better for your bug count and way worse for your application than throwing into the wind.

On the backend, in ClientB.Common, have some sort of static class through which all errors are routed. When you do purposefully catch an exception, call this method explicitly. What it actually does is up to your implementation. You can throw it in an event log, log file, log database table, or just Email it to yourself if that's the preferred route. It doesn't matter, as long as the "catching" part of the architecture handles them uniformly. But when an unhandled exception occurs, and you don't think the generic ASP.NET error page works well aesthetically in your application, we need to wire up higher-level logging.

And nothing is higher-level than Global.asax. Here of course is where you can handle global events in your application around start up, session, and, as it turns out, Application_Error! This event will be raised when any unhandled exception occurs in the app. Here's my implementation:



	protected void Application_Error(object sender, EventArgs e) { try { //initialization Exception exception = this.Server.GetLastError(); if (exception != null) { //clear this.Response.Clear(); this.Server.ClearError(); //email Utilities.SendErrorEmail(exception.ToString(), "Global Error Handler"); //return this.Response.Redirect(string.Concat("~/Home/Error/?message=", Convert.ToBase64String(Encoding.ASCII.GetBytes(exception.Message)))); } } catch (Exception ex) { //we're really broken Utilities.SendErrorEmail(ex.ToString(), "Global Error Handler Error"); this.Response.Redirect("~/Home/Error"); } }

The only interesting thing here is in Line #15 when I base 64-encode the error message and pass that explicitly to a view via querystring. Although I haven't tried it (because it's hard to experiment with error handling logic when you have never had an error in your entire career) it might be a bit cleaner to use session or some other mechanism. But when you're handling global errors, you have no idea what might be broken; I always try to respect this and write the leanest code possible here.

So that's throwing and catching; what about reporting? The Emailing is included in the template because Email is always available for error logging; using a database or a log file or a third party control requires some "intrusion" into the architecture and/or surface area of the application. Email will more likely than not already "be" there, so for this template, we'll just piggy back that tier.

When we're still in the context of the website when an unhandled exception occurs, we need to add a UI to the error reporting in addition to the logging. This way, users don't have a false positive when something didn't work. Like I said, it's far worse to hide these errors than it is to show them; your users will be a little annoyed because an error occurred in general, but appreciate the fact that you spent a few extra minutes to make the experience as graceful as possible.

The view display is up to you; let's take a look at the controller that renders it:



	public ActionResult Error(string message) { //get message if (string.IsNullOrWhiteSpace(message)) message = "An unknown error has occured."; else { try { //get message message = Encoding.ASCII.GetString(Convert.FromBase64String(message)); } catch { //busted message = "Unable to decode error message."; } } //render view this.ViewBag.Message = message; return this.View(); }

Basically, it takes in the encoded error message, and attempts to decode it before passing everything down to the view for rendering. The only reason I screw around with encoding is because I don't like passing human-readable text in query strings. Not only is it sloppy, and lets users see up the skirt of your implementation, but I feel it could be a real easy to get hacked.

That's it for error logging! I won't go into too much detail for the error page itself; just make sure to slap a link on there so they can get back to the home page. You'll notice that the Visual Studio MVC 3 template includes an "Error" view in the "Shared" folder, and that view has code in it that unhinges itself from its layout. This, like my statement about code in the global error handler, is a protection against not knowing what's broken; it could be something in the layout. So be careful not to cause errors by handling errors!

I'm not putting this into the template, but I wanted to call it out real quick. With some of my little MVC 3 sites that are in production, (incidentally all hosted on GoDaddy) I get a lot of HttpExceptions regarding forgery tokens and other "Internet noise." I'm not sure if it cause by dying spam robots defeated by my MVC security measures, actual errors in my URL mappings, or something else entirely. I've found myself adding logic to my global error handling that swallows these, as they are sort of impossible to reproduce and fix. I hate eating exceptions almost as much as I hate Outlook taking ten minutes to load. Just something to think about...

</ Internet Noise>

Let's move on to the controllers, which are of course the brains behind the MVC pattern. Right click the "Controllers" folder and select "Add..." and then "Controller..." In the box that pops up, type in "Base" over the selected text so that the class name becomes "BaseController" and click "Add." We are going to have all of our other controller inherit from this one, so sort of think of it like the code-behind for a master page.

The two pieces of logic I'm including in this template are there to demonstrate two different paradigms of what you'd want to do with a base controller. The first one, which is basic navigation logic, sets Booleans based on which controller is handling the request so the layout can update itself accordingly (by building out a breadcrumb or selecting tab or highlighting a background). Paradigm-wise, this is example of code that needs to run on each load; master pages (or the equivalent) are a great place to take care of these tasks.

Also using the ViewBag, the second sets the current user, which will ideally be cached to avoid database hits on each load. This is the second paradigm a base controller implements: handling do-once-and-cache tasks across the application. Let's look at the code:



	using System; using ClientB.Data; using System.Web.Mvc; namespace ClientB.Web.Controllers { public class BaseController : Controller { #region Events protected override void OnActionExecuting(ActionExecutingContext filterContext) { //initialization base.OnActionExecuting(filterContext); //get calling controller name string url = filterContext.Controller.ValueProvider.GetValue("controller").RawValue.ToString().ToLowerInvariant(); //TODO: use url to update navigation //this.ViewBag.CurrentUrl = url; //if (url.Equals("home", StringComparison.InvariantCultureIgnoreCase)) //{ //this.ViewBag.Home = true; //this.ViewBag.Account = false; //} //else //{ //this.ViewBag.Home = false; //this.ViewBag.Account = true; //} //TODO: caching of common data elements //open database using (Database database = new Database()) { //set current user this.ViewBag.CurrentUser = database.GetCurrentUser(); } } #endregion } }

Whichever paradigm you're following, use base controllers to do the things that happen upon every request. This differs from ActionFilterAttributes, which instead encapsulate logic that could happen on every instance of a particular request. Whereas every single request cares about the current user (base controller), only certain requests need to make sure the current user is authenticated (action filter attribute). The following are out-of-the-box filters that you'll see all over the place in the source code included with this post:

Like I said, these apply common functionality to particular requests. A cool thing about these filters is that they can be applied to both controllers and action methods. Applying it to a controller is the equivalent to applying it to all action methods on that controller. A good example of functionality like this is an attribute that redirects a request to its HTTPS equivalent. If you have a particular request or controller that handles credit card transactions, decorate it with this attribute. If your entire application requires SSL, put it on your base controller.

From here on in, everything else is optional. I'll be discussing some common patterns or functionality that I include in some, but not all, my applications. The ideas above (and in the previous post) are part of almost all of the MVC work I do. The rest are edge cases, but certainly still "common" enough to be represented in (and potentially ignored or removed from) the template. To start, here's an example of the above attribute, called ForceSSL:



	using System; using System.Web; using System.Web.Mvc; namespace ClientB.Web { public class ForceSSL : ActionFilterAttribute { #region Events public override void OnActionExecuting(ActionExecutingContext filterContext) { //initialization HttpRequestBase request = filterContext.HttpContext.Request; HttpResponseBase response = filterContext.HttpContext.Response; //check if we're secure or not and if we're on the local box if (!request.IsSecureConnection && !request.IsLocal) { //rebuild url to use ssl UriBuilder builder = new UriBuilder(request.Url) { Port = 443, Scheme = Uri.UriSchemeHttps }; //redirect response.Redirect(builder.Uri.ToString()); } //base base.OnActionExecuting(filterContext); } #endregion } }

Not only is this a good example of the flexibility of filter attributes specifically, but it also shows just how much control you have in MVC in general. Take advantage of how close you are to the underlying HTTP request. In web forms, these would have to be HTTP modules or handlers (which are sort of obscured from the rest of your code); in MVC, they are right there with the rest of your business logic.

The next optional controller I'm including is the handling of "robots" for SEO purposes. Instead of dealing with a robots.txt file, (which is very un-MVC) you can rig up a path to a controller that does this dynamically. Here's that controller:



	public ContentResult Robots() { //return return new ContentResult() { ContentType = "text/plain", Content = Convert.ToBoolean(ConfigurationManager.AppSettings["AllowRobots"]) ? "User-agent: \r\nAllow: /" : "User-agent: \r\nDisallow: /" }; }

Few things here:

Line #1: This returns a ContentResult, which we can tell the browser that it's getting the plain text that the little Bing and Google robots re hungry for.
Line #7: I have a value in the web.config that controls this behavior. For the template, it's an "on" or "off" idea so that our code hanging out in production isn't being crawled while the site is still under development. However, you can add to this to enable certain crawlers, etc.
We need to enable this route in Global.asax. In the "RegisterRoute" method, before the last line representing the "default" route, add the following line:



	//robots routes.MapRoute("Robots", "Robots.txt", new { area = string.Empty, controller = "Home", action = "Robots" });

Speaking on ContentResults, there's also the nifty FileResult that your actions can return. I use this particularly to map a URL directly to my site's logo. This is useful in both the layout and in the Email template. First, store the relative path (something like "/images/logo.png") in the web.config. Then, create the following action (all of these "optional" actions are on the "Home" or default controller):



	public FilePathResult Logo() { //render image return this.File(this.Server.MapPath(ConfigurationManager.AppSettings["LogoImageURL"]), MediaTypeNames.Image.Jpeg); }

Line #4 has the "System.Net.Mime" namespace "using-ed" in. With this mechanism, "http://clientb.local/home/logo" will return the main image for the site. Finally, let's talk about the account stuff. After all of that wiring of the membership provider, we need to throw some UI into the app to facilitate all of the account-ish things users will need: registration, login/off, password request/change, etc. The "MVC 3 Internet" Visual Studio template pulls a lot of this stuff in for us, but I like to reorganize it a bit.

First, some sanity. There are UI services that come along with the out-of-the-box Account models, and the code is intermingled with them. I feel like service-typed things and POCO-typed things should not be neighbors. I like to refactor these services (and their interfaces) from Models/AccountModels.cs into separate classes on the root, named Services.cs and IServices.cs respectively.

There are even more refactoring opportunities in this file. The next thing I do is move all of the custom validators into a separate file. So create "Validation.cs" in the root of ClientB.Web and copy-and-paste anything that inherits from ValidationAttribute there. There's nothing specific about this code (or the services above) to the Account controller, so let's make it available to our entire site. I've also added some other validators that I use from time to time.

There's one more thing to do here, refactoring wise. There's a static method forlornly tucked into the "Status Codes" region that translates "proprietary" membership error codes into English strings. I move this guy, called "ErrorCodeToString," to the Utilities.cs class over in ClientB.Common. (Make sure you add a reference to the obscure System.Web.ApplicationServices assembly.) Once again, this logic not specific to the Account stuff, or even necessarily to our site, so its home should be Common.

Now we can get to the actual M in the MVC. What's left over are a few models describing the data that needs to be transferred to facilitate out-of-the-box authentication-ish functionality. Namely, these are the "ChangePasswordModel," "LogOnModel," and the "RegisterModel." I've basically kept these in fact in the template, but added "RetrievePasswordModel" and some other goodies. Here's what that looks like:



	public class RetrievePasswordModel { #region Members [Required] [ValidateEmail(true)] [DataType(DataType.EmailAddress)] [DisplayName("Email address")] public string Email { get; set; } #endregion }

Next we need to build out the controller and views needed to implement these models. Now I'm not going to audaciously re-write Microsoft templates as pass them off as my own; the Account controller and views are fine as they are. I only tore apart the models because that file, in my opinion, is a bit sloppy. So all I'll do is add in the infrastructure to support password retrieval, which follows the same patterns as the rest of the out-of-the-box functionality here.

First, let's pull our nicely-refactored services into Controllers/AccountController.cs:



	#region Members public IMembershipService _membershipService { get; set; } public IFormsAuthenticationService _formsService { get; set; } #endregion #region Protected Methods protected override void Initialize(RequestContext requestContext) { //set forms service if (this._formsService == null) this._formsService = new FormsAuthenticationService(); //set membership service if (this._membershipService == null) this._membershipService = new AccountMembershipService(); //initialization base.Initialize(requestContext); } #endregion

And then our password retrieval controller functionality:



	public ActionResult RetrievePassword() { //render view return this.View(); } [HttpPost] [ValidateAntiForgeryToken] public ActionResult RetrievePassword(RetrievePasswordModel model) { //email user thier password if (this.ModelState.IsValid) { //get password if (this._membershipService.RetrievePassword(model.Email)) { //success return this.RedirectToAction("RetrievePasswordSuccess"); } else { //error this.ModelState.AddModelError(string.Empty, "Unable to retrieve password. Please try again."); } } //render view return this.View(); } public ActionResult RetrievePasswordSuccess() { //render view return this.View(); }

The views are fairly straight forward, so I won't make this epic post any longer than it was to be.

And that is it! Attached to this post are two ZIP files: one for the MVC project itself, and one for the project cloner. To use the later, unpackage it, and run it as a command line exe or load it up in Visual Studio. If you're in VS, edit the project file, and enter the following as the "Command line arguments" in the "Debug" tab:

-s "[full path to root folder to clone]" -t "[full path to route target folder]" -o -g -n "[target namespace]" -i bin -i obj -i pkg -i pkgobj -e vspscc -e vssscc -sourcename "[source namespace]"

This code is actually just a utility used by an in-house TFS generation app, and hasn't really been used extensively outside of that context; manipulate it at your own risk! As for the MVC project, unzip it and set it up in Visual Studio as you would any other. You'll see that there's a lot more in there than I write about because, again, this post is way too long. Like I keep saying, this is just a starting point; strip out what you don't need, apply your own patterns and styles, and, as always, have fun MVC-ing!

A Really Sweet MVC 3 Project Template: Part 1 – The Infrastructure

Chris Domino — Tue, 24 Apr 2012 16:12:00 GMT

After doing a few MVC 3 pet projects, I've found myself starting each new one with a copy-and-paste sprint from the last. In one code session, I can have the SQL Membership provider, error handling, Email, user registration, and Entity Framework design and integration all ready to rock. However, as anyone who can spell "TFS" knows, this copy-and-pasting is of course bad. And I'm not just talking about manually touching up namespaces or hacking connection strings; those are more annoying than harmful.

But if your new application has some other company's logo? Or favicon? Or Email template? Or masthead? Not good. Sometimes a global find and replace is magical; other times, it can create far more (and more difficult) problems than it solves. So what I decided to do is create a generic MVC web application (and the encompassing Visual Studio solution) that has everything so I can clone it and strip out what I don't need when I'm onto the next project.

To avoid yet another blog past that has a massive procedure with dozens and dozens of steps, I'm going to break this up into different sections for each component of the application "template." (I put template in quotes here because it's not really a Visual Studio template; I have code that actually clones a directory and outputs new code to more easily facilitate uniqueness of guids, give control over which file types are analyzed, etc. More information about this "Project Cloner," written by Jonathon Rupp, will be available at the end of this post's series.)

Before going through the steps I've taken to build out each project, let's start with the database. Of course, if you have no database, (nor a need for any other component of this structure) just skip over that particular skip. We're doing the database first to keep the order of operations aligned with project dependencies, so that we never have to "go back" to a project once we're done configuring it.

The Database

First things first: create a new database (named ClientB) by any means you choose. (SQL Server Management Studio is about the only time I use a designer; it's the fastest way for me to rig up my database model.) Then build out the rest of your tables, views, etc. Something I almost always have in my applications (the ones that require administrative/CMS functionality at least) is the typical hierarchical term table to model the site's taxonomy. I'll be including that here so that there's something in the data model:



	CREATE TABLE [dbo].[Term] ( [TermId] UNIQUEIDENTIFIER NOT NULL, [ParentTermId] UNIQUEIDENTIFIER NULL, [Name] NVARCHAR (MAX)NOT NULL, [Description] NVARCHAR (MAX)NULL, [Weight] MONEY CONSTRAINT [DF_Term_Weight] DEFAULT ((1)) NOT NULL, [Ordinal]INT NOT NULL, [IsDeleted] BIT CONSTRAINT [DF_Term_IsDeleted] DEFAULT ((0)) NOT NULL, CONSTRAINT [PK_Term] PRIMARY KEY CLUSTERED ([TermId] ASC), CONSTRAINT [FK_Term_Term] FOREIGN KEY ([ParentTermId]) REFERENCES [dbo].[Term] ([TermId]) ON DELETE NO ACTION ON UPDATE NO ACTION );

Next, since almost ALL of my MVC apps have users and forms authentication, I install the ASP.NET SQL Server schema. Real quick:

Start -> All Programs -> Microsoft Visual Studio 2010 -> Visual Studio Tools -> Visual Studio Command Prompt (2010)
Run "aspnet_regsql"
Click "Next"
Click "Next"
Select a server and a database and click "Next"
Click "Next"
Click "Finish"

There are slightly different versions of this infrastructure depending on which version of ASP.NET and SQL Server are installed; we'll deal with this later.

The Solution

The generic starting point for this project structure is called "ClientB" (which you might have guessed from the database name). Sub in your app name wherever you see that here. When the Architecture Council at Rightpoint came up with our project template for SharePoint work, we really flexed our creative wings and went with "ClientA" for that. Following suite, and as part of the ensuing inside joke, this mess is heretofore going to be un-intuitively pronounced "CientB." So to start off on the code side, create a new blank Visual Studio 2010 solution called ClientB.

The Visual Studio solution is made up of five projects, but you probably only need three. Technically, I guess, you can have just one and shove everything in there, but that's simply not proper. The three main ones are:

ClientB.Web: The MVC project itself, and home to all web assets.
ClientB.Data: A project that houses the EF model, and all supporting partial classes and data access logic.
ClientB.Database: A SQL Server 2008 Database project that contains the SQL script files to facilitate quick and easy schema comparisons among development machines and production servers.

The two more optional ones are:

ClientB.Common: This is the "utility" code that could be accessed by any project. Since I'm sort of a nutjob about refactoring, any line of code that might be called by different projects (namely, in the context of ClientB, Web or Data) should live here. This is also the home to any constants used by your application.
ClientB.Dependencies: This is the perversion of TFS to bring files into the mix with source code. Any external or third party DLLs, MSIs, or other supporting files live here so they can be referenced relatively across development machines. (Note: NuGet is the answer to this problem, but I've had issues with it not upgrading and not downloading the packages I have registered. I probably need to spend a bit more time hammering this into place, but for now, old habits will be hard to break.)

Dependencies

That said, let's start with the most optional one: ClientB.Dependencies. Add a new class library project, and delete the "class1.cs" that comes along with it. To start, just add the following file to the project: C:\Program Files (x86)\Microsoft ASP.NET\ASP.NET MVC 3\Assemblies\System.Web.Mvc.dll. Even though this is a DLL, add it as an "Existing Item," not a reference.

This way, when we reference this (or any other) DLL in a project, we'd do it by browsing to this file, so all relative references come down whenever the latest is gotten form TFS. The goal here is to be able to get, compile, and run in a new developer's first few seconds on the project.

Common

Let's finish up with the optional projects. Add another class library named "ClientB.Common" and once again delete "class1.cs." I usually add two classes to this project: Constants.cs and Utilities.cs. Both are static and public, and, like I said, contain any and all functionality that is to be shared across multiple projects in the solution. If you or your organization has a common library, that could replace or compliment this.

There are going to be a lot of places around the application where the name of the app is displayed: page titles, Email signatures, etc. In order to avoid hardcoding the name of the app everywhere, I like to refactor that into a constant - especially when the name of the app (or even the company!) changes half way through the project. This is especially helpful to support us safely cloning this code from project to project. Here's what the constants class looks like:



	namespace ClientB.Common { public static class Constants { #region Properties public const string ApplicationNamespace = "ClientB"; public const string ApplicationFriendlyName = "Client B"; #endregion } }

Sending Email is a great example of logic that belongs in the Common project's Utilities class. I use two methods: one to send the Email itself, and one that wraps it for sending error Emails (when you're in a hosted environment and don't have access to logs (beyond writing to a text file)). Add a reference to System.Configuration and check out the following code in Utilities:



	public static class Utilities { public static void SendErrorEmail(string message, string location) { //compose StringBuilder sb = new StringBuilder(); sb.AppendFormat("An unhandled exception has been thrown in {0}.", Constants.ApplicationFriendlyName); sb.AppendFormat("{0}Location: {1}", Environment.NewLine, location); sb.AppendFormat("{0}Error: {1}", Environment.NewLine, message); //send Utilities.SendEmail(ConfigurationManager.AppSettings["ErrorEmail"], "Administrator", "Error", sb.ToString()); } public static string SendEmail(string email, string to, string subject, string body) { try { //initialization MailMessage mm = new MailMessage(string.Format("{0}<{1}>", Constants.ApplicationFriendlyName, ConfigurationManager.AppSettings["AdminEmail"]), email); //build body StringBuilder sbBody = new StringBuilder(); body.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.None).ToList().ForEach(x => sbBody.AppendFormat("<p style=\"margin: 10px;\"><span style=\"font-family:Arial; color:#FFFFFF;\">{0}</span></p>", x)); //build template StringBuilder sb = new StringBuilder(); sb.AppendFormat("<body style=\"background:url({0}/home/background) repeat left top #CCCCCC;\">", ConfigurationManager.AppSettings["URL"]); sb.Append("<table>"); sb.Append("<tr>"); sb.Append("<td>"); sb.AppendFormat("<img src=\"{0}/home/logo\" alt=\"{1}\" />", ConfigurationManager.AppSettings["URL"], Constants.ApplicationFriendlyName); sb.Append("</td>"); sb.Append("</tr>"); sb.Append("<tr>"); sb.Append("<td style=\"background-color:#4D4D4D;\">"); sb.AppendFormat("<p style=\"margin: 10px;\"><span style=\"font-family:Arial;color:#FFFFFF;\">Hello {0},</span></p>", to); sb.AppendFormat("<p style=\"margin: 10px;\"><span style=\"font-family:Arial;color:#FFFFFF;\">{0}</span></p>", sbBody.ToString()); sb.Append("<p style=\"margin: 10px;\"><span style=\"font-family:Arial;color:#FFFFFF;\">Thank you!</span></p>"); sb.AppendFormat("<p style=\"margin: 10px;\"><a href=\"{0}\" style=\"color:#0071BC; font-family:Arial; text-decoration:none;\" title=\"{1}\">{1}</a></p>", ConfigurationManager.AppSettings["URL"], Constants.ApplicationFriendlyName); sb.Append(">"); sb.Append("</tr>"); sb.Append("</table>"); sb.Append("</body>"); //configure email mm.IsBodyHtml = true; mm.Body = sb.ToString(); mm.Subject = string.Format("{0} - {1}", Constants.ApplicationFriendlyName, subject); //send mail new SmtpClient().Send(mm); //success return string.Empty; } catch (Exception ex) { //error return ex.ToString(); } } }

That's actually as far as I'm going with this one; refactoring is specific to each project as well as each developer's tastes. The above Email methods might be a bit too specific for our purposes here, but the code I use to generate paragraph tags seems to look consistent across most Email clients, so I thought it might be useful to just include it. But remember: if you don't want it in your template, just delete it. The goal here isn't to create a rigid one-stop-shop for all web projects you'd ever do. Instead it's just a starting point; it's stuff I've had to replicate on almost all MVC work I've done.

Database

SQL Server projects were a game changer for me. Synchronizing database schemas across my laptop, desktop, other team member's machines, as well development, staging, and production servers, was always a nightmare. What was the latest version? What state is my database in? Why doesn't my application work? These are all questions easily answered by bringing your database under source control, and throwing a nice schema comparison tool into the mix for good measure. If you have any database dependencies on your project, never leave home without one of these.

First, create a SQL Server 2008 Database project, named ClientB.Database. If you have the SQL Server tools package installed from the Web Platform Installer, there's a better version of the Schema Compare tool; you'll need to upgrade your project to take advantage of it. In this case, right click your project and select "Convert to SQL Server Database project." Then *poof* you're there.

Next let's import our current schema. Right click again, and select "Schema Compare." In the first dropdown, select "Select Source..." and configure a connection to the database. Then specify "Select Target..." in the second and configure it to talk to the project we just created. When you've got that, click "Compare" at the top.

Here's where I'd like to revisit the ASP.NET SQL Server schema discrepancies that can crop up. Not only will your development machine (no doubt running the latest version of everything; possibly the betas of the next versions of everything) probably have a different version of aspnet_regsql than your production environment; (no doubt running an older version of things, which, for example, Go Daddy does) there will also be security concerns between your database project in Visual Studio and the database itself. Namely, I'm talking about importing users, roles, and schemas. In a SQL Server Data project, think of all SQL files as "executable" scripts. If you have bad TSQL in one of them, things won't compile.

So to combat this, I simply ignore slight differences between the schemas of tables and views and the code of stored procedures and database functions, and don't even bother with any SQL objects that could be related to users. Upon every comparison, clear the "Action" checkbox next to any "Type" under the "Add" node that starts with "Role," "Schema," or "User." We don't need it, and like I said above, we don't want to deal with trying to synchronize it across our different databases.

Really the only parts of the SQL Membership infrastructure that I use are the authentication and authorization subsystems, which is only a slice of the technology. If you're doing profiles and whatnot, there's more to consider; the basic functionality, however, works all the same across the various versions. So, despite all this hacking on the backend, no .NET code will change in the middle layer.

Schema Comparison and reconciliation is about all I use this project for, although it can do a lot more. Really the only other functionality I need here is a place to store any random data-population scripts I might find useful. I usually have something that truncates my tables so I can test new code against a clean slate; it's so specific to the model, however, that there's no use for it in this template.

The concept of the anonymous user, however, is fairly pervasive in public-facing web sites. I like to go ahead and create an actual record in the database for the anonymous user with an empty guid for its UserId. This way, instead of nullable foreign keys, every entity in my model that has a relationship with a user can have a nice tidy link to one.

While we're at it with scripting users, let's add in an administrator. If our application has users and administrative functionality, chances are we're going to need some concept of administrators. I implement this by using the SQL Membership's cousin: the Role Provider, which is a simple implementation of groups in the database.

So let's take a look at the following script (or a slight derivation of it, depending on requirements) to make sure these users exist:



	--initialization DECLARE @appID UNIQUEIDENTIFIER DECLARE @roleID UNIQUEIDENTIFIER DECLARE @adminID UNIQUEIDENTIFIER DECLARE @emptyGuid UNIQUEIDENTIFIER = '00000000-0000-0000-0000-000000000000' --ensure application SELECT @appID = Applicationid FROM aspnet_Applications IF @appId IS NULL BEGIN SET @appID = NEWID() INSERT INTO aspnet_Applications VALUES ('/', '/', @appid, null) END --ensure anonymous user IF NOT EXISTS (SELECT * FROM aspnet_Users WHERE UserId=@emptyGuid) BEGIN INSERT INTO aspnet_Users VALUES (@appID, @emptyGuid, 'Anonymous', 'anonymous', NULL, 1, '2012-01-12 21:10:12.000', 0) INSERT INTO aspnet_Membership VALUES (@appID, @emptyGuid, 'cWIho8hr4yIZqXeXETZfjOJbIUkP2MDpRS8wADoIdtRVRY0WYPFCj+pPfF05/ga0', 2, 'O1JsY+aBppJzFQGmojKP+A==', NULL, 'anonymous@clientb.com', 'anonymous@clientb.com', NULL, NULL, 1, 0, '2012-01-12 21:10:12.000', '2012-01-12 21:10:12.000', '2012-01-12 21:10:12.000', '1754-01-01 00:00:00.000', 0, '1754-01-01 00:00:00.000', 0, '1754-01-01 00:00:00.000', NULL) END --ensure admin user SELECT @adminID = UserId FROMaspnet_Users WHERE UserName='Admin' IF @adminID IS NULL BEGIN SET @adminID = NEWID() INSERT INTO aspnet_Users VALUES (@appID, @adminID, 'Admin', 'admin', NULL, 1, '2012-01-12 21:10:12.000', 0) INSERT INTO aspnet_Membership VALUES (@appID, @adminID, 'cWIho8hr4yIZqXeXETZfjOJbIUkP2MDpRS8wADoIdtRVRY0WYPFCj+pPfF05/ga0', 2, 'O1JsY+aBppJzFQGmojKP+A==', NULL, 'admin@clientb.com', 'admin@clientb.com', NULL, NULL, 1, 0, '2012-01-12 21:10:12.000', '2012-01-12 21:10:12.000', '2012-01-12 21:10:12.000', '1754-01-01 00:00:00.000', 0, '1754-01-01 00:00:00.000', 0, '1754-01-01 00:00:00.000', NULL) END --ensure role SELECT @roleID = RoleID FROMaspnet_Roles WHERE RoleName='Admin' IF @roleID IS NULL BEGIN SET @roleID = NEWID() INSERT INTO aspnet_Roles VALUES(@appID, @roleID, 'Admin', 'admin', NULL) END --ensure user in role IF NOT EXISTS (SELECT * FROM aspnet_UsersInRoles WHERE RoleId=@roleID AND UserId=@adminID) BEGIN INSERT INTO aspnet_UsersInRoles VALUES (@adminID, @roleID) END

Now that we have our users scripted, go ahead and execute this against the database to get those guys in there. Finally, we'll add it to our database project for safe keeping. Right click the "Scripts" folder and select "Add..." and then "Script..." In the window that pops up, make sure to select the "Script (Not in build)" template. This allows us to store arbitrary SQL code in TFS that the project doesn't attempt to "compile" upon each build. Name it "Users.sql" and we're done.

<NOTE>

You might be wondering why, after pulling all this wonderful new SQL integration technology into our project, we're still manually running scripts in SQL Management Studio and using it only for source control. It really comes down to the fact that deploying the project (which you can (and I do) turn off in Configuration Manager for one or all the build configurations) is slooooow.

Even on my home computer, which is an i7 with a million gigs of RAM, it adds a few seconds of churn to every F5 without any updates actually being made. Even though I love love love scripted deployments of any kind, the overhead required to configure this single run-once script simply isn't worth it. Script deployments to save yourself time, not create more work.

</NOTE>

Data

Next is the data layer, for which I turn to the Entity Framework to implement every time. If you want to use Linq-To-Sql or CSLA, (juuust kidding) feel free. But EF, especially the 4.0 release, has been real solid for me. So add another class library project, delete class1, and add a reference to System.Web. Once that's all set up, we can import our data model.

Add a new item to the project of type "ADO.NET Entity Data Model" named "Entities.dbmx" and complete the ensuing wizard to select your database connection (which will of course be to the database we created at the start of this process). Something I always screw up in this wizard is which setting dictates the name of the class that will represent my context. This is the screen were you specify the name of the connection string. I go with "Database" but you can use whatever you want. I feel this is a little cleaner than "[name of solution]Entities" (which is what is generated by default).

At the end of the wizard, you specify which tables, views, and procs you want imported into the model. On this screen, expand the "Tables" node and tick off "aspnet_Users," "aspnet_Membership," "aspnet_Applications," and "Terms." In most cases, you'd probably only need the users table, but depending in your style of usage for membership, it might be nice to take all three. The terms table, again, is just for example purposes.

EF actually does a fairly good job of coming up with singularized and pluralized names for your entities and collections of them. However, the membership tables all have that "aspnet_" prefix and are pluralized; the OCD in me cannot stand for this. If grammatical correctness, properly naming your entities, and destroying all superfluous navigation properties is a must for you as well, perform the following clean up:

aspnet_Applications

Rename entity to "Application"
In the F4 properties pane, set the "Entity Set Name" to "Applications"
Delete all navigation properties

aspnet_Users

Rename entity to "User"
In the F4 properties pane, set the "Entity Set Name" to "Users"
Delete the "aspnet_Applications" navigation property
Rename the "aspnet_Membership" navigation property to "Membership"

aspnet_Membership

Rename entity to "Membership"
Delete all navigation properties

Term

Rename the "Term1" navigation property to "ChildTerms"
Rename the "Term2" navigation property to "ParentTerm"

The above exercise, renaming the "Term" table's navigation properties, is the main reason I included the table at all in this structure. I wanted to demonstrate that even when EF gets the name wrong, it's really easy to correct it. Maybe your brain is fine with "Term1" and "Term2" and can deal with it; mine can't. Once you have all your entities the way you want them, the next step is to start extending them.

The partial class-ed-ness of EF entities (and the context itself) is, in my opinion, one of its strongest extensibilities, and makes tasks like databinding, just, well, stupid easy. I will demonstrate this by extending the context to return the current user, and one of the entities to add a read-only property for databinding purposes.

So first, let's get the current user. Add a class called "Database" or whatever you named your entity model to the project. Here's what it'll look like:



	using System; using System.Web; using System.Linq; namespace ClientB.Data { public partial class Database { #region Public Methods public User GetCurrentUser() { //see if this request is anonymous if (HttpContext.Current.Request.IsAuthenticated) { //get current user return this.Users.Include("Membership").Single(u => u.UserName.Equals(HttpContext.Current.User.Identity.Name, StringComparison.InvariantCultureIgnoreCase)); } else { //get anonymous user return this.Users.Include("Membership").Single(u => u.UserId.Equals(Guid.Empty)); } } #endregion } }

Extending entities is just as easy. Let's say we want to display a user's Email. In the SQL Membership infrastructure, Email is actually on the aspnet_Membership table, so we'd have to join and pull it in. But if we partial class our User entity, we can add a new ready-only property, abstract that join out, and have it display nicely (in a grid, for example) along with the rest of the "native" user properties. To see this, add another class to our Data project named "User.cs" and use the following code:



	namespace ClientB.Data { public partial class User { #region Properties public string Email { get { //ensure relationship is loaded if (this.Membership == null) this.MembershipReference.Load(); //return email return this.Membership.Email; } } #endregion } }

As long as you manage the disposal of your context properly, you can add a bit of logic to extended properties and make your UI databinding logic a lot easier.

Web

So this post turned out to be massive; I'm going to present the Web project in a separate one, since it's far and away the biggest. Doing so sort of creates a nice separation between the idea of an MVC solution, which is all of the physical tiers of a web application and an MVC site, which is just the web components. Perhaps you have a completely different approach to setting up your MVC infrastructure, and just are interested in the web bits. If that's the case, I apologize for however long you spent reading this, as your question your question won't be answered until the next post. My bad!

Read on here.

SharePoint Designer 2010 Workflow Advanced Properties

Kim Frehe — Tue, 17 Apr 2012 21:21:00 GMT

I’ve recently spent a lot of time on SharePoint 2010 workflows. I made a ton of errors and learned a lot about the new Task Process in 2010. It may look easy, but there are a lot of things that can go wrong.

I’m currently working on putting together a SharePoint Saturday session on the Task Process. I will be writing a few “Lessons Learned” articles to help me organize my thoughts to prepare for this session (not yet determined when or where). I will cover the following topics in more details in upcoming articles: Association and Initiation Forms, Change the behavior of a single task, Change the behavior of the overall task process, Change the completion conditions for this task process, the difference between assigning tasks and starting a task process.

This article is specifically about the Task Process “Advanced Properties”.

It is not immediately noticeable that a task process has advanced properties. If you click on the name of the task, you are taken to a Task Settings page that allows you to change certain settings. However, there are certain settings that you may not know to set since you do not see it anywhere except for in the task’s Advanced Properties. I will notate these as I go through each one below. Many of the issues I encountered were because these settings had changed or disappeared through the course of my iterations of the workflows.

These settings apply to the three Task Processes that can be added from “Action, Task Actions” and include the word “Process” – Start Approval Process, Start Custom Task Process, Start Feedback Process.

I highly recommend completely setting up your task process and reviewing these settings at the end. Many of these options will be blank when you first set up your task process and will be automatically populated in the course of customizing your workflow.

To view the advanced properties, click on the task process row and click on the drop down button that appears on the right. Then Select Properties, which will show you some settings and variables that are specific to that task process.

Here is a list of all the Properties available. These are the same for all three task processes.

Note: you will see that some items are “Variables” and some items are “Parameters”

o Variables are hidden from end users, but the workflow needs to function

o Parameters may be included on a form or setting for user input

General Property Variables:

1. Content Type ID – this is a read only field, you cannot set the Task Content Type here. If you need to assign a custom content type to a task process, click here for instructions: Assign a Custom Content Type to Task Process in a SharePoint Designer 2010 workflow

2. Allow Change Request –will prevent or allow the assigned user to request a change to the page or document being reviewed.

o This option can be changed from the Task General Settings page (see print screen below)

o This option will generate a button on the form and a corresponding outcome

o Selecting this option will mark the current task as complete, assign a new task to the person a change is requested from. Once that task is marked as complete, a new task will be created to the person that requested the change to review the change and complete the task process.

3. Allow Reassign – will allow the assigned user to reassign a new task to someone else. This will mark the current task as complete with an outcome of delegated to: new person.

o This option can be changed from the Task General Settings page (see print screen below)

o This option will generate a button on the form and a corresponding outcome

o Selecting this option will mark the current task as complete and assign a new task you want to reassign the task to.

4. Delete Tasks on Complete – Setting this to “Yes” will delete the task once it has been completed or canceled.

o You may want to consider this if you will be generating a large number of tasks with workflows.

o If you are collecting data in the workflow task that you need to retain and you need to delete your tasks, you should include steps in your workflow to place that data somewhere else; in your page or document the process is acting on, for example.

5. Expand Groups – This setting only applies if you are assigning tasks to SharePoint User Groups.

o Yes means that each person in the group will get an individual task assigned

o No means that one task will be created and a member of the group will have the option of claiming the task, which will reassign the task from the group to the individual.

o This default can be set with the Initiation Form Parameters

o You can also leave this option on your workflow initiation form and allow the workflow initiator to select the appropriate option.

6. Permission Set – This is asking if you want to use the permissions of the task list (default) or set permissions for these tasks so that only people that are assigned to a task, workflow initiators and admins can see tasks.

o This is set to “Default” by default.

o This can be set on the Task Settings page. If you check the box to “Only allow task recipients and process owners to read and edit workflow tasks SharePoint will set this variable to “AssignedTo”

7. Task Deleted Outcome – This is asking what the task outcome should be logged as if someone deleted a task. By default this is blank. You can enter “Deleted” or “Cancelled” or something that will let someone reviewing the workflow history know what happened to the task.

8. Task Process Owner – Lists who owns this task process. If you change the permissions of the task “PermissionSet” then this user or group will have access to all the tasks as the owner.

o This can be an individual or a SharePoint group.

o You can set this in the Task Information section of the task general settings page.

9. Send Default Task Notifications – pay attention to this one. If you are sending a custom task notification to a user as part of the process, mark this as “No”. Otherwise it will change the default setting of your task list no notify users when a task is assigned.

o Personally, I prefer to customize the task notification message, so I mark this as “no”

o If this is set to “Yes” it will send the automated message below from the Task List this task resides in (the variables in <> below will be populated by the task or item)

Parameters for “[Task Process]”

10. Task Process Name – This is the name of the Task Process, which may be included in notifications, depending on how yours are set up. You can also change this setting in the Task General Settings Page under Task Information.

11. Overdue Repeat – Set this parameter if you want to send a notification to a user when the task is overdue. Your options are Off, Daily, Weekly or Monthly.

o You have the option of customizing the email that is sent in the Task Process. That will be covered in another post.

o The default setting is weekly.

12. Overdue Repeat Times – How many reminders do you want to send to the person or group a task is assigned to? You can enter a set number, or enter -1 for infinity. This means SharePoint will keep sending a reminder on the schedule that you listed in the previous parameter until the task is marked as complete, the task process is cancelled or the task is deleted.

o The default setting is infinity

Parameters for “[this item]”

13. Item ID – Do not change this option. It is defaulted to the Item ID that the workflow is running on.

Parameters for “[these users]”

These variables can also be set in the workflow task using the “Set Workflow Variable” action or when you click on the link to start the task process with “these users”

14. CC: - This variable is asking if an individual or group should be copied on emails regarding this task process.

o Unless you are setting your workflow so that every workflow copies a certain person or group, I would leave this as “Parameter: CC”.

§ You can include this parameter on the initiation form for a person starting the workflow to complete or you can set with workflow actions if the workflow will be started automatically.

15. Comments – Important: if “Parameter: Comments” is not listed here, then if your workflow can be manually started and you allow a workflow initiator to enter comments when manually starting the workflow, they will be lost. They will not be included in the emails or on the “Task Process Consolidated Comments”

o The alternative is to enter static text here or to enter static text when you are adding a workflow to the list, library or content type

16. Subject – Default subject of task notifications.

o I personally do not complete this one because I make each task notification subject different depending on how complex the workflow is.

§ For example, a reassigned or change request task gets a different subject that an original task. Or a task assigned to a group will have a different subject than a task assigned to an individual.

17. Duration – the number of days, weeks or months that a person has to complete a task

o You can set this parameter here, in the overall workflow process itself, or when adding the workflow to the list, library or content type.

o Make sure this is as least set as “Parameter: Duration” in the advanced.

18. Duration Unit – days weeks or months

o You can set this parameter here, in the overall workflow process itself, or when adding the workflow to the list, library or content type.

o Make sure this is as least set as “Parameter: Duration Unit” in the advanced settings.

19. Due Date – If you’d rather set an overall due date for the entire task process you can set it here.

o You can set this parameter here, in the overall workflow process itself, or when adding the workflow to the list, library or content type.

o Make sure this is as least set as “Parameter: Due Date” in the advanced settings.

An example of the screen when you are assigning a workflow to a list, library or content type is below.

· Note the parameters that you can set here or in the Task Process’s advanced settings.

· You can make these fields available to a workflow initiator or hide them.

Connect multiple sub-sites in Data View Web Part 2010

Kim Frehe — Thu, 12 Apr 2012 19:40:00 GMT

In SharePoint 2007, the Data View Web part (DVWP) was all the rage. You could create complex views from multiple sites within your site collection or other data sources and group, sort and format the data in a visually appealing and meaningful way.

SharePoint Designer 2007 made it easy for you to connect multiple lists on sub-sites with a handy little “Connect to another library…” link at the bottom of the data sources task pane. With all the improvements Microsoft has made with the Content Query Web Part, I was excited to use the DVWP as a sort of expanded version of information that I show in a CQWP. However, SharePoint Designer 2010 has gotten rid of the task pane and the handy little link that allows you to quickly connect data sources to display in the DVWP. Out of the box you can see you site’s document libraries and lists in the data sources.

So the question is, how do you combine data from multiple sub-sites to display in a consolidated list? For this example, I have 8 departments and each department has a sub-site. Each of these sub-sites has a “Goals” list that uses a global content type in a custom task list. I want to consolidate each department’s goals on the parent site to display a view the company-wide goals.

Inbar Cizar (@Cizi) does an excellent job of explaining how to add a sub-site’s list to your list of data sources in this post: http://blogs.microsoft.co.il/blogs/cizi/archive/2010/08/01/connect-to-another-library-in-sharepoint-designer-2010.aspx

Once you have added each of your department’s goals as a data source, you will need to create a “Linked Data Sources” and use this Linked Data Source in your Data View Web Part

Then open an existing or create a new page (I used an .aspx page)

On the ribbon, click on the down arrow on the Data View button and select your Linked Data Source.

From there you can add your columns, group, sort and modify the DVWP as needed.

NOTE:

Name your SOAP datasources carefully; you can use the name of the connection to group or sort a DVWP by the name of the sub-site, or whatever you call it. After the datasources have been connected as a Linked Source, any name changes are not reflected, so you will need to create a new Linked Source to reflect a name change.

Here are instructions to group the DVWP by the site name, which is what I named the SOAP Service datasource.

1. Call your “SOAP Services” data source the name of your sub-site.

2. Click on sort and Group

3. Select “Add Sort Expression…”

4. Select “agg:source”

SharePoint Designer 2010 Workflows – an alternate deployment option

Kim Frehe — Thu, 12 Apr 2012 18:55:00 GMT

I love SharePoint Designer and all the cool things you can do with it as a no-code solutions expert. I love the concept of being able to save a globally reusable workflow as a Site Template and deploying it to other site collections via Visual Studio or Sandbox Solutions. Unfortunately, we ran into some major issues when trying to deploy a .wsp file from a local machine to our development server to the client’s stage server and finally to production.

I worked with a supremely talented developer, Chris Domino, to try and deploy workflows through Visual Studio. Unfortunately, for a variety of reasons, we couldn’t get it to work. You can read his take on our deployment adventure in his 3-part blog here: Importing SharePoint Designer Workflows into Visual Studio - Part 1, Part 2 & Part 3.

After spending way too much time on that process, we decided we were going to use the process that Microsoft gave us; Save as a Template, upload into User Solutions, Activate and then turn on the feature. In theory, this sounds great. Unfortunately, we ran into a bunch of issues with this process too…including variables getting messed up, empty folders being created, changes not updating, buttons not working, InfoPath form customizations getting lost, etc. We would resolve one issue and the next time, a totally new one would pop up. The worst thing of all was that when we deactivated the feature and removed the solution, our out-of-the-box task fields that the workflow used were removed too!

As a last resort, I decided to try the same thing that I did when I needed to get a workflow in SharePoint 2007 from one site to another: Copy and Paste. Yup, that’s right, I just copied and pasted a workflow from one site to another, did a quick “Find and replace” of GUID’s for list ID’s and I was able to use the same workflow on multiple sites, my own 2007 version of a reusable workflow.

I thought it was my own little secret way until I just searched for and found this post by Paul Galvin that gives great step-by-step instructions for moving 2007 workflows: https://www.nothingbutsharepoint.com/sites/eusp/Pages/why-can_e2_80_99t-i-easily-port-sharepoint-designer-workflow-solutions-from-one-list-to-another-part-2.aspx). The only thing missing is that you will need to do a Find and Replace of the GUID’s once you have the workflow in its new home. I have only used this method for copying workflows from one site to another in the same site collection in the same environment. I do not know if it will work from environment to environment.

Here are the updated instructions for SharePoint 2010.

Some notes about these instructions:

Workflows were created as Reusable workflows and were not associated with any lists or content types.
I created these workflows on a subsite so they could be tested, then copied it up to the parent site where I could then globally publish them on our development environment and then followed the same process on our production environment.
Our site columns and content types were created through Visual Studio so that all of our environments have the same GUID’s. If you are not able to have a developer do this, then you may need to do a few extra steps listed at the end to re-align everything.
These workflows do not include any lookups to other site lists, but they do include global site columns.

Here is the process that worked best for us. These steps assume that you have completed your workflow, it is fully tested and you are ready to move it to its new home.

First we need to make sure that the workflow’s new home has a “Workflow” folder for it to be moved to.

1. In the site where you will be moving your workflow, go to All Files (see print screen below if you get a blank screen) and confirm that there is a “Workflows” folder.

2. If there is not, create a new reusable workflow. Don’t worry about adding in steps or publishing it…we are just doing this to create the folder.

The following steps happen on the site where the workflow that you want to move currently exists.

1. Click on “All Files”

2. Click on the “Workflows” folder

3. Click on the name of the workflow that you want to move, right click and select “Copy” (or select and click Ctrl +C)

4. Go to the workflow’s new home, “Workflows” folder

5. Paste your folder in the “Workflows” folder by either clicking “Ctrl+V” or right click and select “Paste”

6. Now click on Workflows link in the left navigation and open your workflow.

7. If your form has any out of the box Association or Task InfoPath forms, delete them and let the new site re-generate them for you.

a. NOTE: If you customized the Initiation and/or Task InfoPath form, click on them to open InfoPath and publish them. SharePoint will do some back-end magic that will associate your form with this workflow on this site.

NOTE: Your Task form may have a different name with “Copy” if you are using the out of the box task form. If you need to associate a custom content type task form to your workflow, check out this article: Assign a Custom Content Type to Task Process in a SharePoint Designer 2010 workflow

8. Click through all the steps in your workflow or click on Check for errors to confirm that everything is aligned correctly.

o This is where you may need to delete remove associated fields and re-add them. Or delete fields that you are populating and re-add them in the new environment.

§ Since all of our fields and content types were created with code and the GUID’s matched, I don’t have any examples to show.

9. If you need to make your site globally available, paste your workflow in the “Workflows” folder on the parent site and you can click on “Publish Globally” from here.

Notes about globally publishing a workflow:

· I don’t recommend copying and pasting directly into the global workflows folder. In theory I think it would work, but I don’t know enough about what SharePoint magic happens to make a workflow globally available, and I’d rather be safe than sorry.

· If you have a globally published workflow that you need to add to a content type, don’t add it during business hours or during times where users may actively be editing that content type…they may lose their information as your changes override theirs.

o The same goes for re-publishing changes to the global workflow.

· If you have custom InfoPath forms, the process of globally publishing it will generate a new out of the box form. To replace this, copy the forms from your “All Files ->Workflows” folder and paste into the Global Workflows folder: "All Files ->_catalogs ->wfpub”

Thoughts On Virtualization For SharePoint 2010 Development

Chris Domino — Fri, 06 Apr 2012 19:53:00 GMT

Being a SharePoint developer, I've always run Windows Server natively. From the timeframes of 2003, 2003 R2, 2008, and 2008 R2, I've gotten very used to having gray task bars, typing "sldkjf" into the Shut Down Tracker, and spending lots of time getting wireless and sound to work. There are a lot of resources out there that discuss how to turn Windows Server into a client operating system, going beyond configuring Aero and hacking the Zune setup to install in an unsupported environment.

What I was more interested in was the development experience. Despite the fact that SharePoint 2010 installs, to a limited extent, on Windows 7, I still think that the best development experience is to run server native, and have the full platform and API available to Visual Studio. At the end of the day, you still have Visual Studio and SharePoint installed on the same machine, so why not work with the full features of each?

The alternative of course is virtualization. VMs are great, since you can quickly tear down and tear up server environments pre-packaged with SQL Server, Visual Studio, and all of the SharePoint configuration you require. An interesting corollary to this is that you therefore don't need to reinstall or reinstate Office, other apps, personal files, preferences, etc. every time you hose your box; Email, music, etc. all rock out on your host machine, leaving your VM a lean server environment that could exactly match production.

But there are a few downsides; in my opinion, they sort of outweigh the many upsides. The main one is performance. I love multitasking, and when I'm building out SharePoint sites, there are a lot times when I'm waiting thirty seconds to possibly thirty minutes for IIS to reset, PowerShell scripts to run, sites to spin up and warm up, etc. Those are perfect opportunities to pop into a different instance of Visual Studio and kill a bug or implement a quick feature.

I've found that having a full SharePoint farm running as a web garden on a single physical machine combined with multiple Visual Studios running combined with Outlook, OneNote, Zune, and everything else, things get SLOW. Now virtualize the processor. Now virtualize the hard drive, memory, NIC, etc. Now throw in the overhead of virtualization itself. Yikes. Or, more appropriately: Yawn!

Now if you're on three concurrent SharePoint projects (bless your soul) and need to be able to support three separate farms, the choice to use VMs is sort of made for you. But when it comes to the standard day-to-day doings of a developer, the performance hit is really felt hard. But performance, in terms of hardware (physical or virtual) throughout, is only part of the picture. The other knock I have against living in a virtual world isn't exactly "performance," per say, but "code speed."

I can fly through web development in Visual Studio when I have two monitors, a few extra CPU cores laying around, and a local database. It's not that you can't achieve this with virtualization technology, particularly around multiple monitors; the two technologies I've used, VirtualBox and Hyper-V, can basically get there. (VirtualBox fakes this by having two separate windows that can talk to each other. With Hyper-V running locally, I can remote into the machine with RDP's "Use all my monitors for the remote session" option enabled.)

But it's not the same!

Both setups are "tweaky." Whenever I'm remoted into a server, it never exactly quite feels seamless. There are ever so slight delays in mouse clicks and keystrokes. Or the connection would drop and reset itself. Or the screen would hiccup while repainting and I'd end up opening something twice. Or I'd accidentally control + alt + delete or alt + tab my way into a confusing state.

When using a local VM, my internet connections get screwy. I need to adjust them whenever I'm in a new office or connected to a new wireless or wired network. (And it's quite annoying to have my tray network icon constantly displaying the yellow-warning-exclamation-marked-triangle overlay.) You also lose the file copy-and-paste you get with RDP. Beyond that, there are paradigm shifts for things like hibernation and screen locking that just make my development experience a bit clunkier.

In both scenarios, there are setups I've configured that basically keep me as technically productive as a native development environment, in terms of how long it would take me to complete a given task. However, I don't fly. My code speed is noticeably lessened, and beyond not physically being able to type and compile the same about of code, it's a distraction that steals away some of the cycles from my own CPU (my brain).

This might sound minuet and over-cerebral, but attitude plays a huge role in my work. Technology should be making us more productive, not less; that's the whole reason my career exists. When I boot up and click the Visual Studio icon in my task bar, and don't immediately see the splash screen, I become frustrated, click it again, and end up waiting even longer while both instances of the application launch only to have to close one - which still takes over a minute while my virtual or remote machine warms up elsewhere.

By then it's 9:20, I'm already off my game, and haven't even started working yet.

But I think I've reached a happy place that combines the pros of all of the above environments (native SharePoint / Visual Studio, virtualization, RDP, and having a host client operating system) while mitigating the cons as much as possible. That happy place is Windows 8. (Note: this was written while running Windows 8 Consumer Preview; things might change when the platform RTMs.)

Having been a Windows Phone 7 user since the day it launched, Windows 8 wasn't as big a shift for me as it will be for PC folks not familiar with Metro. But I don't want to write about Windows 8 overall; this is instead focusing on the introduction of Hyper-V to the client, which is a wonderful enhancement. VirtualBox, until now, edged Hyper-V out with client OS support. What I want to discuss here is my exploration into virtualization on the Microsoft stack from the perspective of a SharePoint developer.

The first task was getting my host environment installed. I had been running Windows Server 2008 R2 natively for quite a while. Then my hard drive crashed...literally...into the ground...as my laptop fell from my hand while walking to a meeting. I decided that this would be a great opportunity to kick around not only the beta of the new client OS, but also a new SharePoint development paradigm. After getting a new hard drive for my Lenovo T510, I installed Windows 8 from a USB drive on a new partition.

Once it was installed, after spending a few minutes figuring out how to get into Control Panel, the next thing I did was go and enable Hyper-V in Windows Features. There are two: "Hyper-V Management Tools" and "Hyper-V Platform." The issue I ran into was the latter being disabled. I didn't panic though: CPU virtualization was probably turned off in my BIOS. So I rebooted and into the BIOS, found the proper screen, and then panicked:

It was already enabled! I didn't know what the "Intel VT-d Feature" was, but I decided to enable it anyway, as it could be a component to the CPUs virtualization infrastructure that Hyper-V depends on. Then I rebooted and checked the features again; Hyper-V was still disabled. Already calculating how much more downtime I'd have to burn through installing Windows Server 2008 R2 again, I went to Lenovo's site and starting downloading and installing all BIOS, chipset, and Intel drivers I could get for my T510.

Fortunately, after flashing the BIOS, I was able to finish installing Hyper-V. Unfortunately, in my frantic "I CAN'T WORK" state, I didn't keep track of which updates I installed. I'm almost certain it was the BIOS update, but I can't know for sure. Regardless, I had native virtualization on my native client machine, and was ready to rock.

After standing up a new VM with all the normal trimmings, I installed Windows Server 2008 R2, SQL Server 2008 R2, SharePoint 2010 Enterprise, and Visual Studio 2010 Premier, along with all services packs and droppings from Windows Update. My machine has eight gigs of RAM, and I allocated the maximum allowed amount, five, to the VM. (Let the record show that I did not review or implement any of the Tech-Net Hyper-V performance optimizations, since my set up was so basic. The only other step I performed was creating a Virtual Switch so that I could share my NICs with the VM.

Setting up a virtual network is still something I don't completely have my head around. Why I have to look at this all day still vexes me:

And the fact that wireless works fine at the office but only for my VM at home (that's right: Internet access on the VM but blackout on my host) is even more annoying. Even though it's certainly possible to work without Internet access, the main reason I want it up for both is to be able to remote from host to VM. And I think it does; I've gotten it to work at home, meaning that VM needs to be online "enough" for it to respond to RDP calls, and the host has to also be online "enough" to think it can send them.

But getting proper RDP is worth it. Hyper-V comes with a connection mechanism, but it has crappy "full screen" support. Compare working in:

To:

I know those screen shots aren't great, but it shows you how much real estate you can get with an RDP connection. Once I got past all of this, I was able to really get into a SharePoint development groove. However you do it, having Visual Studio (along with CKS Dev) installed on your SharePoint box is basically a must: quick deploys, copy to root, and better SPMetal support are features I cannot live without. Like I said, it's going to be slower than a bare metal installation, but in addition to a fully functional server environment, I also have a client to run the rest of my apps.

To that point, using Windows 8 beta with the remaining three gigs of RAM while a VM is running with the rest isn't awesome. But it is passable, especially since all my work (Visual Studio, SQL Server, and IIS) is not taking up any of that memory. I typically have a few Office apps, Lync, Zune, and probably a Visual Studio running (like I could possibly stand up an OS without my IDE) and it's not bad.

But like I said, it's not awesome either.

So I'm going to give this a try for a few months. The lock screen crashes. The networking is not 100%. Restarting hangs occasionally. But to date, Windows 8 (beta) with Hyper-V is the most evolved development environment I've had for SharePoint. The best part is, when I'm not developing in SharePoint, it's off; I can dev in my host environment and it's super speedy. (I have heretofore failed to mention that Windows 8, when not babysitting a VM or being a beta brat, is freaking fast.) Also, I owe it to myself (and my readers...and probably Microsoft) to bone up on some Hyper-V best practices, because I might be able to squeeze even better performance out of it.

Cya.

SPItemEventReceiver.ItemUpdated Method Doesn’t Fire When a Workflow Status Changes

Josh Eberhardy — Sat, 31 Mar 2012 17:53:00 GMT

The Backstory

I recently worked on a project where our users wanted to have a number of different approval workflows (about 15) on a single list. When they added a new list item, they would manually select an appropriate workflow depending on the type of list item they had added. Each list item would only have a single workflow running on it at any given time.

However, every time a new workflow is started on a given list, a new column is added to the list that shows the workflow status. After starting several of these workflows, not only do things get ugly by having too many columns, forcing the user to horizontally scroll, but SharePoint lists only allow 8 lookup columns on a list by default. This means that after too many of these workflows are started, they get the following error: This view cannot be displayed because the number of lookup and workflow status columns it contains exceeds the threshold (8) enforced by the administrator.

Of course, this setting can be changed (http://blogs.msdn.com/b/dinaayoub/archive/2010/04/22/sharepoint-2010-how-to-change-the-list-view-threshold.aspx), but changing this value beyond 8 results in a performance hit and not only that, you’re still left with an ugly looking list with too many columns, forcing users to scroll horizontally.

The ideal solution would be to create a single, custom SharePoint Designer workflow which accepts user input to decide where to route the approvals. Our users didn’t like that idea. They wanted separate, out-of-the-box workflows.

Since we would only be running a single workflow on any given list item, I came up with the idea to create a hyperlink column on the list called “Workflow Status”, and have it show the status of the most recently started workflow. This way, rather than having 15 different columns, each showing a different workflow’s status, we could have a single column. Clicking on the status link would show the workflow information and history.

Since we weren’t using SharePoint Designer workflows, we needed a different way to have the workflow update my custom column with the workflow status. I decided to create an event receiver which would be triggered when a workflow was started or its status changed. Below is the code that I wrote:

using System;

using System.Security.Permissions;

using System.Xml.Linq;

using Microsoft.SharePoint;

using Microsoft.SharePoint.Security;

using Microsoft.SharePoint.Utilities;

using Microsoft.SharePoint.Workflow;

namespace ListEventReciever.EventReceiver1

{

    public class EventReceiver1 : SPItemEventReceiver

    {

        public override void ItemUpdating(SPItemEventProperties properties)

        {

            updateWFStatus(properties, true);

            base.ItemUpdating(properties);

        }

        public override void ItemUpdated(SPItemEventProperties properties)

        {

            updateWFStatus(properties, false);

            base.ItemUpdated(properties);

        }

        private void updateWFStatus(SPItemEventProperties properties, bool ing)

        {

            try

            {

                SPListItem currentItem = properties.ListItem;

                string url = string.Empty;

                string wfState = string.Empty;

                SPWorkflowCollection wfc = currentItem.Workflows;

                SPWorkflow workflow = null;

                 //Although only one workflow should be running on this list item,

                 //we should check. If there is more than one, only grab the most

                 //recent one.

                foreach (SPWorkflow wf in wfc)

                {

                    if (workflow == null)

                        workflow = wf;

                    else

                    {

                        if (wf.Created > workflow.Created)

                            workflow = wf;

                    }

                }

                 //The workflow xml is going to let us tap into the status of the WF
                 //and the URL that will allow us to click on the status hyperlink.

                XDocument xdoc = XDocument.Parse(workflow.Xml);

                wfState = GetWorkflowStatus(xdoc);

                url = workflow.StatusUrl;

                this.EventFiringEnabled = false;

                if (ing)

                {

                    properties.AfterProperties["Workflow Status"] = properties.Web.Url + "/" + url + ", " + wfState;

                }

                else

                {

                    currentItem["Workflow Status"] = properties.Web.Url + "/" + url + ", " + wfState;

                    currentItem.Update();

                }

                this.EventFiringEnabled = true;

            }

            catch (Exception)

            {

                this.EventFiringEnabled = true;

            }

        }

         //We need to get the Status1 attribute, which is the ID of our workflow

         //status.

        private string GetWorkflowStatus(XDocument xdoc)

        {

            string Status1String;

            int WorkflowStatusValue;

            string WorkflowStatusString = "";

            Status1String = (string)xdoc.Element("Workflow").Attribute("Status1");

            if (!(String.IsNullOrEmpty(Status1String)))

            {

                WorkflowStatusValue = int.Parse(Status1String.ToString());

                WorkflowStatusString = WorkflowStatusLookup(WorkflowStatusValue);

            }

            return WorkflowStatusString;

        }

         //The status of the workflow is actually an integer. Couldn’t find any

         //official documentation showing these, but an Internet search proved fruitful

         //(http://chanakyajayabalan.wordpress.com/2010/03/08/sharepoint-workflow-status-codes/)

        private string WorkflowStatusLookup(int status)

        {

            switch (status)

            {

                case 0: return "Not Started";

                case 1: return "Failed on Start";

                case 2: return "In Progress";

                case 3: return "Error Occurred";

                case 4: return "Canceled";

                case 5: return "Completed";

                case 6: return "Failed on Start (retrying)";

                case 7: return "Error Occurred (retrying)";

                case 15: return "Canceled";

                case 16: return "Approved";

                case 17: return "Rejected";

                default: return "Unknown";

            }

        }

    }

}

The Problem

The problem was that when the workflow status changed, my code wasn’t firing. However, if I manually changed some other field on the list, the code would fire. This issue perplexed me for the longest time, until I realized that ListItems reference lookup fields by their ID, rather than their value. Therefore, my list item wasn’t storing the value for the workflow status, it was storing the ID of my workflow status field. That ID doesn’t change, regardless of the status, so although the status was changing, the ListItem itself was not.

The Solution

After much weeping and gnashing of teeth I discovered that if Content Approval for the Document Library is turned on (Document Library Settings >> Versioning Settings) and the workflow has Content Approval Enabled, the list item will be updated, thus triggering our code.

We didn’t actually need content approval, so I set the Draft Item Security to “Any user who can read items” so all users would see the item regardless of its content approval status, and I just hid this column from the users. If I wanted to go a step further I could add code to my event receiver to automatically approve these, but for my purposes this wasn’t necessary. Problem solved!

What are the Business Benefits for upgrading to SQL Server 2012?

Marcello Benati — Tue, 27 Mar 2012 15:19:00 GMT

Our Rightpoint architects have spent the last year working extensively with the SQL Server 2012 in conjunction with Microsoft, and with several of our clients. The benefits this new platform has to offer can significantly enhance your SQL Server environments.

1. Improved Visualization of your Data

With Power View you can extract live data into PowerPoint presentations, saving you time and ensuring up to date information for every meeting. This feature enhances your visualization and interactivity with your data, giving you easy access to the company's data, allowing you to quickly make business decisions, and it does this all within one browser.

2. Improved Data Quality

Our clients regularly need help with their data quality, an on-going challenge in many organizations. SQL Server 2012 has significantly reduced this problem by improving the accuracy and consistency of the data. It does this by cleaning the data itself resulting in excellent quality and on-going maintenance.

3. Excellent Performance

SQL Server 2012 greatly improves your query performance by thousands of times. It does this through fast, interactive exploration of your data, allowing you to get even more business value, even quicker, thus resulting in faster and more accurate decisions.

4. Mission Critical Confidence

SQL Server's new disaster recovery solution helps to protect your infrastructure whilst reducing planned and unplanned downtime. It delivers maximum application availability and data protection, ensuring you have the performance you need, at the right price, especially for mission critical workloads.

5. Scale Business Solutions Fast with the Cloud

SQL Server 2012 offers you the agility to quickly create and scale solutions that offer you new business opportunity from server to private or public cloud. These are all linked together for optimized productivity allowing you to build once so you can deploy and manage whenever, wherever.

SQL 2012 Licensing Primer.

Marcello Benati — Tue, 27 Mar 2012 15:16:00 GMT

SQL Server 2012 is a significant product release, providing Mission Critical Confidence with greater uptime, blazing-fast performance and enhanced security features for mission critical workloads; Breakthrough Insight with managed self-service data exploration and stunning interactive data visualization capabilities; Cloud On Your Terms by enabling the creation and extension of solutions across on-premises and public cloud. SQL Server 2012 is a Cloud Ready Information Platform.

Editions overview

The SQL Server 2012 Editions have been streamlined to better align with how customers are deploying applications and solutions. SQL Server 2012 will be released in 3 main editions*:

· Enterprise for mission critical applications and large scale data warehousing

· Business Intelligence, a new product edition, providing premium corporate and self-service BI

· Standard for basic database, reporting and analytics capabilities

The main editions are now offered in a consistent, tiered model which creates greater consistency across editions, features and licensing. Enterprise Edition will include all features available in SQL Server 2012. The Business Intelligence Edition will include premium BI features as well as all of the Standard Edition features.

*Note: SQL Server 2012 will continue to be available in Developer, Express and Compact editions. Web Edition will be offered in a Services Provider License Agreement (SPLA) model only. Datacenter Edition is being retired with all capabilities now available in Enterprise. Workgroup and Small business Editions are also being retired.

SQL Server 2012 Licensing Options

SQL Server 2012 will continue to offer two licensing options – one based on computing power, and one based on users or devices. In the computing power-based license model, however, the way we measure power will shift from processors to cores. Core-based licensing provides a more precise measure of computing power and a more consistent licensing metric regardless of where the solution is deployed across on-premises, virtual and cloud scenarios.

· Enterprise Edition (EE) will be licensed based on compute capacity measured in cores

· Business Intelligence (BI) Edition will be available in the Server + CAL model, based on users or devices

· Standard Edition (SE) offers both licensing models to address basic database workloads

SQL Server 2012 Editions		Description	Licensing Options		Pricing**
SQL Server 2012 Editions		Description	Server + CAL	Core Based	Open NL (US$)
Main Editions	Enterprise	High end datacenter, data warehousing and BI capabilities		ü	$6,874 per Core
	Business Intelligence	Enterprise BI and High Scale Analytics	ü		$8,592 per Server*
	Standard	Basic database and BI capabilities	ü	ü	$1,793 per Core, or $898 per Server*
	Client Access License (CAL)	Access to SQL Server databases licensed per server			$209 per CAL

* Requires CALs, which are sold separately

**Pricing is for demonstrative uses only

Core-Based Licensing

· The Enterprise Edition and Standard Edition of SQL Server 2012 will both be available under core-based licensing. Core-based licenses will be sold in two-core packs.

· Core based licensing is appropriate when customers are unable to count users/devices, have Internet/Extranet facing workloads or systems that integrate with external facing workloads.

· To license a physical server, you must license all the cores in the server with a minimum of 4 core licenses required for each physical processor in the server.

· Core licenses will be priced at ¼ the cost of a SQL Server 2008 R2 (EE/SE) processor license.

How to license 1. License all of the physical cores on the hardware 2. A minimum of 4 core licenses are required per physical processor

PHYSICAL CORES IN THE PROCESSOR:	1 2 4 6 8
CORE LICENSES REQUIRED	4 4 4 6 8

Server and Client Access License (CAL) Licensing

· The Business Intelligence and Standard Editions will be available under the Server and Client Access License (CAL) model.

· This licensing model can be used when the number of users can be readily counted (e.g., internal database applications).

· To access a licensed SQL Server, each user must have a SQL Server CAL that is the same version or newer (for example, to access a SQL Server 2008 SE server, a user would need a SQL Server 2008 or 2012 CAL).

· Each SQL Server CAL can provide access to multiple licensed SQL Servers, including the new Business Intelligence Edition as well as Standard Edition Servers and legacy Enterprise Edition Servers.

· The SQL Server 2012 CAL price will increase by about 27%.

How to license

1. License each individual server with a SQL Server license

2. License each user or device accessing the server with a SQL Server CAL

SQL Server 2012 CALs can be used to access any SQL Server database licensed per server, regardless of platform or edition.

Virtualization Licensing - Cloud Optimized

SQL Server 2012 will offer expanded virtualization rights, options and benefits to provide greater flexibility for customers deploying in virtual environments. There will be two primary virtualization licensing options in SQL Server 2012: The ability to license individual virtual machines and the ability to license for maximum virtualization in highly virtualized and private cloud environments.

Individual Virtual Machines

· As hardware capabilities grow, it will become more common for each database to use a fraction of its server’s computing power.

· When deploying databases on Virtual Machines (VMs) that use just a fraction of a physical server, savings can be achieved by licensing individual VMs.

· To license a VM with core licenses, purchase a core license for each virtual core (virtual thread) allocated to the virtual machine (minimum of 4 core licenses per VM).

· To license a single VM with a server license (for Business Intelligence or Standard only), buy the server license and buy matching SQL Server CALs for each user.

· Each licensed VM covered with Software Assurance (SA) can be moved frequently within a server farm or to a third party hoster or cloud services provider without buying additional SQL Server licenses.

How to License VMs with Core Licenses 1. License the virtual cores in each virtual machine 2. There is a minimum of 4 core licenses required for each virtual machine
VM1	VM2

VM with 4 Virtual Cores 4 Core licenses required	VM with 6 Virtual Cores 6 Core licenses required

How to License VMs with Server + CAL 1. License each VM with a Server License 2. License each user or device with a CAL

VM1	VM2

VM with SQL Server Business Intelligence Edition 1 Server license required + CALs	VM with SQL Server Standard Edition 1 Server license required + CALs

High Density Virtualization

· Further savings can be achieved by operating a database server utility or SQL Server private cloud. This is a great option for customers who want to take advantage of the full computing power of their physical servers and have very dynamic provisioning and de-provisioning of virtual resources.

· Customers will be able to deploy an unlimited number of VM’s on the server and utilize the full capacity of the licensed hardware.

· They can do so by fully licensing the server (or server farm) with Enterprise Edition core licenses and Software Assurance based on the total number of physical cores on the servers. SA then enables the ability to run an unlimited number of virtual machines to handle dynamic workloads and fully utilize the hardware’s computing power.

Licensing SQL Server private cloud:

1. License all the physical cores on the server with Enterprise Edition core licenses and SA

2. Deploy an unlimited number of VMs

Example

What you License

Physical Cores w/EE+SA

What you Deploy

Unlimited VMs (example 6)

Single Server, 2 physical processors, 6 cores/processor (12 total)

What to Buy:

12 SQL Server Enterprise Edition core licenses + SA

VM1

VM2

VM3

VM4

VM5

VM6

Transition to the New Licensing Models

In order to facilitate a smooth transition to the new editions and licensing, Microsoft is offering several options. These are designed to help enable customers to plan for the future while protecting their current investments.

Enterprise Edition Server + CAL Licensing

· New server licenses for SQL Server Enterprise Edition in the Server + Cal model will only be available for purchase through June 30^th, 2012, after which they will no longer be available for purchase. EA/EAP customers that buy SQL Enterprise Edition Servers will have until their next EA/EAP renewal after June 30^th, 2012 to purchase additional server licenses to complete currently planned projects. After that, all new SQL Server Enterprise Edition deployments must be purchased per core.

· All existing SQL Server Enterprise Edition licenses under the Server + CAL model with Software Assurance current when SQL Server 2012 launches can be upgraded to SQL Server 2012 at no additional cost, and SA can be maintained (in the server + cal model) to provide access to future software updates. These Legacy Enterprise Edition Servers remain licensed under the Server + CAL model and require the appropriate version of the SQL Server CAL for users or devices.

· Legacy SQL Server 2012 Enterprise Edition Server deployments licensed in the server + CAL model will be subject to a 20 core per server license maximum. This core maximum applies both to new server licenses and to prior version server licenses upgraded to 2012 with SA. If you purchased SQL Server 2008 R2 Enterprise Edition in the Server + CAL model with Software Assurance and at the launch of SQL Server 2012 are running on a server with > 20 physical cores, contact your Microsoft representative for help transitioning to the new licensing model.

· Legacy SQL Server 2012 Enterprise Edition Server licenses are still considered licensed under the Server + CAL model but have the new core limit to allow customers to upgrade their existing deployments and have some near term deployment options to finish currently planned projects under the Server + CAL model for the SQL Server Enterprise Edition.

· Moving forward, customers who would have purchased new EE server licenses can: purchase SQL BI server licenses for business intelligence, purchase SQL EE per core for high-scale database or data warehouse, or maintain legacy EE server licenses for existing projects requiring 20 cores or less.

SQL Server Processor licenses under SA moving to Core-based Licensing

· Customers with processor licenses under SA can upgrade to SQL Server 2012 at no additional cost. At the end of the SA term, processor licenses will be exchanged for core licenses and customers can renew their SA on core licenses.

· SQL Enterprise and Standard processor licenses under SA will be exchanged for a minimum of 4 core licenses per processor or for the actual number of cores in use. SQL Server Datacenter processor licenses will be exchanged for a minimum of 8 EE core licenses per processor or for the actual number of cores in use.

· At the end of the current agreement term, customers should do a self-inventory of systems currently running SQL Server, documenting the number of cores in each processor in use with a SQL Server processor license covered with Software Assurance. This will enable customers to receive the appropriate number of core licenses based on SQL Server 2012 to continue their current deployments.

· Customers should do this self-inventory using the Microsoft Assessment and Planning (MAP) Toolkit or other inventory tools and processes to accurately archive a time/date stamped inventory of hardware tied to SQL Server installations.

· If customers do not perform the self-inventory, they will receive 4 core licenses for each Standard and Enterprise Edition processor and 8 EE core licenses per Datacenter Edition processor.


PHYSICAL CORES IN THE PROCESSOR:	2 4 6 8 10
ENTERPRISE OR STANDARD – CORES GRANTED	4 4 6 8 10
DATACENTER – EE CORES GRANTED	8 8 8 8 10

Customers with Enterprise Agreements

· Customers in existing Enterprise Agreements, EAPs and EASs will be able to continue to purchase Enterprise Edition server and processor licenses through the end of their term.

· Customers purchasing processor based licenses through the end of their term will continue to need to calculate the number of licenses required for a deployment based on the 2008 R2 processor use rights.

· Customers with an EA or EAP do have the option to add core licenses mid-term to their agreement for future purchases and should contact their reseller or Microsoft account team for more information.

· All servers licensed with SQL Server 2012 Enterprise Edition server licenses will be subject to the 20 core server limitation.

· The same process as outlined above will be followed at the end of term.

Planning for SQL Server 2012

Customers planning to deploy SQL Server 2012, either through upgrades or new licenses, should remember:

· Renewing Software Assurance (SA) is the best way to protect investments and provide access to new versions as well as Deployment Planning Services and technical assistance.

· EAP will continue to offer customers the best value, including discounts of up to 40% on new EE and BI server licenses.

· Customers should select the right edition depending on usage:

o Enterprise for mission critical applications and large scale data warehousing

o Business Intelligence for premium corporate and self-service BI

o Standard for basic database, reporting and analytics capabilities

· Consolidation and virtualization are the best ways to maximize efficiency of hardware and control the size, computing power and more granularly manage cost of your deployments.

PowerPoint Aspect Ratios and Custom Masters

Jeremy Williams — Tue, 20 Mar 2012 16:19:06 GMT

For those of you who have seen a few PowerPoints in your day, you might know exactly what I’m about to ~~complain~~ talk about… You know those black bars that you see on the side of some presentations, the ones that make it look something like:

If those really bother you, then you’re probably the kind of person that hates watching your favorite TV show like Modern Family, Happy Endings, Grey’s Anatomy, <insert your favorite show here> when the aspect ratio is wrong. Who wants to see the actors all squished and squashed, or miss potentially amusing things happening on the fringes of the frame. (Alas, I digress…) If you’re still with me and don’t know what I’m talking about, I’m referring to the fact that some people will use the zoom/aspect feature on their TV to remove the black bars, but at the expense of the proper ratio (thereby cropping part of the picture off the screen and/or messing with the pixel ratios making everything wider, fuzzier, and just plain awful-err (yes, I just said awful-er).

So when you see a PowerPoint presentation, and it has those black bars on it, don’t you wonder if there’s a way to fix that? You guessed it, there is a way! And it’s surprisingly easy. Simply navigate to your PowerPoint presentation, click on the Design Tab, then press the ‘Page Setup’ button and then select your ‘Slides sized for:…” Value. As a cheat-sheet, if you’re presenting on a full HD screen (1920x1080), you’ll want to select 16:9.

Now that’s all well and good since it’ll get rid of those dreaded black bars.

As you can see, it works stupendously if you’re using a design that has elements that ratio-scale well…What’s that mean? Abstract and generic lines that don’t form recognizable shapes. If, however, you have your company logo in your design, you’ll notice something alarming happens when you resize your presentation.

Before:

After:

Well now, that’s a bit annoying (not to mention it looks really bad during your presentation). So, what’s the fix? Easy, you’ll simply duplicate your slide design and name it 16x9. Once you’ve created a new slide design, you’ll need to go in and edit the masters to correct the scaling rations. After that, you’ll be all set!

…

riiiiiiiiggggghhhhhhhttttttttt… So you want to know how to do that now eh? Well, it’s actually pretty easy.

Open up a new presentation and select your design of interest, in my case it’s the ‘Rightpoint v1.0’ theme.
Change your page setup to the 16x9 ratio
Go to the slide master view (On the View tab)
You’ll see all of the possible slide layouts on the left hand side of the screen. Systematically go through them and correct the scaling ratios.
- Before:
- After:
When you’re finished, click ‘Close Master View’
Then click on the Design tab, click on the design-dropdown, and choose ‘Save the current theme’. Give it a name and share it with whomever you need, and feel free to reuse this every time you’re doing a 16x9 persentation

As always, I hope this was helpful… Now go forth and bring correct aspect-ratios upon the world.

Streamlining Data for Delivery Over Web Services

John Wefler — Tue, 13 Mar 2012 20:18:00 GMT

Taking a subset of data from SQL to pass through a WCF web service is of utmost importance for mobile applications using cellular networks. I never thought I'd be helping write applications for cell phones, but my opportunity to help came recently when the architect in charge of the project read "web services" from my skills list. I have done some crazy things reading and writing data to SharePoint via the out-of-the-box web services, but I've never created a web service of my own. Time to grow, I said…

After a brief ramp up, I had a WCF returning data along an HTTPS pipeline. I was dealing with objectified data within the entity framework model. The "queryable" data was of an abstract type I call "message". Imagine a not too complex system to store and retrieve email messages. The data was heavy, dripping with metadata and system-used fields. Some of the data went well with the web-based version of the program that I was helping to create the mobile version of, but most of it didn't need to be passed along the packetized cellular radio infrastructure.

What I needed was to pass my queried data into a method that would transform it into a private object class that would be more suited for transport.

First, I chose a subset of the fields I wanted to return. Then I created a transformer method that mapped fields from the data model into the structure of the subset. I returned a list of these new class objects, which are then serialized with the JavaScript Serializer which spit out objects in JSON format for delivery via web service.

Transformer method:

private static List<Message> CleanResults(IQueryable<Model.message_vw> matchedMessages)

   var MessagesTransformed = matchedMessages.Select(x => new Message

                message_id = x.message_id,

                message_subject = x.message_subject,

                message_body = x.message_body,

                is_urgent = x.is_urgent,

                sent_by_user_id = x.sent_by_user_id

})

   .ToList();

   return MessagesTransformed;

Data Retriever:

using (Model.Wef_Entities myWefEntities = new Model.Wef_Entities())

   var matchedMessages = myWefEntities.message_vw

      .Where(m => m.recipient_user_id == this.UserGuid)

      .OrderByDescending(o => o.sent_dt);

   return SerializeData(CleanResults(matchedMessages));

JSON Serializer:

public string SerializeData(object obj)

   JavaScriptSerializer jss = new JavaScriptSerializer();

   return jss.Serialize(obj);

Getting the first SPMetal queries after application domain startup to not crash

Jonathan Rupp — Mon, 12 Mar 2012 02:46:00 GMT

I was recently asked to take a look at some exception stack traces from the production logs of a large intranet site that just went live and is now experiencing a lot of these exceptions calling SPMetal queries that didn’t show up during development and testing, and whenever they go looking for them, they don’t happen, but they regularly appear in the logs. All of the exceptions had something like this at the top:

System.ArgumentException: An item with the same key has already been added.
at System.ThrowHelper.ThrowArgumentException(ExceptionResource resource)
at System.Collections.Generic.Dictionary`2.Insert(TKey key, TValue value, Boolean add)
at System.Collections.Generic.Dictionary`2.Add(TKey key, TValue value)
at Microsoft.SharePoint.Linq.Rules.ToEnumerableProcessor.GetEnumerableOperator(MethodInfo qm)
at Microsoft.SharePoint.Linq.Rules.ToEnumerableProcessor.ConvertMethod(MethodCallExpression mce, Context ctx)
at Microsoft.SharePoint.Linq.Rules.ToEnumerableProcessor.<.cctor>b__13(MethodCallExpression mce, Context ctx)
at Microsoft.SharePoint.Linq.Rules.GuardedRule`4.<>c__DisplayClass3.<.ctor>b__1(TSourceBase src, TContext ctx)
at Microsoft.SharePoint.Linq.Rules.SwitchRule`3.Apply(TSource src, TContext ctx)

So what did I do to try to narrow this down? Why ILSpy of course (queue the ILSpy theme music – it sounds a lot like the Mission Impossible theme to me, but whatever song plays in your head is fine). Here’s where I started in ToEnumerableProcessor.GetEnumerableOperator:

So, ToEnumerableProcess.enumerableOpsByName, eh?

Yep, that’s a static dictionary. If “typeof(Enumerable).GetMember(@operator.Name, MemberTypes.Method, BindingFlags.Static | BindingFlags.Public).Cast<MethodInfo>().ToArray<MethodInfo>()” takes a bit of time to run, we could probably end up with two threads inside that if block at the same time, then both do the Dictionary.Add call, and all but the first would get the exception we’re looking for. The problem with this theory is that that wouldn’t explain why we get this error a number of times during the day – there’s only 50 different method names on Enumerable, and most of them are probably never used by our code, so we’d not expect to see many of these, even right after startup. After talking to the team, I found out they’ve been making a number of manual tweaks to the web.config file for the site in the last week or so, which would explain why it the application domain is being rebuilt so many times, and why they’re seeing these errors so often. One idea that has been floated is the idea of running *all* SPMetal queries while holding the same lock

Now that we have a theory, can we reproduce it? To do this, we’d need a simple SPMetal context, and a way to test the theory – create a couple of threads, synchronize them (to eliminate thread startup time from the equation), then create the context and execute a query and see what happens. Let’s just do a simple query: “cx.StyleLibrary.ToList()”. What do we get?

System.ArgumentException: An item with the same key has already been added.
   at System.ThrowHelper.ThrowArgumentException(ExceptionResource resource)
   at System.Collections.Generic.Dictionary`2.Insert(TKey key, TValue value, Boolean add)
   at System.Collections.Generic.Dictionary`2.Add(TKey key, TValue value)
   at Microsoft.SharePoint.Linq.Rules.ReflectionTreeRewriter`1.GetRewriter(Type type)
   at Microsoft.SharePoint.Linq.Rules.ReflectionTreeRewriter`1.GetChildren(TNodeBase node)
…

   at Microsoft.SharePoint.Linq.DataContext.GetList[T](String listName)
   at SPMetalThreadTest.WSP.SPMetalDefinition.SPMetalDefinitionContext.get_StyleLibrary()

Well, not exactly what we were expecting, but the same exception – we appear to be on the right track. The trick to solving this is probably going to be doing a bunch of ‘fake’ queries once at startup (or before the first query) to get things “warmed up”. Here’s a first stab at this ‘warmup’ logic (added to the partial DataContext class):

partial void OnCreated()
{
    Warmup();
}

private static bool _WarmedUp = false;
private static object _WarmupLock = new object();
private void Warmup()
{
    if (_WarmedUp)
        return;
    lock (_WarmupLock)
    {
        if (_WarmedUp)
            return;

        DoWarmup();
        _WarmedUp = true;
    }
}

private void DoWarmup()
{
    Console.WriteLine("Running warmup logic");
    var x = this.StyleLibrary;
}

Let’s run it again and see what we get:

System.NullReferenceException: Object reference not set to an instance of an object.
   at System.Collections.Generic.Dictionary`2.Insert(TKey key, TValue value, Boolean add)
   at System.Collections.Generic.Dictionary`2.Add(TKey key, TValue value)
   at Microsoft.SharePoint.Linq.Rules.ToEnumerableProcessor.GetEnumerableOperator(MethodInfo qm)

….
   at Microsoft.SharePoint.Linq.EntityList`1.GetEnumerator()
   at System.Collections.Generic.List`1..ctor(IEnumerable`1 collection)
   at System.Linq.Enumerable.ToList[TSource](IEnumerable`1 source)

Sure enough, a different error. What if I use a different list? Same error, so it appears using a single one of my lists is enough (though I probably would just add getters for all your lists to be safe – this code won’t run very often). Ok, now to fix that error – maybe if I just add a .ToList() call to my Warmup logic?

Waiting for all threads to report ready
All threads reported ready - releasing
Running warmup logic
All threads exited

Yep, that worked. What if I add a select clause to my test query? No change. A where? No change. A where and a select? Bingo – another error:

System.ArgumentException: An item with the same key has already been added.
   at System.ThrowHelper.ThrowArgumentException(ExceptionResource resource)
   at System.Collections.Generic.Dictionary`2.Insert(TKey key, TValue value, Boolean add)
   at System.Collections.Generic.Dictionary`2.Add(TKey key, TValue value)
   at Microsoft.SharePoint.Linq.Rules.ToEnumerableProcessor.GetEnumerableOperator(MethodInfo qm)
   at Microsoft.SharePoint.Linq.Rules.ToEnumerableProcessor.ConvertMethod(MethodCallExpression mce, Context ctx)
….

   at System.Linq.Enumerable.ToList[TSource](IEnumerable`1 source)

And this time, it even looks like the trace from our bug report. We’re definitely on the right track here. Adding a where and select to my ‘warmup’ query got rid of that error. If I add a few more operators to my test query (Distinct, OrderBy, Max), I start getting the error again, so it seems my ‘warmup’ method needs to:

Reference each list I’m going to use.
Populate ToEnumerableProcessor.enumerableOpsByName by:
1. Run one of every query style to be used (just calling everything from System.Linq.Enumerable in a query won’t be enough – some map to different operators or are combined)
  or
2. Use Reflection to make a bunch of calls to Microsoft.SharePoint.Linq.Rules.ToEnumerableProcessor.GetEnumerableOperator to trick it into setting up everything we need.

After taking a few runs at calling all the methods via #2.1, it’s becoming clear that LINQ-to-SP does some operator combinations that are fouling things up, so I’m trying to reflection approach, which seems to be working reliably:

private void DoWarmup()
{
    Console.WriteLine("Running warmup logic");
    var x = this.StyleLibrary.Count();

    var asm = typeof(DataContext).Assembly;
    var opUtilType = asm.GetType("Microsoft.SharePoint.Linq.OpUtil");
    var operatorFields = opUtilType.GetField("operatorFields", BindingFlags.NonPublic | BindingFlags.Static);
    var methods = ((Dictionary<MethodInfo, FieldInfo>)operatorFields.GetValue(null)).Keys.ToList();
    var toEnumerableProcessorType = asm.GetType("Microsoft.SharePoint.Linq.Rules.ToEnumerableProcessor");
    var getEnumerableOperator = toEnumerableProcessorType.GetMethod("GetEnumerableOperator", BindingFlags.NonPublic | BindingFlags.Static);
    foreach (var method in methods)
    {
        getEnumerableOperator.Invoke(null, new object[] { method });
    }

    Console.WriteLine("Warmup logic complete");
}

Great, problem solved, right? Not quite. What happens if I change my test query to be something that runs query operators against integers, something like “cx.StyleLibrary.Where(x => x.Id == 0).Select(x => x.Id).Distinct().OrderBy(x => x).Max()”? Yep, it breaks again…

System.ArgumentException: An item with the same key has already been added.
   at System.ThrowHelper.ThrowArgumentException(ExceptionResource resource)
   at System.Collections.Generic.Dictionary`2.Insert(TKey key, TValue value, Boolean add)
   at System.Collections.Generic.Dictionary`2.Add(TKey key, TValue value)
   at Microsoft.SharePoint.Linq.Rules.ReflectionTreeRewriter`1.GetRewriter(Type type)
   at Microsoft.SharePoint.Linq.Rules.ReflectionTreeRewriter`1.GetChildren(TNodeBase node)
   at Microsoft.SharePoint.Linq.Rules.ChildRule`2.Apply(TNode src, TContext ctx)
…
   at Microsoft.SharePoint.Linq.Rules.ToEnumerableProcessor.Process(Expression e, List`1& assumptions)
   at Microsoft.SharePoint.Linq.SPLinqProvider.RewriteAndCompile[T](Expression expression, List`1& assumptions)
   at Microsoft.SharePoint.Linq.SPLinqProvider.System.Linq.IQueryProvider.Execute[T](Expression expression)
   at System.Linq.Queryable.Max[TSource](IQueryable`1 source)

Not good. It appears I’m going to need to call Microsoft.SharePoint.Linq.Rules.ReflectionTreeRewriter<T>.GetRewriter(Type) for every type we’re dealing with. This could get messy fast…

Luckily, if ReflectionTreeRewriter<T>.GetRewriterForType(Type) returns null, an exception gets thrown, the default returns null, and the only subclass is the non-generic Microsoft.SharePoint.Linq.Rules.ExpressionTreeRewriter, so this may be doable. ExpressionTreeRewriter exposes a singleton instance of itself via it’s “Singleton” field, so let’s try adding this to the ‘DoWarmup’ method:

var expressionTreeRewriterType = asm.GetType("Microsoft.SharePoint.Linq.Rules.ExpressionTreeRewriter");
var singletonField = expressionTreeRewriterType.GetField("Singleton", BindingFlags.Static | BindingFlags.Public);
var expressionTreeRewriter = singletonField.GetValue(null);
var getRewriterMethod = expressionTreeRewriterType.BaseType.GetMethod("GetRewriter", BindingFlags.NonPublic | BindingFlags.Instance);

foreach (var type in types)
{
    getRewriterMethod.Invoke(expressionTreeRewriter, new object[] { type });
    if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
    {
        var baseType = type.GetGenericArguments()[0];
        getRewriterMethod.Invoke(expressionTreeRewriter, new object[] { baseType });
    }
}

Still no dice. Ok, let’s try a simple retry of the query then. Add this extension method, and call it instead of ToList():

public static List<T> ToListSafe<T>(this IEnumerable<T> enumeration)
{
    try
    {
        return enumeration.ToList();
    }
    catch (ArgumentException)
    {
        // add the sleep to work for complicated queries too
        System.Threading.Thread.Sleep(250);
        return enumeration.ToList();
    }
}

And it works! (Adding in a “System.Threading.Thread.Sleep(250)” in the catch block makes it even handle some really complicated queries). In fact, we can get rid of the reflection calls in DoWarmup – just leave the list references there, make sure all of the calls that actually cause queries to execute (such as .ToList, .ToArray, .ToDictionary, .FirstOrDefault(), etc.) are called with a retry if ArgumentException is thrown (like the ToListSafe extension method above), and those problems are history.

Ok, so we’ve come up with hacks to work around this – the obvious next question is…. WHY? Well, I can’t answer that. It appears that the SharePoint LINQ libraries try to heavily take advantage of the performance boost of caching expression trees and the other components that make up query execution. That’s not problematic by itself, if done correctly, but unfortunately, it is done in a way that isn’t thread-safe, since Dictionary<K,V> is *not* thread-safe, and no measures are taken to protect against problems caused by that. If you find yourself in a situation like this in .Net 3.5, the best approach is probably to use a System.Collections.Hashtable (which *is* thread-safe, even if it’s not generic), and make sure you don’t call the .Add method (use the indexer instead). If you’re in .Net 4.0 (which SharePoint 2010 obviously isn’t), ConcurrentDictionary<K,V> is another option, since that *is* thread-safe.

Well, thanks for coming along on yet another dive into the internals of SharePoint to find out why something isn’t behaving like I want it to. The final sample code for this test scenario with the final fix is attached for your experimentation (SPMetalThreadTest.zip). Now, if only I can get iPhones to behave on my site… ah… a story for another day.

Importing SharePoint Designer Workflows Into Visual Studio (Part 3)

Chris Domino — Wed, 07 Mar 2012 23:26:00 GMT

You've made it to Part 3! In Part 1, I described the general situations we faced importing SharePoint Designer 2010 (SPD) Workflows (WF) into Visual Studio 2010 (VS). Part 2 went into a lot of detail about the specific issues we encountered. In this final piece, I'll outline the...are you ready for this...SEVENTY-ONE step procedure that I was given. When the engineer at Microsoft first sent over this document, it was actually only a few very (although extremely convoluted) steps. So I broke them down and distilled the process into something that anyone familiar with VS could follow.

When designing a WF, assign its construction to either VS or SPD in the third place after classifying them as "simple" or "complex" in the second place having defined what each of those terms means to your team and their skillsets in the first place. Then, after the SPD WFs are built and tested, the following procedure gets them into VS, addressing almost all of the concerns listed in Part 2. I'm going to assume you're starting form an existing VS solution.

Let me begin by first defining some placeholders I use in the step-by-step:

[display name of workflow]: The "friendly" name of the WF, with spaces and capitalization.

[folder name of workflow]: After you do an import, you'll have a folder named "Workflows" and under that a folder with a cryptic-ish name that generally resembles an "intenral" name for your WF. For example, I had a WF with a display name of "Process Intake" and the generated folder was named "ProcessIntakeFT" in VS. Meh.

[workflow node]: In Solution Explorer, this is the representation of the folder with the above name under the "Workflows" folder off the root of the project. But it won't be a folder icon, since VS imports it as a module.

[solution namespace]: I follow a standard namespace convention, where my solution name is the name of the client, then the application name, then, for each project, a description of what it does. So something like Client.Application.DataAccess or Client.Application.Web. For workflows, I throw a .Workflows namespace in there, so they are all organized together. This would look like Client.Project.Workflows.SomeWorkflow. Therefore [solution namespace] is everything before the ".Workflows" part.

[display name of solution]: The "friendly" name of your application, which for me, is usually something like "Client Intranet" with spaces and capitalization.

[name of feature]: There is one feature in these SharePoint VS projects, and this will stand for whatever you rename it to.

[content type node]: This is another module under the [workflow node] folder that contains a content type SPD generates for the WF task.

Here's what Solution Explorer will look like after an import (I did clean up some of the node names to make it little more intuitive):

And here we go:

In VS, create new project of type "Import Reusable Workflow" named [solution namespace].Workflows.[folder name of workflow].
In the ensuing wizard, select the local SharePoint site URL and file location of the WSP exported from SPD.
In Solution Explorer, rename the feature "[folder name of workflow]Workflow." This is then [name of feature].
Double click the [name of feature].feature node.
In the feature designer, give it a proper Title ("[display name of solution] [display name of workflow] Workflow") and description ("Installs the [display name of workflow] workflow and any supporting infrastructure.").
Remove the content type from the asset list on the right by clicking on its box, and then clicking the "<" button. You'll see it move over to the list of assets on the left. Critical Note: this is a step we performed because we wanted to use our custom, existing content types for tasks. This is also the thing that didn't work! Omit this step to use the default content type SPD conjures up, and everything works.
Press Control + S to save the file.
In Solution Explorer, delete the folder for the content type (under the "Workflows\[folder name of workflow]" folder). Critical Note: Again, omit this to use the SPD content type.
Copy the InfoPath 2010 (IP) forms into the workflow node (which is the first folder under "Workflows").
Delete the "Other Imported Files" folder.
Right click each XSN file, and select "Properties."
In the property pane, change the "DeploymentType" to "ElementFile."
There could be zero to many XSN files here, one for the association form (if defined) and one for each task content type the WF is associated with. Repeat the above two steps for each if there are any.
In Solution Explorer, right click [workflow node], and select properties. Expand the "Feature Receiver" node.
Enter "Microsoft.Office.Workflow.Feature, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" for the "Assembly."
Enter "Microsoft.Office.Workflow.Feature.WorkflowFeatureReceiver" as the "Class Name."
Click the ellipses in the value for "Feature Properties." A window pops up.
Add a member with a key of "GloballyAvailable" and a value of "true."
Add a member with a key of "RegisterForms" and a value of "[folder name of workflow]\*.xsn."
In Solution Explorer, if you are source controlled, check out all XSN files. If not, make sure they are not read-only, as the following steps involve opening the IP client application, which doesn't handle read-only files well. (It doesn't seem to refresh the file attributes, so if the XSN is read-only when opened, you'll have to close IP, make the file not read-only, and open it back up.)
Right click the workflow node and select "Open Folder in Windows Explorer."
In Windows Explorer, right click the task form (the XSN file with, hopefully, the word "Task" somewhere in the file name), and select "Design." (Note: although it's technically possible to have many task forms as mentioned above, this procedure only supports using one.)
In InfoPath, click "File."
Click "Form Template Properties."
Copy the "ID" field into a new instance of Notepad. Precede it with [TASK].
Click "OK."
Close InfoPath.
Click "Don't Publish."
In Windows Explorer, right click the association form's XSN file and select "Design."
In IP, click "File."
Click "Form Template Properties."
Copy the "ID" field into the existing Notepad instance. Precede it with [ASSN].
Click "OK."
In Notepad, your text file should look like this:

[TASK]urn:schemas-microsoft-com:office:infopath:workflowInitAssoc:-AutoGen-2012-02-02T18:22:24:952Z
[ASSN]urn:schemas-microsoft-com:office:infopath:workflowInitAssoc:-AutoGen-2012-01-27T20:54:17:296Z
In IP, click on the "Page Design" tab.
Select the "Associate" view in the "Views" section's "View" dropdown in the ribbon.
Click "Properties."
In the popup, check "Set as default view."
Press "OK."
Click on the "Data" tab.
Click "Form Load" in the "Rules" section.
In the "Rules" pane on the right, click "New" and select "Action."
Name it "Switch view on form load" under "Details for."
Click the link under "Condition."
In the popup, select "The expression" in the first dropdown.
Enter "isStartWorkflow = "true"" (without the outer quotes) in the textbox.
Click "OK."
Back in the "Rules" pane, click "Add" and select "Switch views."
Select "Start" in the "View" dropdown.
Click "OK."
Click the disk (save) icon above "File."
Click "Save" in the popup.
Close InfoPath.
Click "Don't Publish."
In Visual Studio, in Solution Explorer, open the "Elements.xml" file under the [workflow node].

Add the following markup directly above the closing tag toward the bottom of the file:



	<Instantiation_FormURI>[ID from notepad of the association form]</Instantiation_FormURI> <Association_FormURN>[ID from notepad of the association form]</Association_FormURN> <Task0_FormURN>[ID from notepad of the task form]</Task0_FormURN>

Set the value for the "Workflow" node's "Name" attribute to "[display name of solution] [display name of workflow] Workflow."
Press Control + S to save the file.
Add the following file references to the project (some of these assemblies need to sucked out of the GAC, so this post has an attachment that's a ZIP file of these DLLs):
- Microsoft.Office.Workflow.Actions.dll
- Microsoft.Office.Workflow.Pages.dll
- Microsoft.Office.InfoPath.Server.dll
- Microsoft.Office.InfoPath.dll
Add the "SharePoint 'Layouts' Mapped Folder" to the project.
Add an Application Page to this folder's child. Name it "MyTaskFormHost."
In the Application Page HTML editor, remove all content except for the @Page directive.

Copy the following ABOVE your @Page directive:



	<%@ Assembly Name="$SharePoint.Project.AssemblyFullName$" %> <%@ Assembly Name="Microsoft.Office.Workflow.Pages, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Import Namespace="Microsoft.SharePoint.ApplicationPages" %> <%@ Assembly Name="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %>

Copy the following BELOW your @Page directive:



	<%@ Import Namespace="Microsoft.SharePoint.WebControls" %> <%@ Register Tagprefix="SharePoint" Namespace="Microsoft.SharePoint.WebControls" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Register Tagprefix="Utilities" Namespace="Microsoft.SharePoint.Utilities" Assembly="Microsoft.SharePoint, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Import Namespace="Microsoft.SharePoint" %> <%@ Assembly Name="Microsoft.Web.CommandUI, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Register Tagprefix="InfoPath" Namespace="Microsoft.Office.InfoPath.Server.Controls" Assembly="Microsoft.Office.InfoPath.Server, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c" %> <%@ Register TagPrefix="wssuc" TagName="LinksTable" src="/_controltemplates/LinksTable.ascx" %> <%@ Register TagPrefix="wssuc" TagName="InputFormSection" src="/_controltemplates/InputFormSection.ascx" %> <%@ Register TagPrefix="wssuc" TagName="InputFormControl" src="/_controltemplates/InputFormControl.ascx" %> <%@ Register TagPrefix="wssuc" TagName="LinkSection" src="/_controltemplates/LinkSection.ascx" %> <%@ Register TagPrefix="wssuc" TagName="ButtonSection" src="/_controltemplates/ButtonSection.ascx" %> <%@ Register TagPrefix="wssuc" TagName="ActionBar" src="/_controltemplates/ActionBar.ascx" %> <%@ Register TagPrefix="wssuc" TagName="ToolBar" src="/_controltemplates/ToolBar.ascx" %> <%@ Register TagPrefix="wssuc" TagName="ToolBarButton" src="/_controltemplates/ToolBarButton.ascx" %> <%@ Register TagPrefix="wssuc" TagName="Welcome" src="/_controltemplates/Welcome.ascx" %> <asp:Content ID="Content1" ContentPlaceHolderId="PlaceHolderAdditionalPageHead" runat="server"> </asp:Content> <asp:Content ID="Content2" ContentPlaceHolderId="PlaceHolderPageTitle" runat="server"> <SharePoint:EncodedLiteral ID="EncodedLiteral1" runat="server" text="<% $Resources:dlc, WrkTask_PageTitle %>" EncodeMethod="HtmlEncode" /> </asp:Content> <asp:Content ID="Content3" ContentPlaceHolderId="PlaceHolderPageTitleInTitleArea" runat="server"> <a tabindex="1" href="<% SPHttpUtility.AddQuote(SPHttpUtility.UrlPathEncode(List.DefaultViewUrl,true),Response.Output); %>"> <% SPHttpUtility.HtmlEncode(List.Title,Response.Output); %> <a> </asp:Content> <asp:Content ID="Content4" ContentPlaceHolderId="PlaceHolderTitleBreadcrumb" runat="server"> <asp:SiteMapPath SiteMapProvider="SPContentMapProvider" id="ContentMap" SkipLinkText="" runat="server" /> </asp:Content> <asp:Content ID="Content5" ContentPlaceHolderId="PlaceHolderLeftNavBar" runat="server"> </asp:Content> <asp:Content ID="Content6" ContentPlaceHolderId="PlaceHolderMain" runat="server"> <SharePoint:FormComponent ID="FormComponent1" TemplateName="WorkflowEditFormToolBar" ControlMode="Edit" runat="server"> <table class="ms-informationbar" style="margin-top: 10px;" border="0" cellpadding="2" cellspacing="0" width="100%"> <tr> <td width="10" valign="center" style="padding: 4px;"> <img src="/_layouts/images/Workflows.gif" alt="<% SPHttpUtility.AddQuote(SPHttpUtility.HtmlEncode(GetLocString("WrkTask_PageTitle")),Response.Output); %>" /> </td> <td> <% SPHttpUtility.NoEncode(m_pageDescription, Response.Output); %> </td> </tr> </table> <InfoPath:XmlFormView ID="XmlFormControl" runat="server" style="width: 100%;" /> <SharePoint:FormDigest ID="FormDigest1" runat="server" /> </asp:Content>

In the code behind file of this page, update the using statements at the top of the file to the following:



	using System; using Microsoft.SharePoint; using Microsoft.Office.Workflow; using Microsoft.SharePoint.WebControls; using Microsoft.Office.InfoPath.Server.Controls;

Change the class to inherit from "WrkTaskIPPage."

Update the contents of the class to be the following:



	protected override void OnInit(EventArgs e) { XmlFormControl.Initialize += new EventHandler<InitializeEventArgs>(XmlFormControl_Initialize_Custom); XmlFormControl.SubmitToHost += new EventHandler<SubmitToHostEventArgs>(XmlFormControl_OnSubmitToHost_Custom); XmlFormControl.Close += new EventHandler(XmlFormControl_OnClose_Custom); base.OnInit(e); } protected void XmlFormControl_Initialize_Custom(object sender, InitializeEventArgs ea) { this.ModifySettings(); } protected void XmlFormControl_OnSubmitToHost_Custom(object sender, SubmitToHostEventArgs e) { this.ModifySettings(); } protected void XmlFormControl_OnClose_Custom(object sender, EventArgs e) { this.ModifySettings(); } private void ModifySettings() { this.m_isCustomXsn = true; int taskType = (int)this.m_task[SPBuiltInFieldId.TaskType]; if (taskType == 2) { this.XmlFormControl.DefaultView = "ChangeView"; } }

In Visual Studio, rebuild the project, make sure it compiles.
In Solution Explorer, if you're using the SPD content type, open the elements.xml file under [workflow node]\[content type node].
In the XML editor, under the "FormURLs" element, set "_layouts/ [solution namespace].Workflows.[folder name of workflow]/ MyTaskFormHost.aspx" as the value for the existing "Display" and "Edit" elements.
Add a "New" element as a child to "FormURLs" and set "_layouts/ [solution namespace].Workflows.[folder name of workflow]/ MyTaskFormHost.aspx" as the value for that as well. If you are indeed using your own custom content type, which, recall, is the piece that fails with this procedure, go into the code or configuration that provisions your existing content type, and make sure that "_layouts/ [solution namespace].Workflows.[folder name of workflow]/ MyTaskFormHost.aspx" is set for the NewFormUrl, EditFormUrl, and DisplayFormUrl properties.

The code and markup above was given to me by Microsoft, so use third-hand code at your own risk! But in general, that's it. I mentioned a few times that the one thing that didn't work was using existing content types for our task forms. This was a show-stopper for us, and the only reason we didn't move forward with this procedure. But I hope this outlines what has to be dealt with when exporting "complex" SPD WFs into VS.

And, of course, what has to be dealt with after making assumptions...

Have fun!

Importing SharePoint Designer Workflows Into Visual Studio (Part 2)

Chris Domino — Wed, 07 Mar 2012 22:48:00 GMT

In Part 1 of this post, I discussed the general issues my team has run into importing SharePoint Designer 2010 (SPD) workflows (WFs) into Visual Studio 2010 (VS). But for a quick overview: I am currently part of a hybrid team of SharePoint designers and SharePoint developers, and in order to make our application deployment one hundred percent automated, we wanted to import all of the WFs created via SPD into VS. I made the assumption that the "Import Reusable Workflow" VS project import was the winning ticket. But instead, it was more like a speeding ticket, and, to string along this weak metaphor, I was incarcerated for over two months for driving without insurance.

Our solution was to call Microsoft and task for help. The details of this conversation, specifically the issues we discovered and the questions we asked will comprise this post. Since that discussion and the ensuing ninety percent solution (not one hundred percent, since one show-stopping issue still didn't work) were so long, I'm going to break the latter into a Part 3. I'll be going into detail about the problems we faced with the workflow; specifically, the ones that we determined were not just bugs on our end, but rather nuances with SPD, and what we were left with after a "successful" import into VS.

Interestingly, most of these problems are SPD- specific, and it's possible that the hacks employed to get around them are part of the issue causing VS not to import them correctly. But these were only discovered after augmenting our development approaches to support VS integration. I'll present these first, and then move on to the specific problems we encountered when actually performing the import, or experienced after deploying from VS.

SharePoint Designer Issues

You'll see below that a lot of the SPD questions we posed to Microsoft regarded InfoPath (IP) forms and associated custom content types used for the WF tasks. We created these content types, which inherit from WorkflowTask, to store additional data in our task lists. (All of our WFs use the out-of-the-box "Workflow Tasks" list for each sub site.) The IP forms provide the UI for the users to populate this data.

<Rant>

IP was the cause of many other headaches suffered by our WF designer. Why SPD, in 2010, forces these as the default over ASPX pages, I'll never understand.

</Rant>

Problem Statement #1: For custom task forms, we are unable to set the content type of the task form via SPD (the field is read only). This requires us to do have to manually hack the XMOL and CONFIG files for the WF:

Question #1: How do we properly set the content type for a custom InfoPath (IP) task form?

Problem Statement #2: Another area we have to manually hack the XOML file is configuring the WF to check in/out the current list item. Here's all that's available to us in the UI for check in/out actions:

Question #2: How do we configure an SPD WF step to check out the current list item?

Problem Statement #3: On WFs with custom IP task forms, after solution gallery deployment and activation, we are running into an issue with opening SPD and globally publishing the WFs. Here's what we see in SPD (in the "Forms" section) on the server we just deployed to:

After opening the newly-deployed WF, the following error shows up when clicking "Publish Globally:"

This is actually fine for the association / initialization forms, as those can be auto-generated. However, we have to make customizations to the task form, and those changes will be lost if we have to delete the IP form so SPD can re-gen it. In this case, IP gives me the following message:

In any case, I do a "Quick Publish" operation in IP, and return to SPD. Publishing still fails with that first message above. However, if I close SPD first and then reopen it, the forms appear to know they've been updated via an IP Quick Publish (notice the parentheticals next to the form names now say "custom form" instead of "* needs update").

But when I Publish Globally now, it still fails with the same message. "[name of task form].xsn (custom form)" above changes to "[name of task form].xsn * (needs update)."

But this is the one we can delete and have SPD re-generate! Doing so and globally republishing does work, but the customizations of the task form are lost.

Question #3: How do we fix customized IP task forms (deployed successfully via WSPs in the site collection solutions gallery) so that their customizations are not reset by the "Publish Globally" process?

Problem Statement #4: We have found that every time you WSP-deploy a workflow created from SPD to a new environment via our procedure, folders will be created on the target environment under "All Files\Workflows" that correspond to every workflow that's ever been created in the development environment. In other others, if I have Workflow1 and Workflow2 in my local environment and I WSP-deploy Workflow2 only to my development server, an empty folder will be created under "All Files\Workflows\Workflow1" even though it WASN'T WSP-deployed. Although this is mostly just in the way, if we ever do deploy Workflow1, and forget to delete this extraneous folder, we'll get an error that the folder already exists.

Question #4: Is there any way to get this not to happen?

Question #5: One of our WFs contains a lookup field. After WSP-deploying it to the development environment and opening SPD to globally publish it, we get the following error. This is very indicative of the shortcomings of SPD, since we have carefully deployed our site columns (lookup or otherwise) to ensure they have the same GUIDs across our environments. We could technically work around this issue specifically, but this requires adjustments to our security model and basically re-architecting the WF.

Question #5: How do you get WFs with lookup site columns to be globally-publishable?

Visual Studio Issues

I've combined my VS questions to Microsoft into one narrative:

When using the "Import Reusable Workflow" new project template, the workflows are imported, but the project does not compile. I got past this by adding the proper SharePoint/IP/Office DLL references. However, although I can get it to generate WSP packages, the IP forms are never published; they are actually nowhere to be found on the target environment. After fiddling around with it for two days, I decided to abandon this approach.

Now, when using the "Import SharePoint Solution Package" new project template, the workflow does import, package, and deploy. However, the project is a mess: unwanted content types and site columns are imported, multiple features are created, and depending on the titles used back in SPD, horrendously long file names are generated in the deep folder structure, at times throwing compilation errors due to eclipsing the Windows max path length. But like I said, it *does* deploy and work. We need to perform a hack to get the workflows to be "Globally Published (a la SPD);" otherwise, the features are web-scoped and can only be activated to the root site. Finally, when opening up the XOML file in Visual Studio, the workflow is HUGE; hundreds of activities are created, and they all have those red exclamation marks on them in the VS WF designer. Maintainability-wise, this won't be agreeable to our client.

Additionally, we've come across two situations in which this approach actually fails. First, one of our WSPs refuses to import; the last step in the "Import SharePoint Solution Package" wizard that allows you to choose which assets to import is blank. No files are listed.

Second, some WSPs have TWO workflows in the manifest, and merging them manually through Visual Studio is extremely hacky and doesn't work all the time.

Both of these WSPs are functional in SPD, and were exported using the same process as the rest.

The detailed answers to the SPD questions are out of scope for this post. Of course, hacking the XOML file is not supported. But to my surprise, the issue with the lookup field is not supported either! All in all, the theme of the response was to use VS for "complex" WFs - the subjective answer I discussed in Part 1. As far as explicit SPD support goes, we were toeing the line between what that tool could handle and what VS could do natively. The irony, of course, is that exporting to VS wasn't working either.

So if you take one thing away from these posts, it's this: use SPD for what SPD does well. Because when it works, it works awesome. We only got into trouble when trying to make the tool sweat. Of course, everything has a support list of functionality and a breaking point; we weren't being wanton with SPD in my opinion. Microsoft was very consistent in their guidance, regardless of its subjectivity. So read on to Part 3, and let's see how we were able to get around most of these issues!

Importing SharePoint Designer Workflows Into Visual Studio (Part 1)

Chris Domino — Mon, 05 Mar 2012 22:19:00 GMT

SharePoint is a universe, and like our own, new distant galaxies are discovered and elucidated. Similar to an astronomer, as a SharePoint architect, I occasionally find myself making assumptions. It's sort of like dark matter: we only know it's there because it has to be there; it makes all the math work out. Coming from a development background, I know an awful lot about web parts, feature receivers, client objet models, timer jobs, and so on: all of the code-based galaxies of SharePoint.

However, there are distant "SPStars" out there that I've only gazed at through a telescope; they are too far away from my .NET home planet to see clearly in the least, let along directly observe in the most. These are things like taxonomy, FAST search, BCS, workflow, and so on: galaxies of SharePoint about which I only know what I've had to know to successfully implement them on projects. This varies from code, which I know pervasively and can speak to, estimate against, and work with assumptionlessly.

But for these more ancillary technologies, I can only advise from first hand (and occasionally leverage trusted second hand) experience. The rest is assumptive. BCS is great example. I know that it can be used to index external data for SharePoint search integration. But I've only done it once. If I had to estimate how long it would take to accomplish this a second time, I would have to assume that it would be no longer than the first go-around. But until I've worked with BCS for ten years like I have with .NET, and it is second nature (or even first nature, as it is with me and code) there would be a lot of assumptions.

I want to close out my series about SharePoint Designer / Developer hybrid team development with a piece about assumptions. And SharePoint. And workflow. And how the former crushed the connection between the two latter.

My role on this project as architect was basically to make sure that all requirements deemed "code-ish" were implemented by my developers. In addition, I had to facilitate all things "SharePoint Designer-ish" being integrated into our Visual Studio-based WSP deployment. This was a balls-to-wall deployment, with code-provisioned site structure, taxonomy-guid-matching-across-environment features, and more PowerShell than I ever thought I'd know.

It was also technically challenging, making sure that page layouts, content types, site columns, and other artifacts that could have been provisioned manually in the environment were not blown away by our WSPs. It also required a lot of syncing of HTML, CSS, images, etc. across Email, SharePoint Designer, and TFS. It was a large team with a large range of SharePoint knowledge and toolsets, and it was my job to keep them all chugging along together.

So when the workflow phase of the project plan commenced, I thought that this would be the most elegant example of SharePoint Designer / Developer coordination. I thought that this would demonstrate the true value of my automated deployments.

I thought that it would work.

But my assumptions were horribly wrong. And time consuming. And expensive. And frankly, quite depressing at times. So following is a multi-parter about the problem in the first place, the solution in the second place, and the conclusion in the third place.

We did basically get it to work, technically, but the one feature we needed and couldn't get working was the show-stopper (at the time of this writing, our workflow designer is connected to one of the client's production SharePoint web front end servers, manually configuring a workflow in SharePoint Designer) that made us, after over two months of technical, political, business, and ideological discussions and debates, pull the plug from importing SharePoint Designer 2010 (SPD heretofore) workflows (WF) into Visual Studio 2010 (of course VS).

</Spoiler Alert>

The Assumption

Being in VS all day, I always feel a little miffed and unadventurous scrolling through all the project and item templates I've never touched. Like despite how much WCF I've done over the years, I've never created a "WCF Workflow Service Application" project or an "AJAX-Enabled WCF Service" item. And under the "Data" section there's a "Service-based Database." That sounds cool, but I don't even know what it is. Anyway, spending a lot of time in the SharePoint -> 2010 templates, I've always seen the two "import" project templates, one for WF and one for general WSPs.

On the day this whole mess started, over three months ago now, I had just completed my final deployment proof of concept, (POC) and was feeling great about the things I could accomplish and the time I could save with my toolset. Sitting next to my WF designer, I realized that amidst all this SPD integration, WF was the only thing that we planned to deploy separately from the rest of the application. One-offs never sit well with me, so remembering seeing those VS templates and feeling super confident about my deployment machine, two things happened simultaneously:

I assumed that the "Import Reusable Workflow" VS project template would create a VS project capable of importing a reusable workflow.
I promised my team and my client that I would be able to use this tool to assimilate WF into VS and our deployment proper.

It was a fine day and I felt really good about my plan. This was, unfortunately, the best I'd ever feel about it. As I set about proving this out, my WF designer referred me to a few articles she'd found (one even written by someone she knew) about SPD VS WF integration. She was as excited as I was about this deployment: it meant she would only have to do the work once (verses having to reproduce her WFs manually in each target environment) and that she could learn a thing or two about how her WFs fit into the larger application by way of deployment.

The Problem

Full of excitement for a one hundred percent automated SharePoint deployment mechanism, I had her package up her WF as a WSP via SPD, and shoot me the file. I created a new "Import Reusable Workflow" project, went through the wizard, sucked in the WSP, and watched as VS created a SharePoint 2010 project and provisioned and configured all the necessary structure to represent an SPD WF. "This is awesome," I remember thinking. Right-click on the project, select "Package," and update my PowerShell script to include this with the rest of the solutions. "This will take like ten minutes!"

So I right clicked, packaged, but no packaging occurred; it didn't even compile. Ten minutes become an hour, most of which I spent digging around the GAC and ISAPI for DLLs. Yet I remained undeterred and finally got it to compile and package. Moment of truth: I turned the crank of my deployment, and the WSP was successfully added and deployed. Things were looking really good.

Then on the site, I was able to activate the web-scoped feature that was provisioned, and the WF was visible on lists. But that's as far as I got when the troubles began. I couldn't associate or instantiate the WF. (Read about these here and here.) Then I learned that I was too quick to glaze over the fact that it was a web-scoped feature; the WFs were not available on any sub sites. Then there's the fact that updates didn't really work as desired: upon the second deployment, it was reported that one environment, out of the box site columns disappeared, and in another a content type refused to redeploy.

I think these assets didn't uninstall during a retraction because they were in use, and the VS WSP deployment failed upon redeployment because an object with the same Id already existed. This is something I call "deployment limbo" when uninstallation fails, causing reinstallation to fail, leaving you with a broken component that you can't remove or update. The fix is to blow away the site collection, turn off VS feature auto activation, fix your logic, and redeploy manually via PowerShell.

So the ten minutes that became one hour quickly bloated into two days, and I still couldn't get InfoPath to deploy (read the above links for the back story on that issue). I consulted the aforementioned articles m WF designer gave me, but they all had the same story: import, click next a few times, and you've got it. I'm not sure what's special about our WFs in general or the SPD export process and the VS import process specifically, but somewhere along the way, I ran into many difficulties that apparently no one's seen before.

So why not just bail at this point? Because after getting my client excited about having the WF logic in VS, they quickly stipulated that they didn't want to support SPD at all, since they didn't have the in-house expertise for that tool. So our approach was to have them built in SPD, exported to VS, and then deployment and updated from there. Being in TFS, all code was in one "collaborative" place, and all deployments were automated and repeatable. If the WFs were outside of TFS, then they would have had to maintain the website using two different tools, one of which (SPD) required the manual touching of production.

Another thing to note is that even if everything worked via VS, I don't think that, in hind sight, it would have been a feasible tool to update the WFs. The XOML file designer, once imported into VS, is MONSTEROUS. A simple SPD WF generates many hundreds of activities, including several depths of nested container elements. If I didn't have 8GB RAM on my machine, I'm not sure if it would have been able to handle VS' WF designer while running SharePoint, SQL, and everything else you'd find on a development machine. Even if SharePoint WF is already in your wheel house, it's still probably easier to tweak these things in SPD manually than shuffle through this monstrosity of a designer.

Plus, of course, I hate reneging on above-and-beyond, gold-plated features. If I mention it, I'll build it. So I decided that since I was already two days overinvested in this approach, I might as well exhaust my ideas before bailing. So I went through the import process again, redeployed, and strangely enough, saw things working! What happened? Well, I recalled that the wizard seamed a bit different, and the project structure seemed a bit different too. Turns out, I used the "Import SharePoint Solution Package" by accident!

Although this approach was still flawed (provisioning web-scoped features, occasionally running into an error that the file paths were too long, updates not taking, and a few other small things) it provided the repeatable TFS development experience that our client was assured. However, what brought this approach to its knees wasn't the deployment itself, but rather the apparent bugginess of the WFs.

When created manually in the WF designer's SharePoint environment, (which was a VM) everything worked. However, when it was put into VS and deployed to our development environment, we'd experience sporadic issues. And what's super weird is the WFs would fail with different errors on different servers. These include Emails not being sent, tasks not being created, InfoPath forms not being deployed, WFs themselves not being visible on the association page for a list, and others.

Whereas any developer who uttered the dreaded phrase "but it worked on my machine" would be chastised for not writing robust enough code, the same symptom here could be caused by the deployment, by SharePoint, by Windows Workflow Foundation, or any of the other technologies playing a role here. So my claims of "bug in workflow" were countered with "bug in deployment."

But instead of allowing the team mojo to be muddled with politics and finger pointing, we decided on another approach: call Microsoft. We were looking for three things from them: first, that the process of importing SPD WFs into VS was the recommend approach; second, that creating WFs in SPD, exporting to WSPs, and deploying those was a supported approach; and third how to fix the integration issue we were having.

To make a long story anticlimactic, we did get the validation we were looking for with regard to the first two issues. I was told that SPD was a home run for "simple" WFs, although "simple" is indeed a subjective adjective. Is a WF that performs twenty simple tasks itself therefore simple? In an case, when things get complicated, it's time to turn to VS. And not just for the added goodies of WSP deployments and TFS integration; it's simple a more robust tool. Even though SPD 2010 is way more stable than 2007, (in my experience) I still find myself having to close out and reopen my site at least twice an hour. The main reason those "import" VS project templates even exist is to promote VS as the tool for complex WFs, even if they were created in SPD.

So thanks Microsoft, at least our heads (and certainly our hearts) were in the right place. But now what about the third question: getting this thing working? After several more phone calls and Emails about the proper process for this integration, and spending a lot of time testing, tweaking, and expanding upon it with my own improvements, I'm able to present Part 2 of this post: the solution. Like I said: it's not perfect. And like I haven't said: it's approximately 80 steps long. But regardless, in Part 2, I'll discuss in more detail the technical issues we encountered, and the step-by-step that almost addresses them.

The Conclusion

We don't need to review the procedure to discuss the outcome. Basically, my attitude is that if it's not one hundred percent correct, then it's wrong. Even if you're left with a happy client, it's still not right. Unfortunately, I have to voice a vote of no confidence in SPD WFs. If you need workflow, either build it in VS from scratch, buy it from Nintex or K2, or design it as a timer job, feature receiver, or something else. The VS import tools simply can't handle complex WFs, regardless of what "complex" means.

So if you're building "simple" WFs, then perhaps VS isn't even part of your project, or your world; in any case, considering all of the best practices it requires you to ignore, building your simple WFs in SPD manually and rolling updates on each environment separately might very well be the deployment mechanism that makes the most sense. And as far as assumptions go, you have to trust your tools in the first place, and learn from the experiences in which they fail you in the second place.

Cache Busting With The SharePoint CssRegistration Control

Chris Domino — Fri, 24 Feb 2012 23:53:00 GMT

During the development cycle of my latest SharePoint project, we kept getting the same bug reported by the client: a lot of the branding updates weren't visible after refreshing their browsers upon a deployment. The obvious reaction is to have them do a Control + F5 (IE only in this particular client) first, and then panic if that doesn't work. Well, it always worked, so we never panicked, and like any other bug that isn't immediately apparent to end users, this issue slowly became a lower and lower priority.

Then as we were going live, the client suddenly realized that this might be a larger problem in the field, as we did a lot of UAT with some stakeholders and didn't want them to see old CSS, JavaScript, etc. And running into people's offices to hit Control + F5 for them was not an option either. So the solution we came up with was to do some cache busting. In a standard SharePoint site, peeking behind the scenes via a view source or developer toolbar, you can see "?rev=[a bunch of random characters]" appended to the URLs of static assets.

So we created a feature that deployed an SPWebConfigModification to our web app that stored a revision number (set programmatically to the short date of the latest build). Next we rolled a static property that exposed this as a querystring parameter ready to be tacked onto the end of URLs either via code behind or <% %> tags. Finally we went through our code, and updated all "loose" script tags and CSS includes to consume this (we have a lot of dynamic theming going on). However, we omitted this step for any existing ScriptLink or CssRegistration tags, since they do that automatically.

Or so I thought.

Actually, ScriptLink does the "rev" thing just fine; tacking on a querystring value that "busts" the browser cache by making it technically a new URL. I just assumed that CssRegistration provided this kindness for us, but not so much. Looking back over all the SharePoint projects I've done, I feel like I now owe some old clients a few Control + F5's. No big deal though; just append our cache busting logic to the "Name" property of our CSS controls (which stores the URL to the CSS) in code, redeploy, and be done.

Or, again, so I thought.

<EDIT>

After discussing this with Jonathan Rupp (great developer) and Jim Noellsch (great hair) I learned that CssRegistration does indeed have native support for cache busting. Instead of a normal relative URL to a CSS file in the 14 mapped layouts folder, (presumably _layouts/[name of feature]/styles/[name of file].css) you need to set the "Name" property to "../../[name of feature]/styles/[name of file].css" instead. This causes CssRegistration to render a link tag with a value of "/_layouts/1033/styles/../../[name of feature]/styles/[name of file].css?rev=[some hash of the current content of the file]" for the href.

Even though standard WSP deployment doesn't put anything in the 1033/styles folder in 14, the "../../" parent directory fixes it, while preserving the apparent format the CssRegistration control needs to do its cache busting. When the contents of the file changes, the rev querystring value hash changes, and the cache is busted. Otherwise, the "old" CSS file is loaded by your browser. But keep reading for a different, code-based approach, which I usually prefer to markup anyway.

</EDIT>

We had these URLs set in the HTML for the "Name" property of our CssRegistrations, so in the code behind of the corresponding pages, we programmatically appended our query string to this value. When we tested, we apparently didn't have any new noticeable CSS changes, so we didn't notice that this wasn't working. After the bug was reported that new CSS still wasn't being manifested, I did a view source, and sure enough, CssRegistration tags didn't have the cache buster URL. So I figured that the hard-coded value in the HTML was winning over the code behind (set in page load) so I redeployed with no Name property in the controls, and the URL completely set in code.

So that didn't work. It turns out the answer was to dynamically create the CssRegistration controls in the page load event, and set everything programmatically as follows:



	//cache buster this.Controls.Add(new CssRegistration() { After = "corev4.css", EnableTheming = false, Name = string.Concat("/_layouts/website/styles/site.css?cachebuster=", ConfigurationManager.AppSettings["CacheBuster"]) });

And there you have it: cache busting CSS using the SharePoint CssRegistration control. This works great; end users never see old CSS. And, by programmatically setting the web.config value in our feature, we get a nice correlation between builds and cache busting URLs. I swore that the CssRegistration control did this out of the box, so it's possible that I'm still missing something and re-inventing the wheel. However, this simple architecture can be applied to any asset included in your site, so there's still plenty of value.

Have fun busting some cache!

Assign a Custom Content Type to Task Process in a SharePoint Designer 2010 workflow

Kim Frehe — Tue, 21 Feb 2012 20:17:00 GMT

SharePoint Designer 2010 has some awesome new features! Two of my favorites are (1) the ability to copy and modify an out of the box workflow and (2) the custom task processes.

What I don’t love is the way SharePoint assigns names with spacing to these tasks that have “_X0028_” and “_X0029_copy” in it. It can cause problems with importing the workflow into Visual Studio, referring to the content type in custom web parts, and as an architect, I just don’t like the way it looks too messy. Plus, if I want to make changes to the task list or roll the task up in a web part, I don’t want to have to guess which task goes with which workflow.

Here is an example of what SPD does when it adds a custom task action to a workflow or when you copy out of the box (OOB) workflow:

And this is what I want it to look like:

And it’s not just aesthetics; I have certain fields that I want to be able to store in the task. I know that I can assign them in the workflow task process, but I don’t want the end user to see them so I want them hidden.

Here are the steps:

1. Create your custom content type at your parent site (or content hub).

· Important note: If you are going to be exporting your workflows to other environment (i.e. local to production) and you do not use a content type hub, I STRONGLY recommend creating these content types and any site columns associated with the workflow with code. This will ensure that your GUID’s (custom ID’s) are the same across all environments.

- I worked with a developer to create my site columns and content types for me since we are moving workflows across environments

- If you do not have access to a developer, then you will need to replicate these steps in each environment to make sure the ID’s are correct for each.

2. Optional Step: If you want the “Claim Task”, Custom Outcomes functionality, and the ability to Reassign or Request Changes that comes with the out of the box workflow tasks for Enterprise SharePoint, you will need to change the display and edit forms. If not, you can skip this step.

Example of InfoPath display form vs .aspx display form

· If you create the content type in Code, make sure the display and edit form properties include “_layouts/WrkTaskIP.aspx”

· If you create the content type by hand (or did not assign a display/edit form specification in the code), open the content type in Designer and change the display and edit form to “_layouts/WrkTaskIP.aspx” under “Forms” on the right side of the screen.

3. Create your workflow

· Either Copy and Modify an out of the box workflow

· OR Create a new workflow and add a custom task process – Start Approval Process, Start Custom Task Process or Start Feedback Process

- (I have not tested this with the other task actions)

4. Save the workflow, but do not publish it.

· NOTE: If you have published it and have the odd-named content type, just delete that task form. We will generate a new task form at the end.

- This odd-named content type will exist in your Content types library until you delete it from there

5. Open the custom content type you created in Designer and Copy the ID

6. Go to All Files, Workflows, <WorkflowName> folder

· Note: If the “All Files” folder looks empty, click on another folder, such as subsites, and select “All Files” again.

7. Open the file that ends in “.wfconfig.xml” and replace the following items:

· Line 2: TaskContentType=”<ID>” with your custom content type

· Line 4: ContentType Name=”<Name>” with your custom content type name

· Line 4: ContentTypeID = “<ID>” with your content type ID you copied from previous step

· Line 4: WorkflowForm= “Workflows/<workflowname>/<contenttypename.xsn>” with your content type name (just the name of the form, leave the folder name as is

Here is what it should look like (my content type is “IntakeReviewTask”)

*Line 2 not pictured

8. Save the the xml file and go back to your workflow folder

9. Hover over the file that ends in “.xoml” file and select “Open with” -> “2. SharePoint Designer (Open as XML)”.

10. Click (Ctrl+F) for Find and enter “ContentType” in the “Find what” box

11. Replace the ContentTypeID=”ID” with your custom content ID

12. CLOSE SharePoint Designer and re-open it.

· Refreshing has not worked for me.

13. Open Designer, open your workflow by clicking on “Workflows” and Save your file. Click “No” if you receive any messages to replace your file.

14. Publish your workflow. The right side of the picture below shows my workflow after completing this process.

And Voila, no more messy names and you can use your custom content type for whatever you may need, displayed in a CQWP, for example.

The "No Code" way to Customize FAST Search - Part 1 - Search Results

Kathryn Ciaralli — Tue, 21 Feb 2012 15:17:00 GMT

SharePoint Search can be a great way to elevate the findability of content to a whole new level; even better, it's easily customizable. I used to think about FAST Search customization in the sense that they can only be achieved via code or PowerShell, and to some degree, that's correct. However, there's a lot that can be implemented to enhance the search experience: results, best bets, user targeting, and even document/site promotion and demotion...without writing a drop of code. This is the first of a series, today we will be covering customizing the search results set.

First - a good resources on how to customize (and troubleshoot) SharePoint search using XSLT. A lot of the results customization is very similar to traditional search, with a few exceptions...as such, we won't cover XSLT updates here, short of a few tips.

Let's take a practical scenario - perhaps we want to display different things based on the content types within the FAST Search results - how would we do that?

Create the managed property
Update our search results web part to consume the column and update the XSLT to display the results

Step 1 - Create the Managed Property
Creating a managed property in FAST is a little different than in traditional SharePoint search, and it can be a bit confusing.

Log into Central Admin
Navigate to the FAST Query Service
In the left nav, select "FAST Search Administration" (yes, FAST Search Administration...don't go straight to the Metadata Properties area of the FAST Query Service)
Under Property Management, select "Managed Properties"
On the Managed Properties page, select "Add Managed Property"
In this scenario - we want to add a property called "ContentTypeQuery"; on the add property page:
- TIP - there is already a Content Type managed property, however, you are not able to use this in your search results, so you must create a new one
- Give the property a name, such as ContentTypeQuery
- Set the type to "Text"
- Add mapping and point to "ows_ContentType"
- Set additional properties where applicable (in our case, we just want to display the field in our search results, there is no need to activate the other properties):
  - Sort - if this is a parameter that the search results can be sorted by
  - Query - if you are performing property queries from Advanced Search (or other scenarios)
  - Refinement - if you want this to display in the refinement panel
- Click OK
Conduct a full crawl

Step 2 - Update our search results web part to consume the column and update the XSLT to display the results
Now that our managed property has been created, we need to inform the search results web part that it exists, and pass it on to the search results. Generally speaking, I prefer to use a customized federated location to house search result columns and xslt as it's a better way to disseminate these settings, especially if there are multiple search result pages, or multiple site collections within a farm. For the purpose of this example, I will not be using a federated location, but rather editing the search results web part directly (which, is a great way to test!).

Navigate to your FAST search results page
Edit the page, then edit the "Search Core Results" web part
Expand the "Display Properties" section
- Uncheck the "Use Location Visualization" box (which allows overrides of the federated location)
- Add the column to Fetched Properties
  - Click into the "Fetched Properties" text box and copy all contents to your clipboard, paste it into Notepad (for easier editing)
    - At the end of the XML, before the </Columns> tag, add: <Column Name="ContentTypeQuery"/>
      - Copy from Notepad, and paste it back into the Fetched Properties text box
- Customize the XSLT Search results
  - Click on the XSL Editor
  - Copy/Paste into Notepad or SharePoint Designer - somewhere to make the formatting easier
  - Make the XSLT Updates as needed (there's a whole slew of ways to do this)
    - TIP - the reference to columns in the XSLT is case sensitive...but not in the way one would think. Any references to columns within the Search Results XSLT must be all lowercase, regardless of the way the property is configured.
    - TIP - you do not need to add the property to the top of the XSL file in order to use it within
    - In my case, I was performing some if logic around my content types, which ended up looking like this in the XSLT
  - Copy/Paste back into the XSL editor of the web part
  - Click OK
Save and Publish the page

With the above information, especially the tips, you can add almost anything to your search results, change up the view, and styling, etc. Some common elements to update:

Ratings
Description or other pertinent metadata
Cusotmized xslt in the event we see a task or calendar item (based on content type)
Remove fields that are no longer needed

Happy (no code) customizing! In the next series we will review additional no code customizations around keywords and best bets for FAST.

Chicago SharePoint Business Strategies User Group Presentation: Intro to CQWP

Kim Frehe — Mon, 20 Feb 2012 17:14:00 GMT

I was honored to give a presentation at the February 2012 Chicago Microsoft SharePoint Business Strategies User Group meeting. It was a great group and I had a lot of fun talking about my favorite subject, SharePoint, and my favorite web part, the 2010 Content Query Web Part (CQWP).

A few attendees asked for the slides so I thought I’d post them here for everyone. The notes view will show you my some of my comments, and the examples should be self-explanatory. If not, please feel free to let me know at kfrehe@rightpoint.com.

To summarize, the CQWP is a powerful tool that SharePoint provides, out of the box, to give you access to information across your site collection. The CQWP collects information and displays it for you in one web part on a page, where you can then group, filter and sort the information in a meaningful way.

This presentation:

· Gives a high level overview of what the CQWP is,

· Shows some examples of how we have used the CQWP internally and on some of our projects,

· Includes print screens with descriptions of adding a web part to a page,

· Provides requirements for having access to create and use CQWP’s,

· Offers some tips and tricks for using the CQWP.

Link to Presentation

Enjoy!

To join our next Chicago Microsoft SharePoint Business Strategies User Group meeting, held on the 2^nd Tuesday of the month, please sign up at http://www.meetup.com/sharepoint . The topics change every month and are listed one month prior to the meeting date.

Manage Content Owners with the Content Query Web Part (CQWP)

Kim Frehe — Wed, 15 Feb 2012 17:11:00 GMT

The CQWP is my absolute favorite out of the box web part. There are so many things that you can do with it. There are lots of great blogs out there describing how you can present information to your end user with the CQWP, but did you know that you can also use it to determine how your content owners are using their sites? Are they entering the type of data that you expected them to when you created your form? Do content owners understand the importance of certain processes, such as clicking on “Publish” to make a page visible to readers? Did your users really “get” the training that you gave them?

The current project I am working on is getting ready for a huge launch. It is a publishing site with minor and major versioning turned on for Pages and Document Libraries. It is one parent site with 100+ sub-sites, each containing hundreds of pages and documents. We created a custom web part for content owners to link to other pages in the site collection. This web part is really cool in that it shows the name of the page or document, the date it was reviewed, user ratings, a brief summary of the content and a link to the page or document. We want to give the reader some useful information about the link before they decide to click on it.

With so much content in the site, we are relying on content owners to enter information about the content in a field that will be displayed in FAST Search and will also be displayed in the custom web part to link to related content. The web part respects security, meaning a user must have access to the content in order to view the description in the web part. With a big launch coming up, I wanted to do a content check to see how we are doing. I don’t have time to go randomly clicking around on all these sites, so I created a couple of CQWP’s in order to see how the site is being populated. They also ended up helping our development team complete a final review of our work.

If you’re new the CQWP, it is a web part that you can add to a web part page that can ask all of the sites in your site collection to give you a certain kind of information.

For example, if this wall of candy dispensers is your site collection, with each dispenser being one site:

Then this is the CQWP:

It has done all the work for you and grabbed multiple types of candies for you to consume quickly. Yes, I could go to each tube and grab a little from each…but that just takes way too long and I want my candy NOW J. With the CQWP you can filter your candy to get the specific ones that you need (if you don’t want the brown ones you don’t have to have them).

The CQWP is out of the box when the publishing feature is turned on, and it’s pretty quick to configure, especially with practice. Here are some examples of how I was able to spend a few minutes looking at how the users are using the site and avoid deployment issues. All of these queries were done in a browser, with no .xslt edits. Each took no more than 15 minutes to configure, check, adjust, check, etc. to show exactly what I want on the page.

· Check on published versions

o Created 2 queries, one for all “Pages” libraries and one for all “Document Libraries” across the site collection, filtered by version is less than 1.0 and displays the last person that modified the content.

o Problem Avoided: Users not being able to access pages with page not found error, access denied errors and empty custom web parts

§ In order for a site reader to see a page or document the user must publish a page, or check in a major version.

· This makes the version 1.0 (or 2.0, 3.0, etc. as you publish major versions…drafts always have a decimal). A document that does not have a published version will have a version less than 1.0, which is why I filtered for by version.

§ There were over 400 pages and documents that did not have a published version just two weeks before go live

· View user-completed fields

o Created 2 queries, one for all “Pages” libraries and one for all “Document Libraries” across the site collection, which display the page title and our custom summary field and the content owner.

o Problem Avoided: Poor search results, poor cross-site link descriptions

§ There were over 300 items with “-“, an incomplete description or a duplicate description in the summary field that is displayed in our custom web part and search results.

· Validation or unique values were not viable options in this case.

· Discover users storing documents in wrong locations

o Created one query for all sites, grouped by Page Layout, which showed users were putting Word and .pdf documents in their Pages Libraries (since they had no page layout)

o Problem avoided: Documents stored in wrong locations would not display correctly to the end user

§ We created Pages Libraries for publishing pages and Document Libraries for all stand-alone documents. All documents are presented with a custom page that displays certain properties, taxonomy, user comments and ratings.

The overall outcome of these CQWP’s is that we were able to target the users that needed additional training tips in order to make sure their content is not only visible, but findable for end users on launch day.

Additionally, CQWP’s helped our development team to create a better product:

· Monitor page layout usage and react

o This was a unique project where editors were adding content while we were developing the site. By creating CQWP’s that grouped all Pages by Page Layout we were able to:

§ View how users are actually using the page layouts we designed with content and adjust as needed

§ Allow our front end developer to make changes to design based on usage

§ Allow our back-end developers easy access to test the pages and how they worked with our custom controls and actual content

If you’re not familiar with the content query web part, I strongly recommend spending some time getting to know this very powerful web part. It has been the fastest way for me to get feedback on what’s going on in our sites, so that we can address training issues, user adoption and design before they become a problem.

PowerShell Automatic Publishing Page Builder for SharePoint 2010

John Wefler — Thu, 09 Feb 2012 14:00:00 GMT

I’ve recently created a handy PowerShell script to create publishing pages for my SharePoint sites. During every project, there comes the time when having a decent sized set of randomized page data will help for various lifecycle phases. I created the script when my team realized a load test of pages was required. We weren’t talking about a couple pages, either. This load test needed to handle up to 1,000 pages in order to collect the data we needed to make educated decisions on particular functionality.

Creating 1,000 pages by hand is beyond tedious. Enough said…

As I thought about my page creator, it had to meet several criteria:

Use script vs. code. Script can be “live” edited, pushed to various systems without complicated governance, and doesn’t need compiling. Since PowerShell can utilize almost any .NET object, it is a clear winner.
Reusable on other projects. Having an auto page builder script in your toolbox can be handy for many types of projects. The script I created should be able to be used on any SharePoint 2010 deployment without the need for extensive editing.
Support a decent level of randomness. It would be pretty easy to create pages, and copy them using SharePoint Designer. You’d end up with lots of files with “Copy” in the name and title. The auto page builder creates random names and titles based on the system time variable. It also inserts random field data when available. See the “Nuts and Bolts” below for more details.
Support many field types. Most of the pain in creating any tool that inserts SharePoint data is getting the data formatting right for different fields. The auto page builder so far handles Text, Note, HTML, Taxonomy, DateTime, User, URL, Summary Links. Future releases should be able to handle Lookup and Choice fields.
Easy to use. With script comments, hopefully the auto page builder should be easy to use for all types of administrative users.

Nuts and Bolts

The automatic page builder was created on the simplicity principle. You feed it a publishing web and a page layout, and the script will try its best to do the rest for you. From the page layout the script determines the content type. The script iterates through each column (or field) in the defined content type and attempts to add data to that column on a new page based on its column type. In many cases this data is random.

Managed Metadata

The auto page builder supports single and multi-select taxonomy fields types. It will select an random value for these fields. I left some script lines commented out in the managed metadata field propagation function that can add every possible value to a multi-select taxonomy field, in case you want that type of data.

People and Groups

The auto page builder can find an select a single random user account from SharePoint user profile manager. This code is commented out by default in favor of a single guaranteed good account: "SharePoint\System”. (The auto page builder does not yet support groups assigned to a People and Groups field.)

Ratings

The auto page builder can attempt to add a random rating record for each page built. This rating will come from the administrative local account running the script. Warning! Ratings are not immediately available and depend on the social rating synchronization timer job which runs every 60 minutes.

Notes on Script

Line 52: The script really begins here. The first block is a function to handle data for taxonomy fields.

Variables to Set (I should have used args, but I use the PS ISE exclusively)

Line 56: The “iterations” variable. How many iterations, or pages do you wish to create?

Line 57: The “weburl” variable. This will be the path to publishing web.

Line 58: The “siteurl” variable. This is the path to the root web.

Line 59: The “pagelayoutname” variable. This is the Title of the page layout you want to use to create pages. From the page layout, the script determines the Content Type and therefore the subset of columns to try to fill with data.

Other Notes

Lines 14 – 20: This is a commented out piece of example code that will add each piece of available managed metadata to a field.

Line 136: There is a reference to “demohtml.txt” which is a text file with HTML markup to insert into an HTML field type. An example of this file is pasted below.

Lines 156-161: This is a commented out piece of example code that will drop a random SPUser object into a “User” field.

Download the script -> HERE

The Script

   1:  function GetRandomMetadata ($item, $site, $taxString)

   2:  {

   3:      # 1) Set a taxonomy field to the Title of a taxonomy field in the list

   4:      $taxField = [Microsoft.SharePoint.Taxonomy.TaxonomyField]$item.Fields[$taxString];

5:

   6:      # 2) From properties of the taxField determine the term store and term set from the site

   7:      $taxSession = new-object Microsoft.SharePoint.Taxonomy.TaxonomySession($site);

   8:      $termStore = $taxSession.TermStores[$taxField.SspId];

   9:      $termSet = $termStore.GetTermSet($taxField.TermSetId);

10:

  11:      # 3) Set a taxonomy field collection to collect values

  12:      $taxCollection = new-object Microsoft.SharePoint.Taxonomy.TaxonomyFieldValueCollection($taxField);

13:

  14:      # 4) Add all values to the collection (Commented out)

  15:      #$termSet.GetAllTerms() | ForEach-Object {

  16:      #    $taxonomyFieldValue = new-object Microsoft.SharePoint.Taxonomy.TaxonomyFieldValue($taxField);

  17:      #    $taxonomyFieldValue.TermGuid = $_.Id;

  18:      #    $taxonomyFieldValue.Label = $_.Name;

  19:      #    $taxCollection.Add($taxonomyFieldValue);

  20:      #}

21:

  22:      # 4 Alt)  Pick a random term to set.

  23:      $allTerms = $termSet.GetAllTerms();

24:

  25:      # Gets random term in the termset collection.  (Cool factor 10!)

  26:      $thisTerm = $allterms | Get-Random;

27:

  28:      $taxonomyFieldValue = new-object Microsoft.SharePoint.Taxonomy.TaxonomyFieldValue($taxField);

  29:      $taxonomyFieldValue.TermGuid = $thisTerm.Id;

  30:      $taxonomyFieldValue.Label = $thisTerm.Name;

  31:      $taxCollection.Add($taxonomyFieldValue);

32:

  33:      $thisName = $thisTerm.Name;

34:

  35:      #Write-Host "Metadata for field '$taxString' set to $thisName ..."

36:

  37:      # 5) Set the value of the field in SharePoint

  38:      # Note:  this handles two types of MMD fields, the single and the multiselect

  39:      if ($taxField.TypeAsString -eq "TaxonomyFieldType")

  40:      {

  41:          #Write-Host "Taxonomy Singleton Type Found!";

  42:          $taxField.SetFieldValue($item, $taxonomyFieldValue);

  43:      }

  44:      else

  45:      {

  46:          $taxField.SetFieldValue($item, $taxCollection);

  47:      }

  48:  }

  49:  # END *Get Random Metadata* #

50:

51:

  52:  # MAIN ##################################################

53:

  54:  # Set VARS

55:

  56:  $iterations = 1

  57:  $weburl = “http://wef.local/pubtest2/” #ensure trailing "/"

  58:  $siteurl = “http://wef.local/”

  59:  $pagelayoutname = "Resource"

60:

61:

  62:  # Constants: don't change

  63:  $loremText = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";

64:

  65:  #ensure sharepoint

  66:  Write-Host("Loading SharePoint...");

  67:  if((Get-PSSnapin Microsoft.Sharepoint.Powershell -ErrorAction SilentlyContinue) -eq $null)

  68:  {

  69:      #load snapin

  70:      Add-PSSnapin Microsoft.SharePoint.Powershell;

  71:  }

72:

  73:  # Get publishing web

  74:  $SPWeb = Get-SPWeb -Identity $weburl

  75:  $site = New-Object Microsoft.SharePoint.SPSite($siteurl)

  76:  $web = $site.rootweb

  77:  $pSite = New-Object Microsoft.SharePoint.Publishing.PublishingSite($site)

  78:  $pWeb = [Microsoft.SharePoint.Publishing.PublishingWeb]::GetPublishingWeb($SPWeb)

  79:  $serviceContext = Get-SPServiceContext $site

  80:  $pages = $pWeb.GetPublishingPages($pWeb)

81:

  82:  # Determine Content Type and Page Layout

  83:  $pl = $pSite.GetPageLayouts($false) | Where { $_.Title -eq $pagelayoutname }

  84:  if (-not($pl)) { throw "Page Layout not found!" }

  85:  $plName = $pl.Name;

  86:  Write-Host "Page Layout defined as $plName";

87:

  88:  $contentType = $pl.AssociatedContentType

89:

  90:  $i = 1

91:

  92:  while ($i -le $iterations) {

93:

  94:  Write-Host "Iteration $i of $iterations"

95:

  96:  #Set URL of new page to UNIX time var with concat

  97:  $startTime = Get-Date -Uformat %s

  98:  $uTime = $startTime.ToString().Replace(".","-");

  99:  $PageUrl = "RandomPage-" + $uTime + ".aspx";

 100:  $PageUrl = $PageUrl.Replace("/", "-");

 101:

 102:  $page = $pages.Add($PageUrl, $pl) #URL plus Page Layout

 103:  $page.Update();

 104:

 105:  $item = $page.ListItem;

 106:

 107:  # iterate through each content type field

 108:  $contentType.Fields | ForEach-Object {

 109:

 110:      # ignore read-only and hidden fields

 111:      if ($_.ReadOnlyField -eq "True" -or $_.Hidden -eq "True") { return; }

 112:

 113:      #Set Title because it is special...

 114:      if ($_.StaticName -eq "Title")

 115:      {

 116:          $item[$_.StaticName] = $PageUrl;

 117:          return;

 118:      }

 119:

 120:      #Determine the field type to set appropriate data.

 121:      if ($_.TypeAsString -eq "Text" -and $_.StaticName -ne "Title")

 122:      {

 123:          #Set to Lorem based on $_.MaxLength variable

 124:          $item[$_.StaticName] = $loremText.Substring(0,($_.MaxLength - 1));

 125:          return;

 126:      }

 127:

 128:      if ($_.TypeAsString -eq "Note")

 129:      {

 130:          $item[$_.StaticName] = $loremText;

 131:          return;

 132:      }

 133:

 134:      if ($_.TypeAsString -eq "HTML")

 135:      {

 136:          $item[$_.StaticName] = Get-Content demohtml.txt | out-string;

 137:          return;

 138:      }

 139:

 140:      if ($_.TypeAsString -eq "TaxonomyFieldTypeMulti" -or $_.TypeAsString -eq "TaxonomyFieldType")

 141:      {

 142:          GetRandomMetadata $item $site $_.Title;

 143:          return;

 144:      }

 145:

 146:      if ($_.TypeAsString -eq "DateTime")

 147:      {

 148:          #$thisTime = Get-Date -format s

 149:          #$item[$_.StaticName] = $thisTime;

 150:          $item[$_.StaticName] = [DateTime]::Today.ToString("yyyy-MM-ddTHH:mm:ssZ")

 151:          return;

 152:      }

 153:

 154:      if ($_.TypeAsString -eq "User")

 155:      {

 156:          # Set a random user field

 157:          #$profileManager = New-Object Microsoft.Office.Server.UserProfiles.UserProfileManager($serviceContext)

 158:          #$userProfiles = $profileManager.GetEnumerator();

 159:          #$thisProfile = $userProfiles | Get-Random;

 160:          #$userName = $thisProfile.DisplayName;

 161:          #[Microsoft.SharePoint.SPUser]$spuser = $web.EnsureUser($userName);

 162:

 163:          # Or set a static user

 164:          [Microsoft.SharePoint.SPUser]$spuser = $web.EnsureUser("SharePoint\System");

 165:          $item[$_.StaticName] =  $spuser;

 166:          return;

 167:      }

 168:

 169:      if ($_.TypeAsString -eq "URL")

 170:      {

 171:          $urlField = New-Object Microsoft.SharePoint.SPFieldURLValue

 172:          $urlField.Description = "Rightpoint"

 173:          $urlField.URL = "http://www.rightpoint.com"

 174:          $item[$_.StaticName] =  $urlField;

 175:          return;

 176:      }

 177:

 178:      if ($_.TypeAsString -eq "SummaryLinks")

 179:      {

 180:          $linkField = New-Object Microsoft.SharePoint.Publishing.Fields.SummaryLinkFieldValue

 181:

 182:          $sumLink = New-Object Microsoft.SharePoint.Publishing.SummaryLink Rightpoint

 183:          $sumLink.LinkURL = "http://www.rightpoint.com"

 184:          $linkField.SummaryLinks.Add($sumLink)

 185:

 186:          $sumLink2 = New-Object Microsoft.SharePoint.Publishing.SummaryLink Google

 187:          $sumLink2.LinkURL = "http://www.google.com"

 188:          $linkField.SummaryLinks.Add($sumLink2)

 189:

 190:          $item[$_.StaticName] =  $linkField;

 191:          return;

 192:      }

 193:

 194:      if ($_.TypeAsString -eq "RatingCount")

 195:      {

 196:          # We have a social rating enabled list.  Let's give the item some ratings to help display stars

 197:          $SocialRatingManager = New-Object Microsoft.Office.Server.SocialData.SocialRatingManager($serviceContext);

 198:          [Object]$random = New-Object System.Random

 199:          $rating = $random.Next(1,6);

 200:          $itemURI = $weburl + $item.URL;

 201:          [void]$SocialRatingManager.SetRating($itemURI, $rating)

 202:      }

 203:  }

 204:

 205:  $item.Update();

 206:  Write-Host "Created $($PageUrl)"

 207:

 208:  # Check-in and publish page

 209:  $item.File.CheckIn("");

 210:  $item.File.Publish("");

 211:  if ($item.ListItems.List.EnableModeration) { $item.File.Approve(""); }

 212:

 213:  $endTime = Get-Date -Uformat %s

 214:  $timings = $endTime - $startTime;

 215:  Write-Host "Page $i of $iterations created in $timings seconds"

 216:

 217:  $i++

 218:  } # end iterations

Sample “demohtml.txt”

   1:  <style type="text/css">

   2:   table.tabular{width:95%;border-bottom:1px solid #ccc;background-color:#eee;border-collapse:collapse;margin:20px}

   3:   table.tabular td,table.tabular th{border-top:1px solid #ccc;border-right:1px solid #ccc;padding:3px 20px 3px 3px}

   4:   table.tabular td:first-child,table.tabular th:first-child{border-left:1px solid #ccc}

   5:  </style>

6:

   7:  <table width="100%" cellspacing="1" cellpadding="3" border="0" class="tabular">

   8:      <thead>

   9:          <tr><th>Description</th><th>Result</th></tr>

  10:      </thead>

11:

  12:      <tbody>

  13:          <tr>

  14:              <td>Headings</td>

  15:              <td><h1 style="border:none">Heading 1</h1><h2 style="border:none">Heading 2</h2><h3>Heading 3</h3><h4>Heading 4</h4><h5>Heading 5</h5><h6>Heading 6</h6></td>

  16:          </tr>

  17:          <tr>

  18:              <td>Paragraphs</td>

  19:              <td><p>Normal paragraph text.</p></td>

  20:          </tr>

  21:          <tr>

  22:              <td>Line Break</td>

  23:              <td>I feel a line break coming... <br /> ...up.</td>

  24:         </tr>

  25:          <tr>

  26:              <td>Bold Text</td>

  27:              <td><strong>Bold text.</strong></td>

  28:          </tr>

  29:          <tr>

  30:              <td>Italic Text</td>

  31:              <td><i>Italic text.</i></td>

  32:          </tr>

  33:          <tr>

  34:              <td>Color Text</td>

  35:              <td><p style="color:#000099">Color text.</p></td>

  36:          </tr>

  37:          <tr>

  38:              <td>Text Size</td>

  39:              <td><p style="font-size:18pt">Text size using points.</p><p style="font-size:18px">Text size using pixels.</p><p style="font-size:larger">Text size using relative sizes.</p></td>

  40:          </tr>

  41:          <tr>

  42:      </tbody>

  43:  </table>

Words and Meanings

cquillen — Wed, 01 Feb 2012 18:05:00 GMT

Last Tuesday I attended a Meetup event hosted by David Damaree, of the Chicago-based typography firm Typekit, where he spoke about “Naming Things." The hour focused on the role of naming and domain modeling in making good software and good design. He went through good and bad examples from branding, user experience and code. Sounded pretty awesome but sadly, we mostly just got to hear about the difficulties Typekit had establishing naming conventions on their own website, and how hard it was to decide which definition of “Font” to use. And while that is tricky, since it can mean many things; a metal type character of a single size and style; a digital file of a character set; a database object bla bla bla… I know, I stopped listening too, and I’m a petty big fan of typography.

So the talk wasn’t so great, but alas, what I did find interesting was his use of the Magritte painting “Ceci n’est pas une pipe” to illustrate how words mean different things to different people. While the picture of a pipe isn’t actually a pipe (I love you Magritte) and the letters P-I-P-E also isn’t actually a pipe, it does differentiate that from a cigar. So when you say “pipe” while people will hopefully know that is not a cigar, you also don’t want them to expect a different sort of pipe:

People’s perception of what you are talking about when you say “pipe” will change depending on their understanding of the word, so what is important is to define a word and then establish consistency.

What really drove the point home for me though was the phrasing of the invitation. the event would have drinks and appitizers provided by Groupon, I pictured domestic beer, cheap wine and maybe some cocktails along with some passed hors d’oeuvres, when actually they meant a few liter bottles of diet coke and a pile of empty pizza boxes.

Ah ha! Words mean different things to different people, you say? I see your point, sir, I see your point.

Business Intelligence in Retail. Insights you can count on.

Marcello Benati — Tue, 24 Jan 2012 18:28:00 GMT

BI for retail will be defined by the retailers who have figured out how to maximize customer satisfaction and profitability through the right combination of quality products, friendly and efficient service, unique value, a differentiated shopping experience, and a business model that truly serves the communities they serve -- locally and globally.

How will this be accomplished? It begins with an in depth understanding of the customers and then linking that insight into every decision that is made, from merchandising to marketing to distribution to store operations to finance, so that retailers can predict how to best serve their customers' ever-changing needs and desires.

Our strategy for the future of retail BI provides for that very scenario, through our experience in designing intelligence platforms and our solutions for customer, merchandise, operations, and performance intelligence that are combined in a toolset designed to equip retailers to become truly innovative.

A system that recommends optimized price changes should interface with the price management system, the item master, the system that generates labels, etc.

The Retailers that are Realizing the Most Benefits from BI

Retailers that are realizing the most significant returns on their investments are those that take a purposeful, pragmatic approach to establishing an intelligence platform upon which to base all other BI solutions.

A single, reliable demand forecast, for instance, can also be used in merchandising, marketing, logistics, store operations, call center staffing, etc., for operational benefit.BI that remains segmented by functional area can provide some value, but retailers can realize a much larger return by building the foundation upon which the rest of the house will stand. This is true of both top-tier and midmarket retailers, regardless of segment.

Specific Areas in Which Retailers can Benefit Most Include:

Merchandising-- This is clearly the most important area of a retailer's business and an area where retailers are beginning to exploit the full value of BI. Analysis of past performance, combined with plans and forecasts of trends future customer behavior, leads to more accurate initial allocations of merchandise across channels and stores.

Assortment and size optimization that are based on customer demand patterns ensure that the correct assortments, size, and case-pack distributions get sent to the correct stores. Daily price, promotion, and markdown optimization ensures that items are priced for optimal profitability, both preseason and in season.

Space automation and optimization ensure departmental sales and profit per square foot are maximized, and products are given the correct inventory and space on the shelf or on the rack. Optimized fulfillment ensures that products are allocated or replenished based on demand. Accurate analysis also results in a more efficient use of manpower in picking, packing, and shipping the first wave of product, while minimizing additional, costly payroll expenses to facilitate transfers between stores, vendor returns, changing signage and labels for markdowns, and otherwise correcting mistakes.

Marketing-- By understanding customers better -- whether by profiling, segmenting, gauging propensity to respond, or using market basket analysis -- retailers can create better-defined targeted campaigns, reducing expenses (printing, paper, postage) while increasing response rates, revenues, and gross margins. Also, as retailers gain a better understanding of their customers' buying behavior, this analysis can then be used to create more effective merchandising plans for the next season.

Operations -- Understanding and predicting changes in demand -- by hour, by day, by location, by promotion, by price change-- means that the store floors, the catalog call centers, and the fleet crews delivering replenishment orders from the DC to the store are all appropriately staffed. This understanding also leads to optimal productivity since store-level human capital costs can be scheduled better and managed more efficiently.

The Integrated Solution

It is important to note that a good BI solution will be able to integrate with any other system and platform. That said different BI solutions need to interface with different operational systems for different purposes.

A solution seeking to use customer behavioral data to make better merchandising or marketing decisions needs to interface with sales transaction systems, loyalty systems, in-house credit systems, coupon redemption systems, catalog and Internet customer data systems, and so forth. A system that recommends optimized price changes should interface with the price management system, the item master, the system that generates labels, etc.

There must be a closed-loop interface between the operational systems that retailers rely upon to conduct day-to-day business and the BI systems that help them conduct that business more efficiently and profitably.

SharePoint Saturday Austin Wrap Up

Kim Frehe — Tue, 24 Jan 2012 14:59:00 GMT

Update on February 3, 2012: I have added the Introduction to Content Query Web Part that I presented at this event. Click on the "Attachment" above this text.

----------------------------------------------------------------

SharePoint Saturday Austin (#SPSAusTx) was a fantastic event!

In the last year I have been to 8 SharePoint events and I have to say this was the best that I have been to, and not just because this was my first time being a presenter J. I am an extremely strong supporter of these free community events and have written about my top 5 reasons you should attend a SharePoint Saturday.

I’ll try not to be long winded…so in honor of the Women of SharePoint Panel held at this event…I’ll bullet point the reasons why (not in any particular order, they are all #1’s):

· The Facility – The AT&T Conference Center was beautiful, clean and well organized. The sleeping rooms were fantastic and the meeting rooms were the perfect size to accommodate the large number of attendees.

· The Food – The smorgasbord included healthy alternatives, Texas treats, sandwich stuff, salads, soups, yummy desserts way too much to mention everything. It was beautifully presented and I believe the best buffet I’ve ever had.

· The Weather – yes, it really stank that some of the best speakers got snowed in but it was 7 degrees when I left Chicago and 70 when I got to Austin, so that makes it on this list, sorry Christian Buckly (@buckleyplanet) and Dux Raymond Sy (@meetdux) you were missed and I look forward to seeing you at the next event!

· The Organization – Jim Bob Howard (@jbhoward) and Matthew Lathrop (@MatthewRAX) did a fantastic job period! When you add the last minute pulling-in resources to replace the speakers that Snowpocalypse kept away, it was just amazing. They claimed there were other issues, but they hid them well because I can’t think of anything that wasn’t right.

· The Entertainment - Austin is a great town with some great entertainment…when you add a bunch of SharePoint geeks in there…I just can’t think of anything better!

· The Networking / Social Aspects – There was a great assortment of presenters and attendees. I can’t tell you how awesome it is to have a beer and talk SharePoint and not have your friends look at you like you’re a geek…yes, I KNOW that makes me a geek…but I will happily admit I’m a huge SharePoint geek and talking about it is just FUN for me!

· The Speaker Dinner – It was my first one, so I don’t have anything to compare it to, but the more experienced speakers said it was a good one too! We were bussed to Salt Lick BBQ which was fantastic! I was thrilled to meet a Microsoft MVP Legend, Bill English (@MinnesotaBill) who promised to come speak at our Chicago User Group one day.

· The Women of SharePoint Women’s panel – I had the honor of sitting next to 5 amazing women to answer some thought-provoking questions about being a Woman in a Male-Dominated technology industry. I believe every SharePoint Saturday would benefit from having some kind of Panel Discussion, not just a women’s or leadership panel, but any kind of panel. It was really interesting to see and hear different answers/perspectives to the same question.

- The panel included myself (@chomp1313), Nedra Allmond (@NedraAllmond), Marcy Kellar (@Marcy Kellar), Mistry Rodriguez, and Tiffany Songvilay (@OfficeOverEasy).

- Suzanne George (@SPGenie) did a fantastic job of moderating, in spite of the Chuck Norris joke. We had some great interactions with a wonderful audience!

* Note: the bullet point reference at the beginning of this post is referring to the fact that women have a tendency to want to over-explain in long emails ;-)

· The Presenters – As always, the presenters were top notch. There was a great mix of experienced presenters and new presenters, like me. I really love how supportive the community is of each other. We all work for different companies doing various things. Some companies may even compete against each other, but there is none of that here and I love it! This community is truly unique in the way that we all support and help each other.

· The Attendees – The attendees at this event are always such a good mix of users / providers at every level. These great conversations between sessions, at lunch and at SharePint remind me a few key points about SharePoint in general:

- No one knows everything about every aspect of SharePoint…I believe it is impossible - we all need to specialize in a few key areas and rely on others to specialize in others. That's why we all work so well together.

- What seems easy to you is not easy to someone else with different experiences and vice versa

- There are still people that are just starting out in SharePoint…remember them, they are important

- There are several different ways to reach the same goal in SharePoint, the way you succeed depends on process and the user...make sure the end user is a part of the process

· Presenting - This was the first time I have presented at a SharePoint Event, thanks to Jim Bob Howard's insistence that with 10+ years of SharePoint experience I must have something to say. I had the honor of being able to present an Intro to Content Query Web Parts session. There were a few technical difficulties (user error) and the crowd was extremely helpful and forgiving. The positive feedback I received removes any hesitation I ever had about speaking in public…which is something I never aspired to before. However, SharePoint is something I’m very passionate about and I love talking about it! I am hooked and I will be submitting again!

Well, that pretty much wraps it up. If you’re reading this and you missed it…try to get there next year…it is well worth it! Any of them are, I can honestly say I haven't been to a "bad" one yet. Here's a link to the site to find the closest one to you: http://sharepointsaturday.org/default.aspx

_________________________________________________________________

Past SharePoint Events I have been to since I discovered the awesome SharePoint Community 2011:

1. SPS St. Louis

2. SPTechCon - Boston

3. SPS Houston

4. SPS Chicago

5. SPS New York

6. SharePointFest Chicago

7. SPS DC

8. SPS Austin