Karoline Klever

“Let more people experience that boobs and coding ability are not mutually exclusive” – My Response to “The Token Female”

2012-01-03T09:28:00.001+01:00

Sitting down with my morning coffee, I just came across a retweet by one of my followers on Twitter. The tweet referred to “The token female” by Christin Gorman.

Being a female developer I never seize to be amazed by all the female developer vs. male developer discussions out there, but so far I have been able to stay on the sideline. This blog post, however, triggered something in me (I think it was the sentence “Let more people experience that boobs and coding ability are not mutually exclusive”) and I immediately felt the need to write a response.

I do not agree with all of Christin’s views, particularly her view of placing computer science students in classes based on skills. My main inspiration in life has always been talented piers, and had I not been allowed into the same class as my university friends who have programmed since their early school days, I’m afraid I would have lost a lot of motivation.

While not agreeing with her view on this, I do see her point. Like her, I had never programmed before I started university and of course the guys in my class never asked me a question they needed the answer to. Why should they? They had 3-5 years more experience than me, and all I did was to ask “stupid” questions. My belief is that there are no stupid questions, the only stupid thing you can do is not to ask. So after a year of “stupid” questions I slowly saw things changing. My male friends suddenly started asking me questions, they began to discuss the assignments with me, asking me for help. Their patience and helpfulness had helped me reach their level. BUT, if I had been put in a class containing students with the same (lack of) skills as me, I suspect it would have taken 3-5 years for me to reach this level instead of 1-2 years.

Christin Gorman describes a couple of scenarios in which she has directly been doubted as a female developer from a technical perspective, but I have been lucky enough not to experience this (so far). I know it will happen at some point, and it will probably happen more than once, but I am prepared for that. I have, on the other hand, received quite a lot of inappropriate comments from men I have met in various work related situations. These comments have spanned from “The only reason you got this job is because you’re female” to comments bordering to sexual harassment. As these comments all have come from men who have not actually seen my work, I have been able to shrug them off without much thought. If I have thought anything at all it’s been “Just wait, I’ll show you how good I can be”.

I will always continue to ask “stupid” questions, and my fellow male developers who know me well also know that the reason I do this is so I can become better. Some of them might even stop to think that having to answer all these questions will actually make them better at the same time. But the one thing I’m most grateful for above all, is that my colleagues at Epinova have never doubted my skills as a female developer. They are a living proof of male developers knowing that “boobs and coding ability are not mutually exclusive”.

Most female developers I know have had similar experiences to the ones described by Christin Gorman or myself. While these experiences can be aggravating or hurtful, it has to be said: There is no better feeling than proving you can kick ass AND be a female developer at the same time!

So thank you to Chrisin Gorman for a great blog post. Now, male or female, let us kick some ass!

FusionCharts (v3.2.2) javascript bug in IE 8

2011-12-08T11:25:00.001+01:00

A customer I’m working with requires data generated charts on their EPiServer website, and for that purpose I’ve implemented FusionCharts. By default FusionCharts render Flash charts with a javascript fallback, or you can simply choose to always render javascript charts if you’re not a fan of Flash.

The FusionCharts documentation is one of the best documentations I’ve ever seen, a pleasure to read, and the installation takes two minutes. Seems like a blast doesn’t it!

I thought so until the front-end developer for the project I’m working on came over to my desk and informed me that the charts did not render in IE 8. They worked fine in IE 7 and IE 9, but not IE 8. Say what? I checked it out and saw that FusionCharts.js gave me a “Invalid argument” error on line 76. Since Google is my friend, I googled the problem and found A LOT of other developers on the FusionCharts forum running into the same problem, but the only answer from FusionCharts was that their developers were working on it. They’ve been working on it for over a month and could not say when the bug would be fixed.

The project is going live in about two weeks, so I don’t have time to wait for other developers to fix their bugs. I tried downgrading to the previous version of FusionCharts, but that caused me some other problems, so I went back to v3.2.2. I googled some more and found a FusionCharts service release that was newer than the version I am using, but the javascript error seemed to be living happily ever after.

So what solved my problems?

I have several charts on one page, and therefore each chart needs its separate ID. Being a developer, I set the ID to be a number (big mistake). Apparently the ID can contain numbers, but it cannot begin with a number, so ID=Chart1 is fine, but ID=1Chart will give you a javascript error in IE 8.

Hopefully they’ll fix this in the next version, or at least add a note of it in their (almost) perfect documentation.

Epinova.CRMFramework version 1 has been released!

2011-10-28T10:43:00.001+02:00

For the last couple of years I’ve worked with several customers who wanted to integrate their websites with Microsoft Dynamics CRM 4.0. There are several frameworks available for doing just that, but I never found one that I was 100% satisfied with so I began playing with the thought of creating my own framework.

Then a year ago, I found myself having a couple of weeks of free time between two jobs and I decided to give it a go. I sat in a café with my laptop for the next couple of weeks, and after a lot of coding and coffee drinking I released the alpha version of Epinova.CRMFramework.

So what was so wrong with the other frameworks out there? The main problem was that none of them were as generic as I needed them to be. You could only work with standard CRM entities, and as soon as you needed a custom entity you would have to make a hack in order to do this. The ones that supported both standard and custom entities were not able to retrieve many-to-many relationships or required extreme amounts of configuration in order to do this.

I set myself a list of goals, the framework would be

- generic and developer friendly
- able to do all necessary operations (create, read, update, delete) on all types of entities (standard and custom)
- able to retrieve one-to-one, one-to-many and many-to-many relationships between entities.
- easy to configure, the amount of configuration should be kept at a minumum.

A year later, the framework has been thoroughly tested and I have fulfilled these goals. It has been used by a large customer for half a year and they haven’t run into any problems so far. I plan on keeping it that way!

You can download Epinova.CRMFramework and read the documentation on codeplex.

Now that version 1 is out, it’s time to plan the next version. I’ve received a lot of questions regarding support for Microsoft Dynamics 2011, and this is my main goal for version 2. I also know that a lot of people want a membership provider to be included in the framework, but I’ll have to give this some thought.

I’ll keep you posted when I’ve thought my plans through! For now, enjoy my framework and let me know if you have any questions :) I’m getting myself a coffee to celebrate!

EPiServer vNext Falcon Seminar – My thoughts

2011-09-15T11:07:00.001+02:00

I’ve been spending the last couple of days in the beautiful city of Stockholm in order to attend the EPiServer vNext Falcon Seminar and meet up with the Swedish developers we see every day at Twitter and EPiServer World.

The Swedish hospitality has been great, in the form of lunches and drinks and also borrowing a work desk at the Nansen office. Thank you very much, Martin Söderlund and Leif Boström!

So then, EPiServer vNext Falcon! There were three key points in the presentations, I will go through each one and state my thoughts. EPiServer made it very clear that this is all work in progress, and things might (and probably will to some extent) change. So to you reading this blog post two years from now: These are my private opinions based on how I interpreted what was said during the presentations.

Add-Ons

The Add-On system is a piece of functionality that I think will be loved by editors and potentially frowned upon by developers if EPiServer don’t play their cards right.

The Add-On system can be compared to an “App Store” where editors can install Add-Ons to their website without involving any developers. The Add-Ons will be available through a NuGet feed and will probably have to go through an approval process in order to become available.

There are quite a few interesting challenges when it comes to this, and these possible challenges were made clear in the Q&A after the presentation:

- How will EPiServer deal with Add-Ons and load-balancing?
- How will EPiServer ensure that a site doesn’t break when an editor installs an Add-On?
- Will contributing developers be compensated for creating an Add-On?

In addition to the Add-On system, there was a short presentation on Localiation. EPiServer announced that their language files will be included as embedded resources in vNext. I quite like this, as it removes EPiServers files from the developers files, and I can’t remember ever having to edit one of the EPiServer language files.

Typed pages

This is a huge one!! We’re all familiar with PageTypeBuilder, every developers dream and every editors nightmare, and EPiServer has come to the terms that they need to include typed pages in order to make us all just a little bit happier.

One of the things I found quite interesting is the concept of Blocks (another term for property groups). Grouping of properties into Blocks (for example an image, and alternative text and a link) will diminish the need for custom properties. This in connection with allowing complex property types such as Lists or Dictionaries will in the long run mean that we won’t need custom properties at all. Oh joy!

