root/lang/perl/plagger/lib/Plagger/Plugin/Publish/Pookmark.pm

package Plagger::Plugin::Publish::Pookmark;
use strict;
use base qw( Plagger::Plugin );

use Encode;
use Time::HiRes qw(sleep);
use URI;
use Plagger::Mechanize;

sub register {
    my($self, $context) = @_;
    $context->register_hook(
        $self,
        'publish.entry' => \&add_entry,
        'publish.init'  => \&initialize,
    );
}

sub initialize {
    my $self = shift;
    unless ($self->{mech}) {
        my $mech = Plagger::Mechanize->new;
        $mech->agent_alias('Windows IE 6');
        $mech->quiet(1);
        $self->{mech} = $mech;
    }
    $self->login_pookmark;
}


sub add_entry {
    my ($self, $context, $args) = @_;

    my @tags = @{$args->{entry}->tags};
    my $tag_string = @tags ? join(' ', @tags) : '';

    my $summary;
    if ($self->conf->{post_body}) {
        $summary = encode('utf-8', $args->{entry}->body_text); # xxx should be summary
    }

    if ($self->conf->{default_later}) {
        my $uri = URI->new('http://pookmark.jp/later');
        $uri->query_form(
            url   => $args->{entry}->link,
            title => encode('utf-8', $args->{entry}->title),
        );
        my $res = eval { $self->{mech}->get($uri->as_string) };
        if ($res && $res->is_success) {
           $context->log(info => "Post entry success.");
        } else {
           $context->log(info => "fail to bookmark HTTP Status: " . $res->code);
        }
    } else {
        my $uri = URI->new('http://pookmark.jp/post');
        $uri->query_form(
            url   => $args->{entry}->link,
            title => encode('utf-8', $args->{entry}->title),
        );
        my $res = eval { $self->{mech}->get($uri->as_string) };
        if ($res && $res->is_success) {
            eval {
                my $post_form = $self->{mech}->form_number(2);
                my $no_twitter = $post_form->find_input('no_twitter');
                $no_twitter->value('on') if $no_twitter && $self->conf->{default_no_twitter};
                $self->{mech}->submit_form(
                    form_number => 2,
                    fields => {
                        url     => $args->{entry}->link,
                        title   => encode('utf-8', $args->{entry}->title),
                        comment => $summary,
                        tags    => encode('utf-8', $tag_string),
                        private => ($self->conf->{default_private} ? 'on' : 'off'),
                    }
                )
            };
            if ($@) {
               $context->log(info => "can't submit: " . $args->{entry}->link);
            } else {
                $context->log(info => "Post entry success.");
            }
        } else {
           $context->log(info => "fail to bookmark HTTP Status: " . $res->code);
        }
    }
 
    my $sleeping_time = $self->conf->{interval} || 3;
    $context->log(info => "sleep $sleeping_time.");
    sleep( $sleeping_time );
}

sub login_pookmark {
    my $self = shift;
    unless ($self->conf->{jugemkey_id} && $self->conf->{password}) {
        Plagger->context->log(error => 'set your jugemkey_id and password before login.');
    }
    my $uri = URI->new('http://pookmark.jp/ajax/login');
    $uri->query_form(
        username => $self->conf->{jugemkey_id},
        password => $self->conf->{password},
    );
    my $res = $self->{mech}->get($uri->as_string);
        return $res ? $res->content eq '1' : 0;
}

1;

__END__

=head1 NAME

Plagger::Plugin::Publish::Pookmark - Post to POOKMARK Airlines automatically

=head1 SYNOPSIS

  - module: Publish::Pookmark
    config:
      jugemkey_id: your-jugemkey-id
      password: your-password
      interval: 2
      post_body: 1
      default_no_twitter: 0
      default_private: 0

=head1 DESCRIPTION

This plugin automatically posts feed updates to POOKMARK Airlines
L<http://pookmark.jp/>. It supports automatic tagging as well. It
might be handy for synchronizing delicious feeds into pookmark.

=head1 AUTHOR

Yasuhiro Matsumoto

=head1 SEE ALSO

L<Plagger>, L<Plagger::Plugin::Publish::LivedoorClip>, L<Plagger::Mechanize>

=cut