Blog

Orchard Steering Committee elections announced

Sat, 27 Aug 2011 19:35:37 GMT

Bertrand Le Roy, PM at Microsoft and leader of the Orchard project, has announced today the creation of Orchard Steering Committee, a board responsible for future key (including design) decisions about the project, working closely with the core team at Microsoft. Members of the board will be chosen among the most enthusiastic and active community members in incoming elections.

Hi all,
I've alluded to it before, and now is the time to get this started. We are ready to take the next step in making Orchard a community-based project and incorporating more community participation. We want key decisions (including design) to be handled going forward by a small group of enthusiastic community members in addition to input by the core team at Microsoft. We think about that in the following way:

We'll make a call for candidacy for each of the five seats on the committee. Actually, this post is it.
Seats will be for a year (with an option to leave early if necessary), and will be renewable.
Candidates must commit to spending a portion of their time (personal or professional with their employer's permission) every week. Count on one 1-hour Lync meeting a week usually, plus involvement in feature teams if you so desire. A candidate can be anyone who is active in the community and who is using Orchard. It is not required that you are a ninja coder (although we love ninjas), only that you are passionate and active.
The first elected committee will determine the rules of the game going forward, including the voting process, triage, commit rights, etc.
One of the seats will be for the job of Benevolent Dictator, whose powers are to be determined. Maybe veto or unblocking stalemates.
If we have more candidates than seats, we'll set-up a vote (will be able to vote people who have CodePlex accounts and who have posted at least once on the Orchard discussions).
We’ll create a new mailing-list for the committee, that will be public and archived.
For each development sprint, the committee will spin up feature teams and make calls for participation. Details on this will follow.
We will also need an additional person taking the role of Patch Master (more on this later). This role can be cumulated with a steering committee seat.

All comments on this are of course welcome.
So there it is. Please make your candidacy known to the world by answering this post. Myself (Bertrand Le Roy) and Sébastien Ros are candidates. I will also be a candidate to the role of Benevolent Dictator.
We will leave the thread open for candidacies until 11:59:59PM PST on September 9th, at which point we’ll start the voting process. You will have a week to vote (until 11:59:59PM PST on September 16th), and we’ll announce results on September 19th.
Cheers,
Bertrand

That being said, I’ve obviously thrown myself into the hat for candidacy! I’d be more than happy for your support for my candidacy in the incoming elections.

It would be so nice to be in the center of the project, which you’ve spent endless hours working with, extending and watching it grow from it’s early days. But first and foremost - nothing could happen without the awesome, growing community gathered around the project, helping which I really enjoy! Being a part of the Orchard Steering Committee could help spreading a word about Orchard to a much broader audience, which is what I’ve always been trying to do

Cheers!

DI property injection in Orchard

Thu, 25 Aug 2011 00:09:33 GMT

As everyone developing apps using Orchard surely know, constructor injection in Orchard is a built-in feature. It’s used extensively throughout the whole framework and makes the developer’s life way much easier But there are scenarios where it’s not enough and one may want to do property injection instead. The most common reason is a danger of having circular dependencies, nasty thing hard to trace and sometimes very hard to fix…

Property injection comes to the rescue, but it’s not a thing that comes out-of-the-box in Orchard. It’s ok that the framework doesn’t try to forcibly fill my object properties – property injection should be used only as an alternative to ctor injection and only in certain scenarios.

There are two ways to fill object properties with instances from the container in Orchard, which I found the most useful:

On the object’s level (the one that has properties you need to fill) – using Autofac’s IComponentContext.InjectUnsetProperties(object) method.
On the global level – via Autofac.Module implementation, utilizing the former

Object-level property initialization

It’s a good way to go if you want to inject properties of a specific object only.

This approach requires you to have IWorkContextAccessor object injected into the constructor first. Let’s call this object ‘context’. Filling the object is as easy as calling context.Resolve<IComponentContext>().InjectUnsetProperties(this). You may do that wherever you want to, eg. in a place where your object initialization happens. Of course look out with calling that in a constructor – you may easily run into a circular dependency problem. It’s meant to be called after the object has been constructed.

Of course you may pass any object to InjectUnsetProperties method and have it’s properties filled.

Global-level property injection

Use this approach if you want to do property injection on all objects registered in the container.

It is a more complex solution as it requires you to create an implementation of Autofac.Module class and plug into the container-building processes. Nothing to fear, though

First of all we need to create and implementation of Autofac.Module class and override method AttachToComponentRegistration(IComponentRegistry componentRegistry, IComponentRegistration registration).

Next step is to hook up the Activated event of a given IComponentRegistration and pass an event handler to it that would inject all unset properties of a processed object. Here is the code:

public class MyModule : Module {
    protected override void AttachToComponentRegistration(
        IComponentRegistry componentRegistry, 
        IComponentRegistration registration)
    {
        registration.Activated += (s, e) 
            => e.Context.InjectUnsetProperties(e);
    }
}

Nothing more, nothing less – very simple stuff, I told you This is only a simple example, of course - you can put more fancy logic inside if you need to (e.g.. act only on specific objects and such).

I’ve recently posted an answer on SO to question about achieving property injection in Orchard. It was about filling properties of a specific type only, leaving other properties untouched – a bit more sophisticated stuff. If that’s your case – take a look. The solution I provided was based on the Orchard.Logging.LoggingModule, which injects ILogger implementations.

Moving to Orchard 1.2 - Impressions

Tue, 14 Jun 2011 15:51:27 GMT

After a short struggling I managed to successfully move my site to Orchard 1.2. Official release is just around the corner, but couldn’t help myself and built my own from the latest source:)

