Changeset 2052

Timestamp:

04/24/08 09:36:00 (19 months ago)

Author:

fumiakiy

Message:

Integrated Widget Manager to the core. BugId:68750

Now a widgetset is another type of template. The widgets contained in a widgetset is stored in a meta field.

Location:

branches/release-36

Files:

• default_templates/about_this_page.mtml (added)
• default_templates/archive_widgets_group.mtml (added)
• default_templates/author_archive_list.mtml (added)
• default_templates/calendar.mtml (added)
• default_templates/category_archive_list.mtml (added)
• default_templates/creative_commons.mtml (added)
• default_templates/current_author_monthly_archive_list.mtml (added)
• default_templates/current_category_monthly_archive_list.mtml (added)
• default_templates/date_based_author_archives.mtml (added)
• default_templates/date_based_category_archives.mtml (added)
• default_templates/main_index_widgets_group.mtml (added)
• default_templates/monthly_archive_dropdown.mtml (added)
• default_templates/monthly_archive_list.mtml (added)
• default_templates/pages_list.mtml (added)
• default_templates/powered_by.mtml (added)
• default_templates/recent_assets.mtml (added)
• default_templates/recent_comments.mtml (added)
• default_templates/recent_entries.mtml (added)
• default_templates/search.mtml (added)
• default_templates/signin.mtml (added)
• default_templates/syndication.mtml (added)
• default_templates/tag_cloud.mtml (added)
• default_templates/technorati_search.mtml (added)
• lib/MT/App/CMS.pm (modified) (5 diffs)
• lib/MT/Blog.pm (modified) (1 diff)
• lib/MT/CMS/Template.pm (modified) (4 diffs)
• lib/MT/Core.pm (modified) (1 diff)
• lib/MT/DefaultTemplates.pm (modified) (3 diffs)
• lib/MT/Template.pm (modified) (3 diffs)
• lib/MT/Template/ContextHandlers.pm (modified) (2 diffs)
• lib/MT/Upgrade.pm (modified) (1 diff)
• mt-static/css/widget.css (added)
• mt-static/images/drop.gif (added)
• mt-static/js/widget.js (added)
• plugins/WidgetManager/WidgetManager.pl (modified) (2 diffs)
• plugins/WidgetManager/default_widgets (deleted)
• plugins/WidgetManager/lib/WidgetManager/CMS.pm (deleted)
• plugins/WidgetManager/lib/WidgetManager/Plugin.pm (deleted)
• plugins/WidgetManager/php (deleted)
• plugins/WidgetManager/tmpl (deleted)
• tmpl/cms/edit_widget.tmpl (added)
• tmpl/cms/list_widget.tmpl (added)

branches/release-36/lib/MT/App/CMS.pm

@@ -53 +53 @@
 
         ## Edit methods
-        'edit_role'  => "${pkg}User::edit_role",
+        'edit_role'   => "${pkg}User::edit_role",
+        'edit_widget' => "${pkg}Template::edit_widget",
 
         ## Listing methods
@@ -59 +60 @@
         'list_entry'    => "${pkg}Entry::list",
         'list_template' => "${pkg}Template::list",
+        'list_widget'   => "${pkg}Template::list_widget",
         'list_page'     => "${pkg}Page::list",
         'list_comment'  => {
@@ -96 +98 @@
 
         ## Save
-        'save_cat'     => "${pkg}Category::save",
-        'save_entries' => "${pkg}Entry::save_entries",
-        'save_pages'   => "${pkg}Page::save_pages",
-        'save_entry'   => "${pkg}Entry::save",
-        'save_role'    => "${pkg}User::save_role",
+        'save_cat'       => "${pkg}Category::save",
+        'save_entries'   => "${pkg}Entry::save_entries",
+        'save_pages'     => "${pkg}Page::save_pages",
+        'save_entry'     => "${pkg}Entry::save",
+        'save_role'      => "${pkg}User::save_role",
+        'save_widget'    => "${pkg}Template::save_widget",
 
         ## Delete
         'delete_entry'   => "${pkg}Entry::delete",
+        'delete_widget'   => "${pkg}Template::delete_widget",
 
         ## List actions
@@ -1390 +1394 @@
             system_permission    => 'edit_templates',
         },
