Kazi Manzur Rashid's Blog : DotNetShoutout

For Us By Us

kazimanzurrashid — Sat, 02 May 2009 01:00:44 GMT

No, this is not at all a post of FubuMVC, I just borrowed the words for this post.

Jeff Atwood & Joel Spolsky thinks it is a compliment when they found there site design is copied by a Chinese site and I do agree it completely, specially when it is serving the same community that I belong to. And I also agree with Joel Spolsky that most (at least in my case) English as second language speaking developers prefer the local language when they are communicating between them. We made KiGG an Open Source Project from the very beginning and since the v2.0 is released people are really picking it for creating local .NET community sites in their own language:

Polish version

Russian version

Chinese version (I guess it is still under development)

And this is the power of Open Source, the existing version contains absolutely zero support for localization, but the community picked and made it local for them, it has the same features and power as the original version and my sincere thanks to them who are behind these. As a side note I want to mention that localization is the highest priority that we will be adding in v3.0

Recently, I got few requests about the story publishing process from the peoples who are also planning to launch sites based upon KiGG. So instead of answering them individually, I preferred to write a post to explain it.

Like the many social news/links site the story appearing in the front-page is done based upon some algorithms and it has the complete support to add/replace/remove any of those algorithms. By default, it comes with 6 different algorithms.

The story publish process starts when the Publish method of StoryService is called.

public virtual void Publish()
{
    using(IUnitOfWork unitOfWork = UnitOfWork.Begin())
    {
        DateTime currentTime = SystemTime.Now();

        IList<PublishedStory> publishableStories = GetPublishableStories(currentTime);

        if (!publishableStories.IsNullOrEmpty())
        {
            // First penalty the user for marking the story as spam;
            // It is obvious that the Moderator has already reviewed the story
            // before it gets this far.
            PenaltyUsersForIncorrectlyMarkingStoriesAsSpam(publishableStories);

            //Then Publish the stories
            PublishStories(currentTime, publishableStories);

            unitOfWork.Commit();
        }
    }
}

As you can see, it first calls the GetPublishableStories to prepare a list which is publishable at this moment, next it reduces the score of the users who have incorrectly marked any of those stories as spam (will explain later) and at last it calls another method PublishStories to actually publish it.

private IList<PublishedStory> GetPublishableStories(DateTime currentTime)
{
    List<PublishedStory> publishableStories = new List<PublishedStory>();

    DateTime minimumDate = currentTime.AddHours(-_settings.MaximumAgeOfStoryInHoursToPublish);
    DateTime maximumDate = currentTime.AddHours(-_settings.MinimumAgeOfStoryInHoursToPublish);

    int publishableCount = _storyRepository.CountByPublishable(minimumDate, maximumDate);

    if (publishableCount > 0)
    {
        ICollection<IStory> stories = _storyRepository.FindPublishable(minimumDate, maximumDate, 0, publishableCount).Result;

        foreach (IStory story in stories)
        {
            PublishedStory publishedStory = new PublishedStory(story);

            foreach (IStoryWeightCalculator strategy in _storyWeightCalculators)
            {
                publishedStory.Weights.Add(strategy.Name, strategy.Calculate(currentTime, story));
            }

            publishableStories.Add(publishedStory);
        }
    }

    return publishableStories;
}

The GetPublishableStories first gets a list of active stories (the stories that has been voted, viewed, commented since the last publish, there is also an age factor which means story in specific age range will only qualify, default is 4-240 hour) form the database, next it applies the different algorithm to calculate its weight. This algorithm (Strategy Pattern) is defined as IStoryWeightCalculator interface and injected in the StoryService by the DI container. Once the calculation is done the PublishStories method is called.

private void PublishStories(DateTime currentTime, IList<PublishedStory> publishableStories)
{
    // Now sort it based upon the score
    publishableStories = publishableStories.OrderByDescending(ps => ps.TotalScore).ToList();

    // Now assign the Rank
    publishableStories.ForEach(ps => ps.Rank = (publishableStories.IndexOf(ps) + 1));

    // Now take the stories for front page
    ICollection<PublishedStory> frontPageStories = publishableStories.OrderBy(ps => ps.Rank).Take(_settings.HtmlStoryPerPage).ToList();

    if (!frontPageStories.IsNullOrEmpty())
    {
        foreach (PublishedStory ps in frontPageStories)
        {
            ps.Story.Publish(currentTime, ps.Rank);
        }

        _eventAggregator.GetEvent<StoryPublishEvent>().Publish(new StoryPublishEventArgs(frontPageStories, currentTime));
    }

    // Mark the Story that it has been processed
    publishableStories.ForEach(ps => ps.Story.LastProcessed(currentTime));
}

The PublishStories first ranks the stories based upon its total weight, then it takes the first 20 story (defined in the web.config) for the front-page and marks it as for front-page by updating its rank and published date, at last it updates the last process date of all the stories regardless its publish status so that we can verify its active status for the next publish.

As you can see the story qualifying is completely decided based upon those weight calculators and by adding/removing/replacing the new calculators you can tweak the whole story publishing process. Now lets see how the default calculators works.

VoteWeight: Returns higher value if the vote is given from a different IP address than the story was actually submitted, for example 10 if it is given from a different IP address and 5 from the same IP address. If you do not like it, you can level it in the web.config.

<type name="vote" type="IStoryWeightCalculator" mapTo="VoteWeightCalculator">
    <lifetime type="PerWebRequest"/>
    <typeConfig extensionType="Microsoft.Practices.Unity.Configuration.TypeInjectionElement, Microsoft.Practices.Unity.Configuration">
        <constructor>
            <param name="voteRepository" parameterType="IVoteRepository">
                <dependency/>
            </param>
            <param name="sameIPAddressWeight" parameterType="System.Single">
                <value type="System.Single" value="5"/>
            </param>
            <param name="differentIPAddressWeight" parameterType="System.Single">
                <value type="System.Single" value="10"/>
            </param>
        </constructor>
    </typeConfig>
</type>

CommentWeight: Returns higher value if comment is given from a different Ip and not by the actual submitter. For example, 4 for different IP, 2 for same IP and 1 for the actual submitter no matter from which IP it was submitted. This can be changed from web.config:

<type name="comment" type="IStoryWeightCalculator" mapTo="CommentWeightCalculator">
    <lifetime type="PerWebRequest"/>
    <typeConfig extensionType="Microsoft.Practices.Unity.Configuration.TypeInjectionElement, Microsoft.Practices.Unity.Configuration">
        <constructor>
            <param name="commentRepository" parameterType="ICommentRepository">
                <dependency/>
            </param>
            <param name="ownerWeight" parameterType="System.Single">
                <value type="System.Single" value="1"/>
            </param>
            <param name="sameIPAddressWeight" parameterType="System.Single">
                <value type="System.Single" value="2"/>
            </param>
            <param name="differentIPAddressWeight" parameterType="System.Single">
                <value type="System.Single" value="4"/>
            </param>
        </constructor>
    </typeConfig>
</type>

ViewWeight: Returns the sum of each unique IP address view (view means when a user clicks a link which takes the user to the original source) multiplied by a factor, this can be also changed from the web.config.

<type name="view" type="IStoryWeightCalculator" mapTo="ViewWeightCalculator">
    <lifetime type="PerWebRequest"/>
    <typeConfig extensionType="Microsoft.Practices.Unity.Configuration.TypeInjectionElement, Microsoft.Practices.Unity.Configuration">
        <constructor>
            <param name="storyViewRepository" parameterType="IStoryViewRepository">
                <dependency/>
            </param>
            <param name="weightMultiply" parameterType="System.Single">
                <value type="System.Single" value="0.1"/>
            </param>
        </constructor>
    </typeConfig>
</type>

UserScoreWeight: Returns the sum of user score multiplied by a factor who voted the story, so that stories voted by the higher score users has much more chance to appear in the front-page. The factor can be also changed from the web.config.

Freshness: Returns value depending upon the story age, the young the story the higher the value. The freshness threshold and interval can also be changed from web.config.

KnownSource: Returns a value based upon the source grade. This ensures that stories from an well known source get higher chance to appear in the front-page. For example, a blog post from Gu should take precedence than a blog post of mine. These sources are maintained in the KnownSource database table. If the source is not known, then it returns nothing.

So, as you can understand with the above algorithms even a story that got less votes might rank better than a more voted story and another important things I would like to mention that it does not update any specific part (top/bottom) of the front-page, instead it updates the whole page, the existing story of the front-page might also appear in the front-page at the same or different location based upon its recent rank, the benifit is it will never replace much more popular but old story by a less popular new story.

Okay, if you think the above is a solid publishing process or the process su*ks or you need a much simpler algorithm, my recommendation is to create a new strategy inheriting from the StoryWeightBaseCalculator. Let us see how to create a dumb strategy which rank the story based upon the number of votes and comments it got.

