This is sequel post of the Using the EPiServer Community API outside IIS where I described how you can call the EPiServer CommunityAPI inside a standalone console application. This post will go a little further and show you how you can import images in the same maner.

The issue

In my atttempt to create a lot of users with attached my pages profiles i stumbled across a issue when adding portrait images. It turnes out that the ImageGallery module in the EPiServer Community Framework refers directly to the  System.Web.Hosting.HostingEnvironment, instead of wrapping it inside a custom object as the EPiServer CMS does it with the EPiServer.Web.Hosting.GenericHostingEnvironment class. The HostingEnvironment is thereby not initialized and calls to e.g. HostingEnvironment.MapPath() will fail.

The solution

The only way around this is to create a fake web application context. I did not attempt to figure out this on my own, so I hoped somebody had done this before. After some searching i finally found a nice hack onPhil Haack’s blog. He have created a HttpSimulator class that is intended to be used when performing unit tests. The HttpSimulator sets private field values using reflection values in the same way i’ve injected the community configuration.

To enable adding images do the follwing:

1. Download the HttpSimulator
2. Unzip and copy the following files into your console application
   • HttpSimulator.cs
   • ReflectionHelper.cs
   • SimulatedHttpRequest.cs
    
3. Wrapp all of your community api calls inside the following code block

using (new Subtext.TestLibrary.HttpSimulator("/", Directory.GetCurrentDirectory()).SimulateRequest())
{
//your community api calls here
}

Example:

The following example creates/gets a test user and creates a new new profile image for that user

//Create web application context + http context
using (new Subtext.TestLibrary.HttpSimulator("/", Directory.GetCurrentDirectory()).SimulateRequest())
{

    //*******************************
    // Initializing the community api
    //*******************************

    //Read app config file
    System.Configuration.Configuration config = null;
    config = System.Configuration.ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);

    //Inject configuration into the EPiServer Common + EPiServer Community framework
    Type type = null;
    FieldInfo field = null;

    type = typeof(EPiServer.Common.Configuration.EPiServerCommonSection);
    field = type.BaseType.GetField("m_config", BindingFlags.Static | BindingFlags.NonPublic);
    field.SetValue(null, config);

    type = typeof(EPiServer.Community.Configuration.EPiServerCommunitySection);
    field = type.BaseType.GetField("m_config", BindingFlags.Static | BindingFlags.NonPublic);
    field.SetValue(null, config);

    //Initializing the framework                
    EPiServer.Common.Web.Global.OnBeginRequest();

    if (EPiServer.Community.CommunitySystem.CurrentContext == null)
    {
        throw new Exception("The community context is not initialized");
    }

    //****************************
    // Using the community api
    //****************************

    //the test user to add a profile image
    string username = "TestUser";

    //try to find the test user
    EPiServer.Common.Security.IUser user = EPiServer.Community.CommunitySystem.CurrentContext.DefaultSecurity.GetUserByUserName(username);

    if (user == null)
    {
        //the test user was not found -> lets create a new user
        user = EPiServer.Community.CommunitySystem.CurrentContext.DefaultSecurity.NewUser;
        user.UserName = username;
        user.Alias = "Java Developer";
        user.GivenName = "Test";
        user.SurName = "User";
        user.PassWord = "SomePassword123";
        user.EMail = "testuser@mysite.com";
        user.BirthDate = new DateTime(1900, 1, 1);

        EPiServer.Common.Data.DatabaseHandler.RunInTransaction(delegate
           {
               //This will create the user with mypage profile
               user = EPiServer.Community.CommunitySystem.CurrentContext.DefaultSecurity.AddUser(user);
           });
    }

    //Get hold of the users mypage profile
    EPiServer.Community.MyPage.MyPage profile = EPiServer.Community.MyPage.MyPageHandler.GetMyPage(user);

    //make the profile object writable
    profile = (EPiServer.Community.MyPage.MyPage)profile.Clone();

    if (profile.Portrait == null)
    {
        //the user profile does not have a image -> lets add a new one
        string imagePath = @"Images\JavaDeveloper.jpg";

        using (FileStream file = File.Open(imagePath, FileMode.Open))
        {
            EPiServer.Community.ImageGallery.Image portraitImage
                 = new EPiServer.Community.ImageGallery.Image("ProfileImage.jpg",
                                                              "A random java developer",
                                                              file);

            portraitImage.PublishState = EPiServer.Common.Publishing.PublishState.Published;
            portraitImage.Uploader = profile.User;

            profile.Portrait = portraitImage;

            EPiServer.Common.Data.DatabaseHandler.RunInTransaction(delegate
            {
                EPiServer.Community.MyPage.MyPageHandler.UpdateMyPage(profile);
            });
        }
    }
}

And here is the end result:

I have recently come across a scenario where i had  to migrate alot of data into EPiServer Community from a legacy system. Since there is quite of a lot of data that needed to be transfered from one system to another, the ideal solutions for us was to do this by code via a console app The console app exports data from the legacy system and inserts it into EPiServer Community by using the powerful community framework. This is however not as simple as it sounds. Here is a little howto on what you have to do to overcome this challenge.

1. Creating a community/relate site