+        'design:widgets'  => {
+            label         => 'Widgets',
+            mode          => 'list_widget',
+            order         => 200,
+            permission    => 'edit_templates',
+            view          => "blog",
+        },
 
         'prefs:general' => {
@@ -1696 +1707 @@
             $pkg . 'post_save.template'   => "${pfx}Template::post_save",
             $pkg . 'post_delete.template' => "${pfx}Template::post_delete",
+            'restore' => "${pfx}Template::restore_widgetmanagers",
 
             # tags

branches/release-36/lib/MT/Blog.pm

@@ -244 +244 @@
             $obj->include_with_ssi(1) if $pub_opts->{include_with_ssi};
         }
+        if ( ( 'widgetset' eq $val->{type} )
+          && ( exists $val->{widgets} ) ) {
+            my $modulesets = delete $val->{widgets};
+            $obj->modulesets( MT::Template->widgets_to_modulesets($modulesets, $blog->id) );
+        }
         $obj->save;
         if ($val->{mappings}) {

branches/release-36/lib/MT/CMS/Template.pm

@@ -961 +961 @@
         $val->{text} = $app->translate_templatized( $val->{text} );
         my $tmpl = MT::Template->new;
+        if ( ( 'widgetset' eq $val->{type} )
+          && ( exists $val->{modulesets} ) ) {
+            my $modulesets = delete $val->{modulesets};
+            $tmpl->modulesets( join ',', @$modulesets );
+        }
         $tmpl->set_values($val);
         $tmpl->build_dynamic(0);
@@ -1724 +1729 @@
                 # we found that the previous template had not been
                 # altered, so replace it with new default template...
+                if ( ( 'widgetset' eq $val->{type} )
+                  && ( exists $val->{widgets} ) ) {
+                    my $modulesets = delete $val->{widgets};
+                    $tmpl->modulesets( MT::Template->widgets_to_modulesets($modulesets, $blog_id) );
+                }
                 $tmpl->text( $val->{text} );
                 $tmpl->identifier( $val->{identifier} );
@@ -1734 +1744 @@
                 # create this one...
                 my $tmpl = new MT::Template;
+                if ( ( 'widgetset' eq $val->{type} )
+                  && ( exists $val->{widgets} ) ) {
+                    my $modulesets = delete $val->{widgets};
+                    $tmpl->modulesets( MT::Template->widgets_to_modulesets($modulesets, $blog_id) );
+                }
                 $tmpl->build_dynamic(0);
                 $tmpl->set_values(
@@ -1979 +1994 @@
 }
 
+sub save_widget {
+    my $app = shift;
+    my $q   = $app->param;
+
+    $app->validate_magic() or return;
+    my $author = $app->user;
+
+    my $id = $q->param('id');
+
+    if ( !$author->is_superuser ) {
+        $app->run_callbacks( 'cms_save_permission_filter.template', $app, $id )
+          || return $app->error(
+            $app->translate( "Permission denied: [_1]", $app->errstr() ) );
+    }
+
+    my $filter_result = $app->run_callbacks( 'cms_save_filter.widgetset', $app );
+
+    if ( !$filter_result ) {
+        return edit_widget( $app, { error => $app->translate( "Save failed: [_1]", $app->errstr ) } );
+    }
+
+    my $class = $app->model('template');
+    my $obj;
+    if ( $id ) {
+        $obj = $class->load($id)
+            or return $app->error($app->translate("Invalid ID [_1]", $id));
+    }
+    else {
+        $obj = $class->new;
+    }
+
+    my $original = $obj->clone();
+    $obj->name($q->param('name'));
+    $obj->type('widgetset');
+    $obj->blog_id( $q->param('blog_id') || 0 );
+    $obj->modulesets($q->param('modules'));
+
+    unless (
+        $app->run_callbacks( 'cms_pre_save.template', $app, $obj, $original ) )
+    {
+        return edit_widget( $app, { error => $app->translate( "Save failed: [_1]", $app->errstr ) } );
+    }
+
+    $obj->save
+      or return $app->error(
+        $app->translate( "Saving object failed: [_1]", $obj->errstr ) );
+
+    $app->run_callbacks( 'cms_post_save.template', $app, $obj, $original )
+      or return $app->error( $app->errstr() );
+
+    $app->redirect(
+        $app->uri(
+            'mode' => 'edit_widget',
+            args =>
+              { blog_id => $obj->blog_id, 'saved' => 1, rebuild => 1, id => $obj->id }
+        )
+    );
+}
+
+sub edit_widget {
+    my $app = shift;
+    my (%opt) = @_;
+
+    my $q       = $app->param();
+    my $id      = scalar($q->param('id')) || $opt{id};
+    my $blog_id = scalar $q->param('blog_id') || 0;
+
+    my $tmpl_class = $app->model('template');
+    require MT::Promise;
+    my $obj_promise = MT::Promise::delay(
+        sub {
+            return $tmpl_class->load($id) || undef;
+        }
+    );
+
+    if ( !$app->user->is_superuser ) {
+        $app->run_callbacks( 'cms_view_permission_filter.template',
+            $app, $id, $obj_promise )
+          || return $app->error(
+            $app->translate( "Permission denied: [_1]", $app->errstr() ) );
+    }
+
+    my $param = {
+        blog_id      => $blog_id,
+        search_type  => "template",
+        search_label => MT::Template->class_label_plural,
+        $id ? ( id => $id ) : (), 
+        exists($opt{rebuild}) ? ( rebuild => $opt{rebuild} ) : (),
+        exists($opt{error}) ? ( error => $opt{error} ) : (),
+        exists($opt{saved}) ? ( saved => $opt{saved} ) : ()
+    };
+    if ($blog_id) {
+        my $blog = $app->blog;
+        # include_system/include_cache are only applicable
+        # to blog-level templates
+        $param->{include_system} = $blog->include_system;
+        $param->{include_cache} = $blog->include_cache;
+        $param->{include_with_ssi}      = 0;
+        $param->{cache_path}            = '';
+        $param->{cache_enabled}         = 0;
+        $param->{cache_expire_type}     = 0;
+        $param->{cache_expire_period}   = '';
+        $param->{cache_expire_interval} = 0;
+        $param->{ssi_type} = uc $blog->include_system;
+    }
+    
+    my $iter = $tmpl_class->load_iter(
+        { type => 'widget', blog_id => $blog_id ? [ $blog_id, 0 ] : 0 },
+        { sort => 'name', direction => 'ascend' }
+    );
+
+    my %all_widgets;
+    while (my $m = $iter->()) {
+        next unless $m;
+        $all_widgets{ $m->id } = $m->name;
+    }
+
+    my @inst_modules;
+    my $wtmpl;
+    if ( $id ) {
+        $wtmpl = $obj_promise->force()
+          or return $app->error(
+            $app->translate(
+                "Load failed: [_1]",
+                $tmpl_class->errstr || $app->translate("(no reason given)")
+            )
+          );
+        $param->{name} = $wtmpl->name;
+        $param->{include_with_ssi} = $wtmpl->include_with_ssi
+          if defined $wtmpl->include_with_ssi;
+        $param->{cache_path}       = $wtmpl->cache_path
+          if defined $wtmpl->cache_path;
+        $param->{cache_expire_type} = $wtmpl->cache_expire_type
+          if defined $wtmpl->cache_expire_type;
+        my ( $period, $interval ) =
+          _get_schedule( $wtmpl->cache_expire_interval );
+        $param->{cache_expire_period}   = $period   if defined $period;
+        $param->{cache_expire_interval} = $interval if defined $interval;
+        my @events = split ',', $wtmpl->cache_expire_event;
+        foreach my $name (@events) {
+            $param->{ 'cache_expire_event_' . $name } = 1;
+        }
+        my $modulesets = $wtmpl->modulesets;
+        if ( $modulesets ) {
+            my @modules = split ',', $modulesets;
+            foreach my $mid ( @modules ) {
+                push @inst_modules, { id => $mid, name => $all_widgets{$mid} };
+                delete $all_widgets{$mid};
+            }
+        }
+    }
+    $param->{installed} = \@inst_modules if @inst_modules;
+    my @avail_modules = map { { id => $_, name => $all_widgets{$_} } }
+        keys %all_widgets;
+    $param->{available} = \@avail_modules;
+
+    my $res = $app->run_callbacks('cms_edit.widgetset', $app, $id, $wtmpl, $param);
+    if (!$res) {
+        return $app->error($app->callback_errstr());
+    }
+
+    $app->load_tmpl('edit_widget.tmpl', $param);
+}
+
+sub list_widget {
+    my $app = shift;
+    my (%opt) = @_;
+    my $q = $app->param;
+
+    my $perms = $app->blog ? $app->permissions : $app->user->permissions;
+    return $app->return_to_dashboard( redirect => 1 )
+      unless $perms || $app->user->is_superuser;
+    if ( $perms && !$perms->can_edit_templates ) {
+        return $app->return_to_dashboard( permission => 1 );
+    }
+    my $blog_id = $q->param('blog_id') || 0;
+
+    my $widget_loop = &build_template_table( $app,
+        load_args => [ 
+            { type => 'widget', blog_id => $blog_id ? [ $blog_id, 0 ] : 0 },
+            { sort => 'name', direction => 'ascend' }
+        ],
+    );
+    
+    my $param = {
+        widget_table   => $widget_loop,
+        object_type    => "widgetset",
+        search_type    => "template",
+        search_label   => MT::Template->class_label_plural,
+        listing_screen => 1,
+        screen_id      => "list-widget-set",
+        $blog_id ? ( blog_view => 1, blog_id => $blog_id ) : (),
+        exists($opt{rebuild}) ? ( rebuild => $opt{rebuild} ) : (),
+        exists($opt{error}) ? ( error => $opt{error} ) : (),
+        exists($opt{deleted}) ? ( saved => $opt{deleted} ) : ()
+    };
+
+    my $iter = $app->model('template')->load_iter(
+        { type => 'widgetset', blog_id => $blog_id ? [ $blog_id, 0 ] : 0 },
+        { sort => 'name', direction => 'ascend' }
+    );
+    my @widgetmanagers;
+    while ( my $widgetset = $iter->() ) {
+        next unless $widgetset;
+        my $ws = { 
+            id => $widgetset->id,
+            widgetmanager => $widgetset->name,
+        };
+        if ( my $modulesets = $widgetset->modulesets ) {
+            $ws->{widgets} = $modulesets;
+            my @names;
+            foreach my $module ( split ',', $modulesets ) { 
+                my ( $widget ) = grep { $_->{id} eq $module } @$widget_loop;
+                push @names, $widget->{name} if $widget;
+            }
+            $ws->{names} = join(', ', @names) if @names;
+        }
+        push @widgetmanagers, $ws;
+    }
+    $param->{object_loop} = \@widgetmanagers if @widgetmanagers;
+
+    $app->load_tmpl('list_widget.tmpl', $param);
+}
+
+sub delete_widget {
+    my $app  = shift;
+    my $q    = $app->param;
+    my $type = $q->param('_type');
+
+    return $app->errtrans("Invalid request.")
+      unless $type;
+
+    return $app->error( $app->translate("Invalid request.") )
+      if $app->request_method() ne 'POST';
+
+    $app->validate_magic() or return;
+
+    my $tmpl_class = $app->model('template');
+
+    for my $id ( $q->param('id') ) {
+        next unless $id;    # avoid 'empty' ids
+
+        my $obj = $tmpl_class->load($id);
+        next unless $obj;
+        $app->run_callbacks( 'cms_delete_permission_filter.template',
+            $app, $obj )
+          || return $app->error(
+            $app->translate( "Permission denied: [_1]", $app->errstr() ) );
+
+        $obj->remove
+          or return $app->errtrans(
+            'Removing [_1] failed: [_2]',
+            $app->translate('template'),
+            $obj->errstr
+          );
+        $app->run_callbacks( 'cms_post_delete.template', $app, $obj );
+    }
+    $app->call_return;
+}
+
+sub restore_widgetmanagers {
+    my ($cb, $objects, $deferred, $errors, $callback) = @_;
+    my @keys = grep { $_ =~ /^MT::Template#/ } keys( %$objects );
+    foreach my $key ( @keys ) {
+        my $tmpl = $objects->{$key};
+        next unless 'widgetset' eq $tmpl->type;
+        my $modulesets = $tmpl->modulesets;
+        next unless $modulesets;
+        $callback->( MT->translate( 'Restoring widget set [_1]... ', $tmpl->name ) );
+
+        my @tmpl_ids = split ',', $modulesets;
+        my @new_ids;
+        foreach my $id ( @tmpl_ids ) {
+            my $new_tmpl = $objects->{"MT::Template#$id"};
+            next unless $new_tmpl;
+            push @new_ids, $new_tmpl->id;
+        }
+        if ( @new_ids ) {
+            $tmpl->modulesets( join(',', @new_ids) );
+            $tmpl->save;
+            $callback->( MT->translate("Done.") . "\n" );
+        }
+        else {
+            $callback->( MT->translate("Failed.") . "\n" );
+        }
+    }
+    1;
+}
+
 {
     my @period_options = (

branches/release-36/lib/MT/Core.pm

@@ -713 +713 @@
                 content => qq{<mt:SetVarBlock name="variable">\n    \$0\n</mt:SetVarBlock>\n},
             },
+            'widget_manager' => {
+                trigger => 'widget',
+                label => 'Widget Set',
+                content => '<$mt:WidgetSet name="$0"$>',
+            },
         },
     };

branches/release-36/lib/MT/DefaultTemplates.pm

@@ -141 +141 @@
             'trackbacks' => {
                 label => 'Trackbacks',
+            },
+        },
+        'widget' => {
+            'about_this_page' => {
+                fielname => 'about_this_page.mtml',
+                label => 'About This Page',
+            },
+            'archive_widgets_group' => {
+                fielname => 'archive_widgets_group.mtml',
+                label => 'Archive Widgets Group',
+            },
+            'author_archive_list' => {
+                fielname => 'author_archive_list.mtml',
+                label => 'Author Archives',
+            },
+            'current_author_monthly_archive_list' => {
+                fielname => 'current_author_monthly_archive_list.mtml',
+                label => 'Current Author Monthly Archives',
+            },
+            'calendar' => {
+                fielname => 'calendar.mtml',
+                label => 'Calendar',
+            },
+            'category_archive_list' => {
+                fielname => 'category_archive_list.mtml',
+                label => 'Category Archives',
+            },
+            'current_category_monthly_archive_list' => {
+                fielname => 'current_category_monthly_archive_list.mtml',
+                label => 'Current Category Monthly Archives',
+            },
+            'creative_commons' => {
+                fielname => 'creative_commons.mtml',
+                label => 'Creative Commons',
+            },
+            'main_index_widgets_group' => {
+                fielname => 'main_index_widgets_group.mtml',
+                label => 'Home Page Widgets Group',
+            },
+            'monthly_archive_dropdown' => {
+                fielname => 'monthly_archive_dropdown.mtml',
+                label => 'Monthly Archives Dropdown',
+            },
+            'monthly_archive_list' => {
+                fielname => 'monthly_archive_list.mtml',
+                label => 'Monthly Archives',
+            },
+            'pages_list' => {
+                fielname => 'pages_list.mtml',
+                label => 'Page Listing',
+            },
+            'recent_assets' => {
+                fielname => 'recent_assets.mtml',
+                label => 'Recent Assets',
+            },
+            'powered_by' => {
+                fielname => 'powered_by.mtml',
+                label => 'Powered By',
+            },
+            'recent_comments' => {
+                fielname => 'recent_comments.mtml',
+                label => 'Recent Comments',
+            },
+            'recent_entries' => {
+                fielname => 'recent_entries.mtml',
+                label => 'Recent Entries',
+            },
+            'search' => {
+                fielname => 'search.mtml',
+                label => 'Search',
+            },
+            'signin' => {
+                fielname => 'signin.mtml',
+                label => 'Sign In',
+            },
+            'syndication' => {
+                fielname => 'syndication.mtml',
+                label => 'Syndication',
+            },
+            'tag_cloud' => {
+                fielname => 'tag_cloud.mtml',
+                label => 'Tag Cloud',
+            },
+            'technorati_search' => {
+                fielname => 'technorati_search.mtml',
+                label => 'Technorati Search',
+            },
+            'date_based_author_archives' => {
+                fielname => 'date_based_author_archives.mtml',
+                label => 'Date-Based Author Archives',
+            },
+            'date_based_category_archives' => {
+                fielname => 'date_based_category_archives.mtml',
+                label => 'Date-Based Category Archives',
+            }
+        },
+        'widgetset' => {
+            '2column_layout_sidebar' => {
+                order => 1000,
+                label   => '2-column layout - Sidebar',
+                widgets => [
+                    'Search',
+                    'About This Page',
+                    'Home Page Widgets Group',
+                    'Archive Widgets Group',
+                    'Page Listing',
+                    'Syndication',
+                    'Powered By',
+                ],
+            },
+            '3column_layout_primary_sidebar' => {
+                order => 1000,
+                label   => '3-column layout - Primary Sidebar',
+                widgets => [
+                    'Archive Widgets Group',
+                    'Page Listing',
+                    'Syndication',
+                    'Powered By',
+                ],
+            },
+            '3column_layout_secondary_sidebar' => {
+                order => 1000,
+                label   => '3-column layout - Secondary Sidebar',
+                widgets => [
+                    'Search',
+                    'Home Page Widgets Group',
+                    'About This Page',
+                ],
             },
         },
