Ignore:
Timestamp:
12/10/09 15:21:06 (10 years ago)
Author:
ronosman
Message:

Feature 1052 added : photo re-upload management. When uploading an already added photo, the user is warned and has a choice on action for files, simple properties and multi-values properties.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • extensions/pLoader/trunk/src/Uploader/PWG/WebServices.pm

    r4422 r4467  
    6161           upload_high 
    6262           chunk_size 
    63            sum_high_file 
    64            sum_resized_file 
    65            sum_thumb_file 
    66            sum_original_file 
     63           sum 
     64           image_id 
     65           typecode 
     66                   reupload_action_files 
     67                   reupload_action_properties 
     68                   reupload_action_properties_m 
     69                   single_value_mode 
     70                   multiple_value_mode 
    6771      /  
    6872); 
     
    7276sub Init { 
    7377    my ( $self, $version ) = @_ ; 
    74   
     78 
     79    # to transform a type_code into a typename 
     80    $self->typecode( 
     81        { 
     82             file => 'file', 
     83             thumbnail => 'thumb', 
     84             high => 'high',     
     85        } 
     86    ); 
     87         
     88        $self->single_value_mode( 
     89            { 
     90                    1 => 'fill_if_empty', 
     91                        2 => 'replace', 
     92                } 
     93        ); 
     94 
     95        $self->multiple_value_mode( 
     96            { 
     97                    1 => 'append', 
     98                        2 => 'replace', 
     99                } 
     100        ); 
     101         
    75102    $self->uagent( 
    76103        LWP::UserAgent->new( 
     
    125152    }; 
    126153  
    127     $self->uagent_response( 
    128         $self->uagent->post( 
    129             $self->urlbase.'/ws.php?format=json', 
    130             $form 
    131         ) 
    132     ); 
    133      
     154    $self->_execute_post( 
     155        $form 
     156    );     
     157 
     158    $self->login_result( 
     159        $self->_json_response_content 
     160    ); 
     161 
     162} 
     163 
     164sub _json_response_content { 
     165    my ( $self ) = @_; 
     166 
    134167    my $hresult = {} ; 
    135168 
    136169    if($self->uagent_response->is_success){ 
     170        # when server response has warnings, the content response is not a valid json string 
     171                # find the json response 
     172                #printf("%s\n", $self->uagent_response->content); 
     173        $self->uagent_response->content =~ /(\{.+\})/; 
     174                #printf("json response %s\n", $1); 
    137175        eval { 
    138176            $hresult = from_json( 
    139                 $self->uagent_response->content 
     177                $1 
    140178            ); 
    141179        }; 
     180                 
    142181    } 
    143182    else{ 
    144         $hresult = { 
     183        $hresult = { 
    145184            'message' => $self->uagent_response->message, 
    146185            'stat'    => 'fail', 
    147186        }; 
    148187    } 
    149  
    150     $self->login_result( 
    151         $hresult 
    152     ); 
    153  
    154 } 
    155  
    156 sub GetCategories { 
    157     my ( $self ) = @_; 
    158  
    159     my $result; 
     188         
     189        $hresult; 
     190} 
     191 
     192sub _execute_get { 
     193    my ( $self, $query ) = @_; 
     194 
    160195    eval { 
    161         $result = $self->uagent->get( 
    162             $self->qry_list_categories 
     196        $self->uagent_response( 
     197            $self->uagent->get( 
     198                $query 
     199                    ) 
    163200        ); 
    164201    }; 
     
    166203    if($@){ 
    167204        printf("An error occured in query execution %s\n%s", 
    168             $self->qry_list_categories, 
     205            $query, 
    169206            $@, 
    170207        );       
    171208    } 
    172     my $hresult; 
    173      
    174     eval { 
    175         $hresult = from_json( 
    176             $result->content 
    177         ); 
    178     }; 
    179      
    180     $hresult ||= {}; 
    181  
    182     my $categories = $hresult->{result}{categories}; 
    183  
    184     $categories;         
    185 } 
    186  
    187 sub GetTags { 
    188     my ( $self ) = @_; 
     209} 
     210 
     211sub _execute_post { 
     212    my ( $self, $form ) = @_; 
    189213 
    190214    my $result; 
    191215    eval { 
    192         $result = $self->uagent->get( 
    193             $self->qry_list_tags 
     216        $result = $self->uagent_response( 
     217            $self->uagent->post( 
     218                $self->urlbase.'/ws.php?format=json', 
     219                $form 
     220            ) 
    194221        ); 
    195     }; 
     222        }; 
    196223 
    197224    if($@){ 
    198         printf("An error occured in query execution %s\n%s", 
    199             $self->qry_list_tags, 
     225        printf("An error occured in post execution %s\n%s", 
     226            $form->{method}, 
    200227            $@, 
    201228        );       
    202229    } 
    203     my $hresult; 
    204      
    205     eval { 
    206         $hresult = from_json( 
    207             $result->content 
    208         ); 
    209     }; 
    210      
    211     $hresult ||= {}; 
    212  
    213     $hresult->{result}{tags}; 
     230         
     231        return ( $result->is_success, $result->status_line ); 
     232} 
     233sub GetCategories { 
     234    my ( $self ) = @_; 
     235 
     236  
     237    $self->_execute_get( 
     238            $self->qry_list_categories 
     239        ); 
     240    $self->_json_response_content->{result}{categories}; 
     241} 
     242 
     243sub GetTags { 
     244    my ( $self ) = @_; 
     245 
     246    $self->_execute_get( 
     247        $self->qry_list_tags     
     248        ); 
     249    $self->_json_response_content->{result}{tags}; 
    214250} 
    215251 
     
    223259    }; 
    224260 
    225     my $result = $self->uagent->post( 
    226         $self->urlbase.'/ws.php?format=json', 
    227         $form 
    228     ); 
    229  
    230     my $content = {}; 
    231         eval { 
    232             $content = from_json( 
    233                 $result->content 
    234             ); 
    235         }; 
    236  
    237     return ( $result->is_success, $result->status_line, $content ); 
    238          
     261    return ( $self->_execute_post($form), $self->_json_response_content ); 
    239262}  
    240263 
     
    243266    my ( $self, $progress ) = @_; 
    244267 
    245     $self->sum_resized_file( 
    246         $self->_checksum( 
    247             $self->site_resized_file, 
    248             $progress 
    249         ) 
    250     ); 
    251  
    252     $self->sum_thumb_file( 
    253         $self->_checksum( 
    254             $self->site_thumb_file, 
    255             $progress 
    256         ) 
    257     ); 
    258   
    259     $self->sum_high_file( 
    260         $self->_checksum( 
    261             $self->site_high_file, 
    262             $progress 
    263         ) 
    264     ); 
    265     # is the same in pLoader but may be different  
    266     $self->sum_original_file( 
    267         $self->sum_high_file 
    268     ); 
    269  
    270  
    271     my $site_image_name = $self->site_image_name;  
    272  
    273     my $image_id = $self->_exists($self->sum_original_file);; 
    274     my $status = 0; 
    275     my $status_line = "An error has occured during upload."; 
     268    $self->image_id( 
     269        $self->_exists($progress->{original_sum}) 
     270    ); 
     271 
     272    my $status = 1; 
     273    my $status_line ="OK"; 
    276274    my $content = {}; 
    277275    my $doubleCheck; 
    278276    my $form; 
    279     while(1){ 
    280         if(!defined($image_id)){ 
    281                  
    282             my $resized_params = $self->_send_chunks('file', $progress); 
    283             $status_line = $resized_params->{message}; 
    284             last if !$resized_params->{ok}; 
     277    UPLOAD: while(1){ 
     278        # first upload 
     279        if(!defined($self->image_id)){  
     280            $doubleCheck = 1; 
     281            $self->_checksum_files($progress); 
     282            my @types = ('file', 'thumb'); 
     283            push @types, 'high' if $self->upload_high; 
     284            map{ 
     285                my $rval = $self->_send_chunks($_, $progress); 
     286                $status_line = $rval->{message}; 
     287                last UPLOAD if !$rval->{ok}; 
     288            } @types; 
    285289           
    286             my $thumb_params = $self->_send_chunks('thumb', $progress); 
    287             $status_line = $thumb_params->{message}; 
    288             last if !$thumb_params->{ok}; 
    289290         
    290291            $form = { 
    291292                method            => 'pwg.images.add', 
    292                 original_sum      => $self->sum_original_file, 
    293                 file_sum          => $self->sum_resized_file, 
    294                 thumbnail_sum     => $self->sum_thumb_file, 
     293                original_sum      => $self->sum->{original}, 
     294                file_sum          => $self->sum->{file}, 
     295                thumbnail_sum     => $self->sum->{thumb}, 
    295296                categories        => $self->categories, 
    296                 name              => $site_image_name, 
    297                 rank              => $self->rank, 
     297                name              => $self->site_image_name, 
    298298                author            => $self->site_author, 
    299299                comment           => $self->site_comment, 
     
    302302                 
    303303            }; 
    304      
    305             if($self->upload_high){ 
    306                 my $high_params = $self->_send_chunks('high', $progress); 
    307                 $status_line = $high_params->{message}; 
    308                 last if !$high_params->{ok}; 
    309                                 # high is a HD resized copy of original 
    310                                 $form->{high_sum} = $self->sum_high_file; 
     304 
     305           $form->{high_sum} = $self->sum->{high} if $self->upload_high; 
     306                    
     307           $progress->{yield}->(); 
     308           ( $status, $status_line ) = $self->_execute_post($form);  
     309                } 
     310        # re-upload 
     311        else{ 
     312                    #printf("reupload, files %s, properties %s\n", $self->reupload_action_files, $self->reupload_action_properties); 
     313            # need to check if files have changed 
     314            # and update image info 
     315            if($self->reupload_action_files){ 
     316                $self->_checksum_files($progress); 
     317                my $files = $self->_check_files(); 
     318                if(defined($files)){ 
     319                    $self->_add_files($files, $progress);        
     320                } 
    311321            } 
    312             $doubleCheck = 1; 
    313         } 
    314         else { 
     322 
    315323            $form = { 
    316                 method            => 'pwg.images.setInfo', 
    317                 image_id          => $image_id, 
    318                 categories        => $self->categories, 
    319                 name              => $site_image_name, 
    320                 rank              => $self->rank, 
    321                 author            => $self->site_author, 
    322                 comment           => $self->site_comment, 
    323                 date_creation     => $self->site_img_date_creation, 
    324                 tag_ids           => $self->site_tags, 
     324                    method        => 'pwg.images.setInfo', 
     325                    image_id      => $self->image_id, 
     326                    }; 
     327            # update metadata info 
     328            if($self->reupload_action_properties){       
     329                            #printf("reupload_action_properties %s\n", $self->reupload_action_properties); 
     330                $form->{name} = $self->site_image_name; 
     331                $form->{author}        = $self->site_author; 
     332                $form->{comment}       = $self->site_comment; 
     333                $form->{date_creation} = $self->site_img_date_creation; 
     334                                $form->{single_value_mode}  = $self->single_value_mode->{$self->reupload_action_properties}; 
     335                    } 
     336            if($self->reupload_action_properties_m){     
     337                            #printf("reupload_action_properties_m %s\n", $self->reupload_action_properties_m); 
     338                $form->{tag_ids} = $self->site_tags if $self->site_tags; 
     339                $form->{categories} = $self->categories; 
     340                                $form->{multiple_value_mode} = $self->multiple_value_mode->{$self->reupload_action_properties_m}; 
    325341            }; 
    326342            $progress->{yield}->(); 
    327         } 
     343            ( $status, $status_line ) = $self->_execute_post($form);  
     344            } 
    328345 
    329346        delete $form->{tag_ids} unless defined $self->site_tags; 
     
    331348 
    332349        $progress->{yield}->(); 
    333         my $result = $self->uagent->post( 
    334             $self->urlbase.'/ws.php?format=json', 
    335             $form 
    336         ); 
    337         eval { 
    338             $content = from_json( 
    339                 $result->content 
    340             ); 
    341         }; 
    342  
    343      
    344         $status = $result->is_success; 
    345         $status_line = $result->status_line;  
    346  
    347         if($doubleCheck){ 
    348             $content->{stat} = 'fail' if !$self->_exists($self->sum_original_file);  
     350            #print "form ", Dumper $form; 
     351                #print "status ", $status, "\n"; 
     352                #print "status_line ", $status_line, "\n"; 
     353            # basic check, should perform a checkfile 
     354        $content->{stat} = !$self->_exists($progress->{original_sum}) ? 'fail' : 'ok';  
     355 
     356                last UPLOAD; 
     357    }# UPLOAD 
     358     
     359    return ( $status,  $status_line, $content); 
     360} 
     361 
     362sub _checksum_files { 
     363    my ( $self, $progress ) = @_; 
     364 
     365    $self->sum( 
     366        { 
     367            file => $self->_checksum( 
     368                        $self->site_resized_file, 
     369                        $progress 
     370                    ), 
     371            thumb => $self->_checksum( 
     372                             $self->site_thumb_file, 
     373                             $progress 
     374                         ), 
     375            high => $self->_checksum( 
     376                        $self->site_high_file, 
     377                        $progress 
     378                    ), 
     379            original => $progress->{original_sum} 
    349380        } 
    350  
    351         last; 
     381    );  
     382} 
     383 
     384sub _check_files { 
     385    my ( $self ) = @_; 
     386 
     387    my $form = { 
     388        method   => 'pwg.images.checkFiles', 
     389        image_id => $self->image_id, 
     390    }; 
     391     
     392    @$form{'thumbnail_sum', 'file_sum' } = ( 
     393        $self->sum->{thumb}, 
     394        $self->sum->{file}, 
     395    ); 
     396 
     397    if($self->upload_high){ 
     398        $form->{high_sum} = $self->sum->{high}; 
    352399    } 
    353      
    354     return ( $status,  $status_line, $content); 
     400 
     401    $self->_execute_post($form);     
     402    my $hresult = $self->_json_response_content; 
     403 
     404    my $rval = 'ok' eq $hresult->{stat} ? $hresult->{result} : undef; 
     405     
     406    $rval; 
     407} 
     408 
     409# $files is returned by _check_files 
     410# { 
     411#     thumbnail => 'equals', 'differs', 'missing' 
     412#     file => 'equals', 'differs', 'missing' 
     413#     high => 'equals', 'differs', 'missing' 
     414#} 
     415 
     416sub _add_files { 
     417    my ( $self, $files, $progress ) = @_; 
     418 
     419    map{ 
     420        $self->_add_file($_, $progress); 
     421    } 
     422    map{ 
     423        $self->typecode->{$_}; 
     424    } grep { 'equals' ne $files->{$_} } keys %$files ; 
     425         
     426} 
     427 
     428sub _add_file { 
     429    my ( $self, $type_code, $progress ) = @_; 
     430 
     431    $self->_send_chunks( 
     432        $type_code, 
     433        $progress, 
     434    ); 
     435 
     436    my $form = { 
     437        method => 'pwg.images.addFile', 
     438        image_id => $self->image_id, 
     439        type     => $type_code, 
     440        sum      => $self->sum->{$type_code},            
     441    };   
     442 
     443    $self->_execute_post($form);     
     444    my $hresult = $self->_json_response_content; 
     445print Dumper $hresult; 
     446    my $rval = 'ok' eq $hresult->{stat} ? $hresult->{result} : undef; 
     447     
     448    $rval; 
     449} 
     450 
     451sub IsAlreadyUploaded { 
     452    my ( $self, $md5_sums ) = @_; 
     453         
     454        # md5_sums is an array ref 
     455        $self->_execute_post({ 
     456        method      => 'pwg.images.exist', 
     457        md5sum_list => join(',', @$md5_sums) 
     458            } 
     459        ); 
     460 
     461        my $sums = $self->_json_response_content->{result}; 
     462 
     463    $sums; 
    355464} 
    356465 
     
    363472    }; 
    364473 
    365     my $result = $self->uagent->post( 
    366         $self->urlbase.'/ws.php?format=json', 
    367         $form 
    368     ); 
    369  
    370     my $hresult = {}; 
    371     eval { 
    372         $hresult = from_json( 
    373             $result->{_content} 
    374         ); 
    375     }; 
    376     my $id; 
    377     $id = $hresult->{result}{$self->sum_original_file} if 'ok' eq $hresult->{stat}; 
    378      
     474    $self->_execute_post($form);     
     475    my $hresult = $self->_json_response_content; 
     476 
     477        $hresult->{result} = {} if 'HASH' ne ref $hresult->{result}; 
     478    my $id = 'ok' eq $hresult->{stat} ? $hresult->{result}{$md5_sum} : undef ; 
     479 
    379480    $id; 
    380481}  
     
    405506 
    406507sub _send_chunks { 
    407     my ( $self, $type, $progress ) = @_; 
     508    my ( $self, $type_code, $progress ) = @_; 
    408509 
    409510    my $msg = { 
     
    419520    }; 
    420521 
    421     $progress->{current_msg} = $progress->{$msg->{$type}}; 
     522    $progress->{current_msg} = $progress->{$msg->{$type_code}}; 
    422523    $progress->{yield}->(); 
    423524 
    424525    my $params = { 
    425          filepath      => $filepath->{$type}, 
    426          type          => $type, 
    427          original_sum  => $self->sum_original_file, 
    428     }; 
    429  
     526         filepath      => $filepath->{$type_code}, 
     527         type          => $type_code, 
     528         original_sum  => $self->sum->{original}, 
     529    }; 
     530print Dumper $params; 
    430531    $self->send_chunks( 
    431532       $params, 
     
    446547         
    447548    }; 
    448  
    449     my $result = $self->uagent->post( 
    450         $self->urlbase.'/ws.php?format=json', 
    451         $form 
    452     ); 
    453  
    454     my $content = {}; 
    455         eval { 
    456             $content = from_json( 
    457                 $result->content 
    458             ); 
    459         }; 
    460  
    461     return ( $result->is_success, $result->status_line, $content ); 
    462549         
     550    return ( $self->_execute_post($form), $self->_json_response_content ); 
    463551} 
    464552 
     
    474562    }; 
    475563 
    476     my $result = $self->uagent->post( 
    477         $self->urlbase.'/ws.php?format=json', 
    478         $form 
    479     ); 
    480  
    481     my $content = {}; 
    482         eval { 
    483             $content = from_json( 
    484                 $result->content 
    485             ); 
    486         }; 
    487  
    488     return ( $result->is_success, $result->status_line, $content ); 
    489          
     564    return ( $self->_execute_post($form), $self->_json_response_content ); 
    490565} 
    491566 
Note: See TracChangeset for help on using the changeset viewer.