Create a new site using the deployment center. This is the community site i want to import data into. In this example i have installed an relate site into the following directory c:\EPiServer\Sites\RelateDemo\Source\Web. Open the project file in the web folder in Visual Studio. Rename the EPiServer.Templates.RelatePlus to Web. Save the solution in by select the solution project in Visual studio and save it via File –> Save as. Store it in the parent folder of the project (c:\EPiServer\Sites\RelateDemo\Source)

2. Creating the console app

Create a new console application by selecting the solution file –> new project –> console application. I called my console app MigrationTool. Set the console application as the startup project. The solution should now look similar to this:

Now you must add a bounch of references to the EPiServer Common Framework and THe EPiServer Community Framework. Simple right click the console app project (e.g MigrationTool), then select add reference. Add all assemblies found in the following directories:

• C:\Program Files (x86)\EPiServer\CommonFramework\2.3.517.36\bin
• C:\Program Files (x86)\EPiServer\Community\3.2.517.24\bin

3. Reusing the community configuration

The goal of the console app is to use the community framework in the same matter as the RelatePlus templates does. This requires however a fair amount of configuration in the console apps app.config file and it would basicly look the same as the web.config of the Web project. Instead of creating a new config file for the console app, it would be better to reuse the copying the existing configuration from our web project.

Create a script that copies the config files from the web project by right clicking the the console project and select Properites and then select the Build events tab. Add the following script in the Post-Build events textbox

xcopy "$(SolutionDir)web\*.config" "$(TargetDir)" /y /q /s
copy $(TargetDir)web.config $(TargetPath).config /y

Like this

Notice the last line of the script. It creates a file called MigrationTool.exe.config so that the console app can read the community configuration.

When you build the console app and click the ”don’t lie to me”-button you will notice the bin folder will now contain the following files:

You can now add some code uses the community framework in the console app. E.g fetching the default admin user via the community api:

//Using the community api
EPiServer.Common.Security.IUser user = EPiServer.Community.CommunitySystem.CurrentContext.DefaultSecurity.GetUser(1);
Console.WriteLine(user.UserName);

4. Initializing the Community Framework

If you try to use any of the methods on the community api now you will get a horrible null reference exception since the community framework is not initialize. To work around this you need to trigger the community api to initialize. Add the following code above the code from the previous section:

//Initializing the framework                
EPiServer.Common.Web.Global.OnBeginRequest();

5. Mocking the HttpContext

The console app will still not work. I digged far and deep into to the community api and i spoted that the api references a lot of HttpContext.Current. The most notable is the CachingHandler class that relies on the HttpContext.Current.Cache object. To work around this you need to mock the HttpContext. Add a reference to the System.Web.dll in the console app project and add the following code above the code from the previous sections  

//Mock HttpContext
string fileName = "default.aspx";
string url = "http://local.relatedemo.com";
string queryString = null;

var sb = new StringBuilder();
var sw = new StringWriter(sb);
var request = new HttpRequest(fileName, url, queryString);
var response = new HttpResponse(sw);
var context = new HttpContext(request, response);
HttpContext.Current = context;

6. The Hack: Injecting the community configuration

Oh no. Another problem. When running the application now it will throw the following exception:

The application relative virtual path ‘~/’ is not allowed here.

It turnes out that the EPiServer Common Framework + EPiServer Community Framework assemblies is reading their configuration by using the the System.Web.Configuration.WebConfigurationManager and providing it with a relative path “~” which won’t work outside a web server environment. To avoid the configuration being read using the WebConfigurationMananger you need to inject the configuration into the framework classes yourself.

Add a reference to the System.configuration.dll and add the following code above the previous code.

//Read app config file
System.Configuration.Configuration config = null;
config = System.Configuration.ConfigurationManager.OpenExeConfiguration(typeof(Program).Assembly.Location);

//Inject configuration into the EPiServer Common + EPiServer Community framework
Type type = null;
FieldInfo field = null;

type = typeof(EPiServer.Common.Configuration.EPiServerCommonSection);
field = type.BaseType.GetField("m_config", BindingFlags.Static | BindingFlags.NonPublic);
field.SetValue(null, config);

type = typeof(EPiServer.Community.Configuration.EPiServerCommunitySection);
field = type.BaseType.GetField("m_config", BindingFlags.Static | BindingFlags.NonPublic);
field.SetValue(null, config);

This code reads the configuration from the MigrationTool.exe.config file and injects it into two private static fields deep inside the framework classes using reflection. The EPiServer Common Framework and the EPiServer Common Framework will hence detect the configuration has already been read verifying that the m_config is no longer null and WebConfigurationManager.OpenWebConfiguration(“~”) is never called

7. The Happy Ending

Finally. The code is working and the alias of the username of the admin is printed to the screen:

 

//Read app config file
System.Configuration.Configuration config = null;
config = System.Configuration.ConfigurationManager.OpenExeConfiguration(typeof(Program).Assembly.Location);

//Inject configuration into the EPiServer Common + EPiServer Community
Type type = null;
FieldInfo field = null;

type = typeof(EPiServer.Common.Configuration.EPiServerCommonSection);
field = type.BaseType.GetField("m_config", BindingFlags.Static | BindingFlags.NonPublic);
field.SetValue(null, config);

type = typeof(EPiServer.Community.Configuration.EPiServerCommunitySection);
field = type.BaseType.GetField("m_config", BindingFlags.Static | BindingFlags.NonPublic);
field.SetValue(null, config);