EPiServer also suggested that properties defined in code should be made hidden (or not editable) for editors. One of the issues we’ve had with PageTypeBuilder is when a property’s attribute (such as SortIndex) is set in code, and the editor changes this attribute, the change made by the editor will be overridden when a new deploy is done. Hiding properties defined in code from the editors will (hopefully) solve this issue.

MVC Support

This is another case that deserves a large Woho! I’ve been drooling over ASP.NET MVC for quite a while, but creating Gadgets doesn’t quite dry up the drool. We were shown how MVC Routing will be implemented to work with EPiServer friendly URLs. The fact that a site can contain both web forms and MVC is even better.

There are a couple of downsides for the editors though. On-page-edit won’t work with MVC and neither will the right click menu.

Disappointments

I was hoping I wouldn’t need this section of the blog post, but sadly I do. I’m very disappointed that EPiServer isn’t giving the File Manager any love. It’s a pain for the editors to work with, and it’s quite outdated compared to how everyone have gotten used to managing files.

Unconfirmed rumors and possible bogus

- Will edit mode “disappear” in the long run to be replaced with an on-page-edit like UI with Widgets?

- As a result of the previous point, will on-page-edit disappear?

- Will edit and admin mode be rewritten to MVC?

- Are the developers at EPiServer superheroes who will be able to deliver all of this in Q1?

Authenticate a Web Service in EPiServer using a SQL Server membership account

2011-08-26T16:16:00.001+02:00

I dumped into some trouble today, trying to authenticate a web service in EPiServer using a SQL Server membership account. You would think following the steps in the Web Services tech note would be enough. However, the tech note is missing some important information. Therefore I thought I’d create a small overview myself.

Assumptions:

1) You have created a web service in the WebServices folder of your EPiServer website. Or you are trying to authenticate one of the build-in web services using a SQL Server membership account.

2) You have configured EPiServer to Enable Basic Authentication by adding the BasicAuthentication http module in the <system.web><httpModules> section (for IIS 6) or <system.webserver><modules> section (for IIS 7) of your web.config file:

<system.webServer>
    <modules ...>
        <add name="BasicAuthentication" type="EPiServer.Security.BasicAuthentication, EPiServer" />
        <!-- Other modules -->
    </modules>
</system.webServer>

3) You have a <location path=”WebServices”> section in your web.config file:

<location path="WebServices">
    <episerver.basicAuthentication sendBasicChallenge="true" basicRealm="" />
    <system.web>
      <httpRuntime maxRequestLength="1000000" />
      <authorization>
        <allow roles="Administrators, WebServices" />
        <deny users="*" />
      </authorization>
    </system.web>
    <system.webServer>
      <validation validateIntegratedModeConfiguration="false" />
      <handlers>
        <clear />
        <add name="webresources" path="WebResource.axd" verb="GET" type="System.Web.Handlers.AssemblyResourceLoader" />
        <add name="WebServiceHandlerFactory-Integrated" path="*.asmx" verb="GET,HEAD,POST,DEBUG" type="System.Web.Services.Protocols.WebServiceHandlerFactory, System.Web.Services, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" modules="ManagedPipelineHandler" scriptProcessor="" resourceType="Unspecified" requireAccess="Script" allowPathInfo="false" preCondition="integratedMode" responseBufferLimit="4194304" />
        <add name="wildcard" path="*" verb="*" type="EPiServer.Web.StaticFileHandler, EPiServer" />
      </handlers>
    </system.webServer>
  </location>

4) You have created a group called WebServices in EPiServer admin mode, and have added a SQL membership user to this group. This is the user you want to authenticate your web service with.

5) You have disabled integrated authentication and basic authentication in IIS.

So, what’s the problem?

If you test your web service in a browser (http://localhost/WebServices/MyWebService.asmx), you should get a windows login window instead of the http://localhost/util/login.aspx page. Awesome! This means that you’ve configured everything correctly.

Now if you’re unlucky like me, you will get an unauthorized message when trying to logon using the web service user you created in step 4. So you go over your configuration again and again and again. But everything looks correct…

So what the tech note fails to mention is the fact that your web service user has to be added to the list of web service users under “Permissions to functions” in Admin mode.

So, add the user and voilá!

NDC2011 Aftermath

2011-06-15T13:55:00.001+02:00

Last week I attended the Norwegian Developers Conference for the first time during my career, and I must say I was impressed!

Before the conference my expectations to learn something new, fuel up on motivation, meet old friends and make new friends. Looking back, I can with a 100% certainty say that these expectations were met.

Top sessions (of the ones I was able to make it to):

1. “ASP.NET MVC 3, EF Code First, NuGet, and IIS Express” by Scott Guthrie

This session gave a great overview ASP.NET MVC 3, EF Code First, NuGet and IISExpress which I at this point hadn’t had the chance to try out properly in a project. Needless to say, Scott Guthrie is amazing and so was his session! I got high on ASP.NET MVC 3 after this session, and I’m hoping I’ll have the chance to try it out more in a real life project in near future.

2. “Because You Suck at Design Patterns” by Gary Short

Gary Short gave a great overview of the mostly used design patterns and how most of us use them wrong. One of his most important messages was to know your platform. A design pattern in C++ might not be the same as in C#. This session confirmed to me that I, in fact, do suck at design patterns. So now I’m up for some relearning :)

3. “Functional Programming in C#” by Oliver Sturm

I had a Scheme course in University that I absolutely hated, so I thought I’d try to look into functional programming with an open mind when attending this session. The session was interesting, although at some points I was happy I’d brought coffee. It was very interesting to see the effect of functional programming in C#, but I don’t see myself becoming a huge fan of functional programming any time soon.

4. “Progressive EPiServer Development” by Joel Abrahamsson

Joel Abrahamsson took us though his thoughts on flaws in EPiServer and frameworks created in order to avoid these flaws. Most of it, I’d heard before, but I found a few things quite interesting. For example the future plans of PageTypeBuilder which I’m very much looking forward to!

5. “Continuous Deployment for ASP.NET” by Ben Hall

This session was just above average, but thanks to one sentence said during the presentation, this session was able to make it to my “top sessions” list. The sentence was “A deploy should be a non-event”. In most projects I’ve worked on so far, a deploy is THE greatest event, and the nerves and expectations are accordingly. This sentence made me decide to view depoys in a different way.

The social part

It was great meeting previous colleagues, old classmates and old friends at the conference!

Most of all, it was great to make new acquaintances :) As quite a lot of Swedish EPiServer developers were attending the conference, I decided to set up a dinner so we all could meet up. At first I was planning a small dinner in a restaurant, but as I realized that the number of Swedes coming to town was quite large, I decided to arrange the dinner at the Epinova office instead.

Close to 35 developers showed up, enjoying tapas, drinks and each others company. Quite a success, if I can say so myself! Unfortunately we had such a good time that we almost forgot to take any pictures, but here are the few (appropriate) I took:

I’m looking forward to NDC2012! :)

Remove old versions job in EPiServer CMS 6

2011-02-28T11:00:00.001+01:00

At the moment I’m creating a new EPiServer site for a customer. They have an existing CMS 6 site, and we need to migrate some content from the existing site to the new one.

The existing site was upgraded from EPiServer 4 to CMS 6, and it has never had a max value set for the number of page versions allowed per page. This means that for some pages there were 500 different page version.

So we definitely needed to do some cleaning before migrating the content. I found the Remove old versions job, but this is only for EPiServer 4.

I’ve rewritten the job so that it works on CMS 6. Mind you that I've not written this piece of code, I’ve only edited it to work for CMS 6. Unfortunately, I don’t know who wrote this code but all credit should be given to him/her!

Here’s the code:

[ScheduledPlugIn(DisplayName = "Clear old version job")]

public class RemoveOldPageVersionsJob