Until yesterday my site was running on Orchard 1.0. It’s been a while since then and much has changed. That made the transition process a bit more complicated than I previously thought, although was clearly worth it.

First impression

The most stunning impression is performance. The performance gain is tremendous comparing to previous versions, which can be clearly seen at first sight (or better – first page load). The Orchard Team has done a really great job!

From the UI point of view changes (comparing to 1.1) are barely noticeable, but my opinion is surely biased. I’ve been working with recent source code base all the time and just got used to it:) The official release notes (coming soon) would surely be much better source of information about all changes from the latest release.

v1.0 to v1.2 transition process

Orchard docs describe the process very well – I did everything exactly as they say which made the transition pretty easy. I ran into some problems at the modules’ upgrade step, though. Those apply to 1.0 – 1.1 transition too.

Some older, enabled features will break when the core code gets upgraded. This issue is related to modules dependent on code touched by breaking changes (e.g. v1.1 replaced string with LocalizedString in MenuItem class which causes the first version of Advanced Menu, targeted to Orchard 1.0, to bomb the 1.2 instance). The solution is to disable such features prior to upgrading Orchard. If you forgot to do that and run into YSOD, you can use the “feature disable” command from Orchard command-line.
Some features, previously available as separate modules, has been pushed to the core. If you have the old ones installed you can run into YSOD because of ambiguous class references. I stumbled upon this problem with Iroo.PackageManager, which since v1.1 is available in core Orchard.Packaging module. In this case, just uninstall the old module. Uninstallation has to be done by hand, as described in this thread.

Besides that, everything went perfectly fine and now I’m a happy user of the newest Orchard Team’s creation!

UPDATE (2011/06/15): Orchard 1.2 has just been released!

Orchard Advanced Menu 1.3 released!

Sun, 12 Jun 2011 00:16:55 GMT

New release is finally out! I managed to fix all reported bugs, add some new goodies, do a lot of refactoring and boost performance a little bit. Hope it’ll serve you well.

What’s new?

MenuRelationPart. The part that allows attaching an item to one or more different menus directly from that item’s creation/edit screen. It behaves similar to the default menu part (that added “Show on main menu” checkbox) and replaces it. It’s attached to Page, Blog and BlogPost content types by default, but you can attach it to any custom content type you need, in order to allow adding menu links to it.
Menu widget creation from command-line. You can now create menu widgets directly from Orchard command-line or from your custom recipes. Simply use the command “menuwidget create” Great thanks to Raymond de Jong for contributing this piece of code!
New menu widget display mode – SiblingsExpanded. In this mode the menu is displayed in full, but children are rendered only for the items on selection path. Basically, the menu in this mode looks like a tree-view with single path fully-rendered and others collapsed to the topmost node.

What’s changed?

These are some of the most important changes:

Counters and Breadcrumbs has been moved to separate features. They are disabled by default. You can enable them, if you wish, from the Modules admin pane.
Marking selected/current menu items.
- “Current” CSS class is used to mark the selected menu item, corresponding to currently viewed page. If you have more than one item with the same URL in a single menu – all of them will be marked as “current”
- “Selected” CSS class is used to mark all parent items (path), starting from the one that is actually being viewed. If you have more than one item with the same URL in a single menu – only the first one will have the path marked. The same applies to breadcrumbs – the first valid path found from the current item to the top will be used.
Menu items list in admin view has been filled with additional data (URL, direct links to corresponding content items and the item type)
Changed the name of “templated menu item” to “menu item /w custom Html” in admin UI. There were some misunderstandings about what is it for and I guess putting a more descriptive name is a good idea.
Dropdowns instead of textboxes for choosing a menu in menu/breadcrumbs widgets.
Renamed menu widget display modes to be more descriptive. It’s a topic for the next post.
Lots of other minor things

What’s been fixed?

Issue with deleting menus which rendered menus non-removable.
Menu and breadcrumbs rendering issues. In some cases the module rendered empty, additional <li> tags between parent and child menu items.
After enabling shape tracing, menu items text got overwritten by shape Url (shape tracing has been overwriting an existing property on menu item shape)
In some cases, selected menu items hasn’t been correctly marked with appropriate CSS classes.
Serialization issues with counters when using SQL Server session store.
Incorrect menu level cutting when using “Limit levels” feature
Link to ‘main’ menu appearing even after ‘main’ menu deletion.
Error when trying to recreate menu with the same name as previously deleted menu. It’s an issue with Orchard – by default menu items are not removed from database (just hidden from UI), so unique constraint on menu names throw errors with subsequent inserts.
Menu display mode dropdown doesn't keep selected value when you come to edit it again
Menu widget display modes doesn’t work as expected.
Filling menu with existing items creates duplicates.
“Cut lower levels” option in menu widget works exactly the opposite way.

