Disclaimer: I absolutely do not advocate splogging of any kind. This is simply a way to get your existing data into a Wordpress blog. This same method could be used for chapters in book, recipes, or whatever other kind of data you may have. Rather than taking the monumental effort of manually creating a Wordpress site based on your work, you can use a little creativity to come up with a fast, easy solution that is surprisingly robust (this article creates a Wordpress blog website with over 31,000 posts).

I’m a big fan of native file formats – as they say, “when in rome”…. Yeah. Anyway, this is a quick article to illustrate how to set up Wordpress Import using an Excel spreadsheet. I’ll try to cover this from point A to point Z and even provide the download files and set up a sample URL so you can see the results.

The Wordpress 2.8 Import File screen lists fifteen different file formats including: Blogger, Blogroll, Blogware, Bunny’s Technorati Tags, Categories and Tags Converter, DotClear, GreyMatter, Jerome’s Keywords, LiveJournal, Movable Type and TypePad, RSS, Simple Tagging, Textpattern, Ultimate, and WordPress. I would be lying if I claimed to know what any of these formats actually are, so I’m going to go the easy route and export a file and use it as a template.

The Wordpress export file saves out as a .wxr file. This format is called the WordPress eXtended RSS file format and contains posts, pages, comments, custom fields, categories, and tags. After performing a Wordpress Blog Export from another blog, I can see that what I’m primarily concerned with is the “item” section which corresponds to a post. I’ll chop out the “item” section and save it as its own file. This will be a template that I’ll use later on from VBA. (I cut a couple elements from the bottom as well which I doubted were required by the schema – flying fast and loose on this one. You’d want to make sure your file conforms with any applicable XSD or DTD, but I’m fairly confident this will work.)

I’m inserting some placeholders in the template sample Wordpress Import file. These placeholders will be search and replaced as we create the actual import file(s). Here is the XML snippet of the template and here is the file available to download (coming soon).

<item>
    <title>[propertitle]</title>
    <link>[link]</link>
    <pubDate>Fri, 12 Jun 2009</pubDate>
    <dc:creator><![CDATA[admin]]></dc:creator>
    <category><![CDATA[[category]]]></category>
    <category domain=”category” nicename=”[category]“><![CDATA[[category]]]></category>
    <guid isPermaLink=”false”>http://www.biblewack.com/[testament]/[category]/[hyphen]/</guid>
    <description></description>
    <content:encoded><![CDATA[[content]
<p align=”center”><span style=”font-size: x-small;”>
<a title=”[backtitle]” href=”[backlink]“>&lt;&lt; [backtitle]</a> || <a title=”[nexttitle]” href=”[nextlink]“>[nexttitle] &gt;&gt;</a></span>
]]>
    </content:encoded>
    <excerpt:encoded><![CDATA[[content]]]></excerpt:encoded>
    <wp:post_id>[postid]</wp:post_id>
    <wp:post_date>2009-06-12</wp:post_date>
    <wp:post_date_gmt>2009-06-12</wp:post_date_gmt>
    <wp:comment_status>open</wp:comment_status>
    <wp:ping_status>open</wp:ping_status>
    <wp:post_name>[hyphen]</wp:post_name>
    <wp:status>publish</wp:status>
    <wp:post_parent>0</wp:post_parent>
    <wp:menu_order>0</wp:menu_order>
    <wp:post_type>post</wp:post_type>
    <wp:post_password></wp:post_password>
</item>

Programming the Wordpress Upload

So, I wanted to create a big Wordpress site for this example – really big. I struggled to think of what kind of freely diseminable data I could come up with to create a massive Wordpress Import sample. I found a good source of data with the Bible. Free to distribute and in nice text file format. Each line numbered (think “unique identifier”) and each line with a hard return after it. A perfect data structure for import into Excel (and eventual import into Wordpress). I’ll digress from the Wordpress Import briefly to illustrate how I sliced and diced the data to get it ready.

1. Import into Excel without delimiters. 1 column
2. Chop out Line Numbers with For-Next Loop and instr(function). 2 columns
3. Derive Chapter Name with Lookup function on alpha characters in previously created column. 3 columns
4. Assign Old Testament or New Testament with manual drag in Excel. 4 columns
5. Figure out what the URLs will be and make URL column. 5 columns

The reason I wanted to figure out the absolute URL for each post is I wanted to include “back” and “next” links in the body of each post so one could traverse throughout the entire book from post to post. This is accomplished simply by looking at the previous row (x-1) and the next row (x+1) while executing the loop.

