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

Legend:
Removed from v.44  
changed lines
  Added in v.177

  ViewVC Help
Powered by ViewVC 1.1.26