• You may want to keep all of the files in one store – being forced to put them into a designated folder is not desired.
• You may want to make some file freely available for some time and lock it after a while, or the other way around (e.g. to allow the robots to crawl it initially). having to move them is just silly and defeats the purpose.

So how do you discriminate the files that you want locked from those that you want to be publically available, and potentially from those that you want only the logged in users to be able to get?

Specifying the EPiServer File Metadata sweetness

One of the potential solutions would be to define a special rights group and check for that group for the people that have your “registered” magic-cookie. That however introduces a bogus group, and I would rather like to avoid that. However if you look into the FileSummary.config file that’s located in your web application folder you will find a slightly mysterious content. A bit of hacking reveals that you can actually add your own metadata to the file. For example adding the access rights based on what I’ve established above would look as follows (the content you can already find in the file that comes with the public templates that-we-all-oh-so-love is skipped):

<root xmlns:xforms="http://www.w3.org/2002/xforms" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <model>
    <instance>
      ...
      <AccessLevel />
    </instance>
  </model>

  ...
  <xforms:select1 appearance="full" 
                  ref="AccessLevel" id="id_field51">
    <xforms:item>
      <xforms:label>Unrestricted</xforms:label>
      <xforms:value>Unrestricted</xforms:value>
    </xforms:item>
    <xforms:item>
      <xforms:label>Requires Registration</xforms:label>
      <xforms:value>RequireRegistration</xforms:value>
    </xforms:item>
    <xforms:item>
      <xforms:label>Requires CMS Login</xforms:label>
      <xforms:value>LoggedUserAccess</xforms:value>
    </xforms:item>
  </xforms:select1>
  ...

</root>

Great. So what does it look in the file manager now?

Splendid!

Accessing the metadata

Now that we gave the user to specify the metadata, we need the VPP to act upon them. For the benefit of automation of parsing I’ve specified the enum defining the access levels as follows:

enum FileAccessLevel
{
    Unrestricted,
    RequireRegistration,
    LoggedUserAccess
}

Now we need to update the GetFile method to discriminate the access levels (I have decorated the core lines with –>) those are the lines that access the meta data based on their format specified in the FileSummary.config.

public override VirtualFile GetFile(string virtualPath)
{
    string handledPath;

    if (TryGetHandledAbsolutePath(virtualPath, out handledPath))
    {
        UnifiedFile file = base.GetFile(virtualPath) as UnifiedFile;

        if (file != null)
        {
            string strAccessLevel = (string) file.Summary.Dictionary["AccessLevel"] ??
                                    FileAccessLevel.RequireRegistration.ToString();
            FileAccessLevel accessLevel = (FileAccessLevel) Enum.Parse(typeof (FileAccessLevel), strAccessLevel);

            bool isLoggedIn = HttpContext.Current.Profile != null && !HttpContext.Current.Profile.IsAnonymous;
            bool isRegistered = HttpContext.Current.Request.Cookies.AllKeys.Contains(PASS_COOKIE_NAME);
            string email = isRegistered ? HttpContext.Current.Request.Cookies[PASS_COOKIE_NAME].Value :
                (isLoggedIn ? HttpContext.Current.Profile.UserName : "unregistered");

            switch (accessLevel)
            {
                case (FileAccessLevel.Unrestricted):
                    return file;
                    break;
                case(FileAccessLevel.RequireRegistration):
                    if (!isRegistered && ! isLoggedIn)
                    {
                        HttpContext.Current.Response.Redirect(
                            string.Format(registrationFormUrl,
                                          HttpContext.Current.Server.HtmlEncode(virtualPath)));
                        return null;
                    }
                    return file;
                    break;
                case(FileAccessLevel.LoggedUserAccess):
                    if (isLoggedIn)
                    {
                        return file;
                    }
                    return null;
                    break;
                default:
                    return file;
            }
        }
    }
    return Previous.GetFile(virtualPath);
}

