There are times you will want to accept donations or payments on your MODX-powered sites. In my case I wanted to offer the possibility for users to donate towards one of my open source projects. So I whipped up a snippet to help me do that.

My requirements were simple.

  1. Customizable form to match layout
  2. Simple 2 (3) step procedure: type in amount, make donation, thank you.
  3. Ability to display a configurable "thank you" message
  4. Some kind of "posthooks" allowing you to (programmatically) do other stuff based on a donation. For example when people donate for HandyMan, I want to be able of creating a user account for them so they can access the HandyMan member only area (in the somewhat near future, that is). I don't need that for others, so it needs to configurable :)

After spending some time figuring out the PayPal API calls to use for these requirements it was finished pretty quickly, and the open source landing pages on this site now have one of those forms each.

How it's done (slightly technical)

The package (which I called mhPayPal as I needed a name to get started and didn't try to come up with something more fancy, open to suggestions in the comments!) consists of 2 snippets. One snippet, makeDonate, is used to display the form. It basically wraps a chunk which contains a FormIt call and the html for the form.

The second snippet, makeDonateHook, is registered as a posthook on FormIt which is triggered when the form is submitted. It takes some properties (via the FormIt call) and of course the amount and currency. It then uses a slightly modified version of this PHP PayPal class by Drew Johnston (which is the same one I used for SubscribeMe) to send a SetExpressCheckout API call (which prepares the token for the checkout) with the filled in and calculated data.

After redirecting to PayPal, and returning to the same page you were on when filling in the form, the makeDonate snippet will intercept the request and once again use the phpPayPal class to confirm the payment (DoExpressCheckoutPayment API), and to show the success message. Under the hood, there is data stored in the MODX cache to be able of matching data against the right token.

Does it work? Can I use it too?

Yes, and not yet!

You can see it in action on one of my open source pages (be aware that the forms are live though - I appreciate your donation :P). As I'm not entirely done with the package (need to implement requirement 4 still) I haven't yet wrapped it up for the general public, however it will probably pop up on my Github in the near future is available from Github and possibly in the MODX Extras Repository in the near future.

It's insanely easy to use (simply call the [[!makeDonate]] snippet in your template or content and, if you configured your PayPal credentials, you're done) and I think will be an extra value to those people and institutions that rely on donations and need a real easy solution for both visitors and developer.

Let me know in the comments if you have a project coming up this could be useful for. Perhaps you can also come up with a better name for the package while you're at it? :)

We're closing up 2011, of course cramming all the leftover work into one or two weeks, and with that I wish you Merry Christmas and a Happy HandyMan! Yes, you read that right and I (think) I spelled that right. Today - Christmas 2011, December 25th, 2011 - sees the release of HandyMan, the Mobile Manager for MODX all of you have been waiting for.

(At least - if I can drag myself away from all the Christmas celebrations for just a few minutes to upload the package to the Repository. This post was written a few days ago and I just told it to publish itself on December 25th cause, well, MODX can.)

Merry Christmas & Happy Holidays

Let's get this out of the way. 2011 was a great year for me personally, in which I dropped out of school and landed into this MODX world full of fascinating development projects, and the prospect of doing something I actually seem to like for a living! With over 25 clients in the first year of business I don't think I did too bad either!

I hope your year has been equally exciting, and that there's many interesting things on the shelve, waiting to be dusted off and executed. In memory of the one and only Steve Jobs, I hope we can make 2012 the best year yet

Merry Christmas & Happy Holidays!

Back to.. HandyMan!

Right - HandyMan. That rock-solid jQuery Mobile foundation, with some MODX love sprinkled on top. Or based on the time it took to get this ready for a public release - nearly nine months - a helluva lot MODX! HandyMan allows you to manage your MODX content using virtually any mobile device, including tablets, using a stripped down, mobile optimized UI.

For those who are unfamiliar with it, and don't understand what I'm so excited about - you should check out the following Promo video made by Jared Loman:

That probably told you very little new information.. but c'mon - it had to make you grin right? It's Christmas! :D If you really want more in depth information of what HandyMan is, head over to this eight minute screencast, also by the one and only Jared Loman

But hey.. why not just download the package, and get it up on your own site to start managing your content from a mobile device?

More information on HandyMan can be found on its dedicated site: MODX Mobile.

 

Somewhere in the Spring or Summer of this year I decided I wanted a new website. The old one, while functional, didn't quite speak to me anymore and the blog was simply tucked away too far to ever become a prominent part of the site.

A few different mockups followed, and eventually I found some people (Romain Tripault and YJ Tso most notably) willing to help me out with the whole process of getting a new proper design and get something launched. Now, December 2011, it's finally there.