public class SimpleWeightCalculator : StoryWeightBaseCalculator
{
    private readonly IVoteRepository _voteRepository;
    private readonly ICommentRepository _commentRepository;

    public SimpleWeightCalculator(IVoteRepository voteRepository, ICommentRepository commentRepository) : base("Simple")
    {
        _voteRepository = voteRepository;
        _commentRepository = commentRepository;
    }

    public override double Calculate(DateTime publishingTimestamp, IStory story)
    {
        ICollection<IVote> votes = _voteRepository.FindAfter(story.Id, story.LastProcessedAt ?? story.CreatedAt);
        ICollection<IComment> comments = _commentRepository.FindAfter(story.Id, story.LastProcessedAt ?? story.CreatedAt);

        return (votes.Count + comments.Count);
    }
}

Next, remove the existing strategies and add it in the web.config (I am assuming you know the configuration of MS Unity application block):

<type name="simple" type="IStoryWeightCalculator" mapTo="SimpleWeightCalculator">
    <lifetime type="PerWebRequest"/>
    <typeConfig extensionType="Microsoft.Practices.Unity.Configuration.TypeInjectionElement, Microsoft.Practices.Unity.Configuration">
        <constructor>
            <param name="voteRepository" parameterType="IVoteRepository">
                <dependency/>
            </param>
            <param name="commentRepository" parameterType="ICommentRepository">
                <dependency/>
            </param>
        </constructor>
    </typeConfig>
</type>

Now, when you publish stories, it will rank based upon the vote and comments it got since the last publish.

I hope the above clarifies the story publish process of KiGG and do let me what else of KiGG you want to highlight next.

Script and CSS Management in ASP.NET MVC

kazimanzurrashid — Mon, 27 Apr 2009 21:00:08 GMT

