MT::Import::Base - base class for importing "stuff" into Movable Type.

 package MT::Import::Fubar;
 use base qw (MT::Import::Fubar);

# -*-cperl-*-

use strict;
package MT::Import::Base;

$MT::Import::Base::VERSION = '1.01';

use Date::Parse;
use Date::Format;

use File::Path;
use File::Spec;

use Log::Dispatch;
use Log::Dispatch::Screen;

sub new {
        my $pkg  = shift;
        
        my $self = bless {}, $pkg;

        if (! $self->init(@_)) {
                return undef;
        }

        return $self;
}

sub init {
        my $self = shift;
        my $opts = shift;

        if (UNIVERSAL::isa($opts,"Config::Simple")) {
                $self->{cfg} = $opts;
        }
        
        else {
                my $cfg  = undef;
                
                eval {
                        $cfg = Config::Simple->new($opts);
                };
                
                if ($@) {
                        warn "$opts : $@";
                        return 0;
                }

                $self->{cfg} = $cfg;
        }
        
        #
        
        my $root = $self->{cfg}->param("mt.root");

        if (! -d $root) {
                warn "MT root ($root) is not a directory";
                return 0;
        }
        
        my $blog_id = $self->{cfg}->param("mt.blog_id");

        if (($blog_id !~ /^\d+$/) || ($blog_id < 1)) {
                warn "Blog ID ($blog_id) is not a positive integer";
                return 0;
        }

        my $blog_owner = $self->{cfg}->param("mt.blog_ownerid");

        if (($blog_owner !~ /^\d+$/) || ($blog_owner < 1)) {
                warn "Blog owner ID ($blog_owner) is not a positive integer";
                return 0;
        }

        #

        push @INC, File::Spec->catdir($root,"lib");
        push @INC, File::Spec->catdir($root,"extlib");

        eval {
                require MT;
                require MT::App::CMS;
                
                require MT::Entry;
                require MT::Author;
                require MT::Category;
                require MT::Permission;
                require MT::Placement;
                require MT::TBPing;
                require MT::Trackback;
                
                MT::Author->import(":constants");
        };
        
        if ($@) {
                warn "Failed to load a MT dependency, $@";
                return 0;
        }

        #

        my $app = MT::App::CMS->new(Config    => File::Spec->catfile($root,"mt.cfg"),
                                    Directory => $root);
    
        if (! $app) {
                warn "Failed to create MT application object, ".MT::App::CMS->errstr;
                return 0;
        }
        
        $self->{'__app'} = $app;
        
        #

        my $log_fmt = sub {
                my %args = @_;
                
                my $msg = $args{'message'};
                chomp $msg;
                
                my ($ln,$sub) = (caller(4))[2,3];
                $sub =~ s/.*:://;
                
                return sprintf("[%s][%s, ln%d] %s\n",
                               $args{'level'},$sub,$ln,$msg);
        };
        
        my $logger = Log::Dispatch->new(callbacks=>$log_fmt);
        my $error  = Log::Dispatch::Screen->new(name      => '__error',
                                                min_level => 'error',
                                                stderr    => 1);

        $logger->add($error);
        $self->{'__logger'} = $logger;

        $self->verbose($self->{cfg}->param("importer.verbose"));

        #
        
        $self->{'__imported'}  = [];

        #

        return 1;
}

sub verbose {
    my $self = shift;
    my $bool = shift;

    #

    if (defined($bool)) {

	$self->log()->remove('__verbose');

	if ($bool) {
	    my $stdout = Log::Dispatch::Screen->new(name      => '__verbose',
						    min_level => 'debug');
	    $self->log()->add($stdout);
	}
    }

    #

    return $self->log()->would_log('debug');
}

sub log {
    my $self = shift;
    return $self->{'__logger'};
}

sub imported {
        my $self = shift;
        my $id   = shift;
        
        if (! $id) {
                return (wantarray) ? @{$self->{'__imported'}} : $self->{'__imported'};
        }
        
        if (grep /^$id$/,@{$self->{'__imported'}}) {
                return 1;
        }
        
        push @{$self->{'__imported'}},$id;
        return 1;
}