Many thanks for the giant load of feedback some of you provided since last release. It really helped me a lot when it came to bugfixing and thinking about new features for this release. My special thanks go to Raymond de Jong and Richard Garside for code contributions and great amount of feedback!

Btw - I’m going to write some more detailed tutorial on module usage soon, so stay tuned.

Cheers!

Removing items in Orchard

Fri, 27 May 2011 20:47:48 GMT

Some of you reported an issue with deleting menus in Advanced Menu module. It was widely discussed in initial post comments and on StackOverflow. I’ve investigated that issue and was pretty surprised with findings. It looks like it was related to how Orchard handles content item removal, what is a pretty interesting thing because it works differently as one may think.

Content items never get completely deleted.

Remember that when designing your content parts. They have only certain flags removed which makes them invisible to further queries. It’s a desirable behavior in many cases, as it allows items to be undeleted, browse history etc. But it raises a couple of issues though, e.g.. with unique columns on content part records – you cannot recreate the removed item with the same value, as it’s there all the time.

If you want to completely erase an item – you can do that via IRepository<ContentItem> when needed (e.g.. in ContentHandler’s OnRemoved event). Related content part records will be automatically deleted. I hope that future Orchard releases will have the feature to delete content items via ContentManager built-in.

Thanks to Louis De Jardin, who described it in details here.

Cheers!

New code generation features for Orchard

Tue, 26 Apr 2011 23:36:49 GMT

Back on track after a short break! I’ve just uploaded to the Orchard Gallery a much updated version of Code Generation Extensions module.

Some of you asked for features such as settings codegen and assigning the generated part to specific feature. Here they are! I described the basic commands and usage of those in my previous article. Now, I’d like to describe the new goodies, starting from…

Introducing ‘codegen typesettings’

This is a new Orchard CLI command that generates all files necessary for adding type-specific settings to any existing part. Such settings are commonly used for holding some default values for content parts. You can read more about those here and here (which is the same post, just copied to the official docs).

Like the ‘codegen part’ command, ‘codegen typesettings’ also has a /Properties: switch (optional parameter), with exactly the same syntax. It allows you to easily provide necessary properties via command-line. If you do so, the form fields necessary for editing those properties will be automatically created in an appropriate .cshtml file (which can save you some keystrokes ).

New parameters in ‘codegen part’

/ForFeature:<feature-name> – this switch lets you specify which feature (existing in your module, of course) the generated part has to be specifically bound to. The existence of a feature you specify isn’t being verified (yet), so look out for typing errors. For those of you who would like to get into greater detail – it adds an appropriate [OrchardFeature(…)] attribute to generated classes.
/AttachTo:<type-name> – allows you to specify the content type this part should be automatically attached to. As you may or may not know, attaching parts to content types in Orchard can be done twofold – by describing the structure in data migrations class (which can be further modified via admin UI) or by hardcoding the relation in content handler using ActivationFilter (like e.g.. site settings do). This command uses the second approach.
This switch makes creation of site settings as easy as specifying /AttachTo:Site. Site is a content type in Orchard, so you can attach to it virtually any part you want!
/ShapeFile:<name> – if you want to provide your own name for generated shape files instead of part name – this is the right place. Do not specify the file extension (.cshtml) here – it will be added automatically. This parameter allows you to keep your file-naming scheme intact (e.g.. Funny.MyPart.cshtml instead of MyFunnyPart.cshtml, where MyFunnyPart is the name of your part).

I’d like to thank Brad Millington very much for mentioning this module during speech on MIX11!

That is all for now. I’ll probably make some more additions soon so stay tuned!

Cheers!

Generating Orchard content parts via command-line

Thu, 07 Apr 2011 00:52:37 GMT

Creating a content part in Orchard, even the most trivial one, involves creating many small objects – handler, driver, model (main part object), record, display and editor shapes to name a few. As I was tired of hand-creating/copy-pasting all those every time I needed a content part I wrote a simple Orchard module that automates the process (being a dev is about making life easier, right?) I called that module Code Generation Extensions, as it generally extends the default codegen features.

Module adds an Orchard command-line command “codegen part”. It’s syntax is as follows:

codegen part <module_name> <part_name> [/Properties:<comma-delimited list of name:type pairs>]

For example:

codegen part Modules.Shop ProductPart /Properties: Name:string, Price:int

Properties is an optional parameter, so if you’d like to create an empty part you can just write

codegen part Modules.Shop ProductPart

The command creates a handler, driver, model, record, display and editor shapes and updates the Placement.info file with default Content:before placement for your part shape. If you provide /Properties parameter, the model, record and editor shapes will be filled with appropriate code accordingly.

You can download the module from the Orchard Gallery. Feel free to play with it and I hope you find it useful!

Cheers!

Featuring Orchard Advanced Menu

Sun, 03 Apr 2011 20:05:02 GMT