If you are familiar with YSlow recommendations, I guess you know that it recommends to put your CSS files at the top(#5) and JavaScript files at the bottom(#6) of the pages. Placing the CSS files at the top is not an issue but putting the JavaScript files at the bottom of the pages has some gotchas, specially in heavily ajaxed based site with Master and Content page environment. When developing a Web 2.0 ajax site it is obvious that we will be using quite a number of plug-ins/widgets along with the core framework like jQuery, ExtJS, Prototype etc and of course there will be our hand coded javascript files, depending upon the size and the functionalities, the number of files can vary. This is the screenshot just to show you the usages of javascript files in DotNetShoutout/KiGG.

Certainly we can merge all these files into one large file and put it in the page bottom but it wont be very optimal solution, it will make our page unnecessary heavy and add delays prior making the page usable. Some will argue that it is just for the first time as the browser will cache the file and the visitor does not have to download it again. Yes true, but for a new site where a large percentage of visitors is visiting it for the first time, it is really important that it is lightening fast and reducing the number and size of the external files we can make our pages to load faster. So, instead of downloading a single gigantic file, we preferred to divide and merge those files in terms of functionality into different file sets and add specific sets to each page. The Master page contains the core javascript framework(jQuery), common parts/initialization that are reused in the content pages and the content pages have its own specific file sets and initialization scripts. And this is where it starts throwing javascript exceptions. Consider the following simple scenario:

In your master page at the bottom you have added the Utility.js with the jQuery framework:

    <script type="text/javascript" src="<%= Url.Content("~/Scripts/jquery-1.3.2.min.js")%>"></script>
    <script type="text/javascript" src="<%= Url.Content("~/Scripts/utillity.js")%>"></script>
    <script type="text/javascript">
        $(document).ready(
                            function()
                            {
                                utility.init();
                            }
                        );
    </script>
</body>

And in content page that is using the above master page you have added the dummyObject.js file at the bottom of the content page:

    <script type="text/javascript" src="<%= Url.Content("~/Scripts/dummyObject.js")%>"></script>
    <script type="text/javascript">
        $(document).ready(
                            function()
                            {
                                dummyObject.init();
                            }
                        );
    </script>
</asp:Content>

If you run the above in VS, you will find that VS enters into debug mode with a message “object expected” like the following:

Can you guess what is the problem in the above? yes, before the jQuery framework is downloaded the browser encounter the $ which is not yet defined and starts shooting exceptions.This is a very common gotchas working with Master and Content Pages and it is not ASP.NET MVC specific, the Web Forms also falls into this trap. I guess this is the reason why we have to put the ASP.NET AJAX ScriptManager prior any ajaxable control when working with the Web Forms.

There are quite a few things, we would like to solve:

Ensure that all script tags are rendered first no matter where it is located (Master Page/Content Page/User Control) before the initialization (document.ready of jQuery).
Merge all initialization statements and put into a single initialization block. The ordering should be Master –> Content Page –> User Control, again no matter how deep the nesting is.
Merge all cleanup statements and put into a single cleanup block ($(window).unload of jQuery) same as above initialization but the ordering should be reverse - User Control –> Content Page – > Master Page.

Now meet my tiny little component AssetManagement which solves the above issues very elegantly.

First we will see how the above issues can be solved with the controls of AssetManagement. Yes, it contains very similar controls like ASP.NET Ajax, but the key differences are, you can place it anywhere in the page, it does not generate any extra server tags, just the script tag, no view state, no hidden control nothing, you can easily use it in your ASP.NET MVC application. For the above, we will first put the jQueryScriptManager in the master page like the following:

    <readZ:jQueryScriptManager id="scriptManager" runat="Server">
        <Scripts>
            <readZ:JavaScriptReference Path="~/Scripts/jquery-1.3.2.min.js"/>
            <readZ:JavaScriptReference Path="~/Scripts/utility.js"/>
        </Scripts>
        <OnPageLoad>
            utility.init();
        </OnPageLoad>
    </readZ:jQueryScriptManager>
</body>

Next, in the Content Page:

    <readZ:JavaScriptManagerProxy id="scriptManagerProxy" runat="Server">
        <Scripts>
            <readZ:JavaScriptReference Path="~/Scripts/dummyObject.js"/>
        </Scripts>
        <OnPageLoad>
            dummyObject.init();
        </OnPageLoad>
    </readZ:JavaScriptManagerProxy>
</asp:Content>

Now, when you run, it will generate the following html output:

<script type="text/javascript" src="Scripts/jquery-1.3.2.min.js"></script>
<script type="text/javascript" src="Scripts/utility.js"></script>
<script type="text/javascript" src="Scripts/dummyObject.js"></script>
<script type="text/javascript">
//<![CDATA[
jQuery(document).ready(function(){
            utility.init();
            dummyObject.init();
});
//]]>
</script>
</body>
</html>

You can also use the OnPageUnload property for cleanup. for example:

<readZ:jQueryScriptManager id="scriptManager" runat="Server">
    <Scripts>
        <readZ:JavaScriptReference Path="~/Scripts/jquery-1.3.2.min.js"/>
        <readZ:JavaScriptReference Path="~/Scripts/utility.js"/>
    </Scripts>
    <OnPageLoad>
        utility.init();
    </OnPageLoad>
    <OnPageUnload>
        alert('Cleanup for master page.');
    </OnPageUnload>
</readZ:jQueryScriptManager>

And

<readZ:JavaScriptManagerProxy id="scriptManagerProxy" runat="Server">
    <Scripts>
        <readZ:JavaScriptReference Path="~/Scripts/dummyObject.js"/>
    </Scripts>
    <OnPageLoad>
        dummyObject.init();
    </OnPageLoad>
    <OnPageUnload>
        alert('Cleanup for content page.');
    </OnPageUnload>
</readZ:JavaScriptManagerProxy>

It will generate:

<script type="text/javascript" src="Scripts/jquery-1.3.2.min.js"></script>
<script type="text/javascript" src="Scripts/utility.js"></script>
<script type="text/javascript" src="Scripts/dummyObject.js"></script>
<script type="text/javascript">
//<![CDATA[
jQuery(document).ready(function(){
            utility.init();        
            dummyObject.init();
});

jQuery(window).unload(function(){
            alert('Cleanup for content page.');
            alert('Cleanup for master page.');
});
//]]>
</script>

Okay, if you have promised that you will not use any server control in your ASP.NET MVC application anymore, here is the fluent version of the exact same thing:

Master Page:

<%= Html.jQuery().Scripts(
                            script =>
                            {
                                script.Source("http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js");
                                script.Source("~/Scripts/utility.js");
                            }
                         )
                 .OnPageLoad("utility.init();")
                 .OnPageUnload("alert('Cleanup for master page.');")
%>

Content Page:

<% Html.jQuery().Scripts(script => script.Source("~/Scripts/dummyObject.js"))
                 .OnPageLoad("dummyObject.init();")
                 .OnPageUnload("alert('Cleanup for content page.');");
%>

And it will generate the same output as the controls. Note that for Content Page we are only using <% but for the master page we are using <%= which means we want to dump the result. Also the fluent syntax is progressive interface (inspired by this excellent post of Jan Van Ryswyck) which means once you call a method, it will show the only available methods in that context like the following:

The component also contains an HttpHandler which you can use to combine multiple css and javascript files, the above codes can also refer these assets. To use the asset handler, you have to first define the assets in the web.config like the following:

<configSections>
    <section name="assetSettings" type="ReadZ.AssetManagement.AssetSettingsSection, ReadZ.AssetManagement" requirePermission="false"/>
</configSections>
<assetSettings version="1.0.0.0" cacheDurationInDays="365" compress="true">
    <assets>
        <clear/>
        <add
            name="css"
            contentType="text/css"
            directory="~/assets/css"
            files="site.min.css;ui.jquery.min.css;marItUp.min.css;colorPicker.min.css"
        />
        <add
            name="js2"
            contentType="application/x-javascript"
            directory="~/assets/scripts"
            files="OpenID.min.js;jquery-1.2.6.min.js;jquery.form.min.js;jquery.validate.min.js;ui.core.min.js;ui.tabs.min.js;ui.draggable.min.js;ui.resizable.min.js;ui.dialog.min.js;Utility.min.js;Search.min.js;Tag.min.js;Membership.min.js;Story.min.js;Analytics.min.js"
        />
        <add
            name="js3"
            contentType="application/x-javascript"
            directory="~/assets/scripts"
            files="ui.autocomplete.min.js;jquery.markitup.min.js;showdown.js;colorpicker.min.js;RichEditor.min.js;ImageCode.min.js;Comment.min.js"
        />
    </assets>
    <system.web>
        <pages>
            <controls>
                <add tagPrefix="readZ" namespace="ReadZ.AssetManagement" assembly="ReadZ.AssetManagement"/>
                <add tagPrefix="readZ" namespace="ReadZ.AssetManagement.Controls" assembly="ReadZ.AssetManagement"/>
            </controls>
            <namespaces>
                <add namespace="ReadZ.AssetManagement"/>
                <add namespace="ReadZ.AssetManagement.HtmlHelpers"/>
            </namespaces>
        </pages>
        <httpHandlers>
            <add verb="GET,HEAD" path="asset.axd" validate="false" type="ReadZ.AssetManagement.AssetHandler, ReadZ.AssetManagement"/>
        </httpHandlers>
    </system.web>
    <system.webServer>
        <handlers>
            <remove name="AssetHandler"/>
            <add name="AssetHandler" preCondition="integratedMode" verb="GET,HEAD" path="asset.axd" type="ReadZ.AssetManagement.AssetHandler, ReadZ.AssetManagement"/>
        </handlers>
    </system.webServer>
</assetSettings>

As you can see, each asset has an unique name, the content type and number of files with the location. When an asset is requested it will merge the specified files into a single response, cache and compress it before sending the response. You can define global version, cache duration and compression (line 4) which will apply to all, you can also override the global settings as per asset. When referring these assets in your code you can use:

For Control:

<readZ:jQueryScriptManager id="scriptManager" runat="Server">
    <Scripts>
        <readZ:JavaScriptReference AssetName="js2"/>
    </Scripts>
</readZ:jQueryScriptManager>

For Fluent Html:

<%= Html.jQuery().Scripts(script => script.Asset("js2")) %>

When referring the CSS, you can use:

<head runat="server">
    <title><asp:ContentPlaceHolder ID="TitleContent" runat="server" /></title>
    <link href="<%= Url.Asset("css")%>" rel="stylesheet" type="text/css"/>
</head>

The component has the extension methods for both UrlHelper and HtmlHelper, so that you can use it conveniently in your ASP.NET MVC views.

So far the codes that I have shown is for jQuery only, If you are thinking what about the others like ExtJS, prototype etc. The component has some nice extensibilities which you can use to support other popular libraries as well. For example, lets add the support for the ExtJS. First you have to create a class which implements the IScriptWrapper interface, next add codes for WrapOnPageLoad and WrapOnPageUnload methods like the following:

public class ExtJSScriptWrapper : IScriptWrapper
{
    public string WrapOnPageLoad(string scripts)
    {
        return string.IsNullOrEmpty((scripts ?? string.Empty).Trim()) ? string.Empty : string.Concat("Ext.onReady(function(){\r\n", scripts, "\r\n});");
    }

    public string WrapOnPageUnload(string scripts)
    {
        return string.IsNullOrEmpty((scripts ?? string.Empty).Trim()) ? string.Empty : string.Concat("Ext.EventManager.on(window, 'unload', function(){\r\n", scripts, "\r\n});");
    }
}

Control:

Next create a new control which inherits from base JavaScriptManager and create a new instance of the above wrapper in the constructor and that’s it.

public class ExtJSScriptManager : JavaScriptManager
{
    public ExtJSScriptManager() : base(new ExtJSScriptWrapper())
    {
    }
}

Now you will be able to use the ExtJSScriptManager like the same way as we did with jQueryScriptManager in the above.

Fluent Html:

First, create a class which inherits from base AbstractScriptHtmlHelper and create a new instance of the above wrapper in the constructor:

public class ExtJSScriptHtmlHelper : AbstractScriptHtmlHelper
{
    public ExtJSScriptHtmlHelper(HtmlHelper htmlHelper) : base(new ExtJSScriptWrapper(), htmlHelper)
    {
    }
}

Next create an extension method for the HtmlHelper which will return it.

public static class HtmlHelperExtension
{
    public static ExtJSScriptHtmlHelper ExtJS(this HtmlHelper helper)
    {
        return new ExtJSScriptHtmlHelper(helper);
    }
}

And that’s it, now you will be able to refer ExtJS in the mvc view.

The component also has the unit tests with the amazing duo (xUnit + Moq) and interestingly I was able to achieve 100% code coverage which is worth to check (Yes you will find some unnecessary tests, I did it intentionally to achieve more code coverage).

You can download the above sample code and the component from the bottom of this post. If you have any feedback/bug report/enhancements, do let me know.

Happy YSlow scoring in your ASP.NET MVC App!!!

Download: Source Code

AdRotator for ASP.NET MVC

kazimanzurrashid — Mon, 20 Apr 2009 02:32:49 GMT

I was looking for an Ad Rotator for DotNetShoutout, as the sponsors are coming and most of them wants to show different images for the site and as well as in the feed. Certainly, I can use the built-in AdRotator control for the site, but it does not at all feels MVC-ish. So I decided to create a small class which mimics the same behavior as the original control.

namespace Kigg.Web
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web.Mvc;
    using System.Web.Routing;

    public class Ad
    {
        public string NavigateUrl
        {
            get;
            set;
        }

        public string Target
        {
            get;
            set;
        }

        public object LinkAttributes
        {
            get;
            set;
        }

        public string ImageUrl
        {
            get;
            set;
        }

        public string AlternateText
        {
            get;
            set;
        }

        public object ImageAttributes
        {
            get;
            set;
        }

        public string Keyword
        {
            get;
            set;
        }

        public int Impressions
        {
            get;
            set;
        }

        public static string Rotate(string keywordFilter, params Ad[] ads)
        {
            Ad ad = PickAd(keywordFilter, ads);

            string html = (ad == null) ? string.Empty : GenerateHtml(ad);

            return html;
        }

        public static string Rotate(params Ad[] ads)
        {
            return Rotate(null, ads);
        }

        private static Ad PickAd(string keywordFilter, params Ad[] ads)
        {
            Ad targetAd = null;

            IList<Ad> matchedAds = ads.Where(ad => string.Compare(ad.Keyword, keywordFilter, StringComparison.InvariantCultureIgnoreCase) == 0)
                                      .OrderBy(ad => ad.Impressions)
                                      .ToList();

            if (matchedAds.Count > 0)
            {
                int max = matchedAds.Sum(ad => ad.Impressions);
                int random = new Random().Next(max + 1);
                int runningTotal = 0;

                foreach(Ad ad in matchedAds)
                {
                    runningTotal += ad.Impressions;

                    if (random <= runningTotal)
                    {
                        targetAd = ad;
                        break;
                    }
                }

                if (targetAd == null)
                {
                    targetAd = matchedAds.Last();
                }
            }

            return targetAd;
        }

        private static string GenerateHtml(Ad ad)
        {
            Action<TagBuilder, object> merge = (builder, values) =>
                                               {
                                                   if (values != null)
                                                   {
                                                       builder.MergeAttributes(new RouteValueDictionary(values));
                                                   }
                                               };

            Action<TagBuilder, string, string> mergeIfNotBlank =    (builder, name, value) =>
                                                                    {
                                                                         if (!string.IsNullOrEmpty(value))
                                                                         {
                                                                             builder.MergeAttribute(name, value, true);
                                                                         }
                                                                    };

            TagBuilder imageBuilder = new TagBuilder("img");

            merge(imageBuilder, ad.ImageAttributes);
            mergeIfNotBlank(imageBuilder, "src", ad.ImageUrl);
            mergeIfNotBlank(imageBuilder, "alt", ad.AlternateText);

            if (!imageBuilder.Attributes.ContainsKey("alt"))
            {
                imageBuilder.Attributes.Add("alt", string.Empty);
            }

            TagBuilder linkBuilder = new TagBuilder("a");

            merge(linkBuilder, ad.LinkAttributes);
            mergeIfNotBlank(linkBuilder, "href", ad.NavigateUrl);
            mergeIfNotBlank(linkBuilder, "target", ad.Target);

            linkBuilder.InnerHtml = imageBuilder.ToString(TagRenderMode.SelfClosing);

            return linkBuilder.ToString();
        }
    }
}

