Grep/Model/Item.pm

use strict;
use warnings;

package Grep::Model::Item;
use Jifty::DBI::Schema;

use Grep::Model::Feed;

use Grep::Record schema {

        column in_feed =>
                refers_to Grep::Model::Feed by 'id',
                is indexed,
                is mandatory;
        
        column title =>
                type is 'text',
                is mandatory;
        
        column link =>
                type is 'text',
                is distinct,
                is indexed,
                is mandatory;
        
        column content =>
                type is 'text',
                is mandatory;

        column summary =>
                type is 'text';

        column category =>
                type is 'text';
        
        column author =>
                type is 'text';

        column created_on =>
                type is 'timestamp',
                default is defer { DateTime->now },
                filters are qw( Jifty::Filter::DateTime Jifty::DBI::Filter::DateTime );

        column last_update =>
                type is 'timestamp',
                default is defer { DateTime->now },
                filters are qw( Jifty::Filter::DateTime Jifty::DBI::Filter::DateTime );

};

sub since { '0.0.1' }

# Your model-specific methods go here.

sub current_user_can {
        my $self = shift;
        my $what = shift;

        my $uid = Jifty->web->current_user->id;

        # superuser
        return 1 if ( defined $uid && $uid == 0 );

        return 1 if ( $uid && $what eq 'create' );

        return 1 if ( $uid && ! $self->id );

        my $owner_id = $self->in_feed->owner->id;

#       Jifty->log->debug("current_user[$uid]_can($what) on Item ", $self->id || '???', " owner ", $owner_id || '???');

        return 1 if ( $uid && $owner_id && $uid == $owner_id );

        # system user
        return 1 if ( defined( $uid ) && $uid == 0 );

        warn "$uid can't $what";
}

sub _set {
        my $self = shift;
        my ($val, $msg) = $self->SUPER::_set(@_);

        $self->SUPER::_set(column => 'last_update', value => defer { DateTime->now });

        return ($val, $msg);
}

=head2 link_current

  my $item = Grep::Model::Item->link_currnet( 'http://www.example.com' )
  my $item = $item->link_current( 'http://www.example.com' );

=cut

my $update_every_hr = 24; # s

sub link_current {
        my $self = shift;
        my $uri = shift || die "no uri?";

        my $item = $self;
        if ( ! ref($self) || ! $self->link || ( $self->link && $self->link ne $uri ) ) {
                $item = Grep::Model::Item->new;
                #warn "load_by_cols link => $uri";
                $item->load_by_cols( link => $uri );
                return $item if $item->id;
                return 0;
        }

        return 0 unless ( $item );

        die "item is not Grep::Model::Item, but ", ref( $item ) unless ref( $item ) eq 'Grep::Model::Item';

        my $last_update = $item->last_update || $item->created_on; # fallback
        return 0 unless defined( $last_update ) && $last_update;

        my $newer_than = DateTime->now->subtract( hours => $update_every_hr );
        #warn "$last_update > $newer_than";
        return 0 if ( $last_update - $newer_than )->is_negative;
        return $item;
}

1;

1	dpavlin	2	use strict;
2			use warnings;
3
4			package Grep::Model::Item;
5			use Jifty::DBI::Schema;
6
7			use Grep::Model::Feed;
8
9			use Grep::Record schema {
10
11			column in_feed =>
12			refers_to Grep::Model::Feed by 'id',
13	dpavlin	178	is indexed,
14	dpavlin	2	is mandatory;
15
16			column title =>
17			type is 'text',
18			is mandatory;
19
20			column link =>
21			type is 'text',
22	dpavlin	178	is distinct,
23			is indexed,
24	dpavlin	2	is mandatory;
25
26			column content =>
27			type is 'text',
28			is mandatory;
29
30			column summary =>
31			type is 'text';
32
33			column category =>
34			type is 'text';
35
36			column author =>
37			type is 'text';
38
39	dpavlin	168	column created_on =>
40	dpavlin	2	type is 'timestamp',
41	dpavlin	168	default is defer { DateTime->now },
42	dpavlin	2	filters are qw( Jifty::Filter::DateTime Jifty::DBI::Filter::DateTime );
43
44	dpavlin	168	column last_update =>
45	dpavlin	2	type is 'timestamp',
46	dpavlin	170	default is defer { DateTime->now },
47	dpavlin	2	filters are qw( Jifty::Filter::DateTime Jifty::DBI::Filter::DateTime );
48
49			};
50
51	dpavlin	3	sub since { '0.0.1' }
52
53	dpavlin	2	# Your model-specific methods go here.
54
55	dpavlin	37	sub current_user_can {
56			my $self = shift;
57			my $what = shift;
58
59	dpavlin	63	my $uid = Jifty->web->current_user->id;
60	dpavlin	37
61	dpavlin	143	# superuser
62			return 1 if ( defined $uid && $uid == 0 );
63	dpavlin	63
64	dpavlin	143	return 1 if ( $uid && $what eq 'create' );
65
66	dpavlin	63	return 1 if ( $uid && ! $self->id );
67
68			my $owner_id = $self->in_feed->owner->id;
69
70	dpavlin	70	# Jifty->log->debug("current_user[$uid]_can($what) on Item ", $self->id \|\| '???', " owner ", $owner_id \|\| '???');
71	dpavlin	63
72	dpavlin	110	return 1 if ( $uid && $owner_id && $uid == $owner_id );
73	dpavlin	128
74			# system user
75			return 1 if ( defined( $uid ) && $uid == 0 );
76
77			warn "$uid can't $what";
78	dpavlin	37	}
79
80	dpavlin	168	sub _set {
81			my $self = shift;
82			my ($val, $msg) = $self->SUPER::_set(@_);
83	dpavlin	128
84	dpavlin	168	$self->SUPER::_set(column => 'last_update', value => defer { DateTime->now });
85	dpavlin	127
86	dpavlin	168	return ($val, $msg);
87	dpavlin	127	}
88
89	dpavlin	171	=head2 link_current
90
91			my $item = Grep::Model::Item->link_currnet( 'http://www.example.com' )
92			my $item = $item->link_current( 'http://www.example.com' );
93
94			=cut
95
96			my $update_every_hr = 24; # s
97
98			sub link_current {
99			my $self = shift;
100			my $uri = shift \|\| die "no uri?";
101
102			my $item = $self;
103			if ( ! ref($self) \|\| ! $self->link \|\| ( $self->link && $self->link ne $uri ) ) {
104			$item = Grep::Model::Item->new;
105			#warn "load_by_cols link => $uri";
106			$item->load_by_cols( link => $uri );
107			return $item if $item->id;
108			return 0;
109			}
110
111			return 0 unless ( $item );
112
113			die "item is not Grep::Model::Item, but ", ref( $item ) unless ref( $item ) eq 'Grep::Model::Item';
114
115			my $last_update = $item->last_update \|\| $item->created_on; # fallback
116			return 0 unless defined( $last_update ) && $last_update;
117
118			my $newer_than = DateTime->now->subtract( hours => $update_every_hr );
119			#warn "$last_update > $newer_than";
120			return 0 if ( $last_update - $newer_than )->is_negative;
121			return $item;
122			}
123
124	dpavlin	2	1;
125