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         if (! $topic_id || ! $id) {
  67                 return undef;
  68         }
  69
  70         my $story = undef;
  71         my $ck = $topic_id . '/' . $id;
  72
  73         if ($story = $self->{story_cache}->{$ck}) {
  74                 return $story;
  75         }
  76
  77         if (not $story = $self->_call('story', 1, $topic_id, $id)) {
  78                 return undef;
  79         }
  80
  81         my $format = $story->get('format') || 'grutatxt';
  82
  83         if (my $rndr = $self->{renderers_h}->{$format}) {
  84                 $rndr->story($story);
  85         }
  86
  87         return $self->{story_cache}->{$ck} = $story;
  88 }
  89
  90
  91 sub stories { my $self = shift; return $self->_call('stories', 0, @_); }
  92 sub stories_by_date { my $self = shift;
  93         return $self->_call('stories_by_date', 1, @_, 'today' => $self->today()); }
  94 sub search_stories { my $self = shift; return $self->_call('search_stories', 1, @_); }
  95
  96 sub stories_top_ten {
  97         my $self = shift;
  98
  99         my @l = $self->_call('stories_top_ten', 0, @_);
 100
 101         return sort { $b->[0] cmp $a->[0] } @l;
 102 }
 103
 104 sub search_stories_by_tag { my $self = shift; return $self->_call('search_stories_by_tag', 0, @_); }
 105
 106 sub tags {
 107         my $self = shift;
 108
 109         my @l = $self->_call('tags', 0, @_);
 110
 111         return sort { $b->[1] <=> $a->[1] } @l;
 112 }
 113
 114 sub insert_topic { my $self = shift; return $self->_call('insert_topic', 1, @_); }
 115 sub insert_user { my $self = shift; return $self->_call('insert_user', 1, @_); }
 116 sub insert_story { my $self = shift; return $self->_call('insert_story', 1, @_); }
 117
 118
 119 sub auth {
 120         my $self        = shift;
 121
 122         if (@_) { $self->{auth} = shift; }      # Gruta::Data::User
 123
 124         return $self->{auth};
 125 }
 126
 127
 128 sub auth_from_sid {
 129         my $self        = shift;
 130         my $sid         = shift;
 131
 132         my $u = undef;
 133
 134         if ($sid) {
 135                 $self->_call('purge_old_sessions', 0);
 136
 137                 if (my $session = $self->_call('session', 1, $sid)) {
 138                         $u = $session->source->user( $session->get('user_id') );
 139                         $u->set('sid', $sid);
 140                         $self->auth($u);
 141                 }
 142         }
 143
 144         return $u;
 145 }
 146
 147
 148 sub login {
 149         my $self        = shift;
 150         my $user_id     = shift;
 151         my $passwd      = shift;
 152
 153         my $sid = undef;
 154
 155         if (my $u = $self->user( $user_id )) {
 156
 157                 my $p = $u->get('password');
 158
 159                 if (crypt($passwd, $p) eq $p) {
 160                         # create new sid
 161                         $sid = time() . $$;
 162
 163                         my $session = Gruta::Data::Session->new(
 164                                 id      => $sid,
 165                                 time    => time(),
 166                                 user_id => $user_id
 167                         );
 168
 169                         $u->source->insert_session( $session );
 170
 171                         $u->set('sid', $sid);
 172                         $self->auth($u);
 173                 }
 174         }
 175
 176         return $sid;
 177 }
 178
 179
 180 sub logout {
 181         my $self        = shift;
 182
 183         if (my $auth = $self->auth()) {
 184                 if( my $sid = $auth->get('sid')) {
 185                         if (my $session = $auth->source->session( $sid )) {
 186                                 $session->delete() if $session->can('delete');
 187                         }
 188                 }
 189         }
 190
 191         $self->auth( undef );
 192         return $self;
 193 }
 194
 195
 196 sub _link_to_topic {
 197         my $self        = shift;
 198         my $topic_id    = shift;
 199
 200         my $ret = undef;
 201
 202         if (my $t = $self->topic($topic_id)) {
 203                 $ret = "<a href='?t=TOPIC;topic=$topic_id'>" .
 204                         $t->get('name') . '</a>';
 205         }
 206         else {
 207                 $ret = "Bad topic $topic_id";
 208         }
 209
 210         return $ret;
 211 }
 212
 213
 214 sub _link_to_story {
 215         my $self        = shift;
 216         my $topic_id    = shift;
 217         my $story_id    = shift;
 218
 219         my $ret = undef;
 220
 221         if (my $s = $self->story($topic_id, $story_id)) {
 222                 $ret = "<a href='?t=STORY;topic=$topic_id;id=$story_id'>" .
 223                         $s->get('title') . '</a>';
 224         }
 225         else {
 226                 $ret = "Bad story '$topic_id/$story_id'";
 227         }
 228
 229         return $ret;
 230 }
 231
 232
 233 sub special_uris {
 234         my $self        = shift;
 235         my $string      = shift;
 236
 237         $string =~ s!topic://([\w\d_]+)!$self->_link_to_topic($1)!ge;
 238         $string =~ s!story://([\w\d_]+)/([\w\d_]+)!$self->_link_to_story($1,$2)!ge;
 239
 240         return $string;
 241 }
 242
 243
 244 sub transfer_to_source {
 245         my $self        = shift;
 246         my $dst         = shift;
 247
 248         foreach my $id ($self->users()) {
 249                 my $u = $self->user($id);
 250                 $dst->insert_user($u);
 251         }
 252
 253         foreach my $topic_id (sort $self->topics()) {
 254                 my $t = $self->topic($topic_id);
 255
 256                 my $nti = $topic_id;
 257
 258                 # is it an archive?
 259                 if ($nti =~ /-arch$/) {
 260                         # don't insert topic, just rename
 261                         $nti =~ s/-arch$//;
 262                 }
 263                 else {
 264                         $dst->insert_topic($t);
 265                 }
 266
 267                 foreach my $id ($self->stories($topic_id)) {
 268
 269                         # get story and its tags
 270                         my $s = $self->story($topic_id, $id);
 271                         my @tags = $s->tags();
 272
 273                         # set new topic
 274                         $s->set('topic_id', $nti);
 275
 276                         my $ns = $dst->insert_story($s);
 277
 278                         if (@tags) {
 279                                 $ns->tags(@tags);
 280                         }
 281                 }
 282         }
 283
 284         return $self;
 285 }
 286
 287
 288 sub flush_story_cache {
 289         my $self        = shift;
 290
 291         $self->{story_cache} = {};
 292 }
 293
 294
 295 sub new {
 296         my $class       = shift;
 297
 298         my $g = bless( { @_ } , $class);
 299
 300         $g->{id} ||= 'Gruta';
 301         $g->{story_cache} = {};
 302         $g->{renderers_h} = {};
 303
 304         if (ref($g->{sources}) ne 'ARRAY') {
 305                 $g->{sources} = [ $g->{sources} ];
 306         }
 307
 308         if ($g->{renderers}) {
 309                 if (ref($g->{renderers}) ne 'ARRAY') {
 310                         $g->{renderers} = [ $g->{renderers} ];
 311                 }
 312
 313                 foreach my $r (@{$g->{renderers}}) {
 314                         $g->{renderers_h}->{$r->{renderer_id}} = $r;
 315                 }
 316         }
 317
 318         $g->template->data($g)  if $g->{template};
 319         $g->cgi->data($g)       if $g->{cgi};
 320
 321         return $g;
 322 }
 323
 324 sub run {
 325         my $self        = shift;
 326
 327         if ($self->{cgi}) {
 328                 $self->cgi->run();
 329         }
 330 }
 331
 332 1;