/[webpac]/trunk/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 /trunk/all2xml.pl

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

revision 17 by dpavlin, Sat Feb 22 21:33:04 2003 UTC revision 177 by dpavlin, Mon Nov 24 01:19:15 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    #use GDBM_File;
13    use Fcntl;      # for O_RDWR
14    use TDB_File;
15    
16  $|=1;  $|=1;
17    
# Line 17  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 31  my %opts; Line 35  my %opts;
35    
36  getopts('d:m:qs', \%opts);  getopts('d:m:qs', \%opts);
37    
38  my $db_dir;  my $path;       # this is name of database
39    
40    Text::Iconv->raise_error(0);     # Conversion errors don't raise exceptions
41    
42  #die "usage: $0 -d [database_dir] -m [database1,database2] " if (! %opts);  # 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!
44    my $codepage = 'ISO-8859-2';
45    
46    my $utf2cp = Text::Iconv->new('UTF-8',$codepage);
47    # this function will convert data from XML files to local encoding
48    sub x {
49            return $utf2cp->convert($_[0]);
50    }
51    
52  #print Dumper($config->{indexer});  # decode isis/excel or other import codepage
53  #print "-" x 70,"\n";  my $import2cp;
54    
55  Text::Iconv->raise_error(1);     # Conversion errors raise exceptions  # outgoing xml must be in UTF-8
56    my $cp2utf = Text::Iconv->new($codepage,'UTF-8');
57    
58  #my $isis_codepage = Text::Iconv->new($config->{isis_codepage},'UTF8');  # mapping between data type and tag which specify
59  #my $index_codepage = Text::Iconv->new($config->{isis_codepage},$config->{index_codepage});  # format in XML file
60  my $isis_codepage;  my %type2tag = (
61  my $index_codepage;          'isis' => 'isis',
62  my $cludge_codepage = Text::Iconv->new('UTF8','ISO8859-1');          'excel' => 'column',
63  my $xml_codepage;          '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 isis2xml {  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 62  sub isis2xml { Line 91  sub isis2xml {
91    
92          my %field_usage;        # counter for usage of each field          my %field_usage;        # counter for usage of each field
93    
94          foreach my $field (keys %{$config->{indexer}}) {          # sort subrouting using order="" attribute
95            sub by_order {
96                    my $va = $config->{indexer}->{$a}->{order} ||
97                            $config->{indexer}->{$a};
98                    my $vb = $config->{indexer}->{$b}->{order} ||
99                            $config->{indexer}->{$b};
100    
101                    return $va <=> $vb;
102            }
103    
104            my @sorted_tags;
105            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            # lookup key
113            my $lookup_key;
114    
115            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;
124    
125                  foreach my $x (@{$config->{indexer}->{$field}->{isis}}) {                  my ($swish,$display);
126    
127                          my $format = $x->{content};                  my $tag = $type2tag{$type} || die "can't find which tag to use for type $type";
128                          my ($s,$d,$i) = (1,1,0);        # swish, display default                  foreach my $x (@{$config->{indexer}->{$field}->{$tag}}) {
129    
130                            my $format = x($x->{content});
131                            my $delimiter = x($x->{delimiter}) || ' ';
132    
133                            my $repeat_off = 0;             # repeatable offset
134    
135                            # 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  #print STDERR "## s: $s d: $d i: $i ## $format ##\n";                            $il = 1 if (lc($x->{type}) =~ /^lookup/);
143    
144    
145                            # what will separate last line from this one?
146                            if ($display_data && $x->{append} && $x->{append} eq "1") {
147                                    $line_delimiter = ' ';
148                            } elsif ($display_data) {
149                                    $line_delimiter = '<br/>';
150                            }
151    
152                            # init vars so that we go into while...
153                            ($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) {
186                                    ($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                          $format = $cludge_codepage->convert($format);                                  # filter="name" ; filter this field through
215                          my ($swish,$display) = parse_format($format,$row);                                  # filter/[name].pm
216  #print STDERR "s: $swish\nd: $display\n" if ($swish);                                  my $filter = $x->{filter};
217                                    if ($filter && !$cache->{filter_loaded}->{$filter}) {
218                                            require "filter/".$filter.".pm";
219                                            $cache->{filter_loaded}->{$filter}++;
220                                    }
221                                    # type="swish" ; field for swish
222                                    if ($swish) {
223                                            if ($filter && ($s || $se)) {
224                                                    no strict 'refs';
225                                                    my $tmp = join(" ",&$filter($swish)) if ($s || $se);
226                                                    $swish_data .= $tmp if ($s);
227                                                    $swish_exact_data .= $tmp if ($se);
228    
229                                            } else {
230                                                    $swish_data .= $swish if ($s);
231                                                    $swish_exact_data .= $swish if ($se);
232                                            }
233                                    }
234    
235                                    # type="display" ; field for display
236                                    if ($d && $display) {
237                                            if ($line_delimiter && $display_data) {
238                                                    $display_data .= $line_delimiter;
239                                                    undef $line_delimiter;
240                                            }
241                                            if ($filter) {
242                                                    no strict 'refs';
243                                                    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 {
249                                                    if ($display_data) {
250                                                            $display_data .= $delimiter.mkformat($x,$display);
251                                                    } else {
252                                                            $display_data = mkformat($x,$display);
253                                                    }
254                                            }
255                                    }
256                                                    
257                                    # type="index" ; insert into index
258                                    if ($i && $display) {
259                                            if ($filter) {
260                                                    no strict 'refs';
261                                                    $display = &$filter($display);
262                                            }
263                                            if ($x->{append} && @index_data) {
264                                                    $index_data[$#index_data].=$display;
265                                            } else {
266                                                    push @index_data, $display;
267                                            }
268                                    }
269    
270  #print STDERR "swish: $swish<-- display: $display<--\n";                                  # store fields in lookup
271                          # FIX: this is ugly, UGLY, cludge: OpenIsis return                                  if ($il && $display) {
272                          # UTF8 encoding of strings, but as if source charset                                          if (lc($x->{type}) eq "lookup_key") {
273                          # is ISO8859-1 and not some other. This breaks our                                                  if ($lookup_key) {
274                          # isis character encoding, so we convert it first                                                          print STDERR "WARNING: try to redefine lookup_key (keys shouldn't be repeatable fields!)";
275                          # back to ISO8859-1 (which can actually be different                                                  } else {
276                          # encoding in isis)                                                          $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                          $swish_data .= $swish if ($s && $swish);                          # fill data in index
289                          $display_data .= $display if ($d && $display);                          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                          # insert into index                          if ($val) {
308                          if ($i && $display) {                                  $display_data .= $delimiter.$val if ($d);
309                                  my $index_data = $index_codepage->convert($display) || $display;                                  $swish_data .= $val if ($s);
310                                  $index->insert($field, $index_data, $db_dir);                                  $index->insert($field, $val, $path) if ($i);
311                          }                          }
312    
313                  }                  }
314    
315    
 #print STDERR "s_d: $swish_data\nd_d: $display_data\n" if ($swish_data);  
316                  if ($display_data) {                  if ($display_data) {
                         $display_data = $isis_codepage->convert($display_data) || die "Can't convert '$display_data' !";  
                         # FIX: this is removed and replaced by html tag.  
                         #$xml .= xmlify($field."_display", $display_data);  
317    
318                          if ($field eq "headline") {                          if ($field eq "headline") {
319                                  $xml .= xmlify("headline", $display_data);                                  $xml .= xmlify("headline", $display_data);
# Line 117  sub isis2xml { Line 325  sub isis2xml {
325                                          $field_name = $config->{indexer}->{$field}->{name_singular}."#-#";                                          $field_name = $config->{indexer}->{$field}->{name_singular}."#-#";
326                                  } elsif ($config->{indexer}->{$field}->{name_plural}) {                                  } elsif ($config->{indexer}->{$field}->{name_plural}) {
327                                          $field_name = $config->{indexer}->{$field}->{name_plural}."#-#";                                          $field_name = $config->{indexer}->{$field}->{name_plural}."#-#";
328                                  } else {                                  } elsif ($config->{indexer}->{$field}->{name}) {
329                                          $field_name = $config->{indexer}->{$field}->{name}."#-#";                                          $field_name = $config->{indexer}->{$field}->{name}."#-#";
330                                    } else {
331                                            print STDERR "WARNING: field '$field' doesn't have 'name' attribute!";
332                                  }                                  }
333                                  if ($field_name) {                                  if ($field_name) {
334                                          $html .= $xml_codepage->convert($field_name);                                          $html .= x($field_name);
335                                  }                                  }
336                                  $html .= $display_data."###\n";                                  $html .= $display_data."###\n";
337                          }                          }
338                  }                  }
339                  if ($swish_data) {                  if ($swish_data) {
340                          my $i = Text::Iconv->new($config->{isis_codepage},'ISO8859-2');                          # remove extra spaces
341                          $swish_data = $i->convert($swish_data);                          $swish_data =~ s/ +/ /g;
342                          $xml .= xmlify($field."_swish",unac_string('ISO8859-2',$swish_data));                          $swish_data =~ s/ +$//g;
343                          #$swish_data = $isis_codepage->convert($swish_data)."##" || $swish_data;  
344                          #$xml .= xmlify($field."_swish",unac_string($config->{isis_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    
# Line 139  sub isis2xml { Line 358  sub isis2xml {
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) {
 #print STDERR "x: $xml\n";  
366                  $xml .= $add_xml if ($add_xml);                  $xml .= $add_xml if ($add_xml);
367                  return "<xml>\n$xml</xml>\n";                  return "<xml>\n$xml</xml>\n";
368          } else {          } else {
# Line 153  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');          my $type = lc($cfg -> val($database, 'type')) || die "$database doesn't have 'type' defined";
399          my $type = $cfg -> val($database, 'type');          my $add_xml = $cfg -> val($database, 'xml');    # optional
         my $add_xml = $cfg -> val($database, 'xml');  
400    
401          # read configuration for this type          # create new lookup file
402          $config=XMLin("./import_xml/$type.xml", forcearray => [ 'isis' ], forcecontent => 1);          my $lookup_file = $cfg -> val($database, 'lookup_newfile'); # optional
403          $isis_codepage = Text::Iconv->new($config->{isis_codepage},'UTF8');          if ($lookup_file) {
404          $index_codepage = Text::Iconv->new($config->{isis_codepage},$config->{index_codepage});                  #tie %lhash, 'GDBM_File', $lookup_file, &GDBM_NEWDB, 0644;
405          $xml_codepage = Text::Iconv->new($cfg->val($database,'xml_codepage'),'UTF8');                  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  #print STDERR "mfn: ",$row->{mfn},"\n";                  my @ind = ('-','\\','|','/','-','\\','|','/', '-');
444                          # output current process indicator  
445                          my $p = int($row->{mfn} * 100 / $max_rowid);                  $last_p += $fake_dir;
446                          if ($p != $last_p) {                  $fake_dir = -$fake_dir if ($last_p > 1000 || $last_p < 0);
447                                  printf STDERR ("%5d / %5d [%-51s] %-2d %% \r",$row->{mfn},$max_rowid,"=" x ($p/2).">", $p ) if (! $opts{q});                  if ($last_p % 10 == 0) {
448                                  $last_p = $p;                          printf STDERR ("%5d / %5s [%-51s]\r",$current,"?"," " x ($last_p/20).$ind[($last_p/20) % $#ind]);
449                          }                  }
450            }
451                          if (my $xml = isis2xml($row,$add_xml)) {  
452  #print STDERR "--ret-->$xml\n";          # now read database
453                                  print "Path-Name: $path#".int($row->{mfn})."\n";  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                            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 = data2xml($type_base,$row,$add_xml,$cfg,$database)) {
586                                    $xml = $cp2utf->convert($xml);
587                                    use bytes;      # as opposed to chars
588                                    print "Path-Name: $swishpath\n";
589                                    print "Content-Length: ".(length($xml)+1)."\n";
590                                    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";                                  print "Content-Length: ".(length($xml)+1)."\n";
626                                  print "Document-Type: XML\n\n$xml\n";                                  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 216  __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.17  
changed lines
  Added in v.177

  ViewVC Help
Powered by ViewVC 1.1.26