sub rebuild {
        my $self = shift;
        
        foreach my $id ($self->imported()) {
                $self->rebuild_entry($id);
        }
        
        #
        
        $self->rebuild_indexes();
        return 1;
}

sub rebuild_indexes {
        my $self = shift;
        $self->{'__app'}->rebuild_indexes(BlogID => $self->blog_id());
        return 1;
}

sub rebuild_entry {
        my $self = shift;
        my $id   = shift;
        
        my $entry = MT::Entry->load($id);
        my $next  = undef;
        my $prev  = undef;
        
        if ($next = $entry->next()) {
                $next = $next->id();
                
                $self->imported($next);
        }
        
        if ($prev = $entry->previous()) {
                $prev = $prev->id();
                $self->imported($prev);
        }
        
        my $ok = $self->{'__app'}->rebuild_entry(Entry             => $id,
                                                 BuildDependencies => 0,
                                                 OldPrevious       => $next,
                                                 OldNext           => $prev);

        #
        
        if (! $ok) {
                $self->log()->error("failed to rebuild entry '$id', $!");
                return 0;
        }
        
        $self->log()->info(sprintf("rebuilt entry %d (%s)\n",$id,$entry->title()));
        return 1;
}

sub mk_category {
        my $self    = shift;
        my $label   = shift;
        my $parent  = shift;
        my $auth_id = shift;
        
        #
        
        $label =~ s/^\s+//;
        $label =~ s/\s+$//;
        
        $self->log()->debug("make category $label for ($parent)");

        my $cat = MT::Category->load({label   => $label,
                                      parent  => $parent,
                                      blog_id => $self->blog_id()});

        if (! $cat) {
                $cat = MT::Category->new();
                $cat->blog_id($self->blog_id());
                $cat->label($label);
                $cat->parent($parent);
                $cat->author_id($auth_id);
                
                if (! $cat->save()) {
                        $self->log()->error("failed to add category $label ($parent), $!");
                }
        }

        $self->log()->debug(sprintf("mk category '%s' (%s:%s)",$cat->label(),$cat->id(),$cat->parent()));
        return $cat;
}

sub mk_author {
        my $self  = shift;
        my $name  = shift;
        my $email = shift;

        $name =~ s/^\s+//;
        $name =~ s/\s+$//;
        $name = lc($name);

        my $author = MT::Author->load({name => $name,
                                       type => &MT::Author::AUTHOR()});
        
        if (! $author) {
                $author = MT::Author->new();
                $author->name($name);
                $author->email($email);
                $author->type(&MT::Author::AUTHOR);
                $author->set_password($self->{cfg}->param("mt.author_password"));
                $author->created_by($self->{cfg}->param("mt.blog_ownerid"));
                $author->type(1);
                
                if (! $author->save()) {
                        $self->log()->error("failed to add author $name, $!"); 
                }
        }

        my $pe = MT::Permission->load({blog_id   => $self->{cfg}->param("mt.blog_id"),
                                       author_id => $author->id()});
    
        if (! $pe) {
                $pe = MT::Permission->new();
                $pe->blog_id($self->{cfg}->param("mt.blog_id"));
                $pe->author_id($author->id());
                $pe->role_mask($self->{cfg}->param("mt.author_permissions"));
                $pe->save();
        }
    
        return $author;
}

sub place_category {
        my $self     = shift;
        my $entry    = shift;
        my $category = shift;
        my $primary  = shift;

        $primary ||= 0;

        $self->log()->debug(sprintf("place %s (%s) for %s",$category->label(),$category->id(),$entry->id()));

        my $pl = MT::Placement->load({entry_id    => $entry->id(),
                                      category_id => $category->id()});

        if ($pl) {
                $self->log()->debug("already placed with id");
                return $pl;
        }

        $pl = MT::Placement->new();
        $pl->entry_id($entry->id());
        $pl->blog_id($self->{cfg}->param("mt.blog_id"));
        $pl->is_primary($primary);
        $pl->category_id($category->id());
        
        if (! $pl->save()) {
                $self->log()->error(sprintf("can't save secondary placement for %s (%s), $!",
                                            $category->label(),$category->parent()));
        }

        return $pl;
}