Here is the entirety of the routine to create the .wrx Import file. You may need to split your file up differently depending on your import limits. You can easily do this by saving out a file every XXXX-th time or whatever you need. The code is very simple to understand. I loop through every data row in the spreadsheet (31102 rows and a header). Variables are assigned to the cell string values. A string variable “S” is assigned the result of our Text2String function. As I’m thinking about it now in retrospect, rather than call that code every time – you could just call it initially and create S once. Then you could assign another variable to the value of S every time rather than going through the readfile process, much more efficient…..Oh well… Lastly, I append the contents of S into a file using Print.

Sub makeWordpressImportFile()

Next x
End Sub

Finally, if you’ve been paying attention, you’ll know that we haven’t yet created a well formed XML file – there is no root node. We’ve essentially concatenated together a bunch of nodes, but there is no root. I doubt very seriously this would import into anything. You could write something to open each file and paste in the root node and matching end node – or you can manually open and save your files out. I chose the latter as I didn’t have many files to work with. I used the following as my root node:

<rss version=”2.0″
    xmlns:excerpt=”http://wordpress.org/export/1.0/excerpt/”
    xmlns:content=”http://purl.org/rss/1.0/modules/content/”
    xmlns:wfw=”http://wellformedweb.org/CommentAPI/”
    xmlns:dc=”http://purl.org/dc/elements/1.1/”
    xmlns:wp=”http://wordpress.org/export/1.0/”
>

…and obviously my closing node was simply “</rss>” which indicated the end of file. Once you have your file(s), all you need to do is import it and Wordpress will handle the rest. The categories will be created and the posts will be created. You could obviously fine tune this by working with the dates – future dating posts does work (you can make it look like you’re working when you’re really not!). The sample site that I created is at www.biblewack.com (very hard finding an available URL with “bible” in the title). Good luck.

Text File to String Variable Function (xml file to string variable, html file to string variable)

There are numerous Internet Programming situations where large pieces of text need to be populated with variable values. On other occasions the task could be parsing html files to retrieve SEO information. Yet another common situation is working with XML as a string inside VB. The Microsoft XML objects consume a lot of memory. Sometimes it is more efficient to work with XML as a string instead of consuming the overhead necessary to create XMLHTTP or MSXML objects.

You can also use a xml file as a template for SOAP calls. Simply retrieve the xml as a string, populate some predefined placeholder text and you are ready to call inline webservices. As you’ll see, turning text into a string is easy – it doesn’t matter whether it is xml to string or html to string either.

The TextToString Function

The function below is short and relatively straightforward – feel free to customize it to suit your individual needs. It contains some rudimentary error trapping, but it should be enough to catch common errors and display enough information for easy troubleshooting.

The function contains two variables: the strPath variable is the argument parameter that will contain the absolute path to the file. You may want to implement file extension validation if your project requires a little more ‘tightness’ in the code. strBuff acts as a temporary buffer to hold the results until they can be assigned back to the function’s result.

also called:
Public Function XMLToString(strPath As String) As String
Public Function HTMLToString(strPath As String) As String

Public Function TextToString(strPath As String) As String
    Dim strBuff As String
    On Error GoTo ErrTrap
  
    Open strPath For Binary As #1
    strBuff = Space(LOF(1))
    Get #1, , strBuff
    TextToString = strBuff
    Close #1
ErrTrap:
   If Err Then Err.Raise Err.Number, , “Error from Functions.TextToString ” & Err.Description
End Function

In a later project, we’ll be combining this Text to String Function with the Loop Through Directory routine in order to build content for a Wordpress blog. We’ll examine how to create upload files by manipulating data in Excel.

Wise Man Say, Don’t Run Your Head Against a Stone Wall

For doing ad hoc work around the office, VBA allows you to do things that applications alone simply aren’t powerful enough to do. It seems like I’m always running into a situation where I need to get information about a bunch of files in a directory. Let’s say that you just need to retrieve the names of all files in a certain directory and write them to a column in an Excel spreadsheet.

Unfortunately, Excel doesn’t provide a native way to accomplish such a task. However, the task is reduced to less than 15 lines of code using VBA. The VBA Dir Function is great for iterating over a directory.

Understanding the Dir Function

This function returns a String value containing the name of a file, directory, or folder that matches a specified pattern or file attribute. If you’re working at the root level of a file structure, the Dir function will also return the volume label of a drive.

Dir returns the first file name that matches pathname parameter. The trick to looping through a directory is that calling Dir with no arguments returns any additional file names that match pathname. You can see an example of this in the code snippet below: the line with the comment, “get next entry” is where the Dir function will retrieve the next matching filename.

