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 Grep::Search;

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/;

};

=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 $q = $self->argument_value('q');
        my $user_id = Jifty->web->current_user->id;

        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 $message;
        my $uri = $feed->uri;
        if ($uri =~ m/%s/) {
                $uri = $feed->search_uri( $q );
                $message = 'Searching';
        } else {
                $message = 'Fetching';
        }
        $message .= ' ' . $feed->title . " at $uri";

        Jifty->log->info( $message );

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

        my $content = $r->content;

        return $self->result->error( "No content returned from $uri" ) unless length( $content ) > 1;

        my ( $items, $new ) = $self->collection_from_feed( $feed, $content );

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

                # construct a proper sentence :-)
                my $message = $count 
                        . ( $new == $count ? ' new' : '' )
                        . ( $new == 0 ? ' old' : '' )
                        . ' results '   
                        . ( $new && $new < $count ? "of which $new new " : '' )
                        . "for '$q' in " . $feed->title;
        
                $self->result->message( $message );

                $self->result->content( items => $items );
                $self->result->content( count => $items->count );

                Grep::Search->finish if $new;

                return $items;

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


=head2 collection_from_feed

  my ( $collection, $new ) = $self->collection_from_feed( $feed, '<xml>souce of feed</xml>');

=cut

sub collection_from_feed {
        my $self = shift;
        
        my ( $feed, $content ) = @_;

        die "feed is not a Grep::Model::Feed but ", ref $feed unless $feed->isa('Grep::Model::Feed');

        my $xml_feed = XML::Feed->parse( \$content )
                or return $self->result->error( $feed->title, " returned ", XML::Feed->errstr );


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

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

        my $new;

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

                my ($ok,$msg) = $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,
                );

                $msg ||= '';

                if ( $ok ) {
                        Jifty->log->debug("item ", $i->id, ": $msg");
                        $items->add_record( $i );

                        # is new record?
                        if ( $msg !~ m/^Found/ ) {
                                $new++;
                                Grep::Search->add( $i );
                        }
                } else {
                        warn "can't add entry ", dump( $entry ), "\n";
                }
        }

        return ($items, $new);
}

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