What I wanted

  • Responsive website - Mobile is the future and I don't want to scare my visitors away by providing a bad user experience on other devices.
  • Automatically displaying related articles. Coincidentally I had a custom development client who wanted the same, which resulted in getRelated which is now powering the "related" widgets on the site.
  • Clean design. Fast, accessible. Syntax Highlighting to make code readable.
  • Much more focus on MODX related articles on the blog. Regularly posting fresh and interesting MODX content with visitor interactions through comments (perhaps a guest post someday?) will really thrive this site forward into the "MODX Vibe". (Read my take on the all new Articles plugin)
  • Better representation of the work I do and did for prior clients.
  • A demo site for some of the addons I developed.

Well, you're looking at the result!

I'll be finishing up the migration of the site over the next few days, including the comments that were left there on migrated posts and adjusting links to my site where-ever I can. Oh, and you may want to watch this space on December 25th 2011... to stay updated you could use my MODX 2.2 Dashboard Widget! :)

This website (and domain in general) will start housing many different sections in the next coming months, and the blog is only going to grow and grow - so come back some time! ;)

What do you think of the new design and in general - this website? Any requests on articles? Feel free to leave a comment (here, or on any article of course!) or to get in touch.

VersionX 1.0 was first developed in December 2010 - it was one of the first open source project I started actually. It also was the first tim that I actively developed a custom manager page, and, well, the code is terrible.

Luckily VersionX 2.0 is coming to town!

VersionX 2.0 is a complete rewrite - all that is reused is the name and the initial thoughts behind the plugin: providing a simple versioning component that allows viewing, comparing and restoring of past versions.

The rewrite is in progress, and as with any open source project - not quite as fast as I had wanted - but it's starting to get shape. Here's a quick list of what is currently in place:

  • Saving a resource causes VersionX 2 to check if any changes were made, and if so it will save a new copy to the database. If on MODX 2.1 or higher this includes Template Variable values.
  • Saving any element (templates, template variables, snippets, chunks or plugins) creates a new copy in the database.
  • Resource Versions can be seen and compared to any other version of the same resource through the VersionX Component.

Yes - it versions Elements and Resource TV values - that's new to VersionX! However, having built the versioning functionality for elements, there's not yet a grid to interact with it. The element data will be in the database if you need it, but there's no way to view or compare it from the manager.

As of writing, VersionX 2.0 is at release dev7 and I am expecting to be able of releasing it publicly at around dev15 or so. Here's the things I'm looking to implement by then:

  • Proper upgrade from VersionX 1.0. The database is set up way differently (to allow a more scalable and future-proof strategy), and there's not yet a simple upgrade procedure to re-use the data already stored. This needs to be different before a first public release.
  • Restoration of Resource versions - after all, that's what this whole thing is about.

When those two have been finished I will be releasing VersionX 2.0 as a free package available from the MODX Repository.

After that, hopefully some donations will pop up and I will be able to develop VersionX further. Adding the interface for elements, bringing new tabs to resource update screens to view the versions without leaving that page and more.. all of that and much more is on the roadmap for VersionX 2.0.

I'll admit: deep down inside I'm hurt. I've spent hours and hours trying to get this blog just right with all the right features. You may have noticed that I set up some automated archiving, tags use friendly URLS and you can even leave comments (with notifications). And guess what? You can have all that and more in literally five minutes with the all new "Articles" component for MODX 2.2. Thanks Shaun!

No - but in all seriousness, the release of this all new "Articles" plugin (formerly called "modBlog") is great news. The timing could have been better (like, not right after I deemed the blog section of my new site completed), but this is a great step leap forward for MODX, and I would really say it welcomes MODX 2.2 to the stage with a bang. 

Now, for those that have been hiding under some rocks lately - Articles is a Custom Resource Type developed by Shaun "splittingred" McCormick, MODX Senior Developer. "Custom Resource Type" is real nerdy talk for saying it's something that shows up in the side hierarchical resource tree, but doesn't neccesarily act similar to your regular Documents. If you want the nerdy description - it means you can extend the modResource class, and change its behavior (methods), customizing the user experience (controllers) and more. 

So what does it do?

Well, here's a list of some of its features:

  • Provide an overview UI when clicking the Articles resource in the resource tree, where a grid of posts are shown, as well as a huge amount of settings to configure its behavior.
  • Lists the individual articles on the front-end (powered by getPage and getResourcesTag, meaning you got it paginated and filterable on tags)
  • Creates automated archives (using friendly URLs). 
  • Generates RSS feeds.
  • Allows imports from Wordpress and resources. 
  • Has built in commenting (configurable through the Settings tab) powered by Quip. Real nifty thing here is that the Quip comments view in the manager is integrated with the individual article update screens.