//Mock HttpContext
string fileName = "default.aspx";
string url = "http://local.relatedemo.com";
string queryString = null;

var sb = new StringBuilder();
var sw = new StringWriter(sb);
var request = new HttpRequest(fileName, url, queryString);
var response = new HttpResponse(sw);
var context = new HttpContext(request, response);
HttpContext.Current = context;

//Initializing the framework                
EPiServer.Common.Web.Global.OnBeginRequest();

//Using the community api
EPiServer.Common.Security.IUser user = EPiServer.Community.CommunitySystem.CurrentContext.DefaultSecurity.GetUser(1);
Console.WriteLine(user.UserName);

Now you can create users (with belonging mypage), forum rooms, topics and threads etc. All inside a external non web application.

I hope that this hack is not needed in future releases of the EPiServer Community, but rater add more flexiblity to the framework like using IoC when reading configuration, cach etc so that these small but anoying dependencies can be finally be removed.

Hi, here is my small contribution to the Gadget competition. Meet EpiChatty, your personal assistant (chat bot) that can give you help and information about EPiServer CMS. It could serve as a help desk assistant to EPiServer CMS editors / administrators / developers / designers and to content editors.

The main idea behind this is to have Google Talk client embedded as a gadget on dashboard and run EPiChatty as a console application which can interact with the user and give appropriate response.

Google Talk implements Extensible Messaging and Presence Protocol (XMPP) protocol which essentially exchange messages using XML between clients and servers. More information about this protocol can be found at http://xmpp.org/ and more information about Google Talk API can be found at http://code.google.com/apis/talk/

As Google do not provide any C# implementation of XMPP protocol and as I am primarily a C# developer,(not brave enough to try Google’s java based implementation for this protocol), so I have to look for different options. After bit more research,  I found out that agsXMPP is an open source SDK / library for the XMPP protocol which is written in managed C# and is dedicated to .NET and Mono technologies. More information can be found about this SDK can be found at .

With all my components in place, I have learn basics about the new protocol (which I have never used before) and also use the SDK to implement it (easy).  It took a while to do a ‘hello world’ kind of code, as Google server require a different port (5222) than 80 to be open as well so that it could communicate. Once I figured that out with help from support team at agsXMPP, next thing was to implement the automated behaviour for the asked questions.

There are several ways that this could be implemented, but I went for the XML based approach. I have stored questions and answers in a set patterned way so that if user ask ‘what is’ or ‘how to’ or any ‘generic’ question, a patterned would be matched and answer would be returned. The main reason behind this approach was its simplicity and extendibility.

Here is the screen shot how the EPiChatty gadget will look like on dashboard

The gadget view contains embedded Google Talk client and the controller simply returns the view.  The login it will redirect to central Google account services where you could login and then it will return you back to the dashboard.

once login you can ask ‘what is’ or ‘how to’ or ‘generic’ questions

Here is the screen shot of the console application showing that EPiChatty is available to chat

I have made the EPiChatty as a console application so that it could run separately from the main application as a light weight process in background. In case you want to start chatting and test it out, send an invite to epichatty@googlemail.com . I will be hosting it till the end of December 2009 and then EPiChatty will be on long vacations.

Source files contain every thing apart from the password for the EPiChatty Google’s account. If you would like to host your own, you can create a new Google account and replace the username and password in console application and run the console application.

Source

Sveriges Kommuner och Landsting, SKL har korat de bästa webbplatserna sett ur besökarnas ögon. Huddinge och Tyresö kom på delad förstaplats. Huddinge är utvecklad av Extrude Interactive och Tyresö har skapats av Avantime.
Båda webbplatserna är baserade på publiceringssystemet EPiServer CMS.

Testet gick i korthet ut på att besökaren så snabbt som möjligt skulle hitta olika typer av information.

Läs mer om testet hos SKL

Läs mer om EPiServer

Många företag har i dagens hårda klimat inte råd att ta en enorm investering på IT sidan för att konsolidera sina affärssystem. Argumenten för att konvertera tryter, och utmaningarna med projekten är stora. Det finns en stor risk att företaget går på knäna i samband med implementationen och resultatet blir inte alltid så bra som man tänkt sig.

Visst finns det lycksamma ERP implementationer, men det är alltför ofta man hör motsatsen.

Vad finns det då för alternativ om man sitter fast i ett standardsystem som inte har den funktionalitet man önskar?

Antingen kan man hantera lösningen i stödapplikationer som man utvecklar vid sidan om, använda standardiserade produkter som Microsoft Excel, eller Access, eller så kan man investera i en portal för sitt företag.

Integration i desperation

Genom att öppna tjänster ifrån ERP lösningen och tillhandahålla enklare lösningar som körs i en gemensam portal, ett intranät, på företaget får man möjligheten att utveckla ny funktionalitet ovanpå det gamla systemet, utan att behöva byta ut alltihop.

Det som behövs för att lösa problemet är först och främst en robust integrationsplattform, som stabilt och säkert exponerar tjänster ifrån ditt gamla ERP eller Ekonomisystem.

Ovanpå din integrationsplattform etablerar du sedan en applikationsmiljö som finns tillgänglig i hela organisationen, som är webbaserad och som kan enkelt och flexibelt tillhandahålla applikationer som är specifika för användarens ändamål. Steget efter detta blir att verkligen knyta ihop delar av processer, så att användare i organisationen får ett gränssnitt för att göra sina uppgifter istället för att hantera flera olika system. Möjligheterna till kostnadsbesparing blir många!