And in the view I can use it like the following:

<%= Ad.Rotate(
                new Ad { NavigateUrl = "http://mysponsor1.com?tid=1", LinkAttributes = new { rel = "nofollow" }, ImageUrl = Url.Image("sponsors/mysponsor1/1.gif"), AlternateText = "My Cool Sponsor", ImageAttributes = new { style = "border:0"}, Impressions = 60 },
                new Ad { NavigateUrl = "http://mysponsor1.com?tid=2", LinkAttributes = new { rel = "nofollow" }, ImageUrl = Url.Image("sponsors/mysponsor1/2.gif"), AlternateText = "My Cool Sponsor", ImageAttributes = new { style = "border:0" }, Impressions = 40 },
                new Ad { NavigateUrl = "http://mysponsor1.com?tid=3", LinkAttributes = new { rel = "nofollow" }, ImageUrl = Url.Image("sponsors/mysponsor1/3.gif"), AlternateText = "My Cool Sponsor", ImageAttributes = new { style = "border:0"}, Impressions = 20 }
             )%>

It will randomly rotate based upon the impression value like the original control. Though keyword filtering is not required for DotNetShoutout, but I have implemented it, maybe you can find it useful.

KiGG is now upgraded to ASP.NET MVC RTM 1.0

kazimanzurrashid — Tue, 07 Apr 2009 12:02:46 GMT

Just to let you know that I have uploaded the latest source of KiGG in Codeplex. Other than upgrading to ASP.NET MVC RTM, there are few enhancements:

Implementing EventAggregator.
Background Services like:
- Broadcast in Twitter.
- Ping different Feed Servers automatically.
Restrict Story submit from specific domains.
SQL Server Full Text search.
Other minor enhancements and bug fixes.

And yes http://dotnetshoutout.com is currently running the same codebase. Those who are assuming whether KiGG is following the same practices which I have mentioned recently over here and here, let me tell you, no it is not following all the items, I am in a process of refactoring it following those rest of the items which I hope to deliver in a few weeks or I will post the tiny app that I am also developing.

Stay tuned.

Use Event Aggregator to make your application more extensible

kazimanzurrashid — Thu, 05 Mar 2009 14:35:28 GMT

Recently, in KiGG/DotNetShoutout we have integrated Twitter, nothing complex, very basic thing like when a story is submitted or appears in the front page it will broadcast in Twitter and like our feed it will post the short url of the original story (Cant resist to do some shameless marketing for DotNetShoutout).

Since it is a new requirement, initially I have modified the StoryService constructor to include the twitter client as a new argument and use it after the story is added in the database, the code is something like the following:

//Other codes

//Add it in database
_storyRepository.Add(story);

//Increase User Score
_userScoreService.StorySubmitted(byUser);

// Send Trackback
PingStory(content, story, detailUrl);

//Ping the Feed Servers
PingServers();

//Send Tweet
_twitter.UpdateStatus(story);

result = new StoryCreateResult { NewStory = story, DetailUrl = detailUrl };

return result;

As you can see there are quite a few things that I have do:

Increase the User Score.
Send Trackback (Thank you for submitting this cool story)
Ping Feedburner/Pingomatic/technorati servers.
Send Tweet.

So for this new requirement we have to modify it and will again have to do if we add more features in future and we do have a plan to implement the Spy/Log (don’t confuse it with the code logger, it is ajax view which shows what is happening currently in the application) and this obviously not a path we should follow. It violets the OCP completely, tie us to write some transactional script kind of code. We need to find a way where we can add new features without modifying the StoryService. One option would be to pass an array of IBackgroundService (As these are noting but some background services)in the StoryService constructor which these classes will implement and later on the StoryService will call the Execute method of each background service. But Story Submit, Story Publish is more like a system event which should be globally available.

Enter Event Aggregator

As per Martin Fowler “An Event Aggregator acts as a single source of events for many objects. It registers for all the events of the many objects allowing clients to register with just the aggregator.” Jeremy D Miller also used this pattern in his excellent Build your own CAB series. And recently I was browsing through the CompositeWpf/Prism code and found the EventAggregator which seems a perfect candidate for my situation. According to its documentation:

“The EventAggregator service is primarily a container for events that allow decoupling of publishers and subscribers so they can evolve independently.”

But it has some dependency on .NET WPF which I would like to remove, and after talking with Glen Block, he confirmed that since it is licensed under MS-PL, I can copy and modify it according to my need. Also most of the example you will find of Event Aggregator demonstrate the UI events, but it is a very powerful pattern and can be used in non UI events too which we will see next.

As mentioned in the above that UserScoreService, PingStory, PingServer, SendTweet is some kind of background task which can be run independently and it will act as subscriber in the above diagram, so lets create an interface:

public interface IBackgroundTask
{
    bool IsRunning
    {
        get;
    }

    void Start();

    void Stop();
}

Next we will create an abstract class which will implement this interface to reduce the duplicate codes:

public abstract class BaseBackgroundTask : IBackgroundTask
{
    private readonly IEventAggregator _eventAggregator;

    protected BaseBackgroundTask(IEventAggregator eventAggregator)
    {
        if (eventAggregator == null)
        {
            throw new ArgumentNullException("eventAggregator");
        }

        _eventAggregator = eventAggregator;
    }

    public bool IsRunning
    {
        get;
        private set;
    }

    protected IEventAggregator EventAggregator
    {
        get
        {
            return _eventAggregator;
        }
    }

    public void Start()
    {
        OnStart();
        IsRunning = true;
    }

    public void Stop()
    {
        OnStop();
        IsRunning = false;
    }

    protected abstract void OnStart();

    protected abstract void OnStop();

    protected SubscriptionToken Subscribe<TEvent, TEventArgs>(Action<TEventArgs> action) where TEvent : BaseEvent<TEventArgs> where TEventArgs : class
    {
        return EventAggregator.GetEvent<TEvent>().Subscribe(action, true);
    }

    protected void Unsubscribe<TEvent>(SubscriptionToken token) where TEvent : BaseEvent
    {
        EventAggregator.GetEvent<TEvent>().Unsubscribe(token);
    }
}

Now lets create some concrete implementation of these background tasks.

First, the Twitter:

public class SendTweet : BaseBackgroundTask
{
    private SubscriptionToken _storySubmitToken;

    public SendTweet(IEventAggregator eventAggregator) : base(eventAggregator)
    {
    }

    protected override void OnStart()
    {
        if (!IsRunning)
        {
            _storySubmitToken = Subscribe<StorySubmitEvent, StorySubmitEventArgs>(StorySubmitted);
        }
    }

    protected override void OnStop()
    {
        if (IsRunning)
        {
            Unsubscribe<StorySubmitEvent>(_storySubmitToken);
        }
    }

    private void StorySubmitted(StorySubmitEventArgs eventArgs)
    {
        UpdateStatus(eventArgs.Story);
    }

    private void UpdateStatus(Story story)
    {
        //Update Twitter status goes here
    }
}

Next the UserScoreService:

public class UserScoreService : BaseBackgroundTask
{
    private SubscriptionToken _storySubmitToken;

    public UserScoreService(IEventAggregator eventAggregator) : base(eventAggregator)
    {
    }

    protected override void OnStart()
    {
        if (!IsRunning)
        {
            _storySubmitToken = Subscribe<StorySubmitEvent, StorySubmitEventArgs>(StorySubmitted);
        }
    }

    protected override void OnStop()
    {
        if (IsRunning)
        {
            Unsubscribe<StorySubmitEvent>(_storySubmitToken);
        }
    }

    private void StorySubmitted(StorySubmitEventArgs eventArgs)
    {
        IncreaseUserScore(eventArgs.Story.PostedBy);
    }

