Changeset 1948

Timestamp:

04/17/08 12:38:52 (15 months ago)

Author:

fumiakiy

Message:

New metadata structure is now backup- and restore-able. BugId:79317

Location:

branches/release-35

Files:

• lib/MT/BackupRestore.pm (modified) (5 diffs)
• lib/MT/BackupRestore/BackupFileHandler.pm (modified) (4 diffs)
• t/61-to_from_xml.t (modified) (6 diffs)

branches/release-35/lib/MT/BackupRestore.pm

@@ -178 +178 @@
             $progress->("$err\n", 'Error');
             next;
+        }
+        my @metacolumns;
+        if ( exists( $class->properties->{meta} )
+          && $class->properties->{meta} ) {
+            require MT::Meta;
+            @metacolumns = MT::Meta->metadata_by_class( $class );
         }
         my $records = 0;
@@ -215 +221 @@
                     next;
                 }
-                $bytes += $printer->($object->to_xml(undef, $args) . "\n");
+                $bytes += $printer->($object->to_xml(undef, \@metacolumns) . "\n");
                 $records++;
                 if ($size && ($bytes >= $size)) {
@@ -669 +675 @@
 sub to_xml {
     my $obj = shift;
-    my ($namespace, $args) = @_;
+    my ($namespace, $metacolumns) = @_;
 
     my $coldefs = $obj->column_defs;
@@ -696 +702 @@
         }
     }
+    my ( @meta_elements, @meta_blobs );
+    if ( defined( $metacolumns ) && @$metacolumns ) {
+        foreach my $metacolumn ( @$metacolumns ) {
+            my $name = $metacolumn->{name};
+            if ($obj->$name || (defined($obj->$name) && ('0' eq $obj->$name))) {
+                if ( 'vclob' eq $metacolumn->{type} ) {
+                    push @meta_elements, $name;
+                }
+                elsif ( 'vblob' eq $metacolumn->{type} ) {
+                    push @meta_blobs, $name;
+                }
+                else {
+                    $xml .= " $name='" . MT::Util::encode_xml($obj->$name, 1) . "'";
+                }
+            }
+        }
+    }
     $xml .= '>';
     $xml .= "<$_>" . MT::Util::encode_xml($obj->column($_), 1) . "</$_>" foreach @elements;
@@ -706 +729 @@
                 "</$meta_col>";
     }
+    $xml .= "<$_>" . MT::Util::encode_xml($obj->$_, 1) . "</$_>" foreach @meta_elements;
+    $xml .= "<$_>" . MIME::Base64::encode_base64($obj->$_, '') . "</$_>" foreach @meta_blobs;
     $xml .= '</' . $elem . '>';
     $xml;

branches/release-35/lib/MT/BackupRestore/BackupFileHandler.pm

@@ -9 +9 @@
 use strict;
 use XML::SAX::Base;
+use MIME::Base64;
 
 @MT::BackupRestore::BackupFileHandler::ISA = qw(XML::SAX::Base);
