First, make a backup of ImportExport.pm from your original Movable Type installation, which is the Perl module that handles the export. Do this because you want to make sure that you have a good copy, just in case something goes awry. Put this backup in a safe place, and work with the copy of the file, just in case. Ready? Good.

sub export {

In any version of MT 3.3x (that is, MT 3.31, MT 3.32, MT 3.33, MT 3.34 or MT 3.35), this is on line 516. This indicates the start of the export subroutine. Once you have located this line, scroll down a few lines and locate these lines:

DATE: <$MTEntryDate format="%m/%d/%Y %I:%M:%S %p"$>
-----

This is where you are going to insert the information. Change these two lines so that they look like this:

DATE: <$MTEntryDate format="%m/%d/%Y %I:%M:%S %p"$><MTEntryIfTagged>
TAGS: <MTEntryTags glue=","><$MTTagName quote="1"$></MTEntryTags></MTEntryIfTagged>
-----

What you have done is insert a section of code that will include the tags only if there are tags on the entry. Make sure you include the dashes, as that is a necessary part of the formatting.

By wrapping everything in the MTEntryIfTagged container, you are sure to only include the line if the entry in question has tags. This probably isn't completely necessary, but it makes things tidy, so it's a good idea to include it. The rest of the line just formats everything correctly, producing the necessary information for a valid import.

After making this change, save your changes and exit. Then upload the file to your server and run your export again. Now you should be able to see the tags in your exported file, and you can import these to your MT installation.

There is one difference in this and the MT4 version, and that is that the "include_private" attribute doesn't exist in MT3. This should mean that you get all the tags on the entry, including private tags. But just in case, make a note of any private tags that you have, as you might need to update them later.

This tutorial is written by LMT author Chad Everett of Everitz Consulting.
Tutorial cross posted on Don't Back Down and LMT.

First, of course, you need Windows and IIS. Unfortunately, configuring those two is going quite beyond the scope of this article. Luckily, doing so is not particularly difficult. You'll also need, at a minimum, MySQL and Perl. If you want to use dynamic publishing, you'll also need PHP - but I'm not going to cover that here. Maybe next time. Ready? Let's go!

MySQL is a database. If you're familiar with Microsoft products, then it's somewhat similar to Microsoft SQL Server - but it's free, and Movable Type stores all of its data inside. There is a version of Movable Type that runs on SQL Server, and it's called the Enterprise version. That's also not covered here. This is for the standard product only, though some of the details might be of use to you.

When you go to get MySQL, you want the community version. You can get the Enterprise version if you want, but it's not needed. From the link above, download the MySQL Community Server. The Enterprise version should work, but you'll have to buy it one day (the Enterprise version is not free software). You should also download the MySQL GUI Tools. These aren't strictly required, but if you're used to Windows, chances are you like working in Windows, not at the command line, so it's nice to have them available.

Perl is a programming language. Specifically, it is the language that Movable Type is written in, and in order to run Movable Type, you must have Perl. The link above takes you to the download location. You don't even have to provide your contact details, but you can if you like.

Once you get both MySQL and Perl installed (the installation is fairly straightforward for Windows applications), you're ready to proceed. Also install the GUI tools if you downloaded them. Download your Movable Type installation and unpack it to a directory where you'll store it. Generally this will be called something easy to remember, like mt, and can be found inside your wwwroot directory, along with your other website files.

You will likely need to install two modules before Movable Type will work. This process is started from the command line. Click Start, then Run, then enter CMD and press ENTER. At the command line, type ppm (unlike most *nix systems, Windows is not case-sensitive, so you can actually type ppm, PPM or even PpM and it should work fine) and press ENTER. This starts a graphical installation utility.

The process will take a moment to synchronize the database. When it is done, you will be presented with a list of all installed modules. Click the View menu item, then select All Packages. In the search box, enter dbd-mysql (case is not important).

You should see three packages listed - DBD-mysql, DBD-mysql-SimpleMySQL and DBD-mysqlPP. Next to each are three columns: area, installed and available. We want to see if DBD-mysql is installed. It probably is not. Click the row that contains DBD-mysql to highlight it, then click the box with a plus on it, next to the search box. This marks it for installation.

Next, click in the search box and search for mail-sendmail. Like DBD-mysql, it is probably not installed. Again, click the row to highlight it and then click the box with a plus on it to mark it for installation.

Now we just need to install the modules that were not installed. Click the File menu option, and select Run Marked Actions. This will install those items you have marked. If everything goes as planned, you will now have two new modules installed! If not, try these steps again to see if you can get them to work. If it doesn't you may need some help that can't be addressed here.

Once the modules have been installed, you're done here. You can exit ppm and close the command-line window.

Open the MySQL Query Browser by going to Start, then MySQL, then selecting MySQL Query Browser. You'll be prompted for a login. Specify the user name and password that you gave when installing MySQL earlier. You will also need to provide a default schema. This is simply the default database that you'll be using. Enter mysql for now. So long as it's valid, it doesn't really matter what you specify here.

Once connected, you need to create your new database. We'll call it mt. In the query window (at the top), enter create database mt; (note the semicolon at the end) and click the Execute button. This creates the database for you. You can now exit the MySQL Query Browser.

With the applications configured and the database ready to go, there are only a few items left. First up is updating the Movable Type configuration file. For this, you need to locate the file, which you will find in the mt directory that you created earlier. The name of the file is mt-config.cgi-original. Before doing anything, copy this file to another name - mt-config.cgi (drop the -original from the end). Then edit this new file.

The first line in the file to edit is the CGIPath declaration. This indicates where Movable Type is found, and should be either a full URL or a relative URL (without the domain). Most Windows systems don't use a cgi-bin, so the example is probably not going to be correct. That doesn't stop you from using one, but you don't need one either. Here's the example, simply make the necessary changes to what it will need to be once the site is live:

CGIPath http://www.example.com/cgi-bin/mt/

The next line to configure is the StaticWebPath directive. Because Windows systems rarely use the cgi-bin, and if they do, it's not restricted like it is on *nix systems, the use of this is often simply commented out (just put a # sign in the front). You can use it, but for simplicity, I won't address it here. Your should look like this:

#StaticWebPath http://www.example.com/mt-static

Now you need to configure your database. This actually requires five values. The first will not change with this configuration - we are always using DBI::mysql. The second is going to be the name of the database that we created above (we used mt, if you use something else, replace it here). The third is the username you created when you set up MySQL and the fourth is the password for that user. The last value is the host - localhost since the database is on the same computer as the site. If you move the database, this would point to that location.

ObjectDriver DBI::mysql
Database mt
DBUser DATABASE_USERNAME
DBPassword DATABASE_PASSWORD
DBHost localhost

The final step is actually an optional one, and that is if you want to send notifications. To do this on Windows, we must use SMTP (actually, there are other ways, but this is by far the easiest). Simply specify two more directives in the file:

MailTransfer smtp
SMTPServer localhost

If for any reason the SMTP server is not running on the local computer (for instance, if it's another system), just specify that value instead.

Now, save the mt-config.cgi file.

Almost there - start your IIS Manager. Usually this is done by going to Administrative Tools and then selecting Internet Information Services (IIS) Manager, but you may have a shortcut on the desktop or in the quick launch bar. However you get there is fine. Open the web site where Movable Type will run, whether it is the Default Web Site or another one.

Expand the web site and locate the mt directory. Right-click on the mt directory and select Properties. Click the Configuration button. In the Application Extensions list, scroll down until you reach cgi (it should be between cer and config). It may not be there at all. If you don't see it, you'll need to add it. If it is there, you'll need to edit it. In other words, if you don't see it, click Add. If you do see it, highlight it and click Edit. You want to make the extension look like this mapping.

That means you need to specify the path to the executable - which should be C:\Perl\bin\perlis.dll, the verbs, which are limited to GET,HEAD,POST and check both boxes. There are some references that you should map the cgi extension to the Perl executable rather than the dll. However, there are two reasons why I would suggest that you don't do this. First, the performance with the dll is better. Second, MT4 does not work with the executable. I can't tell you why, as I have been unable to figure it out - but it works with the dll version whenever I've tried. Add to that improved performance, and I'd stick with the dll.

Click, OK to save the mapping, OK to save the Configuration and OK to apply the properties. Almost done.

Scroll all the way to the bottom of the IIS Manager window (left side). You'll see an item called Web Service Extensions. Click it. On the right side, it will list two items for Perl - one for Perl CGI Extension and one for Perl ISAPI Extension. The first is if you decide to use the executable version of Perl. The second is if you use the dll version. Since we're using the dll version, we're using the second. But if you've gone with the executable, you want the first. Keep that in mind.

Since we want the second, click the second (that would be Perl ISAPI Extension) and then click Allow. That's it. Now stop and start your web site, just to make sure that it picks up all the changes that you've made.

To test out your configuration, visit the mt-check.cgi page by loading it in a browser. This will be at the CGIPath location you set earlier, along with mt-check.cgi at the end. So it should look something like this:

http://www.example.com/cgi-bin/mt/mt-check.cgi

If everything works as expected, then all the checks should work. You will get a few that will fail, but you'll have enough that you can run the installation. Just remove the -check (that is, connect to mt.cgi) and you'll be prompted to run the installation procedure.

There's a lot of detail here, but mostly that's to make sure that everything is covered. Read it over and try it out - you'll realize that it's really not that complex.

This tutorial is written by LMT author Chad Everett of Everitz Consulting.
Tutorial cross posted on Don't Back Down and LMT.

One of the issues that I run into fairly regularly is for people who use the MTCommentFields tag. This tag, originally released in version 3.0D - way back in 2004, for those of you keeping track - was designed so that you wouldn't have to keep up with your comment form. Unfortunately, people like to keep up with their comment form, to move it around, change some wording, add features or just tinker. So it rapidly fell out of favor, and in MT4, it's gone completely.

If you're still using it and you want to upgrade, you'll see a message that reads The MTCommentFields tag is no longer available; please include the Comment Form template module instead. You will be able to rebuild your templates, but you won't be able to accept any new ones.

And naturally, if you're upgrading, you won't have this module to make that happen. To make matters worse, if you're a user of certain versions, even if you try and get rid of the tag, you might still have problems. What do you do? Luckily, it's an easy fix.

First, click on Design, then Archive Templates. You are looking for the Individual Entry Archive template. Near the top, locate the JavaScript in the template. It will look something like this:

<script type="text/javascript" language="javascript">
<!--
var HOST = \'<$MTBlogHost$>\';
// Copyright (c) 1996-1997 Athenia Associates.
// http://www.webreference.com/js/
// License is granted if and only if this entire
// copyright notice is included. By Tomer Shiran.
function setCookie (name, value, expires, path, domain, secure) {
    var curCookie = name + "=" + escape(value) + (expires ? "; expires=" + expires : "") + (path ? "; path=" + path : "") + (domain ? "; domain=" + domain : "") + (secure ? "secure" : "");
    document.cookie = curCookie;
}
function getCookie (name) {
    var prefix = name + \'=\';
    var c = document.cookie;
    var nullstring = \'\';
    var cookieStartIndex = c.indexOf(prefix);
    if (cookieStartIndex == -1)
        return nullstring;
    var cookieEndIndex = c.indexOf(";", cookieStartIndex + prefix.length);
    if (cookieEndIndex == -1)
        cookieEndIndex = c.length;
    return unescape(c.substring(cookieStartIndex + prefix.length, cookieEndIndex));
}
function deleteCookie (name, path, domain) {
    if (getCookie(name))
        document.cookie = name + "=" + ((path) ? "; path=" + path : "") + ((domain) ? "; domain=" + domain : "") + "; expires=Thu, 01-Jan-70 00:00:01 GMT";
}
function fixDate (date) {
    var base = new Date(0);
    var skew = base.getTime();
    if (skew > 0)
        date.setTime(date.getTime() - skew);
}
function rememberMe (f) {
    var now = new Date();
    fixDate(now);
    now.setTime(now.getTime() + 365 * 24 * 60 * 60 * 1000);
    if (f.author != undefined)
       setCookie(\'mtcmtauth\', f.author.value, now, \'/\', HOST, \'\');
    if (f.email != undefined)
       setCookie(\'mtcmtmail\', f.email.value, now, \'/\', HOST, \'\');
    if (f.url != undefined)
       setCookie(\'mtcmthome\', f.url.value, now, \'/\', HOST, \'\');
}
function forgetMe (f) {
    deleteCookie(\'mtcmtmail\', \'\', HOST);
    deleteCookie(\'mtcmthome\', \'\', HOST);
    deleteCookie(\'mtcmtauth\', \'\', HOST);
    f.email.value = \'\';
    f.author.value = \'\';
    f.url.value = \'\';
}
//-->
</script>

You want to remove this entire block and change it to this:

<script type="text/javascript" src="<$MTLink template="javascript"$>"></script>

Various versions of the software would create a Site JavaScript file for you. If you view your template listing (index templates) and see a file with a name of Site JavaScript, you'll enter site javascript here. If you see a file with a name of JavaScript, enter javascript here. Case is not important.

This allows Movable Type to pull the name of another template - in this case the JavaScript (or Site JavaScript) - and fill in the blank. This is a much better solution than hardcoding the name, because people have a tendency to tinker with names, and what though a lot of people don't change the name, some might, so this covers most bases. If you change the name, just make sure you change this value.

If for any reason you don't have the JavaScript (or Site JavaScript) template, you can find a new one by looking in the default_templates directory if your Movable Type distribution. In fact, this isn't a bad idea, as new content is periodically added to this file, so you may gain some new functionality by updating this file from time to time as new versions are released.

Next, you need to scroll down and locate the MTCommentFields tag. By default, it is located slightly down the screen, between two tags for MTIfCommentsAllowed:

<MTIfCommentsAllowed>
<MTCommentsFields>
</MTIfCommentsAllowed>

You can simply delete it - but if you do, you need to replace it with something (unless you don't plan on accepting comments, in which case you can save it and you're done).

If you do want to accept comments, then the simplest change is to alter the tag by changing all three lines to an MTInclude statement, which includes the aforementioned Comment Form. Don't worry about the form itself that you need to include right now - we'll create that in a moment. Here is what it should look like:

<$MTInclude module="Comment Form"$>

Remember, replace all three lines with this one. It won't really hurt to leave the outer MTIfCommentsAllowed statements there, but you don't need them, and you're just making more work for the template, because the Comment Form template handles that for you.

Before you save the template, however, you may have one more change to make. So scroll down to the bottom and look for these lines:

<script type="text/javascript" language="javascript">
<!--
if (document.comments_form.email != undefined)
    document.comments_form.email.value = getCookie("mtcmtmail");
if (document.comments_form.author != undefined)
    document.comments_form.author.value = getCookie("mtcmtauth");
if (document.comments_form.url != undefined)
    document.comments_form.url.value = getCookie("mtcmthome");
if (getCookie("mtcmtauth") || getCookie("mtcmthome")) {
    document.comments_form.bakecookie[0].checked = true;
} else {
    document.comments_form.bakecookie[1].checked = true;
}
//-->
</script>

Present in the default template from version%

Movable Type allows you to create categories and sub-categories for organizing your entries. The default MT3.2 Main Index template includes code to list these categories in the sidebar section. This tutorial will attempt to explain the tags used in this code and how they work together.

Categories, Sub-categories, Parent, Child, and Levels

The only difference between a category and a sub-category is that the latter will always have a "parent" category. The sub-category is still a category, and everything else remains the same as any other category. But by having sub-categories, you can provide better organization for your site. One example might be to put sub-categories of "Movable Type" and "Typepad" under a parent category of "Tips", to better classify the information you are creating.

Any category with such a "parent" will be considered a "child". Additionally, any category (even a sub-category!) can have its own children as well. Because of this, within this tutorial, you will see the term "level" used frequently. A parent category (Tips) is on one level. The child category (Movable Type, Typepad) is another. In turn, the child category may have children itself (Plugins, Styles, Templates), creating still another level.

Here is the code from the Main Index template:

<MTTopLevelCategories>
<MTSubCatIsFirst><ul></MTSubCatIsFirst>
<MTIfNonZero tag="MTCategoryCount">
<li><a href="<$MTCategoryArchiveLink$>"
title="<$MTCategoryDescription$>"><MTCategoryLabel></a>
<MTElse>
<li><MTCategoryLabel>
</MTElse>
</MTIfNonZero>
<MTSubCatsRecurse>
</li>
<MTSubCatIsLast></ul></MTSubCatIsLast>
</MTTopLevelCategories>

<MTTopLevelCategories> <MTTopLevelCategories> is a container that processes the code within, starting with the current highest level category. When it gets to the <MTSubCatRecurse> tag, it then repeats the process with the next highest level of category, and so on, through all levels of sub-categories.

<MTSubCatIsFirst> <MTSubCatIsLast> These tags simply indicate if a particular category is the first in the list or the last in the list, respectively. As you can see these tags open the <ul> and then close the <ul> at the end of this section of code. So, the first category in the list of categories opens the unordered list tag - <ul> - which pulls from your stylesheet the direction of how to display an unordered list. (Unordered lists are usually displayed with bullet points. Ordered lists - <ol> - are usually displayed numbered 1, 2, 3, etc.) Likewise, the last category in the list of categories closes the unordered list tag.

<MTIfNonZero>, MTCategoryCount and <MTElse> The <MTIfNonZero> tag compares the value of the tag (in this case, MTCategoryCount) to zero. If there are entries within a category, the MTCategoryCount will be greater than zero and a link will be provided to the category page. If the there are no entries in the category, the MTCategoryCount will equal zero and <MTElse> will come into play and only the category label will be shown, without a link.

In either case, an <li> tag is opened which instructs the browser that what comes next is a list item. The <li> tag is closed after the processing of the <MTSubCatsRecurse> is complete.

<MTSubCatsRecurse> This tag says to process this hunk of code for each level of sub-categories under this one (and so on).

"Recurse", by the way, is a programming term, indicating to "use recursion". In other words, it is the ability of the routine - in this case the <MTTopLevelCategories> container - to call itself over and over again.

In this example it means that the container will continue to loop through each "level" of categories, until it reaches the end of that level. At this point, if on a "lower" level (that is, a sub-category), processing will return to the next higher level (the "parent"), where the loop will complete. If the loop is still on a lower level, it will end that loop, and return up to the next level. And so on.

If you remove this tag, the code will produce the same structure - but it will only be for the top-level categories (no sub-categories). If you include this tag, each time through the loop (that is, for each current category), it will redo the structure for the categories below that one. You can perhaps see this best by looking at the HTML.

For top-level categories only (no recurse tag, meaning no sub-categories at all), you might see something like:

<ul>
  <li>News</li>
</ul>

But with the recurse tag, you will be able to produce something like this:

<ul>
  <li>News
  <ul>
    <li>Local</li>
    <li>World</li>
  </ul>
  </li>
</ul>

To explain how this works...

First, the opening <ul>, then the first category (the only one in this sample). Prior to that tag being closed, the recurse tag runs - and realizes there are some sub-categories for the current category.

So it opens a new <ul> for this level of sub-categories, which in turn has its own items in the list. When that category is at the end, it closes that list with </ul>, then closes that item (News) with </li>. Finally, we're at the end of the entire category list, so the top-level list is closed with </ul>.

This illustrates a more likely example, with multiple categories at each level:

<ul>
  <li>News
  <ul>
    <li>Local</li>
    <li>World</li>
  </ul>
  </li>
  <li>Recipes
  <ul>
    <li>Beef</li>
    <li>Chicken</li>
    <li>Pork</li>
  </ul>
  </li>
  <li>Tips
  <ul>
    <li>Movable Type
    <ul>
      <li>Plugins</li>
      <li>Styles</li>
      <li>Templates</li>
    </ul>
    </li>
    <li>Typepad</li>
  </ul>
  </li>
</ul>

You'll notice that under "Tips", the recurse tag pulls up "Movable Type", similar to how "News" worked earlier. But when this category is the "current" category, it will again pull up the recurse tag, now at the next "level" down in the category listing. This next level down generates the list for those sub-categories: "Plugins", "Styles" and "Templates". The structure is all the same - pulled from the top-level. It just runs it over and over again as needed for all of the sub-categories.

Customizing the Category Listing

Not Showing Categories without Entries The default code will display the name of all of your categories, whether or not you have entries in them. If you want to display only those categories which currently have entries, you need to remove the <MTElse> condition from the equation. Your resulting code would be something like this:

<MTTopLevelCategories>
<MTSubCatIsFirst>    <ul>    </MTSubCatIsFirst>
<MTIfNonZero tag="MTCategoryCount">
<li><a href="<$MTCategoryArchiveLink$>" title="<$MTCategoryDescription$>"><MTCategoryLabel></a>
</MTIfNonZero>
<MTSubCatsRecurse>
</li>
<MTSubCatIsLast>    </ul>    </MTSubCatIsLast>
</MTTopLevelCategories>

Note that if you have a top level category that is empty, but contains sub-categories that have items, removing this piece of code will create an unusual display as those sub-categories will be placed in the same list as the prior category. This is because the <MTCategoryCount> tag doesn't include the count of sub-category items beneath the current category.

If you use sub-categories and you do not want to show sub-categories or top level categories unless they contain items, one method you can use is to install the SubCatCount plugin. With this plugin installed, your code would look like this:

<MTTopLevelCategories>
<MTSubCatIsFirst>    <ul>    </MTSubCatIsFirst>
<MTIfNonZero tag="MTSubCatCount">
<li>    <a href="<$MTCategoryArchiveLink$>" title="<$MTCategoryDescription$>"> <MTCategoryLabel> </a>
<MTElse>
<li>    <MTCategoryLabel>
</MTElse>
</MTIfNonZero>
<MTSubCatsRecurse>
</li>
<MTSubCatIsLast>    </ul>    </MTSubCatIsLast>
</MTTopLevelCategories>

Limiting the levels of sub-categories displayed

If you have several levels of sub-categories, you may want to limit the display of them in your Category List to only a few levels. To do this add a max_depth attribute to the recurse tag like so:

<MTSubCatsRecurse max_depth="3">

Not Showing sub-categories

To show only primary categories, and not sub-categories in your listing, remove the <MTSubCatsRecurse> tag from the code entirely. This is not the same as max_depth="1". That will include the top-level categories and the first level of sub-categories.

Adding an Entry Count

To add the the number of entries in parentheses after each category or sub-category label, you would use the <MTCategoryCount> template tag. Something like this displays the added code at the end of the link to the category archive page:

<li><a href="<$MTCategoryArchiveLink$>" title="<$MTCategoryDescription$>"><MTCategoryLabel></a> (<MTCategoryCount>)

If you wanted to instead display the sub-category count at that point, you should use <MTSubCatCount> instead of <MTCategoryCount>, as mentioned previously, by installing the SubCatCount plugin.

Displaying Categories in a Custom Order

This tip comes in from an LMT reader. To come up with your own custom order of categories or subcategories, without the use of a plugin, do the following:

a. Name the categories 1, 2, 3 ... in the order you want them to appear. b. Use the description field for the name of the category. c. Replace MTCategoryLabel with MTCategoryDescription in your category display code.

Many thanks to Hugo Paulissen for this last tip.