events.pm

   1 #! /usr/bin/perl
   2 # Copyright (C) 2014 Julien Moutinho <julm+ikiwiki+events&autogeree.net>
   3 #
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 3 of the License,
   7 # or (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
  17
  18 package IkiWiki::Plugin::events;
  19
  20 use strict;
  21 use warnings;
  22 use IkiWiki 3.00;
  23 use Time::Local;
  24 use DateTime;
  25 #use Data::Dumper;
  26
  27 sub import {
  28         hook(type => "getsetup",   id => "events", call => \&getsetup);
  29         hook(type => "needsbuild", id => "events", call => \&needsbuild);
  30         hook(type => "preprocess", id => "events", call => \&preprocess);
  31         hook(type => "sessioncgi", id => "events", call => \&sessioncgi);
  32  }
  33 sub getsetup () {
  34         return
  35          { plugin =>
  36                  { safe => 1
  37                  , rebuild => undef
  38                  , section => "widget"
  39                  }
  40          };
  41  }
  42
  43 my $now
  44  = DateTime->now
  45  ( time_zone => 'local'
  46  , locale    => $config{locale}
  47  )->set_time_zone('floating');
  48 my @days    = ('01'..'31');
  49 my @hours   = ('00'..'23');
  50 my @minutes = ('00'..'59');
  51
  52 # update
  53 sub set_rendering_expiration ($$) {
  54         my ($page, $timestamp) = @_;
  55         if (not exists  $pagestate{$page}{events}{expiration}
  56         or $timestamp < $pagestate{$page}{events}{expiration}) {
  57                 my $time = DateTime->from_epoch
  58                  ( epoch     => $timestamp
  59                  , time_zone => 'UTC'
  60                  , locale    => $config{locale}
  61                  );
  62                 #debug("events: set_rendering_expiration(): will refresh: page=".$page
  63                 # . " after: date=".$time->strftime('%Y-%m-%d_%H-%M-%S'));
  64                 $pagestate{$page}{events}{expiration} = $timestamp;
  65          }
  66  }
  67 sub set_next_rendering (%) {
  68         my %params = @_;
  69         if ($params{type} eq 'month'
  70          and $params{focus}->year()  == $now->year()
  71          and $params{focus}->month() == $now->month()) {
  72                 # NOTE: calendar for current month, updates next day
  73                 my $update = $params{focus}->clone;
  74                 $update->set_hour(0);
  75                 $update->set_minute(0);
  76                 $update->set_second(0);
  77                 $update->set_nanosecond(0);
  78                 my $duration = DateTime::Duration->new(days => 1, end_of_month => 'limit');
  79                 $update->add_duration($duration);
  80                 set_rendering_expiration($params{destpage}, $update->epoch());
  81                 #debug("events: will refresh current month: page=".$params{destpage}
  82                 # . " after: date=".$update->strftime('%Y-%m-%d_%H-%M-%S'));
  83          }
  84         elsif ($params{type} eq 'month'
  85          and ((  $params{focus}->year()  == $now->year()
  86                          and $params{focus}->month()  > $now->month())
  87                  or    $params{focus}->year()   > $now->year())) {
  88                 # NOTE: calendar for upcoming month, updates 1st of next month
  89                 my $update = $params{focus}->clone;
  90                 $update->set_day(1);
  91                 $update->set_hour(0);
  92                 $update->set_minute(0);
  93                 $update->set_second(0);
  94                 $update->set_nanosecond(0);
  95                 set_rendering_expiration($params{destpage}, $update->epoch());
  96                 #debug("events: will refresh upcoming month: page=".$params{destpage}
  97                 # . " after: date=".$update->strftime('%Y-%m-%d_%H-%M-%S'));
  98          }
  99         elsif ($params{type} eq 'day'
 100          and ($params{focus}->year()     == $now->year()
 101                          and $params{focus}->month() == $now->month()
 102                          and $params{focus}->day()   == $now->day())) {
 103                 # NOTE: calendar for current day, updates next day
 104                 my $update = $params{focus}->clone;
 105                 $update->set_hour(0);
 106                 $update->set_minute(0);
 107                 $update->set_second(0);
 108                 $update->set_nanosecond(0);
 109                 my $duration = DateTime::Duration->new(days => 1, end_of_month => 'limit');
 110                 $update->add_duration($duration);
 111                 set_rendering_expiration($params{destpage}, $update->epoch());
 112                 #debug("events: will refresh current day: page=".$params{destpage}
 113                 # . " after: date=".$update->strftime('%Y-%m-%d_%H-%M-%S'));
 114          }
 115         elsif ($params{type} eq 'day'
 116          and ((    $params{focus}->year()  == $now->year()
 117                          and ( $params{focus}->month()  > $now->month()
 118                                  or ($params{focus}->month() == $now->month()
 119                                  and $params{focus}->day()    > $now->day() ))
 120                  or      $params{focus}->year()   > $now->year()))) {
 121                 # NOTE: calendar for upcoming day, updates that day
 122                 my $update = $params{focus}->clone;
 123                 $update->set_hour(0);
 124                 $update->set_minute(0);
 125                 $update->set_second(0);
 126                 $update->set_nanosecond(0);
 127                 set_rendering_expiration($params{destpage}, $update->epoch());
 128                 #debug("events: will refresh upcoming day: page=".$params{destpage}
 129                 # . " after: date=".$update->strftime('%Y-%m-%d_%H-%M-%S'));
 130          }
 131  }
 132 sub needsbuild (@) {
 133         my $needsbuild = shift;
 134         foreach my $page (keys %pagestate) {
 135                 if (exists $pagestate{$page}{events}{expiration}) {
 136                         if ($pagestate{$page}{events}{expiration} <= $now->epoch()) {
 137                                 # NOTE: force a rebuild so the calendar shows the current day
 138                                 push @$needsbuild, $pagesources{$page};
 139                          }
 140                         if (exists $pagesources{$page}
 141                          and grep { $_ eq $pagesources{$page} } @$needsbuild) {
 142                                 # NOTE: remove state, will be re-added
 143                                 #       if the calendar is still there during the rebuild
 144                                 delete $pagestate{$page}{events};
 145                          }
 146                  }
 147          }
 148         return $needsbuild;
 149  }
 150
 151 # render
 152 sub date_of_page ($%) {
 153         my ($page, %params) = @_;
 154         my $dir = IkiWiki::dirname($page);
 155         my ($year, $month, $day, $hour, $hour_begin, $hour_end)
 156          = $dir =~ m{
 157                 .*/
 158                 (\d+)/
 159                 (01|02|03|04|05|06|07|08|09|10|11|12)/
 160                 (01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31)/
 161                 (([0-2][0-9]h[0-5][0-9])(-[0-2][0-9]h[0-5][0-9])?)?
 162                 $
 163          }x;
 164         my $r =
 165          { year       => $year
 166          , month      => $month
 167          , day        => $day
 168          , hour       => $hour
 169          , hour_begin => $hour_begin
 170          , hour_end   => $hour_end
 171          };
 172         #debug("date_of_page: dir=".$dir." ".Dumper($r));
 173         return $r;
 174  }
 175 sub event_of_page ($%) {
 176         my ($event, %params) = @_;
 177         my $title
 178          = exists $pagestate{$event}{meta}{title}
 179          ? $pagestate{$event}{meta}{title}
 180          : pagetitle(IkiWiki::basename($event));
 181         my $hour
 182          = date_of_page($event)->{hour};
 183         my $link
 184          = htmllink
 185          ( $params{page}
 186          , $params{destpage}
 187          , $event
 188          , linktext => $title
 189          , noimageinline => 1
 190          , title => $title );
 191         my @tags
 192          = sort {lc $a cmp lc $b}
 193          (grep {
 194                         not defined $params{tags}
 195                         or pagespec_match($_, $params{tags})
 196                  }
 197                  (keys %{$IkiWiki::typedlinks{$event}{tag}}));
 198         @tags
 199          = map {
 200                 my $tag = $_;
 201                 my $title
 202                  = exists $pagestate{$tag}{meta}{title}
 203                  ? $pagestate{$tag}{meta}{title}
 204                  : pagetitle(IkiWiki::basename($tag));
 205                 my $link
 206                  = htmllink
 207                  ( $params{page}
 208                  , $params{destpage}
 209                  , $tag
 210                  , linktext => $title
 211                  , noimageinline => 1
 212                  , title => $title );
 213                 add_depends($params{page}, $event, deptype('content'));
 214                 #add_depends($params{page}, $tag, deptype('content'));
 215                         # XXX: much too heavy :\ and midnight refresh may fix it anyway.
 216                 my $class = qq{$tag};
 217                 $class =~ s{[^a-zA-Z0-9-]}{_}g;
 218                 { class => "tag tag-$class"
 219                 , link  => $link }
 220          } @tags;
 221         return
 222          { hour => $hour
 223          , link => $link
 224          , tags => \@tags };
 225  }
 226 sub events_of_pages ($%) {
 227         my ($pages, %params) = @_;
 228         my @day_events = ();
 229         my @hour_events = ();
 230         my $pagedir = sub { IkiWiki::basename(IkiWiki::dirname(shift)) };
 231         foreach my $page (@$pages) {
 232                 my $date = date_of_page($page);
 233                 if (defined $date->{hour}) {
 234                         push @hour_events, $page;
 235                  }
 236                 else {
 237                         push @day_events, $page;
 238                  }
 239          }
 240         return
 241          map {event_of_page($_, %params)}
 242          ( (sort {lc $pagedir->($a) cmp lc $pagedir->($b)} @day_events)
 243          , (sort {lc $pagedir->($a) cmp lc $pagedir->($b)} @hour_events) );
 244  }
 245 sub event_html ($$%) {
 246         my ($date, $format, %params) = @_;
 247         my $day   = sprintf("%02d", $date->day());
 248         my $month = sprintf("%02d", $date->month());
 249         my $year_html = $date->year();
 250         my $month_html
 251          = $format->{month_name}
 252          ? $date->month_name()
 253          : $month;
 254         my $day_html
 255          = $format->{day_name}
 256          ? $date->day_name()." ".$date->day()
 257          : $format->{day_abbr}
 258          ? $date->day_abbr()." ".$date->day()
 259          : $date->day();
 260         my $wday_class
 261          = "wday-".($date->day_of_week() - 1)
 262          . ( ($date->year()    == $now->year()
 263                         and $date->month() == $now->month()
 264                         and $date->day()   == $now->day())
 265                  ? " today"
 266                  : "" );
 267         my $new_html = "";
 268         if (not defined $params{new} or $params{new} ne 'no') {
 269                 if ($format->{year}) {
 270                         my $year_page
 271                          = sprintf
 272                          ( '%s/%d'
 273                          , $params{base}
 274                          , $date->year()
 275                          );
 276                         add_depends($params{page}, $year_page, deptype("presence"));
 277                         if ($pagesources{$year_page}) {
 278                                 $year_html
 279                                  = htmllink
 280                                  ( $params{page}
 281                                  , $params{destpage}
 282                                  , $year_page
 283                                  , linktext => $year_html
 284                                  , noimageinline => 1 );
 285                          }
 286                  }
 287                 if ($format->{month}) {
 288                         my $month_page
 289                          = sprintf
 290                          ( '%s/%d/%02d'
 291                          , $params{base}
 292                          , $date->year()
 293                          , $date->month()
 294                          );
 295                         add_depends($params{page}, $month_page, deptype("presence"));
 296                         if ($pagesources{$month_page}) {
 297                                 $month_html
 298                                  = htmllink
 299                                  ( $params{page}
 300                                  , $params{destpage}
 301                                  , $month_page
 302                                  , linktext => $month_html
 303                                  , noimageinline => 1 );
 304                          }
 305                  }
 306                 if ($format->{day}) {
 307                         my $day_page
 308                          = sprintf
 309                          ( '%s/%d/%02d/%02d'
 310                          , $params{base}
 311                          , $date->year()
 312                          , $date->month()
 313                          , $date->day()
 314                          );
 315                         add_depends($params{page}, $day_page, deptype("presence"));
 316                         if ($pagesources{$day_page}) {
 317                                 $day_html
 318                                  = htmllink
 319                                  ( $params{page}
 320                                  , $params{destpage}
 321                                  , $day_page
 322                                  , linktext => $day_html
 323                                  , noimageinline => 1 );
 324                          }
 325                  }
 326                 unless ($params{nonew} or not $format->{new}) {
 327                         $new_html
 328                          .= qq{<a class='new' href='}
 329                          . IkiWiki::cgiurl
 330                                  ( base  => $params{base}
 331                                  , ($date->day()
 332                                          ?(day => $day):())
 333                                  , (($date->month() or $date->day())
 334                                          ?(month => $month):())
 335                                  , (($date->year() or $date->month() or $date->day())
 336                                          ?(year => $date->year()):())
 337                                  , do    => 'events'
 338                                  , page  => $params{destpage}
 339                                  )
 340                          . qq{' rel='nofollow'>+</a>};
 341                  }
 342          }
 343         return
 344          { new   => $new_html
 345          , day   => $day_html
 346          , month => $month_html
 347          , year  => $year_html
 348          , wday  => $wday_class
 349          };
 350  }
 351 sub preprocess_day (@) {
 352         my %params = @_;
 353         my @pages
 354          = pagespec_match_list
 355          ( $params{page}
 356          , $params{pages}
 357          , deptype => deptype("presence")
 358                 # NOTE: add presence dependencies to update calendar when pages are added/removed
 359          );
 360         my $event_html
 361          = event_html
 362          ( $params{focus}
 363          , {day=>1, day_name=>1, new => 1}
 364          , %params );
 365         my @events
 366          = map {
 367                 my @tags
 368                  = map {"<li\n class='".$_->{class}."'>".$_->{link}."</li>"}
 369                  @{$_->{tags}};
 370                 "<ul\n class='events'><li class='event'>"
 371                  . "<span class='head'>"
 372                                  . (defined $_->{hour} ? "<span class='hour'>$_->{hour}</span>" : "")
 373                          . "<span class='link'>$_->{link}</span>"
 374                  . "</span>"
 375                  . "<ul\n class='tags'>".join("", @tags)."</ul>"
 376                  . "</li></ul>"
 377          }
 378          events_of_pages(\@pages, %params);
 379         return
 380          "<table\n class='wday'>"
 381          . "<thead><tr><th><span\n class='head'><span\n class='day'>"
 382                          . $event_html->{day}
 383                          . $event_html->{new}
 384                  . "</span></span></th></tr></thead>"
 385          . "<tbody><tr><td\n class='wday $event_html->{wday}'>"
 386                  . join("", @events)
 387                  . "</td></tr></tbody>"
 388          . "</table>";
 389  }
 390 sub preprocess_month (@) {
 391         my %params = @_;
 392         my $one_day = DateTime::Duration->new(days => 1, end_of_month => 'limit');
 393         my $day = $params{focus}->clone->set_day(1);
 394         my $last_day
 395           = DateTime->last_day_of_month
 396          ( year  => $params{focus}->year()
 397          , month => $params{focus}->month() )->day();
 398
 399         my @pages
 400          = pagespec_match_list
 401          ( $params{page}
 402          , $params{pages}
 403          , deptype => deptype("presence")
 404                 # NOTE: add presence dependencies to update calendar when pages are added/removed
 405          );
 406
 407         # NOTE: sort the pages by days of the month
 408         my %days = map {($_=>[])} (1 .. $last_day);
 409         foreach my $page (@pages) {
 410                 my $page_ctime = DateTime->from_epoch
 411                  ( epoch     => $IkiWiki::pagectime{$page}
 412                  , time_zone => 'local'
 413                  , locale    => $config{locale}
 414                  );
 415                 push @{$days{$page_ctime->day()}}, $page;
 416          }
 417
 418         my $t='<tr>';
 419         my $first_wday = $day->clone();
 420         my $last_wday  = ($params{week_start_day} + 6) % 7;
 421         while ($first_wday->day_of_week() - 1 != $params{week_start_day}) {
 422          # NOTE: pad the begining
 423                 $first_wday->subtract_duration($one_day);
 424                 $t.="<td class='no-wday'></td>";
 425          }
 426         my $month = $day->month();
 427         for (; $day->month() == $month; $day->add_duration($one_day)) {
 428                 my $event_html
 429                  = event_html
 430                  ( $day
 431                  , {day=>1, day_abbr=>1, new => 1}
 432                  , %params );
 433                 $t.= "<td class='wday $event_html->{wday}'>";
 434                 my @events
 435                  = map {
 436                         my @tags
 437                          = map {"<li\n class='".$_->{class}."'>".$_->{link}."</li>"}
 438                          @{$_->{tags}};
 439                         "<li\n class='event'>"
 440                          . "<span class='head'>"
 441                                  . (defined $_->{hour} ? "<span class='hour'>$_->{hour}</span>" : "")
 442                                  . "<span class='link'>$_->{link}</span>"
 443                          . "</span>"
 444                          . "<ul class='tags'>".join("", @tags)."</ul>"
 445                          . "</li>\n"
 446                  }
 447                  events_of_pages($days{$day->day()}, %params);
 448                 $t .=
 449                  "<span class='head'>"
 450                          . "<span class='day'>"
 451                                  . $event_html->{day}
 452                                  . $event_html->{new}
 453                          . "</span>"
 454                  . "</span>"
 455                  . "<ul class='events'>".join("", @events)."</ul>";
 456                 $t.='</td>';
 457                 if ($day->day_of_week() - 1 == $last_wday) {
 458                         $t.="</tr>";
 459                         $t.="<tr>"
 460                                 if ($day->day_of_month() < $last_day);
 461                  }
 462          }
 463         while ($day->day_of_week() - 1 != $params{week_start_day}) {
 464          # NOTE: pad the end
 465                 $day->add_duration($one_day);
 466                 $t.="<td class='no-wday'></td>";
 467          }
 468         $t.='</tr>';
 469         my $event_html
 470          = event_html
 471          ( $params{focus}
 472          , {year=>1, month=>1, month_name=>1}
 473          , %params );
 474         return
 475          "<table class='month'>"
 476          . "<thead>"
 477                  . "<tr>"
 478                  . "<th colspan='7'>"
 479                  . "<span class='month'>$event_html->{month}</span>"
 480                  . " <span class='year'>$event_html->{year}</span>"
 481                  . "</th>"
 482                  . "</tr>"
 483                  . "<tr>"
 484                  . join ("", map {
 485                         $_ = "<th><span>".$first_wday->day_name()."</span></th>";
 486                         $first_wday->add_duration($one_day);
 487                         $_ } (1..7))
 488                  . "</tr>"
 489          . "</thead>"
 490          . "<tbody>$t</tbody></table>";
 491  }
 492 sub preprocess (@) {
 493         my %params = @_;
 494         $params{focus} = $now->clone;
 495
 496         $params{pages} = "*"        unless defined $params{pages};
 497         $params{type}  = "month"    unless defined $params{type};
 498         $params{week_start_day} = 0 unless defined $params{week_start_day};
 499         $params{week_start_day} = $params{week_start_day} % 7;
 500
 501         unless (defined $params{base}) {
 502                 $params{base}
 503                  = defined $config{events_base}
 504                  ? $config{events_base}
 505                  : gettext('Agenda');
 506          }
 507         if (defined $params{day}) {
 508                 if ($params{day} =~ m/^([+-])(\d+)$/) {
 509                         my ($sign, $days) = ($1, $2);
 510                         my $duration = DateTime::Duration->new(days => $days, end_of_month => 'limit');
 511                         $params{focus}
 512                          = $sign eq '+'
 513                          ? $params{focus}->add_duration($duration)
 514                          : $params{focus}->subtract_duration($duration);
 515                  }
 516                 else {
 517                         $params{focus}->set(day => $params{day});
 518                  }
 519          }
 520         else {
 521                 #$params{focus}->set(day => 1);
 522          }
 523         if (defined $params{month}) {
 524                 if ($params{month} =~ m/^([+-])(\d+)$/) {
 525                         my ($sign, $months) = ($1, $2);
 526                         my $duration = DateTime::Duration->new(months => $months, end_of_month => 'limit');
 527                         $params{focus}
 528                          = $sign eq '+'
 529                          ? $params{focus}->add_duration($duration)
 530                          : $params{focus}->subtract_duration($duration);
 531                  }
 532                 else {
 533                         $params{focus}->set(month => $params{month});
 534                  }
 535          }
 536         if (defined $params{year}) {
 537                 if ($params{year} =~ m/^([+-])(\d+)$/) {
 538                         my ($sign, $years) = ($1, $2);
 539                         my $duration = DateTime::Duration->new(years => $years, end_of_month => 'limit');
 540                         $params{focus}
 541                          = $sign eq '+'
 542                          ? $params{focus}->add_duration($duration)
 543                          : $params{focus}->subtract_duration($duration);
 544                  }
 545                 else {
 546                         $params{focus}->set(year => $params{year});
 547                  }
 548          }
 549
 550         #debug("events: focus=".$params{focus}->strftime('%Y-%m-%d_%H-%M-%S'));
 551         $params{pages} =~ s[%Y][$params{focus}->year()]eg;
 552         $params{pages} =~ s[%m][sprintf('%02d', $params{focus}->month())]eg;
 553         $params{pages} =~ s[%d][sprintf('%02d', $params{focus}->day())]eg;
 554
 555         set_next_rendering(%params);
 556
 557         my $calendar = "";
 558         if ($params{type} eq 'month') {
 559                 $calendar = preprocess_month(%params);
 560          }
 561         elsif ($params{type} eq 'day') {
 562                 $calendar = preprocess_day(%params);
 563          }
 564
 565         return "<div class='calendar'>$calendar</div>";
 566  }
 567
 568 # new
 569 sub tmpl ($$) {
 570         my ($base, $model) = @_;
 571         my $page = IkiWiki::dirname($base).'/'.'templates/'.$model;
 572         my $file = defined srcfile($page, 1) ? '/'.$page : $model;
 573         return template($file);
 574  }
 575 sub date_of_form ($$;%) {
 576         my ($form, $prefix, %default) = @_;
 577         %default =
 578          ( year   => 0
 579          , month  => 1
 580          , day    => 1
 581          , hour   => 0
 582          , minute => 0
 583          , %default
 584          );
 585         my $date;
 586         eval { $date = DateTime->new
 587          ( year       => ($form->field($prefix.'_year')   ne '' ? $form->field($prefix.'_year')                : $default{year})
 588          , month      => ($form->field($prefix.'_month')  ne '' ? substr($form->field($prefix.'_month'), 0, 2) : $default{month})
 589          , day        => ($form->field($prefix.'_day')    ne '' ? $form->field($prefix.'_day')                 : $default{day})
 590          , hour       => ($form->field($prefix.'_hour')   ne '' ? $form->field($prefix.'_hour')                : $default{hour})
 591          , minute     => ($form->field($prefix.'_minute') ne '' ? $form->field($prefix.'_minute')              : $default{minute})
 592          , second     => 0
 593          , nanosecond => 0
 594          , time_zone  => 'local'
 595          , locale     => $config{locale}
 596          )->set_time_zone('floating') };
 597         return $date;
 598  };
 599 sub duration_of_form ($$) {
 600         my ($form, $prefix) = @_;
 601         my $dur;
 602         eval { $dur = DateTime::Duration->new
 603          ( years        => $form->field($prefix.'_year')
 604          , months       => $form->field($prefix.'_month')
 605          , days         => $form->field($prefix.'_day')
 606          , weeks        => $form->field($prefix.'_week')
 607          , hours        => $form->field($prefix.'_hour')
 608          , minutes      => $form->field($prefix.'_minute')
 609          , seconds      => 0
 610          , nanoseconds  => 0
 611          , end_of_month => 'limit'
 612          ) };
 613         return $dur;
 614  };
 615 sub page_of_event ($$$$$) {
 616         my ($form, $from_date, $to_date, $name, $base) = @_;
 617         my $time = '';
 618         if ($form->field('from_hour')   ne ''
 619         or  $form->field('from_minute') ne '') {
 620                 if ($from_date->hour() == $to_date->hour()
 621                  and $from_date->minute() == $to_date->minute()) {
 622                         $time = sprintf('%02dh%02d', $from_date->hour(), $from_date->minute());
 623                  }
 624                 else {
 625                         $time = sprintf('%02dh%02d-%02dh%02d'
 626                          , $from_date->hour(), $from_date->minute()
 627                          , $to_date->hour(), $to_date->minute());
 628                  }
 629          }
 630         return
 631          ( $base
 632          . ($base?'/':'').$from_date->year()
 633          . '/'.sprintf('%02d', $from_date->month())
 634          . '/'.sprintf('%02d', $from_date->day())
 635          . '/'. ($time ne '' ? $time . '/' : '')
 636          . $name
 637          );
 638  }
 639 sub check_cannewevent ($$$$) {
 640         my $dest=shift;
 641         my $destfile=shift;
 642         my $cgi=shift;
 643         my $session=shift;
 644
 645         # Must be a legal filename.
 646         if (IkiWiki::file_pruned($destfile)) {
 647                 error(sprintf(gettext("illegal name")));
 648          }
 649         # Must not be a known source file.
 650         if (exists $pagesources{$dest}) {
 651                 error(sprintf(gettext("%s already exists"),
 652                         htmllink("", "", $dest
 653                          , linktext => $dest
 654                          , noimageinline => 1)));
 655          }
 656         # Must not exist on disk already.
 657         if (-l "$config{srcdir}/$destfile" || -e _) {
 658                 error(sprintf(gettext("%s already exists on disk"), $destfile));
 659          }
 660
 661         # Must be editable.
 662         IkiWiki::check_canedit($dest, $cgi, $session);
 663
 664         my $can_newevent;
 665         IkiWiki::run_hooks(can_newevent => sub {
 666                 return if defined $can_newevent;
 667                 my $ret=shift->(cgi => $cgi, session => $session, dest => $dest, destfile => $destfile);
 668                 if (defined $ret) {
 669                         if ($ret eq "") {
 670                                 $can_newevent=1;
 671                          }
 672                         elsif (ref $ret eq 'CODE') {
 673                                 $ret->();
 674                                 $can_newevent=0;
 675                          }
 676                         elsif (defined $ret) {
 677                                 error($ret);
 678                                 $can_newevent=0;
 679                          }
 680                  }
 681          });
 682         return defined $can_newevent ? $can_newevent : 1;
 683  }
 684 sub post_newevent ($$$) {
 685         my $cgi=shift;
 686         my $session=shift;
 687         my $dest=shift;
 688
 689         IkiWiki::redirect($cgi, urlto($dest));
 690         exit;
 691  }
 692 sub newevent_hook {
 693         my %params  = @_;
 694         my @events  = @{$params{events}};
 695         my %done    = %{$params{done}};
 696         my $cgi     = $params{cgi};
 697         my $session = $params{session};
 698         return ()
 699                 unless @events;
 700         my @next;
 701         foreach my $event (@events) {
 702                 unless (exists $done{$event->{page}} && $done{$event->{file}}) {
 703                         IkiWiki::run_hooks(newevent => sub {
 704                                 push @next, shift->
 705                                  ( cgi     => $cgi
 706                                  , event   => $event
 707                                  , session => $session
 708                                  );
 709                          });
 710                         $done{$event->{page}} = 1;
 711                  }
 712          }
 713         push @events, newevent_hook
 714          ( cgi     => $cgi
 715          , done    => \%done
 716          , events  => \@next
 717          , session => $session
 718          );
 719         my %seen; # NOTE: insure unicity
 720         return grep { ! $seen{$_->{page}}++ } @events;
 721  }
 722 sub preview($$$$$) {
 723         my ($cgi, $session, $form, $events, $months) = @_;
 724         $form->tmpl_param(year   => gettext("year"));
 725         $form->tmpl_param(month  => gettext("month"));
 726         $form->tmpl_param(day    => gettext("day"));
 727         $form->tmpl_param(hour   => gettext("hour"));
 728         $form->tmpl_param(min    => gettext("min"));
 729         $form->tmpl_param(dow    => gettext("day of week"));
 730         $form->tmpl_param(page   => gettext("page"));
 731         $form->tmpl_param(events => [
 732                 map {
 733                         { from_year      => $_->{from}->year()
 734                         , from_month     => sprintf('%02d', $_->{from}->month())
 735                         , from_monthname => $months->{$_->{from}->month()}
 736                         , from_day       => sprintf('%02d', $_->{from}->day())
 737                         , from_hour      => sprintf('%02d', $_->{from}->hour())
 738                         , from_minute    => sprintf('%02d', $_->{from}->minute())
 739                         , from_dow       => $_->{from}->dow()
 740                         , from_downame   => $_->{from}->day_name()
 741                         , to_year        => $_->{to}->year()
 742                         , to_month       => sprintf('%02d', $_->{to}->month())
 743                         , to_monthname   => $months->{$_->{to}->month()}
 744                         , to_day         => sprintf('%02d', $_->{to}->day())
 745                         , to_hour        => sprintf('%02d', $_->{to}->hour())
 746                         , to_minute      => sprintf('%02d', $_->{to}->minute())
 747                         , to_dow         => $_->{to}->dow()
 748                         , page           =>
 749                                 htmllink("", "", $_->{page}
 750                                  , linktext => $_->{page}
 751                                  , noimageinline => 1)
 752                         }
 753                  } @$events
 754          ]);
 755         if (@$events > 0) {
 756                 my $page = @$events[0];
 757                 # FROM: editpage.pm
 758                 my $new = not exists $pagesources{$page};
 759                 # temporarily record its type
 760                 my $type = $config{default_pageext};
 761                 $pagesources{$page} = $page.".".$type if $new;
 762                 my %wasrendered = map { $_ => 1 } @{$renderedfiles{$page}};
 763                 my $content = @$events[0]->{content};
 764
 765                 IkiWiki::run_hooks(editcontent => sub {
 766                         $content = shift->
 767                          ( cgi     => $cgi
 768                          , content => $content
 769                          , page    => $page
 770                          , session => $session
 771                          );
 772                  });
 773                 my $preview = IkiWiki::htmlize($page, $page, $type,
 774                         IkiWiki::linkify($page, $page,
 775                         IkiWiki::preprocess($page, $page,
 776                         IkiWiki::filter($page, $page, $content), 0, 1)));
 777                 IkiWiki::run_hooks(format => sub {
 778                         $preview = shift->
 779                          ( content => $preview
 780                          , page    => $page
 781                          );
 782                  });
 783                 $form->tmpl_param("preview", $preview);
 784
 785                 # Previewing may have created files on disk.
 786                 # Keep a list of these to be deleted later.
 787                 my %previews = map { $_ => 1 } @{$wikistate{editpage}{previews}};
 788                 foreach my $f (@{$renderedfiles{$page}}) {
 789                         $previews{$f} = 1 unless $wasrendered{$f};
 790                  }
 791
 792                 # Throw out any other state changes made during previewing,
 793                 # and save the previews list.
 794                 IkiWiki::loadindex();
 795                 @{$wikistate{editpage}{previews}} = keys %previews;
 796                 IkiWiki::saveindex();
 797          }
 798         else {
 799                 $form->tmpl_param("preview", gettext("No event"));
 800          }
 801  }
 802 sub create ($$$$$) {
 803         my ($event, $cgi, $session, $months, $base) = @_;
 804         check_cannewevent
 805          ( $event->{page}
 806          , $event->{file}
 807          , $cgi
 808          , $session
 809          );
 810         my $pageext = $config{default_pageext};
 811
 812         $config{cgi} = 0; # NOTE: avoid CGI error message
 813         eval { writefile($event->{file}, $config{srcdir}, $event->{content}) };
 814         if ($config{rcs}) {
 815                 IkiWiki::rcs_add($event->{file});
 816          }
 817         # month page
 818                 my $monthpage =
 819                  ( $base
 820                  . ($base?'/':'').$event->{from}->year()
 821                  . '/'.sprintf('%02d', $event->{from}->month())
 822                  );
 823                 my $monthfile = IkiWiki::newpagefile($monthpage, $pageext);
 824                 if (not exists $pagesources{$monthpage}
 825                  and not -l $config{srcdir}.'/'.$monthfile
 826                  and not -e _) {
 827                         my $tmpl_neweventmonth = tmpl($base, 'neweventmonth.tmpl');
 828                         $tmpl_neweventmonth->param(base      => $base);
 829                         $tmpl_neweventmonth->param(year      => $event->{from}->year());
 830                         $tmpl_neweventmonth->param(month     => sprintf('%02d', $event->{from}->month()));
 831                         $tmpl_neweventmonth->param(monthname => $months->{$event->{from}->month()});
 832                         my $content = $tmpl_neweventmonth->output();
 833                         eval { writefile($monthfile, $config{srcdir}, $content) };
 834                         if ($config{rcs}) {
 835                                 IkiWiki::rcs_add($monthfile);
 836                          }
 837                  }
 838         # day page
 839                 my $daypage =
 840                  ( $monthpage
 841                  . '/'.sprintf('%02d', $event->{from}->day())
 842                  );
 843                 my $dayfile = IkiWiki::newpagefile($daypage, $pageext);
 844                 if (not exists $pagesources{$daypage}
 845                  and not -l $config{srcdir}.'/'.$dayfile
 846                  and not -e _) {
 847                         my $tmpl_neweventday = tmpl($base, 'neweventday.tmpl');
 848                         $tmpl_neweventday->param(base      => $base);
 849                         $tmpl_neweventday->param(year      => $event->{from}->year());
 850                         $tmpl_neweventday->param(month     => sprintf('%02d', $event->{from}->month()));
 851                         $tmpl_neweventday->param(monthname => $months->{$event->{from}->month()});
 852                         $tmpl_neweventday->param(day       => sprintf('%02d', $event->{from}->day()));
 853                         $tmpl_neweventday->param(dayname   => $event->{from}->day_name());
 854                         my $content = $tmpl_neweventday->output();
 855                         eval { writefile($dayfile, $config{srcdir}, $content) };
 856                         if ($config{rcs}) {
 857                                 IkiWiki::rcs_add($dayfile);
 858                          }
 859                  }
 860         $config{cgi} = 1;
 861  }
 862 sub sessioncgi ($$) {
 863         my ($cgi, $session) = @_;
 864         if (defined $cgi->param('do') && $cgi->param('do') eq "newevent") {
 865                 # TOTRY: decode_cgi_utf8($cgi);
 866                 my $base = Encode::decode_utf8(URI::Escape::uri_unescape(IkiWiki::possibly_foolish_untaint($cgi->param('base'))));
 867                 &IkiWiki::check_canedit($base, $cgi, $session);
 868                 my $page = Encode::decode_utf8(URI::Escape::uri_unescape(IkiWiki::possibly_foolish_untaint($cgi->param('page'))));
 869
 870                 my $now_date = DateTime->now
 871                  ( time_zone => 'local'
 872                  , locale    => $config{locale}
 873                  )->set_time_zone('floating');
 874                 my %dows   = map { ($_ => $now_date->{locale}->day_format_wide->[ $_ ]) } (0..6);
 875                 my %months = map { ($_ => $now_date->{locale}->month_format_wide->[ $_ - 1 ]) } (1..12);
 876                 my $cgi_date;
 877                 eval { $cgi_date = DateTime->new
 878                  ( year       => defined $cgi->param("year")   ? $cgi->param("year")   : $now_date->year()
 879                  , month      => defined $cgi->param("month")  ? $cgi->param("month")  : $now_date->month()
 880                  , day        => defined $cgi->param("day")    ? $cgi->param("day")    : $now_date->day()
 881                  , hour       => defined $cgi->param("hour")   ? $cgi->param("hour")   : $now_date->hour()
 882                  , minute     => defined $cgi->param("minute") ? $cgi->param("minute") : $now_date->minute()
 883                  , second     => 0
 884                  , nanosecond => 0
 885                  , time_zone  => 'local'
 886                  , locale     => $config{locale}
 887                  )->set_time_zone('floating') };
 888                 error(sprintf(gettext("illegal date")))
 889                         unless $cgi_date;
 890
 891                 my @years = ($cgi_date->year() .. $cgi_date->year()+5);
 892                 my $week_start_day
 893                  = (defined $config{week_start_day} and $config{week_start_day} >= 0 and $config{week_start_day} <= 6)
 894                  ?          $config{week_start_day}
 895                  : 1;
 896                 my @dow_order = ($week_start_day .. 6, 0 .. $week_start_day-1);
 897
 898                 my $tags = $typedlinks{$page}{tag};
 899                 my $buttons = [qw{Preview Create}];
 900                 my ($from_date, $to_date, $end_date, $inc_dur);
 901                 my $form = CGI::FormBuilder->new
 902                  ( action => IkiWiki::cgiurl()
 903                  , charset => "utf-8"
 904                  , fields => [qw{
 905                          do base
 906                          from_date from_year from_month from_day from_hour from_minute
 907                          to_date to_year to_month to_day to_hour to_minute
 908                          inc_dur inc_year inc_month inc_week inc_day inc_hour inc_minute
 909                          end_times end_date end_year end_month end_day end_hour end_minute
 910                          dom name content
 911                          }]
 912                  , header => 0
 913                  , javascript => 0
 914                  , messages =>
 915                          {
 916                         #   form_required_text  => 'form_required_text'
 917                         # , form_invalid_text   => 'form_invalid_text'
 918                         # , form_invalid_file   => 'form_invalid_file'
 919                         # , form_invalid_input  => gettext('allowed characters: ').$config{wiki_file_chars}
 920                          form_invalid_select => gettext('invalid selection')
 921                          }
 922                  , method     => 'POST'
 923                  , name       => "newevent"
 924                  , stylesheet => 1
 925                  , params     => $cgi
 926                  , required   => [qw{do base year month day name from_date to_date end_date inc_dur}]
 927                  , submit     => [qw{Preview Create}]
 928                  , title      => gettext("newevent")
 929                  , template   => { template("newevent.tmpl") }
 930                  , validate   =>
 931                          { from_date => { perl => sub {
 932                                         my (undef, $form) = @_;
 933                                         $from_date = date_of_form($form, 'from')
 934                                                 unless defined $from_date;
 935                                         defined $from_date
 936                                  } }
 937                          , to_date   => { perl => sub {
 938                                         my (undef, $form) = @_;
 939                                         $from_date = date_of_form($form, 'from')
 940                                                 unless defined $from_date;
 941                                         if (defined $from_date) {
 942                                                 $to_date = date_of_form($form, 'to'
 943                                                  , year   => $from_date->year()
 944                                                  , month  => $from_date->month()
 945                                                  , day    => $from_date->day()
 946                                                  , hour   => $from_date->hour()
 947                                                  , minute => $from_date->minute());
 948                                                 defined $to_date
 949                                                 and (DateTime->compare($from_date, $to_date) <= 0)
 950                                          }
 951                                         else {return 0;}
 952                                  } }
 953                          , end_date  => { perl => sub {
 954                                         my (undef, $form) = @_;
 955                                         if ( $form->field('end_year')   ne ''
 956                                          or  $form->field('end_month')  ne ''
 957                                          or  $form->field('end_day')    ne '' ) {
 958                                                 $from_date = date_of_form($form, 'from')
 959                                                         unless defined $from_date;
 960                                                 if (defined $from_date) {
 961                                                         $end_date = date_of_form($form, 'end'
 962                                                          , year   => $from_date->year()
 963                                                          , month  => $from_date->month()
 964                                                          , day    => $from_date->day()
 965                                                          , hour   => $from_date->hour()
 966                                                          , minute => $from_date->minute());
 967                                                         (defined $from_date and defined $end_date
 968                                                         and DateTime->compare($from_date, $end_date) <= 0)
 969                                                  }
 970                                                 else {return 0;}
 971                                          }
 972                                         else {
 973                                                 1;
 974                                          }
 975                                  } }
 976                          , name => '/^.+$/'
 977                          , base => '/^.*$/'
 978                          , end_times  => sub { $_[0] =~ m/^\d+$/ and $_[0] >= 0 }
 979                          , inc_year   => sub { $_[0] =~ m/^\d+$/ and $_[0] >= 0 }
 980                          , inc_month  => sub { $_[0] =~ m/^\d+$/ and $_[0] >= 0 }
 981                          , inc_week   => sub { $_[0] =~ m/^\d+$/ and $_[0] >= 0 }
 982                          , inc_day    => sub { $_[0] =~ m/^\d+$/ and $_[0] >= 0 }
 983                          , inc_hour   => sub { $_[0] =~ m/^\d+$/ and $_[0] >= 0 }
 984                          , inc_minute => sub { $_[0] =~ m/^\d+$/ and $_[0] >= 0 }
 985                          , inc_dur    => sub {
 986                                         my (undef, $form) = @_;
 987                                         $inc_dur = duration_of_form($form, 'inc');
 988                                         defined $inc_dur
 989                                         and ($inc_dur->is_positive() or $inc_dur->is_zero());
 990                                  }
 991                          }
 992                  );
 993                 $base = $form->field('base') ? $form->field('base') : $base;
 994                 $form->title(sprintf(gettext("creating new events"), pagetitle(IkiWiki::basename($page))));
 995                 $form->field(name => "do", type => "hidden", value => 'newevent', force => 1);
 996                 $form->field(name => "base", type => "hidden", force => 1 , value => $base);
 997                 $form->field(name => "from_date", type => "hidden", value => '1', force => 1);
 998                 $form->field(name => "to_date", type => "hidden", value => '1', force => 1);
 999                 $form->field(name => "end_date", type => "hidden", value => '1', force => 1);
1000                 $form->field(name => "inc_dur", type => "hidden", value => '1', force => 1);
1001                 $form->field(name => "from_year", type => 'select', value => $cgi_date->year(), options => \@years);
1002                 $form->field(name => "from_month", type => 'select'
1003                  , value => sprintf("%02d", $cgi_date->month()).' - '.$months{$cgi_date->month()}
1004                  , options => [map { sprintf("%02d", $_).' - '.$months{$_} } (1..12)]);
1005                 $form->field(name => "from_day", type => 'select'
1006                  , value => sprintf("%02d", $cgi_date->day())
1007                  , options => \@days);
1008                 $form->field(name => "from_hour", type => 'select', value => '', options => \@hours);
1009                 $form->field(name => "from_minute", type => 'select', value => '', options => \@minutes);
1010                 $form->field(name => "name", type => 'text', size => 60, value => gettext('New event'));
1011                 $form->field(name => "to_year", type => 'select', value => '', options => \@years);
1012                 $form->field(name => "to_month", type => 'select'
1013                  , value => ''
1014                  , options => [map { sprintf("%02d", $_).' - '.$months{$_} } (1..12)]);
1015                 $form->field(name => "to_day", type => 'select'
1016                  , value => ''
1017                  , options => \@days);
1018                 $form->field(name => "to_hour", type => 'select', value => '', options => \@hours);
1019                 $form->field(name => "to_minute", type => 'select', value => '', options => \@minutes);
1020                 $form->field(name => "end_year", type => 'select', value => '', options => \@years);
1021                 $form->field(name => "end_month", type => 'select', value => ''
1022                  , options => [map { sprintf("%02d", $_).' - '.$months{$_} } (1..12)]);
1023                 $form->field(name => "end_day", type => 'select', value => '', options => \@days);
1024                 $form->field(name => "end_hour", type => 'select', value => '', options => \@hours);
1025                 $form->field(name => "end_minute", type => 'select', value => '', options => \@minutes);
1026                 $form->field(name => "end_times", type => 'text', value => '0', size => 2);
1027                 $form->field(name => "inc_year", type => 'text', value => '0', size => 2);
1028                 $form->field(name => "inc_month", type => 'text', value => '0', size => 2);
1029                 $form->field(name => "inc_week", type => 'text', value => '0', size => 2);
1030                 $form->field(name => "inc_day", type => 'text', value => '0', size => 2);
1031                 $form->field(name => "inc_hour", type => 'text', value => '0', size => 2);
1032                 $form->field(name => "inc_minute", type => 'text', value => '0', size => 2);
1033                 my $tmpl_neweventcontent = tmpl($base, 'neweventcontent.tmpl');
1034                 $tmpl_neweventcontent->param(title => gettext('Title of the event'));
1035                 $tmpl_neweventcontent->param(tags => [map {{name => $_}} (sort keys %$tags)]);
1036                 $form->field(name => "content", type => "textarea", size => 30, rows => 20, cols => 80
1037                  , value => $tmpl_neweventcontent->output());
1038                 $form->field(name => "dom", type => 'select', multiple => 1, size => 35
1039                  , options => [map { my $n = $_; map {($n.' '.$dows{$_})} (0..6)} ('1°', '2°', '3°', '4°', '5°')]);
1040
1041                 IkiWiki::decode_form_utf8($form);
1042                 IkiWiki::run_hooks(formbuilder_setup => sub {
1043                         shift->(form => $form, cgi => $cgi, session => $session, buttons => $buttons);
1044                  });
1045                 IkiWiki::decode_form_utf8($form);
1046
1047                 if (($form->submitted eq 'Create' || $form->submitted eq 'Preview') && $form->validate) {
1048                         #IkiWiki::checksessionexpiry($cgi, $session, $cgi->param('sid'));
1049                         $base
1050                          = $form->field('base')
1051                          ? $form->field('base')
1052                          : (defined $config{base} ? $config{base} : gettext('Agenda'));
1053                         my $end_times
1054                          = $form->field('end_times') == 0
1055                          ? undef : $form->field('end_times');
1056                         my $dom;
1057                         foreach ($form->field('dom')) {
1058                                 $dom = {} if not defined $dom;
1059                                 $dom->{$_} = 1;
1060                          }
1061                         my $name = $form->field('name');
1062                         $name = IkiWiki::possibly_foolish_untaint(IkiWiki::titlepage($name));
1063                                 # NOTE: these untaints are safe because of the checks
1064                                 #       performed in check_cannewevent later.
1065                         my $content = $form->field('content');
1066                         $content =~ s/\r\n/\n/gs;
1067                         $content =~ s/\n$//s;
1068
1069                         # Queue of event creations to perfom.
1070                         my @events = ();
1071                         my $events_try = 0;
1072                         my $events_max
1073                          = defined $config{newevent_max_per_commit}
1074                          ? $config{newevent_max_per_commit} : (2 * 365) ;
1075                         my $pageext = $config{default_pageext};
1076                         while (++$events_try <= $events_max
1077                          and (not defined $end_times or --$end_times >= 0)
1078                          and (not defined $end_date or DateTime->compare($from_date, $end_date) <= 0)) {
1079                                 my $dest = page_of_event($form, $from_date, $to_date, $name, $base);
1080                                 my $week = $from_date->weekday_of_month();
1081                                 my $day = $now_date->{locale}->day_format_wide->[$from_date->day_of_week()-1];
1082                                 if (not defined $dom or exists $dom->{"$week° $day"}) {
1083                                         push @events,
1084                                          { page => $dest
1085                                          , file => IkiWiki::newpagefile($dest, $pageext)
1086                                          , from => $from_date
1087                                          , to   => $to_date
1088                                          , name => $name
1089                                          };
1090                                  }
1091                                 last unless defined $inc_dur and $inc_dur->is_positive();
1092                                 $from_date = $from_date->clone->add_duration($inc_dur);
1093                                 $to_date   = $to_date->clone->add_duration($inc_dur);
1094                          }
1095                         error("events try per commit overflow: $events_max")
1096                                 unless $events_try <= $events_max;
1097                         my $tmpl_neweventpage = tmpl($base, 'neweventpage.tmpl');
1098                         my $i = 0;
1099                         foreach (@events) {
1100                                 $tmpl_neweventpage->clear_params();
1101                                 $tmpl_neweventpage->param(content => $content);
1102                                 $tmpl_neweventpage->param(page => $_->{page});
1103                                 $tmpl_neweventpage->param(event => $i);
1104                                 $tmpl_neweventpage->param("event_first" => 1)
1105                                         if $i == 0;
1106                                 $tmpl_neweventpage->param("event_last" => 1)
1107                                         if $i == @events - 1;
1108                                 $tmpl_neweventpage->param(events => \@events);
1109                                 $tmpl_neweventpage->param(from_date => "$_->{from}");
1110                                 $tmpl_neweventpage->param(name => $_->{name});
1111                                 $tmpl_neweventpage->param(to_date => "$_->{to}");
1112                                 $_->{content} = $tmpl_neweventpage->output();
1113                                 $i++;
1114                          }
1115                         if ($form->submitted eq 'Create') {
1116                                 @events = newevent_hook
1117                                  ( cgi     => $cgi
1118                                  , done    => {}
1119                                  , events  => \@events
1120                                  , session => $session
1121                                  );
1122                                 require IkiWiki::Render;
1123                                 if ($config{rcs}) {
1124                                         IkiWiki::disable_commit_hook()
1125                                  }
1126                                 foreach my $event (@events) {
1127                                         create($event, $cgi, $session, \%months, $base);
1128                                  }
1129                                 if ($config{rcs}) {
1130                                         IkiWiki::rcs_commit_staged
1131                                          ( message => sprintf(gettext("new event"))
1132                                          , session => $session );
1133                                         IkiWiki::enable_commit_hook();
1134                                         IkiWiki::rcs_update();
1135                                  }
1136                                 IkiWiki::refresh();
1137                                 IkiWiki::saveindex();
1138
1139                                 post_newevent($cgi, $session, (defined $events[0] ? $events[0]->{page} : ''));
1140                          }
1141                         elsif ($form->submitted eq 'Preview') {
1142                                 preview($cgi, $session, $form, \@events, \%months);
1143                                 IkiWiki::showform($form, $buttons, $session, $cgi);
1144                          }
1145                  }
1146                 else {
1147                         IkiWiki::showform($form, $buttons, $session, $cgi);
1148                  }
1149
1150                 exit 0;
1151          }
1152  }
1153
1154 1;