Now the user is really in control of what is published to the general public and robots, what is protected with the registration form and what is only available to logged in users. (now you may add more granularity with file rights naturally, this is just a basic setting that an editor without administrative rights can add.

Well, not really. By default the framework will be run in the “legacy mode”. Thanks to an old article by our own Marek Blotny, I’ve learned how to build Plugin settings which are just perfect for the purpose!

So to configure and enable the new features you need to open your admin UI and in the “Config” click on the “Plugin Manager” item and select our framework plugin as shown in the picture

The available options are:

Setting Name	Meaning	Sample
Default WebParts Path Pattern	The pattern to be used when no pattern is defined for a page.	%inherit%
WebParts Path Patterns	The semicolon separated pairs of pattern;pattern name; This is the part you will want to customize most.	%template%|%pageid%%legacyregion%;Legacy regionalized;%template%|%pageid%;Legacy globalized;page|%pageid%|%region%;Page/region;pagetype|%pagetypeid%;Page Type
Cache WebParts in Memory	Determines whether the WebParts are to be cached  between usages (this is useful for a small set of WebParts (like a number of sidebars) but rather discouraged if you use the legacy mode as there can be a lot of those in such case.	unchecked by default (check to improve performance in sidebar mode)
Legacy WebParts Support (per-page only)	If checked, disables the extensions described by this blog.	checked by default (uncheck to enable the sidebar extensions)

As shown here:

Once you fill in the settings as they are suggested in the above table the context menu (or adjust to your needs) will show you the new options:

The new sub menu will allow you to change the pattern by which the WebParts are selected, while “Edit Web Parts” option will enable you to edit the WebParts for the current effective WebPart set.

First of all – if you want to select a pattern on a page you need a means of storing it. At this moment The framework does it in a property. Which means – for every page type that wants to redefine the web parts rather than using the default pattern (in our case %inherited%) you need to add String property with a “WebPartsPath” name (I may actually add some routines to add the property definition automatically if there will be enough demand for that).

What does “Effective WebPart Set” mean?

Assuming (which is the most interesting scenario) that %inherit% is the default pattern the following is true:

Once you select the effective web parts for the page or just agree with the WebParts pre-selected for you based on the default path you can edit them just like previously. Mind that when you edit WebParts on a page all the pages that have the same “effective path” are going to change as well. (which was our intention in the first place).

The library extension is going to be posted on Epicode as soon as I get a hold of Steve to approve the changes :)

Hmm…

Is sidebar a part of content? No, rather not. We don’t want the editors to have to setup the sidebar for every article they write (and the site has a few dozens of articles created on it every day).

Is sidebar more of a template thing? Well… more like it, but still… we have articles all over the site with different sidebar elements when the articles are in different parts of the site (ok so we could add rules what controls display in which part of the site). But wait! There’s more! The sidebar will be different for every language (region). Now we’re talking a dozen of templates or a rules engine just to make the sidebar different. Customising the template with properties isn’t ideal either as it makes EPiServer UI very cluttered. Additionally we want to change sidebars across many templates so the whole branch/section of the site will be able to share the same sidebar.

To a degree this is an academic discussion as we’ve been through it with the previous version of the site and we already knew that integrating this stuff into templates just won’t work and we will be in a world of pain just changing the templates over and over adding little tweaks and changes while the customer ads promotions and performs ad campaigns. Well, we can do it, of course, but it’s not a work a programmer will enjoy, and we all want to do new and more exciting things, don’t we?

We have an internally developed  module to make something like that, that is fully home-grown by another internal team (we now have 3 “squads” capable or making incredible things with EPiServer and we tend to share a lot of technologies and try to rotate people around to adopt the good habits and experiences) and I was (and still am) VERY impressed by it. The technology uses EPiServer pages for defining every module (which are located somewhere outside the site root branch. and then you can mix and match them either declaratively in the code) or by handpicking them in the UI. It’s really cool, though, during the discussions it turned out that we might have to add big chunks of functionality and might end up with separate branches of module-pages for different languages/regions, but… frankly… about that time an article by Ted Nyberg reminded me about a technology I have read about quite a while ago in an article by Stein-Viggo Grenersen and ooohhhhhh… I got seduced. I really wanted to try if for a long time and Ted’s article made it a snap to try and get convinced, and more important… convince Stu ;) that it’s the right way to explore.

So I started to dig.

Talked with Steve (the original creator of the Framework) a bit and learned that I can “customize a path rewriter” to suit my needs. Great! I just hoped I won’t have to deal with some nasty GUID’s matching, but no! Turns out, all it takes to identify a WebPart set is to have any unique string naming it.

So basically what we needed was a manager to deal with the naming templates and a way to determine the WebParts set to be used per page.

Till now the framework used template file name followed by the page ID, followed by an eventual language/region if a page was not the master branch, for example:

~/templates/Demo/WebPartPage.aspx|26
~/templates/Demo/WebPartPage.aspx|26|en-us

which makes them unique per page, which is not as appealing when you use EPiServer as it for a big part duplicates its functionality. Also a bit of a caveat here for agile programming methodology which promotes an often and early refactoring – if you move your page around or change its name – you lose the WebParts for all pages using it.

What we needed is a flexible and extensible scheme for reusing “WebParts sets” and that’s what our extension allows for.

Also since we’re very performance sensitive, and we operate in a multi server scenarios a lot we’ve added web parts blobs caching. Meaning that the site does not have to reach to the database every time a page is rendered.

The very appealing side of the framework is that it can be extended form the bottom (persistence) from the top (editors, controls, webparts), as well as being pluggable with custom plumbing.

The Sidebar Extensions for WebParts Framework

So to put all the requirements together, we needed the sidebars to be:

• customizable (out of the box)
• easy to use for both developers and editors (out of the box) Wow Steve, I can’t really appreciate enough how cool it is to code for it and how nice it is for the users!
• localizable
• reusable
• inheritable for site branches

