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 LWP::UserAgent;

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,
                        }];
                };

        param item_fragment =>
                label is 'Show',
                render as 'select',
#               valid are qw/result result_short/,
#               available are qw/result result_short/;
                available are qw/long short title/;

        param publish =>
                label is 'In which queue?';

};

=head2 take_action

Returns C<Grep::Model::ItemCollection> of fatched items from Feed which will
also be stored in local cache.

=cut

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

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

        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 = $feed->search_uri( $q );
                Jifty->log->info("Searching ", $feed->title, " at $uri");
        } else {
                Jifty->log->info("Fetching ", $feed->title, " at $uri");
        }

        my $items = Grep::Model::ItemCollection->new();

        sub abort {
                my $message = join(" ", @_);
                if ( $publish ) {
                        Grep::Event::Result->new({
                                q => $q, coll => $items,
                                message => $message, class => 'error',
                        })->publish;
                        return;
                } else {
                        $self->result->error( $message );
                        return;
                }
        }

        my $ua = LWP::UserAgent->new;
        $ua->default_header( 'Cookie' => $feed->cookie );
        my $r = $ua->get( $uri );
        return abort(
                $feed->title . " returned " . $r->status_line . " for $uri\n"
        ) unless ( $r->is_success );

        my $content = $r->content;

        return abort( "No content returned from $uri" ) unless length( $content ) > 1;


        my $xml_feed = XML::Feed->parse( \$content )
                or return abort( $feed->title, " returned ", XML::Feed->errstr, " for $uri" );

        warn "getting entries from ", $xml_feed->title, "\n";

        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") : undef,
                        modified => $entry->modified ? $entry->modified->strftime("%Y-%m-%d %H:%M:%S") : undef,
                );

                if ( $i->id ) {
                        $items->add_record( $i );

                        Jifty->log->debug("added ", $i->id, " to collection");
                } else {
                        warn "can't add entry ", dump( $entry ) unless ( $i->id );
                }

        }

        if ( my $count = $items->count ) {

                my $message = "$count results for '$q' in " . $feed->title;

                $self->result->message( $message );

                if ( $publish ) {
                        Grep::Event::Result->new({
                                q => $q, coll => $items,
                                item_fragment => $self->argument_value('item_fragment'),
                                message => $message, class => 'message',
                        })->publish;
                        Jifty->log->debug( $items->count, " for '$q' published" );
                } else {
                        $self->result->content( items => $items );
                        Jifty->log->debug( $items->count, " for '$q' found" );
                }

        } else {
                return abort( "No results for '$q' in " . $feed->title );
        }

        return $items;
}

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	dpavlin	21	use LWP::UserAgent;
15	dpavlin	3
16			use Data::Dump qw/dump/;
17
18			use Jifty::Param::Schema;
19			use Jifty::Action schema {
20
21			param q =>
22			type is 'text',
23			label is 'Search for',
24			hint is 'enter few words to search for';
25
26			param feed =>
27			label is 'From feed',
28	dpavlin	7	render as 'select',
29	dpavlin	3	available are defer {
30			my $feeds = Grep::Model::FeedCollection->new;
31			$feeds->order_by({ column => 'title', order => 'ASC' });
32			$feeds->unlimit;
33			warn "feeds ", $feeds->build_select_query;
34			[{
35			display_from => 'title',
36			value_from => 'id',
37			collection => $feeds,
38			}];
39			};
40
41	dpavlin	25	param item_fragment =>
42			label is 'Show',
43			render as 'select',
44	dpavlin	28	# valid are qw/result result_short/,
45			# available are qw/result result_short/;
46			available are qw/long short title/;
47	dpavlin	25
48	dpavlin	29	param publish =>
49			label is 'In which queue?';
50
51	dpavlin	3	};
52
53			=head2 take_action
54
55	dpavlin	29	Returns C<Grep::Model::ItemCollection> of fatched items from Feed which will
56			also be stored in local cache.
57
58	dpavlin	3	=cut
59
60			sub take_action {
61			my $self = shift;
62
63			# Custom action code
64
65			my $feed = Grep::Model::Feed->new();
66			my $feed_id = $self->argument_value('feed');
67	dpavlin	29	my $publish = $self->argument_value('publish');
68			my $q = $self->argument_value('q');
69	dpavlin	3
70			if (! $feed_id) {
71			$self->result->message("Need feed ID");
72			return 0;
73			}
74
75			$feed->load_by_cols( id => $feed_id );
76
77			if (! $feed->id) {
78			$self->result->message("Can't fetch feed $feed_id");
79			return 0;
80			}
81
82	dpavlin	7	my $uri = $feed->uri;
83			if ($uri =~ m/%s/) {
84	dpavlin	29	$uri = $feed->search_uri( $q );
85	dpavlin	7	Jifty->log->info("Searching ", $feed->title, " at $uri");
86			} else {
87			Jifty->log->info("Fetching ", $feed->title, " at $uri");
88			}
89	dpavlin	3
90	dpavlin	31	my $items = Grep::Model::ItemCollection->new();
91
92			sub abort {
93			my $message = join(" ", @_);
94			if ( $publish ) {
95			Grep::Event::Result->new({
96			q => $q, coll => $items,
97			message => $message, class => 'error',
98			})->publish;
99	dpavlin	34	return;
100	dpavlin	31	} else {
101			$self->result->error( $message );
102	dpavlin	34	return;
103	dpavlin	31	}
104			}
105	dpavlin	34
106	dpavlin	21	my $ua = LWP::UserAgent->new;
107			$ua->default_header( 'Cookie' => $feed->cookie );
108			my $r = $ua->get( $uri );
109	dpavlin	31	return abort(
110			$feed->title . " returned " . $r->status_line . " for $uri\n"
111			) unless ( $r->is_success );
112	dpavlin	21
113			my $content = $r->content;
114
115	dpavlin	31	return abort( "No content returned from $uri" ) unless length( $content ) > 1;
116	dpavlin	21
117	dpavlin	31
118	dpavlin	21	my $xml_feed = XML::Feed->parse( \$content )
119	dpavlin	31	or return abort( $feed->title, " returned ", XML::Feed->errstr, " for $uri" );
120	dpavlin	3
121	dpavlin	21	warn "getting entries from ", $xml_feed->title, "\n";
122	dpavlin	7
123	dpavlin	3	for my $entry ($xml_feed->entries) {
124			my $i = Grep::Model::Item->new();
125
126			$i->load_or_create(
127			in_feed => $feed,
128			title => $entry->title,
129			link => $entry->link,
130	dpavlin	5	content => $entry->content->body,
131			summary => $entry->summary->body,
132	dpavlin	3	category => $entry->category,
133			author => $entry->author,
134	dpavlin	29	issued => $entry->issued ? $entry->issued->strftime("%Y-%m-%d %H:%M:%S") : undef,
135			modified => $entry->modified ? $entry->modified->strftime("%Y-%m-%d %H:%M:%S") : undef,
136	dpavlin	3	);
137	dpavlin	5
138	dpavlin	25	if ( $i->id ) {
139	dpavlin	29	$items->add_record( $i );
140	dpavlin	7
141	dpavlin	29	Jifty->log->debug("added ", $i->id, " to collection");
142	dpavlin	25	} else {
143	dpavlin	29	warn "can't add entry ", dump( $entry ) unless ( $i->id );
144	dpavlin	25	}
145	dpavlin	9
146	dpavlin	3	}
147
148	dpavlin	33	if ( my $count = $items->count ) {
149	dpavlin	7
150	dpavlin	33	my $message = "$count results for '$q' in " . $feed->title;
151	dpavlin	7
152	dpavlin	31	$self->result->message( $message );
153
154	dpavlin	29	if ( $publish ) {
155	dpavlin	30	Grep::Event::Result->new({
156			q => $q, coll => $items,
157			item_fragment => $self->argument_value('item_fragment'),
158	dpavlin	33	message => $message, class => 'message',
159	dpavlin	30	})->publish;
160	dpavlin	29	Jifty->log->debug( $items->count, " for '$q' published" );
161			} else {
162			$self->result->content( items => $items );
163			Jifty->log->debug( $items->count, " for '$q' found" );
164			}
165	dpavlin	7
166			} else {
167	dpavlin	34	return abort( "No results for '$q' in " . $feed->title );
168	dpavlin	7	}
169	dpavlin	29
170			return $items;
171	dpavlin	3	}
172
173			1;
174