{

private static RemoveOldVersionsDb _removeOldVersionsDb;

private static int _maxVersions;

private static int _numberOfPagesRun;

/// <summary>

/// Start job

/// </summary>

public static string Execute()

{

_numberOfPagesRun = 0;

_removeOldVersionsDb = new RemoveOldVersionsDb();

_maxVersions = EPiServer.Configuration.Settings.Instance.UIMaxVersions;

PageData rootPage = DataFactory.Instance.GetPage(PageReference.StartPage);

FixBranch(rootPage);

return "Removed all old versions except " + _maxVersions + " for all pages (" + _numberOfPagesRun + ") as the following user: " + HttpContext.Current.User.Identity.Name;

}

private static void FixBranch(PageData page)

{

_numberOfPagesRun++;

_removeOldVersionsDb.RemoveVersions(page.PageLink.ID, _maxVersions);

PageDataCollection children = DataFactory.Instance.GetChildren(page.PageLink);

foreach (PageData child in children)

FixBranch(child);

}

public class RemoveOldVersionsDb : DataAccessBase

{

public void RemoveVersions(int pageId, int maxVersions)

{

try

{

OpenConnection();

IDbCommand cmd = CreateCommand("editDeleteObsoletePageVersions");

cmd.Parameters.Add(CreateParameter("PageID", pageId));

cmd.Parameters.Add(CreateParameter("MaxVersions", maxVersions));

cmd.ExecuteNonQuery();

}

finally

{

CloseConnection();

}

Page preview not visible in EPiServer edit mode

2011-01-27T09:48:00.001+01:00

After upgrading a site to EPiServer CMS 6, I tested the site and everything worked as it should. A couple of hours later I got an email from the customer saying that the page preview was not visible in edit mode. Everything else in edit mode was visible, except for the page preview.

I couldn’t understand this as I had tested everything, but after some investigation I realized that this only happened if you were not accessing the site from the server. And it only occurred in IE (in Firefox the page preview was working, but some of the buttons were missing).

It turns out I made a silly mistake, I forgot to check that the VPP folder paths were correct in the episerver.config file. Still, a missing page preview was a quite confusing indication of this. So if the same thing happens to you, you’ll now know what you can check :)

So the moral of the story is:

- Make sure your VPP folder paths are correct after an upgrade!
- Don’t just test the site from the server it’s on, test it from the outside as well….
- Don’t make silly mistakes like this ;)

Dynamic error pages in EPiServer with static fallback

2011-01-19T08:55:00.001+01:00

Recently, I got a request from a customer wanting a dynamic 404 error page. I told them I’d prefer them to stick to the static 404 error page they already had, as dynamic error pages can cause a lot of trouble. It’s recommended that a 404 page should not read from the EPiServer database or retrieve any graphics. This is due to the fact that if your 404 error page is an EPiServer page and someone deletes it on accident, you can end up in an infinite 404 loop. And we don’t want that, do we?

So what would be perfect was a dynamic error page with a static fallback! I started looking around at the plenty blog posts out there by other EPiServer developers and found some quite clever solutions. However, none of them worked quite the way I wanted it to. So then I did what I always do: Tweet about it!

The response was brilliant! A lot of people recommended the 404Handler on EPiCode, but this reads from the lang files and the customer wanted to edit the 404 page from edit mode. So I ruled that one out. Another solution, by Steve Celius, was to use the 404Handler on EPiCode and create a page that saves content to a lang file. This is in fact a good solution, but unfortunately it was presented to me too late. I had already implemented the solution explained below.

The savior of the day was Jens Altbäck, a system architect as SPV. He sent me some code he’d used in a previous project. I’ve simplified the code a bit and made a few modifications, but remember that the great mind behind it is Jens, not me. I’m just the one who’s obsessed with the “sharing is caring” mentality and therefore have an urge to blog about it :)

The idea of it all is simple! You need four things:

- ErrorPageType (optional, but recommended): A pagetype with whatever properties you need, for example Heading and ErrorMessage. You could leave this pagetype out and use one of your existing pagetypes instead, but in order to restrict the editors it’s recommended that you create this pagetype so that you can determine where in the pagetree the page can be created and who should have access to creating the error pages. As you can create this pagetype in whatever way you want, I will not show you how to do this. In the example below, however, I’ve assumed that the pagetype has two properties: Heading and MainBody.

- ErrorHandler.aspx: Determines how the error page should be displayed. Mind that the ErrorHandler.aspx is not used for any pagetypes!

- ErrorHandler.aspx.cs: Gets and sets the correct StatusCode for the Response, determines if an error page exists for the current error. If it exists, the ErrorHandler sets its currentpage to the errorpage, or else it redirects to the static error page.

- error.htm: Static error page.

Here’s a step by step guide to how this all should be put together:

1) Create your ErrorPageType

Create your ErrorPageType with the appropriate properties. Create a page of this pagetype called ‘Page not found’ somewhere in the pagetree of your EPiServer site.

2) Add a property to your startpage

Add a property to the startpage of your site. This property should be called ‘HTTPStatusCode4xxPage’ and be of type Page. Point this property to the page you created in step 1.

3) Create the error.htm static error page.

Create a static html error page called error.htm and put it in the root folder of your website. If the dynamic error page is missing, the user will be directed to this static error page instead.

4) Create the ErrorHandler

The codebehind should look like this:

public partial class ErrorHandler : Templates.Base.TemplateBase

