/[webpac]/trunk2/all2xml.pl
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk2/all2xml.pl

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 29 by dpavlin, Sun Feb 23 07:08:54 2003 UTC revision 170 by dpavlin, Sun Nov 23 15:42:16 2003 UTC
# Line 8  use XML::Simple; Line 8  use XML::Simple;
8  use Text::Unaccent 1.02;        # 1.01 won't compile on my platform,  use Text::Unaccent 1.02;        # 1.01 won't compile on my platform,
9  use Text::Iconv;  use Text::Iconv;
10  use Config::IniFiles;  use Config::IniFiles;
11    use Encode;
12    
13  $|=1;  $|=1;
14    
# Line 17  die "FATAL: can't find configuration fil Line 18  die "FATAL: can't find configuration fil
18    
19  my $config;  my $config;
20    
21  use index_DBI;  # there is no other, right now ;-)  #use index_DBI;         # default DBI module for index
22    use index_DBI_cache;    # faster DBI module using memory cache
23  my $index = new index_DBI();    # open index  my $index;
24    
25  my %opts;  my %opts;
26    
# Line 31  my %opts; Line 32  my %opts;
32    
33  getopts('d:m:qs', \%opts);  getopts('d:m:qs', \%opts);
34    
35  my $db_dir;  my $path;       # this is name of database
36    
37  #die "usage: $0 -d [database_dir] -m [database1,database2] " if (! %opts);  Text::Iconv->raise_error(0);     # Conversion errors don't raise exceptions
38    
39  #print Dumper($config->{indexer});  # this is encoding of all files on disk, including import_xml/*.xml file and
40  #print "-" x 70,"\n";  # filter/*.pm files! It will be used to store strings in perl internally!
41    my $codepage = 'ISO-8859-2';
42    
43    my $utf2cp = Text::Iconv->new('UTF-8',$codepage);
44    # this function will convert data from XML files to local encoding
45    sub x {
46            return $utf2cp->convert($_[0]);
47    }
48    
49  Text::Iconv->raise_error(1);     # Conversion errors raise exceptions  # decode isis/excel or other import codepage
50    my $import2cp;
51    
52  my $isis_codepage;  # outgoing xml must be in UTF-8
53  my $index_codepage;  my $cp2utf = Text::Iconv->new($codepage,'UTF-8');
 my $cludge_codepage = Text::Iconv->new('UTF8','ISO8859-1');  
 my $xml_codepage;  