En tjänsterorienterad plattform kräver eftertanke

Tjänsterna kan sedan användas i applikationer som utvecklats i till exempel Microsoft Sharepoint, EPiServer eller andra plattformar. Utmaningarna med en sån här typ av lösning är många; Med 2 större system och 10 mindre system där varje system exponerar tjänster eller involveras i utvecklingen så riskerar man redan i en sådan relativt liten miljö att få en hög tjänster som skall exponeras, versionshanteras, administreras och förvaltas med en ökad förvaltningskostnad som följd.

Vill du ha hjälp med integrationsfrågor?

Vi på e-man har lång erfarenhet av att spara pengar genom att effektivisera befintliga integrationslösningar samt göra dem anpassade för en allt mer krävande affärsverksamhet.
Vi har Integration som vår expertis, och kan hjälpa till med allt från att ta fram en affärsanpassad integrationsstrategi till utvärdering av integrationsplattform och tillhandahålla resurser för de stora plattformarna, exempelvis Biztalk och TIBCO BusinessWorks

Here come my contribution to the gadgets competition in the “Open gadgets 2009″ category. The gadget works with EPiServer XForm to get live results on a poll or question from the site. Meaning as people vote or answer your question on the site you can follow the result live on the dashboard. You can connect the gadget to any XForm and onthe XForm you can use any any field you wish to follow live. You also have the ability to turn off the live update if there is any performance issue or so. (I have tried to keep it pretty optimized so this will hopefully never be a problem). To configure the gadget you just use the edit menu on the gadget (The little arrow in the upper right corner of the gadget) and set its properties. This means you can have many of this gadgettype with different data working at the same time on the dashboard. It also only updates if there is any change in the data and never updates if the gadget is not visible (it is hidden on another tab or such).

Since I am very early with this gadget I give the possibility for others to see my code use parts of it to help with their development of the gadget. So I hope I get some competition credits for being early!! =)

Functionality

I will try to explain the functionality a little more in detail by explaining on how configure your own poll. Once the gadget is installed (see the installation instructions further down) you are now able to make your own polls.

First set up a new page (use the XForm page template or the demo) in the XForm properties create a new XForm and in this make sure you have a heading (and have “heading” as class since I currently search for this to be able to display heading in the gadget). Create a field like a radio or check boxes or what you like and note down what name you give it. Now save everything and view it in view mode. Should look something like this:

After this you go to the dashboard and add a new poll gadget. Edit the gadget and fill in the information. The pageId of your new page, the property name for the form (probably XForm if you use public templates) and the field name that you noted down earlier. Currently there is only 1 chart type (the pie chart).

Now save your settings and you should have a gadget with no data. So go to the page in view mode and do a few vote to get some data. And watch the magic.

Business Value

I think the business value of this gadget is pretty high. I can see a lot of scenarios where you would like some fast responses to questions be it on an external site or an intranet. This gives the possibility to follow these live and take actions when needed. It also looks pretty cool on the dashboard which might help partners sell EPiServer to customers that like flashy things =)

Technical Overview

The Poll gadget uses Google chart API as a graphical representation and renders the result as an image. This is the only external reference that is used in this gadget. The data comes as said from the XForms in EPiServer that uses data store as storage in EPiServer 6. The new data store should make these kinds of requests fast. The settings for the gadget is also stored in the new data store. The gadget also uses Linq to XML to get hold of the questions from the form XML. The ajaxrequest that is sent between the client and server to update the chart only send a small id to the server and gets json object with a link back.

Installation Instructions

1. Follow the CTP2 installation instructions to install CTP2 CTP2 install instructions. Also install Globalized public template content.
2. Open the poll zip file and extract the content of in into the public templates folder for your CTP2 site.
3. Convert the project file to MVC project. Info on how to do this you can find here: How to create a gadget – By Ted Nyberg Also do the step with web.config (adding the public template assembly).
4. Open the project in Visual Studio and include the 4 folders Content, Controllers, Models and Views to the project by right clicking and choose “Include in Project” on the folders.
5. Add reference to EPiServer.Shell, EPiServer.Data (found by browse to bin folder), system.web.mvc and system.runtime.serialization (found on the .NET tab).
6. Build the solution, go the the dashboard and you will see your poll gadget. (Even though it has no data yet, since you probably haven’t visited the demo page to use the Xform)

Feel free to ask any questions about the installation and I will try to help and update this. (Sorry for not beeing the ultimate installer guy and making some cool installer).

Download the Code here: Download

This is a little how-to on making it easier to share your episerver projects between multiple developers by making the location of the episerver resources more abstract.

1. Don’t use absolute file locations in your web.config.

Instead of pointing directly to the absolute file locations of your unified filesystem like:

• c:\EPiServer\VPP\MySite\Global
• c:\EPiServer\VPP\MySite\PageFiles
• c:\EPiServer\VPP\MySite\Documents

or even the episerver installation folder

• C:\Program Files (x86)\EPiServer\CMS\5.2.375.133\application\Util
• C:\Program Files (x86)\EPiServer\CMS\5.2.375.133\application\UI
• C:\Program Files (x86)\EPiServer\CMS\5.2.375.133\application\App_Themes\Default
• C:\Program Files (x86)\EPiServer\CMS\5.2.375.133\application\WebServices