{

private int statusCode = 0;

private PageData errorPage = null;

protected void Page_Init(object sender, EventArgs e)

{

GetStatusCode();

SetStatusCode();

SetErrorPage();

SetCurrentPage();

RedirectToDefaultErrorPage();

}

private void GetStatusCode()

{

// More to come...

}

private void SetStatusCode()

{

// More to come...

}

private void SetErrorPage()

{

// More to come...

}

private PageData GetHTTPStatusCodePage(string errorCodeProperty)

{

// More to come...

}

private void SetCurrentPage()

{

// More to come...

}

private void RedirectToDefaultErrorPage()

{

// More to come...

}

Let’s start by looking at the two first methods: GetStatusCode() and SetStatusCode(). In order for the ErrorHandler to work properly, we need to set Respone.StatusCode to the correct status code:

/// <summary>

/// Get the HTTP error status code from the querystring

/// </summary>

private void GetStatusCode()

{

string[] requestQueryStrings = Request.QueryString[0].Split(';');

if (requestQueryStrings.Length > 0)

{

int code = 0;

if (int.TryParse(requestQueryStrings[0], out code))

{

statusCode = code;

}

/// <summary>

/// Set the status code of the response

/// </summary>

private void SetStatusCode()

{

if (statusCode != 0)

{

Response.ClearHeaders();

Response.StatusCode = statusCode;

}

The next methods are the SetErrorPage() and the GetHTTPStatusCodePage() methods. SetErrorPage() uses GetHTTPStatusCodePage() to determine if an error page exists. If it does, the private PageData object called errorpage is set. Notice that you can extend the SetErrorPage() method to handle other errors than HTTP 404 as well as long as you create a property for it on the startpage and add it to the web.config (see step 5).

private void SetErrorPage()

{

switch (statusCode)

{

case 404:

PageData current4xxErrorPage = GetHTTPStatusCodePage("HTTPStatusCode4xxPage");

if (current4xxErrorPage != null)

{

errorPage = current4xxErrorPage;

}

break;

default:

break;

}

/// <summary>

/// Get the page set by the errorPagePropertyName on the startpage

/// </summary>

/// <param name="errorCodeProperty">Name of the startpages property</param>

/// <returns>The page set by the errorPagePropertyName</returns>

private PageData GetHTTPStatusCodePage(string errorPagePropertyName)

{

if (PageReference.StartPage == PageReference.EmptyReference)

return null;

PageData startPage = GetPage(PageReference.StartPage);

if (startPage != null)

{

PageReference errorPageRef = startPage[errorPagePropertyName] as PageReference;

if (!PageReference.IsNullOrEmpty(errorPageRef))

return GetPage(errorPageRef);

}

return null;

}

Last, but not least: Add the SetCurrentPage() and RedirectToDefaultErrorPage() methods. The SetCurrentPage() method is in my opinion the piece of code that makes this all so brilliant! If we were to redirect the user to the error page instead of setting current page and the user refreshed the page, the HTTP request done would be towards the error page, not the original page the user requested. Setting the currentpage ensures that is the user refreshes the page, the request done is towards the original page:

private void SetCurrentPage()

{

if (errorPage != null)

{

CurrentMasterPage.CurrentPage = errorPage;

}

private void RedirectToDefaultErrorPage()

{

if (errorPage == null)

{

Response.Redirect("~/error.htm", true);

}

And now the ErrorHandler.aspx. In this example I’ve assumed that the ErrorPageType contains two properties: Heading and ErrorMessage. So in ErrorHandler.aspx I want to display these two properties:

<%@ Page Language="C#" AutoEventWireup="true" MasterPageFile="~/Templates/MasterPages/MasterPage.master" CodeBehind="ErrorHandler.aspx.cs" Inherits="ActaWeb.ErrorHandler" %>

<asp:Content ID="Content1" ContentPlaceHolderID="BodyRegion" runat="server">

<EPiServer:Property PropertyName="Heading" DisplayMissingMessage="false" EnableViewState="false" runat="server" />

<EPiServer:Property PropertyName="ErrorMessage" DisplayMissingMessage="false" EnableViewState="false" runat="server" />

</asp:Content>

You might be wondering why this code is required, will it ever be displayed to the user? Oh yes, it will! As we’ve set currentpage in the codebehind instead of redirecting to the errorpage, this is in fact the code shown to the user. So it doesn’t matter how the ErrorPageType looks, as that will never be shown to anyone visiting the site, it will only be viewed by the editors in edit mode.

5) Edit the <httperrors> section of your web.config file

The <httperrors> section of the web.config should now look like this:

</httpErrors>

And that it!

I’d like to thank Jens Altbäck for showing me this great solution and letting me blog about it. If you’re wondering who this brilliant guy is, you should follow him on Twitter: @jensaltb

EasySearch - “The XSLT stylesheet could not be loaded”

2010-12-27T11:54:00.001+01:00

Right before christmas I got a “The XSLT stylesheet could not be loaded” error message from the EasySearch FacetCollection control on a customers test server. This confused me quite a lot as the FacetCollection control had worked without problems a couple of days earlier.

The first thing that came to mind when seeing this error message was access rights. Maybe the file permissions had been changed after the last deploy to the server? I checked this, and the file permissions were fine. So I checked the MIME types for .xsl and .xslt, but they were also correct. I suddenly realized that I was able to access the XSLT stylesheets by their url’s on the server, which meant that there had to be an access issue somewhere.

Unfortunately, I couldn’t find it. And to make matters worse, I couldn’t find the piece of code that returned the error message. So I ended up sending an email to NetworkedPlanet support. After asking me to check my file permissions (duh…), they found the issue.

The site was using Basic authentication! We had changed from Windows to Basic authentication a couple of days earlier, but apparently this line in the AbstractXmlControl.cs returns a HTTP 401 – Unauthorized exception if the site uses Basic authentication:

ret.Load(targetUri.ToString(), null, resolver);

Luckily, the site is supposed to use Windows authenication, so we simply switched back.

If you need to use Basic authentication, you can solve this issue by adding the XSLT stylesheet in the code behind:

FlatListFacet.XslStylesheet = File.ReadAllText(pathToXslt);

I’d like to thank the NetworkedPlanet support team for great service and resonse time!

EasySearch – Creating a custom index handler

2010-12-07T10:23:00.001+01:00

Lately, I’ve spent quite a lot of time figuring out EasySearch. There is a developer guide available, but sadly it is quite messy and brief. So in this blog post I’ll show you how to create a custom index handler in order to add a creation year field to your Lucene document.

The first thing we need to do is to create a custom index handler class. This class needs to inherit from the NetworkedPlanet.EasySearch.Lucene.IIndexHandler interface, which means it needs two methods: IndexFile(…) and IndexPage(…):

public class CustomIndexHandler : IIndexHandler

{

public CustomIndexHandler(){}

public bool IndexPage(PageData page, Document luceneDoc)

{

AddYearField(page, luceneDoc);

return true; // returns true, because this method should never block the indexing of a file

}

public bool IndexFile(UnifiedFile file, Document luceneDoc)

{

return true; // returns true, because this method should never block the indexing of a file

}

private void AddYearField(PageData page, Document luceneDoc)

{

// Add the last modified date of the file to a field named

// "modified". Use a field that is indexed (i.e., searchable),

// but don't tokenize the field into words.

luceneDoc.Add(new Field("creationYear", DateTools.TimeToString(page.Created.Ticks, DateTools.Resolution.YEAR), Field.Store.YES, Field.Index.UN_TOKENIZED));

}

The AddYearField adds a new “creationYear” field to the Lucene document. This field is given a year value, such as 2008, 2009, 2010. In order to invoke the index handler before the Lucene document is indexed in Lucene we need to register it in the <indexconfiguration> section in web.config:

<lucene:configuration>

<lucene:indexhandler Type="MyProject.CustomIndexHandler, MyProject"/>

</lucene:configuration>

It’s as easy as that! You can now use the creationYear field in the Lucene document in a facet or in any other way you need.

Happy coding!

The CRM Plugin Registration Tool

2010-10-29T15:27:00.001+02:00

After releasing the Epinova.CRMFramework, I’ve received a lot of questions regarding Microsoft Dynamics CRM to EPiServer communication.

A lot of customers want to store some of their CRM data in EPiServer. For example, if they create a new Account in CRM they automatically want a page to be created for this Account in EPiServer. Epinova.CRMFramework does not cover this, as it can only create, read, update and read information from EPiServer to CRM. When a new instance of an entity is created in CRM, EPiServer has no clue of this happening. You could of course create a scheduled job that checks for new instances of the entity every 5 minutes, but that would be a terrible solution! Don’t even think about doing that!

So what to do then? Luckily, a clever guy named Ajith has created a CRM Plugin Registration Tool. Using this tool you can register a plugin and attach it to the Save event of entities, and send the entities to a web service. The web service is of course a web service you’ve created in your EPiServer project.

I will blog more about this in detail when it’s not friday afternoon, this is only a short overview for those of you who need a solution instantly.

Have a great weekend! :)

The alpha version of the open source Microsoft Dynamics CRM Framework for EPiServer is now available!

2010-10-20T20:01:00.001+02:00

I’ve been working on a open source Microsoft Dynamics CRM Framework for EPiServer for a couple of months now. And I’m proud (and a bit nervous) to announce that it is now available: http://crmframework.codeplex.com/

I’ve tried to document the framework as thoroughly as possible, but there will definitely surface issues I haven’t documented thoroughly enough. So please feel free to contact me whether you have any questions, comments or feel for a chat :)

Technical thoughts on the open source Mirosoft Dynamics CRM Framework for EPiServer – Part 3

2010-09-07T11:06:00.001+02:00

In part 1 and part 2 I gave an overview of how you can create, read, update and delete CRM entities, and the available methods of doing so.

We’ve created a CrmContact entity class which we will continue to use in this last part of the blog series. But so far, we’ve only operated on 1:N relationships between entities. This blog post will focus on how you can use the CRM Framework in order to operate on N:N relationships between entities.

N:N Relationships in MS CRM

You can view an entities N:N Relationships from ‘Settings’ –> ‘Customization’ –> ‘Customize Entities’ –> Entity –> ‘N:N Relationships’.

In the image above, you can see that the Contact entity has a N:N relationship with the Order entity. Now, how do we get all Orders associated with a Contact using this framework?

Creating entity classes

Let’s assume you already have a CrmContact entity class like the one created in part 1. For us to retrieve all Orders assiciated with a Contact entity, we also need to create a CrmOrder entity class:

[CrmEntity("salesorder")]

public class CrmOrder

{

[CrmAttribute("salesorderid")]

public Guid OrderId

{

get; set;

}

[CrmAttribute("name")]

public string Name

{

get; set;

}

I haven’t included a lot of attributes in this class, as I only want to display the name of the Orders. You should make it a habit of always including the entity’s primary key attribute (in this case OrderId) to your entity classes! This is because you will always need to specify the primary key attribute when doing update operations on an entity. So now we have both the entity classes we need: CrmContact and CrmOrder.

Creating a CrmManyToManyRelationshipController

In the two previous blog posts we’ve used CrmEntityControllers in order to do operations on entities. When working with N:N Relationships we use a different controller: CrmManyToManyRelationshipController<T, V>, where T is the entity we have and V is the entity we want to be returned. In this example we have a Contact entity, and want to retrieve all Orders associated with the Contact, to T is the CrmContact class and V is the CrmOrder class:

CrmControllerFactory factory = CrmControllerFactory.Instance();

CrmManyToManyRelationshipController<CrmContact, CrmOrder> manyRelationshipController =

factory.GetManyToManyRelationshipController<CrmContact, CrmOrder>();

Of course, in order to create a CrmManyToManyRelationshipController, we need a CrmControllerFactory as shown in line 1 of the code above.

Using the Find method

Now that we have our controller, we can use the Find method in order to retrieve all CrmOrders associated with the CrmContact:

CrmManyToManyRelationshipController<T, V>.Find(CrmQuery query) : List<V>

CrmManyToManyRelationshipController<T, V>.Find(CrmQuery query, CrmSortingCriteria sorting) : List<V>

CrmManyToManyRelationshipController<T, V>.Find(CrmQuery query, int page, int pageSize, out int totalCount, CrmSortingCriteria sorting) : List<V>

Example:

Guid contactGuid = new Guid("50F16A2B-904B-DE11-8A4B-0003FFD726F0");

CrmQuery query = new CrmQuery();

query.AddCondition(new CrmAttributeCriterion("contactid", contactGuid, CrmConditionOperator.Equal));

List<CrmOrder> orders = manyRelationshipController.Find(query);

What happens in the example above is that we find all Orders of the Contact with contactid == contactGuid. As mentioned in the previos blog post, the CrmQuery class will change at some point. I’m not sure if I’ll change it before the release of the alpha version, but at some point I will definitely improve it!

I still need a couple of testers, so if you’d like to try the framework before it is released, let me know :)

Would you like to try the open source Microsoft Dynamics CRM framework for EPiServer?

2010-09-02T13:58:00.001+02:00

I’ve been working part time on an open source Microsoft Dynamics CRM framework for EPiServer for a couple of months now. And the alpha version is almost ready!

And now it’s time for some testing! I’ve tested everything myself, and I’ve created unit tests for the framework. But still, I want some some more testing to be done before I make the source code public.

So if you’d like to try the framework and help me out at the same time, send me an email: karolikl (at) gmail (dot) com.

Prerequisites: An EPiServer site and Microsoft Dynamics CRM 4.0

After the testing and a code review, the source code will be released on codeplex. And of course, more blog posts are coming up!

I’m joining the team at Epinova!

2010-08-26T10:28:00.001+02:00

A lot of things are happening at the moment, and with those things comes great news: I’m joining the team at Epinova!

I’ve worked as a consultant at Itera Consulting (Objectware) for approximately 18 months now. I started fresh out of university, which means I’ve had a pretty steep learning curve.

In university, I had Java programming for my first two semesters and then moved on to C and scripting for the rest of my degree. For those of you who don’t know much about the University in Oslo, it’s all about Linux; Microsoft is considered the ‘dark side’. As a result of this I hadn’t touched an object-oriented language in two years when I started working for Itera Consulting. In addition, I’d never before touched .NET, C# or even Visual Studio (oh yes, I spent my entire time at university playing with Emacs). And worst of all, I had never heard of EPiServer.

So in the last 18 months or so, I’ve bent over backwards in order to learn everything I could about .NET, C# and EPiServer. And Itera Consulting has helped me learn in the best way possible, by throwing me head first into various EPiServer projects while at the same time holding my hand. My colleagues have always been eager to help me, teach me and at times laugh with me when I realize some of the strange things I’ve done.

As always, the hard work has paid off! I’ve simply fallen in love with EPiServer, its community and all that comes along with it. And I want more more more! So Epinova, you’re up next :) I look forward to joining your team and working alongside some of the best EPiServer developers in Norway!

Technical thoughts on the open source Microsoft Dynamics CRM Framework for EPiServer – Part 2

2010-08-12T11:26:00.001+02:00

In part 1 I gave an overview of how MS CRM entities and attributes, creating entity classes and creating CrmEntityControllers. This blog post will focus on the methods available through the CrmEntityController<T> class.

In the examples below we will assume that the CrmContact class from part 1 exists, so the only thing we need is a CrmControllerFactory and CrmEntityController<T> object:

CrmControllerFactory factory = CrmControllerFactory.Instance();

CrmEntityController<CrmContact> crmContactController = factory.GetEntityController<CrmContact>();

Creating a CRM entity

CrmEntityController<T>.Create(T entity) : Guid

Example:

CrmContact contact = new CrmContact();

contact.FirstName = "John";

contact.LastName = "Smith";

Guid contactGuid = crmContactController.Create(contact);

Reading a CRM entity

Get:

CrmEntityController<T>.Get(Guid entityId) : T

Example:

CrmContact contact = crmContactController.Get(guid);

FindAll:

CrmEntityController<T>.FindAll() : List<T>

CrmEntityController<T>.FindAll(CrmSortingCriteria sorting) : List<T>

Example:

List<CrmContact> contactList = crmContactController.FindAll();

List<CrmContact> sortedContactList = crmContactController.FindAll(new CrmSortingCriteria("firstname", CrmSortOrder.Ascending));

Find:

CrmEntityController<T>.Find(CrmQuery query) : List<T>

CrmEntityController<T>.Find(CrmQuery query, CrmSortingCriteria sorting) : List<T>

CrmEntityController<T>.Find(CrmQuery query, int page, int pageSize, out int totalCount, CrmSortingCriteria sorting) : List<T>

Example:

CrmQuery query = new CrmQuery();

query.AddCondition(new CrmAttributeCriterion("firstname", "John", CrmConditionOperator.Equal));

query.LogicalOperator = CrmLogicalOperator.Or;

query.AddCondition(new CrmAttributeCriterion("firstname", "Sarah", CrmConditionOperator.Equal));

List<CrmContact> contactList = crmContactController.Find(query);

List<CrmContact> sortedContactList = crmContactController.Find(query, new CrmSortingCriteria("firstname", CrmSortOrder.Ascending));

int totalCount;

List<CrmContact> pagedContactList = crmContactController.Find(query, 1, 10, out totalCount, null);

Updating a CRM entity

CrmEntityController<T>.Update(T entity)

Example:

CrmContact contact = crmContactController.Get(guid);

contact.FirstName = "Paul";

crmContactController.Update(contact);

Deleting a CRM entity

CrmEntityController<T>.Delete(Guid guid)

Example:

crmContactController.Delete(guid);

So these are the methods created so far, keep in mind that they might change! One of the things that definitely will change is the CrmQuery class. I’m not quite happy with that yet. So if you have any tips on how to create a good query system, please let me know :)

Someone just reminded me of “Push Your Limits”

2010-08-11T09:15:00.001+02:00

A year ago I wrote a text for “97 things programmers should know” by O’Reilly. I decided not to write a technical piece, but rather a personal piece focusing on pushing your limits. The text did not make it into the book, but that doesn’t matter. What matters is that I hadn’t seen this text in a year until today when someone sent me the link. So just for fun I thought I’d post it here :)

Push your Limits

For many areas in life you need to know your limits in order to survive. Where it concerns personal safety, your limits define a boundary that should not be crossed. Where it concerns personal limitations, skills, and knowledge, however, knowing your limits serves an entirely different purpose. In programming, you want to know your limits so that you can pass them in order to become a better programmer.

Fortunately, not many programmers view their code as a ticket to their next paycheck. Those of us who are truly programmers at heart thrive on immersing ourselves in new code and new concepts, and will never cease to take an interest in and learn new technology. Whichever technology or programming language these programmers favor, they have one important thing in common: They know their limits, and they thrive on pushing them little by little every day.

We have all experienced that, if not armed with the knowledge we need or wished we had, attacking a bug or a problem head on takes a lot of time and effort. It can be too easy to pass the beast on to a colleague you know has the solution or can find one quickly. But how will that help you become a better problem solver? A programmer unaware of their own limits — or, worse, aware of them but not challenging them — is more likely to end up working in a never-ending loop of the same tasks every day. To insert a break into this loop, you need to acknowledge your limits by defining your programmatic weaknesses: Is your code readable by others? Are your tests sufficient? Focus on your weaknesses and you'll find that at the end of the struggle, you will have pushed that boundary an inch forward.

Needless to say, what others know should not be forgotten. Fellow programmers and colleagues offer a nearby source of knowledge and information which should be shared and taught to others. They are, however, ignorant of your limits. It is your responsibility to acknowledge exactly where your boundaries are hiding so that you can make better use of the knowledge they offer. One of the most challenging and, many would say, most effective ways to extend your own limits is to explain code and concepts to fellow programmers, for example by blogging or hosting a presentation. You will then force yourself to focus on one of your weaknesses, while at the same time deepening your own and others' knowledge by discussing and getting feedback from others.

At the end of the day, it is not about surviving. It is about surviving in the best way possible, by actively challenging yourself to excel as a programmer.

Technical thoughts on the open source Microsoft Dynamics CRM Framework for EPiServer – Part 1

2010-08-09T15:25:00.001+02:00

Last week I announced that I’ve made up my mind about creating an open source MS CRM framework for EPiServer. The development has been going on since then, and in this blog post I’ll give some insight to what the framework will be like. Please keep in mind that the framework is in its alpha phase, and based on feedback, future code reviews and further development, the code might change! So consider this a draft :)

MS CRM entities and attributes

Before starting, it’s important to know the difference between entities and attributes. An entity such as Contact contains attributes such as Firstname and Lastname. Entities can be related to each other through one-to-many and many-to-many relationships.

You can view all entities and attributes in ‘Settings’ –> ‘Customization’ –> ‘Customize Entities’ in CRM:

You can view an entities attributes from ‘Customize Entities’ –> Entity –> ‘Attributes’:

Web.config

Integration with EPiServer is of course the main focus of this framework, so I’ve put all connection specific details in a separate configSection in the web.config file.

In <configSections>:

</sectionGroup>

The configuration section itself:

</crmFramework>

Creating an Entity class in EPiServer

If you want to get an entity from CRM with all its attributes, this results in a lot of data being transferred and hence the operation can get time consuming. So in order for you to chose exactly what attributes you need, you need to create a class for each entity specifying its attributes. You can do CRUD operations on all CRM entities, standard or custom, and the framework supports all CRM attribute types.

The class needs a CrmEntity attribute speficying the CRM entity name. Each CRM attribute is defined as a public property with a CrmAttribute attribute specifying the attributes CRM name.

Here’s an example of a class created for the CRM Contact entity:

[CrmEntity("contact")]

public class CrmContact

{

// Has to be included for update operations

[CrmAttribute("contactid")]

public Guid ContactId

{

get;

set;

}

[CrmAttribute("firstname")]

public string FirstName

{

get;

set;

}

[CrmAttribute("lastname")]

public string LastName

{

get;

set;

}

Creating a CrmControllerFactory and CrmEntityControllers

In order to use the entity class we just created, we’ll need to get an instance of the CrmControllerFactory class. This is a singleton class handling authentication towards CRM and the CrmEntityControllers.

A CrmEntityController is a generic controller for doing operations on CRM entities. Through the controller you can access methods like Create, Delete, Find, Get, Update etc.

So let’s create a CrmControllerFactory and a CrmEntityController for the CrmContact class created above:

CrmControllerFactory factory = CrmControllerFactory.Instance();

CrmEntityController<CrmContact> crmContactController = factory.GetEntityController<CrmContact>();

As mentioned before, we can now use the crmContactController to do operations on CRM Contact entities. An example is getting a contact by Guid:

CrmContact contact = crmContactController.Get(new Guid("309B8DB0-C5DF-DC11-B07C-0003FF360638"));

string firstName = contact.FirstName;

All the methods available through the CrmEntityController<T> class will be covered in Part 2 of this blog series (in a couple of days). In the future, after a code review, I will also post some code showing the framework itself.

And remember, things might change! If you see anything you already disagree with, please let me know, I’m up for a discussion :)

Are you ready for an open source Microsoft Dynamics CRM Framework for EPiServer?

2010-08-04T16:10:00.001+02:00

Since May I’ve been contemplating developing an open source Microsoft Dynamics CRM Framework for EPiServer. Then, a couple of weeks ago, I made up my mind. I’m going to do it!

Doesn’t that already exist though? Well, yes. EPiServer has its own EPiServer Connect for CRM which is useful in simple projects, but it has quite a lot of limitations when it comes to more complex cases. For instance, it only supports retrieving attributes of some CRM types and it’s limited to working with the Contact and Account entities. It is possible to extend the CRM Connector, but you will not be able to come clear of all the limitations. But EPiServer are not the only ones developing CRM frameworks, there are tons of them out there. The only problem is that most of them are too complex and not made for EPiServer. So my goal is to create a framework that can be used in complex projects where EPiServer Connect for CRM won’t do the trick, but the framework will be easy to use and most importantly: open source and free.

The development has already started and is coming along great if I may say so myself :) In phase 1 of the development I’m focusing on the following:

