cms.pm

1. 记录每个帖子的访问人情况

	    return $app->error($app->translate("Permission denied"));
	}
	my $class = $app->_load_driver_for($type) or return;
        my $cols = $class->column_names;
        my $obj;

        my $blog;
        if ($blog_id) {
            $blog = MT::Blog->load($blog_id);
            $app->add_breadcrumb($blog->name,
                                 $app->uri.'?__mode=menu&blog_id='.$blog->id);
        }

        if ($id) {          # object exists, we're just editing it.
	    $obj = $class->load($id) or
                return $app->error($app->translate("Load failed: [_1]",
                    $class->errstr || "(no reason given)"));
	    if ($type eq 'comment') {
		my $entry = MT::Entry->load($obj->entry_id);
		if (!($entry->author_id == $app->{author}->id
		      || $perms->can_edit_all_posts)) {
		    return $app->error($app->translate("Permission denied."));
		}
	    }
            if ($type eq 'entry') {
                return $app->error($app->translate("Permission denied."))
                    unless $perms->can_edit_entry($obj, $app->{author});
            }
            for my $col (@$cols) {
                $param{$col} = defined $q->param($col) ?
                    $q->param($col) : $obj->$col();
            }
            if ($type eq 'entry') {
                $app->add_breadcrumb($app->translate('Entries'),
				     $app->uri . 
				     '?__mode=list_entries&blog_id=' . $blog_id);
                $app->add_breadcrumb($obj->title || $app->translate('(untitled)'));
                ## Don't pass in author_id, because it will clash with the
                ## author_id parameter of the author currently logged in.
                delete $param{'author_id'};
                delete $param{'category_id'};
                if (my $cat = $obj->category) {
                    $param{category_id} = $cat->id;
                }
                $blog_id = $obj->blog_id;
		my $status = $q->param('status') || $obj->status;
                $param{"status_" . MT::Entry::status_text($status)} = 1;
                $param{"allow_comments_" . ($q->param('allow_comments')
					    || $obj->allow_comments)} = 1;
                my $df = $q->param('created_on_manual') ||
		    format_ts("%Y-%m-%d %H:%M:%S", $obj->created_on);
                $param{'created_on_formatted'} = $df;
                my $comments = $obj->comments;
                my @c_data;
                my $i = 1;
                @$comments = sort { $b->created_on cmp $a->created_on }
                             @$comments;
                for my $c (@$comments) {
                    my $df = format_ts("%Y-%m-%d %H:%M:%S", $c->created_on);
                    my $author = $c->author || '['. $app->translate('No author') . ']';
                    push @c_data, { comment_id => $c->id,
                                    comment_author => $author,
                                    comment_created => $df,
                                    comment_odd => ($i++ % 2 ? 1 : 0) };
                }
                mark_odd_rows(\@c_data);
                $param{comment_loop} = \@c_data;
                $param{num_comment_rows} = @c_data + 3;
                $param{can_send_notifications} = $perms->can_send_notifications;

                ## Load list of trackback pings sent for this entry.
                require MT::Trackback;
                require MT::TBPing;
                my $tb = MT::Trackback->load({ entry_id => $obj->id });
                my @tb_data;
                if ($tb) {
                    my $iter = MT::TBPing->load_iter({ tb_id => $tb->id },
                        { 'sort' => 'created_on',
                          direction => 'ascend' });
                    $i = 1;
                    while (my $ping = $iter->()) {
                        my $df = format_ts("%Y-%m-%d %H:%M:%S", $ping->created_on);
                        push @tb_data, { ping_id => $ping->id,
                                         ping_title => $ping->title,
                                         ping_url => $ping->source_url,
                                         ping_created => $df,
                                         ping_odd => ($i++ % 2 ? 1 : 0) };
                    }
                }
                mark_odd_rows(\@tb_data);
                $param{ping_loop} = \@tb_data;
                $param{num_ping_rows} = @tb_data + 3;

                ## Load next and previous entries for next/previous links
                if (my $next = $obj->next) {
                    $param{next_entry_id} = $next->id;
                }
                if (my $prev = $obj->previous) {
                    $param{previous_entry_id} = $prev->id;
                }

                $param{ping_errors} = $q->param('ping_errors');
                $param{can_view_log} = $app->{author}->can_view_log;

                $param{entry_permalink} = $obj->permalink;
            } elsif ($type eq 'category') {
                $app->add_breadcrumb($app->translate('Categories'),
                                     $app->uri . '?__mode=list_cat&blog_id=' . 
                                     $obj->blog_id);
                $app->add_breadcrumb($obj->label);
                require MT::Trackback;
                my $tb = MT::Trackback->load({ category_id => $obj->id });
                if ($tb) {
                    my $path = $app->{cfg}->CGIPath;
                    $path .= '/' unless $path =~ m!/$!;
                    my $script = $app->{cfg}->TrackbackScript;
                    $param{tb_url} = $path . $script . '/' . $tb->id;
                    if ($param{tb_passphrase} = $tb->passphrase) {
                        $param{tb_url} .= '/' .
                            encode_url($param{tb_passphrase});
                    }
                }
            } elsif ($type eq 'template') {
                $app->add_breadcrumb($app->translate('Templates'),
                            $app->uri . '?__mode=list&_type=template&blog_id=' . 
                                     $obj->blog_id);
                $app->add_breadcrumb($obj->name);
                $blog_id = $obj->blog_id;
                $param{has_name} = $obj->type eq 'index' ||
                                   $obj->type eq 'custom' ||
                                   $obj->type eq 'archive' ||
                                   $obj->type eq 'category' ||
                                   $obj->type eq 'individual';
                $param{has_outfile} = $obj->type eq 'index';
                $param{has_rebuild} = $obj->type eq 'index';
                $param{custom_dynamic} = ($blog->custom_dynamic_templates||"") 
                                           eq 'custom';
                $param{has_build_options} = ($param{custom_dynamic}
                                              || $param{has_rebuild});
                $param{is_special} = $param{type} ne 'index'
                                     && $param{type} ne 'archive'
                                     && $param{type} ne 'category'
                                     && $param{type} ne 'individual';
                $param{has_build_options} = $param{has_build_options}
                                             && $param{type} ne 'custom'
                                             && ! $param{is_special};
                $param{rebuild_me} = defined $obj->rebuild_me ?
                    $obj->rebuild_me : 1;
            } elsif ($type eq 'blog') {
                $app->add_breadcrumb($app->translate('Configuration'),
                                     $app->uri . '?__mode=view&_type=blog&id=' .
                                     $obj->id . '&blog_id=' . $obj->id);
                if (($param{output}||"") eq 'cfg_prefs.tmpl') {
                    $app->add_breadcrumb($app->translate('Preferences'));
                } else {
                    $app->add_breadcrumb($app->translate('Core Setup'));
                }
                $param{nav_config} = 1;
                $blog_id = $obj->id;
                my $at = $obj->archive_type;
                if ($at && $at ne 'None') {
                    my @at = split /,/, $at;
                    for my $at (@at) {
                        $param{'archive_type_' . $at} = 1;
                    }
                }
                $param{'status_default_' . $obj->status_default} = 1 if
                    $obj->status_default;
                $param{'sanitize_spec_' . ($obj->sanitize_spec ? 1 : 0)} = 1;
                $param{sanitize_spec_manual} = $obj->sanitize_spec
                    if $obj->sanitize_spec;
                $param{'archive_type_preferred_' .
                    $obj->archive_type_preferred} = 1 if
                    $obj->archive_type_preferred;
                $param{words_in_excerpt} = 40
                    unless defined $param{words_in_excerpt} &&
                    $param{words_in_excerpt} ne '';
                $param{'sort_order_comments_' . $obj->sort_order_comments} = 1;
                $param{'sort_order_posts_' . $obj->sort_order_posts} = 1;
                my $lang = $obj->language || 'en';
                $lang = 'en' if lc($lang) eq 'en-us' || lc($lang) eq 'en_us';
                $param{'language_' . $lang} = 1;
                (my $offset = $obj->server_offset) =~ s![-\.]!_!g;
                $offset =~ s!_00$!!;
                $param{'server_offset_' . $offset} = 1;
                $param{'allow_comments_default_' . $obj->allow_comments_default} = 1;
                $param{'non_anonymous_comments'} = !$obj->allow_anon_comments;
                $param{'auto_approve_commenters'} =
                            !$obj->manual_approve_commenters;
                $param{cc_license_name} = MT::Util::cc_name($obj->cc_license)
                    if $obj->cc_license;

                ## Load text filters.
                my $filters = MT->all_text_filters;
                my $default_entries = $obj->convert_paras;
                my $default_comments = $obj->convert_paras_comments;
                if ($default_entries eq '1') {
                    $default_entries = '__default__';
                }
                if ($default_comments eq '1') {
                    $default_comments = '__default__';
                }
                $param{text_filters} = [];
                $param{text_filters_comments} = [];
                for my $filter (keys %$filters) {
                    my $row = {
                        filter_key => $filter,
                        filter_label => $filters->{$filter}{label},
                    };
                    my $rowc = { %$row };
                    $row->{filter_selected} = $filter eq $default_entries;
                    $rowc->{filter_selected} = $filter eq $default_comments;
                    push @{ $param{text_filters} }, $row;
                    push @{ $param{text_filters_comments} }, $rowc;
                }
                $param{text_filters} = [
                    sort { $a->{filter_key} cmp $b->{filter_key} }
                    @{ $param{text_filters} } ];
                unshift @{ $param{text_filters} }, {
                    filter_key => '0',
                    filter_label => $app->translate('None'),
                    filter_selected => !$default_entries,
                };
                unshift @{ $param{text_filters_comments} }, {
                    filter_key => '0',
                    filter_label => $app->translate('None'),
                    filter_selected => !$default_entries,
                };
            } elsif ($type eq 'comment') {
                $app->add_breadcrumb($app->translate('Comments'),
                   $app->uri . '?__mode=list_comments&blog_id=' . $obj->blog_id);
                $app->add_breadcrumb($app->translate('Edit Comment'));
                require MT::Entry;
                if (my $entry = MT::Entry->load($obj->entry_id)) {
                    $param{entry_title} = $entry->title || $entry->text || "";
                    $param{entry_title} = substr($param{entry_title}, 0, 25) . '...'
                        if $param{entry_title} && $param{entry_title} =~ m(\S{25,});
                } else {
                    $param{no_entry} = 1;
                }

                $param{created_on_time_formatted} =
                    format_ts("%Y-%m-%d %H:%M:%S", $obj->created_on());
                $param{created_on_day_formatted} =
                    format_ts("%Y-%m-%d", $obj->created_on());

                $param{approved} = $app->param('approved');

                my $perm = MT::Permission->load({author_id => $obj->commenter_id,
                                                 blog_id => $obj->blog_id});
                if ($perm) {
                    $param{commenter_approved} = ($perm->can_comment()
                                                  && !$perm->can_not_comment()
                                                   ? 1 : undef);
                    $param{commenter_blocked} = ($perm->can_not_comment()
                                                   ? 1 : undef);
                }
                if ($obj->commenter_id) {
                    if ($obj->email !~ m/@/) {  # no email for this commenter
                        $param{email_withheld} = 1;
                    }
                }
                $param{invisible_unregistered} = !$obj->visible &&
                                                 !$obj->commenter_id;
            }
            $param{new_object} = 0;
        } else {                                        # object is new
            $param{new_object} = 1;
            for my $col (@$cols) {
                $param{$col} = $q->param($col);
            }
            if ($type eq 'entry') {
                if ($blog_id) {
                    $app->add_breadcrumb($app->translate('Entries'), 
                         $app->uri . '?__mode=list_entries&blog_id=' . $blog_id);
                    $app->add_breadcrumb($app->translate('New Entry'));
                    $param{nav_new_entry} = 1;
                }
                # (if there is no blog_id parameter, this is a
                # bookmarklet post and doesn't need breadcrumbs.)
                delete $param{'author_id'};
                delete $param{'pinged_urls'};
                require MT::Blog;
                my $blog_timezone = 0;
                if ($blog_id) {
                    my $blog = MT::Blog->load($blog_id);
                    $blog_timezone = $blog->server_offset();
                    my $def_status = $q->param('status') ||
                                     $blog->status_default;
                    if ($def_status) {
                        $param{"status_" . MT::Entry::status_text($def_status)}
                            = 1;
                    }
                    $param{'allow_comments_' . 
                           (defined $q->param('allow_comments')
                             ? $q->param('allow_comments')
                             : $blog->allow_comments_default)} = 1;