You should rater create local shares on the  C:\EPiServer\VPP\MySite and the C:\Program Files (x86)\EPiServer folders. This helps you abstract the physical disk location of these resources. Some developers might need to store on a seperat disk than the c-drive and some developers might not have 64-bit machines and the episerver installation would be located under C:\Program Files\EPiServer instead of C:\Program Files (x86)\EPiServer. This is useful when dealing with a large web.config files that you would like to share through the source control.

<!—PageFiles folder –>

<add showInFileManager="false" virtualName="Page Files" virtualPath="~/PageFiles/" bypassAccessCheck="false" name="SitePageFiles" type="EPiServer.Web.Hosting.VirtualPathVersioningProvider,EPiServer" indexingServiceCatalog="Web" physicalPath="\\127.0.0.1\MySite$\PageFiles" />

<!—Global folder –>

<add showInFileManager="true" virtualName="Global Files" virtualPath="~/Global/" bypassAccessCheck="false" name="SiteGlobalFiles" type="EPiServer.Web.Hosting.VirtualPathVersioningProvider,EPiServer" indexingServiceCatalog="Web" physicalPath="\\127.0.0.1\MySite$\Global" />

<!—Documents folder–>

<add showInFileManager="true" virtualName="Documents" virtualPath="~/Documents/" bypassAccessCheck="false" maxVersions="5" name="SiteDocuments" type="EPiServer.Web.Hosting.VirtualPathVersioningProvider,EPiServer" physicalPath="\\127.0.0.1\MySite$\Documents" />

<!—EPiServer folders –>

<add name="UtilFiles" virtualPath="~/Util/" physicalPath="\\127.0.0.1\EPiServer$\CMS\5.2.375.133\application\Util" type="EPiServer.Web.Hosting.VirtualPathNonUnifiedProvider,EPiServer" />
<add name="App_Themes_Default" virtualPath="~/App_Themes/Default/" physicalPath="\\127.0.0.1\EPiServer$\CMS\5.2.375.133\application\App_Themes\Default" type="EPiServer.Web.Hosting.VirtualPathNonUnifiedProvider,EPiServer" />
<add name="WebServiceFiles" virtualPath="~/WebServices/" physicalPath="\\127.0.0.1\EPiServer$\CMS\5.2.375.133\application\WebServices" type="EPiServer.Web.Hosting.VirtualPathNonUnifiedProvider,EPiServer" />
<add name="UI" virtualPath="~/cms/" physicalPath="\\127.0.0.1\EPiServer$\CMS\5.2.375.133\application\UI" type="EPiServer.Web.Hosting.VirtualPathNonUnifiedProvider,EPiServer" />

NB You might abstract the location of the “Global”, “PageFiles” and “Documents” even more by replacing the local machine mapping \\127.0.0.1\  with a custom machine name. e.g  \\mysitefilesystem\. Then do a mapping to the wanted machine through c:\windows\system32\drivers\etc\host file.

2. Exclude the connectionStrings.config file from the source control

Some developers might want to use a local database and some might use a database stored on a shared location during the development process.

Thanks to the great work of Joel Abrahamsson (here his first stab at the solution) and a little more prototyping, it looks like EPiServer and MVC can play together very well! Time to say goodbye to asp.net webforms templates on EPiServer?

At Syzygy, we got this working with EPiServer 5.2.375.236 (the latest production version), MVC 1.0 and recompiled versions of the PageTypeBuilder and Castle DynamicProxy2 assemblies (the reason for this was to solve trust exceptions when the code was running from IIS 7.5).

The trick to get the EPiServer Friendly URL rewriter to play nicely with MVC is to use custom MvcHandler and IControllerFactory implementations: a wild-card style route can be passed to the custom handler which then will be able to:

• find out from EPiServer the ID of the content item (from the friendly URL)
• load the page data
• read custom properties of the page data such as “ControllerName” and “ActionName”
• forward the page data to the correct controller / action through our controller factory

So, in our prototype, we implemented the custom MVC handler with the following code:

		protected override void ProcessRequest(HttpContextBase httpContext)
		{
			var internalUrlBuilder = GetInternalUrl(httpContext.Request.RawUrl);
			var mvcPage = CurrentPageResolver.Instance.GetCurrentPage(internalUrlBuilder.QueryCollection["id"] ?? string.Empty);
			var controllerName = mvcPage.ControllerName;
			var actionName = mvcPage.ActionName;

			RequestContext.RouteData.Values.Add("action", actionName);
			RequestContext.RouteData.Values.Add("controller", controllerName);

			RequestContext.RouteData.Values["data"] = mvcPage;

			var controller = ControllerBuilder.Current.GetControllerFactory().CreateController(RequestContext, controllerName);
			controller.Execute(RequestContext);
		}

This code will intercept the request, convert the raw URL (as generated by the EPiServer Friendly URL rewriter) into the internal EPiServer URL, which will give us the ID of the content item (or, when in edit mode, the ID followed by an underscore and the version ID – i.e. “the slug”).

At this point, we can use any custom class to call the EPiServer DataFactory and get the PageData object. In our custom CurrentPageResolver class, the page data is cast to the base class for all our page types (MvcPageData), which contains information about the controller and the action to use for rendering.