New Hierarchical Menu module release is finally here. As you probably noticed, the module name has changed to Advanced Menu, as I guess it’s more appropriate now. Why? This is basically what I’m about to write about, as there’s been a lot of changes since the last release.

First and foremost – the module is prepared to work with the upcoming Orchard 1.1 release! The bad news about it is that it probably won’t work with the Orchard 1.0, because the new release introduces some breaking changes (e.g. different LocalizationString handling). Would there be a demand for backward compatibility, I’ll do my best to try adding that (I have to make some research if it’s possible at all first).

As the module takes part in the Orchard Module Challenge, I created a simple demo site, which shows it’s most powerful features Check it out!

New features

Version 1.2 introduces many features not available in previous versions (in addition to changes to existing ones, which are described later in this article):

Custom menus– ability to create your own menus.
- Easily create different menus for different purposes, e.g. separate the menus used for display and breadcrumb rendering
- You can auto-fill the created menu with existing content items (Pages, Blogs, Lists etc.) with just a click of a button. There is also an option to include contained items (e.g. Blog posts, List items and such)
Styled menu widget – styled and scripted with Superfish jQuery library menu widget with color customization options. Works with all major browsers and degrades gracefully when JS is disabled
Templated menu items – you can put your own Html markup inside menu items
Visit counters – attach a visit counter to any displayable content type (attached to Page type by default)
- Scoped – you can choose from three predefined counter scopes: PerSite, PerUser and PerSession
- This is the flag use of the counting framework I created while rewriting the included RecentlySeenWidget (which now utilizes this). There’s way more than this, but this is clearly a topic for a different article.

When the Advanced Menu module is enabled, the default menu gets automatically replaced with StyledMenuWidget. So you don't have to create the first widget by hand, as it's already there! You can change it or replace from the Dashboard if you need to.

Changes

More menu and menu item rendering options
- Optional wrapping of sub-items in additional <div> tags
- Add optional subtitle to menu items
- Hide/show menu item’s text
- Render menu item as link (default) or just as a plain text
- Limit the number of menu levels displayed with an option to cut or flatten to a single list the items below threshold
- Specify which menu item children to use as a top level of a displayed menu. By default none, which means that the whole menu is rendered
Tweaks for easy styling/scripting
- Unique Id attribute for each menu widget – each menu widget has a unique menu-<item_id> HTML Id attribute to allow targeting specific menu with jQuery/CSS selectors. The item_id is menu widget’s content item Id.
- Unique Id attribute for each counter – counter-<item_id>, analogous to the former
- Additional CSS classes for counters – counter-<counter_scope>, where counter_scope is the scope used (“PerSite”, “PerUser” or “PerSession”).
Additional shape alternates for customization
- Menu__[item_id], where item_id stands for MenuWidget/StyledMenuWidget content item Id. Example: Menu-33.cshtml
- Breadcrumbs__[item_id] – where item_id is BreadcrumbsWidget content item Id. Example: Breadcrumbs-22.cshtml
- Breadcrumbs__[menu_name] – where menu_name is the name of menu used to render BreadcrumbsWidget. Example: Breadcrumbs-main.cshtml
- Counter__[counter_scope] – where counter_scope is counter scope used (“PerSite”, “PerUser” or “PerSession”). Example: Counter-PerSite.cshtml
- Counter__[item_type] – where item_type is the name of content type the counter is attached to. Example: Counter-BlogPost.cshtml
- Counter__[item_id] – where item_id stands for the Id of an item the counter is attached to. Example: Counter-11.cshtml
Lot of code refactoring

Plans for the next release (around mid/end-April 2011)

Editing content item menu associations on item edit/creation screen
Multi-column sub-items layout – dividing children into multiple lists
Menu item position auto-creation based on existing items
Menu item listing UI improvement and tweaks
Performance improvements by utilizing caching engine where possible
More styling options for StyledMenuWidget – borders, padding, margins, custom CSS, top menu level alignment (left/right/center)
Refactoring – group and divide the features into separate features - I just didn't have time to do this, as OMC deadline was nearby (and being left with the totally broken build few hours before wasn't the thing I dreamt of)

I hope you’ll find it useful in your Orchard projects! I’m going to update my blog to Orchard 1.1 as soon as it arrives to utilize this nice new feature. I’d be very glad for any feedback so I could make this module better and better

Cheers!

SQL Server 2008: Reverting accidental delete/update without recent backup

Mon, 28 Mar 2011 14:35:27 GMT

Recently I ran into a problem after accidentally clearing an important column in one of my DB tables. Ooops… I was in a real hurry and haven’t thought about making a backup first Just a simple query, but also with simple, nasty error within... First thought – I’m doomed! I’m pretty sure many of you had the same situation once

I had only a week old backup – much has changed since, so it’s not an option to revert the whole week. So I started digging for a solution… And found one! My DB is running in Full Recovery mode, so maybe there’s a chance (your DB has to run in this mode too for this solution to work):

