Changeset 18460 for gsdl

Show
Ignore:
Timestamp:
04.02.2009 15:02:01 (11 years ago)
Author:
anna
Message:

Added several functions in GTI.\n 1. Create spreadsheet for all the strings in current module (gtiaction.cpp, english2.dm).\n 2. Create operational files for GLI Help (HTML files etc) as requested, zip them and provide for download (gtiaction.h|cpp, gti.dm, gti.pl).\n 3. Functions for processing GS3 interfaces (gti.pl).

Location:
gsdl/trunk
Files:
5 modified

Legend:

Unmodified
Added
Removed
  • gsdl/trunk/bin/script/gti.pl

    r14258 r18460  
    8989    # 'target_file' => "greenorg/macros/{iso_639_1_target_language_name}.dm"  
    9090      } 
     91 
     92      # { 'key' => "gs3interface", 
     93    #'file_type' => "resource_bundle", 
     94    #'source_file' => "greenstone3", 
     95    #'target_file' => "greenstone3" 
     96      #} 
    9197    ]; 
     98 
     99my @gs3_interface_files = ("AbstractBrowse", "AbstractGS2FieldSearch", "Authentication", "CrossCollectionSearch", "GATEServices", "GS2Construct", "GS2LuceneSearch", "interface_default", "interface_nzdl", "IViaSearch", "LuceneSearch", "MapRetrieve", "MapSearch", "metadata_names", "PhindPhraseBrowse", "QBRWebServicesHelp", "Visualizer"); 
    92100 
    93101 
     
    97105    my $gti_command = shift(@_); 
    98106    my @gti_command_arguments = @_; 
     107    my $module = $_[1]; 
    99108 
    100109    # Open the GTI log file for appending, or write to STDERR if that fails 
     
    109118    if (!$gti_command) { 
    110119    &throw_fatal_error("Missing command."); 
    111     } 
     120    }       
    112121 
    113122    # Process the command 
    114123    if ($gti_command =~ /^get-all-chunks$/i) { 
    115     print &get_all_chunks(@gti_command_arguments); 
     124    # Check that GS3 interface is the target 
     125    if ($module eq "gs3interface") {        
     126        print &get_all_chunks_for_gs3(@gti_command_arguments); 
     127    } else { 
     128        print &get_all_chunks(@gti_command_arguments); 
     129    } 
    116130    } 
    117131    if ($gti_command =~ /^get-first-n-chunks-requiring-work$/i) { 
    118     print &get_first_n_chunks_requiring_work(@gti_command_arguments);         
     132    if ($module eq "gs3interface") {        
     133        print &get_first_n_chunks_requiring_work_for_gs3(@gti_command_arguments); 
     134    } else { 
     135        print &get_first_n_chunks_requiring_work(@gti_command_arguments); 
     136    } 
    119137    } 
    120138    if ($gti_command =~ /^get-language-status$/i) { 
     
    128146    &submit_translations(@gti_command_arguments); 
    129147    } 
    130  
    131     # The command was not recognized 
    132     # &throw_fatal_error("Unknown command \"$gti_command\"."); 
     148    if ($gti_command =~ /^create-glihelp-zip-file$/i) { 
     149    # This command cannot produce any output since it reads input 
     150    &create_glihelp_zip_file(@gti_command_arguments); 
     151    } 
     152#    else { 
     153    # The command was not recognized 
     154    #&throw_fatal_error("Unknown command \"$gti_command\"."); 
     155    #} 
    133156} 
    134157 
     
    197220    my %source_file_key_to_last_update_date_mapping = &build_key_to_last_update_date_mapping($source_file, \@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
    198221    my %target_file_key_to_last_update_date_mapping = &build_key_to_last_update_date_mapping($target_file, \@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
    199      
    200     # Form an XML response to the command 
    201     my $xml_response = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"; 
    202     $xml_response .= "<GTIResponse>\n"; 
    203     $xml_response .= "  <TranslationFile" 
    204     . " key=\"" . $translation_file_key . "\"" 
    205         . " target_file_path=\"" . $target_file . "\"\/>\n"; 
    206      
    207     # Do all the chunks 
    208     $xml_response .= "  <Chunks size=\"" . scalar(keys(%source_file_key_to_text_mapping)) . "\">\n"; 
    209     foreach my $chunk_key (keys(%source_file_key_to_text_mapping)) { 
    210     my $source_file_chunk_date = $source_file_key_to_last_update_date_mapping{$chunk_key}; 
    211     my $source_file_chunk_text = &make_text_xml_safe($source_file_key_to_text_mapping{$chunk_key}); 
    212  
    213     $xml_response .= "    <Chunk key=\"" . &make_text_xml_safe($chunk_key) . "\">\n"; 
    214     $xml_response .= "      <SourceFileText date=\"$source_file_chunk_date\">$source_file_chunk_text</SourceFileText>\n"; 
    215     if (defined($target_file_key_to_text_mapping{$chunk_key})) { 
    216         my $target_file_chunk_date = $target_file_key_to_last_update_date_mapping{$chunk_key}; 
    217         my $target_file_chunk_text = &make_text_xml_safe($target_file_key_to_text_mapping{$chunk_key}); 
    218         $xml_response .= "      <TargetFileText date=\"$target_file_chunk_date\">$target_file_chunk_text</TargetFileText>\n"; 
    219     } 
    220     else { 
    221         $xml_response .= "      <TargetFileText></TargetFileText>\n"; 
    222     } 
    223  
    224     $xml_response .= "    </Chunk>\n"; 
    225     } 
    226     $xml_response .= "  </Chunks>\n"; 
    227      
    228     $xml_response .= "</GTIResponse>\n"; 
     222 
     223    my $xml_response = &create_xml_response_for_all_chunks($translation_file_key, $target_file, \%source_file_key_to_text_mapping, \%target_file_key_to_text_mapping, \%source_file_key_to_last_update_date_mapping, \%target_file_key_to_last_update_date_mapping);    
     224     
    229225    return $xml_response; 
    230226} 
     
    281277    &log_message("Number of target chunks requiring updating: " . scalar(@target_file_keys_requiring_updating)); 
    282278 
    283     # Form an XML response to the command 
    284     my $xml_response = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"; 
    285     $xml_response .= "<GTIResponse>\n"; 
    286     $xml_response .= "  <TranslationFile" 
    287     . " key=\"" . $translation_file_key . "\"" 
    288     . " target_file_path=\"" . $target_file . "\"" 
    289     . " num_chunks_translated=\"" . (scalar(keys(%source_file_key_to_text_mapping)) - scalar(@target_file_keys_requiring_translation)) . "\"" 
    290     . " num_chunks_requiring_translation=\"" . scalar(@target_file_keys_requiring_translation) . "\"" 
    291     . " num_chunks_requiring_updating=\"" . scalar(@target_file_keys_requiring_updating) . "\"\/>\n"; 
    292  
    293     # Do chunks requiring translation first 
    294     if ($num_chunks_to_return > scalar(@target_file_keys_requiring_translation)) { 
    295     $xml_response .= "  <ChunksRequiringTranslation size=\"" . scalar(@target_file_keys_requiring_translation) . "\">\n"; 
    296     } 
    297     else { 
    298     $xml_response .= "  <ChunksRequiringTranslation size=\"" . $num_chunks_to_return . "\">\n"; 
    299     } 
    300  
    301     foreach my $chunk_key (@target_file_keys_requiring_translation) { 
    302     last if ($num_chunks_to_return == 0); 
    303  
    304     my $source_file_chunk_date = $source_file_key_to_last_update_date_mapping{$chunk_key}; 
    305     my $source_file_chunk_text = &make_text_xml_safe($source_file_key_to_text_mapping{$chunk_key}); 
    306      
    307     if(!defined $source_file_chunk_date){ 
    308         $source_file_chunk_date = ""; 
    309     } 
    310      
    311     $xml_response .= "    <Chunk key=\"" . &make_text_xml_safe($chunk_key) . "\">\n"; 
    312     $xml_response .= "      <SourceFileText date=\"$source_file_chunk_date\">$source_file_chunk_text</SourceFileText>\n";    
    313     $xml_response .= "      <TargetFileText></TargetFileText>\n"; 
    314     $xml_response .= "    </Chunk>\n"; 
    315  
    316     $num_chunks_to_return--; 
    317     } 
    318  
    319     $xml_response .= "  </ChunksRequiringTranslation>\n"; 
    320  
    321     # Then do chunks requiring updating 
    322     if ($num_chunks_to_return > scalar(@target_file_keys_requiring_updating)) { 
    323     $xml_response .= "  <ChunksRequiringUpdating size=\"" . scalar(@target_file_keys_requiring_updating) . "\">\n"; 
    324     } 
    325     else { 
    326     $xml_response .= "  <ChunksRequiringUpdating size=\"" . $num_chunks_to_return . "\">\n"; 
    327     } 
    328  
    329     foreach my $chunk_key (@target_file_keys_requiring_updating) { 
    330     last if ($num_chunks_to_return == 0); 
    331  
    332     my $source_file_chunk_date = $source_file_key_to_last_update_date_mapping{$chunk_key}; 
    333     my $source_file_chunk_text = &make_text_xml_safe($source_file_key_to_text_mapping{$chunk_key}); 
    334     my $target_file_chunk_date = $target_file_key_to_last_update_date_mapping{$chunk_key}; 
    335     my $target_file_chunk_text = &make_text_xml_safe($target_file_key_to_text_mapping{$chunk_key}); 
    336      
    337     if(!defined $source_file_chunk_date){ 
    338         $source_file_chunk_date = ""; 
    339     } 
    340  
    341     $xml_response .= "    <Chunk key=\"" . &make_text_xml_safe($chunk_key) . "\">\n";    
    342     $xml_response .= "      <SourceFileText date=\"$source_file_chunk_date\">$source_file_chunk_text</SourceFileText>\n"; 
    343     $xml_response .= "      <TargetFileText date=\"$target_file_chunk_date\">$target_file_chunk_text</TargetFileText>\n"; 
    344     $xml_response .= "    </Chunk>\n"; 
    345  
    346     $num_chunks_to_return--; 
    347     } 
    348  
    349     $xml_response .= "  </ChunksRequiringUpdating>\n"; 
    350  
    351     $xml_response .= "</GTIResponse>\n"; 
     279    my $xml_response = &create_xml_response_for_chunks_requiring_work($translation_file_key, $target_file, scalar(keys(%source_file_key_to_text_mapping)), \@target_file_keys_requiring_translation, \@target_file_keys_requiring_updating, $num_chunks_to_return, \%source_file_key_to_text_mapping, \%target_file_key_to_text_mapping, \%source_file_key_to_last_update_date_mapping, \%target_file_key_to_last_update_date_mapping);    
     280     
    352281    return $xml_response; 
    353282} 
     
    369298    $xml_response .= "  <LanguageStatus code=\"$target_language_code\">\n"; 
    370299 
    371     foreach my $translation_file (@$gti_translation_files) { 
     300    foreach my $translation_file (@$gti_translation_files) {     
     301    my ($num_source_chunks, $num_target_chunks, $num_chunks_requiring_translation, $num_chunks_requiring_updating) = 0; 
     302    my $target_file_name = ""; 
     303     
     304    if ($translation_file->{'key'} eq "gs3interface") { 
     305        my (%source_file_key_to_text_mapping, %target_file_key_to_text_mapping, %source_file_key_to_last_update_date_mapping, %target_file_key_to_last_update_date_mapping ) = (); 
     306        &build_gs3_configuration($target_language_code, \%source_file_key_to_text_mapping, \%target_file_key_to_text_mapping, \%source_file_key_to_last_update_date_mapping, \%target_file_key_to_last_update_date_mapping );     
     307         
     308        my @target_file_keys_requiring_translation = &determine_chunks_requiring_translation(\%source_file_key_to_text_mapping, \%target_file_key_to_text_mapping);      
     309        my @target_file_keys_requiring_updating = &determine_chunks_requiring_updating(\%source_file_key_to_last_update_date_mapping, \%target_file_key_to_last_update_date_mapping); 
     310 
     311        $num_source_chunks = scalar(keys(%source_file_key_to_text_mapping)); 
     312        $num_target_chunks = scalar(keys(%target_file_key_to_text_mapping)); 
     313        $num_chunks_requiring_translation = scalar(@target_file_keys_requiring_translation); 
     314        $num_chunks_requiring_updating = scalar(@target_file_keys_requiring_updating); 
     315    } 
     316    else { 
     317        # Get (and check) the translation configuration 
     318        my ($source_file, $target_file, $translation_file_type) = &get_translation_configuration($target_language_code, $translation_file->{'key'}); 
     319        $target_file_name = $target_file; 
     320 
     321        # Parse the source language and target language files 
     322        my $source_file_path = &util::filename_cat($gsdl_root_directory, $source_file); 
     323        my @source_file_lines = &read_file_lines($source_file_path); 
     324        my %source_file_key_to_line_mapping = &build_key_to_line_mapping(\@source_file_lines, $translation_file_type); 
     325 
     326        my $target_file_path = &util::filename_cat($gsdl_root_directory, $target_file); 
     327        my @target_file_lines = &read_file_lines($target_file_path); 
     328        my %target_file_key_to_line_mapping = &build_key_to_line_mapping(\@target_file_lines, $translation_file_type); 
     329 
     330        # Filter out any automatically translated chunks 
     331        foreach my $chunk_key (keys(%source_file_key_to_line_mapping)) { 
     332        if (&is_chunk_automatically_translated($chunk_key, $translation_file_type)) { 
     333            delete $source_file_key_to_line_mapping{$chunk_key}; 
     334            delete $target_file_key_to_line_mapping{$chunk_key}; 
     335        } 
     336        } 
     337 
     338        my %source_file_key_to_text_mapping = &build_key_to_text_mapping(\@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
     339        my %target_file_key_to_text_mapping = &build_key_to_text_mapping(\@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
     340 
     341        # Determine the target file chunks requiring translation 
     342        my @target_file_keys_requiring_translation = &determine_chunks_requiring_translation(\%source_file_key_to_text_mapping, \%target_file_key_to_text_mapping);      
     343 
     344        # Determine the target file chunks requiring updating 
     345        my @target_file_keys_requiring_updating = (); 
     346        if (-e $target_file_path) { 
     347        my %source_file_key_to_last_update_date_mapping = &build_key_to_last_update_date_mapping($source_file, \@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
     348        my %target_file_key_to_last_update_date_mapping = &build_key_to_last_update_date_mapping($target_file, \@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
     349        @target_file_keys_requiring_updating = &determine_chunks_requiring_updating(\%source_file_key_to_last_update_date_mapping, \%target_file_key_to_last_update_date_mapping);       
     350        } 
     351 
     352        $num_source_chunks = scalar(keys(%source_file_key_to_text_mapping)); 
     353        $num_target_chunks = scalar(keys(%target_file_key_to_text_mapping)); 
     354        $num_chunks_requiring_translation = scalar(@target_file_keys_requiring_translation); 
     355        $num_chunks_requiring_updating = scalar(@target_file_keys_requiring_updating); 
     356    } 
     357     
     358    &log_message("Status of " . $translation_file->{'key'}); 
     359    &log_message("Number of source chunks: " . $num_source_chunks); 
     360    &log_message("Number of target chunks: " . $num_target_chunks); 
     361    &log_message("Number of target chunks requiring translation: " . $num_chunks_requiring_translation); 
     362    &log_message("Number of target chunks requiring updating: " . $num_chunks_requiring_updating); 
     363 
     364    $xml_response .= "    <TranslationFile" 
     365        . " key=\"" . $translation_file->{'key'} . "\"" 
     366        . " target_file_path=\"" . $target_file_name . "\"" 
     367        . " num_chunks_translated=\"" . ($num_source_chunks - $num_chunks_requiring_translation) . "\"" 
     368        . " num_chunks_requiring_translation=\"" . $num_chunks_requiring_translation . "\"" 
     369        . " num_chunks_requiring_updating=\"" . $num_chunks_requiring_updating . "\"\/>\n"; 
     370    } 
     371 
     372    $xml_response .= "  </LanguageStatus>\n"; 
     373 
     374    $xml_response .= "</GTIResponse>\n"; 
     375    return $xml_response; 
     376} 
     377 
     378 
     379sub search_chunks 
     380{ 
     381    # The code of the target language (ensure it is lowercase) 
     382    my $target_language_code = lc(shift(@_)); 
     383    # The key of the file to translate (ensure it is lowercase) 
     384    my $translation_file_key = lc(shift(@_)); 
     385    # The query string 
     386    my $query_string = join(' ', @_); 
     387 
     388    # Check that the necessary arguments were supplied 
     389    if (!$target_language_code || !$translation_file_key || !$query_string) { 
     390    &throw_fatal_error("Missing command argument."); 
     391    } 
     392 
     393    my ($source_file, $target_file, $translation_file_type) = (); 
     394    my %source_file_key_to_text_mapping = (); 
     395    my %target_file_key_to_text_mapping = (); 
     396     
     397     
     398    if ($translation_file_key ne "gs3interface") { 
    372399    # Get (and check) the translation configuration 
    373     my ($source_file, $target_file, $translation_file_type) 
    374         = &get_translation_configuration($target_language_code, $translation_file->{'key'}); 
     400    ($source_file, $target_file, $translation_file_type) = &get_translation_configuration($target_language_code, $translation_file_key); 
    375401 
    376402    # Parse the source language and target language files 
     
    391417    } 
    392418 
    393     my %source_file_key_to_text_mapping = &build_key_to_text_mapping(\@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
    394     my %target_file_key_to_text_mapping = &build_key_to_text_mapping(\@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
    395     &log_message("Number of source chunks: " . scalar(keys(%source_file_key_to_text_mapping))); 
    396     &log_message("Number of target chunks: " . scalar(keys(%target_file_key_to_text_mapping))); 
    397  
    398     # Determine the target file chunks requiring translation 
    399     my @target_file_keys_requiring_translation = &determine_chunks_requiring_translation(\%source_file_key_to_text_mapping, \%target_file_key_to_text_mapping); 
    400     &log_message("Number of target chunks requiring translation: " . scalar(@target_file_keys_requiring_translation)); 
    401  
    402     # Determine the target file chunks requiring updating 
    403     my @target_file_keys_requiring_updating = (); 
    404     if (-e $target_file_path) { 
    405         my %source_file_key_to_last_update_date_mapping = &build_key_to_last_update_date_mapping($source_file, \@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
    406         my %target_file_key_to_last_update_date_mapping = &build_key_to_last_update_date_mapping($target_file, \@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
    407         @target_file_keys_requiring_updating = &determine_chunks_requiring_updating(\%source_file_key_to_last_update_date_mapping, \%target_file_key_to_last_update_date_mapping); 
    408         &log_message("Number of target chunks requiring updating: " . scalar(@target_file_keys_requiring_updating)); 
    409     } 
    410  
    411     $xml_response .= "    <TranslationFile" 
    412         . " key=\"" . $translation_file->{'key'} . "\"" 
    413         . " target_file_path=\"" . $target_file . "\"" 
    414         . " num_chunks_translated=\"" . (scalar(keys(%source_file_key_to_text_mapping)) - scalar(@target_file_keys_requiring_translation)) . "\"" 
    415         . " num_chunks_requiring_translation=\"" . scalar(@target_file_keys_requiring_translation) . "\"" 
    416         . " num_chunks_requiring_updating=\"" . scalar(@target_file_keys_requiring_updating) . "\"\/>\n"; 
    417     } 
    418  
    419     $xml_response .= "  </LanguageStatus>\n"; 
    420  
    421     $xml_response .= "</GTIResponse>\n"; 
    422     return $xml_response; 
    423 } 
    424  
    425  
    426 sub search_chunks 
    427 { 
    428     # The code of the target language (ensure it is lowercase) 
    429     my $target_language_code = lc(shift(@_)); 
    430     # The key of the file to translate (ensure it is lowercase) 
    431     my $translation_file_key = lc(shift(@_)); 
    432     # The query string 
    433     my $query_string = join(' ', @_); 
    434  
    435     # Check that the necessary arguments were supplied 
    436     if (!$target_language_code || !$translation_file_key || !$query_string) { 
    437     &throw_fatal_error("Missing command argument."); 
    438     } 
    439  
    440     # Get (and check) the translation configuration 
    441     my ($source_file, $target_file, $translation_file_type) 
    442     = &get_translation_configuration($target_language_code, $translation_file_key); 
    443  
    444     # Parse the source language and target language files 
    445     my $source_file_path = &util::filename_cat($gsdl_root_directory, $source_file); 
    446     my @source_file_lines = &read_file_lines($source_file_path); 
    447     my %source_file_key_to_line_mapping = &build_key_to_line_mapping(\@source_file_lines, $translation_file_type); 
    448  
    449     my $target_file_path = &util::filename_cat($gsdl_root_directory, $target_file); 
    450     my @target_file_lines = &read_file_lines($target_file_path); 
    451     my %target_file_key_to_line_mapping = &build_key_to_line_mapping(\@target_file_lines, $translation_file_type); 
    452  
    453     # Filter out any automatically translated chunks 
    454     foreach my $chunk_key (keys(%source_file_key_to_line_mapping)) { 
    455     if (&is_chunk_automatically_translated($chunk_key, $translation_file_type)) { 
    456         delete $source_file_key_to_line_mapping{$chunk_key}; 
    457         delete $target_file_key_to_line_mapping{$chunk_key}; 
    458     } 
    459     } 
    460  
    461     my %source_file_key_to_text_mapping = &build_key_to_text_mapping(\@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
    462     my %target_file_key_to_text_mapping = &build_key_to_text_mapping(\@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
     419    %source_file_key_to_text_mapping = &build_key_to_text_mapping(\@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
     420    %target_file_key_to_text_mapping = &build_key_to_text_mapping(\@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
     421    } 
     422    else { 
     423    # Not needed in this case 
     424    my (%source_file_key_to_gti_command_mapping, %target_file_key_to_gti_command_mapping) = (); 
     425    &build_gs3_configuration($target_language_code, \%source_file_key_to_text_mapping, \%target_file_key_to_text_mapping, 
     426                 \%source_file_key_to_gti_command_mapping, \%target_file_key_to_gti_command_mapping); 
     427    } 
     428 
    463429    &log_message("Number of source chunks: " . scalar(keys(%source_file_key_to_text_mapping))); 
    464430    &log_message("Number of target chunks: " . scalar(keys(%target_file_key_to_text_mapping))); 
     
    509475    die "\n"; 
    510476    } 
    511  
    512     # Get (and check) the translation configuration 
    513     my ($source_file, $target_file, $translation_file_type) 
    514     = &get_translation_configuration($target_language_code, $translation_file_key); 
    515  
    516     # Parse the source language and target language files 
    517     my @source_file_lines = &read_file_lines(&util::filename_cat($gsdl_root_directory, $source_file)); 
    518     my %source_file_key_to_line_mapping = &build_key_to_line_mapping(\@source_file_lines, $translation_file_type); 
    519     my %source_file_key_to_text_mapping = &build_key_to_text_mapping(\@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
    520     my %source_file_key_to_gti_comment_mapping = &build_key_to_gti_comment_mapping(\@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
     477     
     478    my %source_file_key_to_text_mapping = (); 
     479    my %source_file_key_to_gti_comment_mapping = (); 
     480    my %target_file_key_to_text_mapping = (); 
     481    my %target_file_key_to_gti_comment_mapping = (); 
     482 
     483    my (@source_file_lines, @target_file_lines) = (); 
     484    my ($source_file, $target_file, $translation_file_type); 
     485 
     486     
     487    if ($translation_file_key ne "gs3interface") { 
     488    # Get (and check) the translation configuration 
     489    ($source_file, $target_file, $translation_file_type) 
     490        = &get_translation_configuration($target_language_code, $translation_file_key); 
     491 
     492    # Parse the source language and target language files 
     493    @source_file_lines = &read_file_lines(&util::filename_cat($gsdl_root_directory, $source_file)); 
     494    my %source_file_key_to_line_mapping = &build_key_to_line_mapping(\@source_file_lines, $translation_file_type); 
     495    %source_file_key_to_text_mapping = &build_key_to_text_mapping(\@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
     496    %source_file_key_to_gti_comment_mapping = &build_key_to_gti_comment_mapping(\@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type);     
     497 
     498    @target_file_lines = &read_file_lines(&util::filename_cat($gsdl_root_directory, $target_file)); 
     499    my %target_file_key_to_line_mapping = &build_key_to_line_mapping(\@target_file_lines, $translation_file_type); 
     500    %target_file_key_to_text_mapping = &build_key_to_text_mapping(\@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
     501    %target_file_key_to_gti_comment_mapping = &build_key_to_gti_comment_mapping(\@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type);     
     502    }  
     503    else { 
     504    &build_gs3_configuration($target_language_code, \%source_file_key_to_text_mapping, \%target_file_key_to_text_mapping,  
     505                 \%source_file_key_to_gti_comment_mapping, \%target_file_key_to_gti_comment_mapping); 
     506    } 
    521507    &log_message("Number of source chunks: " . scalar(keys(%source_file_key_to_text_mapping))); 
    522  
    523     my @target_file_lines = &read_file_lines(&util::filename_cat($gsdl_root_directory, $target_file)); 
    524     my %target_file_key_to_line_mapping = &build_key_to_line_mapping(\@target_file_lines, $translation_file_type); 
    525     my %target_file_key_to_text_mapping = &build_key_to_text_mapping(\@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
    526     my %target_file_key_to_gti_comment_mapping = &build_key_to_gti_comment_mapping(\@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
    527508    &log_message("Number of target chunks: " . scalar(keys(%target_file_key_to_text_mapping))); 
    528509 
     
    538519 
    539520    # Remove any nasty carriage returns 
    540     &log_message("Submission:"); 
     521    # &log_message("Submission:"); 
    541522    foreach my $submission_line (@submission_lines) { 
    542523    $submission_line =~ s/\r$//; 
    543     &log_message("  $submission_line"); 
     524    #&log_message("  $submission_line"); 
    544525    } 
    545526 
     
    561542        $source_file_chunk_text = &unmake_text_xml_safe($source_file_chunk_text); 
    562543 
    563         &log_message("Source file key: $chunk_key"); 
    564         &log_message("Source file text: $source_file_chunk_text"); 
     544        #&log_message("Source file key: $chunk_key"); 
     545        #&log_message("Source file text: $source_file_chunk_text"); 
    565546        $source_file_key_to_submission_mapping{$chunk_key} = $source_file_chunk_text; 
    566547    } 
     
    580561        $target_file_chunk_text = &unmake_text_xml_safe($target_file_chunk_text); 
    581562 
    582         &log_message("Target file key: $chunk_key"); 
    583         &log_message("Target file text: $target_file_chunk_text"); 
     563        #&log_message("Target file key: $chunk_key"); 
     564        #&log_message("Target file text: $target_file_chunk_text"); 
    584565        $target_file_key_to_submission_mapping{$chunk_key} = $target_file_chunk_text; 
    585566    } 
     
    619600    } 
    620601    } 
    621  
    622     eval "&write_translated_${translation_file_type}(\$source_file, \\\@source_file_lines, \\\%source_file_key_to_text_mapping, \$target_file, \\\@target_file_lines, \\\%target_file_key_to_text_mapping, \\\%target_file_key_to_gti_comment_mapping, \$target_language_code)"; 
     602     
     603    if ($translation_file_key ne "gs3interface") { 
     604    eval "&write_translated_${translation_file_type}(\$source_file, \\\@source_file_lines, \\\%source_file_key_to_text_mapping, \$target_file, \\\@target_file_lines, \\\%target_file_key_to_text_mapping, \\\%target_file_key_to_gti_comment_mapping, \$target_language_code)"; 
     605    } else { 
     606    eval "&write_translated_gs3interface(\\\%source_file_key_to_text_mapping, \\\%target_file_key_to_text_mapping, \\\%target_file_key_to_gti_comment_mapping, \$target_language_code)"; 
     607    } 
     608} 
     609 
     610 
     611sub create_glihelp_zip_file 
     612{ 
     613    my $target_language_code = shift(@_); 
     614    my $translation_file_key = "glihelp"; 
     615     
     616    &log_message("Creating GLI Help zip file for $target_language_code"); 
     617 
     618    my ($source_file, $target_file, $translation_file_type) = &get_translation_data_for($target_language_code, $translation_file_key);     
     619     
     620    my $classpath = &util::filename_cat($gsdl_root_directory, "gti-lib"); 
     621    if ( ! -e $classpath) { 
     622    &throw_fatal_error("$classpath doesn't exist! Need the files in this directory (ApplyXLST and its related files) to create the zip file for GLI Help"); 
     623    }     
     624     
     625    my $gli_help_directory = &util::filename_cat($gsdl_root_directory, "gli"); 
     626    $gli_help_directory = &util::filename_cat($gli_help_directory, "help"); 
     627     
     628    my $gen_many_html_xsl_filepath = &util::filename_cat($gli_help_directory, "gen-many-html.xsl"); 
     629    if ( ! -e $gen_many_html_xsl_filepath) { 
     630    &throw_fatal_error("$gen_many_html_xsl_filepath doesn't exist! Need this file to create the zip file for GLI Help"); 
     631    } 
     632 
     633    my $gen_index_xml_xsl_filepath = &util::filename_cat($gli_help_directory, "gen-index-xml.xsl");    
     634    my $split_script_filepath = &util::filename_cat($gli_help_directory, "splithelpdocument.pl");    
     635     
     636    my $target_file_directory = &util::filename_cat($gli_help_directory, $target_language_code); 
     637    $target_file_directory = $target_file_directory."/"; 
     638 
     639    my $target_filepath = &util::filename_cat($gsdl_root_directory, $target_file); 
     640    my $cmd = "/opt/jdk1.6.0/bin/java -cp $classpath:$classpath/xalan.jar ApplyXSLT $target_language_code $gen_many_html_xsl_filepath $target_filepath | perl -S $split_script_filepath $target_file_directory"; 
     641    my $response = `$cmd`; 
     642    &log_message($cmd); 
     643    &log_message($response);     
     644    &log_message("Created HTML operational files"); 
     645     
     646    $cmd = "/opt/jdk1.6.0/bin/java -cp $classpath:$classpath/xalan.jar ApplyXSLT $target_language_code $gen_index_xml_xsl_filepath $target_filepath > " . $target_file_directory . "help_index.xml"; # 2>/dev/null"; 
     647    $response = `$cmd`; 
     648    &log_message($cmd); 
     649    &log_message($response);     
     650    &log_message("Created xml index file"); 
     651 
     652    my $zip_file_path = "/greenstone/custom/gti/" . $target_language_code . "_GLIHelp.zip"; 
     653    $cmd = "zip -rj $zip_file_path $target_file_directory -i \*.htm \*.xml"; 
     654    $response = `$cmd`; 
     655    &log_message($cmd); 
     656    &log_message($response);     
     657    &log_message("Created the zip file"); 
    623658} 
    624659 
     
    767802    my $chunk_cvs_date = $key_to_cvs_date_mapping{$chunk_key}; 
    768803    $key_to_last_update_date_mapping{$chunk_key} = $chunk_cvs_date; 
    769                  
     804 
    770805    # If a comment date exists and it is after the CVS date, use that instead 
    771806        # need to convert the comment date format to SVN format 
     
    773808    if (defined($chunk_gti_comment) && $chunk_gti_comment =~ /(\d?\d-\D\D\D-\d\d\d\d)/) { 
    774809        my $chunk_comment_date = $1;             
    775         if ((!defined($chunk_cvs_date) || &is_date_after($chunk_comment_date, $chunk_cvs_date))) { 
     810        # if the changes were made on 2009 Jan 27, ie. tidying up the GTI commands following each fragment,  
     811        # then should use the GTI comment date instead 
     812        # if ((!defined($chunk_cvs_date) || &is_date_after($chunk_comment_date, $chunk_cvs_date))) { 
     813        if ((!defined($chunk_cvs_date) || &is_date_after($chunk_comment_date, $chunk_cvs_date)  
     814         || (&is_date_after($chunk_cvs_date,$chunk_comment_date) && ($chunk_cvs_date eq "2009-01-27" || $chunk_cvs_date eq "2009-01-28")))) { 
    776815        $key_to_last_update_date_mapping{$chunk_key} = $chunk_comment_date; 
     816         
     817        # &log_message("cvs date: $chunk_cvs_date, comment date: $chunk_comment_date"); 
     818        # die; 
    777819        } 
    778820    } 
     
    10271069 
    10281070 
     1071sub create_xml_response_for_chunks_requiring_work 
     1072{ 
     1073    my ($translation_file_key, $target_file, $total_num_chunks, $target_files_keys_requiring_translation, $target_files_keys_requiring_updating, $num_chunks_to_return, $source_files_key_to_text_mapping, $target_files_key_to_text_mapping, $source_files_key_to_last_update_date_mapping, $target_files_key_to_last_update_date_mapping) = @_; 
     1074 
     1075    # Form an XML response to the command 
     1076    my $xml_response = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"; 
     1077    $xml_response .= "<GTIResponse>\n"; 
     1078    $xml_response .= "  <TranslationFile" 
     1079    . " key=\"" . $translation_file_key . "\"" 
     1080    . " target_file_path=\"" . $target_file . "\"" 
     1081    . " num_chunks_translated=\"" . ($total_num_chunks - scalar(@$target_files_keys_requiring_translation)) . "\"" 
     1082    . " num_chunks_requiring_translation=\"" . scalar(@$target_files_keys_requiring_translation) . "\"" 
     1083    . " num_chunks_requiring_updating=\"" . scalar(@$target_files_keys_requiring_updating) . "\"\/>\n"; 
     1084 
     1085    # Do chunks requiring translation first 
     1086    if ($num_chunks_to_return > scalar(@$target_files_keys_requiring_translation)) { 
     1087    $xml_response .= "  <ChunksRequiringTranslation size=\"" . scalar(@$target_files_keys_requiring_translation) . "\">\n"; 
     1088    } 
     1089    else { 
     1090    $xml_response .= "  <ChunksRequiringTranslation size=\"" . $num_chunks_to_return . "\">\n"; 
     1091    } 
     1092 
     1093    my @sorted_chunk_keys = sort (@$target_files_keys_requiring_translation); 
     1094    foreach my $chunk_key (@sorted_chunk_keys) { 
     1095    last if ($num_chunks_to_return == 0); 
     1096 
     1097    my $source_file_chunk_date = $source_files_key_to_last_update_date_mapping->{$chunk_key} || ""; 
     1098    my $source_file_chunk_text = &make_text_xml_safe($source_files_key_to_text_mapping->{$chunk_key});   
     1099     
     1100    $xml_response .= "    <Chunk key=\"" . &make_text_xml_safe($chunk_key) . "\">\n"; 
     1101    $xml_response .= "      <SourceFileText date=\"$source_file_chunk_date\">$source_file_chunk_text</SourceFileText>\n";    
     1102    $xml_response .= "      <TargetFileText></TargetFileText>\n"; 
     1103    $xml_response .= "    </Chunk>\n"; 
     1104 
     1105    $num_chunks_to_return--; 
     1106    } 
     1107 
     1108    $xml_response .= "  </ChunksRequiringTranslation>\n"; 
     1109 
     1110    # Then do chunks requiring updating 
     1111    if ($num_chunks_to_return > scalar(@$target_files_keys_requiring_updating)) { 
     1112    $xml_response .= "  <ChunksRequiringUpdating size=\"" . scalar(@$target_files_keys_requiring_updating) . "\">\n"; 
     1113    } 
     1114    else { 
     1115    $xml_response .= "  <ChunksRequiringUpdating size=\"" . $num_chunks_to_return . "\">\n"; 
     1116    } 
     1117         
     1118    # foreach my $chunk_key (@target_file_keys_requiring_updating) { 
     1119    @sorted_chunk_keys = sort (@$target_files_keys_requiring_updating); 
     1120    foreach my $chunk_key (@sorted_chunk_keys) { 
     1121    last if ($num_chunks_to_return == 0); 
     1122 
     1123    my $source_file_chunk_date = $source_files_key_to_last_update_date_mapping->{$chunk_key} || ""; 
     1124    my $source_file_chunk_text = &make_text_xml_safe($source_files_key_to_text_mapping->{$chunk_key}); 
     1125    my $target_file_chunk_date = $target_files_key_to_last_update_date_mapping->{$chunk_key} || ""; 
     1126    my $target_file_chunk_text = &make_text_xml_safe($target_files_key_to_text_mapping->{$chunk_key}); 
     1127 
     1128    $xml_response .= "    <Chunk key=\"" . &make_text_xml_safe($chunk_key) . "\">\n";    
     1129    $xml_response .= "      <SourceFileText date=\"$source_file_chunk_date\">$source_file_chunk_text</SourceFileText>\n"; 
     1130    $xml_response .= "      <TargetFileText date=\"$target_file_chunk_date\">$target_file_chunk_text</TargetFileText>\n"; 
     1131    $xml_response .= "    </Chunk>\n"; 
     1132 
     1133    $num_chunks_to_return--; 
     1134    } 
     1135 
     1136    $xml_response .= "  </ChunksRequiringUpdating>\n"; 
     1137 
     1138    $xml_response .= "</GTIResponse>\n"; 
     1139 
     1140    return $xml_response; 
     1141} 
     1142 
     1143 
     1144sub create_xml_response_for_all_chunks 
     1145{ 
     1146    my ($translation_file_key, $target_file, $source_file_key_to_text_mapping, $target_file_key_to_text_mapping, $source_file_key_to_last_update_date_mapping, $target_file_key_to_last_update_date_mapping) = @_; 
     1147 
     1148    # Form an XML response to the command 
     1149    my $xml_response = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"; 
     1150    $xml_response .= "<GTIResponse>\n"; 
     1151    $xml_response .= "  <TranslationFile" 
     1152    . " key=\"" . $translation_file_key . "\"" 
     1153    . " target_file_path=\"" . $target_file . "\"\/>\n"; 
     1154     
     1155    # Do all the chunks 
     1156    $xml_response .= "  <Chunks size=\"" . scalar(keys(%$source_file_key_to_text_mapping)) . "\">\n"; 
     1157 
     1158    my @sorted_chunk_keys = sort (keys(%$source_file_key_to_text_mapping)); 
     1159    foreach my $chunk_key (@sorted_chunk_keys) { 
     1160    my $source_file_chunk_date = $source_file_key_to_last_update_date_mapping->{$chunk_key} || ""; 
     1161    my $source_file_chunk_text = &make_text_xml_safe($source_file_key_to_text_mapping->{$chunk_key}); 
     1162 
     1163    $xml_response .= "    <Chunk key=\"" . &make_text_xml_safe($chunk_key) . "\">\n"; 
     1164    $xml_response .= "      <SourceFileText date=\"$source_file_chunk_date\">$source_file_chunk_text</SourceFileText>\n"; 
     1165    if (defined($target_file_key_to_text_mapping->{$chunk_key})) { 
     1166        my $target_file_chunk_date = $target_file_key_to_last_update_date_mapping->{$chunk_key} || ""; 
     1167        my $target_file_chunk_text = &make_text_xml_safe($target_file_key_to_text_mapping->{$chunk_key}); 
     1168        $xml_response .= "      <TargetFileText date=\"$target_file_chunk_date\">$target_file_chunk_text</TargetFileText>\n"; 
     1169    } 
     1170    else { 
     1171        $xml_response .= "      <TargetFileText></TargetFileText>\n"; 
     1172    } 
     1173 
     1174    $xml_response .= "    </Chunk>\n"; 
     1175    } 
     1176    $xml_response .= "  </Chunks>\n"; 
     1177     
     1178    $xml_response .= "</GTIResponse>\n"; 
     1179    return $xml_response; 
     1180} 
     1181 
     1182 
     1183 
    10291184# ========================================================================================== 
    10301185#   MACROFILE FUNCTIONS 
     
    12651420 
    12661421    # Line contains a dictionary string 
    1267     if ($line =~ /^(\S+?):(.*)$/) { 
     1422    if ($line =~ /^(\S+?)[:|=](.*)$/) { 
    12681423        my $chunk_key = $1; 
    12691424 
     
    12821437 
    12831438    # Simple: just remove string key 
    1284     $chunk_text =~ s/^(\S+?):(\s*)//; 
     1439    $chunk_text =~ s/^(\S+?)[:|=](\s*)//; 
    12851440    $chunk_text =~ s/(\s*)$//;  # Remove any nasty whitespace, carriage returns etc. 
    12861441    $chunk_text =~ s/(\s*)\#\s+Updated\s+(\d?\d-\D\D\D-\d\d\d\d.*)\s*$//i; 
     
    15101665 
    15111666 
     1667# ========================================================================================== 
     1668#   GREENSTONE3 FUNCTIONS 
     1669 
     1670sub get_all_chunks_for_gs3 
     1671{ 
     1672    # The code of the target language (ensure it is lowercase) 
     1673    my $target_language_code = lc(shift(@_)); 
     1674    my $translation_file_key = lc(shift(@_)); 
     1675 
     1676    # Check that the necessary arguments were supplied 
     1677    if (!$target_language_code) { 
     1678    &throw_fatal_error("Missing command argument."); 
     1679    } 
     1680 
     1681    # Get (and check) the translation configuration 
     1682    # my ($source_file_dir, $target_file, $translation_file_type) = &get_translation_configuration($target_language_code, $translation_file_key); 
     1683     
     1684    my %source_files_key_to_text_mapping = (); 
     1685    my %target_files_key_to_text_mapping = (); 
     1686    my %source_files_key_to_last_update_date_mapping = (); 
     1687    my %target_files_key_to_last_update_date_mapping = (); 
     1688 
     1689    &build_gs3_configuration($target_language_code, \%source_files_key_to_text_mapping, \%target_files_key_to_text_mapping, \%source_files_key_to_last_update_date_mapping, \%target_files_key_to_last_update_date_mapping); 
     1690 
     1691    &log_message("Total number of source chunks: " . scalar(keys(%source_files_key_to_text_mapping))); 
     1692    &log_message("Total number of target chunks: " . scalar(keys(%target_files_key_to_text_mapping))); 
     1693 
     1694    my $xml_response = &create_xml_response_for_all_chunks($translation_file_key, "", \%source_files_key_to_text_mapping, \%target_files_key_to_text_mapping, \%source_files_key_to_last_update_date_mapping, \%target_files_key_to_last_update_date_mapping);    
     1695    return $xml_response; 
     1696} 
     1697 
     1698 
     1699sub get_first_n_chunks_requiring_work_for_gs3 
     1700{ 
     1701    # The code of the target language (ensure it is lowercase) 
     1702    my $target_language_code = lc(shift(@_)); 
     1703    # The key of the file to translate (ensure it is lowercase) 
     1704    my $translation_file_key = lc(shift(@_)); 
     1705    # The number of chunks to return (defaults to one if not specified) 
     1706    my $num_chunks_to_return = shift(@_) || "1"; 
     1707     
     1708    # Check that the necessary arguments were supplied 
     1709    if (!$target_language_code || !$translation_file_key) { 
     1710    &throw_fatal_error("Missing command argument."); 
     1711    } 
     1712     
     1713    my %source_files_key_to_text_mapping = (); 
     1714    my %target_files_key_to_text_mapping = (); 
     1715    my %source_files_key_to_last_update_date_mapping = (); 
     1716    my %target_files_key_to_last_update_date_mapping = (); 
     1717 
     1718    &build_gs3_configuration($target_language_code, \%source_files_key_to_text_mapping, \%target_files_key_to_text_mapping,  
     1719                 \%source_files_key_to_last_update_date_mapping, \%target_files_key_to_last_update_date_mapping); 
     1720     
     1721    # Determine the target file chunks requiring translation 
     1722    my @target_files_keys_requiring_translation = &determine_chunks_requiring_translation(\%source_files_key_to_text_mapping, \%target_files_key_to_text_mapping);     
     1723    # Determine the target file chunks requiring updating 
     1724    my @target_files_keys_requiring_updating = &determine_chunks_requiring_updating(\%source_files_key_to_last_update_date_mapping, \%target_files_key_to_last_update_date_mapping); 
     1725    &log_message("Total number of target chunks requiring translation: " . scalar(@target_files_keys_requiring_translation)); 
     1726    &log_message("Total number of target chunks requiring updating: " . scalar(@target_files_keys_requiring_updating)); 
     1727 
     1728    my $xml_response = &create_xml_response_for_chunks_requiring_work($translation_file_key, "", scalar(keys(%source_files_key_to_text_mapping)), 
     1729                                      \@target_files_keys_requiring_translation, \@target_files_keys_requiring_updating, 
     1730                                      $num_chunks_to_return, \%source_files_key_to_text_mapping, \%target_files_key_to_text_mapping, 
     1731                                      \%source_files_key_to_last_update_date_mapping, \%target_files_key_to_last_update_date_mapping); 
     1732    
     1733    return $xml_response; 
     1734} 
     1735 
     1736 
     1737 
     1738sub build_gs3_configuration 
     1739{ 
     1740    my ($target_language_code, $source_files_key_to_text_mapping, $target_files_key_to_text_mapping, 
     1741    $source_files_key_to_gti_comment_mapping, $target_files_key_to_gti_comment_mapping) = @_; 
     1742     
     1743    my $source_file_directory = "greenstone3"; 
     1744    my $translation_file_type = "resource_bundle"; 
     1745 
     1746    foreach my $interface_file_key (@gs3_interface_files) { 
     1747 
     1748    &log_message("Greenstone 3 interface file: " . $interface_file_key); 
     1749 
     1750    # Parse the source language and target language files 
     1751    my $source_file = &util::filename_cat($source_file_directory, $interface_file_key.".properties"); 
     1752    my @source_file_lines = &read_file_lines(&util::filename_cat($gsdl_root_directory, $source_file)); 
     1753    my %source_file_key_to_line_mapping = &build_key_to_line_mapping(\@source_file_lines, $translation_file_type); 
     1754    my %source_file_key_to_text_mapping = &build_key_to_text_mapping(\@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type); 
     1755    my %source_file_key_to_gti_comment_mapping = &build_key_to_gti_comment_mapping(\@source_file_lines, \%source_file_key_to_line_mapping, $translation_file_type);  
     1756     
     1757    my $target_file = &util::filename_cat($source_file_directory, $interface_file_key."_".$target_language_code.".properties"); 
     1758    my @target_file_lines = &read_file_lines(&util::filename_cat($gsdl_root_directory, $target_file)); 
     1759    my %target_file_key_to_line_mapping = &build_key_to_line_mapping(\@target_file_lines, $translation_file_type); 
     1760    my %target_file_key_to_text_mapping = &build_key_to_text_mapping(\@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
     1761    my %target_file_key_to_gti_comment_mapping = &build_key_to_gti_comment_mapping(\@target_file_lines, \%target_file_key_to_line_mapping, $translation_file_type); 
     1762 
     1763 
     1764    # Filter out any automatically translated chunks 
     1765    foreach my $chunk_key (keys(%source_file_key_to_line_mapping)) { 
     1766        if (&is_chunk_automatically_translated($chunk_key, $translation_file_type)) { 
     1767        delete $source_file_key_to_line_mapping{$chunk_key}; 
     1768        delete $target_file_key_to_line_mapping{$chunk_key}; 
     1769        } 
     1770    } 
     1771 
     1772    &log_message("Number of source chunks: " . scalar(keys(%source_file_key_to_text_mapping))); 
     1773    &log_message("Number of target chunks: " . scalar(keys(%target_file_key_to_text_mapping))); 
     1774 
     1775    foreach my $chunk_key (keys(%source_file_key_to_text_mapping)) { 
     1776        my $global_chunk_key = "$interface_file_key.$chunk_key"; 
     1777        $source_files_key_to_text_mapping->{$global_chunk_key} = $source_file_key_to_text_mapping{$chunk_key}; 
     1778        $source_files_key_to_gti_comment_mapping->{$global_chunk_key} = $source_file_key_to_gti_comment_mapping{$chunk_key}; 
     1779 
     1780        if (defined $target_file_key_to_text_mapping{$chunk_key}) { 
     1781        $target_files_key_to_text_mapping->{$global_chunk_key} = $target_file_key_to_text_mapping{$chunk_key}; 
     1782        $target_files_key_to_gti_comment_mapping->{$global_chunk_key} = $target_file_key_to_gti_comment_mapping{$chunk_key}; 
     1783        } 
     1784    }    
     1785    } 
     1786} 
     1787 
     1788 
     1789sub write_translated_gs3interface 
     1790{ 
     1791    my $source_file_key_to_text_mapping = shift(@_); 
     1792    my $target_file_key_to_text_mapping = shift(@_); 
     1793    my $target_file_key_to_gti_comment_mapping = shift(@_); 
     1794    my $target_language_code = shift(@_); 
     1795     
     1796    my @sorted_chunk_keys = sort (keys(%$source_file_key_to_text_mapping)); 
     1797 
     1798    my %translated_interface_file_keys = (); 
     1799    foreach my $chunk_key (keys(%$target_file_key_to_text_mapping)) { 
     1800    $chunk_key =~ /^([^\.]+)?\.(.*)$/; 
     1801    if (!defined $translated_interface_file_keys{$1}) { 
     1802        &log_message("Updated interface file: " . $1);   
     1803        $translated_interface_file_keys{$1}=""; 
     1804    } 
     1805    } 
     1806    &log_message("Updated interface files: " . scalar(keys(%translated_interface_file_keys))); 
     1807     
     1808    my $source_file_directory = "greenstone3";     
     1809     
     1810    foreach my $interface_file_key (keys(%translated_interface_file_keys)) { 
     1811     
     1812    # Build a mapping from chunk key to source file line, and from source file line to chunk key 
     1813    my $source_file = &util::filename_cat($source_file_directory, "$interface_file_key.properties"); 
     1814    my @source_file_lines = &read_file_lines(&util::filename_cat($gsdl_root_directory, $source_file)); 
     1815    my %source_file_key_to_line_mapping = &build_key_to_line_mapping_for_resource_bundle(@source_file_lines); 
     1816    my %source_file_line_to_key_mapping = (); 
     1817    foreach my $chunk_key (keys(%source_file_key_to_line_mapping)) { 
     1818        $source_file_line_to_key_mapping{$source_file_key_to_line_mapping{$chunk_key}} = $chunk_key; 
     1819    } 
     1820     
     1821    # Write the new target file 
     1822    my $target_file = &util::filename_cat($source_file_directory, $interface_file_key . "_" . $target_language_code . ".properties"); 
     1823    my $target_file_path = &util::filename_cat($gsdl_root_directory, $target_file); 
     1824    if (!open(TARGET_FILE, ">$target_file_path")) { 
     1825        &throw_fatal_error("Could not write target file $target_file_path."); 
     1826    } 
     1827 
     1828    # Model the new target file on the source file, with the target file translations 
     1829    my $source_file_line_number = 0; 
     1830    foreach my $line_key (sort sort_by_line (keys(%source_file_line_to_key_mapping))) { 
     1831        # Fill in the gaps before this chunk starts 
     1832        my $source_file_chunk_starting_line_number = (split(/-/, $line_key))[0]; 
     1833        my $source_file_chunk_finishing_line_number = (split(/-/, $line_key))[1]; 
     1834        while ($source_file_line_number < $source_file_chunk_starting_line_number) { 
     1835        print TARGET_FILE $source_file_lines[$source_file_line_number]; 
     1836        $source_file_line_number++; 
     1837        } 
     1838        $source_file_line_number = $source_file_chunk_finishing_line_number + 1; 
     1839 
     1840        my $chunk_key = $source_file_line_to_key_mapping{$line_key}; 
     1841        my $global_chunk_key = "$interface_file_key.$chunk_key"; 
     1842        my $source_file_chunk_text = $source_file_key_to_text_mapping->{$global_chunk_key}; 
     1843        my $target_file_chunk_text = $target_file_key_to_text_mapping->{$global_chunk_key} || ""; 
     1844 
     1845        # If no translation exists for this chunk, show this, and move on 
     1846        if ($source_file_chunk_text ne "" && $target_file_chunk_text eq "") { 
     1847        print TARGET_FILE "# -- Missing translation: $chunk_key\n"; 
     1848        next; 
     1849        } 
     1850 
     1851        print TARGET_FILE "$chunk_key:$target_file_chunk_text"; 
     1852        if ($target_file_key_to_gti_comment_mapping->{$global_chunk_key}) { 
     1853        print TARGET_FILE "  # " . $target_file_key_to_gti_comment_mapping->{$global_chunk_key}; 
     1854        } 
     1855        print TARGET_FILE "\n"; 
     1856    } 
     1857 
     1858    close(TARGET_FILE);  
     1859    }            
     1860} 
     1861 
    15121862&main(@ARGV); 
  • gsdl/trunk/macros/english2.dm

    r18055 r18460  
    10961096_textgtitutorials_ {Tutorial Exercises} 
    10971097_textgtigreenorg_ {Greenstone.org} 
    1098 _textgtigs3core_ {Greenstone3 Interface (Default)} 
     1098_textgtigs3interface_ {Greenstone3 Interface} 
    10991099 
    11001100#for greenstone manuals 
     
    11371137 
    11381138<ol> 
    1139 <li>Download <a href="_gwcgi_?a=gti&amp;p=excel&amp;e=_compressedoptions_">this file</a>. 
     1139<li>Download either <a href="_gwcgi_?a=gti&amp;p=excel&amp;tct=work&amp;e=_compressedoptions_">this file</a> for all the remaining work, or <a href="_gwcgi_?a=gti&amp;p=excel&amp;tct=all&amp;e=_compressedoptions_">this file</a> for all the strings in this module. 
    11401140<li>Open the downloaded file in Microsoft Excel (Office 2003/XP or more recent versions is required) and save as Microsoft Excel workbook (.xls) format. 
    11411141<li>Enter the translations in the boxes provided. 
  • gsdl/trunk/macros/gti.dm

    r18430 r18460  
    179179     <a href="_gwcgi_?a=gti&amp;p=find&amp;e=_compressedoptions_">_textgticorrectexistingtranslations_</a><br> 
    180180     _If_(_4_ eq _gtidownloadglihelp, <a href="_4_">, <a href="_httpprefix_/_4_">)_textgtidownloadtargetfile_</a> 
    181      _If_(_gtiglihelpzipfilepath_ eq "disabled", <a href="_gwcgi_?a=gti&amp;p=glihelp&amp;e=_compressedoptions_">_textgtiglihelpzipfile_</a>, <a href="_httpprefix_/_gtiglihelpzipfilepath_">_gtiglihelpzipfilepath_ Reday to download</a>)<br> 
     181 
     182     _If_(_gtiglihelpzipfilepath_, <a href="_httpprefix_/_gtiglihelpzipfilepath_">_textgtiglihelpzipfile_</a>,)<br> 
     183 
    182184     <a href="_gwcgi_?a=gti&amp;p=offline&amp;e=_compressedoptions_">_textgtitranslatefileoffline_</a><br> 
    183185     _gtiviewtranslationfileinaction_ 
     
    186188} 
    187189 
    188 _gtiglihelpzipfilepath_ {disabled} 
    189  
    190 _textgtiglihelpzipfile_ {Download the zipped GLI Help operational files} 
     190_gtiglihelpzipfilepath_ {} 
     191 
     192_textgtiglihelpzipfile_ {Clicke here to download the operational files for GLI Help} 
    191193 
    192194# -------------------------------------------------------------------------------- 
  • gsdl/trunk/runtime-src/src/recpt/gtiaction.cpp

    r17545 r18460  
    192192   
    193193  // Define the page content for the GTI view status page 
    194     if (args["p"] == "status") { 
    195         define_gti_status_page(disp, args, logout); 
    196         return; 
    197     } 
     194  if (args["p"] == "status") { 
     195    define_gti_status_page(disp, args, logout); 
     196    return; 
     197  } 
    198198 
    199199  // Process user translations 
    200200  if (args["p"] == "submit") { 
    201201    process_gti_submissions(disp, args, logout, true); 
     202  } 
     203 
     204  if (args["p"] == "glihelp") { 
     205    produce_glihelp_zipfile(disp, args, logout);     
    202206  } 
    203207     
     
    335339         
    336340         
    337         //lang_status_temp += "<td valign=\"top\" nowrap>_gtitranslationfilestatus2_(" + num_chunks_translated + "," + num_chunks_requiring_translation + "," + num_chunks_requiring_updating + ")</td>";            
     341    //lang_status_temp += "<td valign=\"top\" nowrap>_gtitranslationfilestatus2_(" + num_chunks_translated + "," + num_chunks_requiring_translation + "," + num_chunks_requiring_updating + ")</td>";            
    338342         
    339         // List the file names as the first row of the status table  
    340         // Add up number of strings need to be translate in each file, as the second line of the status table 
     343    // List the file names as the first row of the status table  
     344    // Add up number of strings need to be translate in each file, as the second line of the status table 
    341345      if (first_lang) { 
    342346        files_temp += "<th class=\"status\">_textgti" + translation_file_key + "_</th>\n"; 
     
    484488  languageinfo_tmap loaded_languages = recpt->get_configinfo().languages; 
    485489  disp.setmacro("gtitargetlanguagename", "gti", loaded_languages[target_language_code].longname); 
    486   disp.setmacro("gtitargetfilepath", "gti", gti_response.translation_files_key_to_target_file_path_mapping[translation_file_key]); 
     490  if (translation_file_key == "glihelp") { 
     491    disp.setmacro("gtitargetfilepath", "gti", "_gtidownloadglihelp_"); 
     492  } else { 
     493    disp.setmacro("gtitargetfilepath", "gti", gti_response.translation_files_key_to_target_file_path_mapping[translation_file_key]); 
     494  } 
    487495  disp.setmacro("gtitranslationfiledesc", "gti", "_gti:textgti" + translation_file_key + "_"); 
    488496  disp.setmacro("gtiviewtranslationfileinaction", "gti", "_gti:gtiview" + translation_file_key + "inaction_"); 
     
    618626  text_t target_language_code = args["tlc"]; 
    619627  text_t translation_file_key = args["tfk"]; 
     628  text_t target_chunk_type = args["tct"]; 
    620629 
    621630  // Send a request to gti.pl to get the Excel spreadsheet data 
    622   text_t gti_arguments = "get-first-n-chunks-requiring-work " + target_language_code + " " + translation_file_key + " " + "10000" + " | java -cp /home/nzdl/gti ApplyXSLT /home/nzdl/gti/gti-generate-excel-xml.xsl -"; 
    623   text_t gti_response_xml_text = do_gti_request(gti_arguments, logout); 
     631  text_t gti_arguments = ""; 
     632  if (target_chunk_type == "work") { 
     633    gti_arguments = "get-first-n-chunks-requiring-work " + target_language_code + " " + translation_file_key + " " + "10000" + " | /opt/jdk1.6.0/bin/java -cp /home/nzdl/gti:/home/nzdl/gti/xalan.jar ApplyXSLT /home/nzdl/gti/gti-generate-excel-xml.xsl -"; 
     634  } else { 
     635    gti_arguments = "get-all-chunks " + target_language_code + " " + translation_file_key + " | /opt/jdk1.6.0/bin/java -cp /home/nzdl/gti:/home/nzdl/gti/xalan.jar ApplyXSLT /home/nzdl/gti/gti-generate-excel-xml.xsl -"; 
     636  } 
     637   
     638  text_t gti_response_xml_text = do_gti_request(gti_arguments, logout);   
    624639  if (gti_response_xml_text == "") { 
    625640    // An error has occurred 
     
    635650} 
    636651 
     652bool gtiaction::produce_glihelp_zipfile(displayclass& disp, cgiargsclass& args, ostream& logout) 
     653{ 
     654 text_t target_language_code = args["tlc"]; 
     655 text_t gti_arguments = "create-glihelp-zip-file " + target_language_code; 
     656 
     657 do_gti_request(gti_arguments, logout);  
     658 
     659 disp.setmacro("gtiglihelpzipfilepath", "gti", target_language_code + "_GLIHelp.zip"); 
     660 
     661 return true; 
     662} 
    637663 
    638664 
  • gsdl/trunk/runtime-src/src/recpt/gtiaction.h

    r17545 r18460  
    118118 
    119119  bool produce_excel_spreadsheet(cgiargsclass& args, ostream& logout); 
     120 
     121  bool produce_glihelp_zipfile(displayclass& disp, cgiargsclass& args, ostream& logout); 
    120122}; 
    121123