Well, that pretty much sums up blogging right? I probably forgot a thing or two there, and luckily there's still some things planned for future releases for the total feature-nuts out there. 

All in all Articles really is a game changer, and the fact that it is for MODX 2.2 and up (I really should write a blog post on that, too!), I have the feeling we're about to see a big spike (a new download record, perhaps?) when 2.2-pl hits the shelves.

(And yes - this blog is still powered by my own craftmansship and hours of hard labor. And 2.1 for that matter. I'll upgrade it all someday - let's launch this baby first!)

On my article on Caching Guidelines for MODX Revolution, Marc Hinse asked a very good question that I don't want to leave unanswered.. however the answer is slightly longer than a simple comment, so this follow-up tries to go into what he's asking.

This was his comment:

A very good question, and now that the basic caching has been cleared up, I suppose we can move on and dive a bit deeper. The source-order recursive parsing makes it fairly complicated to explain (and I'm not sure if I know all the ins and outs myself either), but I'll give it a shot.

Parser Basics & Tag Order

From what I know, the parser collects all tags and starts executing them from start to finish, and inside out - so first the tag nested all the way down, and the outer most tags last. Everytime it has processed something, it would check that output for any tags and execute those - again "inside out". This is for all cached tags. It waits with processing uncached tags until all cached tags have been executed. So you could say this is the parsing order:

  1. Nested cached tag
  2. Cached tag
  3. Nested uncached tag
  4. Uncached tag
To make it all make more sense, I like to envision it that tags are put in some sort of queue, with the priority being set to any of the 1-4 above where 1 is top priority, and 4 is lowest priority. It's also sorted on source order, so a tag that appears in the header is executed before a tag in the footer - also based on the priority.

Furthermore it keeps this queue and parsing order in different levels. When a tag is found and executed its return value is immediately checked for tags, which are then added to a queue and executed. Any return value of those tags will be checked for tags which are added to a queue and executed. Any return valueof those tags.. well, you get the idea right? It's completely recursive and the parsing order is in effect per level (or scope, or context, whatever you want to call that).

Parsing Tags

Everytime a tag is parsed, the output will be checked to see if there are any tags in there, and if it finds any, they are added to the queue according to their priority and source order. Then it goes back to that queue and executes whatever is left based on its priority and source order.

When all cached tags have been processed, the result of all that (so with all uncached tags in place) is written to the cache for future requests. In other words - any uncached tags will appear as-is in the cache file, and will be picked up and executed on every request.

In Marc's example there's another layer of complexity added with the output modifiers. I think it first looks out for "inner tags", so in your example both [[$chunk1]] and [[$chunk2]] would be parsed before [[*tv]]. In that scenario it could be the following after one round of parsing:

Then in the next "round" of finding tags and adding it to the queue, it would parse the chunks to return your uncached snippet call and to replace the pagetitle tag with the pagetitle. So by now, we have the following:

Now we see that we have a cached TV tag, with uncached snippets in there. We know that cached take priority in the queue, so at this stage we would see the output modifier being executed (as well as other cached calls of course), resulting in an output of (assuming tv = 1):

At that point the cache would be written to file and parsed on every subsequent request. So even when nesting, as long as the outer elements are cached it should only save uncached elements for parsing on every request. This also is true when using an uncached placeholder in a snippet tpl chunk - they would be left in the rest of the output when writing to cache, for processing on every request.

Parsing Order & Conditional Logic

Basically, if you have conditional logic using output filters (or the If snippet for that matter), the "inner" tags will be executed before the outer (conditional) tags. What that means is that when you have the following example:

While this seems fine, it will parse inside-out, meaning that the FirstChildRedirect snippet will always be executed, and you end up being redirected to the first child, and the conditional logic is moot.

Now, knowing that we can nest tags anywhere, we can trick the parser somewhat, and put another pair of double brackets around the conditional logic, and remove them from within the conditional logic:

This will execute the conditional logic first, and will return either "!FirstChildRedirect" or "$video-gallery", which, thanks to the outer pair of two brackets, will form a valid tag which will then get executed after the conditional logic takes place.

This doesn't just stop at the name of the tag to load though, here's an example (from Jason "opengeek" Coward) illustrating just what you could do know that you learned this trick.. First we have a chunk (let's call it "sidebox"), which has the following contents:

And how it's being used (again, assuming the name "sidebox"):

Here's an article to read if you're new to chunk parameters and placeholders, but if you know that - and now know this trick - you may get the feeling there's some powerful applications for stufff like that..

Notes

This is the caching as I understand it at this point of time... There's probably some subtleties missing, but beyond that I'm quite confident it is correct and all. ;) I'm glad that Jason Corward was willing to give this article a read before hitting the final "Publish" button though, and pointing out a few important things. Thanks Jason!