WebParts path patterns

The main idea was to free the path names from the restriction they had – being hardcoded for a page. So to do it without hard-coding them I’ve introduced path patterns.

What is a pattern?

Basically a pattern is a way the framework is supposed to encode the WebParts  id for the system to identify. Your site can have any number of “named patterns” and the framework gives you means of switching between them. Pattern allow for almost any string to be a part of it although some tokens have special meaning:

Some sample patterns

The configuration of the module is a descendant of any EPiServer Virtual Path Provider configuration. This aspect is fairly well described on EPiServer pages.

A sample configuration for the TextImageVirtualPathProvider can look as follows

<configuration>
  <episerver>
    <virtualPath
      <providers>
        <add showInFileManager="false"
             virtualName="Text Images"
             virtualPath="~/TextImages/"
             bypassAccessCheck="false"
             name="TextImages"
             type="Cognifide.ImageVirtualPathProvider.TextImageVirtualPathProvider,Cognifide.ImageVirtualPathProvider"
             physicalPath="C:\temp\TextImages"
             allowedReferers="(localhost)"
             allowNullReferrer="false"
             replacementStrings="$colon$,:,$gt$,>,$dot$,.,$quot$,&quot;,$amp$,&amp;,$star$,*,$eol$,&#10;,"/>
      </providers>
    </virtualPath>
  </episerver>
</configuration>

where:

• physicalPath is where the cached version of images will be stored
• shownInFileManager is “false” as there is nothing to present for the user in the file manager.
• allowedReferrers is the regular expression containing the filter for sites that are allowed to access the path provider and get images. This has been added so that your server does not turn into the internet’s text-image open service :)
• allowNullReferrer should be set to false in production environment but allows for testing by directly creating URL’s without using a page to fill in the referrer.
• replacementStrings – this one actually turned out to be very useful since some characters are invalid and not even reaching the VPP if EPiServer or ASP detects them. so to allow for characters like colon or < or even a dot (which would make it hard to form regular expression if it was explicitly available) or * you need to create an escape token for them. The string is a coma separated list of token,value,token,value,…
• virtualPath is something you need to change if you want your VPP to serve images under a different root level folder. (e.g. if you have a page with that name already)

Additionally for IIS6 (most common scenario) you need to add <location> node to configuration for the VPP to work.

<configuration>
  <location path=“TextImages“>
    <system.web>
      <!– Setup the StaticFileHandler for the wildcard mapping to work in IIS6–>
      <httpHandlers>
        <add path=“*“ verb=“GET,HEAD“ type=“System.Web.StaticFileHandler“ validate=“true“ />
      </httpHandlers>
    </system.web>
    <staticFile expirationTime=“-1.0:0:0“ />
  </location>
</configuration>

Unless you want to change the location of the virtual path provider can be found under, there is nothing you need to change here.

The code is accessible on EPiCode, but you can also download a compiled binary here. All you need to do then is to unzip the archive to the “bin” folder within your site and set the web.config values to your preference.

The use case is as follows:

• The client wants the site to look exactly as in a template provided as a image,
• the text is using a non standard font that is not available on 60% of Windows machines,
• the site does not use flash.
• the site needs to be equally good looking in IE6 (more about it later)

The solution was to generate images, but how to do it the right way? This has presented us with a once-in-a-lifetime :) opportunity to create a virtual path provider, do something good and learn something new & cool in the process.

Creating a new virtual path provider.

this functionality in itself is fairly well documented on MSDN one thing to pay attention to is to remember to pass the control to the next provider in the provider queue if your provider does not want to serve the request, so in my case:

        public override VirtualFile GetFile(string virtualPath)
        {
            if (IsPathVirtual(virtualPath))
                VirtualFile file = new TextImageVirtualFile(this, virtualPath);
                return file;
            else
                return Previous.GetFile(virtualPath);
        }

this is necessary so you don’t have to have all-or nothing solution (your provider either serving everything the user requests or not being accessible at all) and honestly I’ve spent quite a while before I found out that… I was just being silly – thinking the technology by itself will resolve that ;)

If your Virtual path provider does not actually implement directories you don’t have to make the very provider to do a lot of complicated things. you are perfectly fine to limit the implementation to providing a custom constructor so that EPiServer passes you the configuration data and a couple of methods to tell whether a file is what you want to handle or not

// this one is actually really cool - whatever values you set in your web.config 
// will be passed to you in the collection so you can really make your VPP 
// as configurable as necessary
public TextImageVirtualPathProvider(string name, NameValueCollection configAttributes)

// This one resolves if the file can be generated
public override bool FileExists(string virtualPath) { /* ... */ }

// Pretty much only passes the info that directory was not found 
// found if the virtual path matches a path that we should handle
public override bool DirectoryExists(string virtualDir) {  /* ... */  }