- CRUD operations on all types of entities (custom and standard)
- Read and update all types of entity attributes (custom and standard).
- Conditional search for entities
- And of course: Integration with EPiServer

I will keep on blogging while developing the framework, so you can expect the first technical blog post this weekend. That will give some insight to how you can use the framework and it will give you the opportunity to influence the development. I’m not quite sure when the framework itself will be available, but I’m hoping the Beta version is out in a couple of months (after all, I do have a job).

All opinions, wishes or slaps on the hand is highly appreciated!

Playing around with the EPiServer.Community.NewsFeed Namespace

2010-07-20T13:59:00.002+02:00

In EPiServer Relate+, whenever you write a blog post, upload an image or become friends with someone this shows up on an activity feed. We all probably recognize this feature from Facebook, after all this is what Facebook is all about: Seeing what your friends have been up to lately.

When working with the EPiServer.Community.NewsFeed namespace, it’s important to understand the difference between Actor, Action, Target and Story.

Example 1: John uploaded an image
Example 2: John became friends with Sarah

Actor
Who performed the action. John is the actor in both the examples above.

Action
What has been done. In example 1 the action is “uploaded an image” while “became friends with” is the action in example 2.

Target
Who or what was the action done upon? In example 1, the image itself is the target. In example 2, Sarah is the target.