54    
55  my $XML_CHARSET = 'UTF8';  # mapping between data type and tag which specify
56    # format in XML file
57    my %type2tag = (
58            'isis' => 'isis',
59            'excel' => 'column',
60            'marc' => 'marc',
61            'feed' => 'feed'
62    );
63    
64    my $cache;      # for cacheing
65    
66  sub isis2xml {  sub data2xml {
67    
68          use xmlify;          use xmlify;
69    
70            my $type = shift @_;
71          my $row = shift @_;          my $row = shift @_;
72          my $add_xml = shift @_;          my $add_xml = shift @_;
73            # needed to read values from configuration file
74            my $cfg = shift @_;
75            my $database = shift @_;
76    
77          my $xml;          my $xml;
78    
# Line 63  sub isis2xml { Line 82  sub isis2xml {
82    
83          my %field_usage;        # counter for usage of each field          my %field_usage;        # counter for usage of each field
84    
85            # sort subrouting using order="" attribute
86            sub by_order {
87                    my $va = $config->{indexer}->{$a}->{order} ||
88                            $config->{indexer}->{$a};
89                    my $vb = $config->{indexer}->{$b}->{order} ||
90                            $config->{indexer}->{$b};
91    
92                    return $va <=> $vb;
93            }
94    
95            my @sorted_tags;
96            if ($cache->{tags_by_order}->{$type}) {
97                    @sorted_tags = @{$cache->{tags_by_order}->{$type}};
98            } else {
99                    @sorted_tags = sort by_order keys %{$config->{indexer}};
100                    $cache->{tags_by_order}->{$type} = \@sorted_tags;
101            }
102    
103          foreach my $field (keys %{$config->{indexer}}) {          foreach my $field (@sorted_tags) {
104    
105                    $field=x($field);
106                  $field_usage{$field}++;                  $field_usage{$field}++;
107    
108                  my $swish_data = "";                  my $swish_data = "";
109                    my $swish_exact_data = "";
110                  my $display_data = "";                  my $display_data = "";
111                  my $line_delimiter = "";                  my $line_delimiter;
112    
113                  foreach my $x (@{$config->{indexer}->{$field}->{isis}}) {                  my ($swish,$display);
114    
115                          my $format = $x->{content};                  my $tag = $type2tag{$type} || die "can't find which tag to use for type $type";
116                          my $delimiter = $x->{delimiter} || ' ';                  foreach my $x (@{$config->{indexer}->{$field}->{$tag}}) {
117    
118                          # FIX: this is ugly, UGLY, cludge string is returned                          my $format = x($x->{content});
119                          # in UTF8 encoding , but as if source charset                          my $delimiter = x($x->{delimiter}) || ' ';
                         # is ISO8859-1 and not some other. This break other  
                         # character encodings, so we convert it first  
                         # back to ISO8859-1  
                         $format = $xml_codepage->convert($format);  
                         $delimiter = $xml_codepage->convert($delimiter) if ($delimiter);  
120    
121                          my $isis_i = 0;         # isis repeatable offset                          my $repeat_off = 0;             # repeatable offset
122    
123                          my ($s,$d,$i) = (1,1,0);        # swish, display default                          my ($s,$se,$d,$i) = (1,0,1,0);  # swish, display default
124                          $s = 0 if (lc($x->{type}) eq "display");                          $s = 0 if (lc($x->{type}) eq "display");
125                          $d = 0 if (lc($x->{type}) eq "swish");                          $d = 0 if (lc($x->{type}) eq "swish");
126                            $se = 1 if (lc($x->{type}) eq "swish_exact");
127                          ($s,$d,$i) = (0,0,1) if (lc($x->{type}) eq "index");                          ($s,$d,$i) = (0,0,1) if (lc($x->{type}) eq "index");
 #print STDERR "## s: $s d: $d i: $i ## $format ##\n";    
128    
129                          $display_data .= $line_delimiter if ($display_data && $display_data !~ /$line_delimiter$/);                          # what will separate last line from this one?
130                            if ($display_data && $x->{append} && $x->{append} eq "1") {
131                                    $line_delimiter = ' ';
132                            } elsif ($display_data) {
133                                    $line_delimiter = '<br/>';
134                            }
135    
136                          my ($swish,$display) = (1,1);                          # init vars so that we go into while...
137                            ($swish,$display) = (1,1);
138    
139                          while ($swish || $display) {                          # placeholder for all repeatable entries for index
140                                  ($swish,$display) = parse_format($format,$row,$isis_i++);                          my @index_data;
141  #print STDERR "s: $swish\nd: $display\n" if ($swish);                          my $index_filter;
142    
143                            sub mkformat {
144                                    my $x = shift || die "mkformat needs tag reference";
145                                    my $data = shift || return;
146                                    my $format_name = x($x->{format_name}) || return $data;
147                                    my $fmt = x($config->{format}->{$format_name}->{content}) || die "<format name=\"$format_name\"> is not defined!";
148                                    my $format_delimiter = x($x->{format_delimiter});
149                                    my @data;
150                                    if ($format_delimiter) {
151                                            @data = split(/$format_delimiter/,$data);
152                                    } else {
153                                            push @data,$data;
154                                    }
155    
156  #print STDERR "swish: $swish<-- display: $display<--\n";                                  if ($fmt) {
157                                            my $nr = scalar $fmt =~ s/%s/%s/g;
158                                            if (($#data+1) == $nr) {
159                                                    return sprintf($fmt,@data);
160                                            } else {
161                                                    print STDERR "mkformat: [$data] can't be split on [$format_delimiter] to $nr fields!\n";
162                                                    return $data;
163                                            }
164                                    } else {
165                                            print STDERR "usage of link '$format_name' without defined format (<link> tag)\n";
166                                    }
167                            }
168    
169                            # while because of repeatable fields
170                            while ($swish || $display) {
171                                    ($swish,$display) = parse_format($type, $format,$row,$repeat_off++,$import2cp);
172                                    if ($repeat_off > 1000) {
173                                            print STDERR "loop (more than 1000 repeatable fields) deteced in $row, $format\n";
174                                            last;
175                                    }
176                                    
177                                  # filter="name" ; filter this field through                                  # filter="name" ; filter this field through
178                                  # filter/[name].pm                                  # filter/[name].pm
179                                  my $filter = $x->{filter};                                  my $filter = $x->{filter};
180                                  if ($filter) {                                  if ($filter && !$cache->{filter_loaded}->{$filter}) {
181                                          require "filter/".$filter.".pm";                                          require "filter/".$filter.".pm";
182                                            $cache->{filter_loaded}->{$filter}++;
183                                  }                                  }
184                                  # type="swish" ; field for swish                                  # type="swish" ; field for swish
185                                  if ($s && $swish) {                                  if ($swish) {
186                                          if ($filter) {                                          if ($filter && ($s || $se)) {
 print STDERR "using filter '$filter'\n";  
187                                                  no strict 'refs';                                                  no strict 'refs';
188                                                  $swish_data .= join(" ",&$filter($swish));                                                  my $tmp = join(" ",&$filter($swish)) if ($s || $se);
189                                                    $swish_data .= $tmp if ($s);
190                                                    $swish_exact_data .= $tmp if ($se);
191    
192                                          } else {                                          } else {
193                                                  $swish_data .= $swish;                                                  $swish_data .= $swish if ($s);
194                                                    $swish_exact_data .= $swish if ($se);
195                                          }                                          }
196                                  }                                  }
197    
198                                  # type="display" ; field for display                                  # type="display" ; field for display
199                                  if ($d && $display) {                                  if ($d && $display) {
200                                            if ($line_delimiter && $display_data) {
201                                                    $display_data .= $line_delimiter;
202                                                    undef $line_delimiter;
203                                            }
204                                          if ($filter) {                                          if ($filter) {
205                                                  no strict 'refs';                                                  no strict 'refs';
206                                                  $display_data .= join($delimiter,&$filter($display));                                                  if ($display_data) {
207                                                            $display_data .= $delimiter.join($delimiter,mkformat($x,&$filter($display)));
208                                                    } else {
209                                                            $display_data = join($delimiter,mkformat($x,&$filter($display)));
210                                                    }
211                                          } else {                                          } else {
212                                                  if ($display_data) {                                                  if ($display_data) {
213                                                          $display_data .= $delimiter.$display;                                                          $display_data .= $delimiter.mkformat($x,$display);
214                                                  } else {                                                  } else {
215                                                          $display_data .= $display;                                                          $display_data = mkformat($x,$display);
216                                                  }                                                  }
217                                          }                                          }
218                                  }                                  }
219                                                                                                    
220                                  # type="index" ; insert into index                                  # type="index" ; insert into index
221                                  if ($i && $display) {                                  if ($i && $display) {
222                                          my $index_data = $index_codepage->convert($display) || $display;                                          push @index_data, $display;
223                                          if ($filter) {                                          $index_filter = $filter if ($filter);
                                                 no strict 'refs';  
                                                 foreach my $d (&$filter($index_data)) {  
                                                         $index->insert($field, $d, $db_dir);  
                                                 }  
                                         } else {  
                                                 $index->insert($field, $index_data, $db_dir);  
                                         }  
224                                  }                                  }
225                          }                          }
226                          if ($x->{append}) {  
227                                  $line_delimiter = ' ';                          # fill data in index
228                          } else {                          if (@index_data) {
229                                  $line_delimiter = '<br/>';                                  if ($index_filter) {
230                                            no strict 'refs';
231                                            foreach my $d (@index_data) {
232                                                    $index->insert($field, &$index_filter($d), $path);
233                                            }
234                                    } else {
235                                            foreach my $d (@index_data) {
236                                                    $index->insert($field, $d, $path);
237                                            }
238                                    }
239                          }                          }
240                  }                  }
241    
242                    # now try to parse variables from configuration file
243                    foreach my $x (@{$config->{indexer}->{$field}->{'config'}}) {
244    
245  #print STDERR "s_d: $swish_data\nd_d: $display_data\n" if ($swish_data);                          my $delimiter = x($x->{delimiter}) || ' ';
246                  if ($display_data) {                          my $val = $cfg->val($database, x($x->{content}));
247    
248                            my ($s,$d,$i) = (1,1,0);        # swish, display default
249                            $s = 0 if (lc($x->{type}) eq "display");
250                            $d = 0 if (lc($x->{type}) eq "swish");
251                            # no support for swish exact in config.
252                            # IMHO, it's useless
253                            ($s,$d,$i) = (0,0,1) if (lc($x->{type}) eq "index");
254    
255                            if ($val) {
256                                    $display_data .= $delimiter.$val if ($d);
257                                    $swish_data .= $val if ($s);
258                                    $index->insert($field, $val, $path) if ($i);
259                            }
260    
261                    }
262    
                         # remove last <br>  
                         $display_data =~ s/$line_delimiter$//;  
263    
264                          $display_data = $isis_codepage->convert($display_data) || die "Can't convert '$display_data' !";                  if ($display_data) {
                         # FIX: this is removed and replaced by html tag.  
                         #$xml .= xmlify($field."_display", $display_data);  
265    
266                          if ($field eq "headline") {                          if ($field eq "headline") {
267                                  $xml .= xmlify("headline", $display_data);                                  $xml .= xmlify("headline", $display_data);
# Line 181  print STDERR "using filter '$filter'\n"; Line 279  print STDERR "using filter '$filter'\n";
279                                          print STDERR "WARNING: field '$field' doesn't have 'name' attribute!";                                          print STDERR "WARNING: field '$field' doesn't have 'name' attribute!";
280                                  }                                  }
281                                  if ($field_name) {                                  if ($field_name) {
282                                          $html .= $xml_codepage->convert($field_name);                                          $html .= x($field_name);
 #                                       $html .= "-->".$field_name."<--";  
283                                  }                                  }
284                                  $html .= $display_data."###\n";                                  $html .= $display_data."###\n";
285                          }                          }
286                  }                  }
287                  if ($swish_data) {                  if ($swish_data) {
                         my $i = Text::Iconv->new($config->{isis_codepage},'ISO8859-2');  
288                          # remove extra spaces                          # remove extra spaces
289                          $swish_data =~ s/ +/ /g;                          $swish_data =~ s/ +/ /g;
290                          $swish_data =~ s/ +$//g;                          $swish_data =~ s/ +$//g;
291    
292                          $swish_data = $i->convert($swish_data);                          $xml .= xmlify($field."_swish", unac_string($codepage,$swish_data));
293                          $xml .= xmlify($field."_swish",unac_string('ISO8859-2',$swish_data));                  }
294                          #$swish_data = $isis_codepage->convert($swish_data)."##" || $swish_data;  
295                          #$xml .= xmlify($field."_swish",unac_string($config->{isis_codepage},$swish_data));                  if ($swish_exact_data) {
296                            $swish_exact_data =~ s/ +/ /g;
297                            $swish_exact_data =~ s/ +$//g;
298    
299                            # add delimiters before and after word.
300                            # That is required to produce exact match
301                            $xml .= xmlify($field."_swish_exact", unac_string($codepage,'xxbxx '.$swish_exact_data.' xxexx'));
302                  }                  }
303    
304    
# Line 204  print STDERR "using filter '$filter'\n"; Line 306  print STDERR "using filter '$filter'\n";
306    
307          # dump formatted output in <html>          # dump formatted output in <html>
308          if ($html) {          if ($html) {
309                  $xml .= xmlify("html",$html);                  #$xml .= xmlify("html",$html);
310                    $xml .= "<html><![CDATA[ $html ]]></html>";
311          }          }
312                    
313          if ($xml) {          if ($xml) {
 #print STDERR "x: $xml\n";  
314                  $xml .= $add_xml if ($add_xml);                  $xml .= $add_xml if ($add_xml);
315                  return "<xml>\n$xml</xml>\n";                  return "<xml>\n$xml</xml>\n";
316          } else {          } else {
# Line 218  print STDERR "using filter '$filter'\n"; Line 320  print STDERR "using filter '$filter'\n";
320    
321  ##########################################################################  ##########################################################################
322    
323    # read configuration for this script
324  my $cfg = new Config::IniFiles( -file => $config_file );  my $cfg = new Config::IniFiles( -file => $config_file );
325    
326    # read global.conf configuration
327    my $cfg_global = new Config::IniFiles( -file => 'global.conf' );
328    
329    # open index
330    $index = new index_DBI(
331                    $cfg_global->val('global', 'dbi_dbd'),
332                    $cfg_global->val('global', 'dbi_dsn'),
333                    $cfg_global->val('global', 'dbi_user'),
334                    $cfg_global->val('global', 'dbi_passwd') || '',
335            );
336    
337    my $show_progress = $cfg_global->val('global', 'show_progress');
338    
339    my $unac_filter = $cfg_global->val('global', 'unac_filter');
340    if ($unac_filter) {
341            require $unac_filter;
342    }
343    
344  foreach my $database ($cfg->Sections) {  foreach my $database ($cfg->Sections) {
345    
346          my $isis_db = $cfg -> val($database, 'isis_db');          my $type = lc($cfg -> val($database, 'type')) || die "$database doesn't have 'type' defined";
347          my $type = $cfg -> val($database, 'type');          my $add_xml = $cfg -> val($database, 'xml');    # optional
         my $add_xml = $cfg -> val($database, 'xml');  
   
         # read configuration for this type  
         $config=XMLin("./import_xml/$type.xml", forcearray => [ 'isis' ], forcecontent => 1);  
         $isis_codepage = Text::Iconv->new($config->{isis_codepage},$XML_CHARSET);  
         $index_codepage = Text::Iconv->new($config->{isis_codepage},$config->{index_codepage});  
         $xml_codepage = Text::Iconv->new($cfg->val($database,'xml_codepage'),$XML_CHARSET);  
   
         my $db = OpenIsis::open( $isis_db );  
         if (0) {  
 #       # FIX  
 #       if (! $db ) {  
                 print STDERR "WARNING: can't open '$isis_db'\n";  
                 next ;  
         }  
348    
349          my $max_rowid = OpenIsis::maxRowid( $db );  print STDERR "reading ./import_xml/$type.xml\n";
350    
351          print STDERR "Reading database: $isis_db [$max_rowid rows]\n";          # extract just type basic
352            my $type_base = $type;
353            $type_base =~ s/_.+$//g;
354    
355          my $path = $database;                   # was $isis_db          $config=XMLin("./import_xml/$type.xml", forcearray => [ $type2tag{$type_base}, 'config', 'format' ], forcecontent => 1);
356    
357            # output current progress indicator
358          my $last_p = 0;          my $last_p = 0;
359            sub progress {
360                    return if (! $show_progress);
361                    my $current = shift;
362                    my $total = shift || 1;
363                    my $p = int($current * 100 / $total);
364                    if ($p != $last_p) {
365                            printf STDERR ("%5d / %5d [%-51s] %-2d %% \r",$current,$total,"=" x ($p/2).">", $p );
366                            $last_p = $p;
367                    }
368            }
369    
370            my $fake_dir = 1;
371            sub fakeprogress {
372                    return if (! $show_progress);
373                    my $current = shift @_;
374    
375                    my @ind = ('-','\\','|','/','-','\\','|','/', '-');
376    
377                    $last_p += $fake_dir;
378                    $fake_dir = -$fake_dir if ($last_p > 1000 || $last_p < 0);
379                    if ($last_p % 10 == 0) {
380                            printf STDERR ("%5d / %5s [%-51s]\r",$current,"?"," " x ($last_p/20).$ind[($last_p/20) % $#ind]);
381                    }
382            }
383    
384            # now read database
385    print STDERR "using: $type...\n";
386    
387            if ($type_base eq "isis") {
388    
389                    my $isis_db = $cfg -> val($database, 'isis_db') || die "$database doesn't have 'isis_db' defined!";
390    
391                    $import2cp = Text::Iconv->new($config->{isis_codepage},$codepage);
392                    my $db = OpenIsis::open( $isis_db );
393    
394                    # check if .txt database for OpenIsis is zero length,
395                    # if so, erase it and re-open database
396                    sub check_txt_db {
397                            my $isis_db = shift || die "need isis database name";
398                            my $reopen = 0;
399    
400                            if (-e $isis_db.".TXT") {
401                                    print STDERR "WARNING: removing $isis_db.TXT OpenIsis database...\n";
402                                    unlink $isis_db.".TXT" || warn "FATAL: unlink error on '$isis_db.TXT': $!";
403                                    $reopen++;
404                            }
405                            if (-e $isis_db.".PTR") {
406                                    print STDERR "WARNING: removing $isis_db.PTR OpenIsis database...\n";
407                                    unlink $isis_db.".PTR" || warn "FATAL: unlink error on '$isis_db.PTR': $!";
408                                    $reopen++;
409                            }
410                            return OpenIsis::open( $isis_db ) if ($reopen);
411                    }
412    
413                    # EOF error
414                    if ($db == -1) {
415                            $db = check_txt_db($isis_db);
416                            if ($db == -1) {
417                                    print STDERR "FATAL: OpenIsis can't open zero size file $isis_db\n";
418                                    next;
419                            }
420                    }
421    
422                    # OpenIsis::ERR_BADF
423                    if ($db == -4) {
424                            print STDERR "FATAL: OpenIsis can't find file $isis_db\n";
425                            next;
426                    # OpenIsis::ERR_IO
427                    } elsif ($db == -5) {
428                            print STDERR "FATAL: OpenIsis can't access file $isis_db\n";
429                            next;
430                    } elsif ($db < 0) {
431                            print STDERR "FATAL: OpenIsis unknown error $db with file $isis_db\n";
432                            next;
433                    }
434    
435                    my $max_rowid = OpenIsis::maxRowid( $db );
436    
437                    # if 0 records, try to rease isis .txt database
438                    if ($max_rowid == 0) {
439                            # force removal of database
440                            $db = check_txt_db($isis_db);
441                            $max_rowid = OpenIsis::maxRowid( $db );
442                    }
443    
444                    print STDERR "Reading database: $isis_db [$max_rowid rows]\n";
445    
446                    my $path = $database;
447    
448                    for (my $row_id = 1; $row_id <= $max_rowid; $row_id++ ) {
449                            my $row = OpenIsis::read( $db, $row_id );
450                            if ($row && $row->{mfn}) {
451            
452                                    progress($row->{mfn}, $max_rowid);
453    
454                                    my $swishpath = $path."#".int($row->{mfn});
455    
456                                    if (my $xml = data2xml($type_base,$row,$add_xml,$cfg,$database)) {
457                                            $xml = $cp2utf->convert($xml);
458                                            use bytes;      # as opposed to chars
459                                            print "Path-Name: $swishpath\n";
460                                            print "Content-Length: ".(length($xml)+1)."\n";
461                                            print "Document-Type: XML\n\n$xml\n";
462                                    }
463                            }
464                    }
465                    # for this to work with current version of OpenIsis (0.9.0)
466                    # you might need my patch from
467                    # http://www.rot13.org/~dpavlin/projects/openisis-0.9.0-perl_close.diff
468                    OpenIsis::close($db);
469                    print STDERR "\n";
470    
471            } elsif ($type_base eq "excel") {
472                    use Spreadsheet::ParseExcel;
473                    use Spreadsheet::ParseExcel::Utility qw(int2col);
474                    
475                    $import2cp = Text::Iconv->new($config->{excel_codepage},$codepage);
476                    my $excel_file = $cfg -> val($database, 'excel_file') || die "$database doesn't have 'excel_file' defined!";
477    
478                    my $sheet = x($config->{sheet}) || die "no sheet in $type.xml";
479                    my $start_row = x($config->{start_row}) - 1 || die "no start_row in $type.xml";
480    
481                    my $oBook = Spreadsheet::ParseExcel::Workbook->Parse($excel_file) || die "can't open Excel file '$excel_file'";
482    
483                    my $sheet_nr = 0;
484                    foreach my $oWks (@{$oBook->{Worksheet}}) {
485                            #print STDERR "-- SHEET $sheet_nr:", $oWks->{Name}, "\n";
486                            last if ($oWks->{Name} eq $sheet);
487                            $sheet_nr++;
488                    }
489    
490                    my $oWorksheet = $oBook->{Worksheet}[$sheet_nr];
491            
492                    print STDERR "using sheet: ",$oWorksheet->{Name},"\n";
493                    defined ($oWorksheet) || die "can't find sheet '$sheet' in $excel_file";
494                    my $end_row = x($config->{end_row}) || $oWorksheet->{MaxRow};
495    
496                    for(my $iR = $start_row ; defined $end_row && $iR <= $end_row ; $iR++) {
497                            my $row;
498                            for(my $iC = $oWorksheet->{MinCol} ; defined $oWorksheet->{MaxCol} && $iC <= $oWorksheet->{MaxCol} ; $iC++) {
499                                    my $cell = $oWorksheet->{Cells}[$iR][$iC];
500                                    if ($cell) {
501                                            $row->{int2col($iC)} = $cell->Value;
502                                    }
503                            }
504    
505                            progress($iR, $end_row);
506    
507    #                       print "row[$iR/$end_row] ";
508    #                       foreach (keys %{$row}) {
509    #                               print "$_: ",$row->{$_},"\t";
510    #                       }
511    #                       print "\n";
512    
513                            my $swishpath = $database."#".$iR;
514    
515                            next if (! $row);
516    
517                            if (my $xml = data2xml($type_base,$row,$add_xml,$cfg,$database)) {
518                                    $xml = $cp2utf->convert($xml);
519                                    use bytes;      # as opposed to chars
520                                    print "Path-Name: $swishpath\n";
521                                    print "Content-Length: ".(length($xml)+1)."\n";
522                                    print "Document-Type: XML\n\n$xml\n";
523                            }
524                    }
525            } elsif ($type_base eq "marc") {
526    
527                    use MARC;
528                    
529                    $import2cp = Text::Iconv->new($config->{marc_codepage},$codepage);
530                    my $marc_file = $cfg -> val($database, 'marc_file') || die "$database doesn't have 'marc_file' defined!";
531    
532                    # optional argument is format
533                    my $format = x($config->{format}) || 'usmarc';
534    
535                    print STDERR "Reading MARC file '$marc_file'\n";
536    
537                    my $marc = new MARC;
538                    my $nr = $marc->openmarc({
539                                    file=>$marc_file, format=>$format
540                            }) || die "Can't open MARC file '$marc_file'";
541    
542                    my $i=0;        # record nr.
543    
544                    my $rec;
545    
546                    while ($marc->nextmarc(1)) {
547    
548                            # XXX
549                            fakeprogress($i++);
550    
551  #       { my $row_id = 4514;                          my $swishpath = $database."#".$i;
552  # FIX  
553          for (my $row_id = 1; $row_id <= $max_rowid; $row_id++ ) {                          if (my $xml = data2xml($type_base,$marc,$add_xml,$cfg,$database)) {
554                  my $row = OpenIsis::read( $db, $row_id );                                  $xml = $cp2utf->convert($xml);
555                  if ($row && $row->{mfn}) {                                  use bytes;      # as opposed to chars
556  #print STDERR "mfn: ",$row->{mfn},"\n";                                  print "Path-Name: $swishpath\n";
                         # output current process indicator  
                         my $p = int($row->{mfn} * 100 / $max_rowid);  
                         if ($p != $last_p) {  
                                 printf STDERR ("%5d / %5d [%-51s] %-2d %% \r",$row->{mfn},$max_rowid,"=" x ($p/2).">", $p ) if (! $opts{q});  
                                 $last_p = $p;  
                         }  
   
                         if (my $xml = isis2xml($row,$add_xml)) {  
 #print STDERR "--ret-->$xml\n";  
                                 print "Path-Name: $path#".int($row->{mfn})."\n";  
557                                  print "Content-Length: ".(length($xml)+1)."\n";                                  print "Content-Length: ".(length($xml)+1)."\n";
558                                  print "Document-Type: XML\n\n$xml\n";                                  print "Document-Type: XML\n\n$xml\n";
559                          }                          }
560                  }                  }
561            } elsif ($type_base eq "feed") {
562    
563                    $import2cp = Text::Iconv->new($config->{feed_codepage},$codepage);
564                    my $prog = x($config->{prog}) || die "$database doesn't have 'prog' defined!";
565    
566                    print STDERR "Reading feed from program '$prog'\n";
567    
568                    open(FEED,"feeds/$prog |") || die "can't start $prog: $!";
569    
570                    my $i=1;        # record nr.
571    
572                    my $data;
573                    my $line=1;
574    
575                    while (<FEED>) {
576                            chomp;
577    
578                            if (/^$/) {
579                                    my $swishpath = $database."#".$i++;
580    
581                                    if (my $xml = data2xml($type_base,$data,$add_xml,$cfg,$database)) {
582                                            $xml = $cp2utf->convert($xml);
583                                            use bytes;      # as opposed to chars
584                                            print "Path-Name: $swishpath\n";
585                                            print "Content-Length: ".(length($xml)+1)."\n";
586                                            print "Document-Type: XML\n\n$xml\n";
587                                    }
588                                    $line = 1;
589                                    $data = {};
590                                    next;
591                            }
592    
593                            $line = $1 if (s/^(\d+):\s*//);
594                            $data->{$line++} = $_;
595    
596                            fakeprogress($i);
597    
598                    }
599          }          }
         print STDERR "\n";  
600  }  }
601    
602  # call this to commit index  # call this to commit index
# Line 281  __END__ Line 608  __END__
608    
609  =head1 NAME  =head1 NAME
610    
611  isis2xml.pl - read isis file and dump XML  all2xml.pl - read various file formats and dump XML for SWISH-E
612    
613  =head1 DESCRIPTION  =head1 DESCRIPTION
614    
615  This command will read ISIS data file using OpenIsis perl module and  This command will read ISIS data file using OpenIsis perl module, MARC
616  create XML file for usage with I<SWISH-E>  records using MARC module and optionally Micro$oft Excel files to
617  indexer. Dispite it's name, this script B<isn't general xml generator>  create one XML file for usage with I<SWISH-E> indexer. Dispite it's name,
618  from isis files (isis allready has something like that). Output of this  this script B<isn't general xml generator> from isis files (isis allready
619  script is tailor-made for SWISH-E.  has something like that). Output of this script is tailor-made for SWISH-E.
620    
621    =head1 BUGS
622    
623    Documentation is really lacking. However, in true Open Source spirit, source
624    is best documentation. I even made considerable effort to comment parts
625    which are not intuitively clear, so...
626    
627  =head1 AUTHOR  =head1 AUTHOR
628    

Legend:
Removed from v.29  
changed lines
  Added in v.170

  ViewVC Help
Powered by ViewVC 1.1.26