Gruta.pm

   1 package Gruta;
   2
   3 use strict;
   4 use warnings;
   5
   6 $Gruta::VERSION = '2.0-pre2';
   7
   8 sub sources { return @{$_[0]->{sources}}; }
   9 sub template { return $_[0]->{template}; }
  10 sub cgi { return $_[0]->{cgi}; }
  11
  12 sub today {
  13         my $self        = shift;
  14
  15         if (not $self->{_today}) {
  16                 my ($S,$M,$H,$d,$m,$y) = (localtime)[0..5];
  17                 $self->{_today} =
  18                          sprintf("%04d%02d%02d%02d%02d%02d",
  19                         1900 + $y, $m + 1, $d, $H, $M, $S);
  20         }
  21
  22         return $self->{_today};
  23 }
  24
  25 sub log {
  26         my $self        = shift;
  27         my $msg         = shift;
  28
  29         print STDERR $self->{id}, ' ', scalar(localtime), ': ', $msg, "\n";
  30 }
  31
  32
  33 sub _call {
  34         my $self        = shift;
  35         my $method      = shift;
  36         my $short       = shift;
  37
  38         my @r = ();
  39
  40         foreach my $s ($self->sources()) {
  41                 if (my $m = $s->can($method)) {
  42                         my @pr = $m->($s, @_);
  43
  44                         if (@pr && $pr[0]) {
  45                                 @r = (@r, @pr);
  46
  47                                 last if $short;
  48                         }
  49                 }
  50         }
  51
  52         return wantarray ? @r : $r[0];
  53 }
  54
  55 sub topic { my $self = shift; return $self->_call('topic', 1, @_); }
  56 sub topics { my $self = shift; return $self->_call('topics', 0); }
  57
  58 sub user { my $self = shift; return $self->_call('user', 1, @_); }
  59 sub users { my $self = shift; return $self->_call('users', 0); }
  60
  61 sub story {
  62         my $self        = shift;
  63         my $topic_id    = shift;
  64         my $id          = shift;
  65
  66         my $story = undef;
  67         my $ck = $topic_id . '/' . $id;
  68
  69         if ($story = $self->{story_cache}->{$ck}) {
  70                 return $story;
  71         }
  72
  73         if (not $story = $self->_call('story', 1, $topic_id, $id)) {
  74                 return undef;
  75         }
  76
  77         my $format = $story->get('format') || 'grutatxt';
  78
  79         if (my $rndr = $self->{renderers_h}->{$format}) {
  80                 $rndr->story($story);
  81         }
  82
  83         return $self->{story_cache}->{$ck} = $story;
  84 }
  85
  86
  87 sub stories { my $self = shift; return $self->_call('stories', 0, @_); }
  88 sub stories_by_date { my $self = shift;
  89         return $self->_call('stories_by_date', 1, @_, 'today' => $self->today()); }
  90 sub search_stories { my $self = shift; return $self->_call('search_stories', 1, @_); }
  91
  92 sub stories_top_ten {
  93         my $self = shift;
  94
  95         my @l = $self->_call('stories_top_ten', 0, @_);
  96
  97         return sort { $b->[0] cmp $a->[0] } @l;
  98 }
  99
 100 sub stories_by_tag { my $self = shift; return $self->_call('stories_by_tag', 0, @_); }
 101
 102 sub tags {
 103         my $self = shift;
 104
 105         my @l = $self->_call('tags', 0, @_);
 106
 107         return sort { $b->[1] cmp $a->[1] } @l;
 108 }
 109
 110 sub insert_topic { my $self = shift; $self->_call('insert_topic', 1, @_); return $self; }
 111 sub insert_user { my $self = shift; $self->_call('insert_user', 1, @_); return $self; }
 112 sub insert_story { my $self = shift; $self->_call('insert_story', 1, @_); return $self; }
 113
 114
 115 sub auth {
 116         my $self        = shift;
 117
 118         if (@_) { $self->{auth} = shift; }      # Gruta::Data::User
 119
 120         return $self->{auth};
 121 }
 122
 123
 124 sub auth_from_sid {
 125         my $self        = shift;
 126         my $sid         = shift;
 127
 128         my $u = undef;
 129
 130         if ($sid) {
 131                 $self->_call('purge_old_sessions', 0);
 132
 133                 if (my $session = $self->_call('session', 1, $sid)) {
 134                         $u = $session->source->user( $session->get('user_id') );
 135                         $u->set('sid', $sid);
 136                         $self->auth($u);
 137                 }
 138         }
 139
 140         return $u;
 141 }
 142
 143
 144 sub login {
 145         my $self        = shift;
 146         my $user_id     = shift;
 147         my $passwd      = shift;
 148
 149         my $sid = undef;
 150
 151         if (my $u = $self->user( $user_id )) {
 152
 153                 my $p = $u->get('password');
 154
 155                 if (crypt($passwd, $p) eq $p) {
 156                         # create new sid
 157                         $sid = time() . $$;
 158
 159                         my $session = Gruta::Data::Session->new(
 160                                 id      => $sid,
 161                                 time    => time(),
 162                                 user_id => $user_id
 163                         );
 164
 165                         $u->source->insert_session( $session );
 166
 167                         $u->set('sid', $sid);
 168                         $self->auth($u);
 169                 }
 170         }
 171
 172         return $sid;
 173 }
 174
 175
 176 sub logout {
 177         my $self        = shift;
 178
 179         if (my $auth = $self->auth()) {
 180                 if( my $sid = $auth->get('sid')) {
 181                         if (my $session = $auth->source->session( $sid )) {
 182                                 $session->delete() if $session->can('delete');
 183                         }
 184                 }
 185         }
 186
 187         $self->auth( undef );
 188         return $self;
 189 }
 190
 191
 192 sub _link_to_topic {
 193         my $self        = shift;
 194         my $topic_id    = shift;
 195
 196         my $ret = undef;
 197
 198         if (my $t = $self->topic($topic_id)) {
 199                 $ret = "<a href='?t=TOPIC;topic=$topic_id'>" .
 200                         $t->get('name') . '</a>';
 201         }
 202         else {
 203                 $ret = "Bad topic $topic_id";
 204         }
 205
 206         return $ret;
 207 }
 208
 209
 210 sub _link_to_story {
 211         my $self        = shift;
 212         my $topic_id    = shift;
 213         my $story_id    = shift;
 214
 215         my $ret = undef;
 216
 217         if (my $s = $self->story($topic_id, $story_id)) {
 218                 $ret = "<a href='?t=STORY;topic=$topic_id;id=$story_id'>" .
 219                         $s->get('title') . '</a>';
 220         }
 221         else {
 222                 $ret = "Bad story '$topic_id/$story_id'";
 223         }
 224
 225         return $ret;
 226 }
 227
 228
 229 sub special_uris {
 230         my $self        = shift;
 231         my $string      = shift;
 232
 233         $string =~ s!topic://([\w\d_]+)!$self->_link_to_topic($1)!ge;
 234         $string =~ s!story://([\w\d_]+)/([\w\d_]+)!$self->_link_to_story($1,$2)!ge;
 235
 236         return $string;
 237 }
 238
 239
 240 sub transfer_to_source {
 241         my $self        = shift;
 242         my $dst         = shift;
 243
 244         foreach my $id ($self->users()) {
 245                 my $u = $self->user($id);
 246                 $dst->insert_user($u);
 247         }
 248
 249         foreach my $topic_id ($self->topics()) {
 250                 my $t = $self->topic($topic_id);
 251                 $dst->insert_topic($t);
 252
 253                 foreach my $id ($self->stories($topic_id)) {
 254                         my $s = $self->story($topic_id, $id);
 255                         my $ns = $dst->insert_story($s);
 256
 257                         $ns->tags( $s->tags() );
 258                 }
 259         }
 260
 261         return $self;
 262 }
 263
 264
 265 sub flush_story_cache {
 266         my $self        = shift;
 267
 268         $self->{story_cache} = {};
 269 }
 270
 271
 272 sub new {
 273         my $class       = shift;
 274
 275         my $g = bless( { @_ } , $class);
 276
 277         $g->{id} ||= 'Gruta';
 278         $g->{story_cache} = {};
 279
 280         if (ref($g->{sources}) ne 'ARRAY') {
 281                 $g->{sources} = [ $g->{sources} ];
 282         }
 283         if (ref($g->{renderers}) ne 'ARRAY') {
 284                 $g->{renderers} = [ $g->{renderers} ];
 285         }
 286
 287         $g->{renderers_h} = {};
 288
 289         foreach my $r (@{$g->{renderers}}) {
 290                 $g->{renderers_h}->{$r->{renderer_id}} = $r;
 291         }
 292
 293         $g->template->data($g)  if $g->{template};
 294         $g->cgi->data($g)       if $g->{cgi};
 295
 296         return $g;
 297 }
 298
 299 sub run {
 300         my $self        = shift;
 301
 302         if ($self->{cgi}) {
 303                 $self->cgi->run();
 304         }
 305 }
 306
 307 1;