A File-Uploading Windows Script Component
By Andy Smith
Introduction
Probably one of the most asked question on the ASP Messageboard
is how to upload files from a Web form. Usually, the answer is simple: "Buy or Download a component."
Unfortunately, not everybody can use 3rd party components on their server, especially those
in hosted environments. I was once one of those people. Additionally, those components are oftentimes
not very affordable for someone who works with ASP as a hobby. (For a listing of third-party
upload components, be sure to check out the Uploading
Article Index!)
After having promised a client that I could give them a Web-based file upload, and then finding out I couldn't register a component on the server, I started sweating, imagining many future late nights at work trying to solve this horrible issue.
Then I found a wonderful article on ASPToday.com - Uploading with ASP and VBScript - that solved the problem with a couple functions. Voila! After using it for that client, I came to realize that, while the solution provided there was functional, it wasn't very user friendly. About the same time, I started getting interested in the usefulness of Windows Script Components as a replacement for the inability to register compiled components. (If you are unfamiliar with Windows Script Components be sure to read: Building Windows Script Components!) Naturally, I decided to whip myself up a nicely object oriented, encapsulated and compatible version of the File Upload function I had been using.
The Gist Of It
The whole thing breaks down into three objects, all packaged together into one file.
-
The
FileUp
objectThis serves as a compatibility layer between my object and the normal ASP Request object. It has properties and methods that span my Form Request object as well as the other intrinsic Request objects. It also has routines for setting defaults for the object. It's default property is
Item
, which gives compatibility with the ASP Request
object.
The Form
object
This one does all the real magic of parsing the Post and giving access to the items. This
object essentially takes the place of the Form object in the normal Request. The default
property for it is Item
, which gives compatibility with the ASP Request.Form
object
The UploadControl
object
Each item is stored in one of these, and is accessed by the Form object's default Item
property. The default Value property returns the value of normal form fields, and the
filename of file fields.
Using the object is almost exactly the same as using the normal ASP request object. Here's
some sample code that you would use in your page to test if the page had been submitted by
testing the value of the submit
control, and then writing out a couple of the
values as well as saving the file to the current folder.
|
FileUp
ObjectWhen you create the
FileUp
object, a few things happen. First, it checks to see
if it should do anything at all with the line:
|
This checks to make sure that the form that posted to the page used the encoding type that
is need to send files at all. If it wasn't used, then all requests made to the FileUp
object will be directly forwarded to the ASP Request object.
Assuming that the proper enctype
is found, then a new Form
object is
created and is told to parse and populate itself with these lines:
|
The CreateComponent
function is a VBScript function used for WSC's to reference
other Components in the WSC Package. Build, tells the object to parse the Post
,
and the last 2 set default behavior for File Saving operations.
Next a dummy, empty Form
object is also created to allow for people trying to
access nonexistent items in the request in the same way they can use the ASP Request object.
This object has only one UploadControl
in it, named "empty" and that is what is
always returned when no item can be found that matches what the page asks for. It's created
exactly the same as the real object, except that the line:
objEmpty.BuildEmpty = True
|
is set before it's Build
method is called.
The default Item
property gives the compatibility with ASP Request. It allows the
client to reference items with the Request("itemName")
syntax, and it still
searches the Request in the same order as ASP would. It does this with code like:
|
You can also use the Request.Form("itemName")
syntax thanks to the Form
property. It searches either itself, or the intrinsic Form object, depending on the enctype
of the Post, which was found earlier.
Two new properties are OverWrite
and SavePath
. These two do what
you probably think they do. They tell each UploadControl
what to do when
.Save
or .SaveAs
is called on a file object. Setting OverWrite
to true allows files to be overwritten without an error. SavePath
, which defaults
to the folder which the script is running in, tells the UploadControls
where to
save files to. They do this by calling the Form
object's SetOverWriteFiles
and SetSavePath
methods.
This concludes our examination of the FileUp
object. In
Part 2 we'll take a close look at the Form
and UploadControl
objects!