root/branches/release-41/lib/MT/CMS/Blog.pm @ 2676

Revision 2676, 82.5 kB (checked in by auno, 17 months ago)

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