Story
If you put an Actor, an Action and a Target together, you have a Story. Both examples above are stories, the simplest stories we can create. If we want a more complex story we can create stories with multiple actors or targets.

Now how do we do this in code? Let’s assume you have a working Relate+ site. The users of your site will then be actors and the EPiServer Community entities will be your targets (for example blogs, images, users). So we only have to create actions and stories!

Creating, getting and removing actions

Creating an action is very easy, the only thing you need is to find a name for your action and to determine whether the action should be allowed to have multiple actors or targets. Let’s continue our Facebook line of thought and create a “Poke” action:

NewsFeedAction pokeUser = new NewsFeedAction("Poke User");

The action “Poke User” can only have one actor and one target. Let’s create another action “Poke Multiple Users”:

NewsFeedAction pokeMultipleUsers = new NewsFeedAction("Poke Multiple Users", NewsFeedActionCapability.MultipleTargets);

Removing an action is just as easy, first you get the action then you remove it:

NewsFeedAction pokeUser = NewsFeedHandler.GetAction("Poke User"); NewsFeedHandler.RemoveAction(pokeUser);

At last, you can get a collection with all the actions available by calling GetActions():

NewsFeedActionCollection actionCollection = NewsFeedHandler.GetActions();

Creating, getting and removing stories

Let’s create a NewsFeedStory specifying the action, actor and target:

NewsFeedStory story = new NewsFeedStory("Poke User", CurrentUser, null, pokedUser); NewsFeedHandler.AddStoryToActorFeed(story);

The AddStoryToActorFeed adds the story to the actors personal activity feed. In order to get a story you use the NewsFeedHandler.GetStory() method while removing a story can be done by using NewsFeedHandler.RemoveStory():

NewsFeedStory story = NewsFeedHandler.GetStory(1); NewsFeedHandler.RemoveStory(story);

As you can see, the GetStory() method expects you to know the id of the story you want to retreieve. This means that you need to loop through your stories if you don’t know the id. Let’s take a look at how that can be done!

A more complex example

Let’s assume John and Sarah have become friends on your community website. After weeks of cleaning up John’s messy code, Sarah has had enough and decides to delete John as a friend. On a standard installation of Relate+ the friendship will be deleted, but the story will still be visible in the newsfeed. So now we’d like write some code to delete the story from the newsfeed.

First we start off with a simple method called GetSpecificActions() which expects a list of action names. It loops though all the available actions on your site and returns a NewsFeedActionCollection containing all the actions specified in the list:

private NewsFeedActionCollection GetSpecificActions(List<string> includeActions)