using System;
using System.Collections.Generic;
using EPiServer;
using EPiServer.Core;
using MvcCms.Bases;

namespace MvcCms.Utilities
{
    public class CurrentPageResolver
    {
        private static readonly CurrentPageResolver instance = new CurrentPageResolver();

        private CurrentPageResolver()
        {
        }

        public static CurrentPageResolver Instance
        {
            get { return instance; }
        }

        public MvcPageData GetCurrentPage(string id)
        {
            if (String.IsNullOrEmpty(id))
            {
                return GetHomePage();
            }

            return IsWorkPage(id) ?
                           GetWorkPage(id) : GetPage(id);
        }

        private static bool IsWorkPage(string id)
        {
            return id.Contains("_");
        }

        private static MvcPageData GetWorkPage(string slug)
        {
            PageData page = null;

            string[] splitSlug = slug.Split(new[] {'_'}, StringSplitOptions.RemoveEmptyEntries);

            int pageId;
            if (splitSlug.Length > 1 && int.TryParse(splitSlug[0], out pageId))
            {
                int workPageId;
                if (int.TryParse(splitSlug[1], out workPageId))
                {
                    var workPageReference = new PageReference(pageId, workPageId);
                    page = DataFactory.Instance.GetPage(workPageReference);
                }
            }

            return page as MvcPageData;
        }

        protected MvcPageData GetPage(string id)
        {
            int pageId;
            if (int.TryParse(id, out pageId))
            {
                var pageReference = new PageReference(pageId);
                return DataFactory.Instance.GetPage(pageReference) as MvcPageData;
            }

            return null;
        }

        public static MvcPageData GetHomePage()
        {
            return DataFactory.Instance.GetPage(PageReference.StartPage) as MvcPageData;
        }

        public List<MvcPageData> GetChildren()
        {
            return GetChildren(GetHomePage().PageLink);
        }

        public List<MvcPageData> GetChildren(PageReference parent)
        {
            PageDataCollection pages = DataFactory.Instance.GetChildren(parent);
            var list = new List<MvcPageData>(pages.Count);
            foreach (PageData page in pages)
            {
                list.Add(page as MvcPageData);
            }
            return list;
        }
    }
}

Our page type base (MvcPageData) class looks like this:

using System.Collections.Generic;
using MvcCms.Utilities;
using PageTypeBuilder;

namespace MvcCms.Bases
{
    public abstract class MvcPageData : TypedPageData
    {
        public abstract string ControllerName { get; }
        public virtual string ActionName
        {
            get
            {
                return "Index";
            }
        }

        public string PageUrlSegment
        {
            get { return this.GetPropertyValue(page => page.PageUrlSegment); }
        }

        public virtual List<MvcPageData> Children
        {
            get
            {
                if (PageLink == StartPage.PageLink)
                {
                    return new List<MvcPageData>(0);
                }

                return CurrentPageResolver.Instance.GetChildren(PageLink);
            }
        }

        public virtual List<MvcPageData> SiteLinks
        {
            get { return CurrentPageResolver.Instance.GetChildren(StartPage.PageLink); }
        }

        public MvcPageData StartPage
        {
            get { return CurrentPageResolver.GetHomePage(); }
        }
    }
}

The custom controller factory will use the information that is contained in the route data to create the correct controller from the available ones. Once the controller is created, this will again be able to use the MvcPageData available in the route data (through a custom model binder), and pass it to a view.

The last step would be to wire up all the work in the global.asax, ignoring the requests to edit, admin, util and app_themes URLs.

		protected void Application_Start(Object sender, EventArgs e)
		{
			ControllerBuilder.Current.SetControllerFactory(new MvcControllerFactory());
			ModelBinders.Binders.Add(typeof (MvcPageData), new PageDataModelBinder());

			RegisterRoutes(RouteTable.Routes);
		}

		public static void RegisterRoutes(RouteCollection routes)
		{
			routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
			routes.IgnoreRoute("cms/{*pathInfo}");
			routes.IgnoreRoute("util/{*pathInfo}");
			routes.IgnoreRoute("app_themes/{*pathInfo}");

			routes.Add(new Route("{*data}", new WildCardRouteHandler()));
		}

In order to get the solution working, you’ll need to follow the instructions in the readme.txt file. Any problems, contact me.

Enjoy!

Fabio

I kristider och lågkonjunkturer sparar företagen. De insatser som ändå görs måste vara kostnadseffektiva och kunna leverera mätbar effekt i form av siffror som går att presentera för att få vidare förtroende.

Trenden visar att webben är det media som går bäst. EpiServer har gjort en undersökning bland marknadschefer ang vad de tänker lägga sina marknadspengar framöver. “Fyra av tio företag kommer att öka investeringarna på sin sajt under det kommande året och tre av fyra ska investera i sajten året som kommer” (dagensmedia.se).

Låter bra tycker jag som jobbar på just en webbyrå . Det jag ser som en av webbens största fördelar är att den är just kostnadseffektiv jämfört med exempelvis tryckt media. Dessutom går det att mäta sina investeringar på webben på ett helt annat sätt än annonser i tidningar etc. Med hjälp av webbanalyser och statistik kan man få fram exakta siffror på vad sin webbinvestering har gett för resultat i pengar. Helt otroligt, men ack så sant.

In a customer project, I needed to do lookups against the Norwegian postal register. Normally, I have made a table in a SQL database or had an XML file that I have query against. This has created several problems, like to keep the register updated.

