The application will manage an archive of discussion papers, including abstracts, BibTeX citations, and supplemental data files.  I need to store uploaded files and provide links to download them from the application.

Retooling for IC::FS included subclassing IC::FS to tune its operation for my needs and writing my own utility method to serve up the files instead of using Static::Simple.  IC::FS uses UUIDs for filenames in the filesystem and I want the original filenames in the URLs in the application.  Serving up files directly isn’t difficult so I wrote my own Catalyst controller method, cribbing code from Static::Simple:

sub send_file : Private
{
    my ($self, $c, $file, $filename) = @_;

    my $type;
    my $stat = $file->stat;

    # Get MIME Type - swiped from Static::Simple
    if ( $filename =~ /.*\.(\S{1,})$/xms )
    {
        my $ext = $1;
        my $types = MIME::Types->new(only_complete => 1);
        $type = $types->mimeTypeOf($ext);
    }
    else
    {
        # Don't know type, so punt
        $type = 'text/plain';
    }

    $c->res->headers->content_type($type);
    $c->res->headers->content_length($stat->size);
    $c->res->headers->last_modified($stat->mtime);
    $c->res->headers->header("Content-Disposition" =>
                             "filename=\"$filename\"");

    # More code swiped from Static::Simple
    if ( Catalyst->VERSION le '5.33' )
    {
        # old File::Slurp method
        my $content = File::Slurp::read_file( $file );
        $c->res->body( $content );
    }
    else
    {
        # new method, pass an IO::File object to body
        my $fh = $file->openr;
        if ( defined $fh )
        {
            binmode $fh;
            $c->res->body( $fh );
        }
        else
        {
            Catalyst::Exception->throw(
                                       message => "Unable to open $file for reading" );
        }
    }
    return 1;
}

I didn’t know about DBIx::Class::InflateColumn::File at the time, so I wrote my own system using Catalyst::Model::File to store the uploaded files.  It was a mild pain in the ass to deal with the files separately from the DB model, but it worked and got the job done.

Lately, I’ve been working on another application that requires uploading and storing files:  a discussion paper archive and search system for the Department of Statistical Science at Duke University.  Again, I was struggling with using Catalyst::Model::File to store the uploaded manuscripts and associated data files.  I don’t like using C::M::File because it breaks the model paradigm.  I’d rather put all the data for each discussion paper in the DBIx::Class based DB model I built.  I’m thinking of writing some command line utility scripts for the archive and using C::M::File binds me to Catalyst in ways I don’t want.  So I went looking.

I saw discussion of DBIx::Class::InflateColumn::FS on the Catalyst mailing list and started investigating it.  Then I found DBIx::Class::InflateColumn::File.  Both provide the filesystem-based storage of files tied into my DB model I need, but I’m going to use InflateColumn::File.  It fits my needs better and lets me serve up the files using Static::Simple in a straightforward manner.

I love the CPAN!  It gave me not one, but two!, good alternatives to Catalyst::Model::File, and I don’t have to write it.   I only wish I’d noticed InflateColumn::File last year.