{

NewsFeedActionCollection newsFeedActionCollection = new NewsFeedActionCollection();

foreach (NewsFeedAction action in NewsFeedHandler.GetActions())

{

if (includeActions.Contains(action.Name))

{

newsFeedActionCollection.Add(action);

}

return newsFeedActionCollection;

}

Next we create a method called DeleteNewsFeedStory():

protected void DeleteNewsFeedStory(IUser actor, IUser target)

{

List<string> actionList = new List<string> { Properties.Settings.Default.ActionFriendship };

NewsFeedActionCollection newsFeedActionCollection = GetSpecificActions(actionList);

NewsFeedStoryCollection stories = NewsFeedHandler.GetActorFeed(actor, newsFeedActionCollection, DateTime.MinValue, DateTime.Now, 1, 25);

foreach (NewsFeedStory story in stories)

{

foreach (IEntity targetEntity in story.Targets)

{

IUser user = targetEntity as IUser;

if (user != null && user.ID == target.ID)

{

NewsFeedHandler.RemoveStory(story);

}

In this method we call GetSpecificActions() and use the NewsFeedActionCollection returned in order to find all Sarah’s stories with action equal to ActionFriendship. We then loop through all the stories and check if the one of the stories has John as a target, and if it does we delete the story.

We could do the exact same thing as we’ve done in this example without specifying the type of action the stories retrieved should have. You’d then get all stories (no matter what action) and you would have to check if the action was correct before removing the story.

Note: This example only shows how to delete the story, the friendship itself is not deleted in this example. I’ve made an assumption that you’ve already deleted the friendship prior to deleting the story :)

Computers alone would not make me stay in this business.

2010-04-29T18:47:00.001+02:00

Now and then I find myself observing other developers in awe of their discussions and line of thought. When in this state of mind, I don’t participate in the discussion because my mind is occupied by “something” I haven’t been able to put into words until recently.

Arnold Schwarzenegger once said “Good things don’t happen by coincidence” (yes, I’m quoting The Terminator). He is, however, wrong. If it hadn’t been for a series of coincidences, I would never have become a developer. In fact, if you would have asked me five years ago what I wanted to be when I “grew up”, I would have answered a doctor. Luckily for all patients out there, that didn’t happen.

As I began my degree in computer science, I didn’t actually know what programming was. Computers had never fascinated me, they were simply tools for getting things done more efficiently. Developers were geeky men whose words I couldn’t make sense of. Exactly how and when I went from being clueless to becoming one of the geeky men (although I’m female), I don’t know. But within the last year, I’ve become more and more certain of one thing: Computers alone would not make me stay in this business.

Of course, I find the technology we’re working with extremely interesting. But that can not be compared to the fascination I have of developers. When you, as a developer, are given a task you find challenging and exhilarating you become passionate about your code. You find yourself yelling at your computer when nothing works out the way you planned. You’re so determined to fix the problems that you’re not able to think outside the box and you end up leaving the office annoyed because you weren’t able to locate the problem. You wake up the next day even more determined than the day before, and after hours of intense work you’re able to think outside the box and the problems are solved. You’re not yelling anymore, you’re cheering.

Hopefully, this is not what every day looks like to you, but I’m sure you’ve experienced it. Have you, however, thought about what this scenario would look like if you weren’t passionate? You would probably not care much about these unexpected problems, you’d be satisfied as long as you could go home at night without any responsibilities. Luckily I can’t say I’ve met any developer yet who just doesn’t care, and I’m glad for that.

However, the passion goes further than this. The passion you have for your job is one thing, but what really amazes me is the passion I observe while I’m not at work. A lot of developers have their own personal projects where they live out their dream of trying out the newest technology in order to realize some of the ideas they get from who knows where. I see these personal projects being mentioned everywhere: on Twitter, in blogs, at meetups, or while talking to other developers. The passion these developers have for their projects sometimes intimidate me. How do they do it? How do they manage to fit all these projects into their schedule?

How or why they do it is not important, the only thing I ask of you is to continue! After all, that’s what makes me stay in this business: Your passion. So if you’re a developer, give yourself a pat on the back. You deserve it :)

Extending the ProfileBase class in ASP.NET

2010-03-08T18:36:00.001+01:00

In this blog post I'll show you how you can extend the ProfileBase class in ASP.NET. This is useful in many situations, for example if you need to create a custom shopping cart. However, as a shopping cart can be quite complex, I've chosen to use a simpler example in this case.

Assume you have a website containing a large number of news articles and you want to let your authenticated users add personal comments to the each of the articles. By personal comments I mean comments that are stored in a user's profile and are therefore only accessible to the user who created the comment.

Our first step is to create a Comment class. Note that the Comment class has to be serializable.

    [Serializable]
    public class Comment
    {
        private readonly int _articleId;
        private readonly string _commentText;
        private readonly DateTime _created;

        public Comment(int articleId, string commentText)
        {
            _articleId = articleId;
            _commentText = commentText;
            _created = DateTime.Now;
        }

        public string CommentText
        {
            get { return _commentText; }
        }

        public int ArticleId
        {
            get { return _articleId; }
        }

        public DateTime Created
        {
            get { return _created; }
        }
    }

The second class we need is a CommentCollection class. This class contains a list of a specific users comments, as well as methods for adding, removing and editing comments. To keep it short, I’ve only included the InsertComment() method in this blogpost.

    [Serializable]
    public class CommentsCollection
    {
        private readonly List<Comment> _comments;

        public CommentsCollection()
        {
            if (_comments == null)
            {
                _comments = new List<Comment>();
            }
        }

        public Collection<Comment> Comments
        {
            get
            {
                return new Collection<Comment>(_comments);
            }
        }

        public void InsertComment(int articleId, string commentText)
        {
            Comment comment = new Comment(articleId, commentText);
            _comments.Add(comment);
        }
    }

So now we have a class for managing the comments, but how do we use this? First of all, we have to register it as a property in the <system.web><profile><properties> section of the web.config:

<add name="CustomComments" type="Your.Namespace.CommentsCollection" serializeAs="Binary" />

Now it’s time to create a CustomProfile class, extending the Profilebase class. This class contains two methods. One for retrieving the Profile of the currently logged-in user, and one for retrieving the Profile of a specific user.

    public class CustomProfile : ProfileBase
    {
        /// <summary>
        /// Get the profile of the currently logged-on user.
        /// </summary>     
        public static CustomProfile GetProfile()
        {
            return (CustomProfile)HttpContext.Current.Profile;
        }

        /// <summary>
        /// Gets the profile of a specific user.
        /// </summary>
        public static CustomProfile GetProfile(string userName)
        {
            return (CustomProfile)Create(userName);
        }

        /// <summary>
        /// Gets a users comment collection
        /// </summary>
        public CommentsCollection CommentsCollection
        {
            get { return (CommentsCollection)GetPropertyValue("CustomComments"); }
        }
    }

We also have a property called CommentCollection that uses ProfileBase.GetPropertyValue to get the value of the CustomComments property registered in the web.config. Additionally, in order for ASP.NET to use your custom class instead of the ProfileBase class, this has to be specified in the web.config:

<profile enabled="true" defaultProvider="SqlProfile" automaticSaveEnabled="true" inherits="Your.Namespace.CustomProfile">

And that’s it! Here’s an example of how to use CustomProfile and CommentCollection to create comments:

     //Get the profile of the currently logged-in user
     CustomProfile.CustomProfile profile = CustomProfile.CustomProfile.GetProfile();
            
     // Get the users comment collection
     CommentsCollection commentsCollection = profile.CommentsCollection;

     // Insert new comment
     commentsCollection.InsertComment(1, "My first comment");
            
     // Get a users comments
     Collection<Comment> comments = commentsCollection.Comments;

Note: There seems to be a bug in ASP.NET, so if you get the error “Unable to case object of type ‘ProfileCommon’ to type ‘CustomProfile’”, change <profile enabled="true">

to <profile enabled="false"> and back again to true. After this everything will work fine. If you find the cause of this bug, please let me know :)

Using the query system in EPiServer Community

2009-09-26T11:13:00.005+02:00

The query system in EPiServer Community is a simple way of retrieving entities and collections specific to EPiServer Community. In this blog post I’ll walk through four examples of how the query system can be used.

Let us start with an easy one: Get a user by an ID. This can of course be done by calling the EPiServer.Community.CommunitySystem.CurrentContext.DefaultSecurity.GetUser() method, but let’s see how it can be done by querying:

As we are retrieving a user, we create a query of type UserQuery. All queries have properties of type [x]Criterion, where [x] can be Integer, String, Boolean etc. This means that before setting a property value, we always have to define its criterion type. In this case, as the ID is an int we create an IntegerCriterion and assign it to the userQuery.ID property. We can then set its Value. At last, we call the GetQueryResult() method to get the result of the query.

In the previous example we were only looking for one entity. Now what if we have a list of email addresses, and we want to retrieve all the users with those addresses?

One of the most common mistakes when using the query system is to forget an initialization of an object. If we were to remove the second or third line in the example above, we would get the error message: “Object not set to an instance of an object”. If you’re new to the query system, you’ll probably see this message quite a few times before you get the hang of it, but the only thing it means is that you’ve forgotten to initialize one of the objects.

Now, let’s pick up the pace. Searching is an important feature of every website, and in a search you’ll need to do logical operations. If in a search, you want to retrieve all the clubs with the word “Elephant” in the title OR the description, you’ll need to use a Logical OR operator:

In order to do a logical operation in a query, you need a CriteriaGroup to which you can add all the criteria. In the example above we create a StringCriterion for the clubs Name, and add it to the criteriagroup. We then do the same for the description, but now we specify a LogicalOperator. Finally, we need to add the criteriagroup to the query.

In the final example we’ll see how to query attributes.Let us say you’ve created an attribute for type IUser of type string which specifies the user’s phone number. You now want to retrieve a user based on that phone number:

That’s it for now, happy querying!

Customizing an EPiServer Community Module using Attributes

2009-09-21T20:59:00.019+02:00

While developing an EPiServer Community or EPiServer Relate+ site, you will find the custom Community modules extremely useful. Sooner or later though, you will realize that you need to customize them in order to fit the customers need.

In this blog post, I’ll walk you through how to customize the ‘Add User’ module in the ‘System Settings’ section of the Community tab. I will not show you how to create a custom module as this has previously been explained by the brilliant Joel Abrahamsson.

So the goal in this blog post is to add a custom field, in this case a phone number, to the ‘Add User’ module:

The first thing you need to do is to create a class that inherits from and extends the EPiServer.Community.Web.Administration.EditUserPage class:

In this class I’ve added the textbox that we’ll include in the page later on, and three methods: OnInit, OnLoadComplete and a click event for the save button. Let’s take a look at the OnInit method first:

First we call the OnInit method in the base class, and then we invoke the buttonSave.Click event by supplying the method, buttonSave_Click. This means that the base class’ buttonSave_Click event will be called first and the buttonSave_Click event in our custom class will be called afterwards. The buttonSave_Click event looks like this:

Now, this is where the fun begins. In order for us to save the new users phone number, we are going to use attributes. For more information on attributes in EPiServer Community, click here. So assuming we have added a PhoneNumber attribute of type string for the type IUser, we will be able to save the phone number.

Before we can do this though, we need to retrieve the user who the phone number belongs to. As the buttonSave_Click event of the base class has already been fired, the user has been created and the only thing we need to do is to get the email address in order to retrieve the user. By snooping around in the base class, you’ll see that getting the email address is as easy as this: tabPageUserSettings.Email

So we now have the email address and are able to retrieve the user by calling the GetUserByUserName method (assuming an email address is used as the username). We then clone the user, set the attribute value, update the user and voilá! The phone number is saved.

So far this will not work as we haven’t changed the @Page directive of the EditUser.aspx or added the label and textbox. So first, change the @Page directive of the EPiServerCommunity\Security\EditUser.aspx so that the page inherits your custom class instead of the default implementation. Second, add a label and a textbox to the EditUser.aspx, make sure the textbox has the same id as in your custom class.

Now everything will work fine, except for one thing: Editing the user. If you try to edit the user you just created, you’ll see that the phone number textbox remains empty. In order to fix this, we need to override the OnLoadComplete method of the base class:

Again, we get the email and using that we retrieve the user. We can then get the PhoneNumber attribute value, and add that to the Text property of the textbox. And we’re done :)