// Retrieves the virtual file that generates the image if the
// Virtual path matches our pattern or disregards the request if it doesn't
public override VirtualFile GetFile(string virtualPath) {  /* ... */  }

// Again this is only a pass through method as we don't support directories
public override VirtualDirectory GetDirectory(string virtualDir) {  /* ... */ }

Now that we have ASP passing the request to us we need to wonder how to format the request in a way that is intuitive to the user, I wanted the URL to be straightforward and follow the path of EPiServer’s friendly URL-S so that they are easily formed by editors. So how about:

http://my.server.com/color/font-name/font-size/The%20text%20i%20want%20to%20print.gif

Ok.. well…, that won’t fly for GIFs – the font will be plain ugly if I don’t use antialiasing and if I do I will have an ugly black background underneath it. The solution to that would be using translucent PNG (which the VPP supports) but IE6 does not support those with transparency without ugly hacks. So I need to replace the blacks with a hint so that it generates a background colour when it merges the background with the font for antialiasing. For the sake of this article let’s assume it was an easy switch (IT WASN’T!) and let’s extend the URL to:

http://my.server.com/color/antialias-hint-color/font-name/font-size/The%20text%20i%20want%20to%20print.gif

But I need the font to be bold! Ok… ok…

http://my.server.com/color/antialias-hint-color/font-name/font-size/font-formatting/The%20text%20i%20want%20to%20print.gif

Can I have the image rotated too? Sigh….

http://my.server.com/color/antialias-hint-color/font-name/font-size/font-formatting(optional)/transformatio(optional)/The%20text%20i%20want%20to%20print.gif

The image rotation follows the RotateFlipType enumeration so you can specify any string that is defined in the MSDN documentation for the enumeration.

A sample result for the URL:

http://my.server.com/TextImages/Blue/white/Courier%20New/40/BUI/rotate270flipnone/Hello$eol$from$eol$Cognifide!.gif

Will look as follows

For the curious

The final string format matching regular expression looks as follows:

