root/branches/release-35/lib/MT/Upgrade.pm @ 1897

Revision 1897, 105.8 kB (checked in by bchoate, 20 months ago)

Upgrade users with existing MT::Notification objects with an enabled address book setting. bugid:78883
  • Property svn:keywords set to Id Revision
Line 
1# Movable Type (r) Open Source (C) 2001-2008 Six Apart, Ltd.
2# This program is distributed under the terms of the
3# GNU General Public License, version 2.
4#
5# $Id$
6
7package MT::Upgrade;
8
9use strict;
10use base qw( MT::ErrorHandler );
11use File::Spec;
12
13# The upgrade process...
14#
15#    * Database check of all data types
16#      - assign default values for 'null' columns
17#    * Template check for all blogs
18
19use vars qw(%classes %functions $App $DryRun $Installing $SuperUser
20            $CLI $MAX_TIME $MAX_ROWS @steps);
21sub BEGIN {
22    $MAX_TIME = 5;
23    $MAX_ROWS = 100;
24
25    %functions = (
26        # standard routines
27        'core_upgrade_begin' => {
28            code => \&core_upgrade_begin,
29            priority => 1,
30        },
31        'core_fix_type' => {
32            code => \&core_fix_type,
33            priority => 2,
34        },
35        'core_add_column' => {
36            code => sub { shift->core_column_action('add', @_) },
37            priority => 3,
38        },
39        'core_drop_column' => {
40            code => sub { shift->core_column_action('drop', @_) },
41            priority => 3,
42        },
43        'core_alter_column' => {
44            code => sub { shift->core_column_action('alter', @_) },
45            priority => 3,
46        },
47        'core_index_column' => {
48            code => sub { shift->core_column_action('index', @_) },
49            priority => 3.5,
50        },
51        'core_seed_database' => {
52            code => \&seed_database,
53            priority => 4,
54        },
55        'core_upgrade_templates' => {
56            code => \&upgrade_templates,
57            priority => 5,
58        },
59        'core_upgrade_end' => {
60            code => \&core_upgrade_end,
61            priority => 9,
62        },
63        'core_finish' => {
64            code => \&core_finish,
65            priority => 10,
66        },
67    );
68}
69
70sub core_upgrade_functions {
71    return {
72        # < 2.0
73        'core_create_placements' => {
74            version_limit => 2.0,
75            priority => 9.1,
76            updater => {
77                type => 'entry',
78                label => 'Creating entry category placements...',
79                condition => sub { $_[0]->category_id },
80                code => sub {
81                    require MT::Placement;
82                    my $entry = shift;
83                    my $existing = MT::Placement->load({ entry_id => $entry->id,
84                        category_id => $entry->category_id });
85                    if (!$existing) {
86                        my $place = MT::Placement->new;
87                        $place->entry_id($entry->id);
88                        $place->blog_id($entry->blog_id);
89                        $place->category_id($entry->category_id);
90                        $place->is_primary(1);
91                        $place->save;
92                    }
93                    $entry->category_id(0);
94                },
95            },
96        },
97        'core_create_template_maps' => {
98            version_limit => 2.0,
99            code => \&core_create_template_maps,
100            priority => 9.1,
101        },
102
103        # < 2.1
104        'core_fix_placement_blog_ids' => {
105            version_limit => 2.1,
106            priority => 9.2,
107            updater => {
108                type => 'placement',
109                label => 'Updating category placements...',
110                condition => sub { !$_[0]->blog_id },
111                code => sub {
112                    require MT::Category;
113                    my $cat = MT::Category->load($_[0]->category_id);
114                    $_[0]->blog_id($cat->blog_id) if $cat;
115                },
116            },
117        },
118
119        # < 3.0
120        'core_set_blog_allow_comments' => {
121            version_limit => 3.0,
122            priority => 9.3,
123            updater => {
124                type => 'blog',
125                label => 'Assigning comment/moderation settings...',
126                condition => sub { !(defined $_[0]->allow_unreg_comments ||
127                                     defined $_[0]->allow_reg_comments ||
128                                     defined $_[0]->manual_approve_comments ||
129                                     defined $_[0]->moderate_unreg_comments) },
130                code => sub {
131                    $_[0]->allow_unreg_comments(1)
132                        unless defined $_[0]->allow_unreg_comments;
133                    $_[0]->allow_reg_comments(1)
134                        unless defined $_[0]->allow_reg_comments;
135                    $_[0]->manual_approve_commenters(0)
136                        unless defined $_[0]->manual_approve_commenters;
137                    $_[0]->moderate_unreg_comments(0)
138                        unless defined $_[0]->moderate_unreg_comments;
139                    $_[0]->moderate_pings(0)
140                        unless defined $_[0]->moderate_pings;
141                },
142                sql => [
143                    'update mt_blog
144                        set blog_allow_unreg_comments = 1
145                      where blog_allow_unreg_comments is null',
146                    'update mt_blog
147                        set blog_allow_reg_comments = 1
148                      where blog_allow_reg_comments is null',
149                    'update mt_blog
150                        set blog_manual_approve_commenters = 0
151                      where blog_manual_approve_commenters is null',
152                    'update mt_blog
153                        set blog_moderate_unreg_comments = 0
154                      where blog_moderate_unreg_comments is null'
155                ],
156            },
157        },
158
159        # < 3.2
160        'core_set_default_basename_limit' => {
161            version_limit => 3.2,
162            priority => 9.3,
163            updater => {
164                type => 'blog',
165                label => 'Setting blog basename limits...',
166                condition => sub { !$_[0]->basename_limit },
167                code => sub { $_[0]->basename_limit(15) },
168                sql => 'update mt_blog set blog_basename_limit = 15
169                         where blog_basename_limit is null
170                            or blog_basename_limit < 15',
171            },
172        },
173        'core_set_default_blog_extension' => {
174            version_limit => 3.2,
175            priority => 9.3,
176            updater => {
177                type => 'blog',
178                label => 'Setting default blog file extension...',
179                condition => sub { !$_[0]->file_extension },
180                code => sub { $_[0]->file_extension('html') },
181            },
182        },
183        'core_set_enable_archive_paths' => {
184            version_limit => 3.2,
185            code => \&core_set_enable_archive_paths,
186            priority => 9.3,
187        },
188        # whereas init_comment_visible is done for adding new a comment visible
189        # to the comment table, this task sets all comments with a visible
190        # status of 2 to 0 since we now treat this field as a boolean.
191        'core_update_comment_visible' => {
192            version_limit => 3.2,
193            priority => 9.3,
194            updater => {
195                type => 'entry',
196                label => 'Updating comment status flags...',
197                condition => sub { $_[0]->allow_comments == 2 },
198                code => sub { $_[0]->allow_comments(0) },
199                sql => 'update mt_entry set entry_allow_comments = 0
200                         where entry_allow_comments = 2',
201            },
202        },
203        'core_remove_unique_constraints' => {
204            version_limit => 3.2,
205            code => \&core_remove_unique_constraints,
206            priority => 9.3,
207        },
208        'core_create_commenter_records' => {
209            version_limit => 3.2,
210            priority => 9.3,
211            updater => {
212                type => 'comment',
213                label => 'Updating commenter records...',
214                condition => sub { $_[0]->commenter_id },
215                code => sub {
216                    my ($comment) = @_;
217                    require MT::Permission; require MT::Author;
218                    my $perm = MT::Permission->load( { author_id => $comment->commenter_id,
219                        blog_id => $comment->blog_id } );
220                    if (!$perm) {
221                        if (my $cmtr = MT::Author->load($comment->commenter_id)) {
222                            $cmtr->pending($comment->blog_id);
223                        }
224                    }
225                }
226            }
227        },
228        'core_set_blog_admins' => {
229            version_limit => 3.2,
230            priority => 9.3,
231            updater => {
232                type => 'permission',
233                label => 'Assigning blog administration permissions...',
234                condition => sub { $_[0]->author_id && $_[0]->blog_id && $_[0]->can_edit_config },
235                code => sub {
236                    require MT::Association;
237                    require MT::Role;
238                    my ($role) = MT::Role->load_by_permission("administer_blog");
239                    if ($role) {
240                        my $user = MT::Author->load($_[0]->author_id);
241                        my $blog = MT::Author->load($_[0]->blog_id);
242                        if ($user && $blog) {
243                            MT::Association->link($role => $user => $blog);
244                        }
245                    } else {
246                        $_[0]->can_administer_blog(1)
247                    }
248                },
249            }
250        },
251        'core_set_blog_allow_pings' => {
252            version_limit => 3.2,
253            priority => 9.3,
254            updater => {
255                type => 'blog',
256                label => 'Setting blog allow pings status...',
257                condition => sub { !defined $_[0]->allow_pings },
258                code => sub { $_[0]->allow_pings($_[0]->allow_pings_default) },
259                sql => 'update mt_blog set blog_allow_pings = blog_allow_pings_default
260                         where blog_allow_pings is null',
261            }
262        },
263        'core_set_superuser' => {
264            version_limit => 3.2,
265            code => \&core_set_superuser,
266            priority => 9.3,
267        },
268        'core_conflate_require_email' => {
269            version_limit => 3.2,
270            priority => 9.3,
271            updater => {
272                type => 'blog',
273                label => 'Updating blog comment email requirements...',
274                condition => sub { !$_[0]->require_comment_emails },
275                code => sub { $_[0]->require_comment_emails(1)
276                                  if !$_[0]->allow_anon_comments },
277            }
278        },
279        'core_populate_entry_basenames' => {
280            version_limit => 3.2,
281            priority => 9.3,
282            updater => {
283                type => 'entry',
284                condition => sub { !$_[0]->basename },
285                code => sub { my $entry = shift; my %args = @_;
286                    $args{from} < 3.20021
287                        ? $entry->basename(mt32_dirify($entry->title))
288                        : 1;
289                },
290                label => 'Assigning entry basenames for old entries...',
291            }
292        },
293        'core_set_api_password' => {
294            version_limit => 3.2,
295            priority => 9.3,
296            updater => {
297                type => 'author',
298                condition => sub { ($_[0]->type == 1) && (($_[0]->api_password || '') eq '') },
299                code => sub { $_[0]->api_password($_[0]->password) },
300                label => 'Updating user web services passwords...',
301            }
302        },
303        'core_create_config_table' => {
304            version_limit => 3.2,
305            code => \&core_create_config_table,
306            priority => 9.3,
307        },
308        'core_deprecate_old_style_archive_links' => {
309            version_limit => 3.2,
310            priority => 9.3,
311            updater => {
312                type => 'blog',
313                label => 'Updating blog old archive link status...',
314                condition => sub { my $blog = shift; my %args = @_;
315                                   $blog->old_style_archive_links
316                                       || $args{from} < 3.0 },
317                code => sub {
318                    my ($blog) = @_;
319                    require MT::TemplateMap;
320                    foreach my $map (MT::TemplateMap->load({ blog_id => $blog->id })) {
321                        next if $map->file_template;
322           
323                        my $at = $map->archive_type;
324                        if ($at eq 'Individual') {
325                            $map->file_template('%e%x');
326                        } elsif ($at eq 'Daily') {
327                            $map->file_template('%y_%m_%d%x');
328                        } elsif ($at eq 'Weekly') {
329                            $map->file_template('week_%y_%m_%d%x');
330                        } elsif ($at eq 'Monthly') {
331                            $map->file_template('%y_%m%x');
332                        } elsif ($at eq 'Category') {
333                            $map->file_template('cat_%C%x');
334                        }
335                        $map->save;
336                    }
337                    $blog->old_style_archive_links(0);
338                }
339            }
340        },
341        'core_set_entry_weeknumber' => {
342            version_limit => 3.20006,
343            priority => 9.3,
344            updater => {
345                type => 'entry',
346                condition => sub { ($_[0]->week_number || 0) < 54 },
347                code => sub { 1 },
348                label => 'Updating entry week numbers...',
349            }
350        },
351        'core_set_tag_permissions' => {
352            version_limit => 3.20021,
353            priority => 9.3,
354            updater => {
355                type => 'permission',
356                condition => sub { !$_[0]->can_edit_tags && !$_[0]->can_administer_blog },
357                code => sub { $_[0]->can_edit_tags($_[0]->can_edit_categories) },
358                label => 'Updating user permissions for editing tags...',
359            }
360        },
361        'core_init_blog_entry_display_defaults' => {
362            version_limit => 3.20021,
363            code => sub {
364                require MT::Permission;
365                &core_update_records
366            },
367            priority => 9.3,
368            updater => {
369                type => 'blog',
370                condition => sub { !(MT::Permission->exist({
371                    blog_id => $_[0]->id, author_id => 0 })) },
372                code => sub {
373                    my $perm = new MT::Permission;
374                    $perm->entry_prefs('Advanced|Bottom');
375                    $perm->blog_id($_[0]->id);
376                    $perm->author_id(0);
377                    $perm->save;
378                },
379                label => 'Setting new entry defaults for blogs...',
380            }
381        },
382        'core_upgrade_tag_categories' => {
383            version_limit => 3.20021,
384            priority => 9.3,
385            updater => {
386                type => 'category',
387                condition => sub { ($_[0]->description||'') =~ m/<!--tag-->/ },
388                code => sub {
389                    my ($cat) = @_;
390                    require MT::Placement;
391                    require MT::Entry;
392                    my @e = MT::Entry->load(undef, {join => ['MT::Placement', 'entry_id', { category_id => $cat->id }]});
393                    my $tag_name = $cat->label;
394                    foreach my $e (@e) {
395                        my $tags = $e->tags;
396                        $e->tags($tags, $tag_name);
397                        $e->save;
398                    }
399                },
400                label => 'Migrating any "tag" categories to new tags...',
401            }
402        },
403        'core_init_blog_custom_dynamic_templates' => {
404            on_field => 'MT::Blog->custom_dynamic_templates',
405            priority => 3.1,
406            updater => {
407                type => 'blog',
408                condition => sub { !defined $_[0]->custom_dynamic_templates },
409                code => sub { $_[0]->custom_dynamic_templates('none') },
410                label => 'Assigning custom dynamic template settings...',
411                sql => q{update mt_blog
412                            set blog_custom_dynamic_templates = 'none'
413                          where blog_custom_dynamic_templates is null},
414            }
415        },
416        'core_init_author_type' => {
417            on_field => 'MT::Author->type',
418            priority => 3.1,
419            updater => {
420                type => 'author',
421                condition => sub { !$_[0]->type },
422                code => sub { $_[0]->type(1) },
423                label => 'Assigning user types...',
424                sql => 'update mt_author set author_type = 1
425                        where author_type is null or author_type = 0',
426            }
427        },
428        'core_init_category_parent' => {
429            on_field => 'MT::Category->parent',
430            priority => 3.1,
431            updater => {
432                type => 'category',
433                condition => sub { !defined $_[0]->parent },
434                code => sub { $_[0]->parent(0) },
435                label => 'Assigning category parent fields...',
436                sql => 'update mt_category set category_parent = 0
437                        where category_parent is null',
438            }
439        },
440        'core_init_template_build_dynamic' => {
441            on_field => 'MT::Template->build_dynamic',
442            priority => 3.1,
443            updater => {
444                type => 'template',
445                condition => sub { !defined $_[0]->build_dynamic },
446                code => sub { $_[0]->build_dynamic(0) },
447                label => 'Assigning template build dynamic settings...',
448                sql => 'update mt_template set template_build_dynamic = 0
449                        where template_build_dynamic is null',
450            }
451        },
452        'core_init_comment_visible' => {
453            on_field => 'MT::Comment->visible',
454            priority => 3.1,
455            updater => {
456                type => 'comment',
457                condition => sub { !defined $_[0]->visible },
458                code => sub { $_[0]->visible(1) },
459                label => 'Assigning visible status for comments...',
460                sql => 'update mt_comment set comment_visible = 1
461                        where comment_visible is null',
462            }
463        },
464        'core_init_comment_junk_status' => {
465            version_limit => 4.0053,
466            priority => 3.1,
467            updater => {
468                type => 'comment',
469                condition => sub { !$_[0]->junk_status },
470                code => sub { $_[0]->junk_status(1) },
471                label => 'Assigning junk status for comments...',
472                sql => 'update mt_comment set comment_junk_status = 1
473                        where comment_junk_status is null
474                           or comment_junk_status=0',
475            }
476        },
477        'core_init_tbping_visible' => {
478            on_field => 'MT::TBPing->visible',
479            priority => 3.1,
480            updater => {
481                type => 'tbping',
482                condition => sub { !defined $_[0]->visible },
483                code => sub { $_[0]->visible(1) },
484                label => 'Assigning visible status for TrackBacks...',
485                sql => 'update mt_tbping set tbping_visible = 1
486                        where tbping_visible is null',
487            }
488        },
489        'core_init_tbping_junk_status' => {
490            version_limit => 4.0053,
491            priority => 3.1,
492            updater => {
493                type => 'tbping',
494                condition => sub { !$_[0]->junk_status },
495                code => sub { $_[0]->junk_status(1) },
496                label => 'Assigning junk status for TrackBacks...',
497                sql => 'update mt_tbping set tbping_junk_status = 1
498                        where tbping_junk_status is null
499                          or tbping_junk_status=0',
500            }
501        },
502        'core_init_category_basename' => {
503            version_limit => 3.2002,
504            priority => 3.1,
505            updater => {
506                type => 'category',
507                condition => sub { !defined $_[0]->basename },
508                code => sub { my $cat = shift; my %args = @_;
509                    $args{from} < 3.20021
510                        ? $cat->basename(mt32_dirify($cat->label))
511                        : 1;
512                },
513                label => 'Assigning basename for categories...',
514            }
515        },
516        'core_set_author_status' => {
517            version_limit => 3.301,
518            priority => 3.1,
519            updater => {
520                type => 'author',
521                label => 'Assigning user status...',
522                condition => sub {
523                    ($_[0]->type == 1) && (!defined $_[0]->status)
524                },
525                code => sub {
526                    shift->status(1);
527                },
528                sql => 'update mt_author set author_status = 1
529                        where author_type = 1 and author_status is null',
530            }
531        },
532        'core_install_default_roles' => {
533            code => \&create_default_roles,
534            on_class => 'MT::Role',
535            priority => 3.1,
536        },
537        'core_migrate_permissions_to_roles' => {
538            version_limit => 3.3101,
539            priority => 3.2,
540            updater => {
541                type => 'permission',
542                label => 'Migrating permissions to roles...',
543                condition => sub { $_[0]->blog_id },
544                code => \&_migrate_permission_to_role,
545            }
546        },
547        'core_remove_dynamic_site_bootstrapper' => {
548            code => \&remove_mtviewphp,
549            version_limit => 3.3101,
550            priority => 5.1,
551        },
552        'core_migrate_commenter_auth' => {
553            code => \&migrate_commenter_auth,
554            version_limit => 3.3101,
555            priority => 3.1,
556        },
557        'core_deprecate_bitmask_permissions' => {
558            code => \&deprecate_bitmask_permissions,
559            version_limit => 4.0002,
560            priority => 3.3,
561        },
562        'core_migrate_system_privileges' => {
563            code => \&migrate_system_privileges,
564            version_limit => 4.0002,
565            priority => 3.3,
566        },
567        'core_populate_authored_on' => {
568            version_limit => 4.0014,
569            priority => 3.1,
570            updater => {
571                type => 'entry',
572                label => 'Populating authored and published dates for entries...',
573                condition => sub {
574                    !defined $_[0]->authored_on
575                },
576                code => sub {
577                    $_[0]->authored_on($_[0]->created_on)
578                        if !defined $_[0]->authored_on;
579                },
580                sql =>
581                    'update mt_entry set entry_authored_on = entry_created_on
582                        where entry_authored_on is null',
583            },
584        },
585        'core_update_3x_system_search_templates' => {
586            version_limit => 4.0017,
587            priority => 3.1,
588            code => \&update_3x_system_search_templates,
589        },
590        'core_rename_php_plugin_filenames' => {
591            version_limit => 4.0019,
592            priority => 3.1,
593            code => \&rename_php_plugin_filenames,
594        },
595        'core_migrate_nofollow_settings' => {
596            version_limit => 4.0020,
597            priority => 3.1,
598            code => \&migrate_nofollow_settings,
599        },
600        'core_update_widget_template' => {
601            version_limit => 4.0022,
602            priority => 3.1,
603            code => \&update_widget_templates,
604        },
605        # This upgrade step is currently necessary for PostgreSQL
606        # which doesn't support adding a column, populating the existing
607        # records with a value.
608        'core_typify_category_records' => {
609            version_limit => 4.0023,
610            priority => 3.1,
611            updater => {
612                type => 'category',
613                label => 'Classifying category records...',
614                condition => sub {
615                    !$_[0]->column('class')
616                },
617                code => sub {
618                    $_[0]->class('category');
619                },
620                sql =>
621                    "update mt_category set category_class = 'category'
622                        where category_class is null",
623            },
624        },
625        'core_typify_entry_records' => {
626            version_limit => 4.0023,
627            priority => 3.1,
628            updater => {
629                type => 'entry',
630                label => 'Classifying entry records...',
631                condition => sub {
632                    !$_[0]->column('class')
633                },
634                code => sub {
635                    $_[0]->class('entry');
636                },
637                sql =>
638                    "update mt_entry set entry_class = 'entry'
639                        where entry_class is null",
640            },
641        },
642        'core_merge_comment_response_templates' => {
643            version_limit => 4.0023,
644            priority => 3.1,
645            updater => {
646                type => 'blog',
647                label => "Merging comment system templates...",
648                code => \&_merge_comment_response_templates_updater,
649            },
650        },
651        'core_populate_default_file_template' => {
652            version_limit => 4.0023,
653            priority => 3.1,
654            updater => {
655                type => 'templatemap',
656                label => 'Populating default file template for templatemaps...',
657                condition => sub {
658                    !defined $_[0]->file_template
659                },
660                code => sub {
661                    my %default_template = (
662                        Individual => '%y/%m/%f',
663                        Category => '%c/%i',
664                    );
665                    $_[0]->file_template($default_template{$_[0]->archive_type})
666                        if !defined $_[0]->file_template && exists($default_template{$_[0]->archive_type});
667                },
668            },
669        },
670        'core_remove_unused_templatemap' => {
671            version_limit => 4.0023,
672            priority => 3.0,
673            updater => {
674                type => 'blog',
675                label => 'Removing unused template maps...',
676                condition => sub {
677                    my $blog = shift;
678                    my @blog_at = map { "'$_'" } split ',', $blog->archive_type;
679                    MT::TemplateMap->remove(
680                      { blog_id => $blog->id, archive_type => \@blog_at },
681                      { not => { archive_type => 1 } }
682                    ) if @blog_at;
683                    return 0;
684                },
685            },
686        },
687        'core_set_author_auth_type' => {
688            version_limit => 4.0024,
689            priority => 3.2,
690            updater => {
691                type => 'author',
692                label => 'Assigning user authentication type...',
693                condition => sub {
694                    !$_[0]->auth_type;
695                },
696                code => \&core_populate_author_auth_type,
697            },
698        },
699        'core_add_newfeature_widget' => {
700            version_limit => 4.0027,
701            priority => 3.2,
702            updater => {
703                type => 'author',
704                label => 'Adding new feature widget to dashboard...',
705                condition => sub {
706                    my ($user) = @_;
707                    $user->type == MT::Author::AUTHOR(); # AUTHOR records only
708                },
709                code => sub {
710                    my ($user) = @_;
711                    my $widget_store = $user->widgets();
712                    if ($widget_store && %$widget_store) {
713                        for my $set (keys %$widget_store) {
714                            $widget_store->{$set}->{new_version} = {
715                                template => 'widget/new_version.tmpl',
716                                set      => 'main',
717                                singular => 1,
718                                order    => -1,
719                            };
720                        }
721                    }
722                    $user->widgets($widget_store);
723                },
724            },
725        },
726        'core_add_email_template' => {
727            version_limit => 4.0030,
728            priority => 9.3,
729            code => sub {
730                my $self = shift;
731                $self->upgrade_templates({ Install => 1 });
732            },
733        },
734        'core_replace_openid_username' => {
735            version_limit => 4.0033,
736            priority => 3.2,
737            updater => {
738                type => 'author',
739                label => 'Moving OpenID usernames to external_id fields...',
740                condition => sub {
741                    return 0 if 'MT' eq $_[0]->auth_type;
742                    my $auth = MT->commenter_authenticator($_[0]->auth_type);
743                    return 0 unless $auth && %$auth && exists($auth->{class});
744                    my $auth_class = $auth->{class};
745                    eval "require $auth_class;";
746                    return 0 if $@;
747                    return UNIVERSAL::isa($auth_class, 'MT::Auth::OpenID');
748                },
749                code => sub {
750                    return unless $_[0]->url;
751                    my $existing = MT::Author->load({ name => $_[0]->url, auth_type => 'OpenID' });
752                    unless ($existing) {
753                        $_[0]->external_id($_[0]->name);
754                        $_[0]->name($_[0]->url);
755                    }
756                },
757            },
758        },
759        'core_set_template_set' => {
760            version_limit => 4.0034,
761            priority => 3.2,
762            updater => {
763                type => 'blog',
764                label => 'Assigning blog template set...',
765                condition => sub {
766                    !$_[0]->template_set;
767                },
768                code => sub {
769                    $_[0]->template_set('mt_blog');
770                    MT->run_callbacks( 'blog_template_set_change', { blog => $_[0] } );
771                },
772            },
773        },
774        'core_set_page_layout' => {
775            version_limit => 4.0036,
776            priority => 3.2,
777            updater => {
778                type => 'blog',
779                label => 'Assigning blog page layout...',
780                condition => sub {
781                    !$_[0]->page_layout;
782                },
783                code => sub {
784                    my ($blog) = @_;
785                    my $layout = 'layout-wtt';
786                    require MT::Template;
787                    my $styles = MT::Template->load({ blog_id => $blog->id, identifier => 'styles' });
788                    if ($styles) {
789                        if ($styles->text =~ m{ <mt:?setvar \s+ name="page_layout" \s+ value="([^"]+)"> }xmsi) {
790                            $layout = $1;
791                        }
792                    }
793                    $blog->page_layout($layout);
794                },
795            },
796        },
797        'core_set_author_basename' => {
798            version_limit => 4.0037,
799            priority => 3.2,
800            updater => {
801                type => 'author',
802                label => 'Assigning author basename...',
803                condition => sub {
804                    $_[0]->type == 1;
805                },
806                code => sub {
807                    my ($author) = @_;
808                    my $basename = MT::Util::make_unique_author_basename($author);
809                    $author->basename($basename);
810                },
811            },
812        },
813        'core_remove_indexes' => {
814            version_limit => 4.0041,
815            priority => 3.2,
816            code => \&remove_indexes,
817        },
818        'core_set_count_columns' => {
819            version_limit => 4.0047,
820            priority      => 3.2,
821            updater       => {
822                type      => 'entry',
823                label     => 'Assigning entry comment and TrackBack counts...',
824                condition => sub {
825                    require MT::Comment;
826                    my $comment_count = MT::Comment->count(
827                        {
828                            entry_id => $_[0]->id,
829                            visible  => 1,
830                        }
831                    );
832                    $_[0]->comment_count($comment_count);
833                    require MT::Trackback;
834                    require MT::TBPing;
835                    my $tb = MT::Trackback->load( { entry_id => $_[0]->id } );
836                    my $ping_count;
837                    if ($tb) {
838                        my $ping_count = MT::TBPing->count(
839                            {
840                                tb_id   => $tb->id,
841                                visible => 1,
842                            }
843                        );
844                        $_[0]->ping_count($ping_count);
845                    }
846                    ( $comment_count || $ping_count );
847                },
848                # only count once and set it, so code do nothing.
849                # it doesn't have the unnecessary save.
850                code => sub { 1; },
851            },
852        },
853        'core_assign_object_embedded' => {
854            version_limit => 4.0052,
855            priority => 3.2,
856            updater => {
857                type => 'objectasset',
858                label => 'Assigning embedded flag to asset placements...',
859                code => sub {
860                    $_[0]->embedded(1);
861                },
862                sql => 'update mt_objectasset set objectasset_embedded=1',
863            },
864        },
865        'core_enable_address_book' => {
866            version_limit => 4.0054,
867            priority => 3.2,
868            code => sub {
869                require MT::Notification;
870                if (MT::Notification->exist()) {
871                    my $cfg = MT->config;
872                    if (! $cfg->EnableAddressBook) {
873                        $cfg->EnableAddressBook(1, 1);
874                        $cfg->save;
875                    }
876                }
877                return 0;
878            },
879        },
880    }
881}
882
883sub core_populate_author_auth_type {
884    my ($u) = @_;
885    if ($u->type == 1) {
886        $u->auth_type(MT->config->AuthenticationModule || 'MT');
887    } else {
888        # for legacy OpenID plugin commenters
889        if ($u->name =~ m(^openid\n(.*)$)) {
890            my $url = $1;
891            if (eval { require Digest::MD5; 1; }) {
892                $url = Digest::MD5::md5_hex($url);
893            } else {
894                $url = substr $url, 0, 255;
895            }
896            $u->name($url);
897            $u->auth_type('OpenID');
898        }
899        elsif ($u->name =~ m!^[a-f0-9]{32}$!) {
900            # Vox OpenID URL; set auth_type to 'Vox'
901            if ($u->url =~ m!\.vox\.com/!) {
902                $u->auth_type('Vox');
903            }
904            # LJ OpenID URL; set auth_type to 'LiveJournal'
905            elsif ($u->url =~ m!\.livejournal\.com/!) {
906                $u->auth_type('LiveJournal');
907            }
908            else {
909                # Other custom auth, which for now means OpenID
910                $u->auth_type('OpenID');
911            }
912        }
913        else {
914            # Default to TypeKey for remaining plain name fields
915            $u->auth_type('TypeKey');
916        }
917    }
918}
919
920sub migrate_nofollow_settings {
921    my $self = shift;
922
923    $self->progress($self->translate_escape("Migrating Nofollow plugin settings..."));
924    require MT::PluginData;
925    my $cfg = MT->config;
926    my $plugins = $cfg->PluginSwitch || {};
927    my $nofollow_switch = $plugins->{'nofollow/nofollow.pl'};
928    my $enabled = defined $nofollow_switch ? ($nofollow_switch ? 1 : 0) : 1;
929    my $default_follow_auth_links = 1;
930
931    # For any configuration settings that exist
932    my @config = MT::PluginData->load({ plugin => 'Nofollow' });
933    my %blogs_saved;
934    foreach my $cfg (@config) {
935        if ($cfg->key =~ m/^configuration:blog:(\d+)/) {
936            my $blog = MT::Blog->load($1) or next;
937            my $setting = ($cfg->data || {})->{follow_auth_links};
938            $blog->follow_auth_links($setting) if defined $setting;
939            $blog->nofollow_urls($enabled);
940            $blog->save;
941            $blogs_saved{$blog->id} = 1;
942        } else {
943            my $setting = ($cfg->data || {})->{follow_auth_links};
944            $default_follow_auth_links = $setting if defined $setting;
945        }
946    }
947    $_->remove for @config;
948
949    my $blog_iter = MT::Blog->load_iter;
950    while (my $blog = $blog_iter->()) {
951        next if exists $blogs_saved{$blog->id};
952        $blog->nofollow_urls($enabled);
953        $blog->follow_auth_links($default_follow_auth_links);
954        $blog->save;
955    }
956
957    # Forcibly disable nofollow plugin now since this has become
958    # a core function.
959    $cfg->PluginSwitch('nofollow/nofollow.pl=0', 1);
960    $cfg->save_config();
961
962    return 0;
963}
964
965sub update_3x_system_search_templates {
966    my $self = shift;
967
968    require MT::Template;
969    $self->progress($self->translate_escape('Updating system search template records...'));
970    my $tmpl_iter = MT::Template->load_iter({
971        type => 'search_template',
972    });
973    my %blogs;
974    while (my $tmpl = $tmpl_iter->()) {
975        $blogs{$tmpl->blog_id} = $tmpl->id;
976        $tmpl->type('search_results');
977        $tmpl->save;
978    }
979    # for any old 'search_template' system templates, remove the
980    # newly installed 'search_results' template.
981    foreach my $blog_id (keys %blogs) {
982        my $tmpl = MT::Template->load({ type => 'search_results',
983            blog_id => $blog_id, id => $blogs{$blog_id} }, {
984            not => { id => 1 } });
985        $tmpl->remove if $tmpl;
986    }
987    if (my @blog_ids = keys %blogs) {
988        MT::Template->remove(
989            { type => 'search_results', blog_id => \@blog_ids },
990            { not => { blog_id => 1 } }
991        );
992    }
993    0;
994}
995
996my $perm_role_names = {
997    4096 => 'Blog Administrator',  # administer_blog
998    30687 => 'Blog Administrator', # 32767 - 2048(not comment) - 32(reserved) = all permissions in MT3.3
999    14303 => 'Blog Administrator', # 16383 - 2048(not comment) - 32(reserved) = all permissions in MT3.2
1000    2 => 'Writer', # post
1001    6 => 'Writer (can upload)', # post + upload
1002    17032 => 'Editor',  # edit_all_posts + edit_tags + edit_categories + rebuild
1003    17036 => 'Editor (can upload)', # Editor + upload
1004    144 => 'Designer', # edit_templates + rebuild
1005    17292 => 'Publisher', # Editor (can upload) + send_notifications
1006};
1007
1008{
1009    my $full_perm_mask = 0;
1010    my %LegacyPerms = (
1011        # System-wide permissions
1012        #[ 2**0, 'administer', 'System Administrator', 2, 'system' ],
1013        #[ 2**1, 'create_blog', 'Create Blogs', 2, 'system' ],
1014        #[ 2**2, 'view_log', 'View System Activity Log', 2, 'system' ],
1015        #[ 2**3, 'manage_plugins', 'Manage Plugins', 'system' ],
1016 
1017        # Blog-specific permissions:
1018        # The order here is the same order they are presented on the
1019        # role definition screen.
1020        2**0 => 'comment',# 'Add Comments', 1, 'blog'],
1021        2**12 => 'administer_blog',# 'Blog Administrator', 1, 'blog'],
1022        2**6 => 'edit_config',# 'Configure Blog', 1, 'blog'],
1023        2**3 => 'edit_all_posts',# 'Edit All Entries', 1, 'blog'],
1024        2**4 => 'edit_templates',# 'Manage Templates', 1, 'blog'],
1025        2**2 => 'upload',# 'Upload File', 1, 'blog'],
1026        2**1 => 'post',# 'Create Entry', 1, 'blog'],
1027        2**16 => 'edit_assets',# 'Manage Assets', 1, 'blog'],
1028        2**15 => 'save_image_defaults',# 'Save Image Defaults', 1, 'blog'],
1029        2**9 => 'edit_categories',# 'Add/Manage Categories', 1, 'blog'],
1030        2**14 => 'edit_tags',# 'Manage Tags', 1, 'blog'],
1031        2**10 => 'edit_notifications',# 'Manage Notification List', 1, 'blog'],
1032        2**8 => 'send_notifications',# 'Send Notifications', 1, 'blog'],
1033        2**13 => 'view_blog_log',# 'View Activity Log', 1, 'blog'],
1034        #[ 2**17, 'publish_post', 'Publish Post', 1, 'blog'],
1035        #[ 2**18, 'manage_feedback', 'Manage Feedback', 1, 'blog'],
1036        #[ 2**19, 'set_publish_paths', 'Set Publishing Paths', 1, 'blog'],
1037        #[ 2**20, 'manage_pages', 'Manage Pages', 1, 'blog'],
1038        # 2**5 == 32 is deprecated; reserved for future use
1039        2**7 => 'rebuild',# 'Rebuild Files', 1, 'blog'],
1040        # Not a real permission but a denial thereeof; unlisted because it
1041        # has no label.
1042        2**11 => 'not_comment',# '', 1, 'blog'],
1043    );
1044
1045
1046sub _migrate_permission_to_role {
1047    my $perm = shift;
1048
1049    return unless $perm->author_id;
1050    my $user = MT::Author->load($perm->author_id);
1051    if (!$user) {
1052        $perm->remove;
1053        return;
1054    }
1055    # Don't bother with non-AUTHOR types
1056    return unless $user->type == 1;
1057
1058    my $role_mask = $perm->role_mask;
1059    $role_mask -= 32 if (32 & $role_mask) == 32; # for permissions before 3.2
1060
1061    if (!$full_perm_mask) {
1062        # only consider blog permissions that are supported (exclude
1063        # now reserved permission bits like 32).
1064        foreach my $key (keys %LegacyPerms) {
1065            next if $LegacyPerms{$key} =~ m/^not_/; # skip exclusion permissions
1066            $full_perm_mask |= $key;
1067        }
1068    }
1069
1070    $role_mask = $full_perm_mask & $role_mask;
1071
1072    # '0' permission, not used for permissions, just prefs
1073    return unless $role_mask;
1074
1075    my $name;
1076    $name = MT->translate($perm_role_names->{$role_mask})
1077        if $perm_role_names->{$role_mask};
1078    $name ||= MT->translate("Custom ([_1])", $role_mask);
1079    require MT::Role;
1080    my $role = MT::Role->load({ name => $name });
1081    if ($role) {
1082        if (($role->role_mask != $role_mask) &&
1083            ((4096 != $role->role_mask) && (30687 != $role_mask))) {
1084            $role = undef;
1085        }
1086    }
1087    unless ($role) {
1088        $role = new MT::Role;
1089        $role->name($name);
1090        $role->description(MT->translate("This role was generated by Movable Type upon upgrade."));
1091        $role->role_mask($role_mask);
1092        $role->save;
1093    }
1094    my $blog = MT::Blog->load($perm->blog_id);
1095    $user->add_role($role, $blog) if $blog;
1096}
1097
1098sub _process_masks {
1099    my $self = shift;
1100    my ($perm) = @_;
1101
1102    my $mask = $perm->role_mask;
1103    return unless $mask;
1104    my @perms;
1105    for my $key (keys %LegacyPerms) {
1106        if (int($mask) & int($key)) {
1107            if (2 eq $key) { # post
1108                push @perms, 'create_post', 'publish_post';
1109            } elsif (64 eq $key) { #edit_config
1110                push @perms, 'edit_config', 'set_publish_paths', 'manage_feedback';
1111            } elsif (4096 eq $key) { #adminsiter_blog
1112                push @perms, 'administer_blog', 'manage_pages';
1113            } elsif (2048 eq $key) { #not_comment
1114                $perm->restrictions("'comment'");
1115            } else {
1116                push @perms, $LegacyPerms{$key};
1117            }
1118        }
1119    }
1120    my $perm_str = scalar(@perms) ? "'" . join("','", @perms) . "'" : q();
1121    $perm->permissions($perm_str);
1122    $perm->role_mask(0); ## remove legacy permissions
1123    $perm;
1124}
1125
1126sub deprecate_bitmask_permissions {
1127    my $self = shift;
1128   
1129    require MT::Permission;
1130    my $perm_iter = MT::Permission->load_iter;
1131    $self->progress($self->translate_escape('Migrating permission records to new structure...'));
1132    while (my $perm = $perm_iter->()) {
1133        if ($self->_process_masks($perm)) {
1134            $perm->save;
1135        }
1136    }
1137
1138    require MT::Role;
1139    my $role_iter = MT::Role->load_iter;
1140    $self->progress($self->translate_escape('Migrating role records to new structure...'));
1141    while (my $role = $role_iter->()) {
1142        if ($self->_process_masks($role)) {
1143            # do not have to rebuild permissions here.
1144            # "save" here causes segfault in sqlite.
1145            $role->update;
1146        }
1147    }
1148}
1149}
1150
1151sub migrate_system_privileges {
1152    my $self = shift;
1153
1154    require MT::Permission;
1155    my $author_iter = MT::Author->load_iter({ type => MT::Author::AUTHOR() });
1156    $self->progress($self->translate_escape('Migrating system level permissions to new structure...'));
1157    while (my $author = $author_iter->()) {
1158        my @perms;
1159        push @perms, 'administer' if $author->column('is_superuser');
1160        push @perms, 'create_blog' if $author->column('can_create_blog') || $author->column('is_superuser');
1161        push @perms, 'view_log' if $author->column('can_view_log') || $author->column('is_superuser');
1162        push @perms, 'manage_plugins' if $author->column('is_superuser');
1163        if (@perms) {
1164            my $perm = MT::Permission->load({ author_id => $author->id,
1165                blog_id => 0 });
1166            if (!$perm) {
1167                $perm = MT::Permission->new;
1168                $perm->author_id($author->id);
1169                $perm->blog_id(0);
1170            }
1171            $perm->set_these_permissions(@perms);
1172            $perm->save;
1173        }
1174    }
1175}
1176
1177sub init {
1178    my $pkg = shift;
1179    unless (%classes) {
1180        my $types = MT->registry('object_types');
1181        foreach my $type (keys %$types) {
1182            $classes{$type} = $types->{$type};
1183        }
1184    }
1185    my $fns = MT::Component->registry('upgrade_functions') || [];
1186    foreach my $fn_set (@$fns) {
1187        %functions = ( %functions, %{ $fn_set } );
1188    }
1189}
1190
1191# Step execution...
1192
1193# iterate routines:
1194#     no parameters, start with offset == 0
1195#     offset parameter, pass thru
1196#     if routine returns 0, routine is done
1197#     if routine returns undef, routine failed
1198#     if routine returns > 0, that's the new offset
1199
1200sub run_step {
1201    my $self = shift;
1202    my ($step) = @_;
1203    my ($name, %param) = @$step;
1204
1205    if (my $fn = $functions{$name}) {
1206        local $MT::CallbacksEnabled = 0;
1207        if (my $cond = $fn->{condition}) {
1208            $cond = MT->handler_to_coderef($cond);
1209            next unless $cond->($self, %param);
1210        }
1211        my %update_params;
1212        if ($fn->{updater}) {
1213            %update_params = %{$fn->{updater}};
1214            $fn->{code} ||= \&core_update_records;
1215        }
1216        my $code = $fn->{code} || $fn->{handler};
1217        $code = MT->handler_to_coderef($code);
1218        my $result = $code->($self, %param, %update_params, step => $name);
1219        if ((defined $result) && ($result > 1)) {
1220            $param{offset} = $result; $result = 1;
1221            $self->add_step($name, %param);
1222        }
1223        return $result;
1224    } else {
1225        return $self->error($self->translate_escape("Invalid upgrade function: [_1].", $name));
1226    }
1227    0;
1228}
1229
1230sub run_callbacks {
1231    my $self = shift;
1232    my ($cb, @param) = @_;
1233    local $MT::CallbacksEnabled = 1;
1234    MT->run_callbacks('MT::Upgrade::' . $cb, $self, @param);
1235}
1236
1237# Main "do" interface for controlling apparatus
1238
1239sub do_upgrade {
1240    my $self = shift;
1241    my (%opt) = @_;
1242
1243    $self->init;
1244
1245    my $harnessed = ref $opt{App} && (UNIVERSAL::can($opt{App}, 'add_step'));
1246
1247    local $App = $opt{App};
1248    local $DryRun = $opt{DryRun};
1249    local $SuperUser = $opt{SuperUser} || '';
1250    local $CLI = $opt{CLI} || '';
1251
1252    @steps = ();
1253    if ($opt{Install}) {
1254        my %init_params = (%{$opt{User} || {}}, %{$opt{Blog} || {}});
1255        $self->install_database(\%init_params);
1256    } else {
1257        $self->upgrade_database();
1258    }
1259
1260    # no app is running the show, so we must!
1261    if (!$harnessed) {
1262        # set these limits very high since we're running unharnessed
1263        $MAX_TIME = 10000000;
1264        $MAX_ROWS = 300;
1265        my $fn = \%MT::Upgrade::functions;
1266        my @these_steps = @steps;
1267        while (@these_steps) {
1268            my $step = shift @these_steps;
1269            @steps = ();
1270            $self->run_step($step);
1271            if (@steps) {
1272                push @these_steps, @steps;
1273                @these_steps = sort { $fn->{$a->[0]}->{priority} <=>
1274                                      $fn->{$b->[0]}->{priority} } @these_steps;
1275            }
1276        }
1277        return 1;
1278    } else {
1279        return \@steps;
1280    }
1281}
1282
1283sub upgrade_database {
1284    my $self = shift;
1285
1286    my $config_schema_ver;
1287    my $schema_ver;
1288    if ($config_schema_ver = MT->instance->config('SchemaVersion')) {
1289        my $needs_upgrade;
1290        $needs_upgrade = 1 if $config_schema_ver < MT->schema_version;
1291        if (!$needs_upgrade) {
1292            foreach (@MT::Components) {
1293                $needs_upgrade = 1 if $_->needs_upgrade;
1294            }
1295        }
1296        return 1 unless $needs_upgrade;
1297        $schema_ver = $config_schema_ver;
1298    } else {
1299        $schema_ver = $self->detect_schema_version;
1300    }
1301
1302    # this will add steps to upgrade all tables that need it...
1303    $self->add_step("core_upgrade_begin", from => $schema_ver);
1304    $self->check_schema;
1305    $self->add_step('core_upgrade_templates');
1306    $self->add_step('core_upgrade_end', from => $schema_ver);
1307    $self->add_step('core_finish');
1308    1;
1309}
1310
1311sub install_database {
1312    my $self = shift;
1313    my ($user) = @_;
1314
1315    # this will add steps to install all tables...
1316    $self->check_schema;
1317    # this will populate them...
1318    $self->add_step('core_seed_database', %$user);
1319    $self->add_step('core_upgrade_templates');
1320    $self->add_step('core_finish');
1321    1;
1322}
1323
1324sub check_schema {
1325    my $self = shift;
1326    my $class;
1327    foreach my $type (keys %classes) {
1328        $class = MT->model($type)
1329            or return $self->error($self->translate_escape("Error loading class [_1].", $type));
1330        $self->check_type($type);
1331    }
1332    1;
1333}
1334
1335sub check_type {
1336    my $self = shift;
1337    my ($type) = @_;
1338
1339    my $class = MT->model($type);
1340    if (my $result = $self->type_diff($type)) {
1341        if ($result->{fix}) {
1342            $self->add_step('core_fix_type', type => $type);
1343        } else {
1344            $self->add_step('core_add_column', type => $type)
1345                if $result->{add};
1346            $self->add_step('core_alter_column', type => $type)
1347                if $result->{alter};
1348            $self->add_step('core_drop_column', type => $type)
1349                if $result->{drop};
1350            $self->add_step('core_index_column', type => $type)
1351                if $result->{index};
1352        }
1353    }
1354    1;
1355}
1356
1357sub type_diff {
1358    my $self = shift;
1359    my ($type) = @_;
1360
1361    my $class = MT->model($type) or return;
1362
1363    my $table = $class->datasource;
1364    my $defs = $class->column_defs;
1365
1366    my $ddl = $class->driver->dbd->ddl_class;
1367    my $db_defs = $ddl->column_defs($class);
1368
1369    my $class_idx_defs = $class->index_defs;
1370    my $db_idx_defs = $ddl->index_defs($class);
1371
1372    # now, compare $defs and $db_defs;
1373    # here are the scenarios
1374    #   1. we find something in $defs that isn't in $db_defs
1375    #      -- column should be inserted. this may trigger a process
1376    #   2. we find something in $db_defs that isn't in $defs
1377    #      -- this is a-ok. user may have added a column.
1378    #   3. we find a difference between $defs and $db_defs for a field
1379    #      a. type differs; this may trigger a process
1380    #      b. type is same, but null property differs; this may
1381    #         trigger a process
1382    #      c. type is same, but size differs; this may trigger a process
1383    #      d. key differs
1384    #      e. auto differs (auto-increment)
1385    #   4. table doesn't exist and must be created
1386
1387    my $fix_class;
1388    $fix_class = 1 unless defined $db_defs;
1389
1390    # we're only scanning defined columns; we don't care about
1391    # columns that are unique to the table.
1392    my (@cols_to_add, @cols_to_alter, @cols_to_drop, @cols_to_index);
1393
1394    if (!$fix_class) {
1395        my @def_cols = keys %$defs;
1396
1397        foreach my $col (@def_cols) {
1398            my $col_def = $defs->{$col};
1399            next if !defined $col_def;
1400
1401            $col_def->{name} = $col;
1402
1403            my $db_def = $db_defs->{$col};
1404
1405            if (!$db_def) {
1406                # column is missing altogether; we're going to have to add it
1407                push @cols_to_add, $col;
1408            } else {
1409                if (($col_def->{type} eq 'string')
1410                 && ($db_def->{type} eq 'string')
1411                 && ($col_def->{size} <= $db_def->{size})) {
1412                    if (($col_def->{not_null} || 0) != ($db_def->{not_null} || 0)) {
1413                        push @cols_to_alter, $col;
1414                    }
1415                } elsif ($ddl->type2db($col_def)
1416                      ne $ddl->type2db($db_def)) {
1417                    # types are different
1418                    # don't bother if the database has sufficient
1419                    # capacity for this field
1420                    next if ($db_def->{type} eq 'integer')
1421                         && ($col_def->{type} eq 'smallint'
1422                          || $col_def->{type} eq 'boolean');
1423                    push @cols_to_alter, $col;
1424                } elsif (($col_def->{not_null} || 0) != ($db_def->{not_null} || 0)) {
1425                    push @cols_to_alter, $col;
1426                }
1427            }
1428        }
1429
1430        foreach my $key (keys %$class_idx_defs) {
1431            my $db_idx_def = $db_idx_defs->{$key};
1432            if (!$db_idx_def) {
1433                push @cols_to_index, $key;
1434                next;
1435            }
1436            # if there is a mismatch in definition, add it to index
1437            my $class_idx_def = $class_idx_defs->{$key};
1438            if (ref($class_idx_def)) {
1439                if (!ref $db_idx_def) {
1440                    push @cols_to_index, $key;
1441                }
1442                else {
1443                    my $db_cols;
1444                    if (exists $db_idx_def->{columns}) {
1445                        $db_cols = join ',', @{ $db_idx_def->{columns} };
1446                    }
1447                    else {
1448                        $db_cols = $key;
1449                    }
1450                    my $class_cols;
1451                    if (exists $class_idx_def->{columns}) {
1452                        $class_cols = join ',', @{ $class_idx_def->{columns} };
1453                    }
1454                    else {
1455                        $class_cols = $key;
1456                    }
1457                    if ($db_cols ne $class_cols) {
1458                        push @cols_to_index, $key;
1459                    }
1460                    else {
1461                        if (($db_idx_def->{unique} || 0) != ($class_idx_def->{unique} || 0)) {
1462                            push @cols_to_index, $key;
1463                        }
1464                    }
1465                }
1466            }
1467            else {
1468                if (ref $db_idx_def) {
1469                    push @cols_to_index, $key;
1470                }
1471            }
1472        }
1473    }
1474
1475    if ($fix_class || @cols_to_add || @cols_to_alter || @cols_to_drop || @cols_to_index) {
1476        my %param;
1477        $param{drop} = \@cols_to_drop if @cols_to_drop;
1478        $param{add} = \@cols_to_add if @cols_to_add;
1479        $param{alter} = \@cols_to_alter if @cols_to_alter;
1480        $param{fix} = $fix_class;
1481        $param{index} = \@cols_to_index if @cols_to_index;
1482        if ((@cols_to_add && !$ddl->can_add_column) ||
1483            (@cols_to_alter && !$ddl->can_alter_column) ||
1484            (@cols_to_drop && !$ddl->can_drop_column)) {
1485            $param{fix} = 1;
1486        }
1487        return \%param;
1488    }
1489    undef;
1490}
1491
1492sub seed_database {
1493    my $self = shift;
1494    my (%param) = @_;
1495
1496    require MT::Author;
1497    return undef if MT::Author->exist;
1498
1499    $self->progress($self->translate_escape("Creating initial blog and user records..."));
1500
1501    local $MT::CallbacksEnabled = 1;
1502
1503    require MT::L10N;
1504    my $lang = exists $param{user_lang} ? $param{user_lang} : MT->config->DefaultLanguage;
1505    my $LH = MT::L10N->get_handle($lang);
1506
1507    # TBD: parameter for username/password provided by user from $app
1508    use URI::Escape;
1509    my $author = MT::Author->new;
1510    $author->name(exists $param{user_name} ? uri_unescape($param{user_name}) : 'Melody');
1511    $author->type(MT::Author::AUTHOR());
1512    $author->set_password(exists $param{user_password} ? uri_unescape($param{user_password}) : 'Nelson');
1513    $author->email(exists $param{user_email} ? uri_unescape($param{user_email}) : '');
1514    $author->hint(exists $param{user_hint} ? uri_unescape($param{user_hint}) : '');
1515    $author->nickname(exists $param{user_nickname} ? uri_unescape($param{user_nickname}) : '');
1516    $author->is_superuser(1);
1517    $author->can_create_blog(1);
1518    $author->can_view_log(1);
1519    $author->can_manage_plugins(1);
1520    $author->preferred_language($lang);
1521    $author->external_id(MT::Author->pack_external_id($param{user_external_id})) if exists $param{user_external_id};
1522    $author->auth_type(MT->config->AuthenticationModule);
1523    $author->save or return $self->error($self->translate_escape("Error saving record: [_1].", $author->errstr));
1524    $App->{author} = $author if ref $App;
1525
1526    $self->create_default_roles(%param);
1527
1528    require MT::Blog;
1529    my $blog = MT::Blog->create_default_blog(MT->translate('First Blog'), $param{blog_template_set})
1530        or return $self->error($self->translate_escape("Error saving record: [_1].", MT::Blog->errstr));
1531    $blog->site_path(exists $param{blog_path} ? uri_unescape($param{blog_path}) : '');
1532    $blog->site_url(exists $param{blog_url} ? uri_unescape($param{blog_url}) : '');
1533    $blog->name(exists $param{blog_name} ? uri_unescape($param{blog_name}) : '');
1534    $blog->server_offset(exists $param{blog_timezone} ? ($param{blog_timezone} || 0) : 0);
1535    $blog->template_set($param{blog_template_set});
1536    $blog->save;
1537    MT->run_callbacks( 'blog_template_set_change', { blog => $blog } );
1538
1539    # Create an initial entry and comment for this blog
1540    require MT::Entry;
1541    my $entry = MT::Entry->new;
1542    $entry->blog_id($blog->id);
1543    $entry->title(MT->translate("I just finished installing Movable Type [_1]!", int(MT->product_version)));
1544    $entry->text(MT->translate("Welcome to my new blog powered by Movable Type. This is the first post on my blog and was created for me automatically when I finished the installation process. But that is ok, because I will soon be creating posts of my own!"));
1545    $entry->author_id($author->id);
1546    $entry->status(MT::Entry::RELEASE());
1547    $entry->save
1548        or return $self->error($self->translate_escape("Error saving record: [_1].", MT::Entry->errstr));
1549
1550    require MT::Comment;
1551    my $comment = MT::Comment->new;
1552    $comment->entry_id($entry->id);
1553    $comment->blog_id($blog->id);
1554    $comment->text(MT->translate("Movable Type also created a comment for me as well so that I could see what a comment will look like on my blog once people start submitting comments on all the posts I will write."));
1555    $comment->visible(1);
1556    $comment->junk_status(1);
1557    $comment->author(exists $param{user_nickname} ? uri_unescape($param{user_nickname}) : undef);
1558    $comment->save
1559        or return $self->error($self->translate_escape("Error saving record: [_1].", MT::Comment->errstr));
1560
1561    require MT::Association;
1562    require MT::Role;
1563    my ($blog_admin_role) = MT::Role->load_by_permission("administer_blog");
1564    MT::Association->link( $blog => $blog_admin_role => $author );
1565
1566    1;
1567}
1568
1569## Translation
1570# translate('Blog Administrator')
1571# translate('Can administer the blog.')
1572# translate('Editor')
1573# translate('Can upload files, edit all entries/categories/tags on a blog and publish the blog.')
1574# translate('Author')
1575# translate('Can create entries, edit their own, upload files and publish.')
1576# translate('Designer')
1577# translate('Can edit, manage and publish blog templates.')
1578# translate('Webmaster')
1579# translate('Can manage pages and publish blog templates.')
1580# translate('Contributor')
1581# translate('Can create entries, edit their own and comment.')
1582# translate('Moderator')
1583# translate('Can comment and manage feedback.')
1584# translate('Commenter')
1585# translate('Can comment.')
1586
1587sub create_default_roles {
1588    my $self = shift;
1589    my (%param) = @_;
1590
1591    my @default_roles = (
1592        { name => 'Blog Administrator',
1593          description => 'Can administer the blog.',
1594          role_mask => 2**12,
1595          perms => ['administer_blog'] },
1596        { name => 'Editor',
1597          description => 'Can upload files, edit all entries/categories/tags on a blog and publish the blog.',
1598          perms => ['comment', 'create_post', 'publish_post', 'edit_all_posts', 'edit_categories', 'edit_tags', 'manage_pages',
1599                    'rebuild', 'upload', 'send_notifications', 'manage_feedback'], },
1600        { name => 'Author',
1601          description => 'Can create entries, edit their own, upload files and publish.',
1602          perms => ['comment', 'create_post', 'publish_post', 'upload', 'send_notifications'], },
1603        { name => 'Designer',
1604          description => 'Can edit, manage and publish blog templates.',
1605          role_mask => (2**4 + 2**7),
1606          perms => ['edit_templates', 'rebuild'] },
1607        { name => 'Webmaster',
1608          description => 'Can manage pages and publish blog templates.',
1609          perms => ['manage_pages', 'rebuild'] },
1610        { name => 'Contributor',
1611          description => 'Can create entries, edit their own and comment.',
1612          perms => ['comment', 'create_post'], },
1613        { name => 'Moderator',
1614          description => 'Can comment and manage feedback.',
1615          perms => ['comment', 'manage_feedback'], },
1616        { name => 'Commenter',
1617          description => 'Can comment.',
1618          role_mask => 2**0,
1619          perms => ['comment'], },
1620    );
1621
1622    require MT::Role;
1623    return if MT::Role->exist();
1624
1625    foreach my $r (@default_roles) {
1626        my $role = MT::Role->new();
1627        $role->name(MT->translate($r->{name}));
1628        $role->description(MT->translate($r->{description}));
1629        $role->clear_full_permissions;
1630        $role->set_these_permissions($r->{perms});
1631        if ($r->{name} =~ m/^System/) {
1632            $role->is_system(1);
1633        }
1634        $role->role_mask($r->{role_mask}) if exists $r->{role_mask};
1635        $role->save;
1636    }
1637
1638    1;
1639}
1640
1641sub remove_mtviewphp {
1642    my $self = shift;
1643    my (%param) = @_;
1644
1645    require MT::Template;
1646    $self->progress($self->translate_escape('Removing Dynamic Site Bootstrapper index template...'));
1647    MT::Template->remove( { type => 'index', outfile => 'mtview.php' } );
1648    1;
1649}
1650
1651sub migrate_commenter_auth {
1652    my ($self) = shift;
1653    my (%param) = @_;
1654
1655    my $iter = MT::Blog->load_iter({ 'allow_reg_comments' => 1 });
1656    while (my $blog = $iter->()) {
1657        $blog->commenter_authenticators('TypeKey') if $blog->remote_auth_token;
1658        $blog->save;
1659    }
1660    1;
1661}
1662
1663sub upgrade_templates {
1664    my $self = shift;
1665    my (%opt) = @_;
1666
1667    my $install = $opt{Install} || 0;
1668
1669    my $updated = 0;
1670
1671    my $tmpl_list;
1672    require MT::DefaultTemplates;
1673    $tmpl_list = MT::DefaultTemplates->templates || [];
1674
1675    my $mt = MT->instance;
1676    my @arch_tmpl;
1677
1678    require MT::Template;
1679    require MT::Blog;
1680
1681    my $installer = sub {
1682        my ($val, $blog_id) = @_;
1683
1684        my $terms = {};
1685        $terms->{type} = $val->{type};
1686        $terms->{name} = $val->{name}
1687            if $val->{set} ne 'system';
1688        $terms->{blog_id} = $blog_id;
1689
1690        return 1 if MT::Template->exist( $terms );
1691
1692        $self->progress($self->translate_escape("Creating new template: '[_1]'.", $val->{name}));
1693
1694        my $obj = MT::Template->new;
1695        $obj->build_dynamic(0);
1696        foreach my $v (keys %$val) {
1697            $obj->column($v, $val->{$v}) if $obj->has_column($v);
1698        }
1699        $obj->blog_id($blog_id);
1700        $obj->save or return $self->error($self->translate_escape("Error saving record: [_1].", $obj->errstr));
1701        $updated = 1;
1702        if ($val->{mappings}) {
1703            push @arch_tmpl, {
1704                template => $obj,
1705                mappings => $val->{mappings},
1706            };
1707        }
1708        return 1;
1709    };
1710
1711    for my $val (@$tmpl_list) {
1712        if (!$Installing) {
1713            next if $val->{type} eq 'search_results';
1714        }
1715        if (!$install) {
1716            if (!$val->{global}) {
1717                next if $val->{set} ne 'system';
1718            }
1719        }
1720
1721        my $p = $val->{plugin} || $mt;
1722        $val->{name} = $p->translate($val->{name});
1723        $val->{text} = $p->translate_templatized($val->{text});
1724
1725        if ($val->{global}) {
1726            $installer->($val, 0) or return;
1727        }
1728        else {
1729            my $iter = MT::Blog->load_iter();
1730            while (my $blog = $iter->()) {
1731                $installer->($val, $blog->id);
1732            }
1733        }
1734    }
1735
1736    if (@arch_tmpl) {
1737        $self->progress($self->translate_escape("Mapping templates to blog archive types..."));
1738        require MT::TemplateMap;
1739
1740        for my $map_set (@arch_tmpl) {
1741            my $tmpl = $map_set->{template};
1742            my $mappings = $map_set->{mappings};
1743            foreach my $map_key (keys %$mappings) {
1744                my $m = $mappings->{$map_key};
1745                my $at = $m->{archive_type};
1746                # my $preferred = $mappings->{$map_key}{preferred};
1747                my $map = MT::TemplateMap->new;
1748                $map->archive_type($at);
1749                $map->is_preferred(1);
1750                $map->template_id($tmpl->id);
1751                $map->file_template($m->{file_template}) if $m->{file_template};
1752                $map->blog_id($tmpl->blog_id);
1753                $map->save;
1754            }
1755        }
1756    }
1757
1758    $updated;
1759}
1760
1761sub rename_php_plugin_filenames {
1762    my $self = shift;
1763
1764    my $server_path = MT->instance->server_path() || '';
1765    $server_path =~ s/\/*$//;
1766    my $plugin_path = File::Spec->canonpath("$server_path/php/plugins");
1767
1768    # If PHP plugins directory doesn't exist, return without failing
1769    return 0 if !-d $plugin_path;
1770
1771    opendir(DIR, $plugin_path)
1772        or return 0;
1773    my @files = grep { /^(?:function|block)\.(.*)\.php$/ } readdir(DIR);
1774    closedir(DIR);
1775
1776    return 0 unless @files;
1777
1778    $self->progress($self->translate_escape('Renaming PHP plugin file names...'));
1779    my @error_files = ();
1780    for my $file (@files) {
1781        my $newfile = lc $file;
1782        next if $file eq $newfile;
1783        if (!rename("$plugin_path/$file", "$plugin_path/$newfile")) {
1784            push @error_files, $file;
1785        }
1786    }
1787    if ($#error_files >= 0) {
1788        $self->progress($self->translate_escape('Error renaming PHP files. Please check the Activity Log.'));
1789        MT->log(
1790            {
1791                message => $self->translate_escape("Cannot rename in [_1]: [_2].", $plugin_path, join(', ', @error_files)),
1792                level   => MT::Log::ERROR(),
1793                category => 'upgrade',
1794            }
1795        );
1796    }
1797    1;
1798}
1799
1800sub update_widget_templates {
1801    my $self = shift;
1802
1803    $self->progress($self->translate_escape('Updating widget template records...'));
1804    require MT::Template;
1805    my $iter = MT::Template->load_iter(
1806        { type => 'custom' },
1807        { 'sort' => 'name',
1808          'direction' => 'ascend' }
1809    );
1810
1811    while (my $tmpl = $iter->()) {
1812        my $name = $tmpl->name();
1813        if ($name =~ s/^(?:Widget|Sidebar): ?//) {
1814            $tmpl->name($name);
1815            $tmpl->type('widget');
1816            $tmpl->save;
1817        }
1818    }
1819    1;
1820}
1821
1822sub remove_indexes {
1823    my $self = shift;
1824
1825    $self->progress($self->translate_escape('Removing unnecessary indexes...'));
1826
1827    my $driver = MT::Object->driver;
1828
1829    if ($driver->dbd =~ m/::Pg$|::Oracle$/) {
1830        $driver->sql([
1831            'drop index mt_asset_url',
1832            'drop index mt_asset_file_path',
1833            'drop index mt_blocklist_name',
1834            'drop index mt_entry_blog_id',
1835            'drop index mt_template_build_dynamic'
1836        ]);
1837    } elsif ($driver->dbd =~ m/::mysql$/) {
1838        $driver->sql([
1839            'drop index mt_asset_url on mt_asset',
1840            'drop index mt_asset_file_path on mt_asset',
1841            'drop index mt_blocklist_name on mt_blocklist',
1842            'drop index mt_entry_blog_id on mt_entry',
1843            'drop index mt_template_build_dynamic on mt_tempalte'
1844        ]);
1845    } elsif ($driver->dbd =~ m/::mssqlserver$/) {
1846        $driver->sql([
1847            'drop index mt_asset.mt_asset_url',
1848            'drop index mt_asset.mt_asset_file_path',
1849            'drop index mt_blocklist.mt_blocklist_name',
1850            'drop index mt_entry.mt_entry_blog_id',
1851            'drop index mt_tempalte.mt_template_build_dynamic'
1852        ]);
1853    }
1854    1;
1855}
1856
1857###  Upgrade triggers
1858
1859# we don't need these yet, but it makes me feel good to have them around
1860
1861# 'pre' triggers should execute quickly. 'post' triggers can add steps
1862# if they require processing that will take time to complete.
1863
1864sub pre_upgrade_class { 1 }
1865sub post_upgrade_class { 1 }
1866sub pre_alter_column { 1 }
1867sub post_alter_column { 1 }
1868sub pre_drop_column { 1 }
1869sub post_drop_column { 1 }
1870sub pre_add_column { 1 }
1871sub pre_index_column { 1 }
1872sub post_index_column { 1 }
1873sub pre_schema_upgrade { 1 }
1874
1875# issued last, after all table creation...
1876
1877sub post_schema_upgrade {
1878    my $self = shift;
1879    my ($from) = @_;
1880
1881    my $plugin_ver = MT->config('PluginSchemaVersion') || {};
1882    $plugin_ver->{'core'} = $from;
1883
1884    # run any functions that define a version_limit and where the schema we're
1885    # upgrading from is below that limit.
1886    foreach my $fn (keys %functions) {
1887        my $save_from = $from;
1888        {
1889            my $func = $functions{$fn};
1890
1891            if ($func->{plugin} && (UNIVERSAL::isa($func->{plugin}, 'MT::Component'))) {
1892                my $id = $func->{plugin}->id;
1893                $from = $plugin_ver->{$id};
1894            }
1895            if ($func->{version_limit}
1896                && (defined $from)
1897                && ($from < $func->{version_limit})) {
1898                $self->add_step($fn, from => $from);
1899            }
1900            elsif ($func
1901                && !exists($func->{version_limit})
1902                && !defined($from)) {
1903                $self->add_step($fn);
1904            }
1905        }
1906        $from = $save_from;
1907    }
1908
1909    1;
1910}
1911
1912sub pre_create_table {
1913    my $self = shift;
1914    my ($class) = @_;
1915    $class->driver->dbd->ddl_class->drop_sequence($class);
1916}
1917
1918sub post_create_table {
1919    my $self = shift;
1920    my ($class) = @_;
1921
1922    $class->driver->dbd->ddl_class->create_sequence($class);
1923
1924    if (!$Installing) {
1925        foreach (keys %functions) {
1926            my $func = $functions{$_};
1927            next unless $func->{on_class};
1928            $self->add_step($_) if $func->{on_class} eq $class;
1929        }
1930    }
1931
1932    1;
1933}
1934
1935# Note that this trigger only fires on BerkeleyDB for columns
1936# that are non-null or indexed.
1937
1938sub post_add_column {
1939    my $self = shift;
1940    my ($class, $col_defs) = @_;
1941
1942    if (!$Installing) {
1943        my %cols = map { $_ => 1 } @$col_defs;
1944        foreach (keys %functions) {
1945            my $func = $functions{$_};
1946            next unless $func->{on_field};
1947            if ($func->{on_field} =~ m/^\Q$class\E->(.*)/) {
1948                $self->add_step($_) if $cols{$1};
1949            }
1950        }
1951    }
1952    1;
1953}
1954
1955# Passthru routines-- passing to calling application...
1956
1957sub progress {
1958    my $self = shift;
1959    $App->progress(@_) if $App;
1960}
1961
1962sub translate_escape {
1963    my $self = shift;
1964    my $trans = MT->translate(@_);
1965    return $trans if $CLI;
1966    $trans = MT::I18N::encode_text($trans, undef, 'utf-8');
1967    return MT::Util::escape_unicode($trans);
1968}
1969
1970sub error {
1971    my $self = shift;
1972    my ($msg) = @_;
1973    $App->error(@_) if $App;
1974    return undef;
1975}
1976
1977sub add_step {
1978    my $self = shift;
1979    if ($App && (ref $App)) {
1980        $App->add_step(@_);
1981    } else {
1982        push @steps, [ @_ ];
1983    }
1984}
1985
1986# Misc utilities.
1987
1988sub detect_schema_version {
1989    my $self = shift;
1990
1991    require MT::Object;
1992    my $driver = MT::Object->driver;
1993
1994    require MT::Config;
1995    if ($driver->table_exists('MT::Config')) {
1996        return 3.2;
1997    }
1998
1999    require MT::Template;
2000    my $dyn_error_template =
2001        MT::Template->exist({type => 'dynamic_error'});
2002    if ($dyn_error_template) {
2003        return 3.1;
2004    }
2005
2006    my $comment_pending_template =
2007        MT::Template->exist({type => 'comment_pending'});
2008    if ($comment_pending_template) {
2009        return 3.0;
2010    }
2011
2012    require MT::TemplateMap;
2013    if ($driver->table_exists('MT::TemplateMap')) {
2014        return 2.0;
2015    }
2016
2017    1.0;
2018}
2019
2020# A note about upgrade routines:
2021#
2022# They should all be 'safe' to execute, regardless of the
2023# active schema. In other words, running them twice in a row
2024# should not cause any errors or break the schema.
2025
2026sub core_fix_type {
2027    my $self = shift;
2028    my (%param) = @_;
2029
2030    my $type = $param{type};
2031    my $class = MT->model($type);
2032
2033    my $result = $self->type_diff($type);
2034    return 1 unless $result;
2035    return 1 unless $result->{fix};
2036
2037    my $alter = $result->{alter};
2038    my $add = $result->{add};
2039    my $drop = $result->{drop};
2040    my $index = $result->{index};
2041
2042    my $driver = $class->driver;
2043    my $ddl = $driver->dbd->ddl_class;
2044    my @stmts;
2045    push @stmts, sub { $self->pre_upgrade_class($class) };
2046    push @stmts, $ddl->upgrade_begin($class);
2047    push @stmts, sub { $self->pre_create_table($class) };
2048    push @stmts, sub { $self->pre_add_column($class, $add) } if $add;
2049    push @stmts, sub { $self->pre_alter_column($class, $alter) } if $alter;
2050    push @stmts, sub { $self->pre_drop_column($class, $drop) } if $drop;
2051    push @stmts, sub { $self->pre_index_column($class, $index) } if $index;
2052    push @stmts, $ddl->fix_class($class);
2053    push @stmts, sub { $self->post_create_table($class) };
2054    push @stmts, sub { $self->post_add_column($class, $add) } if $add;
2055    push @stmts, sub { $self->post_alter_column($class, $alter) } if $alter;
2056    push @stmts, sub { $self->post_drop_column($class, $drop) } if $drop;
2057    push @stmts, sub { $self->post_index_column($class, $index) } if $index;
2058    push @stmts, $ddl->upgrade_end($class);
2059    push @stmts, sub { $self->post_upgrade_class($class) };
2060    $self->run_statements($class, @stmts);
2061}
2062
2063sub core_column_action {
2064    my $self = shift;
2065    my ($action, %param) = @_;
2066
2067    my $type = $param{type};
2068    my $class = MT->model($type);
2069    my $defs = $class->column_defs;
2070
2071    my $result = $self->type_diff($type);
2072    return 1 unless $result;
2073    my $columns = $result->{$action};
2074    return 1 unless $columns;
2075
2076    my $pre_method = "pre_${action}_column";
2077    my $post_method = "post_${action}_column";
2078    my $method = "${action}_column";
2079
2080    my $driver = $class->driver;
2081    my $ddl = $driver->dbd->ddl_class;
2082    my @stmts;
2083    push @stmts, sub { $self->pre_upgrade_class($class) };
2084    push @stmts, $ddl->upgrade_begin($class);
2085    push @stmts, sub { $self->$pre_method($class, $columns) };
2086    push @stmts, $ddl->$method($class, $_) foreach @$columns;
2087    push @stmts, sub { $self->$post_method($class, $columns) };
2088    push @stmts, $ddl->upgrade_end($class);
2089    push @stmts, sub { $self->post_upgrade_class($class) };
2090    $self->run_statements($class, @stmts);
2091}
2092
2093sub run_statements {
2094    my $self = shift;
2095    my ($class, @stmts) = @_;
2096
2097    my $driver = $class->driver;
2098    my $defs = $class->column_defs;
2099    my $dbh = $driver->rw_handle;
2100    my $mt = MT->instance;
2101
2102    my $updated = 0;
2103    if (@stmts) {
2104        $self->progress($self->translate_escape("Upgrading table for [_1] records...", $class->can('class_label') ? $class->class_label : $class));
2105        eval {
2106            foreach my $stmt (@stmts) {
2107                if (ref $stmt eq 'CODE') {
2108                    $stmt->() if !$DryRun;
2109                } else {
2110                    if ($dbh && !$DryRun) {
2111                        my $err;
2112                        $dbh->do($stmt) or $err = $dbh->errstr;
2113                        if ($err) {
2114                            # ignore drop errors; the table/sequence/constraint
2115                            # didn't exist
2116                            if (($stmt !~ m/^drop /i) && ($stmt !~ m/DROP CONSTRAINT /i)) {
2117                                die "failed to execute statement $stmt: $err";
2118                            }
2119                        }
2120                    } elsif ($dbh && $DryRun) {
2121                        $self->run_callbacks('SQL', $stmt);
2122                    }
2123                }
2124                $updated = 1;
2125            }
2126        };
2127        if ($@) {
2128            return $self->error($@);
2129        }
2130    }
2131    $updated;
2132}
2133
2134sub core_upgrade_begin {
2135    my $self = shift;
2136    my (%param) = @_;
2137    my $from_schema = $param{from};
2138    if ($from_schema) {
2139        my $cur_schema = MT->schema_version;
2140        $self->progress($self->translate_escape("Upgrading database from version [_1].", $from_schema)) if $from_schema < $cur_schema;
2141        $self->pre_schema_upgrade($from_schema);
2142    }
2143}
2144
2145sub core_upgrade_end {
2146    my $self = shift;
2147    my (%param) = @_;
2148
2149    my $from_schema = $param{from};
2150    if ($from_schema) {
2151        $self->post_schema_upgrade($from_schema);
2152    }
2153    1;
2154}
2155
2156sub core_finish {
2157    my $self = shift;
2158
2159    my $user;
2160    if ((ref $App) && ($App->{author})) {
2161        $user = $App->{author};
2162    }
2163
2164    my $cfg = MT->config;
2165    my $cur_schema = MT->instance->schema_version;
2166    my $old_schema = $cfg->SchemaVersion || 0;
2167    if ($cur_schema > $old_schema) {
2168        $self->progress($self->translate_escape("Database has been upgraded to version [_1].", $cur_schema)) ;
2169        if ($user && !$DryRun) {
2170            MT->log(MT->translate("User '[_1]' upgraded database to version [_2]", $user->name, $cur_schema));
2171        }
2172        $cfg->SchemaVersion( $cur_schema, 1 );
2173    }
2174
2175    my $plugin_schema = $cfg->PluginSchemaVersion || {};
2176    foreach my $plugin (@MT::Components) {
2177        my $ver = $plugin->schema_version;
2178        next unless $ver;
2179        next if $plugin->id eq 'core';
2180        my $old_plugin_schema = $plugin_schema->{$plugin->id} || 0;
2181        if ($old_plugin_schema && ($ver > $old_plugin_schema)) {
2182            $self->progress($self->translate_escape("Plugin '[_1]' upgraded successfully to version [_2] (schema version [_3]).", $plugin->label, $plugin->version || '-', $ver));
2183            if ($user && !$DryRun) {
2184                MT->log(MT->translate("User '[_1]' upgraded plugin '[_2]' to version [_3] (schema version [_4]).", $user->name, $plugin->label, $plugin->version || '-', $ver));
2185            }
2186        } elsif ($ver && !$old_plugin_schema) {
2187            $self->progress($self->translate_escape("Plugin '[_1]' installed successfully.", $plugin->label));
2188            if ($user && !$DryRun) {
2189                MT->log(MT->translate("User '[_1]' installed plugin '[_2]', version [_3] (schema version [_4]).", $user->name, $plugin->label, $plugin->version || '-', $ver));
2190            }
2191        }
2192        $plugin_schema->{$plugin->id} = $ver;
2193    }
2194    if (keys %$plugin_schema) {
2195        $cfg->PluginSchemaVersion($plugin_schema, 1);
2196    }
2197
2198    my $cur_version = MT->version_number;
2199    if ( !defined($cfg->MTVersion) || ( $cur_version > $cfg->MTVersion ) ) {
2200        $cfg->MTVersion( $cur_version, 1 );
2201    }
2202    $cfg->save_config unless $DryRun;
2203
2204    # do one last thing....
2205    if ((ref $App) && ($App->can('finish'))) {
2206        $App->finish();
2207    }
2208
2209    1;
2210}
2211
2212sub core_set_superuser {
2213    my $self = shift;
2214
2215    my $app = $App;
2216    my $author;
2217    if ((ref $app) && ($app->{author})) {
2218        require MT::Author;
2219        $self->progress($self->translate_escape("Setting your permissions to administrator."));
2220        $author = MT::Author->load($app->{author}->id);
2221    } elsif ($SuperUser) {
2222        require MT::Author;
2223        $self->progress($self->translate_escape("Setting your permissions to administrator."));
2224        $author = MT::Author->load($SuperUser);
2225    }
2226
2227    if ($author) {
2228        $author->is_superuser(1);
2229        $author->save or return $self->error($self->translate_escape("Error saving record: [_1].", $author->errstr));
2230    }
2231
2232    1;
2233}
2234
2235sub core_remove_unique_constraints {
2236    my $self = shift;
2237
2238    my $driver = MT::Object->driver;
2239    if (ref $driver->dbd =~ m/::Pg$/) {
2240        # category, author, permission, template
2241        $driver->sql([
2242            'alter table mt_category drop constraint mt_category_category_blog_id_key',
2243            'create index mt_category_label on mt_category (category_label)',
2244
2245            'alter table mt_author drop constraint mt_author_author_name_key',
2246            'create index mt_author_name on mt_author (author_name)',
2247            'alter table mt_permission drop constraint mt_permission_permission_blog_id_key',
2248            'create index mt_permission_blog_id on mt_permission (permission_blog_id)',
2249            'alter table mt_template drop constraint mt_template_template_blog_id_key',
2250            'create index mt_template_blog_id on mt_template (template_blog_id)'
2251        ]);
2252    } elsif (ref $driver->dbd =~ m/::mysql$/) {
2253        $driver->sql([
2254            'alter table mt_category drop index category_blog_id',
2255            'create index category_blog_id on mt_category (category_blog_id)',
2256            'create index category_label on mt_category (category_label)',
2257            'alter table mt_author drop index author_name',
2258            'create index author_name on mt_author (author_name)',
2259            'alter table mt_permission drop index permission_blog_id',
2260            'create index permission_blog_id on mt_permission (permission_blog_id)',
2261            'alter table mt_template drop index template_blog_id',
2262            'create index template_blog_id on mt_template (template_blog_id)'
2263        ]);
2264    }
2265    1;
2266}
2267
2268sub _merge_comment_response_templates_updater {
2269    my ($blog) = @_;
2270    require MT::Template;
2271    my $tmpl = MT::Template->load({ blog_id => $blog->id, type => 'comment_response' });
2272    unless ($tmpl) {
2273        $tmpl = new MT::Template;
2274        $tmpl->blog_id($blog->id);
2275        $tmpl->type('comment_response');
2276    }
2277
2278    my $confirm_template = <<'EOT';
2279<MTSetVarBlock name="page_title"><__trans phrase="Comment Posted"></MTSetVarBlock>
2280
2281<MTSetVar name="heading" value="<__trans phrase="Confirmation...">">
2282
2283<MTSetVarBlock name="message">
2284<p><__trans phrase="Your comment has been posted!"></p>
2285</MTSetVarBlock>
2286EOT
2287
2288    my $pending_template = <<'EOT';
2289<MTSetVarBlock name="page_title"><__trans phrase="Comment Pending"></MTSetVarBlock>
2290
2291<MTSetVar name="heading" value="<__trans phrase="Thank you for commenting.">">
2292
2293<MTSetVarBlock name="message">
2294<p><__trans phrase="Your comment has been received and held for approval by the blog owner."></p>
2295</MTSetVarBlock>
2296EOT
2297
2298    my $error_template = <<'EOT';
2299<MTSetVarBlock name="page_title"><__trans phrase="Comment Submission Error"></MTSetVarBlock>
2300
2301<MTSetVar name="heading" value="$page_title">
2302
2303<MTSetVarBlock name="message">
2304<p><__trans phrase="Your comment submission failed for the following reasons:"></p>
2305<blockquote>
2306    <$MTErrorMessage$>
2307</blockquote>
2308</MTSetVarBlock>
2309EOT
2310
2311    my $header_template = <<'EOT';
2312<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
2313    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
2314<html xmlns="http://www.w3.org/1999/xhtml" id="sixapart-standard">
2315<head>
2316    <meta http-equiv="Content-Type" content="text/html; charset=<$MTPublishCharset$>" />
2317    <meta name="generator" content="<$MTProductName version="1"$>" />
2318    <link rel="stylesheet" href="<$MTBlogURL$>styles-site.css" type="text/css" />
2319    <title>
2320    <__trans phrase="[_1]: [_2]" params="<$MTBlogName encode_html="1"$>%%<$MTGetVar name="page_title"$>">
2321    </title>
2322    <script type="text/javascript" src="<$MTBlogURL$>mt-site.js"></script>
2323</head>
2324<body class="layout-one-column comment-preview" onload="individualArchivesOnLoad(commenter_name)">
2325    <div id="container">
2326        <div id="container-inner" class="pkg">
2327            <div id="banner">
2328                <div id="banner-inner" class="pkg">
2329                    <h1 id="banner-header"><a href="<$MTBlogURL$>" accesskey="1"><$MTBlogName encode_html="1"$></a></h1>
2330                    <h2 id="banner-description"><$MTBlogDescription$></h2>
2331                </div>
2332            </div>
2333            <div id="pagebody">
2334                <div id="pagebody-inner" class="pkg">
2335                    <div id="alpha">
2336                        <div id="alpha-inner" class="pkg">
2337EOT
2338
2339    my $footer_template = <<'EOT';
2340                        </div>
2341                    </div>
2342                </div>
2343            </div>
2344        </div>
2345    </div>
2346</body>
2347</html>
2348EOT
2349
2350    my $message_template = <<'EOT';
2351<h1><$MTGetVar name="heading"$></h1>
2352
2353<$MTGetVar name="message"$>
2354
2355<p><__trans phrase="Return to the <a href="[_1]">original entry</a>." params="<$MTEntryLink$>"></p>
2356EOT
2357
2358    my $mt = MT->instance;
2359    $tmpl->name($mt->translate("Comment Response"));
2360    $tmpl->text($mt->translate_templatized(<<"EOT"));
2361<MTSetVar name="system_template" value="1">
2362<MTSetVar name="feedback_template" value="1">
2363
2364<MTIf name="body_class" eq="mt-comment-pending">
2365$pending_template
2366</MTIf>
2367
2368<MTIf name="body_class" eq="mt-comment-error">
2369$error_template
2370</MTIf>
2371
2372<MTIf name="body_class" eq="mt-comment-confirmation">
2373$confirm_template
2374</MTIf>
2375
2376$header_template
2377
2378$message_template
2379
2380$footer_template
2381EOT
2382    $tmpl->save;
2383}
2384
2385sub core_create_config_table {
2386    my $self = shift;
2387
2388    require MT::Config;
2389    my $config = MT::Config->load();
2390    if (!$config) {
2391        #$self->progress($self->translate_escape("Creating configuration record."));
2392        $config = MT::Config->new;
2393        $config->data('');
2394        $config->save or return $self->error($self->translate_escape("Error saving record: [_1].", $config->errstr));
2395    }
2396    return 1;
2397}
2398
2399sub core_set_enable_archive_paths {
2400    my $self = shift;
2401    MT->config->EnableArchivePaths(1, 1);
2402    return 1;
2403}
2404
2405sub core_create_template_maps {
2406    my $self = shift;
2407    my (%param) = @_;
2408   
2409    my $offset = $param{offset};
2410    require MT::Template;
2411    require MT::TemplateMap;
2412    require MT::Blog;
2413
2414    my $msg = $self->translate_escape("Creating template maps...");
2415    if ($offset) {
2416        my $count = MT::Template->count;
2417        return 1 unless $count;
2418        $self->progress(sprintf("$msg (%d%%)", ($offset / $count * 100)), 1);
2419    } else {
2420        $self->progress($msg, 1);
2421    }
2422
2423    my $iter = MT::Template->load_iter(undef, { offset => $offset, limit => $MAX_ROWS+1 });
2424    my $start = time;
2425    my $continue = 0;
2426    my $count = 0;
2427    while (my $tmpl = $iter->()) {
2428        $offset++;
2429        my $blog = MT::Blog->load($tmpl->blog_id);
2430        my(@at);
2431        if ($tmpl->type eq 'archive') {
2432            @at = qw( Daily Weekly Monthly );
2433        } elsif ($tmpl->type eq 'category') {
2434            @at = ('Category');
2435        } elsif ($tmpl->type eq 'page') {
2436            @at = ('Page');
2437        } elsif ($tmpl->type eq 'individual') {
2438            @at = ('Individual');
2439        } else {
2440            next;
2441        }
2442        for my $at (@at) {
2443            my $meth = 'archive_tmpl_' . lc($at);
2444            my $file_tmpl = $blog->$meth();
2445            my $existing = MT::TemplateMap->load({ blog_id => $blog->id,
2446                archive_type => $at, template_id => $tmpl->id });
2447            if (!$existing) {
2448                my $map = MT::TemplateMap->new;
2449                if ($file_tmpl) {
2450                    $self->progress($self->translate_escape("Mapping template ID [_1] to [_2] ([_3]).", $tmpl->id, $at, $file_tmpl));
2451                    $map->file_template($file_tmpl);
2452                } else {
2453                    $self->progress($self->translate_escape("Mapping template ID [_1] to [_2].", $tmpl->id, $at));
2454                }
2455                $map->archive_type($at);
2456                $map->is_preferred(1);
2457                $map->template_id($tmpl->id);
2458                $map->blog_id($tmpl->blog_id);
2459                $map->save or return $self->error($self->translate_escape("Error saving record: [_1].", $map->errstr));
2460            }
2461        }
2462        $count++;
2463        $continue = 1, last if $count == $MAX_ROWS;
2464        $continue = 1, last if time > $start + $MAX_TIME;
2465    }
2466    if ($continue) {
2467        $iter->('finish');
2468        return $offset;
2469    } else {
2470        $self->progress("$msg (100%)", 1);
2471    }
2472    1;
2473}
2474
2475sub core_update_records {
2476    my $self = shift;
2477    my (%param) = @_;
2478
2479    my $class = MT->model($param{type});
2480    return $self->error($self->translate_escape("Error loading class: [_1].", $param{type}))
2481        unless $class;
2482
2483    my $msg;
2484    my $class_label = ($class->can('class_label') ? $class->class_label : $class);
2485    if ($param{label}) {
2486        $msg = $param{label};
2487        if (ref $msg eq 'CODE') {
2488            $msg = $msg->($class_label);
2489        }
2490        $msg = $self->translate_escape($msg);
2491    } else {
2492        $msg = $self->translate_escape($param{message} || "Updating [_1] records...", $class_label);
2493    }
2494    my $offset = $param{offset};
2495    if ($offset) {
2496        my $count = $class->count;
2497        return unless $count;
2498        $self->progress(sprintf("$msg (%d%%)", ($offset/$count*100)), $param{step});
2499    } else {
2500        $self->progress($msg, $param{step});
2501    }
2502
2503    my $cond = MT->handler_to_coderef($param{condition});
2504    my $code = MT->handler_to_coderef($param{code});
2505    my $sql = $param{sql};
2506
2507    my $continue = 0;
2508    my $driver = $class->driver;
2509
2510    if ($sql && $DryRun) {
2511        $self->run_callbacks('SQL', $sql);
2512    }
2513    return 1 if $DryRun;
2514
2515    if (!$sql || !$driver->sql($sql)) {
2516        my $iter= $class->load_iter(undef, { offset => $offset, limit => $MAX_ROWS+1 });
2517        my $start = time;
2518        my @list;
2519        while (my $obj = $iter->()) {
2520            push @list, $obj;
2521            $continue = 1, last if scalar @list == $MAX_ROWS;
2522        }
2523        $iter->('finish') if $continue;
2524        for my $obj (@list) {
2525            $offset++;
2526            if ($cond) {
2527                next unless $cond->($obj, %param);
2528            }
2529            $code->($obj);
2530            use Data::Dumper;
2531            $obj->save()
2532                or return $self->error($self->translate_escape("Error saving [_1] record # [_3]: [_2]... [_4].", $class_label, $obj->errstr, $obj->id, Dumper($obj)));
2533            $continue = 1, last if time > $start + $MAX_TIME;
2534        }
2535    }
2536    if ($continue) {
2537        return $offset;
2538    } else {
2539        $self->progress("$msg (100%)", $param{step});
2540    }
2541    1;
2542}
2543
2544#############################################################################
2545
2546{
2547    my %HighASCII = (
2548        "\xc0" => 'A',    # A`
2549        "\xe0" => 'a',    # a`
2550        "\xc1" => 'A',    # A'
2551        "\xe1" => 'a',    # a'
2552        "\xc2" => 'A',    # A^
2553        "\xe2" => 'a',    # a^
2554        "\xc4" => 'Ae',   # A:
2555        "\xe4" => 'ae',   # a:
2556        "\xc3" => 'A',    # A~
2557        "\xe3" => 'a',    # a~
2558        "\xc8" => 'E',    # E`
2559        "\xe8" => 'e',    # e`
2560        "\xc9" => 'E',    # E'
2561        "\xe9" => 'e',    # e'
2562        "\xca" => 'E',    # E^
2563        "\xea" => 'e',    # e^
2564        "\xcb" => 'Ee',   # E:
2565        "\xeb" => 'ee',   # e:
2566        "\xcc" => 'I',    # I`
2567        "\xec" => 'i',    # i`
2568        "\xcd" => 'I',    # I'
2569        "\xed" => 'i',    # i'
2570        "\xce" => 'I',    # I^
2571        "\xee" => 'i',    # i^
2572        "\xcf" => 'Ie',   # I:
2573        "\xef" => 'ie',   # i:
2574        "\xd2" => 'O',    # O`
2575        "\xf2" => 'o',    # o`
2576        "\xd3" => 'O',    # O'
2577        "\xf3" => 'o',    # o'
2578        "\xd4" => 'O',    # O^
2579        "\xf4" => 'o',    # o^
2580        "\xd6" => 'Oe',   # O:
2581        "\xf6" => 'oe',   # o:
2582        "\xd5" => 'O',    # O~
2583        "\xf5" => 'o',    # o~
2584        "\xd8" => 'Oe',   # O/
2585        "\xf8" => 'oe',   # o/
2586        "\xd9" => 'U',    # U`
2587        "\xf9" => 'u',    # u`
2588        "\xda" => 'U',    # U'
2589        "\xfa" => 'u',    # u'
2590        "\xdb" => 'U',    # U^
2591        "\xfb" => 'u',    # u^
2592        "\xdc" => 'Ue',   # U:
2593        "\xfc" => 'ue',   # u:
2594        "\xc7" => 'C',    # ,C
2595        "\xe7" => 'c',    # ,c
2596        "\xd1" => 'N',    # N~
2597        "\xf1" => 'n',    # n~
2598        "\xdf" => 'ss',
2599    );
2600    my $HighASCIIRE = join '|', keys %HighASCII;
2601    sub mt32_convert_high_ascii {
2602        my($s) = @_;
2603        $s =~ s/($HighASCIIRE)/$HighASCII{$1}/g;
2604        $s;
2605    }
2606}
2607
2608sub mt32_iso_dirify {
2609    my $s = $_[0];
2610    my $sep;
2611    if ($_[1] && ($_[1] ne '1')) {
2612        $sep = $_[1];
2613    } else {
2614        $sep = '_';
2615    }
2616    $s = mt32_convert_high_ascii($s);  ## convert high-ASCII chars to 7bit.
2617    $s = lc $s;                   ## lower-case.
2618    $s = MT::Util::remove_html($s);         ## remove HTML tags.
2619    $s =~ s!&[^;\s]+;!!g;         ## remove HTML entities.
2620    $s =~ s![^\w\s]!!g;           ## remove non-word/space chars.
2621    $s =~ s! +!$sep!g;             ## change space chars to underscores.
2622    $s;   
2623}
2624
2625sub mt32_utf8_dirify {
2626    my $s = $_[0];
2627    my $sep;
2628    if ($_[1] && ($_[1] ne '1')) {
2629        $sep = $_[1];
2630    } else {
2631        $sep = '_';
2632    }
2633    $s = mt32_xliterate_utf8($s);      ## convert two-byte UTF-8 chars to 7bit ASCII
2634    $s = lc $s;                   ## lower-case.
2635    $s = MT::Util::remove_html($s);         ## remove HTML tags.
2636    $s =~ s!&[^;\s]+;!!g;         ## remove HTML entities.
2637    $s =~ s![^\w\s]!!g;           ## remove non-word/space chars.
2638    $s =~ s! +!$sep!g;             ## change space chars to underscores.
2639    $s;   
2640}
2641
2642sub mt32_dirify {
2643    ($MT::VERSION && MT->instance->{cfg}->PublishCharset =~ m/utf-?8/i)
2644        ? mt32_utf8_dirify(@_) : mt32_iso_dirify(@_);
2645}
2646
2647sub mt32_xliterate_utf8 {
2648    my ($str) = @_;
2649    my %utf8_table = (
2650          "\xc3\x80" => 'A',    # A`
2651          "\xc3\xa0" => 'a',    # a`
2652          "\xc3\x81" => 'A',    # A'
2653          "\xc3\xa1" => 'a',    # a'
2654          "\xc3\x82" => 'A',    # A^
2655          "\xc3\xa2" => 'a',    # a^
2656          "\xc3\x84" => 'Ae',   # A:
2657          "\xc3\xa4" => 'ae',   # a:
2658          "\xc3\x83" => 'A',    # A~
2659          "\xc3\xa3" => 'a',    # a~
2660          "\xc3\x88" => 'E',    # E`
2661          "\xc3\xa8" => 'e',    # e`
2662          "\xc3\x89" => 'E',    # E'
2663          "\xc3\xa9" => 'e',    # e'
2664          "\xc3\x8a" => 'E',    # E^
2665          "\xc3\xaa" => 'e',    # e^
2666          "\xc3\x8b" => 'Ee',   # E:
2667          "\xc3\xab" => 'ee',   # e:
2668          "\xc3\x8c" => 'I',    # I`
2669          "\xc3\xac" => 'i',    # i`
2670          "\xc3\x8d" => 'I',    # I'
2671          "\xc3\xad" => 'i',    # i'
2672          "\xc3\x8e" => 'I',    # I^
2673          "\xc3\xae" => 'i',    # i^
2674          "\xc3\x8f" => 'Ie',   # I:
2675          "\xc3\xaf" => 'ie',   # i:
2676          "\xc3\x92" => 'O',    # O`
2677          "\xc3\xb2" => 'o',    # o`
2678          "\xc3\x93" => 'O',    # O'
2679          "\xc3\xb3" => 'o',    # o'
2680          "\xc3\x94" => 'O',    # O^
2681          "\xc3\xb4" => 'o',    # o^
2682          "\xc3\x96" => 'Oe',   # O:
2683          "\xc3\xb6" => 'oe',   # o:
2684          "\xc3\x95" => 'O',    # O~
2685          "\xc3\xb5" => 'o',    # o~
2686          "\xc3\x98" => 'Oe',   # O/
2687          "\xc3\xb8" => 'oe',   # o/
2688          "\xc3\x99" => 'U',    # U`
2689          "\xc3\xb9" => 'u',    # u`
2690          "\xc3\x9a" => 'U',    # U'
2691          "\xc3\xba" => 'u',    # u'
2692          "\xc3\x9b" => 'U',    # U^
2693          "\xc3\xbb" => 'u',    # u^
2694          "\xc3\x9c" => 'Ue',   # U:
2695          "\xc3\xbc" => 'ue',   # u:
2696          "\xc3\x87" => 'C',    # ,C
2697          "\xc3\xa7" => 'c',    # ,c
2698          "\xc3\x91" => 'N',    # N~
2699          "\xc3\xb1" => 'n',    # n~
2700          "\xc3\x9f" => 'ss',   # double-s
2701    );
2702   
2703    $str =~ s/([\200-\377]{2})/$utf8_table{$1}||''/ge;
2704    $str;
2705}
2706
27071;
2708__END__
2709
2710=head1 NAME
2711
2712MT::Upgrade - MT class for managing system upgrades.
2713
2714=head1 SYNOPSIS
2715
2716    MT::Upgrade->do_upgrade(Install => 1);
2717
2718=head1 DESCRIPTION
2719
2720This module is responsible for handling the upgrade or installation of
2721an MT database. The framework is flexible enough for third party plugins
2722to use as well to manage their own schema (please refer to the documentation
2723in L<MT::Plugin> for more information on this).
2724
2725=head1 METHODS
2726
2727=head2 MT::Upgrade-E<gt>do_upgrade
2728
2729The main worker method for this module is I<do_upgrade>. It accepts a
2730handful of arguments, which are:
2731
2732=over 4
2733
2734=item * Install
2735
2736Specify a value of '1' to assume a new installation along with an operation
2737to install a blog and initial user.
2738
2739=item * App
2740
2741A package name or app object that can service the following methods:
2742
2743=over 4
2744
2745=item * progress($package, $message)
2746
2747Called during the upgrade operation to provide feedback with respect to
2748the operations the upgrade process is running.
2749
2750=item * error($package, $message)
2751
2752Called during the upgrade operation to communicate an error that has
2753occurred.
2754
2755=item * translate_escape
2756
2757Call this method to translate messages and phrases which are to appear
2758on the progress screen.  DO NOT use this method to messages and phrases
2759which directly are stored in database.  Use MT->translate for the purpose.
2760
2761=back
2762
2763=item * CLI
2764
2765Specified (set to '1') when invoked from a command line tool. This prevents
2766encoding response messages in the configured PublishCharset for the
2767installation.
2768
2769=item * SuperUser
2770
2771If upgrading from the command line, and running on a pre-MT 3.2 database,
2772set this to an existing author ID that should be upgrade to system
2773administrator status.
2774
2775=item * DryRun
2776
2777Specified (set to '1') to examine the database for installation/upgrade
2778needs but not actually make any physical changes to the database. This will
2779issue all the upgrade progress messages without doing the upgrade itself.
2780
2781=back
2782
2783=head1 CALLBACKS
2784
2785The upgrade module defines the following MT callbacks:
2786
2787=over 4
2788
2789=item * MT::Upgrade::SQL
2790
2791Called with each SQL statement that is executed against the database
2792as part of the upgrade process. The parameters passed to this callback are:
2793
2794    $callback, $upgrade_app, $sql_statement
2795
2796The first parameter is an L<MT::Callback> object. C<$upgrade_app> is a
2797package name or L<MT::App> object used to drive the upgrade process.
2798C<$sql_statement> is the actual SQL query that is about to be executed
2799against the database.
2800
2801=back
2802
2803=head1 UPGRADE FUNCTIONS
2804
2805The bulk of this module consists of Movable Type upgrade operations.
2806These are declared as upgrade functions, and are registered in the
2807package variabled '%functions'. (Note: the word 'function' here is
2808not meant to describe a Perl subroutine.)
2809
2810Some functions are invoked to manage the upgrade process from start
2811to finish ('core_upgrade_begin' for instance, which merely displays
2812a progress message to the calling application). The rest handle
2813schema and data transformation from one version of the MT schema to
2814another.
2815
2816Schema translation itself is handled by Movable Type automatically.
2817MT is able to check the physical schema represenation in the database
2818and compare it with the schema as defined by the L<MT::Object>-descended
2819package. If a new property is added to the L<MT::Blog> package, the
2820upgrade process sees that has happened and can issue the actual
2821'alter table' SQL statement necessary to add it to the database. The
2822'core_fix_type' function is responsible for examining a particular
2823table used by a class like L<MT::Blog> and will append additional
2824upgrade steps ('core_add_column', 'core_alter_column') that it finds
2825necessary to the upgrade workflow.
2826
2827Following the schema translation operations, the data transformation
2828functions would be used to manipulate the data as necessary from
2829an older schema to the current one. For instance, the
2830'core_create_placements' upgrade function was written to upgrade
2831really old MT schemas from the pre-2.0 release to the current schema.
2832The upgrade function is registered like this:
2833
2834    $MT::Upgrade::functions{core_create_placements} = {
2835        version_limit => 2.0,
2836        code          => \&core_update_records,
2837        priority      => 9.1,
2838        updater       => {
2839            class     => 'MT::Entry',
2840            message   => 'Creating entry category placements...',
2841            condition => sub { $_[0]->category_id },
2842            code      => sub {
2843                require MT::Placement;
2844                my $entry = shift;
2845                my $existing = MT::Placement->load({ entry_id => $entry->id,
2846                    category_id => $entry->category_id });
2847                if (!$existing) {
2848                    my $place = MT::Placement->new;
2849                    $place->entry_id($entry->id);
2850                    $place->blog_id($entry->blog_id);
2851                    $place->category_id($entry->category_id);
2852                    $place->is_primary(1);
2853                    $place->save;
2854                }
2855                $entry->category_id(0);
2856            }
2857        }
2858    };
2859
2860With MT version 2.0, the L<MT::Placement> class was introduced and
2861immediately deprecated the use of MT::Entry-E<gt>category as a result.
2862To facilitate upgrading the existing L<MT::Entry> objects this upgrade
2863function is declared such that:
2864
2865=over 4
2866
2867=item * It is limited to only run for MT schemas older than version 2.0 (the version_limit element handles this).
2868
2869=item * It operates on L<MT::Entry> objects (updater-E<gt>class element
2870declares that).
2871
2872=item * It tells the user what is happening (updater-E<gt>message).
2873
2874=item * It excludes any L<MT::Entry> objects that do not have a category_id element (updater-E<gt>condition).
2875
2876=item * It checks for an existing L<MT::Placement> relationship; if not
2877present, it creates one (updater-E<gt>code).
2878
2879=item * It empties out the category_id member of the L<MT::Entry> object
2880being upgrade to prevent it from being processed in the future
2881(updater-E<gt>code).
2882
2883=back
2884
2885For plugins, upgrade functions are assignable in the plugin registration
2886hash as documented in L<MT::Plugin>. You may also return a hashref of
2887upgrade functions from the plugin using the MT::Plugin::upgrade_functions
2888subroutine.
2889
2890Let's look at the anatomy of an upgrade function declaration:
2891
2892=over 4
2893
2894=item * version_limit (optional)
2895
2896The version_limit property allows you to declare that this upgrade
2897operation is only applicable to MT B<schema> versions below the version
2898specified.
2899
2900To register an upgrade function that is only applied to releases prior
2901to the current one, specify the current schema version as the version
2902limit. This will allow the upgrade function to run for any prior releases
2903but prevent it from running in subsequent releases.
2904
2905B<NOTE>: If you are declaring a B<plugin> upgrade function, this version
2906limit is compared with your plugin's schema version, not the Movable Type
2907schema version.
2908
2909=item * priority (optional)
2910
2911If your upgrade operation is dependent on another being done already,
2912it is possible to order them using the priority value. A lower value
2913means a higher priority.
2914
2915=item * condition (optional)
2916
2917This is a coderef parameter. If specified, it should return a true or
2918false value that determines whether the upgrade step is actually to run
2919or not.
2920
2921When called, it is given the parameters normally passed to an upgrade
2922operation (see the 'code' parameter documentation).
2923
2924=item * on_field (optional)
2925
2926If specified, this upgrade function is triggered upon the creation of
2927the field identified by this element. For instance,
2928
2929    on_field => 'MT::Foo->bar'
2930
2931This would specify that the upgrade step is only to run when the 'bar'
2932column is being added to the table that stores data for the MT::Foo
2933package.
2934
2935=item * code
2936
2937This coderef parameter is the declared handler for the upgrade
2938function. It is responsible for doing the upgrade task itself. For
2939quick operations, it is fine to do all of your work within this
2940subroutine. However, to faciliate large databases, it is important
2941to do that work in manageable portions so it doesn't time-out by
2942the web server or browser client.
2943
2944To facilitate an iterative process for your upgrade function, the
2945upgrade routine itself can yield a return value to signal the
2946upgrade process on how to proceed:
2947
2948=over 4
2949
2950=item * 0
2951
2952The upgrade function completed successfully.
2953
2954=item * undef
2955
2956upgrade routine failed with error. The error should be placed using the
2957MT::Upgrade-E<gt>error method.
2958
2959=item * E<gt> 0
2960
2961More work to do; the return value is the 'offset' parameter
2962to pass on the next invocation of the upgrade function.
2963
2964=back
2965
2966Due to the complexity of handling this kind of staged operation,
2967you will most likely want to use the prebuilt
2968'MT::Upgrade::core_update_records' routine to do most of your upgrade
2969operations that handle some or all records of a given package.
2970
2971If using the 'core_update_records' routine, you should also specify
2972an 'updater' parameter for your upgrade function.
2973
2974=item * updater
2975
2976This parameter is only used if you've specified the 'core_update_records'
2977routine (from the L<MT::Upgrade> package itself) for the 'code' element of
2978your upgrade function.
2979
2980    code => \&MT::Upgrade::core_update_records,
2981    updater => {
2982        class => 'MT::Foo',
2983        message => 'Updating Foo bars...',
2984        code => sub {
2985            my $foo = shift;
2986            $foo->bar(1);
2987        },
2988        condition => sub {
2989            my $foo = shift;
2990            !defined $foo->bar;
2991        },
2992        sql => 'update mt_foo set foo_bar = 1 where foo_bar is null'
2993    }
2994
2995This updater declaration is going to process all MT::Foo objects that
2996are available, setting the 'bar' property to 1 if it hasn't been assigned
2997a value already.
2998
2999Here's an overview of an 'updater' element:
3000
3001=over 4
3002
3003=item * class (required)
3004
3005The L<MT::Object>-descendant class to be processed.
3006
3007=item * code (required)
3008
3009A coderef to execute for B<each> record of the table. The parameter to
3010this routine is the object being processed. Following the call to your
3011subroutine, the object is saved for you, so you don't have to save
3012the object yourself.
3013
3014=item * message (optional)
3015
3016The status message to display when running this upgrade operation.
3017
3018=item * condition (optional)
3019
3020A coderef to use to test whether the current object needs to be upgraded
3021or not. This routine should return true if it is to be processed; false
3022if not. It is given the object as a parameter.
3023
3024=item * sql (optional)
3025
3026If specified, and if MT is using a SQL-based database for storing data,
3027this SQL statement is issued instead of doing the Perl-based row-by-row
3028upgrade.
3029
3030    sql => 'update mt_foo set foo_bar=1 where foo_bar is null'
3031
3032You may also specify multiple SQL statements using an array:
3033
3034    sql => [
3035        'update mt_foo set foo_bar=1 where foo_bar is null',
3036        'update mt_foo set foo_baz=2 where foo_baz is null'
3037    ]
3038
3039B<WARNING>: The 'sql' property is only meant to be used for cases where you
3040can issue simple, cross-database SQL statements. It is not advised to
3041use any vendor-specific SQL syntax. So, if you can't do that, don't specify
3042the 'sql' element at all and instead use the 'code' element exclusively
3043to do the upgrade operation.
3044
3045=back
3046
3047=back
3048
3049The declarative style of upgrade functions make it possible for MT to
3050fix itself, upgrading from any older schema version to the current one.
3051Upgrade functions are selected through an introspection process, so any
3052given upgrade operation may run a different selection of upgrade functions.
3053As such, it is important that any upgrade functions be written with this
3054in mind. Here are some general best practices to use when writing them:
3055
3056=over 4
3057
3058=item * Make them fast.
3059
3060Use the 'sql' element for a 'core_update_records' type upgrade function
3061so that SQL-based databases can be upgraded in one pass.
3062
3063=item * Make them indepedent.
3064
3065Don't assume that any other upgrade operation will have run within the
3066same application request. The upgrade process can run them in most any
3067order and across multiple application requests. You do have a guarantee
3068that a higher priority upgrade function will be run prior to a lower-priority
3069upgrade function (ie, assigning a priority of 1 will ensure it will run
3070before one with a priority of 2).
3071
3072=item * Limit them as much as possible.
3073
3074Specify a version_limit so it only runs for the proper schemas. Use the
3075condition element to bypass objects or the upgrade step altogether when
3076possible.
3077
3078=item * Repeating an upgrade function should be safe.
3079
3080This can be made possible through use of the 'condition' elements, bypassing
3081objects that have already been processed (see how the
3082'core_create_placements' upgrade function declares conditions for an
3083example).
3084
3085=item * Beware which translate method to call
3086
3087$self->translate_escape is for messages and phrases which appear on the
3088progress screen (therefore they are sent in JSON).  Use MT->translate
3089to messages and phrases which directly stored in the database.  Log messages
3090and objects' attributes fall into this category.
3091
3092=back
3093
3094=head1 AUTHOR & COPYRIGHTS
3095
3096Please see the I<MT> manpage for author, copyright, and license information.
3097
3098=cut
Note: See TracBrowser for help on using the browser.