Gruta/Template/Artemus.pm

   1 package Gruta::Template::Artemus;
   2
   3 use strict;
   4 use warnings;
   5 use Carp;
   6
   7 use base 'Gruta::Template::BASE';
   8
   9 use Artemus;
  10 use Gruta::Data;
  11
  12 sub new {
  13         my $class       = shift;
  14         my %args        = @_;
  15
  16         my $a = bless( {}, $class );
  17
  18         $a->{_artemus} = undef;
  19         $a->{path} = $args{path};
  20
  21         return $a;
  22 }
  23
  24
  25 sub _artemus {
  26         my $self        = shift;
  27
  28         if (not $self->{_artemus}) {
  29                 my $data = $self->data();
  30
  31                 my %f = ();
  32                 my %v = ();
  33
  34                 $f{l} = sub {
  35                         my $t = shift;
  36
  37                         return '?t=' . $t . ';' . join(';', @_);
  38                 };
  39
  40                 $f{'add'} = sub { $_[0] + $_[1]; };
  41                 $f{'sub'} = sub { $_[0] - $_[1]; };
  42                 $f{'gt'} = sub { $_[0] > $_[1]; };
  43                 $f{'lt'} = sub { $_[0] < $_[1]; };
  44                 $f{'eq'} = sub { $_[0] eq $_[1] ? 1 : 0; };
  45
  46                 $f{date} = sub { $data->today(); };
  47                 $f{random} = sub { $_[rand(scalar(@_))]; };
  48
  49                 foreach my $p (Gruta::Data::Topic->new->afields()) {
  50                         $f{'topic_' . $p} = sub {
  51                                 my $topic = shift;
  52                                 my $ret = '';
  53
  54                                 if ($topic ne '[]') {
  55                                         $ret = $data->topic($topic)->get($p) || '';
  56                                 }
  57
  58                                 return $ret;
  59                         };
  60                 }
  61
  62                 foreach my $p (Gruta::Data::Story->new->afields()) {
  63                         $f{'story_' . $p} = sub {
  64                                 my $topic_id    = shift;
  65                                 my $id          = shift;
  66                                 my $ret         = '';
  67
  68                                 if ($id ne '[]') {
  69                                         $ret = $data->story($topic_id, $id)->get($p);
  70                                 }
  71
  72                                 return $ret;
  73                         };
  74                 }
  75
  76                 $f{story_tags} = sub {
  77                         my $topic_id    = shift;
  78                         my $id          = shift;
  79                         my $ret         = '';
  80
  81                         if ($id ne '[]') {
  82                                 my $story = $data->story($topic_id, $id);
  83
  84                                 $ret = join(', ', $story->tags());
  85                         }
  86
  87                         return $ret;
  88                 };
  89
  90                 $f{story_body} = sub {
  91                         my $story = $data->story($_[0], $_[1]);
  92                         my $ret = $story->get('body');
  93
  94                         if (not $data->auth()) {
  95                                 $story->touch();
  96                         }
  97
  98                         return $ret;
  99                 };
 100
 101                 $f{story_date} = sub {
 102                         my $format      = shift;
 103                         my $topic_id    = shift;
 104                         my $id          = shift;
 105                         my $ret         = '';
 106
 107                         if ($id ne '[]') {
 108                                 $ret = $data->story($topic_id, $id)->date($format);
 109                         }
 110
 111                         return $ret;
 112                 };
 113
 114                 foreach my $p (Gruta::Data::User->new->afields()) {
 115                         $f{'user_' . $p} = sub {
 116                                 my $id  = shift;
 117                                 my $ret = '';
 118
 119                                 if ($id ne '[]') {
 120                                         $ret = $data->user($id)->get($p);
 121                                 }
 122
 123                                 return $ret;
 124                         };
 125                 }
 126
 127                 $f{template} = sub {
 128                         my $t = shift;
 129                         my $ret = '';
 130
 131                         if ($t ne '[]') {
 132                                 $t = $data->template->template($t);
 133                                 $ret = $self->{_artemus}->armor($t);
 134                         }
 135
 136                         return $ret;
 137                 };
 138
 139                 $f{save_template} = sub {
 140                         my $template    = shift;
 141                         my $content     = shift;
 142                         my $msg         = shift;
 143
 144                         $content = $self->{_artemus}->unarmor($content);
 145                         $data->template->save_template($template, $content);
 146
 147                         return $msg || "Template saved.";
 148                 };
 149
 150                 $f{loop_topics} = sub {
 151                         my $template    = shift;
 152                         my $sep         = shift;
 153
 154                         return join($sep, map {
 155                                 my $t = $data->topic($_);
 156                                 sprintf('{-%s|%s|%s}',
 157                                         $template, $t->get('name'),
 158                                         $t->get('id')
 159                                 );
 160                         } $data->topics());
 161                 };
 162
 163                 $f{loop_users} = sub {
 164                         return join($_[1], map { "{-$_[0]|$_}" } $data->users());
 165                 };
 166
 167                 $f{loop_renderers} = sub {
 168                         return join($_[1], map { "{-$_[0]|$_}" }
 169                                 sort(keys(%{$data->{renderers_h}})));
 170                 };
 171
 172                 $f{loop_templates} = sub {
 173                         return join($_[1], map { "{-$_[0]|$_}" }
 174                                 $data->template->templates());
 175                 };
 176
 177                 $f{loop_upload_dirs} = sub {
 178                         return join($_[1], map { "{-$_[0]|$_}" }
 179                                 $data->cgi->upload_dirs());
 180                 };
 181
 182                 $f{loop_story_tags} = sub {
 183                         my $topic_id    = shift;
 184                         my $id          = shift;
 185
 186                         return join($_[1], map { "{-$_[0]|$_}" }
 187                                 $data->story($topic_id, $id)->tags());
 188                 };
 189
 190                 $f{story_loop_by_date} = sub {
 191                         my $topic       = shift;
 192                         my $num         = shift;
 193                         my $offset      = shift;
 194                         my $template    = shift;
 195                         my $sep         = shift;
 196                         my $from        = shift;
 197                         my $to          = shift;
 198                         my $future      = shift;
 199
 200                         return join($sep, map { "{-$template|$topic|$_}" }
 201                                 $data->stories_by_date(
 202                                         $topic,
 203                                         num     => $num,
 204                                         offset  => $offset,
 205                                         from    => $from,
 206                                         to      => $to,
 207                                         future  => $future
 208                                 )
 209                         );
 210                 };
 211
 212                 $f{is_logged_in} = sub {
 213                         return $data->auth() ? 1 : 0;
 214                 };
 215
 216                 $f{is_admin} = sub {
 217                         if ($data->auth() and $data->auth->get('is_admin')) {
 218                                 return 1;
 219                         }
 220                         return 0;
 221                 };
 222
 223                 $f{is_topic_editor} = sub {
 224                         my $auth;
 225
 226                         if (not $auth = $data->auth()) {
 227                                 return 0;
 228                         }
 229
 230                         if ($auth->get('is_admin')) {
 231                                 return 1;
 232                         }
 233
 234                         my $topic;
 235
 236                         if (not $topic = $data->topic($_[0])) {
 237                                 return 0;
 238                         }
 239
 240                         if (my $editors = $topic->get('editors') and
 241                                 my $user_id = $auth->get('id')) {
 242                                 return 1 if $editors =~/\b$user_id\b/;
 243                         }
 244
 245                         return 0;
 246                 };
 247
 248                 $f{login} = sub {
 249                         my $user_id     = shift;
 250                         my $password    = shift;
 251                         my $error_msg   = shift;
 252
 253                         if ($user_id eq '' || $user_id eq 'cgi-userid') {
 254                                 $error_msg = '{-login_box}';
 255                         }
 256                         elsif (my $sid = $data->login($user_id, $password)) {
 257                                 $data->cgi->cookie("sid=$sid");
 258                                 $data->cgi->redirect('?t=INDEX');
 259                                 $self->{abort} = 1;
 260                         }
 261
 262                         return $error_msg || 'Login incorrect.';
 263                 };
 264
 265                 $f{logout} = sub {
 266                         $data->logout();
 267                         $data->cgi->redirect('?t=INDEX');
 268                         $self->{abort} = 1;
 269                 };
 270
 271                 $f{assert} = sub {
 272                         my $cond        = shift;
 273                         my $redir       = shift || 'ADMIN';
 274
 275                         if (! $cond) {
 276                                 $data->cgi->redirect('?t=' . $redir);
 277                                 $self->{abort} = 1;
 278                         }
 279
 280                         return '';
 281                 };
 282
 283                 $f{username} = sub {
 284                         my $ret = '';
 285
 286                         if ($data->auth()) {
 287                                 $ret = $data->auth->get('username');
 288                         }
 289
 290                         return $ret;
 291                 };
 292
 293                 $f{search_stories} = sub {
 294                         my $topic_id    = shift;
 295                         my $query       = shift;
 296
 297                         return "search_stories: FIXME";
 298                 };
 299
 300                 $f{story_loop_top_ten} = sub {
 301                         my $num         = shift;
 302                         my $internal    = shift; # ignored
 303                         my $template    = shift;
 304                         my $sep         = shift;
 305
 306                         return join($sep, map { "{-$template|$_->[1]|$_->[2]}" }
 307                                 $data->stories_top_ten($num)
 308                         );
 309                 };
 310
 311                 $f{is_visible_story} = sub {
 312                         my $story = $data->story($_[0], $_[1]);
 313
 314                         if (!$data->auth() && $story->get('date') > $data->today()) {
 315                                 return 0;
 316                         }
 317
 318                         return 1;
 319                 };
 320
 321                 $f{redir_if_archived} = sub {
 322                         my $template    = shift;
 323                         my $topic_id    = shift;
 324                         my $id          = shift;
 325
 326                         if ($topic_id =~ /-arch$/) {
 327                                 return '';
 328                         }
 329
 330                         my $story = $data->story($topic_id, $id);
 331
 332                         if ($story->get('topic_id') =~ /-arch$/) {
 333                                 $data->cgi->redirect(
 334                                         sprintf('?t=%s;topic=%s;id=%s',
 335                                         $template,
 336                                         $story->get('topic_id'),
 337                                         $id)
 338                                 );
 339                                 $self->{abort} = 1;
 340                         }
 341
 342                         return '';
 343                 };
 344
 345                 $f{topic_has_archive} = sub {
 346                         return $data->topic($_[0] . '-arch') ? 1 : 0;
 347                 };
 348
 349                 $f{save_topic} = sub {
 350                         my $topic_id    = shift || return 'Error 1';
 351
 352                         my $topic = undef;
 353
 354                         if (not $topic = $data->topic($topic_id)) {
 355                                 $topic = Gruta::Data::Topic->new (
 356                                         id => $topic_id );
 357                         }
 358
 359                         $topic->set('name',             shift);
 360                         $topic->set('editors',          shift);
 361                         $topic->set('internal',         shift eq 'on' ? 1 : 0);
 362                         $topic->set('max_stories',      shift);
 363
 364                         # update or insert
 365                         if ($topic->source()) {
 366                                 $topic = $topic->save();
 367                         }
 368                         else {
 369                                 $topic = $data->insert_topic($topic);
 370                         }
 371
 372                         return $topic ? 'OK' : 'Error 2';
 373                 };
 374
 375                 $f{save_story} = sub {
 376                         my $topic_id    = shift || return 'Error 1';
 377                         my $id          = shift;
 378
 379                         my $story = undef;
 380
 381                         if (not $story = $data->story($topic_id, $id)) {
 382                                 $story = Gruta::Data::Story->new (
 383                                         topic_id        => $topic_id,
 384                                         id              => $id
 385                                 );
 386                         }
 387
 388                         my $content = shift;
 389                         $content = $self->{_artemus}->unarmor($content);
 390
 391                         $story->set('content',  $content);
 392
 393                         # pick date and drop time
 394                         my $y = shift;
 395                         my $m = shift;
 396                         my $d = shift;
 397                         shift; shift; shift;
 398                         my $date = $data->today();
 399
 400                         if ($y && $m && $d) {
 401                                 $date = sprintf("%04d%02d%02d000000", $y, $m, $d);
 402                         }
 403
 404                         $story->set('date',     $date);
 405                         $story->set('format',   shift || 'grutatxt');
 406
 407                         # drop all cached stories
 408                         $data->flush_story_cache();
 409
 410                         if ($story->source()) {
 411                                 $story = $story->save();
 412                         }
 413                         else {
 414                                 $story = $data->insert_story($story);
 415                         }
 416
 417                         # store the tags
 418                         my $tags = shift;
 419
 420                         if ($tags ne 'cgi-tags') {
 421                                 $story->tags(split(/\s*,\s*/, $tags));
 422                         }
 423
 424                         return $story ? $story->get('id') : 'Error 2';
 425                 };
 426
 427                 $f{save_user} = sub {
 428                         shift;  # new (ignored)
 429                         my $id = shift || return 'Error 1';
 430
 431                         my $user = undef;
 432
 433                         if (not $user = $data->user($id)) {
 434                                 $user = Gruta::Data::User->new (
 435                                         id              => $id,
 436                                         is_admin        => 0,
 437                                         can_upload      => 0
 438                                 );
 439                         }
 440
 441                         $user->set('username',          shift);
 442                         $user->set('email',             shift);
 443
 444                         # these params can only be set by an admin
 445                         if ($data->auth() && $data->auth->get('is_admin')) {
 446                                 $user->set('is_admin',          shift);
 447                                 $user->set('can_upload',        shift);
 448                         }
 449                         else {
 450                                 shift;
 451                                 shift;
 452                         }
 453
 454                         my $pass1 = shift;
 455                         my $pass2 = shift;
 456
 457                         if ($pass1 and $pass2) {
 458                                 if ($pass1 ne $pass2) {
 459                                         croak "Passwords are different";
 460                                 }
 461
 462                                 my $salt = sprintf('%02d', rand(100));
 463                                 my $pw = crypt($pass1, $salt);
 464
 465                                 $user->set('password', $pw);
 466                         }
 467
 468                         if ($user->source()) {
 469                                 $user = $user->save();
 470                         }
 471                         else {
 472                                 $user = $data->insert_user($user);
 473                         }
 474
 475                         return $user ? 'OK' : 'Error 2';
 476                 };
 477
 478                 $f{upload} = sub {
 479
 480                         $data->cgi->upload($_[0], $_[1]);
 481                         return 'OK';
 482                 };
 483
 484                 $f{delete_story} = sub {
 485                         my $topic_id    = shift || return 'Error 1';
 486                         my $id          = shift;
 487
 488                         $data->story($topic_id, $id)->delete();
 489
 490                         # drop all cached stories
 491                         $data->flush_story_cache();
 492
 493                         return 'OK';
 494                 };
 495
 496                 $f{search_stories_by_tag} = sub {
 497                         my $tag         = shift;
 498                         my $template    = shift;
 499                         my $sep         = shift;
 500
 501                         return join($sep, map { "{-$template|$_->[0]|$_->[1]}" }
 502                                 $data->search_stories_by_tag($tag)
 503                         );
 504                 };
 505
 506                 $self->{abort}          = 0;
 507                 $self->{unresolved}     = [];
 508
 509                 $self->{_artemus} = Artemus->new(
 510                         'include-path'  =>      $self->{path},
 511                         'funcs'         =>      \%f,
 512                         'vars'          =>      \%v,
 513                         'unresolved'    =>      $self->{unresolved},
 514                         'abort'         =>      \$self->{abort},
 515                 );
 516
 517                 if ($self->{cgi_vars}) {
 518                         foreach my $k (keys(%{ $self->{cgi_vars} })) {
 519                                 my $c = $self->{_artemus}->
 520                                         armor($self->{cgi_vars}->{$k});
 521                                 $c =~ s/\r//g;
 522
 523                                 $v{"cgi-${k}"} = $c;
 524                         }
 525                 }
 526         }
 527
 528         return $self->{_artemus};
 529 }
 530
 531
 532 sub data {
 533         my $self        = shift;
 534         my $data        = shift;
 535
 536         if (defined($data)) {
 537                 $self->{data} = $data;
 538                 $self->{_artemus} = undef;
 539         }
 540
 541         return $self->{data};
 542 }
 543
 544
 545 sub cgi_vars {
 546         my $self        = shift;
 547
 548         if (@_) {
 549                 $self->{cgi_vars} = shift;
 550                 $self->{_artemus} = undef;
 551         }
 552
 553         return $self->{cgi_vars};
 554 }
 555
 556
 557 sub process { $_[0]->_artemus->process('{-' . $_[1] . '}'); }
 558
 559 1;