GeoNames is geographical database available under a Creative Common attribution license. This data is accessible free of charge through a number of web services. One of the services you can query against is postal register for over 40+ countries. Send postal code and country code (ISO-3166), and get data like city, county, county number and postal code back.

I’ve created an interface to the webservice "PostalCodeLookup". You find the code here : http://snipplr.com/view/16844/postal-code/

Recently i stumbled into a problem where I needed to import already existing user-accounts from an old website into a new EPiServer website that was using the ASP.NET Membership-system.

The question was:

• How can you automatically create approximately 7,500 user-accounts in an easy way by using the ASP.NET Membership-system?
• What are the requirements for doing this and is it possible to connect the newly created user-account with a certain role or several roles?
• What about Profiles? Can you create the UserProfile as a part of the import-process?

Well, after a little research i came up with the following solution:

• Create a Windows desktop-application (this is not a requirement, but it eases the development process) that uses the classes for the ASP.NET Mebership system.
• Make sure the application can access the datasource for the old useraccounts; preferable a SQL Server database or some sort of datasource that is easy to extract data from.
• Log every account that is imported even if the import failed in order to investigate the reason for the failure.

Requirements:

• The passwords must be in clear-text in the datasource you are importing from. When the account is created in the ASP.NET Membership-system the password will be hashed/encrypted which means that you will not be able to read it in clear-text, so this is a one-way import process.

The solution is quite simple and straightforward. A couple of methods and some configuration makes it possible to create n user-accounts from the old membership-system.

The client application.

   1: using System;

   2: using System.Collections.Generic;

   3: using System.ComponentModel;

   4: using System.Data;

   5: using System.Drawing;

   6: using System.Linq;

   7: using System.Text;

   8: using System.Windows.Forms;

   9: using System.Web;

  10: using System.Web.Profile;

  11: using System.Web.Security;

  12: using System.IO;

  13:  

  14: namespace AccountConverter

  15: {

  16:     public partial class frmConvert : Form

  17:     {

  18:         public frmConvert()

  19:         {

  20:             InitializeComponent();

  21:         }

  22:  

  23:         /// <summary>

  24:         /// Start the conversion process.

  25:         /// </summary>

  26:         /// <param name="sender"></param>

  27:         /// <param name="e"></param>

  28:         private void btConvert_Click(object sender, EventArgs e)

  29:         {

  30:             // Get all active users 

  31:             List<ConvertingCustomer> oldAccounts = GetOldAccounts();

  32:  

  33:             progressBar1.Minimum = 0;

  34:             progressBar1.Maximum = oldAccounts.Count();

  35:  

  36:             // Iterate through all users that should be converted.

  37:             int i = 0;

  38:             foreach (ConvertingCustomer account in oldAccounts)

  39:             {

  40:                 // Set current rownumber

  41:                 i += 1;

  42:  

  43:                 try

  44:                 {

  45:                     // Convert the current account

  46:                     CreateAccount(account);

  47:  

  48:                     // Update the listbox with status for the current account

  49:                     UpdateListBox(i, string.Format("SUCCESS: {0}\t{1}",

  50:                         account.AccountNumber,

  51:                         account.UserName));

  52:  

  53:                     // Log that the account was successfully converted

  54:                     Log(account.AccountNumber, ConvertStatus.SUCCESS.ToString(), "Account was successfully converted.");

  55:                 }

  56:                 catch (Exception ex)

  57:                 {

  58:                     // Update the listbox with status

  59:                     UpdateListBox(i, string.Format("FAILED: {0}\t{1}\t{2}",

  60:                         account.AccountNumber,

  61:                         account.UserName,

  62:                         ex.Message));

  63:  

  64:                     // Log that the account could not be converted

  65:                     Log(account.AccountNumber, ConvertStatus.FAILED.ToString(), ex.Message);

  66:                 }

  67:  

  68:                 // Update the progressbar

  69:                 progressBar1.Value = i;

  70:                 progressBar1.Update();

  71:             }

  72:         }

  73:  

  74:         /// <summary>

  75:         /// Convert a single account. Create a new account with the ASP.NET Membership-system, connect it to a certain role and create an user-profile.

  76:         /// </summary>

  77:         /// <param name="convertingCustomer">An object with necessary data for the customer to be converted.</param>

  78:         private void CreateAccount(ConvertingCustomer convertingCustomer)

  79:         {

  80:             // Create the User

  81:             MembershipUser mu = Membership.CreateUser(

  82:                 string.Format("{0}{1}", "TEST_", convertingCustomer.UserName),

  83:                 convertingCustomer.Password,

  84:                 convertingCustomer.UserName);

  85:             mu.IsApproved = true;

  86:  

  87:             // Add the user to the Customers-role

  88:             Roles.AddUserToRoles(

  89:                 convertingCustomer.UserName,

  90:                 new string[] { "Customers" });

  91:  

  92:             // Update the User-Profile

  93:             WebProfile webProfile = new WebProfile(WebProfile.Create(convertingCustomer.UserName));

  94:             webProfile.Email = convertingCustomer.UserName;

  95:             webProfile.CustomerNumber = convertingCustomer.AccountNumber;

  96:             // ... add your own fields here

  97:             webProfile.Save();

  98:         }

  99:         

 100:         /// <summary>

 101:         /// Connect to a datasource and get data for the old accounts that is to be converted.

 102:         /// </summary>

 103:         /// <returns></returns>

 104:         private List<ConvertingCustomer> GetOldAccounts()

 105:         {

 106:             // Get old account-data.

 107:             //var myOldAccounts = datasource.GetAccounts();

 108:  

 109:             // Get accounts from datasource

 110:             //var accountDataList = from account in myOldAccounts

 111:             //                      select new ConvertingCustomer

 112:             //                      {

 113:             //                          AccountNumber = account.CustomerId,

 114:             //                          UserName = account.UserName,

 115:             //                          Password = account.Password

 116:             //                      };

 117:             //return accountDataList.ToList<ConvertingCustomer>(); 

 118:             

 119:             return new List<ConvertingCustomer> 

 120:             {

 121:                 AccountNumber = "123456",

 122:                 UserName = "TestUser@labs.com",

 123:                 Password = "Pa$$w0rd"

 124:             }

 125:         }

 126:         

 127:         /// <summary>

 128:         /// Log the progress with the account conversion.

 129:         /// </summary>

 130:         /// <param name="accountNumber">The customers accountnumber in the backend.</param>

 131:         /// <param name="status">Status of the progress.</param>

 132:         /// <param name="message">An errormessage or a message with information about the conversion.</param>

 133:         private void Log(string accountNumber, string status, string message)

 134:         {

 135:             using (StreamWriter sw = new StreamWriter(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "convert.log"), true, Encoding.UTF8))

 136:             {

 137:                 sw.WriteLine("{0}\t{1}\t{2}", status, accountNumber, message);

 138:             }

 139:         }

 140:  

 141:         /// <summary>

 142:         /// Update the ListBox in the GUI to display the progress.

 143:         /// </summary>

 144:         /// <param name="recordNumber">An integer with the rownumber of the account that was processed.</param>

 145:         /// <param name="message">The resulting message from the conversion process.</param>

 146:         private void UpdateListBox(int recordNumber, string message)

 147:         {

 148:             lbConvertProgress.Items.Insert(0, string.Format("#{0} - {1}", recordNumber, message));

 149:             lbConvertProgress.Update();

 150:         }

 151:         

 152:         /// <summary>

 153:         /// An internal class used to handle customer-data. 

 154:         /// </summary>

 155:         private class ConvertingCustomer

 156:         {

 157:             public string UserName;

 158:             public string Password;

 159:             public string AccountNumber;

 160:         }

 161:         

 162:         /// <summary>

 163:         /// An enum with conversion-status.

 164:         /// </summary>

 165:         private enum ConvertStatus

 166:         {

 167:             SUCCESS,

 168:             FAILED

 169:         }

 170:  

 171:     }

 172: }

