Blog

Upgrading Orchard and security exceptions

Mon, 26 Mar 2012 13:05:17 GMT

In some cases, when upgrading your Orchard instance, you may see something like this in your logs and wonder, “what the hell is going on??”:

Orchard.Environment.Extensions.ExtensionManager - Error loading extension 'XXX’
System.TypeLoadException: Inheritance security rules violated by type: ‘XXX’. Derived types must either match the security accessibility of the base type or be less accessible.

This is because of some changes to assembly-level security in Orchard, which makes using the assembly attribute

[assembly: SecurityTransparent]

to cause trouble. Some older modules had that attribute declared inside the /Properties/AssemblyInfo.cs file.

The solution is to change the line shown above to:

[assembly: SecurityRules(SecurityRuleSet.Level2)]

to enforce Level 2 security in a given module. Removing that line would also help.

You can read more about security in .NET framework on MSDN.

Wrapping up content item zones in custom markup

Sun, 25 Mar 2012 16:43:07 GMT

When it comes to rendering a given content item, Orchard splits it in a couple of zones, like Header, Content and Footer. The markup produced by each of the parts contained in an item is then dispatched to one of those zones. That is what Placement.info files are mainly used for – they tell the rendering engine in which zone to put a given shape’s final markup.

But what to do if you’d like to have the whole zone (eg. a Header) wrapped up in some custom markup? And what’s more – you’d like it to do in unobtrusive way, so no matter how the whole item is rendered (whether there are some shape alternates or not) – you want a given zone to be always displayed as you want it to be.

I’ve recently came up with a nice technique for doing that. First of all – zones inside a given content item are nothing more than… ordinary shapes! So you are free to attach a wrapper to them, like:

public class Shapes : IShapeTableProvider
{
    public void Discover(ShapeTableBuilder builder)
    {
        builder.Describe("Content")
            .OnDisplaying(displaying =>
            {
                // displaying.Shape.Header is the header zone shape!
                var theHeader = displaying.Shape.Header;
                // assign a custom wrapper directly to the header
                theHeader.Metadata.Wrappers.Add("MyHeaderWrapper");
            });
    }
}

The only thing left is to create the MyHeaderWrapper.cshtml:

<div class="my-custom-header">
    @DisplayChildren(Model)
</div>

Note the call to DisplayChildren. We remember that the wrapper wraps the whole zone (so Model contains the zone shape), right? And zones are containers for other shapes, so we have to display the contained children – that’s what DisplayChildren is intended for (using Display would run you into the StackOverflowException! Orchard would then try to render your wrapper, and your wrapper, and your wrapper and so on).

That’s all!

Now, when you try to open eg. a page, by default you’ll see the markup like this:

<article class="content-item page">
    <header>
        <div class="my-custom-header">
            Here comes the whole current header
        </div>
    </header>
    <p>Page content</p>
</article>

You’re free to apply this technique to any available zone (like Header, Content, Footer etc.) and to any available content item stereotype (like Content, Widget and so on) For the purpose of this article I just used Content stereotype and it’s Header zone.

Wiring SignalR with Autofac

Fri, 16 Mar 2012 21:36:28 GMT

After having a bit of struggle recently (which was quite fun, btw) with making two cool software pieces – Orchard and SignalR – work together, I came up with a simple library that allows you to wire SignalR’s internal dependency injection mechanism with Autofac. Useful thing if you already use Autofac and wish to keep all the dependencies there.

Orchard uses Autofac, so it was pretty obvious that something like this would be necessary at some point to make everything work.

The code is available at GitHub: https://github.com/pszmyd/SignalR.Autofac. I’ll publish the lib as NuGet package shortly.

Usage

It’s simple as hell – just a single class. To use it in your ASP.NET app, you need to set the SignalR resolver to AutofacDependencyResolver in your bootstrapping/initialization code:

var resolver = new AutofacDependencyResolver(lifetimeScope); 
AspNetHost.SetResolver(resolver);

It takes a single ctor argument – your Autofac container instance (ILifetimeScope).

The simplest example could look like this (assuming Initialize is a method that bootstraps your application):

public void Initialize() { 
    // Building the Autofac container 
    var builder = new ContainerBuilder(); 
    builder.RegisterType<SomeType>().As<ISomeInterface>; 
    
    // .... 

    var container = builder.Build(); 
    var resolver = new AutofacDependencyResolver(container); 
    AspNetHost.SetResolver(resolver); 
}

And that’s all. Now, you can use all the types that SignalR registers (eg. IConnectionManager) in other parts of your application and vice-versa.

Orchard 1.4 is here!

Thu, 01 Mar 2012 02:30:00 GMT

Finally! Today we officially announced the new Orchard release - version 1.4. It's a big step forward from the previous, 1.3.10 version, both in terms of performance and features.

Unfortunately, it comes with a price... There are some breaking changes which might cause some modules to stop working. Especially those modules that utilize the routing features (ie. deal with all the items accessible by URLs). It also affects the Advanced Menu module, so the current 1.3 version won't work with Orchard 1.4 out-of-the-box. I'll be submitting the compatible version to the Gallery tomorrow [UPDATE: Unfortunately the module release will be delayed by one day].

You can find detailed information on the release notes page.

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!