@@ -238 +366 @@
                 }
                 $tmpl->{set} = $type; # system, index, archive, etc.
+                $tmpl->{order} = 0 unless exists $tmpl->{order};
 
                 $type = 'custom' if $type eq 'module';
@@ -274 +403 @@
     }
     my @tmpls = (values(%tmpls), values(%global_tmpls));
+    @tmpls = sort { $a->{order} <=> $b->{order} } @tmpls;
     MT->run_callbacks('DefaultTemplateFilter' . ($set ? '.' . $set : ''), \@tmpls);
     return \@tmpls;

branches/release-36/lib/MT/Template.pm

@@ -44 +44 @@
         'cache_expire_event' => 'string meta',
         'cache_path' => 'string meta',
+        'modulesets' => 'string meta',
     },
     indexes => {
@@ -283 +284 @@
 }
 
+sub widgets_to_modulesets {
+    my $pkg = shift;
+    my ( $widgets, $blog_id ) = @_;
+    return unless $widgets && @$widgets;
+
+    my @widgets = map { MT->translate( $_ ) } @$widgets;
+
+    my @wtmpls = $pkg->load(
+        { name => \@widgets, blog_id => $blog_id ? [ $blog_id, 0 ] : 0, type => 'widget' }
+    );
+    my @wids;
+    foreach my $name ( @widgets ) {
+        my ( $widget ) = grep { $_->name eq $name } @wtmpls;
+        next unless $widget;
+        push @wids, $widget->id;
+    }
+    return join ',', @wids;
+}
+
+sub save_widgetset {
+    my $obj = shift;
+
+    my $ms = $obj->modulesets;
+    # build module list
+    my @inst;
+    if ( $ms && $ms =~ /;/ ) {
+        my @mods = split /;/, $ms;
+        for (@mods) {
+            # tmpl_id = column index . order in column ;
+            my ($id, $col) = /(\d+)=(\d+)\.(\d+)/;
+            push @inst, $id if $col && ( $col == 1 );
+        }
+        $obj->modulesets( join ',', @inst );
+    }
+    else {
+        @inst = split /,/, $obj->modulesets;
+    }
+
+    my @widgets = MT::Template->load(
+        { id => \@inst, type => 'widget',
+          blog_id => $obj->blog_id ? [ 0, $obj->blog_id ] : '0' },
+        { fetchonly => [ 'id', 'name' ] }
+    );
+
+    my $string_tmpl = '<mt:include widget="%s">';
+    my $text = q();
+    foreach my $wid (@inst) {
+        my ( $tmpl ) = grep { $_->id eq $wid } @widgets;
+        next unless $tmpl;
+        $text .= sprintf( $string_tmpl, $tmpl->name );
+    }
+    $obj->text($text) if $text;
+    return $obj->SUPER::save;
+}
+
 sub save {
     my $tmpl = shift;
@@ -289 +345 @@
         && ($existing->type eq $tmpl->type)) {
         return $tmpl->error(MT->translate('Template with the same name already exists in this blog.'));
+    }
+
+    if ( 'widgetset' eq $tmpl->type ) {
+        return $tmpl->save_widgetset();
     }
 