Regex regex = new Regex(
    @"^(?<colour>                  # The first match - starting form the beginning of the string
    ([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[a-zA-Z]*))   # match either a 6 hex digit string or a name of a known color - this is for text color
    /                             # now we expect the first separating slash
    (?<hint>                      # next match group is about background hint for antialiasing
    ([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[a-zA-Z]*))   # match either a 3 or 6 hex digit string or a name of a known color - this is for antialiasing color hint
    /                             # again separating slash
    (?<font>[\w\s]*)              # font family name - accept white spaces
    /                             # yet another separating slash
    (?<size>[\d]{0,3})            # font size 
    /                             # oh noes! another slash!
    ((?<style>[BIUSRN\s]*)        # font style Bold, Italic, Underline, Strikethrough
    /){0,1}                       # this group is optional.
    ((?<transform>[\w]*)          # transformation name as specified with System.Drawing.RotateFlipType - this group is optional
    /){0,1}                       # this group is optional too.
    (?<text>[\s\S]*[^\.])         # the text to render - basically anything but a dot - use relacement strings for dots
    [\.]                          # separating dot - now that's a nice change!
    (?<extension>(png|gif))       # the file extension - so that we know whether to generate png or gif
    $                             # everything comes to an end  
    ",
    RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace | RegexOptions.CultureInvariant);

Usability concerns

The Colours can be provided as both named Colours (red, green, etc..) or html hex formatted colours (e.g. ff00bb, fob, fff, badfoo) both 6 and 3 hex digits strings are accepted.

The URL accepts spaces, and whatever text string that cannot be passed as a part of the url or is invalidated by EPiServer can be escaped by defining a token for it in web.config so for example as you can see in the above url the end of line “\n” character has been escaped into $eol$.

Obviously the font selection is limited to what is installed on your server.

Performance concerns

The basic concern that comes to mind is – how does this impact the server performance if the image is generated every time? Even though the performance impact seemed to be negligible I’ve decided to cache content. These things simply pile up if you have a high load site so why take the chance? Once an URL is called it is saved on first generation asserting the uniqueness of each parameter. Colours like black and 000 will be treated as same colour and cached only once.

Security concerns

So what was done to prevent our server to be an open server for generating images for everyone on the Internet? The VPP only allows for the images to be generated if the request referrer is in a domain or a host that is specified in the web.config. Additionally for testing you can enable the referrer to be null (direct call to images, as opposed to referring to them from a page).

Also as a seconds line of defence, it’s wise to define the cache folder on a share with a quota so we don’t get our server filled up with images should the referrer limiting measure fail for some reason.

One of the first projects (that I took part in) is CogniScale – an app that allows FlexiScale users to manage their servers. Here’s the story…

Being the agile company taking part in many EPiServer projects we never seem to have enough environments to test our web-apps and software in general in various scenarios. We find ourselves constantly reinstalling and trying to keep our servers in a state that can can at least remotely be called as stable. After all how many deployments and tearing down of various EPiServer, CruiseControl, TeamCity, SQL Server and other "I need to have" apps can a server take before slowing down to a crawl or collapsing all together (that said I bow before our faithful THOTH for taking all the abuse it does). We definitely needed more servers! And we needed them now!

Early this year we’ve started to talk to the guys at XCalibre that came up with a great idea. What if you could have an unlimited amount of servers available for you at any given time? I mean really what if you could have 0 servers one day and the next day have a rich farm of servers for literally no cost, paying only when you power them up and not paying a bit if you take them down.  This turned out to be quite a project for them that turned to materialize as FlexiScale. (you can read more about it here). Looking at all that I’ve mentioned before while eliminating the cost of maintaining the servers locally we decided to give FlexiScale a spin.

Early this year FlexiScale published a set of API’s that we looked at and (being the geeks we are) tried to utilize it in a desktop application with a limited success. It turned out that the initial API was perfectly accessible from dynamically typed languages while statically typed languages like C# didn’t really get their love in the initial release :) So we started opening the support tickets and shortly after that establishing a lively dialogue with the great folks there. Let me tell you, the guys in the FlexiScale support are really an amazing and responsive bunch. Not only did we get the support and the fixes we needed for the language we chose but we also pretty much got all our suggestions implemented and added to the API’s.

Thus CogniScale was born:

The app allows for easy powering up and down the servers (allowing you to describe the reason for the action) from a nice and shiny GUI as well as scheduling it with windows task scheduler through its command line interface. it allows you to connect using FTP or Remote Desktop as well as any other app you can run from command line (it features a custom command editor that allows you to configure any app to work with it) with a single click. The app also allows you to quickly go through the history of servers’ maintenance to determine how often and for what reason were they taken on and off-line.

Should you decide that FlexiScale is your thing, please give CogniScale a whirl and let us know what you think.

As a .Net developer this pretty much makes me laugh through tears. What an excellent publicity stunt. First of all, Microsoft does not plan to release a Linux version. It’s cross-platformedness (is that a word?) refers strictly to the fact that there has been a runtime engine port made for a Mac. What was ported? The CLR and the DLR. Big deal! This has been there in a form of Mono years ago! And the CLR is available for Linux for a few years now. How is that suddenly an exciting thing?

If you’re interested in what exactly was done you may want to look at the interview with Scott Guthrie, GM of the Silverlight team. GAC was not ported. Wait! GAC WAS NOT PORTED?! Only a subset of classes that are needed inside a browser. Basic GC, no ASP.Net. It’s nothing like a cross platform version of a full .Net framework. this is also nothing really that new from the cross platform point of view – this kind of stunt was already pulled by Microsoft in form of the Compact version of the .Net framework. Something similar has already been done in terms of XNA – which is a form of .Net framework for XBox. In fact Silverlight is much more like XNA than it is like the full .Net framework.

Second of all the only open part is the DLR which is actually developed in an “embrace and devour” fashion. Ruby, Python and the likes developers – we love you! come join us under our Common Language runtime! Of course Microsoft will open it. Those developers are all about open and free this makes a lot of sense doing it this way. Give something, get a lot in return. Don’t get me wrong, I love the dynamic extensions, and I really like what’s being developed in the DLR, but make no mistake, the motives haven’t changed.

In the end CLR has been open for a long time and it’s not where the most exciting part of the development is. It’s the framework. I’ve not seen a word about Windows forms being ported. Or any of the ASP.Net namespaces on that mater. Heck even Mono has big ASP.Net 1.0 and chunks of 2.0. If you look at the image where do you see the CLR?

It’s the small middle circle inside the big one. That’s a far cry from releasing .Net as a standalone portable framework. And if you think about it, it does not make any sense from Microsoft’s point of view to go the whole way. What for? for it to make Windows expendable? Ridiculous!

My feeling is that (other than making another bucket of money), partially the motives behind is is to kick Adobe’s butt. If it did not occur to you yet, Microsoft and Adobe are full-out at war at this point. PDF is combated with XML Digital Paper, Flash has its Silverlight, Shockwave (& Macromedia Director) has Blend and XAML now and so on…

Adobe already takes shots back at Microsoft

While Adobe made PDF readily-available to other software companies such as Apple, Sun, Corel, and OpenOffice, when it came to deep-pocketed Microsoft, Adobe took a different stance, demanding that it remove the feature and charge a separate fee.

In response, Microsoft agreed to remove the feature, but refused to charge consumers separately for it. Adobe consequently sought negotiating leverage by threatening to sue before the EC, despite the fact that neither Adobe nor Microsoft are based in Europe, neither operates major production facilities there, and neither maintains primary business locations there.

Now that we have a few myths busted, I don’t want you to think that I am not excited by Silverlight.

The coolness ensues

It is still incredibly cool that they are doing it and not for the cross platform reasons (although it’s nice), and not for the multi browser compatibility (even nicer), but for it’s roots in the full framework. For us .Net developers it’s like one day we woke up and we knew how to write Action Script (Flash) applications. The Silverlight download is only 5 meg, so in the broadband world it’s going to be on almost every computer fairly quick. We will have a robust development environment for developing those applets in less than a year. It’s root in the .Net framework roots will make it talk seamlessly to our IIS embedded apps and services. You wanted web applications?

You asked for web applications? We will deliver…
… only they will be desktop applications running inside a browser we approve....
… and on any platform we choose for you…
… the best of both worlds – no matter if you want to run them in Windows OR in Internet Explorer. :)