The App.Config-file.

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

   2: <configuration>

   3:     <connectionStrings>

   4:         <add name="MyDataSourceConnectionString"

   5:              connectionString="Data Source=myDatabaseServer;Database=myDatabase;User Id=myDBUser;password=P@ssw0rd;Connection Timeout=30"

   6:              providerName="System.Data.SqlClient" />

   7:     </connectionStrings>

   8:     <system.web>

   9:         <membership defaultProvider="SqlServerMembershipProvider">

  10:             <providers>

  11:                 <clear/>

  12:                 <add name="SqlServerMembershipProvider"

  13:                      type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"

  14:                      connectionStringName="MyDataSourceConnectionString"

  15:                      requiresQuestionAndAnswer="false"

  16:                      applicationName="MyWebApplication"

  17:                      requiresUniqueEmail="true"

  18:                      passwordFormat="Hashed"

  19:                      maxInvalidPasswordAttempts="5"

  20:                      minRequiredPasswordLength="6"

  21:                      minRequiredNonalphanumericCharacters="0"

  22:                      passwordAttemptWindow="10"

  23:                      passwordStrengthRegularExpression=""/>

  24:             </providers>

  25:         </membership>

  26:         <roleManager enabled="true"

  27:                      defaultProvider="SqlServerRoleProvider">

  28:             <providers>

  29:                 <clear/>

  30:                 <add name="SqlServerRoleProvider"

  31:                      connectionStringName="MyDataSourceConnectionString"

  32:                      applicationName="MyWebApplication"

  33:                      type="System.Web.Security.SqlRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"/>

  34:             </providers>

  35:         </roleManager>

  36:         <profile enabled="true"

  37:                  defaultProvider="SqlProfile"

  38:                  automaticSaveEnabled="true">

  39:             <properties>

  40:                 <add name="CustomerNumber"

  41:                      type="System.String"/>

  42:                 <add name="Email"

  43:                      type="System.String"/>

  44:                 <add name="Name"

  45:                      type="System.String"/>

  46:                 <add name="Phone"

  47:                      type="System.String"/>

  48:                 <add name="CellPhone"

  49:                      type="System.String"/>

  50:             </properties>

  51:             <providers>

  52:                 <clear/>

  53:                 <add name="SqlProfile"

  54:                      type="System.Web.Profile.SqlProfileProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"

  55:                      connectionStringName="MyDataSourceConnectionString"

  56:                      applicationName="MyWebApplication"/>

  57:             </providers>

  58:         </profile>

  59:     </system.web>

  60:     <appSettings />

  61: </configuration>