root/branches/release-35/lib/MT/CMS/Blog.pm @ 2003

Revision 2003, 81.3 kB (checked in by fumiakiy, 20 months ago)

L10 Japanese the Cal release, take one.
  • Property svn:keywords set to Id Revision
Line 
1package MT::CMS::Blog;
2
3use strict;
4
5sub edit {
6    my $cb = shift;
7    my ($app, $id, $obj, $param) = @_;
8
9    my $q = $app->param;
10    my $cfg = $app->config;
11    my $blog = $app->blog;
12    my $blog_id = $id;
13
14    if ($id) {
15        my $output = $param->{output} ||= 'cfg_prefs.tmpl';
16        $param->{need_full_rebuild}  = 1 if $q->param('need_full_rebuild');
17        $param->{need_index_rebuild} = 1 if $q->param('need_index_rebuild');
18        $param->{show_ip_info} = $cfg->ShowIPInformation;
19        $param->{use_plugins} = $cfg->UsePlugins;
20
21        my $entries_on_index = ( $obj->entries_on_index || 0 );
22        if ($entries_on_index) {
23            $param->{'list_on_index'} = $entries_on_index;
24            $param->{'posts'}         = 1;
25        }
26        else {
27            $param->{'list_on_index'} = ( $obj->days_on_index || 0 );
28            $param->{'days'} = 1;
29        }
30        my $lang = $obj->language || 'en';
31        $lang = 'en' if lc($lang) eq 'en-us' || lc($lang) eq 'en_us';
32        $lang = 'ja' if lc($lang) eq 'jp';
33        $param->{ 'language_' . $lang } = 1;
34
35        $param->{system_allow_comments} = $cfg->AllowComments;
36        $param->{system_allow_pings}    = $cfg->AllowPings;
37        $param->{tk_available}          = eval { require MIME::Base64; 1; }
38          && eval { require LWP::UserAgent; 1 };
39        $param->{'auto_approve_commenters'} =
40          !$obj->manual_approve_commenters;
41        $param->{identity_system}     = $app->config('IdentitySystem');
42        $param->{handshake_return}    = $app->base . $app->mt_uri;
43        $param->{"moderate_comments"} = $obj->moderate_unreg_comments;
44        $param->{ "moderate_comments_"
45              . ( $obj->moderate_unreg_comments || 0 ) } = 1;
46        $param->{ "moderate_pings_" . ( $obj->moderate_pings || 0 ) } = 1;
47
48        my $cmtauth_reg = $app->registry('commenter_authenticators');
49        foreach my $auth ( keys %$cmtauth_reg ) {
50            $cmtauth_reg->{$auth}->{disabled} = 1
51              if exists( $cmtauth_reg->{$auth}->{condition} )
52              && !( $cmtauth_reg->{$auth}->{condition}->() );
53        }
54        if ( my $auths = $blog->commenter_authenticators ) {
55            foreach ( split ',', $auths ) {
56                if ( 'MovableType' eq $_ ) {
57                    $param->{enabled_MovableType} = 1;
58                }
59                else {
60                    $cmtauth_reg->{$_}->{enabled} = 1;
61                }
62            }
63        }
64        my @cmtauth_loop;
65        foreach ( keys %$cmtauth_reg ) {
66            $cmtauth_reg->{$_}->{key} = $_;
67            if (
68                UNIVERSAL::isa(
69                    $cmtauth_reg->{$_}->{plugin}, 'MT::Plugin'
70                )
71              )
72            {
73                push @cmtauth_loop, $cmtauth_reg->{$_};
74            }
75        }
76        unshift @cmtauth_loop, $cmtauth_reg->{'TypeKey'}
77          if exists( $cmtauth_reg->{'TypeKey'} )
78          && $blog->remote_auth_token;
79        unshift @cmtauth_loop, $cmtauth_reg->{'Vox'}
80          if exists $cmtauth_reg->{'Vox'};
81        unshift @cmtauth_loop, $cmtauth_reg->{'LiveJournal'}
82          if exists $cmtauth_reg->{'LiveJournal'};
83        unshift @cmtauth_loop, $cmtauth_reg->{'OpenID'}
84          if exists $cmtauth_reg->{'OpenID'};
85
86        $param->{cmtauth_loop} = \@cmtauth_loop;
87
88        if ( $output eq 'cfg_prefs.tmpl' ) {
89            $app->add_breadcrumb( $app->translate('General Settings') );
90
91            my $lang = $obj->language || 'en';
92            $lang = 'en' if lc($lang) eq 'en-us' || lc($lang) eq 'en_us';
93            $lang = 'ja' if lc($lang) eq 'jp';
94            $param->{ 'language_' . $lang } = 1;
95
96            if ( $obj->cc_license ) {
97                $param->{cc_license_name} =
98                  MT::Util::cc_name( $obj->cc_license );
99                $param->{cc_license_image_url} =
100                  MT::Util::cc_image( $obj->cc_license );
101                $param->{cc_license_url} =
102                  MT::Util::cc_url( $obj->cc_license );
103            }
104        }
105        elsif ( $output eq 'cfg_entry.tmpl' ) {
106            ## load entry preferences for new/edit entry page of the blog
107            my $pref_param = $app->load_entry_prefs;
108            %$param = ( %$param, %$pref_param );
109            $param->{ 'sort_order_posts_'
110                  . ( $obj->sort_order_posts || 0 ) } = 1;
111            $param->{ 'status_default_' . $obj->status_default } = 1
112              if $obj->status_default;
113            $param->{ 'allow_comments_default_'
114                  . ( $obj->allow_comments_default || 0 ) } = 1;
115            $param->{system_allow_pings} =
116              $cfg->AllowPings && $blog->allow_pings;
117            $param->{system_allow_comments} = $cfg->AllowComments
118              && ( $blog->allow_reg_comments
119                || $blog->allow_unreg_comments );
120            my $replace_fields = $blog->smart_replace_fields || '';
121            my @replace_fields = split( /,/, $replace_fields );
122            foreach my $fld (@replace_fields) {
123                $param->{ 'nwc_' . $fld } = 1;
124            }
125            $param->{ 'nwc_smart_replace_' . ( $blog->smart_replace || 0 ) } = 1;
126            $param->{ 'nwc_replace_none' } = ( $blog->smart_replace || 0 ) == 2;
127        }
128        elsif ( $output eq 'cfg_web_services.tmpl' ) {
129            $param->{system_disabled_notify_pings} =
130              $cfg->DisableNotificationPings;
131            $param->{system_allow_outbound_pings} =
132              $cfg->OutboundTrackbackLimit eq 'any';
133            my %selected_pings = map { $_ => 1 }
134              split ',', ($obj->update_pings || '');
135            my $pings = $app->registry('ping_servers');
136            my @pings;
137            push @pings,
138              {
139                key   => $_,
140                label => $pings->{$_}->{label},
141                exists( $selected_pings{$_} ) ? ( selected => 1 ) : (),
142              } foreach keys %$pings;
143            $param->{pings_loop} = \@pings;
144        }
145        elsif ( $output eq 'cfg_comments.tmpl' ) {
146            $param->{email_new_comments_1} =
147              ( $obj->email_new_comments || 0 ) == 1;
148            $param->{email_new_comments_2} =
149              ( $obj->email_new_comments || 0 ) == 2;
150            $param->{nofollow_urls}     = $obj->nofollow_urls;
151            $param->{follow_auth_links} = $obj->follow_auth_links;
152            $param->{ 'sort_order_comments_'
153                  . ( $obj->sort_order_comments || 0 ) } = 1;
154            $param->{global_sanitize_spec} = $cfg->GlobalSanitizeSpec;
155            $param->{ 'sanitize_spec_' . ( $obj->sanitize_spec ? 1 : 0 ) } =
156              1;
157            $param->{sanitize_spec_manual} = $obj->sanitize_spec
158              if $obj->sanitize_spec;
159            $param->{allow_comments} = $blog->allow_reg_comments
160              || $blog->allow_unreg_comments;
161            $param->{use_comment_confirmation} =
162              defined $blog->use_comment_confirmation
163              ? $blog->use_comment_confirmation
164              : 0;
165            $param->{system_allow_comments} = $cfg->AllowComments
166              && ( $blog->allow_reg_comments
167                || $blog->allow_unreg_comments );
168            my @cps = MT->captcha_providers;
169
170            foreach my $cp (@cps) {
171                if ( ( $blog->captcha_provider || '' ) eq $cp->{key} ) {
172                    $cp->{selected} = 1;
173                }
174            }
175            $param->{captcha_loop} = \@cps;
176        }
177        elsif ( $output eq 'cfg_trackbacks.tmpl' ) {
178            $param->{email_new_pings_1} = ( $obj->email_new_pings || 0 ) == 1;
179            $param->{email_new_pings_2} = ( $obj->email_new_pings || 0 ) == 2;
180            $param->{nofollow_urls}     = $obj->nofollow_urls;
181            $param->{system_allow_selected_pings} =
182              $cfg->OutboundTrackbackLimit eq 'selected';
183            $param->{system_allow_outbound_pings} =
184              $cfg->OutboundTrackbackLimit eq 'any';
185            $param->{system_allow_local_pings} =
186                 ( $cfg->OutboundTrackbackLimit eq 'local' )
187              || ( $cfg->OutboundTrackbackLimit eq 'any' );
188        }
189        elsif ( $output eq 'cfg_registration.tmpl' ) {
190            $param->{commenter_authenticators} =
191              $obj->commenter_authenticators;
192            my $registration = $cfg->CommenterRegistration;
193            if ( $registration->{Allow} ) {
194                $param->{registration} =
195                  $blog->allow_commenter_regist ? 1 : 0;
196            }
197            else {
198                $param->{system_disallow_registration} = 1;
199            }
200            $param->{allow_reg_comments} = $blog->allow_reg_comments;
201            $param->{allow_unreg_comments} = $blog->allow_unreg_comments;
202            $param->{require_typekey_emails} = $obj->require_typekey_emails;
203        }
204        elsif ( $output eq 'cfg_spam.tmpl' ) {
205            my $threshold = $obj->junk_score_threshold || 0;
206            $threshold = '+' . $threshold if $threshold > 0;
207            $param->{junk_score_threshold} = $threshold;
208            $param->{junk_folder_expiry}   = $obj->junk_folder_expiry || 60;
209            $param->{auto_delete_junk}     = $obj->junk_folder_expiry;
210        }
211        elsif ( $output eq 'cfg_archives.tmpl' ) {
212            $app->add_breadcrumb( $app->translate('Publishing Settings') );
213            if (   $obj->column('archive_path')
214                || $obj->column('archive_url') )
215            {
216                $param->{enable_archive_paths} = 1;
217                $param->{archive_path}         = $obj->column('archive_path');
218                $param->{archive_url}          = $obj->column('archive_url');
219            }
220            else {
221                $param->{archive_path} = '';
222                $param->{archive_url}  = '';
223            }
224            $param->{ 'archive_type_preferred_'
225                  . $blog->archive_type_preferred } = 1
226              if $blog->archive_type_preferred;
227            my $at = $blog->archive_type;
228            if ( $at && $at ne 'None' ) {
229                my @at = split /,/, $at;
230                for my $at (@at) {
231                    $param->{ 'archive_type_' . $at } = 1;
232                }
233            }
234            require MT::PublishOption;
235            if ( $app->model('template')->exist(
236                    { blog_id => $blog->id, build_type => MT::PublishOption::DYNAMIC() })
237              || $app->model('templatemap')->exist(
238                    { blog_id => $blog->id, build_type => MT::PublishOption::DYNAMIC() }) )
239            {
240                $param->{dynamic_enabled} = 1;
241            }
242            eval "require List::Util; require Scalar::Util;";
243            unless ($@) {
244                $param->{can_use_publish_queue} = 1;
245            }
246            if ( $blog->publish_queue ) {
247                $param->{publish_queue} = 1;
248            }
249            if ( $blog->include_cache ) {
250                $param->{include_cache} = 1;
251            }
252        }
253        elsif ( $output eq 'cfg_plugin.tmpl' ) {
254            $app->add_breadcrumb( $app->translate('Plugin Settings') );
255            $param->{blog_view} = 1;
256            require MT::CMS::Plugin;
257            MT::CMS::Plugin::build_plugin_table( $app,
258                param => $param,
259                scope => 'blog:' . $blog_id
260            );
261            $param->{can_config} = 1;
262        }
263        else {
264            $app->add_breadcrumb( $app->translate('Settings') );
265        }
266        ( my $offset = $obj->server_offset ) =~ s![-\.]!_!g;
267        $offset =~ s!_0+$!!; # fix syntax highlight ->!
268        $param->{ 'server_offset_' . $offset } = 1;
269        if ( $output eq 'cfg_comments.tmpl' ) {
270            ## Load text filters.
271            $param->{text_filters_comments} =
272              $app->load_text_filters( $obj->convert_paras_comments,
273                'comment' );
274        }
275        elsif ( $output eq 'cfg_entry.tmpl' ) {
276            ## Load text filters.
277            $param->{text_filters} =
278              $app->load_text_filters( $obj->convert_paras, 'entry' );
279        }
280        $param->{nav_config} = 1;
281        $param->{error} = $app->errstr if $app->errstr;
282    } else {
283        $app->add_breadcrumb( $app->translate('New Blog') );
284        ( my $tz = $cfg->DefaultTimezone ) =~ s![-\.]!_!g;
285        $tz =~ s!_00$!!; # fix syntax highlight ->!
286        $param->{ 'server_offset_' . $tz } = 1;
287        $param->{'can_edit_config'}        = $app->user->can_create_blog;
288        $param->{'can_set_publish_paths'}  = $app->user->can_create_blog;
289
290        my $sets = $app->registry("template_sets");
291        $sets->{$_}{key} = $_ for keys %$sets;
292        $sets->{'mt_blog'}{selected} = 1;
293        $sets = $app->filter_conditional_list([ values %$sets ]);
294        no warnings;
295        @$sets = sort { $a->{order} <=> $b->{order} } @$sets;
296        $param->{'template_set_loop'} = $sets;
297        $param->{'template_set_index'} = $#$sets;
298    }
299
300    if (   !$param->{site_path}
301        && !( $param->{site_path} = $app->config('DefaultSiteRoot') ) )
302    {
303        my $cwd = $app->document_root;
304        $cwd = File::Spec->catdir($cwd, 'BLOG-NAME'); # for including the end of directory separator
305        $cwd =~ s!BLOG-NAME\z!!;                      # canonpath() remove it
306        $cwd =~ s!([\\/])cgi(?:-bin)?([\\/].*)?$!$1!;
307        $cwd =~ s!([\\/])mt[\\/]?$!$1!i;
308        $param->{suggested_site_path} = $cwd;
309    }
310    if ( !$param->{id} ) {
311        if ( $param->{site_path} ) {
312            $param->{site_path} =
313              File::Spec->catdir( $param->{site_path}, 'BLOG-NAME' );
314        }
315        else {
316            $param->{suggested_site_path} =
317              File::Spec->catdir( $param->{suggested_site_path},
318                'BLOG-NAME' );
319        }
320    }
321
322    # If not yet defined, set the site_url to the config default, if one exists.
323    $param->{site_url} ||= $app->config('DefaultSiteURL');
324    if ( !$param->{site_url} ) {
325        $param->{suggested_site_url} = $app->base . '/';
326        $param->{suggested_site_url} =~ s!/cgi(?:-bin)?(/.*)?$!/!;
327        $param->{suggested_site_url} =~ s!/mt/?$!/!i;
328    }
329    if ( !$param->{id} ) {
330        if ( $param->{site_url} ) {
331            $param->{site_url} .= '/'
332              unless $param->{site_url} =~ /\/$/;
333            $param->{site_url} .= 'BLOG-NAME/';
334        }
335        else {
336            $param->{suggested_site_url} .= '/'
337              unless $param->{suggested_site_url} =~ /\/$/;
338            $param->{suggested_site_url} .= 'BLOG-NAME/';
339        }
340    }
341    1;
342}
343
344sub list {
345    my $app = shift;
346
347    $app->return_to_dashboard( redirect => 1 ) if $app->param('blog_id');
348
349    my $author    = $app->user;
350    my $list_pref = $app->list_pref('blog');
351
352    my $limit  = $list_pref->{rows};
353    my $offset = $app->param('offset') || 0;
354    my $args   = { offset => $offset, sort => 'name' };
355    $args->{limit} = $limit + 1;
356    unless ( $author->is_superuser ) {
357        $args->{join} = MT::Permission->join_on(
358            'blog_id',
359            { author_id => $author->id },
360            { unique    => 1 }
361        );
362    }
363    my $blog_class       = $app->model('blog');
364    my %param            = %$list_pref;
365    my @blogs            = $blog_class->load( undef, $args );
366    my $can_edit_authors = $author->is_superuser;
367    my $blog_loop        = make_blog_list( $app, \@blogs );
368
369    if ($blog_loop) {
370        ## We tried to load $limit + 1 entries above; if we actually got
371        ## $limit + 1 back, we know we have another page of entries.
372        my $have_next = @$blog_loop > $limit;
373        pop @$blog_loop while @$blog_loop > $limit;
374        if ($offset) {
375            $param{prev_offset}     = 1;
376            $param{prev_offset_val} = $offset - $limit;
377            $param{prev_offset_val} = 0 if $param{prev_offset_val} < 0;
378        }
379        if ($have_next) {
380            $param{next_offset}     = 1;
381            $param{next_offset_val} = $offset + $limit;
382        }
383    }
384    $param{offset}      = $offset;
385    $param{object_type} = 'blog';
386    $param{list_start}  = $offset + 1;
387    delete $args->{limit};
388    delete $args->{offset};
389    $param{list_total} = $blog_class->count( undef, $args );
390    $param{list_end}        = $offset + ( $blog_loop ? scalar @$blog_loop : 0 );
391    $param{next_max}        = $param{list_total} - $limit;
392    $param{next_max}        = 0 if ( $param{next_max} || 0 ) < $offset + 1;
393    $param{can_create_blog} = $author->can_create_blog;
394    $param{saved_deleted}   = $app->param('saved_deleted');
395    $param{refreshed}       = $app->param('refreshed');
396    $param{nav_blogs}       = 1;
397    $param{list_noncron}    = 1;
398    $param{search_label}    = $app->translate('Blogs');
399
400    if ($blog_loop) {
401        $param{object_loop} = $param{blog_table}[0]{object_loop} = $blog_loop;
402        $app->load_list_actions( 'blog', \%param );
403    }
404
405    $param{page_actions} = $app->page_actions('list_blog');
406    $param{feed_name}    = $app->translate("Blog Activity Feed");
407    $param{feed_url}     = $app->make_feed_link('blog');
408    $app->add_breadcrumb( $app->translate("Blogs") );
409    $param{nav_weblogs} = 1;
410    $param{object_label} = $blog_class->class_label;
411    $param{object_label_plural} = $blog_class->class_label_plural;
412    $param{screen_class} = "list-blog";
413    $param{screen_id} = "list-blog";
414    $param{listing_screen} = 1;
415    return $app->load_tmpl( 'list_blog.tmpl', \%param );
416}
417
418sub cfg_archives {
419    my $app = shift;
420    my %param;
421    %param = %{ $_[0] } if $_[0];
422    my $q = $app->param;
423
424    my $blog_id = $q->param('blog_id');
425
426    return $app->return_to_dashboard( redirect => 1 ) unless $blog_id;
427
428    my $blog = $app->model('blog')->load($blog_id)
429        or return $app->error($app->translate('Can\'t load blog #[_1].', $blog_id));
430    my @data;
431    for my $at ( split /\s*,\s*/, $blog->archive_type ) {
432        my $archiver = $app->publisher->archiver($at);
433        next unless $archiver;
434        next if 'entry' ne $archiver->entry_class;
435        my $archive_label = $archiver->archive_label;
436        $archive_label = $at unless $archive_label;
437        $archive_label = $archive_label->() if ( ref $archive_label ) eq 'CODE';
438        push @data,
439          {
440            archive_type_translated => $archive_label,
441            archive_type            => $at,
442            archive_type_is_preferred =>
443              ( $blog->archive_type_preferred eq $at ? 1 : 0 ),
444          };
445    }
446    @data = sort { MT::App::CMS::archive_type_sorter( $a, $b ) } @data;
447    $param{entry_archive_types} = \@data;
448    $param{saved_deleted}       = 1 if $q->param('saved_deleted');
449    $param{saved_added}         = 1 if $q->param('saved_added');
450    $param{archives_changed}    = 1 if $q->param('archives_changed');
451    $param{no_writedir}         = $q->param('no_writedir');
452    $param{no_cachedir}         = $q->param('no_cachedir');
453    $param{no_writecache}       = $q->param('no_writecache');
454    $param{include_system}      = $blog->include_system || '';
455
456    if ( $app->config->ObjectDriver =~ qr/(db[id]::)?sqlite/i ) {
457        $param{hide_build_option} = 1
458          unless $app->config->UseSQLite2;
459    }
460    my $mtview_path = File::Spec->catfile( $blog->site_path(), "mtview.php" );
461
462    if ( -f $mtview_path ) {
463        open my ($fh), $mtview_path;
464        while ( my $line = <$fh> ) {
465            $param{dynamic_caching} = 1
466              if $line =~ m/^\s*\$mt->caching\s*=\s*true;/i;
467            $param{dynamic_conditional} = 1
468              if $line =~ /^\s*\$mt->conditional\s*=\s*true;/i;
469        }
470        close $fh;
471    }
472    $param{output} = 'cfg_archives.tmpl';
473    $q->param( '_type', 'blog' );
474    $q->param( 'id',    $blog_id );
475    $param{screen_class} = "settings-screen archive-settings";
476    $param{object_type}  = 'author';
477    $param{search_label} = $app->translate('Users');
478    $app->forward( "view", \%param );
479}
480
481sub cfg_prefs {
482    my $app     = shift;
483    my $q       = $app->param;
484    my $blog_id = scalar $q->param('blog_id');
485    return $app->return_to_dashboard( redirect => 1 )
486      unless $blog_id;
487    $q->param( '_type', 'blog' );
488    $q->param( 'id',    $blog_id );
489    my $blog_prefs = $app->user_blog_prefs;
490    my $perms      = $app->permissions;
491    return $app->error( $app->translate('Permission denied.') )
492      unless $app->user->is_superuser()
493      || (
494        $perms
495        && (   $perms->can_edit_config
496            || $perms->can_administer_blog
497            || $perms->can_set_publish_paths )
498      );
499    my $output = 'cfg_prefs.tmpl';
500    $app->forward("view",
501        {
502            output       => $output,
503            screen_class => 'settings-screen general-screen'
504        }
505    );
506}
507
508sub cfg_web_services {
509    my $app     = shift;
510    my $q       = $app->param;
511    my $blog_id = scalar $q->param('blog_id');
512    return $app->return_to_dashboard( redirect => 1 )
513      unless $blog_id;
514    $q->param( '_type', 'blog' );
515    $q->param( 'id',    scalar $q->param('blog_id') );
516    $app->forward( "view",
517        {
518            output       => 'cfg_web_services.tmpl',
519            screen_class => 'settings-screen web-services-settings'
520        }
521    );
522}
523
524sub rebuild_phase {
525    my $app  = shift;
526    my $type = $app->param('_type') || 'entry';
527    my @ids  = $app->param('id');
528    $app->{goback} = "window.location='" . $app->return_uri . "'";
529    $app->{value} ||= $app->translate('Go Back');
530    if ( $type eq 'entry' ) {
531        my %ids = map { $_ => 1 } @ids;
532        return $app->rebuild_these( \%ids );
533    }
534    elsif ( $type eq 'template' ) {
535        require MT::Template;
536        foreach (@ids) {
537            my $template = MT::Template->load($_);
538            $app->rebuild_indexes(
539                Template => $template,
540                Force    => 1
541            ) or return;
542        }
543    }
544    $app->run_callbacks('post_build');
545    $app->call_return;
546}
547
548sub rebuild_pages {
549    my $app   = shift;
550    my $perms = $app->permissions
551      or return $app->error( $app->translate("No permissions") );
552    require MT::Entry;
553    require MT::Blog;
554    my $q             = $app->param;
555    my $start_time    = $q->param('start_time');
556
557    if ( ! $start_time ) {
558        # start of build; invoke callback
559        $app->run_callbacks('pre_build');
560        $start_time = time;
561    }
562
563    my $blog_id       = int($q->param('blog_id'));
564    return $app->errtrans("Invalid request.") unless $blog_id;
565
566    my $blog          = MT::Blog->load($blog_id)
567        or return $app->error($app->translate('Can\'t load blog #[_1].', $blog_id));
568    my $order         = $q->param('type');
569    my @order         = split /,/, $order;
570    my $next          = $q->param('next');
571    my $done          = 0;
572    my $type          = $order[$next];
573
574    my $pub           = $app->publisher;
575    $pub->start_time( $start_time );  # force start time to parameter start_time
576
577    my $archiver      = $pub->archiver($type);
578    my $archive_label = $archiver ? $archiver->archive_label : '';
579
580    $archive_label = $app->translate($type) unless $archive_label;
581    $archive_label = $archive_label->() if ( ref $archive_label ) eq 'CODE';
582    $next++;
583    $done++ if $next >= @order;
584    my $offset = 0;
585    my ($total) = $q->param('total');
586
587    my ($tmpl_saved);
588
589    # Make sure errors go to a sensible place when in fs mode
590    # TODO: create contin. earlier, pass it thru
591    if ( $app->param('fs') ) {
592        my ( $type, $obj_id ) = $app->param('type') =~ m/(entry|index)-(\d+)/;
593        if ( $type && $obj_id ) {
594            my $edit_type = $type;
595            $edit_type = 'template' if $type eq 'index';
596            if ($type eq 'entry') {
597                require MT::Entry;
598                my $entry = MT::Entry->load($obj_id);
599                $edit_type = $entry ? $entry->class : 'entry';
600            }
601            $app->{goback} =
602              "window.location='"
603              . $app->object_edit_uri( $edit_type, $obj_id ) . "'";
604            $app->{value} ||= $app->translate('Go Back');
605        }
606    }
607
608    # FIXME: Wrap the entire rebuild operation with begin/end callbacks
609    if ( $type eq 'all' ) {
610        return $app->error( $app->translate("Permission denied.") )
611          unless $perms->can_rebuild;
612
613        # FIXME: Rebuild the entire blog????
614        $app->rebuild( BlogID => $blog_id )
615          or return $app->publish_error();
616    }
617    elsif ( $type eq 'index' ) {
618        return $app->error( $app->translate("Permission denied.") )
619          unless $perms->can_rebuild;
620        $app->rebuild_indexes( BlogID => $blog_id )
621            or return $app->publish_error();
622    }
623    elsif ( $type =~ /^index-(\d+)$/ ) {
624        return $app->error( $app->translate("Permission denied.") )
625          unless $perms->can_rebuild;
626        my $tmpl_id = $1;
627        require MT::Template;
628        $tmpl_saved = MT::Template->load($tmpl_id);
629        $app->rebuild_indexes(
630            BlogID   => $blog_id,
631            Template => $tmpl_saved,
632            Force    => 1
633        ) or return $app->publish_error();
634        $order = "index template '". $tmpl_saved->name . "'";
635    }
636    elsif ( $type =~ /^entry-(\d+)$/ ) {
637        my $entry_id = $1;
638        require MT::Entry;
639        my $entry = MT::Entry->load($entry_id);
640        return $app->error( $app->translate("Permission denied.") )
641          unless $perms->can_edit_entry( $entry, $app->user );
642        $app->rebuild_entry(
643            Entry             => $entry,
644            BuildDependencies => 1,
645            OldPrevious       => $q->param('old_previous'),
646            OldNext           => $q->param('old_next')
647        ) or return $app->publish_error();
648        $order = "entry '" . $entry->title . "'";
649    }
650    elsif ( $archiver->category_based ) {
651        return $app->error( $app->translate("Permission denied.") )
652          unless $perms->can_rebuild;
653        $offset = $q->param('offset') || 0;
654        my $start = time;
655        my $count = 0;
656        my $cb    = sub {
657            $count++;
658            return time - $start > 20 ? 0 : 1;
659        };
660        if ( $offset < $total ) {
661            $app->rebuild(
662                BlogID         => $blog_id,
663                ArchiveType    => $type,
664                NoIndexes      => 1,
665                Offset         => $offset,
666                Limit          => $app->config->EntriesPerRebuild,
667                FilterCallback => $cb,
668            ) or return $app->publish_error();
669            $offset += $count;
670        }
671        if ( $offset < $total ) {
672            $done-- if $done;
673            $next--;
674        }
675        else {
676            $offset = 0;
677        }
678    }
679    elsif ($type) {
680        my $special = 0;
681        my @options = $app->{rebuild_options} ||= {};
682        $app->run_callbacks( 'rebuild_options', $app, \@options );
683        for my $optn (@options) {
684            if ( ( $optn->{key} || '' ) eq $type ) {
685                $optn->{code}->();
686                $special = 1;
687            }
688        }
689        if ( !$special ) {
690            return $app->error( $app->translate("Permission denied.") )
691              unless $perms->can_rebuild;
692            $offset = $q->param('offset') || 0;
693            if ( $offset < $total ) {
694                my $start = time;
695                my $count = 0;
696                my $cb    = sub {
697                    $count++;
698                    return time - $start > 20 ? 0 : 1;
699                };
700                $app->rebuild(
701                    BlogID         => $blog_id,
702                    ArchiveType    => $type,
703                    NoIndexes      => 1,
704                    Offset         => $offset,
705                    Limit          => $app->config->EntriesPerRebuild,
706                    FilterCallback => $cb,
707                ) or return $app->publish_error();
708                $offset += $count;
709            }
710            if ( $offset < $total ) {
711                $done-- if $done;
712                $next--;
713            }
714            else {
715                $offset = 0;
716            }
717        }
718    }
719
720    # Rebuild done--now form the continuation.
721    unless ($done) {
722        my $dynamic   = 0;
723        my $type_name = $order[$next];
724
725        ## If we're moving on to the next rebuild step, recalculate the
726        ## limit.
727        my $static_count;
728        if ( $type_name !~ m/^index/ ) {
729            $static_count = $blog->count_static_templates($type_name) || 0;
730        }
731        else {
732            $static_count = 1;
733        }
734        if ( !$static_count ) {
735            $dynamic = 1;
736        }
737        elsif ( defined($offset) && $offset == 0 ) {
738            $dynamic = 0;
739        }
740        if ( $offset == 0 ) {
741
742            # determine total
743            if ( my $archiver = $app->publisher->archiver($type_name) ) {
744                if ( $archiver->entry_based || $archiver->date_based ) {
745                    my $entry_class = $archiver->entry_class || 'entry';
746                    require MT::Entry;
747                    my $terms = {
748                        class   => $entry_class,
749                        status  => MT::Entry::RELEASE(),
750                        blog_id => $blog_id,
751                    };
752                    $total = MT::Entry->count($terms);
753                }
754                elsif ( $archiver->category_based ) {
755                    require MT::Category;
756                    my $terms = { blog_id => $blog_id, };
757                    $total = MT::Category->count($terms);
758                }
759                elsif ( $archiver->author_based ) {
760                    require MT::Author;
761                    require MT::Entry;
762                    my $terms = {
763                        blog_id => $blog_id,
764                        status  => MT::Entry::RELEASE(),
765                        class   => 'entry',
766                    };
767                    $total = MT::Author->count(
768                        undef,
769                        {
770                            join   => MT::Entry->join_on( 'author_id', $terms, { unique => 1 } ),
771                            unique => 1,
772                        }
773                    );
774                }
775            }
776        }
777
778        my $type = $order[$next];
779        if ($type) {
780            $archiver      = $app->publisher->archiver($type);
781            $archive_label = $archiver ? $archiver->archive_label : '';
782            $archive_label = $app->translate($type) unless $archive_label;
783            $archive_label = $archive_label->()
784              if ( ref $archive_label ) eq 'CODE';
785        }
786
787        my $complete =
788          $total
789          ? ( $total == $offset ? 100 : int( ( $offset / $total ) * 100 ) )
790          : 0;
791
792        my %param = (
793            build_type      => $order,
794            build_next      => $next,
795            build_type_name => $archive_label,
796            archives        => $archiver ? 1 : 0,
797            total           => $total,
798            offset          => $offset,
799            complete        => $complete,
800            start_time      => $start_time,
801            incomplete      => 100 - $complete,
802            entry_id        => scalar $q->param('entry_id'),
803            dynamic         => $dynamic,
804            is_new          => scalar $q->param('is_new'),
805            old_status      => scalar $q->param('old_status'),
806            is_full_screen  => scalar $q->param('fs'),
807            return_args     => scalar $q->param('return_args')
808        );
809        $app->load_tmpl( 'rebuilding.tmpl', \%param );
810    }
811    else {
812        $app->run_callbacks( 'post_build' );
813        if ( $q->param('entry_id') ) {
814            require MT::Entry;
815            my $entry = MT::Entry->load( scalar $q->param('entry_id') )
816                or return $app->error($app->translate('Can\'t load entry #[_1].', $q->param('entry_id')));
817            require MT::Blog;
818            my $blog = MT::Blog->load( $entry->blog_id )
819                or return $app->error($app->translate('Can\'t load blog #[_1].', $entry->blog_id));
820            require MT::CMS::Entry;
821            MT::CMS::Entry::ping_continuation( $app,
822                $entry, $blog,
823                OldStatus => scalar $q->param('old_status'),
824                IsNew     => scalar $q->param('is_new'),
825            );
826        }
827        else {
828            my $all          = $order =~ /,/;
829            my $type         = $order;
830            my $is_one_index = $order =~ /index template/;
831            my $is_entry     = $order =~ /entry/;
832            my $built_type;
833            if ( $is_entry || $is_one_index ) {
834                ( $built_type = $type ) =~
835                  s/^(entry|index template)/$app->translate($1)/e;
836            }
837            else {
838                $built_type = $app->translate($type);
839            }
840            my %param = (
841                all             => $all,
842                type            => $archive_label,
843                is_one_index    => $is_one_index,
844                is_entry        => $is_entry,
845                archives        => $type ne 'index',
846                start_timestamp => MT::Util::epoch2ts($blog, $start_time),
847                total_time      => time - $start_time,
848            );
849            if ($is_one_index) {
850                $param{tmpl_url} = $blog->site_url;
851                $param{tmpl_url} .= '/' if $param{tmpl_url} !~ m!/$!;
852                $param{tmpl_url} .= $tmpl_saved->outfile;
853            }
854            if ( $q->param('fs') ) {    # full screen--go to a useful app page
855                if ( my $return_args = $q->param('return_args') ) {
856                    $app->call_return;
857                }
858                else {
859                    my $type = $q->param('type');
860                    $type =~ /index-(\d+)/;
861                    my $tmpl_id = $1;
862                    $app->run_callbacks( 'rebuild', $blog );
863                    return $app->redirect(
864                        $app->uri(
865                            'mode' => 'view',
866                            args   => {
867                                '_type'       => 'template',
868                                id            => $tmpl_id,
869                                blog_id       => $blog->id,
870                                saved_rebuild => 1
871                            }
872                        )
873                    );
874                }
875            }
876            else {    # popup--just go to cnfrmn. page
877                return $app->load_tmpl( 'popup/rebuilt.tmpl', \%param );
878            }
879        }
880    }
881}
882
883sub rebuild_new_phase {
884    my ($app) = @_;
885    my %reb_set = map { $_ => 1 } $app->param('id');
886    $app->rebuild_these( \%reb_set, how => MT::App::CMS::NEW_PHASE() );
887}
888
889sub start_rebuild_pages {
890    my $app           = shift;
891    my $q             = $app->param;
892    my $start_time    = $q->param('start_time');
893
894    if ( ! $start_time ) {
895        # start of build; invoke callback
896        $app->run_callbacks('pre_build');
897        $start_time = time;
898    }
899
900    my $type          = $q->param('type');
901    my $next          = $q->param('next') || 0;
902    my @order         = split /,/, $type;
903    my $total         = $q->param('total') || 0;
904    my $type_name     = $order[$next];
905    my $archiver      = $app->publisher->archiver($type_name);
906    my $archive_label = $archiver ? $archiver->archive_label : '';
907    $archive_label = $app->translate($type_name) unless $archive_label;
908    $archive_label = $archive_label->() if ( ref $archive_label ) eq 'CODE';
909    my $blog_id = $q->param('blog_id');
910
911    if ($archiver) {
912        if ( $archiver->entry_based || $archiver->date_based ) {
913            my $entry_class = $archiver->entry_class || 'entry';
914            require MT::Entry;
915            my $terms = {
916                class   => $entry_class,
917                status  => MT::Entry::RELEASE(),
918                blog_id => $blog_id,
919            };
920            $total = MT::Entry->count($terms);
921        }
922        elsif ( $archiver->category_based ) {
923            require MT::Category;
924            my $terms = {
925                blog_id => $blog_id,
926                class   => $archiver->category_class,
927            };
928            $total = MT::Category->count($terms);
929        }
930        elsif ( $archiver->author_based ) {
931            require MT::Author;
932            require MT::Entry;
933            my $terms = {
934                blog_id => $blog_id,
935                status  => MT::Entry::RELEASE(),
936                class => 'entry',
937            };
938            $total = MT::Author->count(
939                undef,
940                {
941                    join   => MT::Entry->join_on( 'author_id', $terms, { unique => 1 } ),
942                    unique => 1,
943                }
944            );
945        }
946    }
947
948    my %param = (
949        build_type      => $type,
950        build_next      => $next,
951        total           => $total,
952        start_time      => $start_time,
953        complete        => 0,
954        incomplete      => 100,
955        build_type_name => $archive_label,
956        return_args     => $app->return_args
957    );
958
959    if ( $type_name =~ /^index-(\d+)$/ ) {
960        my $tmpl_id = $1;
961        require MT::Template;
962        my $tmpl = MT::Template->load($tmpl_id)
963            or return $app->error($app->translate('Can\'t load template #[_1].', $tmpl_id));
964        $param{build_type_name} =
965          $app->translate( "index template '[_1]'", $tmpl->name );
966        $param{is_one_index} = 1;
967    }
968    elsif ( $type_name =~ /^entry-(\d+)$/ ) {
969        my $entry_id = $1;
970        require MT::Entry;
971        my $entry = MT::Entry->load($entry_id)
972            or return $app->error($app->translate('Can\'t load entry #[_1].', $entry_id));
973        $param{build_type_name} =
974          $app->translate( "[_1] '[_2]'", $entry->class_label, $entry->title );
975        $param{is_entry} = 1;
976        $param{entry_id} = $entry_id;
977        for my $col (qw( is_new old_status old_next old_previous )) {
978            $param{$col} = $q->param($col);
979        }
980    }
981    $param{is_full_screen} = ( $param{is_entry} )
982      || $q->param('single_template');
983    $param{page_titles} = [ { bc_name => 'Rebuilding' } ];
984    $app->load_tmpl( 'rebuilding.tmpl', \%param );
985}
986
987sub _create_build_order {
988    my ( $app, $blog, $param ) = @_;
989
990    my $at = $blog->archive_type || '';
991    my ( @blog_at, @at, @data );
992    my $archiver;
993    my $archive_label;
994
995    if ( $at && $at ne 'None' ) {
996        @blog_at = split /,/, $at;
997        require MT::PublishOption;
998        foreach my $t (@blog_at) {
999            $archiver = $app->publisher->archiver($t);
1000            next unless $archiver;    # ignore unknown archive types
1001            next if MT::PublishOption::archive_build_type($t) == MT::PublishOption::DISABLED();
1002            push @at, $t;
1003            $archive_label = $archiver->archive_label;
1004            $archive_label = $at unless $archive_label;
1005            $archive_label = $archive_label->()
1006              if ( ref $archive_label ) eq 'CODE';
1007            push(
1008                @data,
1009                {
1010                    archive_type       => $t,
1011                    archive_type_label => $archive_label
1012                }
1013            );
1014        }
1015    }
1016    $param->{archive_type_loop} = \@data;
1017    $param->{build_order} = join ',', @at, 'index';
1018    1;
1019}
1020
1021sub rebuild_confirm {
1022    my $app     = shift;
1023    my $blog_id = $app->param('blog_id');
1024    require MT::Blog;
1025    my $blog = MT::Blog->load($blog_id)
1026        or return $app->error($app->translate('Can\'t load blog #[_1].', $blog_id));
1027
1028    my %param     = (
1029        build_next        => 0,
1030    );
1031    _create_build_order( $app, $blog, \%param );
1032
1033    $param{index_selected} = ( $app->param('prompt') || "" ) eq 'index';
1034
1035    if ( my $tmpl_id = $app->param('tmpl_id') ) {
1036        require MT::Template;
1037        my $tmpl = MT::Template->load($tmpl_id)
1038            or return $app->error($app->translate('Can\'t load template #[_1].', $tmpl_id));
1039        $param{index_tmpl_id}   = $tmpl->id;
1040        $param{index_tmpl_name} = $tmpl->name;
1041    }
1042    my $options = $app->registry("rebuild_options") || {};
1043    my @options;
1044    if ($options) {
1045        foreach my $opt ( keys %$options ) {
1046            $options->{$opt}{key} ||= $opt;
1047            push @options, $options->{$opt};
1048        }
1049    }
1050    $app->run_callbacks( 'rebuild_options', $app, \@options );
1051    my $rebuild_options = $app->filter_conditional_list( \@options );
1052    $param{rebuild_option_loop} = $rebuild_options;
1053    $param{refocus}             = 1;
1054    $app->add_breadcrumb( $app->translate('Publish Site') );
1055    $app->load_tmpl( 'popup/rebuild_confirm.tmpl', \%param );
1056}
1057
1058sub save_favorite_blogs {
1059    my $app = shift;
1060    $app->validate_magic() or return;
1061    my $fav = $app->param('id');
1062    return unless int($fav) > 0;
1063    $app->add_to_favorite_blogs($fav);
1064    $app->send_http_header("text/javascript+json");
1065    return 'true';
1066}
1067
1068sub cc_return {
1069    my $app   = shift;
1070    my $code  = $app->param('license_code');
1071    my $url   = $app->param('license_url');
1072    my $image = $app->param('license_button');
1073    my %param = ( license_name => MT::Util::cc_name($code) );
1074    if ($url) {
1075        $param{license_code} = "$code $url $image";
1076    }
1077    else {
1078        $param{license_code} = $code;
1079    }
1080    $app->load_tmpl( 'cc_return.tmpl', \%param );
1081}
1082
1083sub handshake {
1084    my $app               = shift;
1085    my $blog_id           = $app->param('blog_id');
1086    my $remote_auth_token = $app->param('remote_auth_token');
1087
1088    my %param = ();
1089    $param{remote_auth_token} = $remote_auth_token;
1090    $app->load_tmpl( 'handshake_return.tmpl', \%param );
1091}
1092
1093sub update_welcome_message {
1094    my $app = shift;
1095    $app->validate_magic or return;
1096
1097    my $perms = $app->permissions;
1098    return $app->errtrans("Permission denied.")
1099      unless $perms && $perms->can_edit_config;
1100
1101    my $blog_id    = $app->param('blog_id');
1102    my $message    = $app->param('welcome-message-text');
1103    my $blog_class = $app->model('blog');
1104    my $blog       = $blog_class->load($blog_id)
1105      or return $app->error( $app->translate("Invalid blog") );
1106    $blog->welcome_msg($message);
1107    $blog->save;
1108    $app->redirect(
1109        $app->uri( mode => 'menu', args => { blog_id => $blog_id } ) );
1110}
1111
1112sub dialog_select_weblog {
1113    my $app = shift;
1114
1115    #return $app->errtrans("Permission denied.")
1116    #    unless $app->user->is_superuser;
1117
1118    my $favorites = $app->param('select_favorites');
1119    my %favorite;
1120    my $confirm_js;
1121    my $terms = {};
1122    my $args  = {};
1123    if ($favorites) {
1124        my $auth = $app->user or return;
1125        if ( my @favs = @{ $auth->favorite_blogs || [] } ) {
1126            $terms->{id} = \@favs;
1127            $args->{not}{id} = 1;
1128        }
1129        $confirm_js = 'saveFavorite';
1130    }
1131
1132    my $hasher = sub {
1133        my ( $obj, $row ) = @_;
1134        $row->{label} = $row->{name};
1135        $row->{'link'} = $row->{site_url};
1136    };
1137
1138    $app->listing(
1139        {
1140            type     => 'blog',
1141            code     => $hasher,
1142            template => 'dialog/select_weblog.tmpl',
1143            terms    => $terms,
1144            args     => $args,
1145            params   => {
1146                dialog_title  => $app->translate("Select Blog"),
1147                items_prompt  => $app->translate("Selected Blog"),
1148                search_prompt => $app->translate(
1149                    "Type a blog name to filter the choices below."),
1150                panel_label       => $app->translate("Blog Name"),
1151                panel_description => $app->translate("Description"),
1152                panel_type        => 'blog',
1153                panel_multi       => defined $app->param('multi')
1154                ? $app->param('multi')
1155                : 0,
1156                panel_searchable => 1,
1157                panel_first      => 1,
1158                panel_last       => 1,
1159                list_noncron     => 1,
1160                return_url       => $app->uri . '?'
1161                  . ( $app->param('return_args') || '' ),
1162                confirm_js => $confirm_js,
1163                idfield    => ( $app->param('idfield') || '' ),
1164                namefield  => ( $app->param('namefield') || '' ),
1165            },
1166        }
1167    );
1168}
1169
1170sub can_view {
1171    my ( $eh, $app, $id ) = @_;
1172    my $perms = $app->permissions;
1173    if ( $id
1174        && ( $perms->can_set_publish_paths && !$perms->can_administer_blog ) )
1175    {
1176        return 1 if 'view' eq $app->mode;
1177    }
1178    if (
1179        (
1180            $id && !(
1181                   $perms->can_edit_config
1182                || $perms->can_set_publish_paths
1183                || $perms->can_manage_feedback
1184            )
1185        )
1186        || ( !$id && !$app->user->can_create_blog )
1187      )
1188    {
1189        return 0;
1190    }
1191    1;
1192}
1193
1194sub can_save {
1195    my ( $eh, $app, $id ) = @_;
1196    my $perms = $app->permissions;
1197    return ( $id
1198          && ( $perms->can_edit_config || $perms->can_set_publish_paths ) )
1199      || ( !$id && $app->user->can_create_blog );
1200}
1201
1202sub can_delete {
1203    my ( $eh, $app, $obj ) = @_;
1204    my $author = $app->user;
1205    return 1 if $author->is_superuser();
1206    require MT::Permission;
1207    my $perms = $author->permissions( $obj->id );
1208    return $perms && $perms->can_administer_blog;
1209}
1210
1211sub pre_save {
1212    my $eh = shift;
1213    my ( $app, $obj ) = @_;
1214    if ( !$app->param('overlay')
1215        && $app->param('cfg_screen') )
1216    {
1217
1218        # Checkbox options have to be blanked if they aren't passed.
1219        my $screen = $app->param('cfg_screen');
1220        my @fields;
1221        if ( $screen eq 'cfg_web_services' ) {
1222        }
1223        elsif ( $screen eq 'cfg_archives' ) {
1224        }
1225        elsif ( $screen eq 'cfg_templatemaps' ) {
1226        }
1227        elsif ( $screen eq 'cfg_comments' ) {
1228            @fields = qw( allow_comment_html autolink_urls
1229              use_comment_confirmation );
1230        }
1231        elsif ( $screen eq 'cfg_registration' ) {
1232            @fields = qw( allow_commenter_regist
1233              require_comment_emails allow_unreg_comments
1234              require_typekey_emails );
1235        }
1236        elsif ( $screen eq 'cfg_entry' ) {
1237            @fields = qw( allow_comments_default
1238              allow_pings_default );
1239        }
1240        elsif ( $screen eq 'cfg_trackbacks' ) {
1241            @fields = qw( allow_pings moderate_pings
1242              autodiscover_links internal_autodiscovery );
1243        }
1244        elsif ( $screen eq 'cfg_plugins' ) {
1245        }
1246        for my $cb (@fields) {
1247            unless ( defined $app->param($cb) ) {
1248
1249      # two possibilities: user unchecked the option, or user was not allowed to
1250      # set the value (and therefore there was no field to submit).
1251                my $perms = $app->permissions;
1252                if (
1253                    $app->user->is_superuser
1254                    || (
1255                        $perms
1256                        && (   $perms->can_administer_blog
1257                            || $perms->can_edit_config )
1258                    )
1259                  )
1260                {
1261                    $obj->$cb(0);
1262                }
1263                else {
1264                    delete $obj->{column_values}->{$cb};
1265                    delete $obj->{changed_cols}->{$cb};
1266                }
1267            }
1268        }
1269        if ( $screen eq 'cfg_comments' ) {
1270
1271            # value for comments:  1 == Accept from anyone
1272            #                      2 == Accept authenticated only
1273            #                      0 == No comments
1274            if ( $app->param('allow_comments') ) {
1275                $obj->allow_reg_comments(1);
1276            }
1277            else {
1278                $obj->allow_unreg_comments(0);
1279                $obj->allow_reg_comments(0);
1280            }
1281            $obj->moderate_unreg_comments( $app->param('moderate_comments') );
1282            $obj->nofollow_urls( $app->param('nofollow_urls')         ? 1 : 0 );
1283            $obj->follow_auth_links( $app->param('follow_auth_links') ? 1 : 0 );
1284            my $cp_old = $obj->captcha_provider;
1285            $obj->captcha_provider( $app->param('captcha_provider') );
1286            my $rebuild = $cp_old ne $obj->captcha_provider ? 1 : 0;
1287            $app->add_return_arg( need_full_rebuild => 1 ) if $rebuild;
1288        }
1289        if ( $screen eq 'cfg_web_services' ) {
1290            my $tok = '';
1291            ( $tok = $obj->remote_auth_token ) =~ s/\s//g;
1292            $obj->remote_auth_token($tok);
1293
1294            my $ping_servers = $app->registry('ping_servers');
1295            my @pings_list;
1296            push @pings_list, $_ foreach grep {
1297                defined( $app->param( 'ping_' . $_ ) )
1298                  && $app->param( 'ping_' . $_ )
1299              }
1300              keys %$ping_servers;
1301            $obj->update_pings( join( ',', @pings_list ) );
1302        }
1303        if ( $screen eq 'cfg_entry' ) {
1304            my %param = $_[0] ? %{ $_[0] } : ();
1305            my $pref_param = $app->load_entry_prefs;
1306            %param = ( %param, %$pref_param );
1307        }
1308        if ( $screen eq 'cfg_trackbacks' ) {
1309            if ( my $pings = $app->param('allow_pings') ) {
1310                if ($pings) {
1311                    $obj->moderate_pings( $app->param('moderate_pings') );
1312                    $obj->nofollow_urls( $app->param('nofollow_urls') ? 1 : 0 );
1313                }
1314                else {
1315                    $obj->moderate_pings(1);
1316                    $obj->email_new_pings(1);
1317                }
1318            }
1319        }
1320        if ( $screen eq 'cfg_registration' ) {
1321            $obj->allow_commenter_regist(
1322                $app->param('allow_commenter_regist') );
1323            $obj->allow_unreg_comments( $app->param('allow_unreg_comments') );
1324            if ( $app->param('allow_unreg_comments') ) {
1325                $obj->require_comment_emails(
1326                    $app->param('require_comment_emails') );
1327            }
1328            else {
1329                $obj->require_comment_emails(0);
1330            }
1331            my @authenticators;
1332
1333            my $c = $app->registry('commenter_authenticators');
1334            foreach ( keys %$c ) {
1335                if ( $app->param( 'enabled_' . $_ ) ) {
1336                    push @authenticators, $_;
1337                }
1338            }
1339            push @authenticators, 'MovableType'
1340              if $app->param('enabled_MovableType');
1341            my $c_old = $obj->commenter_authenticators;
1342            $obj->commenter_authenticators( join( ',', @authenticators ) );
1343            my $rebuild = $obj->commenter_authenticators ne $c_old ? 1 : 0;
1344            if ( $app->param('enabled_TypeKey') ) {
1345                $rebuild = $obj->require_typekey_emails ? 0 : 1;
1346                $obj->require_typekey_emails(
1347                    $app->param('require_typekey_emails') );
1348            }
1349            else {
1350                $obj->require_typekey_emails(0);
1351            }
1352            my $tok = '';
1353            ( $tok = $obj->remote_auth_token ) =~ s/\s//g;
1354            $obj->remote_auth_token($tok);
1355
1356            $app->add_return_arg( need_full_rebuild => 1 ) if $rebuild;
1357        }
1358        if ( $screen eq 'cfg_spam' ) {
1359            my $threshold = $app->param('junk_score_threshold');
1360            $threshold =~ s/\+//;
1361            $threshold ||= 0;
1362            $obj->junk_score_threshold($threshold);
1363            if ( my $expiry = $app->param('junk_folder_expiry') ) {
1364                $obj->junk_folder_expiry($expiry);
1365            }
1366            my $perms = $app->permissions;
1367            unless ( defined $app->param('auto_delete_junk') ) {
1368                if (
1369                    $app->user->is_superuser
1370                    || (
1371                        $perms
1372                        && (   $perms->can_administer_blog
1373                            || $perms->can_edit_config )
1374                    )
1375                  )
1376                {
1377                    $obj->junk_folder_expiry(0);
1378                }
1379                else {
1380                    delete $obj->{column_values}{junk_folder_expiry};
1381                    delete $obj->{changed_cols}{junk_folder_expiry};
1382                }
1383            }
1384        }
1385        if ( $screen eq 'cfg_entry' ) {
1386            my %param = $_[0] ? %{ $_[0] } : ();
1387            my $pref_param = $app->load_entry_prefs;
1388            %param = ( %param, %$pref_param );
1389            $param{ 'sort_order_posts_' . ( $obj->sort_order_posts || 0 ) } = 1;
1390            $param{words_in_excerpt} = 40
1391              unless defined $param{words_in_excerpt}
1392              && $param{words_in_excerpt} ne '';
1393            if ( $app->param('days_or_posts') eq 'days' ) {
1394                $obj->days_on_index( $app->param('list_on_index') );
1395                $obj->entries_on_index(0);
1396            }
1397            else {
1398                $obj->entries_on_index( $app->param('list_on_index') );
1399                $obj->days_on_index(0);
1400            }
1401            $obj->basename_limit(15)
1402              if $obj->basename_limit < 15;    # 15 is the *minimum*
1403            $obj->basename_limit(250)
1404              if $obj->basename_limit > 250;    # 15 is the *maximum*
1405        }
1406        if ( $screen eq 'cfg_archives' ) {
1407            $obj->include_system( $app->param('include_system') || '' );
1408            if ( !$app->param('enable_archive_paths') ) {
1409                $obj->archive_url('');
1410                $obj->archive_path('');
1411            }
1412        }
1413        if ( $screen eq 'cfg_publish_profile' ) {
1414            if ( my $dcty = $app->param('dynamicity') ) {
1415                $obj->custom_dynamic_templates($dcty);
1416            }
1417        }
1418    }
1419    else {
1420
1421        #$obj->is_dynamic(0) unless defined $app->{query}->param('is_dynamic');
1422    }
1423
1424    if ( ( $obj->sanitize_spec || '' ) eq '1' ) {
1425        $obj->sanitize_spec( scalar $app->param('sanitize_spec_manual') );
1426    }
1427
1428    1;
1429}
1430
1431sub _update_finfos {
1432    my ($app, $new_virtual, $where) = @_;
1433    my $finfo_class = MT->model('fileinfo');
1434    my $driver = $finfo_class->driver;
1435    my $dbd = $driver->dbd;
1436
1437    my $stmt = $dbd->sql_class->new;
1438
1439    if ($where) {
1440        my $new_where = {};
1441        while (my ($key, $val) = each %$where) {
1442            my $new_key = $dbd->db_column_name($finfo_class->datasource, $key);
1443            $new_where->{$new_key} = $val;
1444        }
1445        $stmt->add_complex_where([ $new_where ]);
1446    }
1447    my $virtual_col = $dbd->db_column_name($finfo_class->datasource, 'virtual');
1448    $stmt->add_complex_where([ { $virtual_col => { op => '!=', value => $new_virtual } } ]);
1449
1450    my $sql = join q{ }, 'UPDATE', $driver->table_for($finfo_class), 'SET',
1451        $virtual_col, '= ?', $stmt->as_sql_where();
1452
1453    my $dbh = $driver->rw_handle;
1454    $dbh->do($sql, {}, $new_virtual, @{ $stmt->{bind} })
1455        or return $app->error($dbh->errstr || $DBI::errstr);
1456    1;
1457}
1458
1459sub post_save {
1460    my $eh = shift;
1461    my ( $app, $obj, $original ) = @_;
1462
1463    my $perms = $app->permissions;
1464    return 1
1465      unless $app->user->is_superuser
1466      || $app->user->can_create_blog
1467      || ( $perms && $perms->can_edit_config );
1468
1469    my $screen = $app->param('cfg_screen') || '';
1470    if ( $screen eq 'cfg_publish_profile' ) {
1471        if ( my $dcty = $app->param('dynamicity') ) {
1472            # Apply publishing rules for templates based on
1473            # publishing method selected:
1474            #     none (0% publish queue, all static)
1475            #     async_all (100% publish queue)
1476            #     async_partial (high-priority templates publish synchronously (main index, preferred indiv. archives, feed templates))
1477            #     all (100% dynamic)
1478            #     archives (archives dynamic, static indexes)
1479            #     custom (custom configuration)
1480
1481            update_publishing_profile(
1482                $app,
1483                $obj
1484            );
1485
1486            if (($dcty eq 'none') || ($dcty =~ m/^async/)) {
1487                _update_finfos($app, 0);
1488            }
1489            elsif ($dcty eq 'all') {
1490                _update_finfos($app, 1);
1491            }
1492            elsif ($dcty eq 'archives') {
1493                # Only archives have template maps.
1494                _update_finfos($app, 1, { templatemap_id => \'is not null' });
1495                _update_finfos($app, 0, { templatemap_id => \'is null' });
1496            }
1497        }
1498
1499        cfg_publish_profile_save($app, $obj) or return;
1500    }
1501    if ( $screen eq 'cfg_archives' ) {
1502        # If either of the publishing paths changed, rebuild the fileinfos.
1503        my $path_changed = 0;
1504        for my $path_field (qw( site_path archive_path site_url archive_url )) {
1505            $path_changed = 1 && last if $app->param($path_field)
1506                && $app->param($path_field) ne $original->$path_field();
1507        }
1508
1509        if ($path_changed) {
1510            $app->rebuild( BlogID => $obj->id, NoStatic => 1 )
1511                or return $app->publish_error();
1512        }
1513
1514        cfg_archives_save($app, $obj) or return;
1515    }
1516    if ( $screen eq 'cfg_prefs' ) {
1517        my $blog_id = $obj->id;
1518
1519        # FIXME: Needs to exclude MT::Permission records for groups
1520        $app->model('permission')
1521          ->load( { blog_id => $blog_id, author_id => 0 } );
1522        if ( !$perms ) {
1523            $perms = $app->model('permission')->new;
1524            $perms->blog_id($blog_id);
1525            $perms->author_id(0);
1526        }
1527    }
1528    if ( $screen eq 'cfg_entry' ) {
1529        my $blog_id = $obj->id;
1530
1531        # FIXME: Needs to exclude MT::Permission records for groups
1532        my $perms =
1533          $app->model('permission')
1534          ->load( { blog_id => $blog_id, author_id => 0 } );
1535        if ( !$perms ) {
1536            $perms = $app->model('permission')->new;
1537            $perms->blog_id($blog_id);
1538            $perms->author_id(0);
1539        }
1540        my $prefs = $app->_entry_prefs_from_params;
1541        if ($prefs) {
1542            $perms->entry_prefs($prefs);
1543            $perms->save
1544              or return $app->errtrans( "Saving permissions failed: [_1]",
1545                $perms->errstr );
1546        }
1547    }
1548
1549    if ( !$original->id ) {    # If the object is new, the "orignal" was blank
1550        ## If this is a new blog, we need to set up a permissions
1551        ## record for the existing user.
1552        $obj->create_default_templates( $obj->template_set );
1553
1554        # Add this blog to the user's "favorite blogs", pushing any 10th
1555        # blog off the list
1556        my $auth = $app->user;
1557
1558        # FIXME: Should we still be doing this?
1559        my $perms = $app->model('permission')->new;
1560        $perms->author_id( $auth->id );
1561        $perms->blog_id( $obj->id );
1562        $perms->set_full_permissions;
1563        $perms->save;
1564
1565        # permission granted - need to update commenting cookie
1566        my %cookies = $app->cookies();
1567        $app->cookie_val();
1568        my ($x, $y, $remember) = split(/::/, $cookies{$app->user_cookie()}->value);
1569        my $cookie  = $cookies{'commenter_id'};
1570        my $cookie_value = $cookie ? $cookie->value : '';
1571        my ($id, $blog_ids) = split(':', $cookie_value);
1572        if ( $blog_ids ne 'S' && $blog_ids ne 'N' ) {
1573            $blog_ids .= ",'" . $obj->id . "'";
1574        }
1575        my $timeout = $remember ? '+10y' : 0;
1576        $timeout = '+' . $app->config->CommentSessionTimeout . 's' unless $timeout;
1577        my %id_kookee = (-name => "commenter_id",
1578                           -value => $auth->id . ':' . $blog_ids,
1579                           -path => '/',
1580                           ($timeout ? (-expires => $timeout) : ()));
1581        $app->bake_cookie(%id_kookee);
1582
1583        require MT::Log;
1584        $app->log(
1585            {
1586                message => $app->translate(
1587                    "Blog '[_1]' (ID:[_2]) created by '[_3]'",
1588                    $obj->name, $obj->id, $auth->name
1589                ),
1590                level    => MT::Log::INFO(),
1591                class    => 'blog',
1592                category => 'new',
1593            }
1594        );
1595
1596        $app->run_callbacks( 'blog_template_set_change', { blog => $obj } );
1597    }
1598    else {
1599
1600        # if you've changed the comment configuration
1601        if (
1602            (
1603                grep { $original->column($_) ne $obj->column($_) }
1604                qw(allow_unreg_comments allow_reg_comments remote_auth_token)
1605            )
1606          )
1607        {
1608            if ( RegistrationAffectsArchives( $obj->id, 'Individual' ) ) {
1609                $app->add_return_arg( need_full_rebuild => 1 );
1610            }
1611            else {
1612                $app->add_return_arg( need_index_rebuild => 1 );
1613            }
1614        }
1615
1616        # if other settings were changed that would affect published pages:
1617        if ( grep { $original->column($_) ne $obj->column($_) }
1618            qw(allow_pings allow_comment_html) )
1619        {
1620            $app->add_return_arg( need_full_rebuild => 1 );
1621        }
1622
1623        if ( ($original->template_set || '') ne ($obj->template_set || '') ) {
1624            $app->run_callbacks( 'blog_template_set_change', { blog => $obj } );
1625            $app->add_return_arg( need_full_rebuild => 1 );
1626        }
1627    }
1628    1;
1629}
1630
1631sub save_filter {
1632    my $eh    = shift;
1633    my ($app) = @_;
1634    my $name  = $app->param('name');
1635    if ( defined $name ) {
1636        $name =~ s/(^\s+|\s+$)//g;
1637        $app->param( 'name', $name );
1638    }
1639    my $perms = $app->permissions;
1640    my $screen = $app->param('cfg_screen') || '';
1641    return $eh->error( MT->translate("You did not specify a blog name.") )
1642      if ( !( $screen && $perms->can_edit_config )
1643        && ( defined $app->param('name') && ( $app->param('name') eq '' ) ) );
1644    return $eh->error( MT->translate("Site URL must be an absolute URL.") )
1645      if ( $screen eq 'cfg_archives' )
1646      && $perms->can_set_publish_paths
1647      && $app->param('site_url') !~ m.^https?://.;
1648    return $eh->error( MT->translate("Archive URL must be an absolute URL.") )
1649      if ( $screen eq 'cfg_archives' )
1650      && $perms->can_set_publish_paths
1651      && $app->param('archive_url') !~ m.^https?://.
1652      && $app->param('enable_archive_paths');
1653    return $eh->error( MT->translate("You did not specify an Archive Root.") )
1654      if ( $screen eq 'cfg_archives' )
1655      && $app->param('archive_path') =~ m/^\s*$/
1656      && $app->param('enable_archive_paths');
1657    return 1;
1658}
1659
1660sub post_delete {
1661    my ( $eh, $app, $obj ) = @_;
1662
1663    $app->log(
1664        {
1665            message => $app->translate(
1666                "Blog '[_1]' (ID:[_2]) deleted by '[_3]'",
1667                $obj->name, $obj->id, $app->user->name
1668            ),
1669            level    => MT::Log::INFO(),
1670            class    => 'blog',
1671            category => 'delete'
1672        }
1673    );
1674    $app->_delete_pseudo_association(undef, $obj->id);
1675}
1676
1677sub make_blog_list {
1678    my $app = shift;
1679    my ($blogs) = @_;
1680
1681    my $author = $app->user;
1682    my $data;
1683    my $can_edit_authors = 1 if $author->is_superuser;
1684    my @blog_ids = map { $_->id } @$blogs; 
1685    my %counts;
1686    my $e_iter = $app->model('entry')->count_group_by(
1687        { blog_id => \@blog_ids },
1688        { group => [ 'blog_id' ] }
1689    );
1690    while ( my ($e_count, $e_blog_id) = $e_iter->() ) {
1691        $counts{$e_blog_id}{'entry'} = $e_count;
1692    }
1693    my $c_iter = $app->model('comment')->count_group_by(
1694        { blog_id => \@blog_ids },
1695        { group => [ 'blog_id' ] }
1696    );
1697    while ( my ($c_count, $c_blog_id) = $c_iter->() ) {
1698        $counts{$c_blog_id}{'comment'} = $c_count;
1699    }
1700    my $p_iter = $app->model('tbping')->count_group_by(
1701        { blog_id => \@blog_ids },
1702        { group => [ 'blog_id' ] }
1703    );
1704    while ( my ($p_count, $p_blog_id) = $p_iter->() ) {
1705        $counts{$p_blog_id}{'ping'} = $p_count;
1706    }
1707
1708    for my $blog (@$blogs) {
1709        my $blog_id = $blog->id;
1710        my $perms   = $author->permissions($blog_id);
1711        my $row     = {
1712            id          => $blog->id,
1713            name        => $blog->name,
1714            description => $blog->description,
1715            site_url    => $blog->site_url
1716        };
1717        $row->{num_entries}  = $counts{$blog_id}{'entry'};
1718        $row->{num_comments} = $counts{$blog_id}{'comment'};
1719        $row->{num_pings}    = $counts{$blog_id}{'ping'};
1720        $row->{can_create_post}  = $perms->can_create_post;
1721        $row->{can_edit_entries} = $perms->can_create_post
1722          || $perms->can_edit_all_posts
1723          || $perms->can_publish_post;
1724        $row->{can_edit_templates} = $perms->can_edit_templates;
1725        $row->{can_edit_config}    = $perms->can_edit_config
1726          || $perms->can_administer_blog;
1727        $row->{can_set_publish_paths} = $perms->can_set_publish_paths
1728          || $perms->can_administer_blog;
1729        $row->{can_manage_feedback} = $perms->can_manage_feedback;
1730        $row->{can_edit_assets}     = $perms->can_edit_assets;
1731        $row->{can_administer_blog} = $perms->can_administer_blog;
1732        push @$data, $row;
1733    }
1734    $data;
1735}
1736
1737sub build_blog_table {
1738    my $app = shift;
1739    my (%args) = @_;
1740
1741    my $blog_class    = $app->model('blog');
1742    my $tbp_class     = $app->model('ping');
1743    my $entry_class   = $app->model('entry');
1744    my $comment_class = $app->model('comment');
1745
1746    my $iter;
1747    if ( $args{load_args} ) {
1748        my $class = $app->model('blog');
1749        $iter = $class->load_iter( @{ $args{load_args} } );
1750    }
1751    elsif ( $args{iter} ) {
1752        $iter = $args{iter};
1753    }
1754    elsif ( $args{items} ) {
1755        $iter = sub { pop @{ $args{items} } };
1756    }
1757    return [] unless $iter;
1758    my $param = $args{param};
1759
1760    my $author           = $app->user;
1761    my $can_edit_authors = $author->is_superuser;
1762    my @data;
1763    my $i;
1764    my ( $entry_count, $ping_count, $comment_count );
1765    while ( my $blog = $iter->() ) {
1766        my $blog_id = $blog->id;
1767        my $row     = {
1768            id          => $blog->id,
1769            name        => $blog->name,
1770            description => $blog->description,
1771            site_url    => $blog->site_url
1772        };
1773
1774        # we should use count by group here...
1775        $row->{num_entries} =
1776          ( $entry_count ? $entry_count->{$blog_id} : $entry_count->{$blog_id} =
1777              MT::Entry->count( { blog_id => $blog_id } ) )
1778          || 0;
1779        $row->{num_comments} = (
1780              $comment_count
1781            ? $comment_count->{$blog_id}
1782            : $comment_count->{$blog_id} = MT::Comment->count(
1783                { blog_id => $blog_id, junk_status => MT::Comment::NOT_JUNK() }
1784            )
1785          )
1786          || 0;
1787        $row->{num_pings} = (
1788            $ping_count ? $ping_count->{$blog_id} : $ping_count->{$blog_id} =
1789              MT::TBPing->count(
1790                { blog_id => $blog_id, junk_status => MT::TBPing::NOT_JUNK() }
1791              )
1792        ) || 0;
1793        $row->{num_authors} = 0;
1794
1795        # FIXME: This isn't efficient
1796        my $iter = MT::Permission->load_iter(
1797            {
1798                blog_id => [ 0, $blog_id ],
1799
1800                #    role_mask => [ 2, undef ]
1801                #}, {
1802                #    range_incl => { 'role_mask' => 1 }
1803            }
1804        );
1805        my %a;
1806        while ( my $p = $iter->() ) {
1807            next if exists $a{ $p->author_id };
1808            $a{ $p->author_id } = 1;
1809            $row->{num_authors}++ if $p->can_create_post;
1810        }
1811        if ( $author->is_superuser ) {
1812            $row->{can_create_post}       = 1;
1813            $row->{can_edit_entries}      = 1;
1814            $row->{can_edit_templates}    = 1;
1815            $row->{can_edit_config}       = 1;
1816            $row->{can_set_publish_paths} = 1;
1817            $row->{can_administer_blog}   = 1;
1818        }
1819        else {
1820            my $perms = $author->permissions($blog_id);
1821            $row->{can_create_post}  = $perms->can_create_post;
1822            $row->{can_edit_entries} = $perms->can_create_post
1823              || $perms->can_edit_all_posts
1824              || $perms->can_publish_post;
1825            $row->{can_edit_templates} = $perms->can_edit_templates;
1826            $row->{can_edit_config}    = $perms->can_edit_config
1827              || $perms->can_administer_blog;
1828            $row->{can_set_publish_paths} = $perms->can_set_publish_paths
1829              || $perms->can_administer_blog;
1830            $row->{can_administer_blog} = $perms->can_administer_blog;
1831        }
1832        $row->{object} = $blog;
1833        push @data, $row;
1834    }
1835
1836    if (@data) {
1837        $param->{blog_table}[0]{object_loop} = \@data;
1838        $app->load_list_actions( 'blog', \%$param );
1839        $param->{object_loop} = $param->{blog_table}[0]{object_loop};
1840    }
1841
1842    \@data;
1843}
1844
1845sub cfg_blog {
1846    my $q = $_[0]->{query};
1847    $q->param( '_type', 'blog' );
1848    $q->param( 'id',    scalar $q->param('blog_id') );
1849    $_[0]->forward( "view", { output => 'cfg_prefs.tmpl' } );
1850}
1851
1852sub cfg_archives_save {
1853    my $app = shift;
1854    my ($blog) = @_;
1855
1856    my $at = $app->param('preferred_archive_type');
1857    $blog->archive_type_preferred($at);
1858    $blog->include_cache( $app->param('include_cache') ? 1 : 0 );
1859    require MT::PublishOption;
1860    if ( ( $blog->custom_dynamic_templates eq 'all'
1861        || $blog->custom_dynamic_templates eq 'archives' )
1862      && ( $app->model('template')->exist(
1863            { blog_id => $blog->id, build_type => MT::PublishOption::DYNAMIC() })
1864        || $app->model('templatemap')->exist(
1865            { blog_id => $blog->id, build_type => MT::PublishOption::DYNAMIC() }) ) )
1866    {
1867        # dynamic enabled and caching option may have changed - update mtview
1868        my $cache       = $app->param('dynamic_cache')       ? 1 : 0;
1869        my $conditional = $app->param('dynamic_conditional') ? 1 : 0;
1870        _create_mtview( $blog, $blog->site_path, $cache, $conditional );
1871        _create_dynamiccache_dir( $blog, $blog->site_path ) if $cache;
1872        if ( $blog->archive_path ) {
1873            _create_mtview( $blog, $blog->archive_path, $cache, $conditional );
1874            _create_dynamiccache_dir( $blog, $blog->archive_path ) if $cache;
1875        }
1876    }
1877    $blog->save
1878      or return $app->error(
1879        $app->translate( "Saving blog failed: [_1]", $blog->errstr ) );
1880
1881    1;
1882}
1883
1884sub cfg_publish_profile_save {
1885    my $app = shift;
1886    my ($blog) = @_;
1887
1888    my $dcty = $app->param('dynamicity') || 'none';
1889    my $pq = $dcty =~ m/^async/ ? 1 : 0;
1890    $blog->publish_queue( $pq );
1891    if ( $dcty eq 'all' || $dcty eq 'archives' ) {
1892        # update the dynamic publishing options if they changed
1893        update_dynamicity(
1894            $app,
1895            $blog
1896        );
1897    }
1898    $blog->save
1899      or return $app->error(
1900        $app->translate( "Saving blog failed: [_1]", $blog->errstr ) );
1901
1902    1;
1903}
1904
1905# FIXME: Faulty, since it doesn't take into account module includes
1906sub RegistrationAffectsArchives {
1907    my ( $blog_id, $archive_type ) = @_;
1908    require MT::TemplateMap;
1909    require MT::Template;
1910    my @tms = MT::TemplateMap->load(
1911        {
1912            archive_type  => $archive_type,
1913            blog_id       => $blog_id
1914        }
1915    );
1916    grep { !$_->build_dynamic && ($_->text =~ /<MT:?IfRegistration/i) }
1917      map { MT::Template->load( $_->template_id ) } @tms;
1918}
1919
1920sub update_publishing_profile {
1921    my $app = shift;
1922    my ( $blog ) = @_;
1923
1924    my $dcty = $blog->custom_dynamic_templates;
1925
1926    require MT::PublishOption;
1927    require MT::Template;
1928
1929    if ( ($dcty eq 'none') || ($dcty =~ m/^async/) ) {
1930        my @templates = MT::Template->load( {
1931            blog_id => $blog->id,
1932            # FIXME: enumeration of types
1933            type =>
1934              [ 'index', 'archive', 'individual', 'page', 'category' ],
1935          } );
1936        for my $tmpl (@templates) {
1937            my $bt = $tmpl->build_type || 0;
1938            # Do not make automatic modifications to templates with these
1939            # manually configured build types
1940            next if $bt == MT::PublishOption::DISABLED();
1941            next if $bt == MT::PublishOption::MANUALLY();
1942            next if $bt == MT::PublishOption::SCHEDULED();
1943
1944            if ($dcty eq 'async_partial') {
1945                # these should be build synchronously
1946                if (($tmpl->identifier || '') =~ m/^(main_index|feed_recent)$/) {
1947                    $tmpl->build_type(MT::PublishOption::ONDEMAND());
1948                } else {
1949                    if (($tmpl->type eq 'individual') || ($tmpl->type eq 'page')) {
1950                        my @tmpl_maps = MT::TemplateMap->load( { template_id => $tmpl->id } );
1951                        foreach my $tmpl_map (@tmpl_maps) {
1952                            if (($tmpl_map->archive_type =~ m/^(Individual|Page)$/) &&
1953                                ($tmpl_map->is_preferred)) {
1954                                    $tmpl_map->build_type(MT::PublishOption::ONDEMAND());
1955                                $tmpl_map->save;
1956                                next;
1957                            }
1958                            if ( $tmpl_map->build_type != MT::PublishOption::ASYNC() ) {
1959                                $tmpl_map->build_type(MT::PublishOption::ASYNC());
1960                                $tmpl_map->save;
1961                            }
1962                        }
1963                    }
1964                    else {
1965                        # updates all template maps too
1966                        $tmpl->build_type(MT::PublishOption::ASYNC());
1967                    }
1968                }
1969            } elsif ($dcty eq 'async_all') {
1970                $tmpl->build_type(MT::PublishOption::ASYNC());
1971            } else {
1972                $tmpl->build_type(MT::PublishOption::ONDEMAND());
1973            }
1974            $tmpl->save();
1975        }
1976    }
1977    elsif ( $dcty eq 'archives' ) {
1978        my @templates = MT::Template->load( {
1979            blog_id => $blog->id,
1980            # FIXME: enumeration of types
1981            type =>
1982              [ 'index', 'archive', 'individual', 'page', 'category' ],
1983          } );
1984        for my $tmpl (@templates) {
1985            my $bt = $tmpl->build_type || 0;
1986            next if $bt == MT::PublishOption::DISABLED();
1987            next if $bt == MT::PublishOption::MANUALLY();
1988            next if $bt == MT::PublishOption::SCHEDULED();
1989
1990            $tmpl->build_type( $tmpl->type ne 'index' ? MT::PublishOption::DYNAMIC() : MT::PublishOption::ONDEMAND() );
1991            $tmpl->save();
1992        }
1993    }
1994    elsif ( $dcty eq 'all' ) {
1995        my @templates = MT::Template->load(
1996            {
1997                blog_id => $blog->id,
1998
1999                # FIXME: enumeration of types
2000                type =>
2001                  [ 'index', 'archive', 'individual', 'page', 'category' ],
2002            }
2003        );
2004        for my $tmpl (@templates) {
2005            my $bt = $tmpl->build_type || 0;
2006            next if $bt == MT::PublishOption::DISABLED();
2007            next if $bt == MT::PublishOption::MANUALLY();
2008            next if $bt == MT::PublishOption::SCHEDULED();
2009
2010            $tmpl->build_type( MT::PublishOption::DYNAMIC() );
2011            $tmpl->save();
2012        }
2013    }
2014    return 1;
2015}
2016
2017sub update_dynamicity {
2018    my $app = shift;
2019    my ( $blog ) = @_;
2020
2021    my $cache       = $app->param('dynamic_cache')       ? 1 : 0;
2022    my $conditional = $app->param('dynamic_conditional') ? 1 : 0;
2023
2024    require MT::PublishOption;
2025    if ( $app->model('template')->exist(
2026            { blog_id => $blog->id, build_type => MT::PublishOption::DYNAMIC() })
2027      || $app->model('templatemap')->exist(
2028            { blog_id => $blog->id, build_type => MT::PublishOption::DYNAMIC() }) )
2029    {
2030        # dynamic publishing enabled
2031        prepare_dynamic_publishing($app, $blog, $cache, $conditional, $blog->site_path, $blog->site_url);
2032        if ( $blog->archive_path ) {
2033            prepare_dynamic_publishing($app, $blog, $cache, $conditional, $blog->archive_path, $blog->archive_url);
2034        }
2035        my $compiled_template_path =
2036          File::Spec->catfile( $blog->site_path(), 'templates_c' );
2037        if ( -d $compiled_template_path ) {
2038            $app->add_return_arg( 'no_writecache' => 1 )
2039              unless ( -w $compiled_template_path );
2040        }
2041        else {
2042            $app->add_return_arg( 'no_cachedir' => 1 )
2043              unless ( -d $compiled_template_path );
2044        }
2045
2046        # FIXME: use FileMgr
2047        if ($cache) {
2048            my $cache_path = File::Spec->catfile( $blog->site_path(), 'cache' );
2049            if ( -d $cache_path ) {
2050                $app->add_return_arg( 'no_write_cache_path' => 1 )
2051                  unless ( -w $cache_path );
2052            }
2053            else {
2054                $app->add_return_arg( 'no_cache_path' => 1 )
2055                  unless ( -d $cache_path );
2056            }
2057        }
2058    }
2059}
2060
2061sub _create_mtview {
2062    my ( $blog, $site_path, $cache, $conditional ) = @_;
2063
2064    my $mtview_path = File::Spec->catfile( $site_path, "mtview.php" );
2065    eval {
2066        my $mv_contents = '';
2067        if ( -f $mtview_path ) {
2068            open( my $mv, "<$mtview_path" );
2069            while ( my $line = <$mv> ) {
2070                $mv_contents .= $line if ( $line !~ m!^//|<\?(?:php)?|\?>! );
2071            }
2072            close $mv;
2073        }
2074        my $cgi_path = MT->instance->server_path() || "";
2075        $cgi_path =~ s!/*$!!;
2076        my $mtphp_path = File::Spec->canonpath("$cgi_path/php/mt.php");
2077        my $blog_id    = $blog->id;
2078        my $config     = MT->instance->{cfg_file};
2079        my $cache_code = $cache ? "\n    \$mt->caching = true;" : '';
2080        my $conditional_code =
2081          $conditional ? "\n    \$mt->conditional = true;" : '';
2082        my $new_mtview = <<NEW_MTVIEW;
2083
2084    include('$mtphp_path');
2085    \$mt = new MT($blog_id, '$config');$cache_code$conditional_code
2086    \$mt->view();
2087NEW_MTVIEW
2088
2089        if ( $new_mtview ne substr( $mv_contents, 0, length($new_mtview) ) ) {
2090            $mv_contents =~ s!\n!\n//!gs;
2091            my $mtview = <<MTVIEW;
2092<?php
2093$new_mtview
2094$mv_contents
2095?>
2096MTVIEW
2097
2098            $blog->file_mgr->mkpath( $site_path );
2099            open( my $mv, ">$mtview_path" )
2100              || die "Couldn't open $mtview_path for appending";
2101            print $mv $mtview || die "Couldn't write to $mtview_path";
2102            close $mv;
2103        }
2104    };
2105    if ($@) { print STDERR $@; }
2106}
2107
2108sub _create_dynamiccache_dir {
2109    my ( $blog, $site_path ) = @_;
2110
2111    # FIXME: use FileMgr
2112    my $cache_path = File::Spec->catfile( $site_path, 'cache' );
2113    my $fmgr = $blog->file_mgr;
2114    my $saved_umask = MT->config->DirUmask;
2115    MT->config->DirUmask('0000');
2116    $fmgr->mkpath($cache_path);
2117    MT->config->DirUmask($saved_umask);
2118    my $message;
2119    if ( -d $cache_path ) {
2120        $message = MT->translate(
2121'Error: Movable Type cannot write to the template cache directory. Please check the permissions for the directory called <code>[_1]</code> underneath your blog directory.',
2122            'cache'
2123        ) unless ( -w $cache_path );
2124    }
2125    else {
2126        $message = MT->translate(
2127'Error: Movable Type was not able to create a directory to cache your dynamic templates. You should create a directory called <code>[_1]</code> underneath your blog directory.',
2128            'cache'
2129        ) unless ( -d $cache_path );
2130    }
2131    if ( $message ) {
2132        MT->log(
2133            {
2134                message => $message,
2135                level   => MT::Log::ERROR(),
2136                class   => 'system',
2137            }
2138        );
2139    }
2140}
2141
2142sub prepare_dynamic_publishing {
2143    my ( $cb, $blog, $cache, $conditional, $site_path, $site_url ) = @_;
2144
2145    my $htaccess_path = File::Spec->catfile( $site_path, ".htaccess" );
2146    my $mtview_path   = File::Spec->catfile( $site_path, "mtview.php" );
2147
2148    ## Don't re-create when files are there in callback.
2149    return 1
2150      if !defined($cache)
2151      && !defined($conditional)
2152      && ( 'MT::Callback' eq ref($cb) )
2153      && ( -f $htaccess_path )
2154      && ( -f $mtview_path );
2155    return 1 
2156        if 'all' ne $blog->custom_dynamic_templates
2157        && 'archives' ne $blog->custom_dynamic_templates;
2158
2159    # IIS itself does not handle .htaccess,
2160    # but IISPassword (3rd party) does and dies with this.
2161    if ( $ENV{SERVER_SOFTWARE} !~ /Microsoft-IIS/ ) {
2162        eval {
2163            require URI;
2164            my $mtview_server_url = new URI( $site_url );
2165            $mtview_server_url = $mtview_server_url->path();
2166            $mtview_server_url .=
2167              ( $mtview_server_url =~ m|/$| ? "" : "/" ) . "mtview.php";
2168
2169            my $contents = "";
2170            if ( open( HT, $htaccess_path ) ) {
2171                local $/ = undef;
2172                $contents = <HT>;
2173                close HT;
2174            }
2175            if ( $contents !~ /^\s*Rewrite(Cond|Engine|Rule)\b/m ) {
2176                my $htaccess = <<HTACCESS;
2177
2178## %%%%%%% Movable Type generated this part; don't remove this line! %%%%%%%
2179# Disable fancy indexes, so mtview.php gets a chance...
2180Options -Indexes +SymLinksIfOwnerMatch
2181  <IfModule mod_rewrite.c>
2182  # The mod_rewrite solution is the preferred way to invoke
2183  # dynamic pages, because of its flexibility.
2184
2185  # Add mtview.php to the list of DirectoryIndex options, listing it last,
2186  # so it is invoked only if the common choices aren't present...
2187  <IfModule mod_dir.c>
2188    DirectoryIndex index.php index.html index.htm default.htm default.html default.asp $mtview_server_url
2189  </IfModule>
2190
2191  RewriteEngine on
2192
2193  # don't serve mtview.php if the request is for a real directory
2194  # (allows the DirectoryIndex lookup to function)
2195  RewriteCond %{REQUEST_FILENAME} !-d
2196
2197  # don't serve mtview.php if the request is for a real file
2198  # (allows the actual file to be served)
2199  RewriteCond %{REQUEST_FILENAME} !-f
2200  # anything else is handed to mtview.php for resolution
2201  RewriteRule ^(.*)\$ $mtview_server_url [L,QSA]
2202</IfModule>
2203
2204<IfModule !mod_rewrite.c>
2205  # if mod_rewrite is unavailable, we forward any missing page
2206  # or unresolved directory index requests to mtview
2207  # if mtview.php can resolve the request, it returns a 200
2208  # result code which prevents any 4xx error code from going
2209  # to the server's access logs. However, an error will be
2210  # reported in the error log file. If this is your only choice,
2211  # and you want to suppress these messages, adding a "LogLevel crit"
2212  # directive within your VirtualHost or root configuration for
2213  # Apache will turn them off.
2214  ErrorDocument 404 $mtview_server_url
2215  ErrorDocument 403 $mtview_server_url
2216</IfModule>
2217## ******* Movable Type generated this part; don't remove this line! *******
2218
2219HTACCESS
2220
2221                $blog->file_mgr->mkpath( $site_path );
2222
2223                open( HT, ">>$htaccess_path" )
2224                  || die "Couldn't open $htaccess_path for appending";
2225                print HT $htaccess || die "Couldn't write to $htaccess_path";
2226                close HT;
2227            }
2228        };
2229        if ($@) { print STDERR $@; }
2230    }
2231
2232    _create_mtview( $blog, $site_path, $cache, $conditional );
2233
2234    my $compiled_template_path =
2235      File::Spec->catfile( $site_path, 'templates_c' );
2236    my $fmgr        = $blog->file_mgr;
2237    my $cfg         = MT->config;
2238    my $saved_umask = $cfg->DirUmask;
2239    $cfg->DirUmask('0000');
2240    $fmgr->mkpath($compiled_template_path);
2241    $cfg->DirUmask($saved_umask);
2242    my $message = q();
2243
2244    if ( -d $compiled_template_path ) {
2245        $message = MT->translate(
2246'Error: Movable Type cannot write to the template cache directory. Please check the permissions for the directory called <code>[_1]</code> underneath your blog directory.',
2247            'templates_c'
2248        ) unless ( -w $compiled_template_path );
2249    }
2250    else {
2251        $message = MT->translate(
2252'Error: Movable Type was not able to create a directory to cache your dynamic templates. You should create a directory called <code>[_1]</code> underneath your blog directory.',
2253            'templates_c'
2254        ) unless ( -d $compiled_template_path );
2255    }
2256
2257    if ($cache) {
2258        _create_dynamiccache_dir( $blog, $site_path );
2259    }
2260}
2261
22621;
Note: See TracBrowser for help on using the browser.