    private void IncreaseUserScore(User user)
    {
        // Increase user score goes here
    }
}

I am skipping the PingStory and PingServer as they are very much same as above.

Next the published part, now the StoryService will forward the StorySubmit event to EventAggregator instead of calling these class individually.

//Other codes

//Add it in database
_storyRepository.Add(story);

//Publish the event
_eventAggregator.GetEvent<StorySubmitEvent>().Publish(new StorySubmitEventArgs(story, detailUrl));

result = new StoryCreateResult { NewStory = story, DetailUrl = detailUrl };

return result;

And now we have to ensure that these background services can start listing this event. So lets create a BootstrapperTask which I have shown in my previous post.

public class StartBackgroundTasks : IBootstrapperTask
{
    private readonly IBackgroundTask[] _tasks;

    public StartBackgroundTasks(IBackgroundTask[] tasks)
    {
        _tasks = tasks;
    }

    public void Execute()
    {
        foreach(IBackgroundTask task in _tasks)
        {
            task.Start();
        }
    }
}

And at last the wiring of Unity container, I am using the fluent version but you can also use the xml configuration if you want.

IUnityContainer container = new UnityContainer();

container.RegisterType<IBackgroundTask, UserScoreService>("userScore", new ContainerControlledLifetimeManager())
         .RegisterType<IBackgroundTask, SendTweet>("sendTweet", new ContainerControlledLifetimeManager())
         .RegisterType<IBackgroundTask, PingStory>("pingStory", new ContainerControlledLifetimeManager())
         .RegisterType<IBackgroundTask, PingServer>("pingServer", new ContainerControlledLifetimeManager())
         .RegisterType<IEventAggregator, EventAggregator>(new ContainerControlledLifetimeManager())
         .RegisterType<IControllerFactory, CommonServiceLocatorControllerFactory>(new ContainerControlledLifetimeManager())
         .RegisterType<IBootstrapperTask, RegisterRoutes>("route", new ContainerControlledLifetimeManager(), new InjectionConstructor(new [] { RouteTable.Routes}))
         .RegisterType<IBootstrapperTask, RegisterControllerFactory>("controllerFactory", new ContainerControlledLifetimeManager())
         .RegisterType<IBootstrapperTask, StartBackgroundTasks>("startBackgroundTasks", new ContainerControlledLifetimeManager())
         .RegisterType<IFormsAuthentication, FormsAuthenticationService>(new ContainerControlledLifetimeManager())
         .RegisterType<IMembershipService, AccountMembershipService>(new InjectionConstructor())
         .RegisterType<AccountController>()
         .RegisterType<HomeController>();

ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(container));

My initial plan was to refer you the KiGG/DotNetShoutout source code rather than posting a separate version, but as you know that ASP.NET MVC RC2 has released few days ago I would rather upgrade it to that version.

Further Reference:

Comments/Suggestions?

Download: EventAggregator.zip

Use Bootstrapper in Your ASP.NET MVC Application and Reduce Code Smell

kazimanzurrashid — Tue, 17 Feb 2009 17:56:00 GMT

In this post, I will show how you can use a simple bootstrapper to make your application more extensible. In a typical ASP.NET MVC application you will find there are lots of thing going on in Application_Start, like configuring your IoC/DI, registering routes, model binders etc. The following is the code snippet of latest Oxite source:

protected virtual void OnStart()
{
    setupContiner();

    setupSite();

    registerRoutes();

    registerActionFilters();

    registerModelBinders();

    registerViewEngines();

    registerControllerFactory();

    launchBackgroundServices();
}

Don't you think there are too many things going on, Is there any way to extend it, how do you add new routes/model binder/view engine without modifying it, does not it violet the Open Closed Principle?

The Bootstrapper

The bootstrapper should have only one responsibility, execute the start up tasks, so first lets create a Task interface:

public interface IBootstrapperTask
{
    void Execute();
}

Next, create few small classes for each kind of task which implements this interface, I will use my previous blog post example in this case:

RegisterControllerFactory:

public class RegisterControllerFactory : IBootstrapperTask
{
    private readonly IControllerFactory _controllerFactory;

    public RegisterControllerFactory(IControllerFactory controllerFactory)
    {
        _controllerFactory = controllerFactory;
    }

    public void Execute()
    {
        ControllerBuilder.Current.SetControllerFactory(_controllerFactory);
    }
}

RegisterRoutes:

public class RegisterRoutes : IBootstrapperTask
{
    private readonly RouteCollection _routes;

    public RegisterRoutes() : this(RouteTable.Routes)
    {
    }

    public RegisterRoutes(RouteCollection routes)
    {
        _routes = routes;
    }

    public void Execute()
    {
        _routes.Clear();

        _routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
        _routes.MapRoute("Default", "{controller}/{action}/{id}", new { controller = "Home", action = "Index", id = "" });
    }
}

As you can understand there can be more, for example, I am using it in DotNetShoutout for creating default users, running background tasks etc. Next create a static class Bootstrapper which will execute these tasks:

public static class Bootstrapper
{
    static Bootstrapper()
    {
        ConfigureContainer();
    }

    public static void Run()
    {
        var tasks = ServiceLocator.Current.GetAllInstances<IBootstrapperTask>();

        foreach(var task in tasks)
        {
            task.Execute();
        }
    }

    private static void ConfigureContainer()
    {
        IUnityContainer container = new UnityContainer();

        UnityConfigurationSection configuration = (UnityConfigurationSection) ConfigurationManager.GetSection("unity");
        configuration.Containers.Default.Configure(container);

        ServiceLocator.SetLocatorProvider(() => new UnityServiceLocator(container));
    }
}

And in the Global.asax:

protected void Application_Start()
{
    Bootstrapper.Run();
}

And in the web.config, we can wired the tasks like the following:

<unity>
    <typeAliases>
        <typeAlias alias="IControllerFactory" type="System.Web.Mvc.IControllerFactory, System.Web.Mvc"/>
        <typeAlias alias="ControllerFactory" type="UnityCommonServiceLocatorMVC.CommonServiceLocatorControllerFactory, UnityCommonServiceLocatorMVC"/>
        <typeAlias alias="IBootstrapperTask" type="UnityCommonServiceLocatorMVC.IBootstrapperTask, UnityCommonServiceLocatorMVC"/>
        <typeAlias alias="RegisterRoutes" type="UnityCommonServiceLocatorMVC.RegisterRoutes, UnityCommonServiceLocatorMVC"/>
        <typeAlias alias="RegisterControllerFactory" type="UnityCommonServiceLocatorMVC.RegisterControllerFactory, UnityCommonServiceLocatorMVC"/>
    </typeAliases>
    <containers>
        <container>
            <types>
                <type name="registerRoutes" type="IBootstrapperTask" mapTo="RegisterRoutes"/>
                <type type="IControllerFactory" mapTo="ControllerFactory"/>
                <type name="registerControllerFactory" type="IBootstrapperTask" mapTo="RegisterControllerFactory">
                    <typeConfig extensionType="Microsoft.Practices.Unity.Configuration.TypeInjectionElement, Microsoft.Practices.Unity.Configuration">
                        <constructor>
                            <param name="controllerFactory" parameterType="IControllerFactory">
                                <dependency/>
                            </param>
                        </constructor>
                    </typeConfig>
                </type>
            </types>
        </container>
    </containers>
</unity>

So by using this bootstrapper we are making our application completely extensible, we can create new task and execute it in the application start without modifying anything.

Comments/Suggestions?

Download: Complete Source

ASP.NET MVC RC1, ValidateInput, A potential dangerous request and the Pitfall

kazimanzurrashid — Sat, 14 Feb 2009 00:12:30 GMT

In the latest release of ASP.NET MVC, a new attribute ValidateInput is introduced which is same as Web Forms ValidateRequest page directive, certainly a good choice. Phil Haack blogged it, so as Steven Smith and also Nick Berarrdi. But it starts to break when you want to accept html tags from your user and using RenderAction of MVC Future to render different parts of your page. Consider the following screenshot DotNetShoutout story submit page:

Rendered by Html.RenderAction<MembershipController>(c => c.Menu()) in Master Page.
Rendered by Html.RenderAction<CategoryController>(c => c.Menu()) in Master Page.
This is original request StoryController.Submit.
Rendered by Html.RenderAction<TagController>(c => c.Tabs()) in Master Page.
Rendered by Html.RenderAction<CategoryController>(c => c.RadioButtonList()) in Content Page.