When Dir can no longer return a match, it returns a zero-length string (”"). If a zero-length string is returned, either a new pathname must be passed or an error occurs. You can change to a new pathname without retrieving all of the file names that match the current pathname.

NOTE: Do not nest Dir loops and don’t attempt to call the Dir function recursively. Calling Dir with the vbDirectory attribute does not continually return subdirectories. If you think you need to recurse directories, first consider whether you can copy the results of a simple Windows Search to a new directory to achieve your desired results.

Looping Over Files with Dir, Looping Through Files, Looping Through Directories…

The following VB code snippet is pretty easy to understand. There are three variables: strPath, strFile and x. strPath is used to pass the initial parameter to the Dir function. This simply tells Dir which directory to traverse. strFile is used to hold the file name as the code executes and continues to retrieve file names. x is used simply as a counter so that the correct cell in the Excel spreadsheet is updated with the correct filename (Dir doesn’t return files in any specific order, so you may need to sort them afterward).

Sub LoopThruDirectory()
   
Dim strPath As String
Dim strFile As String
Dim x As Integer

    strPath = “C:\temp\datajunction\XMLOUT\”
    strFile = Dir(strPath)
       
    Do While strFile <> “”
        x = x + 1
        Sheet1.Cells(x, 1) = strFile
        strFile = Dir    ‘ Get next entry.
    Loop
   
End Sub

Wise Man Says, “A Bird in Hand is Worth Two in Bush”

At the outset, the templates were created by an advanced business user. The templates were originally created merely as shortcuts to create business documentation. However, they incidentally gathered a great deal of foundational business data, such as customer information and transaction terms.
Users quickly became frustrated by having to enter data into two systems: (1) the Word templates, and (2) the central database application.

The IT department was faced with a dilemma; they needed to begin maintaining the templates and enhance their functionality to either pull information from the database, or feed the database directly from the VBA templates. A quick review of the templates found that they didn’t meet any of the internal application guidelines. They weren’t even signed and required users to have their security set to “low” in order to run.
This was clearly an example where a professional development environment (and some forethought) could have prevented a costly project.

Sidenote:
With the development of information technology, most of the people started using computers and software for managing their data. Different software tools are available in market to perform specific tasks, like if you are a tax consultant then defiantly you should have tax software.

Procedurally, the information was typed into a Word document and passed through the various channels until “the deal” was either approved or rejected. In the case of an approval, all of the information was then retrieved from the Word document and manually entered into the backend database solution.

The project, as originally conceived, was to write a complex application to parse the Word document, extract the appropriate data and populate the database accordingly. We discussed this solution at length and recommended a “Document Assembly” approach to the business as an alternative. Unstructured Word documents were simply to difficult to parse in a reliable fashion. However, we could let the users enter the data in a very long series of conditional UserForms. The data would be collected and when complete, a document (the original write-up) would be created to memorialize the transaction and receive the appropriate signatures. Once the data was complete, it was a simple manner of transferring said data to the backend database and the need for an entire department was eliminated. The original solution was driven by VBA and designed as a Word template (you can find the original (with trade secret and proprietary data omitted) at http:///www.docbuilder.com/downloads/Sample Large Template.zip). This was in 1997.

Note:

A lot of work is undergoing in website design and development. If you are planning to develop web site and looking for web development agency then you don’t need to wait, simply go online and search for web design consulting.

Basically, if the institution purchased enough of a particular mutual fund they would meet what is called a “right of accumulation” threshold and they’d be entitled to a refund. There were several other components of the calculation including the amount of transactions in a given time period, various legal aspects and total fees paid by the institutional client.

Although the data was always present, the process had long been a tedious manual process that was strictly linear to the number of clients they had. The more business they generated, the more people they were required to hire to process these calculations.

There were also the obvious inefficiencies involving manual calculations, training, lack of productivity, etc. These calculations were complicated and involved several different financial aspects – all of which users relied on MS Excel to calculate. The project was initially conceived as a web project, but that required the development team to write (from scratch) the financial calculations that Excel already provided. After much discussion, we agreed to write a VSTO Excel solution.

This is a classic example of a problem that needs a VSTO solution:

•  Excel already contained the necessary formulas.
•  The end users were familiar and comfortable working with Excel.
•  VSTO allowed a more rapid development environment than starting from scratch.
•  Existing logic and formulas could be easily re-used in the solution.

Download here: Visual Basic 6.0 MazeMan

Here’s a snippet of a form.

VERSION 5.00
Begin VB.Form frmAbout
   Caption         =   “About MazeMan v. 1.0″
   ClientHeight    =   3195
   ClientLeft      =   60
   ClientTop       =   345
   ClientWidth     =   4680
   LinkTopic       =   “Form1″
   MaxButton       =   0   ‘False
   MinButton       =   0   ‘False
   ScaleHeight     =   3195
   ScaleWidth      =   4680
   StartUpPosition =   3  ‘Windows Default
   Begin VB.CommandButton cmdClose
      Caption         =   “Close”
      Height          =   375
      Left            =   3000
      TabIndex        =   2
      Top             =   2640
      Width           =   1335
   End
   Begin VB.Label lblCompany
      Caption         =   “Company”
      Height          =   495
      Left            =   480
      TabIndex        =   1
      Top             =   960
      Width           =   3015
   End
   Begin VB.Label lblTitle
      Caption         =   “Title”
      Height          =   375
      Left            =   480
      TabIndex        =   0
      Top             =   240
      Width           =   2895
   End
End
Attribute VB_Name = “frmAbout”
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = False
Attribute VB_PredeclaredId = True
Attribute VB_Exposed = False
Option Explicit

Private Sub cmdClose_Click()
Unload Me
End Sub

Private Sub Form_Load()
Me.lblTitle.Caption = App.Title
Me.lblCompany.Caption = App.CompanyName
End Sub

Syntax Errors

Let’s start with the easiest type of program error to deal with, the syntax error. A syntax error occurs when your code is written improperly. An example would be a misspelled or missing variable or keyword:

Dim strName as

Obviously, an essential piece of code is missing in the statement: the data type. A correct statement would read:

Dim strName as String

The key to eliminating syntax errors is to use the Option Explicit statement in every module. Option Explicit will require that all variables are explicitly declared in your project. Explicitly declaring your variables is important for ­several reasons. Simple misspellings in a variable name can cause unwanted behavior and data loss. When working with databases, corrupt data can be entered without any error ever being generated.

Note:

VBA treats a misspelled variable as just another variable. For example,
lPayment  = 7,224.45

Me.txtBalance.Value = lPaymint

The variable lPayment on the second line is misspelled. VBA won’t recognize the misspelling if Option Explicit isn’t turned on, and it will assume that you want it to create a new variable (variant by default). As a result the text box will be updated with an Empty value instead of the desired value of $7,224.45.

Another important reason to use explicit variable declaration is to optimize your project. By default, undeclared variables use the variant data type. This data type may use significantly more memory than you intend for the variable’s purpose. For example, you may want to use a byte variable in your code. Bytes occupy 1 byte of memory space. If you didn’t explicitly declare the variable, it would be initialized as a variant even though it would only hold 1 byte of data. This means that you’d be using up 16 times the memory you actually need.

Remember, you can also use the VBE to force variable declaration. Simply select Tools | Options and go to the Editor tab. Once you’re there you can turn Require Variable Declaration on. This will insert Option Explicit at the top of each new module; however, it will not update your existing modules. Go back into your project and insert Option Explicit in any modules you have previously created.

Note:

VBA doesn’t allow the same degree of customization as VB as far as compiler settings are concerned. However, there are still some optimizations available. In the VBE, select Tools | Options and go to the General tab. Here you will find a Compile On Demand option. If this is checked, your project should run faster because modules will not be compiled until they are loaded for execution.

Also on the General tab is a Background Compile option. This option allows the computer to compile your project in the background while the computer is idle. Selecting the Background Compile option can slightly improve the run-time speed of your project (Compile On Demand must also be enabled to use this feature).

Caution:

As a final measure of caution, you should always compile your project before it is distributed. This will ensure that all syntax errors have been found. A frequent problem is that your code will refer to a control on a form that has been deleted. If you don’t compile the program ahead of time, you’ll be running to desktops and moving your program’s execution point to the next line of code, or worse, you’ll be the author of the dreaded “AllUser” e-mail informing people there is a problem and instructing them to stay out of the template, document, spreadsheet, or whatever. The process is very simple; just go to the Debug menu and choose Compile Project.

Logic Errors

Logic errors occur when your code doesn’t respond the way you intended. Perhaps your logic is unsound, or the program may flow in a different manner than you intended. The best way to check these errors is to manually step through your code using Watch windows. This can be especially tricky when using a series of UserForms—make sure you understand the call stack.

Tip:

If you are using a series of UserForms, do not place any code after you call the Show method of the next UserForm. Your program’s execution will always resolve back through the call stack and could produce unexpected results.

Run-Time Errors

You cannot avoid run-time errors. However, you can plan for them. Planning for run-time errors involves developing an error handler. The Developer’s Edition of Office 2000 includes a VBA Error Handler add-in that makes working with your error handler easier. Although, we’ll briefly discuss this add-in toward the end of the chapter, we’ll assume you are working in the normal Office environment and discuss how you can implement error handling without this add-in.

]]>