branches/release-36/lib/MT/Template/ContextHandlers.pm

@@ -361 +361 @@
             Include => \&_hdlr_include,
             Link => \&_hdlr_link,
+            WidgetManager => \&_hdlr_widget_manager,
+            WidgetSet => \&_hdlr_widget_manager,
 
             ErrorMessage => \&_hdlr_error_message,
@@ -9000 +9002 @@
 }
 
+sub _hdlr_widget_manager {
+    my ( $ctx, $args ) = @_;
+    my $tmpl_name = $args->{name}
+        or return $ctx->error(MT->translate("name is required."));
+    my $blog_id = $args->{blog_id} || $ctx->{__stash}{blog_id} || 0;
+
+    require MT::Template;
+    my $tmpl = MT::Template->load({ name => $tmpl_name,
+                                    blog_id => $blog_id ? [ 0, $blog_id ] : 0,
+                                    type => 'widgetset' })
+        or return $ctx->error(MT->translate("Specified WidgetSet not found."));
+    my $text = $tmpl->text;
+    return $ctx->build($text) if $text;
+
+    my $modulesets = $tmpl->modulesets;
+    return ''; # empty widgetset is not an error
+
+    my $string_tmpl = '<mt:include widget="%s">';
+    my @selected = split ','. $modulesets;
+    foreach my $mid (@selected) {
+        my $wtmpl = MT::Template->load($mid)
+            or return $ctx->error(MT->translate(
+                "Can't find included template widget '[_1]'", $mid ));
+        $text .= sprintf( $string_tmpl, $wtmpl->name );
+    }
+    return '' unless $text;
+    return $ctx->build($text);
+}
+
 1;