The story description box will allow few known html tags and for this I have to decorate all of the above controllers method with ValidateInput(false) which is bit of annoying. I think the problem is mainly in MVC Future as it takes the same HttpContext but does not mark it as child/worker request (which I think it should) so when the ControllerActionInvoker.InvokeAction() comes into the action it does not takes the original attribute decoration into consideration. This is not a big deal for a small app like KiGG, but is definitely going to be if I am planning to develop DotNetNuke like CMS with ASP.NET MVC.

I think I need to take a look at the MVCContrib, how they have handled this situation with SubController.

DotNetShoutout : Few Productivity Tips

kazimanzurrashid — Fri, 13 Feb 2009 00:21:13 GMT

I just want share few tips with the DotNetShoutout users, maybe you have already discovered it, if you have not then it might be handy.

Feed

If you subscribe to our published or upcoming feed, you will notice that clicking on the link does not take you back to DotNetShoutout story page, instead it will take you directly to the original Story page, saving you from one unnecessary click.

With the story text you will also find the number of shout and a small page preview, if you want to shout the story click the shout it counter, it will take you to the DotNetShoutout page. And by the way you can subscribe to our Upcoming feed without worrying about spam, our system is quite equipped fighting with those spammers.

Sharing

Like the feed when you share a story, it will share the original url instead of the DotNetShoutout url. Currently we are only supporting MSDN Social(though I am not sure how many people are using it), delicious, facebook and twitter and for twitter we are even shrinking the original url to fit in 140 characters.

And in Twitter:

Shout it Badge

If you are blogging from Live write and putting the Shout it badge manually, please stop. We do a have plug-in for the latest Live Writer which autmattically inserts the counter in the footer of your post. Just visit the release section of codeplex and download the LiveWriterBinary.zip, it is just a simple dll (you can also get the source code version from the release page) which you have to copy in the plug-in folder of Live Writer (e.g . C:\Program Files\Windows Live\Writer\Plugins). Once you copied the dll, you find the plug-in name in Live Writer menu –> Tool->Options->Plug-ins, like the following:

Make sure it is enabled, you can also change the default colors from the options depending upon your blog theme. Now write your post and click publish, live writer might ask you do you want to execute this plug-in, click yes. The counter will appear at the bottom of your post like this post.

Enjoy!!!

Domain Model (Developing KiGG v2.0 Part 1)

kazimanzurrashid — Thu, 12 Feb 2009 00:27:00 GMT

As mention in my previous post that I will be discussing the technical side of KiGG. So this is the beginning and it will be a multi-part series. I will try to put as much detail as possible, do let me know if I missed anything.

Just for a recap, KiGG is Web 2.0 style social news application where I am trying to exercise some of the best practice like TDD, DDD, SOLID etc with Microsoft supported tooling. If you want to see it in action just visit http://dotnetshoutout.com.

KiGG is already a fully functional application, but here I am starting from scratch, so the actual code might not look the same with following but it will show you how it is evolved as I am going to post more on it over the time.

Let us begin with the core functionalities:

User should be able to submit story.
- User will select a category and can specify multiple tags when submitting story.
- User should not be able to submit a story which already exists (based upon Url).
- The system will ensure the story is a .NET related story, otherwise it will need moderator approval prior make it visible to everyone.
User should be able to promote story.
- When the story has not been promoted by him/her.
- When the story has not been marked as spam by him/her.
User should be able to demote story.
- When the story has not been submitted by him/her.
- When the story has been previously promoted by him/her.
User should be able to mark story as spam.
- When the story has not been promoted by him/her.
- When the story has not been marked as spam by him/her.
- When story is not published.
User should be able to post comment.
- The system will ensure the comment is not a spam.
User should be able to subscribe/unsubscribe comments of a Story.
User should be able to Tag story.
User should be able to view the original story by clicking the link and the count should be maintained.
User Score should be increased/decreased based upon the above actions.
User should be able to view the story list by published/upcoming/category/tag/user etc.
Moderator should be able to Edit Story.
Moderator should be able to Delete Story.
Moderator should be able to Confirm a Story/Comment as Spam.
Moderator should be able to Approve a Story as not spam which was previously marked as spam.
Admin should be able to Lock/Unlock a User.
Admin should be able to change role of a User.
Admin should be able to Publish stories at periodic interval.

With the above functionalities we can come up with an object model which consists classes like User, Story, Tag, Category, Vote, MarkAsSpam, Comment:

Now, lets refine this domain model with TDD (I will skip the red part of red-green-refactor to save space of this post, but you should always exercise the red part while developing in this way).

Promoting

When promoting the story we have to check two things, user has not previously promoted it and not marked it as spam. Lets write the tests:

[Fact]
public void HasPromoted_Should_Return_False_When_User_Has_Not_Previously_Promoted()
{
    var user = new User();

    Assert.False(_story.HasPromoted(user));
}

[Fact]
public void HasMarkedAsSpam_Should_Return_False_When_User_Has_Not_Previously_MarkedAsSpam()
{
    var user = new User();

    Assert.False(_story.HasMarkedAsSpam(user));
}

And in Story:

public bool HasPromoted(User byUser)
{
    return Votes.Any(v => v.ByUser.Id == byUser.Id);
}

public bool HasMarkedAsSpam(User byUser)
{
    return MarkAsSpams.Any(m => m.ByUser.Id == byUser.Id);
}

Now, create a new method that internally calls these two methods, so that client can only call this single method instead of calling those, test:

[Fact]
public void CanPromote_Should_Return_True_When_Story_Has_Not_Been_Promoted()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.CanPromote(user));
}

[Fact]
public void CanPromote_Should_Return_True_When_Story_Has_Not_Been_MarkedAsSpam_By_The_User()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.CanPromote(user));
}

And in Story:

public bool CanPromote(User byUser)
{
    return !HasPromoted(byUser) && !HasMarkedAsSpam(byUser);
}

Now the actual promote, note that we have introduced a new property Timestamp in Vote, tests:

[Fact]
public void Promote_Should_Return_True_When_User_Can_Promote()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.Promote(DateTime.UtcNow, user));
}

[Fact]
public void Promote_Should_Add_User_Vote_In_Votes()
{
    var user = new User { Id = Guid.NewGuid() };

    _story.Promote(DateTime.UtcNow, user);

    Assert.True(_story.Votes.Count(v => v.ByUser.Id == user.Id) > 0);
}

And in Story:

private readonly List<Vote> _votes = new List<Vote>();

public ICollection<Vote> Votes
{
    get
    {
        return _votes.AsReadOnly();
    }
}

public bool Promote(DateTime at, User byUser)
{
    if (CanPromote(byUser))
    {
        Vote vote = new Vote
                        {
                            ByUser = byUser,
                            ForStory = this,
                            Timestamp = at
                        };

        _votes.Add(vote);

        return true;
    }

    return false;
}

Notice that I have exposed the Votes as read only collection, though the ReadOnlyCollection<T> of ObjectModel namespace should be more appropriate, but I would like to stick with the interface instead of concrete class. So adding vote in Votes will raise exception, the client always have to use the Promote method.

Demoting

Demoting is similar to promoting, we have to check that the User has not submitted the story and the story has been previously promoted by the user(You can only demote if you previously promoted it), tests:

[Fact]
public void CanDemote_Should_Return_True_When_Story_Has_Been_Promoted_By_The_User()
{
    //Promote it first
    var user = new User { Id = Guid.NewGuid() };
    _story.Promote(DateTime.UtcNow, user);

    Assert.True(_story.CanDemote(user));
}

[Fact]
public void Demote_Should_Return_True_When_User_Can_Demote()
{
    //Promote it first
    var user = new User { Id = Guid.NewGuid() };
    _story.Promote(DateTime.UtcNow, user);

    Assert.True(_story.Demote(user));
}

[Fact]
public void Demote_Should_Remove_User_Vote_From_Votes()
{
    //Promote it first
    var user = new User { Id = Guid.NewGuid() };
    _story.Promote(DateTime.UtcNow, user);

    _story.Demote(user);

    Assert.True(_story.Votes.Count(v => v.ByUser.Id == user.Id) == 0);
}

And in Story:

public bool CanDemote(User byUser)
{
    return (PostedBy.Id != byUser.Id) && HasPromoted(byUser);
}

public bool Demote(User byUser)
{
    if (CanDemote(byUser))
    {
        Vote vote = _votes.Single(v => v.ByUser.Id == byUser.Id);

        _votes.Remove(vote);

        return true;
    }

    return false;
}

Marking as Spam

Marking as spam is also similar to story promoting, only a new checking that is if the story is published, so we will need a new property which will indicate whether the story is published, lets create a new property PublishedAt of nullable DateTime and create an extension method:

public static bool IsPublished(this Story story)
{
    return (story.PublishedAt.HasValue);
}

we also introduced a new property Timestamp for MarkAsSpam like vote, tests:

[Fact]
public void CanMarkAsSpam_Should_Return_True_When_Story_Has_Not_Been_Published()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.CanMarkAsSpam(user));
}