Create a Transaction Log-only backup now (after the accident)
Restore the old backup (week old in my situation) using RESTORE WITH NORECOVERY option. This option can be selected in Restore Wizard –> Options screen (or specified in restoration script). This ensures that DB will be restored from backup and won’t allow outside connections until we’re finished the whole restoration process.
Restore the Transaction Log backup (created in 1.) to a point in time before the accidental update/delete happened. You can choose the desired point in time in Restore Wizard, or (if you prefer the scripted way of doing things) use the WITH STOPAT <date> option. This time, choose RESTORE WITH RECOVERY option, to make DB fully operational after restoration process.

You may also need to check WITH REPLACE option in 2. and 3. if your DB shouts with errors.

And everything returns back to normal, phew… HTH!

Cheers

Incoming Warm-up module helps running Orchard on shared hosting

Thu, 24 Mar 2011 11:10:19 GMT

Most of us doesn’t have the possibility to run Orchard on his own server machine. Using the shared hosting account is the cheapest and most common way to have your site up and running, but it has lots of drawbacks, especially in terms of performance and first-load (cold-start) response times.

A while ago I wrote an article on how to boost your Orchard instance cold-start times. Most of the solutions to this issue unfortunately require you to have access to IIS Management Console, which isn’t always possible.

Here comes the Orchard.Warmup module, which will arrive with the incoming Orchard release. As application response times are crucial in terms of UX, this module will allow your site to be responsive even when your AppPool gets recycled! You’d be able to quickly serve your visitors the cached versions of pages you want, until your application loads fully in the background. When that happens, everything returns to normal

Check out this thread, where Renaud Paquay from The Orchard Team describes the idea in greater detail.

Cheers!

The whole truth about CS studies

Wed, 23 Mar 2011 16:52:44 GMT

It’s so true, that I couldn’t help myself posting this

What do you think about that?

Is it university CS programmes that lag behind the real-world needs or new wave of students who believe CS courses to be a longer version of a (Java/.NET/PHP/whatever) programming tutorial and don’t care about the principles?

Cheers!

Customizing Orchard shapes

Wed, 23 Mar 2011 16:03:17 GMT

Shapes are the basic building blocks of Orchard UI. They can be easily created and further reused by just putting an appropriate .cshtml file in your module /Views folder. This is nicely described here and here. But what if you’d want to arm your shape with some more fancy logic (eg. let them contain other shapes/objects, make them auto-wrapped with some Html tags, allow fine-grained overriding and such)? I’ll try to show you how to get the most from your Orchard shapes.

Creating a custom IShapeTableProvider

This is the main extension points for adding some custom logic to shapes. What’s the most important thing – not only your shapes! You can also alter the behavior of existing ones – cool! Basically, you are able to eg. add custom wrappers, class names, attributes, fire some custom logic on shape lifetime events and so on.

The place everything happens in is the Discover(ShapeTableBuilder builder) method. You operate on the provided builder object to create all shapes’ customizations. The basic structure looks like this:

public class MyShapes : IShapeTableProvider {
    public void Discover(ShapeTableBuilder builder)
    {
        builder.Describe("MyShape")
	    .Configure(descriptor => { })
            .OnCreated(context => { })
            .OnCreating(context => { })
            .OnDisplayed(context => { })
            .OnDisplaying(context => { });
    }
}

As you can see the builder adds a nice, fluent interface for specifying the necessary stuff. First, you have to tell the builder which shape you’d like to alter by using a Describe() method. “MyShape” name I provided corresponds to /Views/MyShape.cshtml shape file. The way shape names are constructed from the corresponding .cshtml file names is described in detail here (section “From template file name to shape name”).

Next, you are free to add your own logic inside one or more of the five provided methods. For each of those methods you can specify a delegate (or lambda/anonymous method as shown above) which will get called at an appropriate moment:

Configure – used to add some config options to your shape. Mostly used to define wrappers (other shapes that wrap your shape) via descriptor.Wrappers collection.
OnCreating – called when your shape is about to be created. This event is mostly used for providing some custom shape construction info, like context.ShapeType (the type of object you want to be the base type of this shape – nice if you’d like to add some custom properties to the shape) or context.Behaviors (collection of IClayBehavior implementations for defining behavior when accessing shape members - pretty low-level stuff).
OnCreated – called when your shape is fully created, but not pushed to display yet. Generally, all display structure is defined here (eg. shape zones, startup items, child items placement and such)
OnDisplaying – called when your shape is about to be displayed. Mainly used for adding custom CSS classes (via context.Shape.Classes) or defining shape alternates to allow fine-grained overriding by your module users. What are shape alternates is described here.
OnDisplayed – called when your shape Html just got rendered.

Next, you can operate on the provided context object to add necessary customizations. That’s it!

The most important thing - you can access the corresponding dynamic Shape object by context.Shape. The Shape property is not available in OnCreating event though (for obvious reasons).

There are more methods, of course, but these are the most useful ones. In most cases you won’t ever need to use the others.

As an example I’d advise you to take a look at CoreShapes.cs, located in Orchard.Core/Shapes. It contains the definitions for the most common shapes and nice examples of how you can customize your own shapes!

Cheers!

WDI2011 conference site runs on Orchard

Sat, 19 Mar 2011 06:02:57 GMT

Had a hard work for a last few days rewriting the whole existing WDI2011 conference site to Orchard. Works like a charm so I think it was worth that