branches/release-36/lib/MT/Upgrade.pm

@@ -1948 +1948 @@
         my $obj = MT::Template->new;
         $obj->build_dynamic(0);
+        if ( ( 'widgetset' eq $val->{type} )
+          && ( exists $val->{widgets} ) ) {
+            my $modulesets = delete $val->{widgets};
+            $obj->modulesets( MT::Template->widgets_to_modulesets($modulesets, $blog_id) );
+        }
         foreach my $v (keys %$val) {
             $obj->column($v, $val->{$v}) if $obj->has_column($v);

branches/release-36/plugins/WidgetManager/WidgetManager.pl

@@ -15 +15 @@
 use base qw( MT::Plugin );
 use constant DEBUG => 0;
-our $VERSION = '1.0';
+use MT::Template;
+use MT::Util qw( escape_unicode );
+use MT::I18N qw( encode_text );
+
+our $VERSION = '1.1';
 
 my $plugin = MT::Plugin::WidgetManager->new({
-    id          => 'WidgetManager',
-    name        => 'Widget Manager',
-    description => q(<MT_TRANS phrase="Maintain your blog's widget content using a handy drag and drop interface.">),
-    version     => $VERSION,
-    author_name => 'Six Apart',
-    key         => 'widget-manager',
-    l10n_class  => 'WidgetManager::L10N',
+    id             => 'WidgetManager',
+    name           => 'Widget Manager Upgrade Assistant',
+    description    => q(<MT_TRANS phrase="Widget Manager version 1.1; This version of the plugin is to upgrade data from older version of Widget Manager that has been shipped with Movable Type to the Movable Type core schema.  No other features are included.  You can safely remove this plugin after installing/upgrading Movable Type.\">),
+    version        => $VERSION,
+    schema_version => $VERSION,
+    author_name    => 'Six Apart, Ltd.',
+    key            => 'widget-manager',
+    l10n_class     => 'WidgetManager::L10N',
 });
 MT->add_plugin($plugin);
@@ -33 +38 @@
     my $plugin = shift;
     $plugin->registry({
-        tags => {
-            help_url => sub { MT->translate('http://www.movabletype.org/documentation/appendices/tags/%t.html') },
-            function => {
-                WidgetManager => '$WidgetManager::WidgetManager::Plugin::_hdlr_widget_manager',
-                WidgetSet => '$WidgetManager::WidgetManager::Plugin::_hdlr_widget_manager',
+        upgrade_functions => {
+            'upgrade_widgetmanagers_nv' => {
+                # this is to workaround absence of PluginSchemaVersion
+                code => \&upgrade_widgetmanagers,
             },
-        },
-        callbacks => {
-            'clone_blog_widgets' => {
-                callback => 'MT::Blog::post_clone',
-                handler => '$WidgetManager::WidgetManager::Plugin::clone_blog_widgemanagers',
-            },
-            'remove_blog_widgets' => {
-                callback => 'MT::Blog::post_remove',
-                handler => '$WidgetManager::WidgetManager::Plugin::remove_blog_widgetmanager',
-            },
-            'DefaultTemplateFilter' => '$WidgetManager::MT::Plugin::WidgetManager::default_templates',
-            'MT::Blog::post_create_default_templates' => '$WidgetManager::WidgetManager::Plugin::create_default_widgetsets',
-            'restore' => '$WidgetManager::WidgetManager::Plugin::restore_widgetmanagers',
-        },
-        applications => {
-            cms => {
-                methods => {
-                    list_widget => '$WidgetManager::WidgetManager::CMS::list',
-                    edit_widget => '$WidgetManager::WidgetManager::CMS::edit',
-                    delete_widget => '$WidgetManager::WidgetManager::CMS::delete',
-                    save_widget => '$WidgetManager::WidgetManager::CMS::save',
-                },
-                menus => {
-                    'design:widgets' => {
-                        label => 'Widgets',
-                        mode => 'list_widget',
-                        order => 200,
-                        permission => 'edit_templates',
-                        view => "blog",
-                    },
-                },
-                template_snippets => {
-                    'widget_manager' => {
-                        label => 'Widget Set',
-                        content => '<$mt:WidgetSet name="$0"$>',
-                        trigger => 'widget',
-                    },
-                },
-            },
+            'upgrade_widgetmanagers' => {
+                version_limit => 1.1,
+                code => \&upgrade_widgetmanagers,
+            }
         },
     });
+    return 1;
 }
 
-sub load_selected_modules { 
-    require WidgetManager::Plugin; 
-    WidgetManager::Plugin::load_selected_modules(@_); 
-}
+sub _disable_widgetmanager { 
+    my $switch = MT->config('PluginSwitch') || {}; 
+    $switch->{$plugin->{plugin_sig}} = 0; 
+    MT->config('PluginSwitch', $switch, 1); 
+    MT->config->save_config(); 
+} 
 
-sub default_templates {
-    my $cb = shift;
-    my ($tmpl_list) = @_;
+sub _translate_escape { 
+    my $trans = $plugin->translate(@_); 
+    return $trans if $MT::Upgrade::CLI; 
+    $trans = MT::I18N::encode_text($trans, undef, 'utf-8'); 
+    return MT::Util::escape_unicode($trans); 
+} 
 
-    my $widgetmgr = MT::Plugin::WidgetManager->instance;
-    my $widget_tmpls = $widgetmgr->templates(MT->instance);
-    push @$tmpl_list, @$widget_tmpls;
-}
+sub upgrade_widgetmanagers { 
+    my $upg = shift; 
 
-sub templates {
-    my $plugin = shift;
-    my ($app) = @_;
-    my $default_widget_templates;
-
-    use File::Spec;
-    my $widgets_dir = File::Spec->catfile($plugin->{full_path}, 'default_widgets');
-    my $cfg_file = File::Spec->catfile($widgets_dir, 'widgets.cfg');
-    
-    local(*FH, $_, $/);
-    $/ = "\n";
-    open FH, $cfg_file or
-        return $app->error(MT->translate(
-                               "Error opening file '[_1]': [_2]", $cfg_file, "$!" ));
-    my $cfg = join('',<FH>);
-    eval "$cfg;";
-    close FH;
-
-    my @tmpls;
-    require MT::Template;
-    foreach (@$default_widget_templates) {
-        open(TMPL, File::Spec->catfile($widgets_dir, $_->{template})) or die "Error: $!\n";
-        while (my $line = <TMPL>) {
-            $_->{text} .= $line;
+    require MT::PluginData;
+    my $iter = MT::PluginData->load_iter(
+        { plugin => $plugin->key }
+    );
+    while ( my $pd = $iter->() ) {
+        next unless $plugin->key eq $pd->plugin;
+        my ( $blog_id ) = $pd->key =~ /configuration:blog:(\d+)/;
+        next unless $blog_id;
+        my $config = $pd->data;
+        next unless $config;
+        my $modulesets = $config->{modulesets};
+        next unless $modulesets;
+        foreach my $mod_key ( keys %$modulesets ) {
+            $upg->progress(_translate_escape('Moving storage of Widget Manager [_1]...', $mod_key));
+            my $tmpl_ids = $modulesets->{$mod_key};
+            my $tmpl = MT::Template->new;
+            $tmpl->blog_id($blog_id);
+            $tmpl->name($mod_key);
+            $tmpl->type('widgetset');
+            $tmpl->build_dynamic(0);
+            $tmpl->rebuild_me(0);
+            $tmpl->modulesets($tmpl_ids);
+            $tmpl->save_widgetset
+                or $upg->progress(_translate_escape('Failed.')), next;
+            $upg->progress(_translate_escape('Done.'));
         }
-        close TMPL;
-        my $tmpl = MT::Template->new;
-        $tmpl->{type} = 'widget';
-        $tmpl->{name} = $plugin->translate($_->{label});
-        $tmpl->{text} = $plugin->translate_templatized($_->{text});
-        push @tmpls, $tmpl;
+        $pd->remove;
     }
-    return \@tmpls;
+    _disable_widgetmanager;
 }