[Fact]
public void CanMarkAsSpam_Should_Return_True_When_Story_Has_Not_Been_Promoted_By_The_User()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.CanMarkAsSpam(user));
}

[Fact]
public void CanMarkAsSpam_Should_Return_True_When_Story_Has_Not_Been_MarkedAsSpam_By_The_User()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.CanMarkAsSpam(user));
}

[Fact]
public void MarkAsSpam_Should_Return_True_When_User_Can_Mark_As_Spam()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.True(_story.MarkAsSpam(DateTime.UtcNow, user));
}

[Fact]
public void MarkAsSpam_Should_Add_User_Marking_In_MarkAsSpams()
{
    var user = new User { Id = Guid.NewGuid() };

    _story.MarkAsSpam(DateTime.UtcNow, user);

    Assert.True(_story.MarkAsSpams.Count(m => m.ByUser.Id == user.Id) > 0);
}

And in Story

private readonly List<MarkAsSpam> _markAsSpams = new List<MarkAsSpam>();

public ICollection<MarkAsSpam> MarkAsSpams
{
    get
    {
        return _markAsSpams.AsReadOnly();
    }
}

public bool CanMarkAsSpam(User byUser)
{
    return !this.IsPublished() && !HasPromoted(byUser) && !HasMarkedAsSpam(byUser);
}

public bool MarkAsSpam(DateTime at, User byUser)
{
    if (CanMarkAsSpam(byUser))
    {
        MarkAsSpam markAsSpam = new MarkAsSpam
                                    {
                                        ByUser = byUser,
                                        ForStory = this,
                                        Timestamp = at
                                    };

        _markAsSpams.Add(markAsSpam);

        return true;
    }

    return false;
}

Post Comment

For comment we have to introduce few new properties, Id, Content and CreatedAt. We will skip the spam checking part for the future post, tests:

[Fact]
public void PostComment_Should_Return_New_Comment()
{
    var user = new User{ Id = Guid.NewGuid() };

    var comment = _story.PostComment("This is a dummy content", DateTime.UtcNow, user);

    Assert.NotNull(comment);
}

[Fact]
public void PostComment_Should_Increase_Comments_Collection()
{
    var previousCount = _story.Comments.Count;

    var user = new User { Id = Guid.NewGuid() };

    _story.PostComment("This is a dummy content", DateTime.UtcNow, user);

    Assert.True(_story.Comments.Count > previousCount);
}

And in Story:

private readonly List<Comment> _comments = new List<Comment>();

public ICollection<Comment> Comments
{
    get
    {
        return _comments.AsReadOnly();
    }
}

public Comment PostComment(string content, DateTime at, User byUser)
{
    Comment comment = new Comment
                          {
                              Id = Guid.NewGuid(),
                              ByUser = byUser,
                              ForStory = this,
                              CreatedAt = at,
                              Content = content
                          };

    _comments.Add(comment);

    return comment;
}

Subscribing/Unsubscribing Comments

When subscribing comment we will check if the user has already subscribed, if not we will subscribe otherwise we will ignore it, tests:

[Fact]
public void ContainsCommentSubscriber_Should_Return_False_When_User_Does_Not_Exist_In_CommentSubscribers_Collection()
{
    var user = new User { Id = Guid.NewGuid() };

    Assert.False(_story.ContainsCommentSubscriber(user));
}

[Fact]
public void SubscribeComment_Should_Increase_CommentSubscribers_Collection()
{
    var user = new User { Id = Guid.NewGuid() };

    var previousCount = _story.CommentSubscribers.Count;

    _story.SubscribeComment(user);

    Assert.True(_story.CommentSubscribers.Count > previousCount);
}

[Fact]
public void SubscribeComment_Should_Not_Increase_CommentSubscribers_Collection_When_User_Already_Exists()
{
    var user = new User { Id = Guid.NewGuid() };

    _story.SubscribeComment(user);

    var previousCount = _story.CommentSubscribers.Count;

    _story.SubscribeComment(user);

    Assert.Equal(_story.CommentSubscribers.Count, previousCount);
}

[Fact]
public void UnsubscribeComment_Should_Decrease_CommentSubscribers_Collection()
{
    var user = new User { Id = Guid.NewGuid() };
    _story.SubscribeComment(user);

    var previousCount = _story.CommentSubscribers.Count;

    _story.UnSubscribeComment(user);

    Assert.True(_story.CommentSubscribers.Count < previousCount);
}

And in Story:

private readonly List<User> _commentSubscribers = new List<User>();

public ICollection<User> CommentSubscribers
{
    get
    {
        return _commentSubscribers.AsReadOnly();
    }
}

public bool ContainsCommentSubscriber(User byUser)
{
    return _commentSubscribers.Any(cs => cs.Id == byUser.Id);
}

public void SubscribeComment(User byUser)
{
    if (!ContainsCommentSubscriber(byUser))
    {
        _commentSubscribers.Add(byUser);
    }
}

public void UnSubscribeComment(User byUser)
{
    if (ContainsCommentSubscriber(byUser))
    {
        var s = _commentSubscribers.Single(cs => cs.Id == byUser.Id);
        _commentSubscribers.Remove(s);
    }
}

Viewing Story

We need the track how many times a story has been viewed, so let us introduce another property ViewCount, Test:

[Fact]
public void View_Should_Increase_ViewCount()
{
    var previousCount = _story.ViewCount;

    _story.View();

    Assert.True(_story.ViewCount > previousCount);
}

And in Story:

public int ViewCount
{
    get;
    private set;
}

public void View()
{
    ViewCount += 1;
}

Increasing/Decreasing User Score

User score should be increased/decreased based upon the action like submitting/promoting/demoting etc. So first let us create an Enum which will hold some predefined User Actions:

public enum UserAction
{
    None = 0,
    AccountActivated = 1,
    StorySubmitted = 2,
    StoryViewed = 3,
    StoryPromoted = 4,
    StoryCommented = 5,
    StoryMarkedAsSpam = 6,
    SpamStorySubmitted = 7
}

With increasing/decreasing user score we also need to have the support to know the current score and query score for a given time period, so lets add a new class which holds the date, score and user action when increasing/decreasing score, tests:

[Fact]
public void CurrentScore_Should_Be_Zero_When_User_Is_Created()
{
    Assert.Equal(0, _user.CurrentScore);
}

[Fact]
public void IncreaseScoreBy_Should_Increase_CurrentScore()
{
    decimal previousScore = _user.CurrentScore;

    _user.IncreaseScoreBy(5, UserAction.StorySubmitted);

    Assert.Equal(previousScore + 5, _user.CurrentScore);
}

[Fact]
public void DecreaseScoreBy_Should_Decrease_CurrentScore()
{
    decimal previousScore = _user.CurrentScore;

    _user.DecreaseScoreBy(50, UserAction.SpamStorySubmitted);

    Assert.Equal(previousScore - 50, _user.CurrentScore);
}

And in User:

public DateTime CreatedAt
{
    get;
    set;
}

public decimal CurrentScore
{
    get
    {
        return GetScoreBetween(CreatedAt, DateTime.UtcNow);
    }
}

private decimal GetScoreBetween(DateTime from, DateTime to)
{
    return _userScores.Where(us => us.Timestamp >= from && us.Timestamp <= to).Sum(us => us.Score);
}

public void IncreaseScoreBy(decimal score, UserAction reason)
{
    AddScore(score, reason);
}

public void DecreaseScoreBy(decimal score, UserAction reason)
{
    AddScore(-score, reason);
}

private void AddScore(decimal score, UserAction reason)
{
    _userScores.Add(
                        new UserScore
                        {
                            OfUser = this,
                            Reason = reason,
                            Score = score,
                            Timestamp = DateTime.UtcNow
                        });
}

Tag Story

When submitting story, user should be able to specify tags for story and later on can view the stories with that specified tags, so we need to associate tag with both User and Story. Since it is a common behavior, we can create an interface which both Story and User has to implement:

public interface ITagContainer
{
    ICollection<Tag> Tags
    {
        get;
    }

    void AddTag(Tag tag);

    void RemoveTag(Tag tag);

    void RemoveAllTags();

    bool ContainsTag(Tag tag);
}

Though composition is better than inheritance, but for the time being lets keep it this way. Since both is the same I am only showing the Story, tests:

[Fact]
public void Tags_Should_Be_Empty_When_Story_Is_Created()
{
    Assert.Empty(_story.Tags);
}

[Fact]
public void Contains_Should_Return_True_When_Tag_Exists_In_Tags()
{
    var tag = new Tag
                  {
                      Id = Guid.NewGuid(),
                      Name = "Dummy Tag"
                  };

    _story.AddTag(tag);

    Assert.True(_story.ContainsTag(new Tag { Name = "Dummy Tag" }));
}