As I had to assign some time to that (and, unfortunately, this resource is highly limited) - the planned releases (refreshed Hierarchical Menu and the new one - Frooth – dynamic layout platform) will be delayed to Tuesday/Wednesday next week. I apologize for that… But I can also promise you won’t be disappointed with the incoming bits!

An I’d be happy to invite those of you visiting Warsaw at the end of March (30-31) to come and join us at the annual WDI 2011 conference. WDI is the biggest student-oriented (but not only) IT conference in Poland. This year the conference is being held at the Warsaw University of Technology.

Cheers

New Hierarchical Menu coming soon - features

Sun, 06 Mar 2011 15:58:45 GMT

I’m working hard to deliver the next release of Hierarchical Menu, which will arrive soon (as the deadline for OMC is nearby). I’d like to list some new features most of which many of you asked for:

Custom menus – the ability to create your own menus from Dashboard, in addition to existing, hardcoded ones - “main” and “admin”
Pre-filling the menu with existing items – it will allow you to pre-fill the custom menu with existing routable items in one click (and save time). You could further customize the menu (delete, modify items) as you wish
New, styled and scripted menu widget – in addition to the current plain one. Many of you had problems with proper styling the hierarchy, so I added the pre-configured widget with some GUI-based display customization properties. It’s intended for those of you who don’t want to deal with styling and scripting.
Main menu as a widget – the new release will replace the hardcoded main menu with a widget, so you’d be able to customize/remove/replace it from Dashboard.
Flexible menu localization – you’d be able to specify the menu item names for different cultures.
Menu item visibility – allowing you to state whether the item should be visible/invisible when displaying in menus. This is mainly for breadcrumbs widget purpose so you’d be able to hide item in the menu (to keep menu concise), but make it show in the breadcrumbs path. I’m thinking about this feature right now whether to add it or not. Why? There are some issues:
- What to do with child items?
- Would it bring the unnecessary complexity and further problems? This can be achievable by just having two defined menus – one for display (shorter) and one for breadcrumbs (full). I guess this is much cleaner though.
Tweaked “Recently seen” widget
- Restricting the number of items displayed
- Option to display the number of views
- Scoping the view counter used – you’d be able to choose one of the following: per-session, per-user and per-site view counters
Tweaked “Menu” widget
- Restricting levels displayed per-widget – as opposed to per-menu atm,
- Choosing the root node for menu display – you’d be able to select one of the existing items as the display root to restrict the displayed menu to only the subset of the whole (the selected item’s children).

I’d like to thank all of you for a lot of feedback on using the Hierarchical Menu module! It made the feature selection for the upcoming release much easier

My special thanks go to: Olin, Skywalker, tobias and John Tarbox for the very elaborate feedback on the subject.

Cheers!

Orchard cool new feature - Recipes

Wed, 02 Mar 2011 15:32:06 GMT

I’ve just came across a new feature which, I suppose, will be ready for the upcoming Orchard 1.1 release – the Recipes.

It allows you to describe the startup configuration of Orchard and brew your own environment just by defining the necessary setup steps in simple XML. Cool!

Apart from the manifest part (the <Recipe> section) containing info about recipe you can define everything you need for your Orchard application to successfully set up:

Modules needed (the <Module> section). The coolest thing about this section is that you can define even the modules not existing in the installation package and those will be automatically downloaded and installed from Orchard Gallery (or other repositories of your own you may optionally specify)
Features enabled/disabled by default (the <Feature> section)
Themes available (the <Theme> section)
Content types and parts (<Metadata> section with <Types> and <Parts> subsections)
Default site settings (<Settings> section)
Migrations to run (<Migration> section). You can specify for which features the migrations should be run (* by default, which means all)
Commands to invoke (<Command> section).

As an example of such recipe take a look at the one used for setting up a default environment.

I guess this gives a huge boost for everyone building highly customized applications on Orchard, as the whole setup phase can be clearly defined. So you can simply say “goodbye” to hours spent on setting up your Orchard box for the n-th time!

Cheers!

Running Orchard on shared hosting

Tue, 01 Mar 2011 17:04:31 GMT

Trying to run Orchard on shared hosting can run you into many problems. There’s already been a long discussion about that on Orchard discussion board. The main issue noticed is a long Orchard loading time, especially when accessing the site for the first time.

Orchard is a very complex application which needs a lot of preparation stuff at startup. Unfortunately shared hosting providers care the most about site density on their servers and do frequent AppPool restarts so to allow other sites to reuse the server resources. Every AppPool restart forces Orchard to load itself from scratch and do the so-called “cold-start”. Also, on less frequently visited sites the AppPool will be additionally recycled because of long idle times.

There are two approaches to lessen the impact of those on your visitors’ experience (of course if AppPool recycling is the case):

Use ping service to shorten the application idle time. It will ensure that your site is constantly running by pinging the specified URL in specified time periods and will automatically force cold-starts. Some of such services were mentioned in this thread.
Use Application Warm-Up IIS plugin. This is the much better way as long as you have access to your site via IIS Management Console. In my opinion this is a must-have plugin! It ensures the application gets a hot-start even when AppPool gets recycled. Basically it makes your application start before the first request arrives.

