This is a big post, I know, but I think it’ll be worth it. If you don’t have
time to read it all, I organized it by importance, so the important stuff is at the
top anyway :).
I’ve been hinting for a while that I’ve been working on a secret side project using
ASP.Net MVC that was sort-of related to DotNetNuke. Well, it’s finally time
for me to put some code out there :). Today, I published a source code package
containing version 0.1 of MaVeriCk, a Content Management System written in ASP.Net
MVC. I’ll explain what it is and how to get started in this blog post.
Warning
: MaVeriCk is nowhere near finished,
and very much an alpha (maybe even a pre-alpha ;).
Major features are completely missing (such as user management, and any useful modules,
see below for details)
Disclaimer
: This project has NO RELATION to
the DotNetNuke project. While I am a DNN Core Team member, this is purely a
personal side-project. DotNetNuke has inspired some of the things I’ve done
in MaVeriCk, but that’s the extent of the connection between the two.
What is MaVeriCk?
Maverick is an open-source Content Management System in the style of *Nuke applications
such as DotNetNuke. For the rest of
this post, I’m going to assume you’re fairly familiar with that style of application.
Basically, users create pages and drop little widgets (or “Modules”) onto those pages
to provide features like a Blog, Message Board, or even just a block of HTML.
Where (and how) do I get it?
The project is hosted on GitHub (http://github.com/anurse/MaVeriCk/)
so you can feel free to clone the repository and hack away there. Alternatively,
if you either don’t have Git or don’t want to bother with getting the whole repository,
you can download version 0.1.0, from the downloads section: http://github.com/anurse/MaVeriCk/downloads.
Also on the downloads page are the release notes for this version which include a
full installation guide. Unfortunately, there is no automated installation system,
but the steps are quite straightforward if you’re familiar with ASP.Net.
Feel free to post comments on this blog, or send me email at: andrew AT andrewnurse
DOT net
(After all, I’m just a junior programmer just out of college and don’t purport to
be an expert in the various development patterns and architectures, so if you think
something doesn’t look right, please let me know!)
How does it work?
The rest of this post will be a, very short, introduction to the Module Framework
provided by Maverick. I’ll be posting much more detailed information about the
guts of Maverick later on, this is just a taste. Feel free to send me email
(see above) if you have questions about the rest of the architecture, and don’t be
afraid to dive into the code!
Let’s start by taking a look at a MaVeriCk page:
Here, we see a page with two modules. The first module is an instance of the
“Current Time” Module Application, the second is an instance of the “Claim Dumper”
Module Application. A Module Application is an MVC Application, with its own
Controllers and Views, which handles requests for a particular type of module.
If you’re familiar with DNN, the “Module Application” is analogous to the “Module
Definition” concept in DNN.
Here’s a look at the code for the Current Time Module Application:
[Export(typeof(ModuleApplication))]
[ModuleApplication(ApplicationId, ApplicationName, "1.0.0.0", "Displays the Current Time", "Maverick", "~/Modules/CurrentTime/Content/Images/Icon.png")]
public class CurrentTimeModuleApplication : ModuleApplication {
private const string ApplicationId = "A1FE2A31-0BC9-4B12-9B81-3B75C098EB33";
private const string ApplicationName = "Current Time";
protected override string FolderPath {
get { return "CurrentTime"; }
}
protected internal override void Init(MaverickApplication application) {
base.Init(application);
RegisterRoutes(Routes);
}
private static void RegisterRoutes(RouteCollection routes) {
routes.RegisterDefaultRoute("Maverick.Web.Modules.CurrentTime.Controllers");
}
}
Compare this with the Global.asax file with an MVC app, and you’ll find it’s very
similar. The “Init” method is equivalent to “Application_Start” and is called
the first time the Module Application is run during the current ASP.Net Application’s
lifetime. Just as you would in an MVC ‘Application_Start’ method, the Current
Time Application registers routes into a route table for this module application.
In this case, the module is using a helper that Maverick provides to register the
default route, but if we take a look at that helper, the only difference between the
standard MVC route and this route is that we require that the namespace containing
the Controllers is specified:
public static void RegisterDefaultRoute(this RouteCollection routes, string routeName, string defaultController, string defaultAction, string defaultId, string[] namespaces) {
routes.MapRoute(
routeName,
"{controller}/{action}/{id}",
new {controller = defaultController, action = defaultAction, id = defaultId},
namespaces
);
}
(Note: there are various overrides to this method, including the
one you see used by the CurrentTimeModuleApplication class above)
Routing in Maverick is a little more complex than in standard MVC applications.
I’ll go into more details on it later, but the gist of it is that a portion of the
URL for a request is handled by Maverick, and the rest (if any) goes to one of the
modules on the page (called the “Active” or “Selected” module). All the other
modules (referred to as “Passive” modules) get an empty URL, and their default route
is run.
From there on, a module is surprisingly similar to an MVC application. It has
Controllers and Views, just like an MVC app. The big difference is that, in
most cases, the ActionResult returned by a Controller does not represent the whole
page, just a fragment of it. Maverick collects all the ActionResults for a page
and then renders them out one-by-one in the correct location. Of course there
are exceptions (for example, if a Module returns a FileResult or a RedirectResult),
but that’s the core of it.
Missing Features
Maverick is in an early preview state at the moment. There is a powerful authentication
model available (or “Identity” model, as I call it), but at the moment, there’s only
a very simple “Debug” implementation of it (which just automatically logs you in as
an Administrator). I have a prototype system which uses the Azure Access Control
Service in the code, but it is not active by default (I’ll post more about that later).
Maverick does not really include any useful modules, so you’re on your own there.
Module development is relatively simple, and will be the focus of another blog post.
Feel free to check out the other modules for more info. The only major component
of Module Development not covered in the provided sample modules is data storage.
Maverick does have a system for modules to store data in the Maverick Database, but
none of the built in modules do that.
There is a very rudimentary Theming system in place to allow you to create your own
templates for the site (similar to DNN Skins).
Despite being touted as a Content Management System, Maverick doesn’t actually contain
any Content Management features :), no Workflow, no Versioning, no Content Approval.
However, those features are planned for the future.
If you have any other suggestions, please let me know!