sub mk_date {
        my $self = shift;
        my $str  = shift;
        my $time = str2time($str);
        my $dt   = time2str("%Y-%m-%d%H:%M:%S",$time);
        $dt      =~ s/(?:-|:)//g;
        return $dt;
}

sub upload_file {
        my $self = shift;
        my $fh   = shift;
        my $dest = shift;

        $self->log()->debug("upload file to $dest");

        seek($fh,0,0);

        my $blog  = MT::Blog->load($self->blog_id());
        my $fmgr  = $blog->file_mgr();
        my $bytes = $fmgr->put($fh,$dest,"upload");
        
        if (! $bytes) {
                $self->log()->error("failed to upload part to $dest, ".$fmgr->errstr());
                return 0;
        }

        return 1;
}

sub blog_id {
        my $self = shift;
        return $self->{cfg}->param("mt.blog_id");
}

sub purge {
        my $self = shift;
        my $blog = MT::Blog->load($self->blog_id());

        my @classes = qw(MT::Permission MT::Entry
                         MT::Category MT::Notification);

        foreach my $class (@classes) {
                eval "use $class;";
                my $iter = $class->load_iter({blog_id => $self->blog_id()});
                my @ids = ();
                
                # I'm not really sure why this needs to
                # happen this way (or, really, why it's
                # not black-boxed) but it's what MT::Blog
                # does so there you go...
                
                while (my $obj = $iter->()) {
                        push @ids, $obj->id;
                }
                
                for my $id (@ids) {
                        my $obj = $class->load($id);
                        print sprintf("%s remove %d\n",$class,$obj->id());
                        $obj->remove;
                }
        }
}

sub ping_for_reply {
        my $self  = shift;
        my $entry = shift;
        my $reply = shift;
        my $from  = shift;

        $self->log()->debug("reply is $reply");

        my $to_ping = MT::Entry->load({basename => $reply,
                                       blog_id  => $self->blog_id()});

        if (! $to_ping) {
                $self->log()->warning("can't locate entry for $reply");
                return 0;
        }

        $self->log()->debug("to ping : ".$to_ping->id());
                
        my $tb = MT::Trackback->load({entry_id=>$to_ping->id()});
        
        $self->log()->debug("tb is : ".$tb->id());
        
        if (! $tb) {
                $self->log()->warning("can't locate trackback entry for $reply");
                return 0;
        }
                        
        my $ping = MT::TBPing->new();
        $ping->blog_id($tb->blog_id());
        $ping->tb_id($tb->id());
        $ping->source_url($entry->permalink());
        $ping->ip($self->blog_id());
        $ping->visible(1);
        $ping->junk_status(0);
        
        $ping->title($entry->title());
        $ping->blog_name($from);
        
        if (! $ping->save()) {
                $self->log()->error("can not save ping, $!");
        }
        
        $self->log()->debug(sprintf("ping from %s to %s\n",
                                    $entry->permalink(),
                                    $to_ping->permalink()));
        
        my $blog = MT::Blog->load($ping->blog_id());
        $blog->touch();
        
        if (! $blog->save()) {
                # $self->log()->error();
        }
        
        $self->imported($to_ping->id());
        
        #
        
        my @pinged   = split("\n",$entry->pinged_urls());
        my $ping_url = $to_ping->permalink();
        
        if (! grep /^$ping_url$/,@pinged ) {
                push @pinged, $ping_url;
                $entry->pinged_urls(join "\n", @pinged);
                $entry->save();
        }
        
        $self->log()->debug(sprintf("pinged %d : %s\n",
                                    $entry->id(),
                                    join(";",split("\n",$entry->pinged_urls()))));
        
        return 1;
}

return 1;