@@ -91 +92 @@
                     $obj = $class->load({ name => $column_data{name} });
                     if ($obj) {
-                        if ( $obj->id == MT->instance->user->id ) {
+                        if ( UNIVERSAL::isa('MT::App', MT->instance)
+                          && ( $obj->id == MT->instance->user->id ) ) {
                             MT->log({ message => MT->translate(
                                 "User with the same name as the name of the currently logged in ([_1]) found.  Skipped the record.", $obj->name),
@@ -153 +155 @@
                     my $success = $obj->restore_parent_ids(\%column_data, $objects);
                     if ($success) {
-                        $obj->set_values(\%column_data);
+                        require MT::Meta;
+                        my @metacolumns = MT::Meta->metadata_by_class( ref($obj) );
+                        my %metacolumns = map { $_->{name} => $_->{type} } @metacolumns;
+                        $self->{metacolumns}{ref($obj)} = \%metacolumns;
+                        my %realcolumn_data = map { $_ => $column_data{$_} }
+                            grep { !exists($metacolumns{$_}) }
+                                keys %column_data;
+                        $obj->set_values(\%realcolumn_data);
+                        foreach my $metacol ( keys %metacolumns ) {
+                            next if ( 'vclob' eq $metacolumns{$metacol} )
+                                 || ( 'vblob' eq $metacolumns{$metacol} );
+                            $obj->$metacol( $column_data{$metacol} );
+                        }
                         $self->{current} = $obj;
                     } else {
@@ -202 +216 @@
             
             my $defs = $obj->column_defs;
-            if ('blob' eq $defs->{$column_name}->{type}) {
-                require MIME::Base64;
-                $obj->column($column_name, MIME::Base64::decode_base64($text));
-            } else {
-                $text = MT::I18N::encode_text($text, 'utf-8');
-                $obj->column($column_name, $text);
+            if ( exists( $defs->{$column_name} ) ) {
+                if ('blob' eq $defs->{$column_name}->{type}) {
+                    $obj->column($column_name, MIME::Base64::decode_base64($text));
+                } else {
+                    $text = MT::I18N::encode_text($text, 'utf-8');
+                    $obj->column($column_name, $text);
+                }
+            }
+            elsif ( my $metacolumns = $self->{metacolumns}{ref($obj)} ) {
+                if ( my $type = $metacolumns->{$column_name} ) {
+                    if ( 'vblob' eq $type ) {
+                        $self->{callback}->($text);
+                        $text = MIME::Base64::decode_base64($text);
+                        $self->{callback}->($text);
+                        $obj->$column_name( $text );
+                    }
+                    else {
+                        $text = MT::I18N::encode_text($text, 'utf-8');
+                        $obj->$column_name( $text );
+                    }
+                }
             }
         } else {

branches/release-35/t/61-to_from_xml.t

@@ -5 +5 @@
 
 use lib 't/lib', 'extlib', 'lib', '../lib', '../extlib';
-use Test::More tests => 3598;
+use Test::More qw(no_plan);#tests => 3598;
 
 use MT;
@@ -49 +49 @@
 foreach my $key (keys %$types) {
     next if exists $skip{$key};
-    my @data = MT->model($key)->load;
+    my $iter = MT->model($key)->load_iter;
+    my @data;
+    while ( my $obj = $iter->() ) {
+        push @data, $obj;
+    }
     $oldies{$key} = \@data;
 }
 
 MT::BackupRestore->backup(undef, $printer, sub {}, sub {}, sub { print $_[0], "\n"; }, 0, 'UTF-8');
+open my $fh, '>', 'c:\\temp\\hoge.txt';
+print $fh $backup_data;
+close $fh;
 
 use IO::String;
@@ -61 +68 @@
 
 is(scalar(keys %deferred), 0);
-print join "\n", @errors;
+warn join "\n", @errors if @errors;
 is(scalar(@errors), 0, 'no error during backup');
-
 &checkthemout(\%oldies, \%objects);
 
@@ -73 +79 @@
     foreach my $name (keys %$oldies) {
         my $old_objects = $oldies->{$name};
+        my %meta;
         for my $old (@$old_objects) {
             my $class = MT->model($name);
@@ -112 +119 @@
                     );
                     next if ($ds eq 'category' && ($col eq 'parent'));
-                    # MT::Trackback will always be created upon MT::Entry->save,
-                    # and restore will just skip to restore <trackback> data,
-                    # meaning trackback_created_on will not be restored but newly created.
-                    next if ($name eq 'trackback' && ($col eq 'created_on'));
+                    if ( ($name eq 'trackback') && ($col eq 'is_disabled') ) {
+                        if ( defined($obj->is_disabled) && $obj->is_disabled
+                          && (!defined($obj->entry->allow_pings) || ($obj->entry->allow_pings == 0)) )
+                        {
+                            # is_disabled will be changed upon $entry->save
+                            # and save may occur $comment's post_save trigger
+                            # no harm for the testing purpose, ignore the case.
+                            next;
+                        }
+                    }
                     if ('HASH' eq ref($old->$col)) {
                         is(Dumper($old->$col), Dumper($old->$col), $col);
@@ -125 +138 @@
                     } else {
                         is($old->$col, $obj->$col, "$class<$col>" . $obj->id);
+                    }
+                }
+            }
+            unless ( exists($meta{ref($obj)}) ) {
+                my @metacolumns = MT::Meta->metadata_by_class( ref($obj) );
+                my %metacolumns = map { $_->{name} => $_->{type} } @metacolumns;
+                $meta{ref($obj)} = \%metacolumns
+            }
+            my $metacolumns = $meta{ref($obj)};
+            foreach my $metacol (keys %$metacolumns) {
+                if ( my $type = $metacolumns->{$metacol} ) {
+                    if ( 'vblob' eq $type ) {
+                        if ( defined($old->$metacol) && defined($obj->$metacol) ) {
+                            is(
+                                MIME::Base64::encode_base64($old->$metacol, ''),
+                                MIME::Base64::encode_base64($obj->$metacol, ''),
+                                "vblob - $metacol");
+                        }
+                    }
+                    else {
+                        is($old->$metacol, $obj->$metacol, "$class<meta:$metacol>" . $obj->id);
                     }
                 }