Hope you find it helpful

Cheers!

Referencing custom assemblies in Orchard module

Tue, 01 Mar 2011 16:07:39 GMT

This is one of the common problems you can run into at module development time.

In the most usual (and preferred) dev setup you work in VS 2010 on a single Orchard.sln solution containing full Orchard source and add your custom modules as an additional projects. This setup works perfectly fine unless you try to use additional assemblies not listed in /lib folder (under the full Orchard source code root, as downloaded from Codeplex).

If you try to add a custom assembly reference to your module project it’s inevitable that sooner or later you’ll run into:

"The type or namespace name 'yyy' does not exist in the namespace 'xxx' (are you missing an assembly reference?)"

exception when debugging from Visual Studio. The reason is fairly simple. As Orchard is a sophisticated platform, it’s still an ASP.NET MVC application though and needs all of the assemblies used placed in the Orchard.Web /bin folder (apart from those coming from GAC)! [EDIT] Orchard has also a second directory for holding custom assemblies - /AppData/Dependencies - and this is the place where all of non-core dlls land. Renaud Paquay from the Orchard Team wrote about the reasons behind that below.

When you install a module from NuGet package, the necessary assemblies contained in this package get copied to the Orchard.Web application’s /AppData/Dependencies folder and everything is fine. But when you debug the whole app from VS, the modules are already there and no installation (and file copying) happens…

The workaround to this problem is to add all assemblies referenced by your module(s) to the Orchard.Web project too.

[EDIT] There is also a different workaround. You can store all your necessary assemblies in a single folder, and point Orchard to look into that folder at runtime (when the dynamic compilation happens). To achieve that just add the path to that folder to Web.config file in Orchard.Web project. The path should be placed in /runtime/assemblyBinding/probing privatePath property, separated with semi-colon from others.

As I stated above, this is only necessary at development time. When you deploy your module as NuGet package (via package create command) and install it – everything is perfectly fine. Your custom assemblies get packaged together with the module source and Orchard copies them to the appropriate locations.

And btw, I’d like to give you a tip at the end of this article

When using custom assemblies in your modules, check if they exist in /lib folder under the Orchard listing root. If so, make use of them – those assemblies won’t get packaged within your module NuGet package, so you’ll end up with a much lighter file. Remember though that for this to happen you MUST use exactly the same version of assemblies as in /lib folder.

Hope you find it helpful!

Most useful Orchard extension points

Fri, 25 Feb 2011 13:00:38 GMT

After some time spent developing Orchard modules I found many useful, yet not documented extension points you can use when writing your own Orchard-based apps. Mentions of many of them are scattered throughout the Orchard discussion board so I made an effort to put them all in one place.

Although in most cases you won’t use all of those features in a single app, knowledge of what you can do can be useful when building more complex, custom, Orchard-based applications.

Note: As far as I have seen the naming convention states that interfaces ending with “Service” are single instance, so if you create the custom implementation, it will be the one used across the whole app. In contrast, interfaces ending with “Provider” mark objects that are thought to provide additional functionality and cooperate with other existing ones, so to be used and injected as an IEnumerable<ISomeProvider>.

Authentication and authorization

IAuthenticationService – responsible for user authentication in Orchard. By default, orchard uses forms-based authentication delivered by FormsAuthenticationService. Custom implementation overrides the default one.
IAuthorizationService – responsible for user authorization in Orchard. By default, Orchard uses role-based authorization delivered by Orchard.Roles module. Custom implementation overrides the default RolesBasedAuthorizationService.
IMembershipService – responsible for account creation and retrieval. The default MembershipService comes from Orchard.Users.
IPermissionsProvider – allows creating custom permissions for reuse in authorization service. Check the Orchard.Blogs permissions provider as an example.

Navigation

INavigationProvider – provides additional menu items to be merged into the named menu. Implementations can be found almost in every module, which adds menu items to the Dashboard (e.g.. in Orchard.Blogs).

Messaging

IMessagingChannel – defines a channel for sending messages from Orchard. Orchard.Email defines the only one – “email” messaging channel, but you are free to create your own. After creating a custom channel you’d be able to force Orchard to use it by default by choosing it as a default one in Site settings.

Request filters

FilterProvider – defines the filter applied to each request. Resembles the way default ASP.NET MVC action filters work with the difference that it’s not an attribute. All FilterProvider objects are injected into the request pipeline and are applied to all requests (so you need to check if the current request is suitable for your filter at the beginning of an appropriate method).
As with the default ASP.NET MVC filters, your filter also has to implement one (or more) of the following interfaces: IActionFilter, IAuthorizationFilter, IResultFilter, IExceptionFilter. Check those as an example: AdminFilter, ThemeFilter, SecurityFilter.

Display shapes

IShapeTableProvider – allows you to programmatically describe your own shapes. Shapes from shape table providers are merged with the dynamically discovered ones (from .cshtml files). Check the CoreShapes definition as an example.

Background tasks

