/[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 9 by dpavlin, Sat Jan 11 19:55:30 2003 UTC revision 153 by dpavlin, Sun Nov 16 22:42:41 2003 UTC
# Line 6  use Getopt::Std; Line 6  use Getopt::Std;
6  use Data::Dumper;  use Data::Dumper;
7  use XML::Simple;  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  require Unicode::Map8;  use Text::Iconv;
10  use DBI;  use Config::IniFiles;
11    use Encode;
12    
13  my $config=XMLin(undef, forcearray => [ 'isis' ], forcecontent => 1);  $|=1;
 my $dbh = DBI->connect("DBI:Pg:dbname=webpac","","") || die $DBI::errstr; # FIX  
 # FIX; select relname from pg_class where relname like 'index_%' ;  
 $dbh->begin_work || die $dbh->errstr();  
14    
15  $dbh->do("delete from index_author") || die $dbh->errstr();  my $config_file = $0;
16  $dbh->do("delete from index_title") || die $dbh->errstr();  $config_file =~ s/\.pl$/.conf/;
17    die "FATAL: can't find configuration file '$config_file'" if (! -e $config_file);
18    
19    my $config;
20    
21    #use index_DBI;         # default DBI module for index
22    use index_DBI_cache;    # faster DBI module using memory cache
23    my $index;
24    
25  my %opts;  my %opts;
26    
# Line 27  my %opts; Line 32  my %opts;
32    
33  getopts('d:m:qs', \%opts);  getopts('d:m:qs', \%opts);
34    
35  my $db_dir = $opts{d} || "ps";  # FIX  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    # this is encoding of all files on disk, including import_xml/*.xml file and
40    # 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  #print Dumper($config->{indexer});  # decode isis/excel or other import codepage
50  #print "-" x 70,"\n";  my $import2cp;
51    
52  # how to convert isis code page to UTF8?  # outgoing xml must be in UTF-8
53  my $isis_map = Unicode::Map8->new($config->{isis_codepage}) || die;  my $cp2utf = Text::Iconv->new($codepage,'UTF-8');
54    
55  sub isis2xml {  # 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    sub data2xml {
65    
66            use xmlify;
67    
68            my $type = shift @_;
69          my $row = shift @_;          my $row = shift @_;
70            my $add_xml = shift @_;
71            # needed to read values from configuration file
72            my $cfg = shift @_;
73            my $database = shift @_;
74    
75          my $xml;          my $xml;
         $xml->{db_dir} = [ $db_dir ];   # FIX remove?  
76    
77          sub isis_sf {          use parse_format;
78                  my $row = shift @_;  
79                  my $isis_id = shift @_;          my $html = "";          # html formatted display output
80                  my $subfield = shift @_;  
81                  if ($row->{$isis_id}->[0]) {          my %field_usage;        # counter for usage of each field
82                          my $sf = OpenIsis::subfields($row->{$isis_id}->[0]);  
83                          if (! defined $subfield || length($subfield) == 0) {          # sort subrouting using order="" attribute
84                                  # subfield list undef, empty or no defined subfields for this record          sub by_order {
85                                  my $all_sf = $row->{$isis_id}->[0];                  my $va = $config->{indexer}->{$a}->{order} ||
86                                  $all_sf =~ s/\^./ /g;   nuke definirions                          $config->{indexer}->{$a};
87                                  return $all_sf;                  my $vb = $config->{indexer}->{$b}->{order} ||
88                          } elsif ($sf->{$subfield}) {                          $config->{indexer}->{$b};
89                                  return $sf->{$subfield};  
90                          }                  return $va <=> $vb;
                 }  
91          }          }
92    
93          foreach my $field (keys %{$config->{indexer}}) {          foreach my $field (sort by_order keys %{$config->{indexer}}) {
94    
95                    $field=x($field);
96                    $field_usage{$field}++;
97    
                 my $display_data = "";  
98                  my $swish_data = "";                  my $swish_data = "";
99                  my $index_data = "";                  my $display_data = "";
100                    my $line_delimiter;
101    
102                    my ($swish,$display);
103    
104                    my $tag = $type2tag{$type} || die "can't find which tag to use for type $type";
105                    foreach my $x (@{$config->{indexer}->{$field}->{$tag}}) {
106    
107                            my $format = x($x->{content});
108                            my $delimiter = x($x->{delimiter}) || ' ';
109    
110                  foreach my $x (@{$config->{indexer}->{$field}->{isis}}) {                          my $repeat_off = 0;             # repeatable offset
111    
112                          my $display_tmp = "";                          my ($s,$d,$i) = (1,1,0);        # swish, display default
                         my $swish_tmp = "";  
                         my $index_tmp = "";  
   
                         my $format = $x->{content};  
                         my $s = 1;      # swish only  
                         my $d = 1;      # display only  
                         my $i = 0;      # index only  
113                          $s = 0 if (lc($x->{type}) eq "display");                          $s = 0 if (lc($x->{type}) eq "display");
114                          $d = 0 if (lc($x->{type}) eq "swish");                          $d = 0 if (lc($x->{type}) eq "swish");
115                          ($s,$d,$i) = (0,0,1) if (lc($x->{type}) eq "index");                          ($s,$d,$i) = (0,0,1) if (lc($x->{type}) eq "index");
116  #print STDERR "## s: $s d: $d i: $i ## $format ##\n";    
117                          # parse format                          # what will separate last line from this one?
118                          my $prefix = "";                          if ($display_data && $x->{append} && $x->{append} eq "1") {
119                          if ($format =~ s/^([^\d]+)//) {                                  $line_delimiter = ' ';
120                                  $prefix = $1;                          } elsif ($display_data) {
121                          }                                  $line_delimiter = '<br/>';
122                          while ($format) {                          }
123                                  if ($format =~ s/^(\d\d\d)(\w?)//) {  
124                                          my $isis_tmp = isis_sf($row,$1,$2);                          # init vars so that we go into while...
125                                          if ($isis_tmp) {                          ($swish,$display) = (1,1);
126  #                                               $display_tmp .= $prefix . "/$1/$2/".$isis_tmp if ($d);  
127                                                  $display_tmp .= $prefix . $isis_tmp if ($d);                          # placeholder for all repeatable entries for index
128                                                  $swish_tmp .= $isis_tmp." " if ($s);                          my @index_data;
129                                                  $index_tmp .= $prefix . $isis_tmp if ($i);                          my $index_filter;
130  #print STDERR " $isis_tmp <--\n";  
131                                          }                          sub mkformat {
132                                          $prefix = "";                                  my $x = shift || die "mkformat needs tag reference";
133                                  } elsif ($format =~ s/^([^\d]+)//) {                                  my $data = shift || return;
134                                          $prefix = $1;                                  my $format_name = x($x->{format_name}) || return $data;
135                                    my $fmt = x($config->{format}->{$format_name}->{content}) || die "<format name=\"$format_name\"> is not defined!";
136                                    my $format_delimiter = x($x->{format_delimiter});
137                                    my @data;
138                                    if ($format_delimiter) {
139                                            @data = split(/$format_delimiter/,$data);
140                                    } else {
141                                            push @data,$data;
142                                    }
143    
144                                    if ($fmt) {
145                                            my $nr = scalar $fmt =~ s/%s/%s/g;
146                                            if (($#data+1) == $nr) {
147                                                    return sprintf($fmt,@data);
148                                            } else {
149                                                    print STDERR "mkformat: [$data] can't be split on [$format_delimiter] to $nr fields!\n";
150                                                    return $data;
151                                            }
152                                  } else {                                  } else {
153                                          print STDERR "WARNING: unparsed format '$format'\n";                                          print STDERR "usage of link '$format_name' without defined format (<link> tag)\n";
154                                    }
155                            }
156    
157                            # while because of repeatable fields
158                            while ($swish || $display) {
159                                    ($swish,$display) = parse_format($type, $format,$row,$repeat_off++,$import2cp);
160                                    if ($repeat_off > 1000) {
161                                            print STDERR "loop (more than 1000 repeatable fields) deteced in $row, $format\n";
162                                          last;                                          last;
163                                  };                                  }
164                                    
165                                    # filter="name" ; filter this field through
166                                    # filter/[name].pm
167                                    my $filter = $x->{filter};
168                                    if ($filter) {
169                                            require "filter/".$filter.".pm";
170                                    }
171                                    # type="swish" ; field for swish
172                                    if ($s && $swish) {
173                                            if ($filter) {
174                                                    no strict 'refs';
175                                                    $swish_data .= join(" ",&$filter($swish));
176                                            } else {
177                                                    $swish_data .= $swish;
178                                            }
179                                    }
180    
181                                    # type="display" ; field for display
182                                    if ($d && $display) {
183                                            if ($line_delimiter && $display_data) {
184                                                    $display_data .= $line_delimiter;
185                                                    undef $line_delimiter;
186                                            }
187                                            if ($filter) {
188                                                    no strict 'refs';
189                                                    if ($display_data) {
190                                                            $display_data .= $delimiter.join($delimiter,mkformat($x,&$filter($display)));
191                                                    } else {
192                                                            $display_data = join($delimiter,mkformat($x,&$filter($display)));
193                                                    }
194                                            } else {
195                                                    if ($display_data) {
196                                                            $display_data .= $delimiter.mkformat($x,$display);
197                                                    } else {
198                                                            $display_data = mkformat($x,$display);
199                                                    }
200                                            }
201                                    }
202                                                    
203                                    # type="index" ; insert into index
204                                    if ($i && $display) {
205                                            push @index_data, $display;
206                                            $index_filter = $filter if ($filter);
207                                    }
208                            }
209    
210                            # fill data in index
211                            if (@index_data) {
212                                    if ($index_filter) {
213                                            no strict 'refs';
214                                            foreach my $d (@index_data) {
215                                                    $index->insert($field, &$index_filter($d), $path);
216                                            }
217                                    } else {
218                                            foreach my $d (@index_data) {
219                                                    $index->insert($field, $d, $path);
220                                            }
221                                    }
222                            }
223                    }
224    
225                    # now try to parse variables from configuration file
226                    foreach my $x (@{$config->{indexer}->{$field}->{'config'}}) {
227    
228                            my $delimiter = x($x->{delimiter}) || ' ';
229                            my $val = $cfg->val($database, x($x->{content}));
230    
231                            my ($s,$d,$i) = (1,1,0);        # swish, display default
232                            $s = 0 if (lc($x->{type}) eq "display");
233                            $d = 0 if (lc($x->{type}) eq "swish");
234                            ($s,$d,$i) = (0,0,1) if (lc($x->{type}) eq "index");
235    
236                            if ($val) {
237                                    $display_data .= $delimiter.$val if ($d);
238                                    $swish_data .= $val if ($s);
239                                    $index->insert($field, $val, $path) if ($i);
240                          }                          }
241                          # add suffix  
242                          $display_tmp .= $prefix if ($display_tmp);                  }
243                          $index_tmp .= $prefix if ($index_tmp);  
244    
245  #                       $display_data .= $display_tmp if ($display_tmp ne "");                  if ($display_data) {
246  #                       $swish_data .= $swish_tmp if ($swish_tmp ne "");  
247                          $display_data .= $display_tmp;                          if ($field eq "headline") {
248                          $swish_data .= $swish_tmp;                                  $xml .= xmlify("headline", $display_data);
249                          $index_data .= $index_tmp;                          } else {
250    
251                  }                                  # find field name (signular, plural)
252  #print "--display:$display_data\n--swish:$swish_data\n";                                  my $field_name = "";
253                  #$xml->{$field."_display"} = $isis_map->tou($display_data)->utf8 if ($display_data);                                  if ($config->{indexer}->{$field}->{name_singular} && $field_usage{$field} == 1) {
254                  #$xml->{$field."_swish"} = unac_string($config->{isis_codepage},$swish_data) if ($swish_data);                                          $field_name = $config->{indexer}->{$field}->{name_singular}."#-#";
255                  $xml->{$field."_display" } = [ $isis_map->tou($display_data)->utf8 ] if ($display_data);                                  } elsif ($config->{indexer}->{$field}->{name_plural}) {
256                  $xml->{$field."_swish"} = [ unac_string($config->{isis_codepage},$swish_data) ] if ($swish_data);                                          $field_name = $config->{indexer}->{$field}->{name_plural}."#-#";
257                                    } elsif ($config->{indexer}->{$field}->{name}) {
258                  # index                                          $field_name = $config->{indexer}->{$field}->{name}."#-#";
259                  if ($index_data && $index_data ne "") {                                  } else {
260                          my $sql = "select $field from index_$field where upper($field)=upper(?)";                                          print STDERR "WARNING: field '$field' doesn't have 'name' attribute!";
261                          my $sth = $dbh->prepare($sql) || die $dbh->errstr();                                  }
262                          $sth->execute($index_data) || die "SQL: $sql; ".$dbh->errstr();                                  if ($field_name) {
263  #print STDERR "--->$index_data<---\n";                                          $html .= x($field_name);
264                          if (! $sth->fetchrow_hashref) {                                  }
265                                  my $sql = "insert into index_$field values (?)";                                  $html .= $display_data."###\n";
                                 my $sth = $dbh->prepare($sql) || die $dbh->errstr();  
 #print STDERR "$sql: $index_data<!----\n";  
                                 $sth->execute($index_data) || die "SQL: $sql; ".$dbh->errstr();  
266                          }                          }
267                  }                  }
268                    if ($swish_data) {
269                            # remove extra spaces
270                            $swish_data =~ s/ +/ /g;
271                            $swish_data =~ s/ +$//g;
272    
273                            $xml .= xmlify($field."_swish", unac_string($codepage,$swish_data));
274                    }
275    
276    
277            }
278    
279            # dump formatted output in <html>
280            if ($html) {
281                    #$xml .= xmlify("html",$html);
282                    $xml .= "<html><![CDATA[ $html ]]></html>";
283          }          }
284            
285          if ($xml) {          if ($xml) {
286                  return XMLout($xml, rootname => 'xml', keeproot => 0, noattr => 0 );                  $xml .= $add_xml if ($add_xml);
287                    return "<xml>\n$xml</xml>\n";
288          } else {          } else {
289                  return;                  return;
290          }          }
# Line 145  sub isis2xml { Line 292  sub isis2xml {
292    
293  ##########################################################################  ##########################################################################
294    
295  my $last_tell=0;  # read configuration for this script
296    my $cfg = new Config::IniFiles( -file => $config_file );
297    
298  my @isis_dirs = ( '.' );        # use dirname as database name  # read global.conf configuration
299    my $cfg_global = new Config::IniFiles( -file => 'global.conf' );
300    
301  if ($opts{m}) {  # open index
302          @isis_dirs = split(/,/,$opts{m});  $index = new index_DBI(
303  }                  $cfg_global->val('global', 'dbi_dbd'),
304                    $cfg_global->val('global', 'dbi_dsn'),
305                    $cfg_global->val('global', 'dbi_user'),
306                    $cfg_global->val('global', 'dbi_passwd') || '',
307            );
308    
309  my @isis_dbs;  my $show_progress = $cfg_global->val('global', 'show_progress');
310    
311  foreach (@isis_dirs) {  foreach my $database ($cfg->Sections) {
312          if (-e $config->{isis_data}."/$db_dir/$_/LIBRI") {  
313                  push @isis_dbs,$config->{isis_data}."/$db_dir/$_/LIBRI/LIBRI";          my $type = lc($cfg -> val($database, 'type')) || die "$database doesn't have 'type' defined";
314          }          my $add_xml = $cfg -> val($database, 'xml');    # optional
315          if (-e $config->{isis_data}."/$db_dir/$_/PERI") {  
316                  push @isis_dbs,$config->{isis_data}."/$db_dir/$_/PERI/PERI";  print STDERR "reading ./import_xml/$type.xml\n";
317          }  
318          if (-e $config->{isis_data}."/$db_dir/$_/AMS") {          # extract just type basic
319                  push @isis_dbs,$config->{isis_data}."/$db_dir/$_/AMS/AMS";          my $type_base = $type;
320            $type_base =~ s/_.+$//g;
321    
322            $config=XMLin("./import_xml/$type.xml", forcearray => [ $type2tag{$type_base}, 'config', 'format' ], forcecontent => 1);
323    
324            # output current progress indicator
325            my $last_p = 0;
326            sub progress {
327                    return if (! $show_progress);
328                    my $current = shift;
329                    my $total = shift || 1;
330                    my $p = int($current * 100 / $total);
331                    if ($p != $last_p) {
332                            printf STDERR ("%5d / %5d [%-51s] %-2d %% \r",$current,$total,"=" x ($p/2).">", $p );
333                            $last_p = $p;
334                    }
335          }          }
336          if (-e $config->{isis_data}."/$db_dir/$_/ARTI") {  
337  #               push @isis_dbs,$config->{isis_data}."/$db_dir/$_/ARTI/ARTI";          my $fake_dir = 1;
338            sub fakeprogress {
339                    return if (! $show_progress);
340                    my $current = shift @_;
341    
342                    my @ind = ('-','\\','|','/','-','\\','|','/', '-');
343    
344                    $last_p += $fake_dir;
345                    $fake_dir = -$fake_dir if ($last_p > 1000 || $last_p < 0);
346                    if ($last_p % 10 == 0) {
347                            printf STDERR ("%5d / %5s [%-51s]\r",$current,"?"," " x ($last_p/20).$ind[($last_p/20) % $#ind]);
348                    }
349          }          }
 }  
350    
351  print STDERR "FATAL: Can't find isis database.\nPerhaps isis_data (".$config->{isis_data}.") has wrong value?\n" if (! @isis_dbs);          # now read database
352    print STDERR "using: $type...\n";
353    
354            if ($type_base eq "isis") {
355    
356  my $db;                  my $isis_db = $cfg -> val($database, 'isis_db') || die "$database doesn't have 'isis_db' defined!";
357    
358  foreach my $isis_db (@isis_dbs) {                  $import2cp = Text::Iconv->new($config->{isis_codepage},$codepage);
359                    my $db = OpenIsis::open( $isis_db );
360    
361                    # check if .txt database for OpenIsis is zero length,
362                    # if so, erase it and re-open database
363                    sub check_txt_db {
364                            my $isis_db = shift || die "need isis database name";
365                            my $reopen = 0;
366    
367                            if (-e $isis_db.".TXT") {
368                                    print STDERR "WARNING: removing $isis_db.TXT OpenIsis database...\n";
369                                    unlink $isis_db.".TXT" || warn "FATAL: unlink error on '$isis_db.TXT': $!";
370                                    $reopen++;
371                            }
372                            if (-e $isis_db.".PTR") {
373                                    print STDERR "WARNING: removing $isis_db.PTR OpenIsis database...\n";
374                                    unlink $isis_db.".PTR" || warn "FATAL: unlink error on '$isis_db.PTR': $!";
375                                    $reopen++;
376                            }
377                            return OpenIsis::open( $isis_db ) if ($reopen);
378                    }
379    
380                    # EOF error
381                    if ($db == -1) {
382                            $db = check_txt_db($isis_db);
383                            if ($db == -1) {
384                                    print STDERR "FATAL: OpenIsis can't open zero size file $isis_db\n";
385                                    next;
386                            }
387                    }
388    
389          my $db = OpenIsis::open( $isis_db );                  # OpenIsis::ERR_BADF
390          if (0) {                  if ($db == -4) {
391  #       # FIX                          print STDERR "FATAL: OpenIsis can't find file $isis_db\n";
392  #       if (! $db ) {                          next;
393                  print STDERR "WARNING: can't open '$isis_db'\n";                  # OpenIsis::ERR_IO
394                  next ;                  } elsif ($db == -5) {
395          }                          print STDERR "FATAL: OpenIsis can't access file $isis_db\n";
396                            next;
397                    } elsif ($db < 0) {
398                            print STDERR "FATAL: OpenIsis unknown error $db with file $isis_db\n";
399                            next;
400                    }
401    
402          my $max_rowid = OpenIsis::maxRowid( $db );                  my $max_rowid = OpenIsis::maxRowid( $db );
403    
404          print STDERR "Reading database: $isis_db [$max_rowid rows]\n";                  # if 0 records, try to rease isis .txt database
405                    if ($max_rowid == 0) {
406                            # force removal of database
407                            $db = check_txt_db($isis_db);
408                            $max_rowid = OpenIsis::maxRowid( $db );
409                    }
410    
411          my $last_p = 0;                  print STDERR "Reading database: $isis_db [$max_rowid rows]\n";
412    
413                    my $path = $database;
414    
415                    for (my $row_id = 1; $row_id <= $max_rowid; $row_id++ ) {
416                            my $row = OpenIsis::read( $db, $row_id );
417                            if ($row && $row->{mfn}) {
418            
419                                    progress($row->{mfn}, $max_rowid);
420    
421                                    my $swishpath = $path."#".int($row->{mfn});
422    
423                                    if (my $xml = data2xml($type_base,$row,$add_xml,$cfg,$database)) {
424                                            $xml = $cp2utf->convert($xml);
425                                            use bytes;      # as opposed to chars
426                                            print "Path-Name: $swishpath\n";
427                                            print "Content-Length: ".(length($xml)+1)."\n";
428                                            print "Document-Type: XML\n\n$xml\n";
429                                    }
430                            }
431                    }
432                    # for this to work with current version of OpenIsis (0.9.0)
433                    # you might need my patch from
434                    # http://www.rot13.org/~dpavlin/projects/openisis-0.9.0-perl_close.diff
435                    OpenIsis::close($db);
436                    print STDERR "\n";
437    
438            } elsif ($type_base eq "excel") {
439                    use Spreadsheet::ParseExcel;
440                    use Spreadsheet::ParseExcel::Utility qw(int2col);
441                    
442                    $import2cp = Text::Iconv->new($config->{excel_codepage},$codepage);
443                    my $excel_file = $cfg -> val($database, 'excel_file') || die "$database doesn't have 'excel_file' defined!";
444    
445                    my $sheet = x($config->{sheet}) || die "no sheet in $type.xml";
446                    my $start_row = x($config->{start_row}) - 1 || die "no start_row in $type.xml";
447    
448                    my $oBook = Spreadsheet::ParseExcel::Workbook->Parse($excel_file) || die "can't open Excel file '$excel_file'";
449    
450                    my $sheet_nr = 0;
451                    foreach my $oWks (@{$oBook->{Worksheet}}) {
452                            #print STDERR "-- SHEET $sheet_nr:", $oWks->{Name}, "\n";
453                            last if ($oWks->{Name} eq $sheet);
454                            $sheet_nr++;
455                    }
456    
457  #       { my $row_id = 1;                  my $oWorksheet = $oBook->{Worksheet}[$sheet_nr];
458  # FIX          
459          for (my $row_id = 1; $row_id <= $max_rowid; $row_id++ ) {                  print STDERR "using sheet: ",$oWorksheet->{Name},"\n";
460                  my $row = OpenIsis::read( $db, $row_id );                  defined ($oWorksheet) || die "can't find sheet '$sheet' in $excel_file";
461                  if ($row && $row->{mfn}) {                  my $end_row = x($config->{end_row}) || $oWorksheet->{MaxRow};
462    
463                          # output current process indicator                  for(my $iR = $start_row ; defined $end_row && $iR <= $end_row ; $iR++) {
464                          my $p = int($row->{mfn} * 100 / $max_rowid);                          my $row;
465                          if ($p != $last_p) {                          for(my $iC = $oWorksheet->{MinCol} ; defined $oWorksheet->{MaxCol} && $iC <= $oWorksheet->{MaxCol} ; $iC++) {
466                                  printf STDERR ("%5d / %5d [%-51s] %-2d %% \r",$row->{mfn},$max_rowid,"=" x ($p/2).">", $p ) if (! $opts{q});                                  my $cell = $oWorksheet->{Cells}[$iR][$iC];
467                                  $last_p = $p;                                  if ($cell) {
468                          }                                          $row->{int2col($iC)} = $cell->Value;
469                                    }
                         if (my $xml = isis2xml($row)) {  
                                 my $path = $isis_db;  
                                 $path =~ s#$config->{isis_data}/*##g;  
                                 my $out = "Path-Name: $path#".$row->{mfn}."\n";  
                                 $out .= "Content-Length: ".(length($xml)+1)."\n";  
                                 $out .= "Document-Type: XML\n\n$xml\n";  
                                 print $out;  
470                          }                          }
471    
472                            progress($iR, $end_row);
473    
474    #                       print "row[$iR/$end_row] ";
475    #                       foreach (keys %{$row}) {
476    #                               print "$_: ",$row->{$_},"\t";
477    #                       }
478    #                       print "\n";
479    
480                            my $swishpath = $database."#".$iR;
481    
482                            next if (! $row);
483    
484                            if (my $xml = data2xml($type_base,$row,$add_xml,$cfg,$database)) {
485                                    $xml = $cp2utf->convert($xml);
486                                    use bytes;      # as opposed to chars
487                                    print "Path-Name: $swishpath\n";
488                                    print "Content-Length: ".(length($xml)+1)."\n";
489                                    print "Document-Type: XML\n\n$xml\n";
490                            }
491                    }
492            } elsif ($type_base eq "marc") {
493    
494                    use MARC;
495                    
496                    $import2cp = Text::Iconv->new($config->{marc_codepage},$codepage);
497                    my $marc_file = $cfg -> val($database, 'marc_file') || die "$database doesn't have 'marc_file' defined!";
498    
499                    # optional argument is format
500                    my $format = x($config->{format}) || 'usmarc';
501    
502                    print STDERR "Reading MARC file '$marc_file'\n";
503    
504                    my $marc = new MARC;
505                    my $nr = $marc->openmarc({
506                                    file=>$marc_file, format=>$format
507                            }) || die "Can't open MARC file '$marc_file'";
508    
509                    my $i=0;        # record nr.
510    
511                    my $rec;
512    
513                    while ($marc->nextmarc(1)) {
514    
515                            # XXX
516                            fakeprogress($i++);
517    
518                            my $swishpath = $database."#".$i;
519    
520                            if (my $xml = data2xml($type_base,$marc,$add_xml,$cfg,$database)) {
521                                    $xml = $cp2utf->convert($xml);
522                                    use bytes;      # as opposed to chars
523                                    print "Path-Name: $swishpath\n";
524                                    print "Content-Length: ".(length($xml)+1)."\n";
525                                    print "Document-Type: XML\n\n$xml\n";
526                            }
527                    }
528            } elsif ($type_base eq "feed") {
529    
530                    $import2cp = Text::Iconv->new($config->{feed_codepage},$codepage);
531                    my $prog = x($config->{prog}) || die "$database doesn't have 'prog' defined!";
532    
533                    print STDERR "Reading feed from program '$prog'\n";
534    
535                    open(FEED,"feeds/$prog |") || die "can't start $prog: $!";
536    
537                    my $i=1;        # record nr.
538    
539                    my $data;
540                    my $line=1;
541    
542                    while (<FEED>) {
543                            chomp;
544    
545                            if (/^$/) {
546                                    my $swishpath = $database."#".$i++;
547    
548                                    if (my $xml = data2xml($type_base,$data,$add_xml,$cfg,$database)) {
549                                            $xml = $cp2utf->convert($xml);
550                                            use bytes;      # as opposed to chars
551                                            print "Path-Name: $swishpath\n";
552                                            print "Content-Length: ".(length($xml)+1)."\n";
553                                            print "Document-Type: XML\n\n$xml\n";
554                                    }
555                                    $line = 1;
556                                    $data = {};
557                                    next;
558                            }
559    
560                            $line = $1 if (s/^(\d+):\s*//);
561                            $data->{$line++} = $_;
562    
563                            fakeprogress($i);
564    
565                  }                  }
566          }          }
         print STDERR "\n";  
567  }  }
568    
569  $dbh->commit || die $dbh->errstr();  # call this to commit index
570    $index->close;
571    
572  1;  1;
573  __END__  __END__
# Line 225  __END__ Line 575  __END__
575    
576  =head1 NAME  =head1 NAME
577    
578  isis2xml.pl - read isis file and dump XML  all2xml.pl - read various file formats and dump XML for SWISH-E
579    
580  =head1 DESCRIPTION  =head1 DESCRIPTION
581    
582  This command will read ISIS data file using OpenIsis perl module and  This command will read ISIS data file using OpenIsis perl module, MARC
583  create XML file for usage with I<SWISH-E>  records using MARC module and optionally Micro$oft Excel files to
584  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,
585  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
586  script is tailor-made for SWISH-E.  has something like that). Output of this script is tailor-made for SWISH-E.
587    
588    =head1 BUGS
589    
590    Documentation is really lacking. However, in true Open Source spirit, source
591    is best documentation. I even made considerable effort to comment parts
592    which are not intuitively clear, so...
593    
594  =head1 AUTHOR  =head1 AUTHOR
595    

Legend:
Removed from v.9  
changed lines
  Added in v.153

  ViewVC Help
Powered by ViewVC 1.1.26