Grep/Action/Fetch.pm

use strict;
use warnings;

=head1 NAME

Grep::Action::Fetch

=cut

package Grep::Action::Fetch;
use base qw/Grep::Action Jifty::Action/;

use XML::Feed;

use Data::Dump qw/dump/;

use Jifty::Param::Schema;
use Jifty::Action schema {

        param q =>
                type is 'text',
                label is 'Search for',
                hint is 'enter few words to search for';

        param feed =>
                label is 'From feed',
                render as 'select',
                available are defer {
                        my $feeds = Grep::Model::FeedCollection->new;
                        $feeds->order_by({ column => 'title', order => 'ASC' });
                        $feeds->unlimit;
                        warn "feeds ", $feeds->build_select_query;
                        [{
                                display_from => 'title',
                                value_from => 'id',
                                collection => $feeds,
                        }];
                };

};

=head2 take_action

=cut

sub take_action {
    my $self = shift;
    
    # Custom action code

        my $feed = Grep::Model::Feed->new();
        my $feed_id = $self->argument_value('feed');

        if (! $feed_id) {
                $self->result->message("Need feed ID");
                return 0;
        }

        $feed->load_by_cols( id => $feed_id );

        if (! $feed->id) {
        $self->result->message("Can't fetch feed $feed_id");
                return 0;
        }

        my $uri = $feed->uri;
        if ($uri =~ m/%s/) {
                $uri = sprintf( $uri, $self->argument_value('q') );
                Jifty->log->info("Searching ", $feed->title, " at $uri");
        } else {
                Jifty->log->info("Fetching ", $feed->title, " at $uri");
        }

        my $xml_feed = XML::Feed->parse( URI->new($uri) )
                or die XML::Feed->errstr;

        warn "fetching ", $xml_feed->title, "\n";

        my @results;

        for my $entry ($xml_feed->entries) {
                my $i = Grep::Model::Item->new();

                $i->load_or_create(
                        in_feed => $feed,
                        title => $entry->title,
                        link => $entry->link,
                        content => $entry->content->body,
                        summary => $entry->summary->body,
                        category => $entry->category,
                        author => $entry->author,
                        issued => $entry->issued ? $entry->issued->strftime("%Y-%m-%d %H:%M:%S %z") : undef,
                        modified => $entry->modified ? $entry->modified->strftime("%Y-%m-%d %H:%M:%S %z") : undef,
                );

                die "can't create item from entry ", dump( $entry ) unless ( $i->id );

                push @results, $i->id;

                Jifty->log->debug("item ", $i->id, " = ",dump( $entry ) );
        }

        if ( @results ) {

                $self->result->message( $self->argument_value('q') . ' => ' .
                        $xml_feed->entries . ' items: ' . join(",", @results)
                );

                $self->result->content( results => \@results );
                return 1;

        } else {

                $self->result->message( 'No results found' );

                # with default sticky_on_failure, this will keep form data
                $self->result->failure( 1 );

                return 0;
        }
}

1;

1	dpavlin	3	use strict;
2			use warnings;
3
4			=head1 NAME
5
6			Grep::Action::Fetch
7
8			=cut
9
10			package Grep::Action::Fetch;
11			use base qw/Grep::Action Jifty::Action/;
12
13			use XML::Feed;
14
15			use Data::Dump qw/dump/;
16
17			use Jifty::Param::Schema;
18			use Jifty::Action schema {
19
20			param q =>
21			type is 'text',
22			label is 'Search for',
23			hint is 'enter few words to search for';
24
25			param feed =>
26			label is 'From feed',
27	dpavlin	7	render as 'select',
28	dpavlin	3	available are defer {
29			my $feeds = Grep::Model::FeedCollection->new;
30			$feeds->order_by({ column => 'title', order => 'ASC' });
31			$feeds->unlimit;
32			warn "feeds ", $feeds->build_select_query;
33			[{
34			display_from => 'title',
35			value_from => 'id',
36			collection => $feeds,
37			}];
38			};
39
40			};
41
42			=head2 take_action
43
44			=cut
45
46			sub take_action {
47			my $self = shift;
48
49			# Custom action code
50
51			my $feed = Grep::Model::Feed->new();
52			my $feed_id = $self->argument_value('feed');
53
54			if (! $feed_id) {
55			$self->result->message("Need feed ID");
56			return 0;
57			}
58
59			$feed->load_by_cols( id => $feed_id );
60
61			if (! $feed->id) {
62			$self->result->message("Can't fetch feed $feed_id");
63			return 0;
64			}
65
66	dpavlin	7	my $uri = $feed->uri;
67			if ($uri =~ m/%s/) {
68			$uri = sprintf( $uri, $self->argument_value('q') );
69			Jifty->log->info("Searching ", $feed->title, " at $uri");
70			} else {
71			Jifty->log->info("Fetching ", $feed->title, " at $uri");
72			}
73	dpavlin	3
74	dpavlin	7	my $xml_feed = XML::Feed->parse( URI->new($uri) )
75	dpavlin	3	or die XML::Feed->errstr;
76
77			warn "fetching ", $xml_feed->title, "\n";
78	dpavlin	7
79			my @results;
80
81	dpavlin	3	for my $entry ($xml_feed->entries) {
82			my $i = Grep::Model::Item->new();
83
84			$i->load_or_create(
85			in_feed => $feed,
86			title => $entry->title,
87			link => $entry->link,
88	dpavlin	5	content => $entry->content->body,
89			summary => $entry->summary->body,
90	dpavlin	3	category => $entry->category,
91			author => $entry->author,
92			issued => $entry->issued ? $entry->issued->strftime("%Y-%m-%d %H:%M:%S %z") : undef,
93			modified => $entry->modified ? $entry->modified->strftime("%Y-%m-%d %H:%M:%S %z") : undef,
94			);
95	dpavlin	5
96	dpavlin	7	die "can't create item from entry ", dump( $entry ) unless ( $i->id );
97
98			push @results, $i->id;
99
100			Jifty->log->debug("item ", $i->id, " = ",dump( $entry ) );
101	dpavlin	3	}
102
103	dpavlin	7	if ( @results ) {
104
105			$self->result->message( $self->argument_value('q') . ' => ' .
106			$xml_feed->entries . ' items: ' . join(",", @results)
107			);
108
109			$self->result->content( results => \@results );
110			return 1;
111
112			} else {
113
114	dpavlin	8	$self->result->message( 'No results found' );
115
116			# with default sticky_on_failure, this will keep form data
117			$self->result->failure( 1 );
118
119	dpavlin	7	return 0;
120			}
121	dpavlin	3	}
122
123			1;
124