IBackgroundTask – defines the task, which will be run in the background in specified time intervals. It’s Sweep() method will be called every 1 minute (hardcoded in Orchard.Tasks.SweepGenerator). Chris Bower wrote a nice article about that.
IScheduledTask – defines the task, which will be run once at a specified time. You can create new tasks via IScheduledTaskManager – just inject this as a dependency and use inside your task-creating objects.
IScheduledTaskHandler – defines the processing logic for your custom defined scheduled tasks (look at Orchard.PublishLater module for example).

Data storage

IRepository<T> – defines the interface for data storage. By default Orchard uses NHibernate to store items in the DB, but you are free to define your own storage logic for specific items. Just implement this interface for the object type you'd like to store an it will override the default one.

Orchard delivers a lot more extension points you can make use of. I tried to describe the ones I found the most useful. If you found some other useful ones not described here, fell free to post the info about them in comments – I’ll update the list above.

If the list becomes full enough – I’ll make an effort to place it in the official documentation

Cheers!

Connect to SQL Server using domain account from remote machine

Wed, 23 Feb 2011 15:41:47 GMT

As most of production databases don’t use the SQL Server integrated logon and leverage the existing AD domain accounts instead, there exists an issue with connecting to them from outside the domain. Unfortunately SSMS do not allow you to specify the domain account used in the connection directly (only SQL or Windows Integrated authentication are the options). It means that you can’t access such DB directly eg. when connecting to corporate VPN network from your own laptop

I’m not keen on RDPing to the DB server every time to make a bunch of queries, so I found this workaround

From the command line you can specify the account that will be impersonated in all network-related communication of a given executable:

runas /netonly /user:DOMAIN\account "<path to your exe>"

Cool!

So to impersonate your domain account when using SSMS simply write:

runas /netonly /user:DOMAIN\account “C:\Program Files (x86)\Microsoft SQL Server\100\Tools\Binn\VSShell\Common7\IDE\Ssms.exe”

You’ll be asked for domain password and… That’s it! Choose “Windows Integrated” in SSMS connection screen and you can work with your DB from outside!

Remember the /netonly switch – it ensures that the account provided will be used in the network-related stuff only. It won’t work without supplying it, though.

Cheers!

How to assign default role(s) to new user in Orchard

Sun, 20 Feb 2011 22:31:37 GMT

This is a commonly asked question. Orchard, by default, assigns no explicit roles to the newly created user.

Every authenticated user has the Authenticated role, which is attached to the user object at runtime (it’s hardcoded, so you won’t find the user role in DB). Although adding necessary permissions to this role can suit most needs, sometimes you may need to explicitly add some other roles, possibly different, based on some set of rules, etc. In other words – sometimes there is some custom logic involved, which makes the default behavior unsuitable.

In such case the admin action is needed after user creation… It’s not the preferred option, though, especially when you have lots of users. The best way would be to do this automatically, so the user gets assigned one (or more) defined roles after registration. How to do that?

This can be achieved in two ways:

By implementing the IUserEventHandler interface (from Orchard.Users.Events) and handling the role-adding logic in Created method
By hooking to OnCreated<UserPart>() event in one of your ContentHandlers, and handling the role-adding logic inside.

Assigning the role to the user is a bit tricky, as there is no such thing as RolePart, which you can easily query for. Also, there is neither any collection property on User object which you could add your role to, nor any method for assigning roles in IAuthorizationService

Assigning role via IUserEventHandler

In this example we’re assigning the Administrator role to created user (not necessarily the best option though):

public class DefaultRolesHandler : IUserEventHandler {
    private readonly IRepository<UserRolesPartRecord> _userRolesRepository;
    private readonly IRoleService _roleService;
    private readonly IOrchardServices _services;

    public DefaultRolesHandler(
        IRepository<UserRolesPartRecord> userRolesRepository,
        IRoleService roleService,
        IOrchardServices services)
    {
        _userRolesRepository = userRolesRepository;
        _roleService = roleService;
        _services = services;
    }

    #region Implementation of IUserEventHandler

    /// <summary> /// Called before a User is created /// </summary> public void Creating(UserContext context)
    {
    }

    /// <summary> /// Called once a user has been created /// </summary> public void Created(UserContext context)
    {
        var role = _roleService.GetRoleByName("Administrator");
        if (role != null)
        {
            _userRolesRepository.Create(
                new UserRolesPartRecord {
                    UserId = context.User.As<IUser>().Id,
                    Role = role
                });
        }
    }
    #endregion }

As shown above, we have to use the repository of UserRolePartRecord directly to create an appropriate User-Role relation record.

IRoleService is a wrapper around the Role repository for CRUD operations on roles. It comes with some useful methods (e.g.. GetRoleByName for fetching roles by name, used above).

We’re done! Now, if a user account gets created in our Orchard app, it will be assigned the Administrator role instantly.

Assigning role via ContentHandler’s OnCreated method

For the sake of brevity, I’ll omit the code for achieving this, as it’s almost identical to shown above.

The only difference is, that we place the code for attaching the role inside OnCreated<UserPart>((ctx, part) => { <code_goes_here> }) method in one of your content handlers instead of the Created method of IUserEventHandler.

Hope you found this useful!

Cheers!