But honestly – should you use some artificial and clunky surrogates of instantly-responsive-interactivity in forms of AJAX when you can have the real thing running faster and delivering much wider functionality? Developing a browser apps was possible before, but .Net was never perceived as a platform specifically designed for that kind of activity, the quasi multi-platform/browser compatibility has a chance to change that perception. Perfect crime :)

I can’t wait for Silverlight to turn gold. It’s a brave new world.

So the class that we are going to store needs to persists the following values:

namespace Cognifide.EPiServerTest.ObjectStore
{
    [Serializable, XmlInclude(typeof (PageCommentDO))]
    public class PageCommentDO : IItem, IPageComment
    {
        private object id;
        private string name;
        [Indexed(true)]
        private int pageId;
        private string title;
        private string content;
        [Indexed(true)]
        private DateTime submitDate;
        [Indexed(true)]
        private bool moderated;
        [Indexed(true)]
        private bool published = true;
        [Indexed(true)]
        private bool reported;

    }
}

 You might have noticed that contrary to what I did before this class has some of its fields tagged with [Indexed(true)] attribute. This is required by the store object if we ever want to query the store for the class using those fields as a filtering criteria. The page also implements the required IItem interface (although the properties required by the interface are not shown in the excerpt) as well as our internal IPageComment which is added there for the purpose of easy switching of implementations. We intend to implement it on both ObjectStore and using NHibernate to make sure we get the best performance possible out of our solution. This interface is to allow us to easily switch between the 2 implementations.

Back to the ObjectStore

 First we need to introduce a few new classes EPiServer uses for querying the Store. The namespace that scopes the querying consists of the following entities: 

namespace EPiServer.BaseLibrary.Search
{
    public class BetweenExpression : IExpression;
    public class EqualExpression : IExpression;
    public sealed class Expression;
    public interface IExpression;
    public class Order;
    public class Query : IEnumerable;
}

The Query class is at the center of any search in the Store, let’s start with the samples right away. The saving is almost identical to the sample that I’ve shown in my previous article:

public void Save()
{
    ISession session = null;
    try
    {
        // check if there is a schema for the type, if not create it.
        if (Context.Repository.SchemaForType(GetType()) == null)
        {
            TypeSchemaBuilder.RegisterSchemaAndType("CognifidePageCommentsStorage", GetType());
        }

        // get a new session from the current context.
        session = Context.Repository.CreateSession();

        // wrap it in a transaction 
        session.BeginTransaction();

        // make sure the id has been defined.
        if (Id.Equals(Guid.Empty))
        {
            Id = Guid.NewGuid();
        }

        //persist
        session.Save(this);
        session.CommitTransaction();
    }
    catch (ElektroPostException exception)
    {
        // ... rollback the transaction and do some reporting
        if (session != null)
        {
            session.RollbackTransaction();
        }
        throw;
    }
    finally
    {
        if (session != null)
        {
            session.Close();
        }
    }
}

Really there is not much meat there. The interesting part comes in the object retrieval. Even though the Search namespace does not look like it offers much, you can still build a fairly fophisticated filter with it. following code retrieves comments for a specific PageLinkID. The comments can be filtered by date and since the call is used to retrieve the page for viewing, we probably only want the ones that are public (meaning they have not been removed by the comment moderator).