[Fact]
public void AddTag_Should_Increase_Tags_Collection()
{
    int previousCount = _story.Tags.Count;

    var tag = new Tag
                  {
                      Id = Guid.NewGuid(),
                      Name = "Dummy Tag"
                  };

    _story.AddTag(tag);

    Assert.True(_story.Tags.Count > previousCount);
}

[Fact]
public void AddTag_Should_Not_Increase_Tags_Collection_For_Duplicate_Tag()
{
    var tag1 = new Tag
                   {
                       Id = Guid.NewGuid(),
                       Name = "Dummy Tag"
                   };

    _story.AddTag(tag1);

    int previousCount = _story.Tags.Count;

    var tag2 = new Tag
                   {
                       Id = Guid.NewGuid(),
                       Name = "Dummy Tag"
                   };

    _story.AddTag(tag2);

    Assert.Equal(previousCount, _story.Tags.Count);
}

[Fact]
public void RemoveTag_Should_Decrease_Tags_Collection()
{
    var tag = new Tag
                  {
                      Id = Guid.NewGuid(),
                      Name = "Dummy Tag"
                  };

    _story.AddTag(tag);

    int previousCount = _story.Tags.Count;

    _story.RemoveTag(new Tag { Name = "Dummy Tag" });

    Assert.True(_story.Tags.Count < previousCount);
}

[Fact]
public void RemoveAllTags_Should_Make_Tags_Collection_Empty()
{
    _story.AddTag(new Tag { Id = Guid.NewGuid(), Name = "Dummy Tag1" });
    _story.AddTag(new Tag { Id = Guid.NewGuid(), Name = "Dummy Tag2" });

    _story.RemoveAllTags();

    Assert.Empty(_story.Tags);
}

And in story:

private readonly List<Tag> _tags = new List<Tag>();

public ICollection<Tag> Tags
{
    get
    {
        return _tags.AsReadOnly();
    }
}

public void AddTag(Tag tag)
{
    if (!ContainsTag(tag))
    {
        _tags.Add(tag);
    }
}

public void RemoveTag(Tag tag)
{
    Tag sameNameTag = _tags.SingleOrDefault(t => t.Name == tag.Name);

    if (sameNameTag != null)
    {
        _tags.Remove(sameNameTag);
    }
}

public void RemoveAllTags()
{
    _tags.Clear();
}

public bool ContainsTag(Tag tag)
{
    return _tags.Any(t => t.Name == tag.Name);
}

Skipping few functionalities

We will skip story submit, edit, delete, confirm as spam, view story list for future post.

Changing Role of User

Admin should be able to change role of User. So we need to introduce another property in User. We will have some predefined role and the functionalities for each role should be static. First, let create an Enum

public enum Roles
{
    User = 0,
    Bot = 1,
    Moderator = 2,
    Administrator = 4
}

Next, the user will have a property Role and a method to change the role, we will skip the checking whether the caller is an admin for future when changing the role, test:

[Fact]
public void ChangeRole_Should_Update_Role()
{
    _user.ChangeRole(Roles.Administrator);

    Assert.Equal(Roles.Administrator, _user.Role);
}

and in User:

public Roles Role
{
    get;
    private set;
}

public void ChangeRole(Roles role)
{
    Role = role;
}

Lock/Unlock User

Admin should be able to lock/unlock user. It should be same as Role, we will again skip the admin calling checking for future, tests:

[Fact]
public void Lock_Should_Update_IsLocked()
{
    _user.Lock();

    Assert.True(_user.IsLocked);
}

[Fact]
public void Unlock_Should_Update_IsLocked()
{
    _user.Unlock();

    Assert.False(_user.IsLocked);
}

And in User:

public bool IsLocked
{
    get;
    private set;
}

public void Lock()
{
    IsLocked = true;
}

public void Unlock()
{
    IsLocked = false;
}

Approving Story

User can Mark story as spam if they think the story is not relevant, also our spam checkers can block a story from appearing if they detect it as spam. But the Moderator should be the final judge for confirming a story as spam, if the Moderator finds a story is not spam, s/he will approve the story which makes sure the story appearance. For marking the Story as approved we will introduce a new Property ApprovedAt, same as Story published, tests:

[Fact]
public void Approve_Should_Update_ApprovedAt()
{
    var now = DateTime.UtcNow;

    _story.Approve(now);

    Assert.Equal(now, _story.ApprovedAt);
}

And in Story:

public DateTime? ApprovedAt
{
    get;
    private set;
}

public void Approve(DateTime at)
{
    ApprovedAt = at;
}

Note that we are again skipping the checking if the caller is Moderator in Approve method for future.

Publishing Story

Story publish is a process where popular stories appears in the front page, certainly there should be different strategies for calculating the popularity of story, which we will again it skip for future post, for the time being we will only focus once a story is qualified to publish how do we mark it. As mentioned in the Marking as Spam section that once a Story is published we will update its PublishedAt property, but updating only the PublishedAt does not serves our purpose as we also have to know the Rank to order it in the list. Tests:

[Fact]
public void Publish_Should_Update_PublishedAt()
{
    var now = DateTime.UtcNow;

    _story.Publish(now, 1);

    Assert.Equal(now, _story.PublishedAt);
}

[Fact]
public void Publish_Should_Update_Rank()
{
    _story.Publish(DateTime.UtcNow, 1);

    Assert.Equal(1, _story.Rank);
}

And in story:

public DateTime? PublishedAt
{
    get;
    private set;
}

public int? Rank
{
    get;
    private set;
}

public void Publish(DateTime at, int rank)
{
    PublishedAt = at;
    Rank = rank;
}

The following is final object model of this part that we have done so far:

You can also download the complete code from the bottom of this post.

There are few points in the above which I like to highlight

Note that in above we are only focusing on the Domain Logic, we did not mentioned anything about database, UI or any other infrastructural stuffs.
Almost all of the code blocks are 3/4 lines long which is easy to understand and unit test.
There are certain functionalities in the above can be also achieved by using only properties instead of using method, for example in the User we can have IsLocked property with both getter and setter but instead we have created Lock, Unlock method and readonly property IsLocked which I think makes it more explicit and also expressive.

In the next post, we will check how to map this domain model into the database and create repository with LinqToSql with 100% code coverage.

Stay tuned!!!

Download: Source Code

Introducing DotNetShoutout.com

kazimanzurrashid — Tue, 20 Jan 2009 07:15:00 GMT

DotNetShoutout is a Web 2.0 style social news site for .NET developers running on our open source project KiGG.

Background

KiGG was started as a fun project to get familiar with the new ASP.NET MVC framework and with no exception I started to hear terms like DDD, BDD, SOLID, DRY, Law of Demeter, Testability etc etc which brings me a new world of learning. I found, following alt.net community is the best way to lean these stuffs, I followed them (and still doing) ruthlessly over the blogs, twitter, podcast, discussion group etc. The latest release of KiGG is the outcome whatever I have learned from them in these days.

Goal

My goal was to implement a very loosely coupled application with MS supported technologies following the Domain Driven Design. It is developed with:

ASP.NET MVC Beta
Linq To SQL
MS Patterns & Practices – Enterprise Library (Logging & Caching)
MS Patterns & Practices – Unity
jQuery

Unit Testing:

Moq
xUnit.net

Other Open Source Projects:

DotNetOpenId
HtmlAgilityPack
jQuery UI
MarkItUp Editor

What’s new in v2.0

OpenID integration.
Web page thumbnail.
RSS/Atom.
Captcha.
Rich Story/Comment editor via Markdown.
Both internal and external spam protection (Akismet, TypePad and Defensio) .
Url shrinking.
Sitemap including standard, mobile (Google only), news (Google only).
Open Search.
Mircroformats hAtom, hReview, hVote, xFolk etc.
Karma point system for Users.
Easy sharing with MSDN social, delicious, facebook and twitter.
Vote Counter with customization (Check the bottom of this post).
Live Writer Plug-in.
BlogEngine.NET Extension.
Both Community Server ICS Module and Graffiti Chalk.

Why DotNetShoutout.com

DotNetShoutout is like eating one’s own dog food. Since, it has all these nice features and the controversies that are around with our primary source of .NET story, we decided why not run a site for our own community that solves these issues and keep you informed with the latest happening of .NET world. So dear reader, I am inviting you in the public beta release of DotNetShoutout.com. Please, tell us what you like, what you do not like, what you think can be improved or added. We are still working on some of the cool features which will be available in 1/2 weeks.

And I will be also blogging about the technical side of this project in coming days.

To end this post, I just to share with you that I have been again awarded as MVP for year 2009.

Long Live .NET!!!