Tips and tricks on taking the 70-536 Microsoft .NET Framework – Application Development Foundation exam

2009-08-26T09:41:00.002+02:00

One thing I noticed in this exam is that the details of the exam can save you from failing, and the details actually make it easier for you to guess correctly if you don’t know the answer for a question. These are things you would easily notice if you did the exam without a time limit and in your own living room, but as soon as you’re a bit stressed out they’re easy to ignore.

These examples might help you out if you’re absolutely stuck on a question and don’t know what to do.

Example #1:
All the answers for a question look similar, but if you take a good look at them you’ll see that one or two of the answers have nothing to do with the question whatsoever. Let’s say all the answers are lines of code containing a method, and inside the method something is done (it doesn’t matter what). The natural thing to do is to focus on what is done inside the method and how the method is declared, that’s where you assume you’ll find the answer.

But what about the name of the method? I know for a fact that I usually don’t pay attention to the method name unless it’s in a larger context, but you really should. What if, in one of the answers, the method is called SerializeDataSet(…) and the question has nothing to do with serialization? Then you can probably eliminate this answer and you’re one step closer to where you want to be.

Example #2:
As far as I’ve seen, this exam does not contain any trick questions (questions that lead you in the wrong direction). So if a question tells you that you have a variable ‘x’, and one of the answers does not use this variable, you can be pretty sure the answer is wrong.

Example #3:
Make sure you read the questions carefully and more than once. If a question states that a collection should be strongly typed, make sure the answer you choose in fact is strongly typed. If a question asks you to encrypt a file, make sure you choose the answer that encrypts (not decrypts) it. If you’re in a rush, details like these may be easy to ignore.

Last but not least, mark all the questions you are unsure of for review. The other questions in the exam might give you a clue on the way, so you should always go over the questions more than once. And if you don’t know the answer for a question, and you’re not able to eliminate any of the answers, go with your first hunch. Statistics show that your first hunch is more likely to be correct than choosing an arbitrary answer.

Good luck!

How to study for the 70-536 Microsoft .NET Framework – Application Development Foundation exam

2009-08-19T13:48:00.005+02:00

As I passed my 70-536 exam today, I thought I’d write this blog post to try to help out everyone else out there studying for the exam. Before starting though, remember one thing: This way of studying worked for me, it might not be the best way for you!

Also, Microsoft states that “Candidates should have at least two to three years of experience developing Web-based, Windows-based, or distributed applications by using the Microsoft .NET Framework 1.0, the .NET Framework 1.1, the .NET Framework 2.0, or the .NET Framework 3.5.”

That’s really not necessary, I have 6 months of experience and I managed to pass it without too much hassle. It will save you a lot of study time if you have more experience than me though!

Before you start studying you should get an overview of the ‘Skills measured’. Highlight all the topics you know you’re unsure of, and be honest with yourself! If you find yourself thinking “I might know this”, you should assume that you don’t know. You’re not fooling anyone but yourself.

Do the same thing with the contents overview in the Self-Paces Training Kit.(Mind that this exam is exactly the same for .NET 2.0 and 3.5)

After doing this you’ll have a good overview of what the exam covers and how much you know.

The next part is where you need some self control: the studying itself. In my world there are two ways of doing this:

First study for the topics you don’t know, then have a look at those you do know (just to check that your knowledge covers everything)
First have a look at those you do know, then study for the topics you don’t know

If you go for #1, by the time you’re done studying for the things you don’t know, you’ll probably be sick of studying and skip the part where you have a look at what you actually know. So #2 is the best way to go (trust me!)

When having a look at what you do know, quickly browse through the relevant topics in the book. If you see anything you don’t recognize, read it. If you don’t understand it after reading it, you should put it on your ‘Don’t know’ list.

So now you’ve covered everything you do know, and it’s time for the time consuming part: Learning what you don’t know. Read the highlighted topics, and if you don’t understand what you’re reading Google and Bing are your friends.

Each time you’ve covered a new topic, test your knowledge by doing a MeasureUp test (in custom mode - selecting the relevant topic)

And finally, when you’ve covered all of the topics: Do the MeasureUp test in the certification mode. If you don’t pass, you’ll get a nice overview over which topics you don’t know well enough and you can have a look at these topics again. And surprise, surprise: This step repeats itself until you know all the topics well enough!

And one last tips for all the procrastinators out there: As charming as procrastination is, it’s not very helpful. Make a schedule and stick to it! Some blood, sweat and tears later, and you’ll be certified :)

Next time: Tips and tricks on doing the exam itself

Attributes in EPiServer Relate+

2009-07-13T14:16:00.009+02:00

Attributes in EPiServer Relate+ is an easy way of extending classes without having to do it programmatically. In order to assign an attribute to an object, the object has to implement the IAttributeExtendableEntity interface and to everyone’s joy most objects in Relate+ do.

In this example each user of type EPiServer.Common.Security.IUser will be able to register their favorite sport of type System.String. The first thing to do is to add the attribute in the Community tab of the edit interface:

The attribute is now defined in the database, so we can set its value:

Getting the attribute value is just as simple:

Now what if we want to find all the users who have rugby as their favorite sport? Most of the EPiServer Community classes allow querying based on a set of criteria, and that’s the way to go:

First a new UserQuery is created and a StringCriterion is added. Multiple criterions can be added if that’s needed. The GetQueryResult method fills up the cache with the query result. Use the RemoveQueryResultCache method to clear the cache:

Piece of cake!