public static List<PageCommentDO> GetCommentsForPage(int pageId,
    DateTime beforeDate, DateTime afterDate, bool includeOnlyPublished)
{
    ISession session = null;

    try
    {
        // make sure there is a schema to read from, otherwise there is no point
        if (Context.Repository.SchemaForType( typeof (PageCommentDO)) == null)
        {
            return null;
        }

        //acquire a session
        session = Context.Repository.CreateSession();

        //create the query 
        Query query = new Query(typeof (PageCommentDO));

        // we only want comments for a singler page 
        query.Add(Expression.Equal("pageId", pageId));

        // should we filter to only wshow comments from some set time period?
        // the following demonstrate how to request a value from within a range
        if ((beforeDate != DateTime.MinValue) ||
            ((afterDate != DateTime.MaxValue) && (afterDate != DateTime.MinValue)))
        {
            query.Add(
                Expression.Between("submitDate",
                                   (beforeDate != DateTime.MinValue) ? beforeDate : new DateTime(0x76c, 1, 1),
                                   ((afterDate != DateTime.MinValue) && (afterDate != DateTime.MaxValue))
                                       ? afterDate
                                       : new DateTime(0x834, 1, 1)));
        }

        // probably for a displayed page we will only want to show published comments
        if (includeOnlyPublished)
        {
            query.Add(Expression.Equal("published", true));
        }

        // order the comments by date/time so that we get the most recent first
        query.AddOrder(new Order("submitDate", true));

        IList list = session.ExecuteQueryObject(query);
        List<PageCommentDO> result = new List<PageCommentDO>(list.Count);
        foreach (object item in list)
        {
            result.Add((PageCommentDO) item);
        }
        return result;
    }
    catch (ElektroPostException ex)
    {
        // ... do some reporting
        throw;
    }
    finally
    {
        if (session != null)
        {
            session.Close();
        }
    }
}

You nahe to agree, this really IS neat. All you need to do now to place the comments on a page is a few lines of code to bind the data from the Store with a repeated of a kind, and a set of edit boxes with a submit button :)

This is basically how much code the submission and retrieval the comments comment take:

// Load the comments to a repeater
protected void Page_Load(object sender, EventArgs e)
{
        List<PageCommentDO> comments =
            PageCommentDO.GetCommentsForPage(CurrentPage.PageLink.ID, DateTime.MinValue, DateTime.MaxValue);
        CurrentComments.DataSource = comments;
        CurrentComments.DataBind();
}

// Comment submission
protected void SubmitComment(object sender, System.EventArgs e)
{
    PageCommentDO newComment = new
        PageCommentDO(Guid.Empty,
        string.Format("CommentForPage{0}", CurrentPage.PageLink.ID),
        CurrentPage.PageLink.ID,
        SubjectTextBox.Text, ContentTextBox.Text, DateTime.Now, false, true, false);
    newComment.Save();
}

// the data binding for the labels
protected void CurrentComments_ItemDataBound(object sender, RepeaterItemEventArgs e)
{
    PageCommentDO comment = (e.Item.DataItem as PageCommentDO);

    Label commentSubjectLabel = (Label)e.Item.FindControl("CommentSubjectLabel");
    if (comment != null)
    {
        commentSubjectLabel.Text = comment.Title;
    }

    Label commentContentLabel = (Label)e.Item.FindControl("CommentContentLabel");
    if (comment != null)
    {
        commentContentLabel.Text = comment.Content;
    }
}

Short of having a control pre=built for you I cannot think of it being able to make it easier.

I will look into packing it into a nice control that we would be looking into contributing some time in the future and of course if there is actually a demand for it.

Sure I could go to the administration console and do it manually, but hey, why waste 30 seconds every time you do it when you can actually batch waste them in a chunk of half an hour to automate it.

so here’s my findings.

The adsutil.vbs is the script you want to get intalled on your system somewhere in the search path. %systemroot% will do.
You will find the script on your XP CD in the \i386 folder. Unpack with the following command:

expand E:\i386\adsutil.vb_ %SystemRoot%\adsutil.vbs

Assuming that E: is your CR-ROM drive.

You can find the user’s reference for the script on the Microsoft page

You may want to make sure that your Episerver is running in the default location by using the following call:

Cscript.exe %SystemRoot%\adsutil.vbs SET /W3SVC/1/ROOT

But since you’re probably having only one web server running on your machine anyway (why would you read it otherwise) probably the only thing you really need to do is:

Cscript.exe %SystemRoot%\adsutil.vbs SET /W3SVC/1/ROOT “C:\Inetpub\MyEPiServer###”

Another great tool I use that’s actually built into windows is reg.exe. this tool actually allows you to modify registry from command line. this was actually my initial approach to changing the path. It didn’t succeed to actually change the IIS root – but still it did the modification to the registry (that IIS just merrily ignored).

reg.exe ADD “HKLM\SYSTEM\CurrentControlSet\Services\W3SVC\Parameters\Virtual Roots” /v “/” /d “C:\Inetpub\MyEPiServer###,,201″ /t REG_SZ /f

This is however good for changing some database settings if anything is stored in the registry before restarting the IIS, which is can be scripted as:

net stop W3svc
net start W3svc

So to summarize… my script for switching sites ends as:

@echo off

set root_folder=C:\Inetpub\MyEPiServer2\
set adscript_location=%SystemRoot%\adsutil.vbs

echo Switching IIS to %root_folder%
Cscript.exe %adscript_location% SET /W3SVC/1/ROOT “%root_folder%”
net stop W3svc
net start W3svc

<%@ Control Language=”C#” AutoEventWireup=”false” CodeFile=”CategoryListing.ascx.cs” Inherits=”development.templates.Units.CategoryListing” TargetSchema=”http://schemas.microsoft.com/intellisense/ie5″ %>

<%@ Register TagPrefix=”EPiServer” Namespace=”EPiServer.WebControls” Assembly=”EPiServer” %>

 

<div id=”rightmenudivStartPage”>                       

    <div class=”listheadingcontainer”>

        <div class=”listheadingleftcorner”></div>

        <a class=”listheading leftfloating” href=”<%=EventRootPage.LinkURL%>“><%= EventRootPage.PageName %></a>

        <div class=”listheadingrightcorner”></div>

    </div>

 

    <EPiServer:PageList runat=”server” ID=”PageList1″>

        <ItemTemplate>

            <div class=”startpagecalendaritem”>

                <span class=”datelistingtext”>

                <episerver:property ID=”Property1″ runat=”server” PropertyName=”PageLink” CssClass=”StartCalendar” />

                <span class=”Normal”><episerver:property ID=”Property3″ runat=”server” PropertyName=”MainIntro” /></span>

            </div>

        </ItemTemplate>

    </EPiServer:PageList>

    <br/><br/>

</div>

The wirst thing you will notice after looking at the code is that PageList is pretty much a standard ASP.NET reinvented and rehashed. GREAT! Sounds like we can use the Data binding, right? That’s also true:

private void Page_Load(object sender, System.EventArgs e)

{

    if (!IsPostBack)

    {

        PageList1.DataSource = CategoryPages;

        DataBind();

    }

}

Does the trick of binding the data to the repeater… uh… oh… sorry… I mean PageList.

Now comes the hard and non-obvious part.

How does one actually find the pages assigned to a category? Short of calling the database directly to query the tblCategorypage table that comes to mind at first, it looks like EPiServer has a really cool page finding module that allows for simple yet fairly effective discovery of pages conforming to some developer defined criteria. Those criteria are defined by means of forming any necessary number of instances of PropertyCriteria class provided as a PropertyCriteriaCollection to Global.EPDataFactory. The result is handed to us back as a PageDataCollection. The fetching of the pages looks like this:

public PageDataCollection GetCategoryPages()

{

    PropertyCriteria criteria = null;

 

    CategoryList categories = ((PropertyCategory)(CurrentPage.Property["AggregatedCategory"])).Category;

 

    criteria = new PropertyCriteria();

    criteria.Condition = CompareCondition.Equal;

    criteria.Type = PropertyDataType.Category;

    criteria.Value = categories.ToString();

    criteria.Name = “PageCategory”;

    criteria.Required = true;

 

    PropertyCriteriaCollection col = new PropertyCriteriaCollection();

    col.Add(criteria);

 

    PageDataCollection pdc = new PageDataCollection();

    pdc = Global.EPDataFactory.FindPagesWithCriteria(EPiServer.Global.EPConfig.StartPage, col);

 

    return pdc;

}

For this to work though, one has to define some more stuff in the web admin part of the site. the usual task is to define the Page Template for the control. In this case when you define the Page Template make sure to put the “AggregatedCategory” property in that should be of type Category selection. This property defines what categories you want your control to aggregate, and you can provide one or more of those. the other property that is required for this very control is “CategoryContainer” of type Page. This is solely for the purpose of having a master page that you define as the “main page” for the chosen category selection. It serves as a clickable header in the control. Unnecessary maybe but one would have to define a caption for the control anyway so why not make it meaningful.

The usage of the said control is trivial. A sample usage on the default EPiServer site looks like this:

<%@ Page language=”c#” Codebehind=”CategorySummary.aspx.cs” AutoEventWireup=”false” Inherits=”development.Templates.CategorySummary” %>

<%@ Register TagPrefix=”EPiServer” Namespace=”EPiServer.WebControls” Assembly=”EPiServer” %>

<%@ Register TagPrefix=”development” TagName=”CategoryListing”  Src=”~/templates/Units/CategoryListing.ascx”%>

<%@ Register TagPrefix=”development” TagName=”DefaultFramework”    Src=”~/templates/Frameworks/DefaultFramework.ascx”%>

 

<development:DefaultFramework ID=”DefaultFramework” runat=”server”>

    <EPiServer:Content ID=”Content1″ Region=”fullRegion” runat=”server”>

        <development:CategoryListing  ID=”CategoryContent” runat=”server”/>

    </EPiServer:Content>

</development:DefaultFramework>

Out of which really only the <development:CategoryListing  ID=”CategoryContent” runat=”server”/> part is meaningful.

For the record… It looks like THE place to go to solve that kind of dilemas fast is the EpiServer “Developer to Developer” forums.

*)… couldn’t ressist with the title joke :) For those not in subject… It’s a reference to a silly commercial of one of the market chain (Biedronka) in Poland that advertises recently with “My first *something*… from Biedronka*

The article is based on the knowledge I’ve gathered and work I’ve performed for Cognifide. Cognifide is an official partner EPiServer and the real contributor of the the control.