GCNumista.pm 53.2 KB
Newer Older
1
2
3
4
#
# More information here: http://wiki.gcstar.org/en/websites_plugins
#

5
6
7
8
9
package GCPlugins::GCcoins::GCNumista;

###################################################
#
#  Copyright 2005-2010 Tian
10
#  Copyright 2014-2021 MesBedes
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#
#  This file is part of GCstar.
#
#  GCstar is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version.
#
#  GCstar is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with GCstar; if not, write to the Free Software
#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
###################################################

use strict;
use utf8;  # pour dire que le source est en utf8
use GCPlugins::GCcoins::GCcoinsCommon;
33
#use open qw(:std :utf8); # pour dire que les entrées et sorties sont par défaut en utf8
34
35
36

{
    package GCPlugins::GCcoins::GCPluginNumista;
37
38
    use base qw(GCPlugins::GCcoins::GCcoinsPluginsBase);
    use URI::Escape;
39

40
41
42
43
44
    sub getSearchType
    {
        return "coin";
    }

45
46
47
48
49
50
51
52
    # getSearchUrl
    sub getSearchUrl
    {
        my ($self, $word) = @_;
        my $url;
        # q=50 permet d'avoir 50 résultats dans la page
        # les valeurs possibles : 10, 20, 50 ou 100

53
        if ($self->{searchField} eq 'name')
54
        {
55
            # recherche simplifiée sur le nom de la monnaie
56
57
58
59
60
61
            # TODO : en cas d'espace en trop, exemple "20 francs 1848   "
            # Enlève les blancs en début de chaine
            $word =~ s/^\s*//;
            # Enlève les blancs en fin de chaine
            $word =~ s/\s*$//;
            # on remplace les espaces internes par des plus
62
            $word =~ s/ /\+/gi;
63
64
            $url = "https://fr.numista.com/catalogue/index.php?mode=simplifie&p=1&e=&d=&ca=3&no=&i=&v=&m=&a=&t=&dg=&w=&g=&f=&c=&tb=y&tc=y&tn=y&tp=y&tp=y&tt=y&te=y&cat=y";
            $url .= "&ct=" . $self->getSearchType() . "&q=100&r=$word";
Kerenoc's avatar
Kerenoc committed
65
        }
66
        elsif ($self->{searchField} eq 'country')
67
68
69
70
71
72
73
74
75
76
77
78
79
80
        {
            # recherche sur le pays (&r=pays:nom traduit en &r=pays%3Anom)
            $url = "https://fr.numista.com/catalogue/index.php?ca=3&no=&c=&tb=y&tc=y&tn=y&tp=y&tp=y&tt=y&te=y&cat=y&mode=simplifie&p=1&e=&d=&i=&v=&m=&a=&t=&dg=&w=&g=&f=";
            $url .= "&ct=" . $self->getSearchType() . "&q=100&r=pays:".$word;
        }
        elsif ($self->{searchField} eq 'number1')
        {
            # recherche par KM (&km=numero)
            # todo : ne marche pas si séparateur espace
            # KM# 757 ne fonctionne pas, il faut envoyer KM#757
            $word =~ s/ //;
            $url = "https://fr.numista.com/catalogue/index.php?mode=simplifie&p=1&e=&d=&ca=3&no=&i=&v=&m=&a=&t=&dg=&w=&g=&f=&c=&tb=y&tc=y&tn=y&tp=y&tp=y&tt=y&te=y&cat=y";
            $url .= "&ct=" . $self->getSearchType() . "&q=100&r=".$word;
        }
81
82
83
84
85
86
87
88
        return $url;
    }

    # getItemUrl
    sub getItemUrl
    {
        my ($self, $url) = @_;
        my $absUrl;
89
        $absUrl = "https://fr.numista.com" . $url;
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
        return $absUrl;
    }

    # getCharset
    sub getCharset
    {
        my $self = shift;
        return "ISO-8859-1";
    }

    # getName
    sub getName
    {
        return "fr.numista";
    }

    # getAuthor
    sub getAuthor
    {
        return 'MesBedes';
    }

    # getLang
    sub getLang
    {
        return 'FR';
    }

    sub getSearchFieldsArray
    {
120
        return ['name', 'country', 'number1'];
121
122
    }

123
124
125
126
127
128
129
    # getSearchCharset
    sub getSearchCharset
    {
        my $self = shift;
        return "utf8";
    }

130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
    # getExtra
    sub getExtra
    {
        return '';
    }

    # getNumberPasses
    sub getNumberPasses
    {
        return 1;
    }

    # changeUrl
    sub changeUrl
    {
        my ($self, $url) = @_;
        return $url;
    }

    # start
    sub start
    {
        my ($self, $tagname, $attr, $attrseq, $origtext) = @_;
        $self->{inside}->{$tagname}++;
        if ($self->{parsingList})
        {
156
            # exploitation de la liste des résultats de la recherche
157
158
159
160
            if (($tagname eq "div") && ($attr->{id} eq "resultats_recherche"))
            {
                $self->{insideResults} = 1;
            }
161
162
            if ($self->{insideResults} eq 1)
            {
163
                if (($tagname eq "div") && ($attr->{class} eq "resultat_recherche") && ($attr->{class} ne "resultat_recherche_ad") && ($self->{isCoin} eq 0))
164
165
                {
                    $self->{isCoin} = 1;
166
167
                    $self->{itemIdx}++;
                    $self->{isInfo} = 0;
168
                }
169
                elsif (($tagname eq "div") && ($attr->{class} eq "photo_avers") && ($self->{isCoin} eq 1))
170
171
172
173
174
175
176
                {
                    $self->{isCoin} = 2;
                }
                elsif (($tagname eq "div") && ($attr->{class} eq "photo_revers") && ($self->{isCoin} eq 2))
                {
                    $self->{isCoin} = 3;
                }
177
                elsif (($tagname eq "div") && ($attr->{class} eq "description_piece") && ($self->{isCoin} eq 3))
178
179
180
181
182
183
184
185
                {
                    $self->{isCoin} = 4;
                }
                elsif (($tagname eq "span") && ($attr->{class} =~ /^sprite/) && ($self->{isCoin} eq 4))
                {
                    $self->{isCoin} = 5;
                    $self->{itemsList}[ $self->{itemIdx} ]->{country} = $attr->{title};
                }
186
                elsif (($tagname eq "a") && ($attr->{href} =~ /(pieces|exonumia)(\d+)\.html/) && ($self->{isCoin} eq 5))
187
188
189
                {
                    my $url = $attr->{href};
                    $self->{itemsList}[ $self->{itemIdx} ]->{url} = $url;
190
                    # nom/série
191
                    $self->{isCoin} = 6;
192
                    $self->{isInfo} = 1;
193
                }
194
                elsif ($self->{isCoin} eq 6)
195
                {
196
197
                    # TODO : au 25/07/2020, les ND (non daté) ne renvoi pas la date entre parenthèse
                    # année
198
199
                    $self->{isCoin} = 7;
                }
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
                elsif ($self->{isCoin} eq 7)
                {
                    # TODO : au 25/07/2020, problème des balise BR qui empêchent le remplissage référence, valeur, atelier et métal
                    # TODO : ne fonctionne pas si ligne supplémentaire concernant la commémorative (une balise BR en plus)
                    # par exemple 100 shillings 2017 (Elephant) 
                    # métal
                    $self->{isCoin} = 8;
                }
                elsif ($self->{isCoin} eq 8)
                {
                    # TODO : au 25/07/2020, problème des balise BR qui empêchent le remplissage référence, valeur, atelier et métal
                    # TODO : ne fonctionne pas si ligne supplémentaire concernant la commémorative (une balise BR en plus)
                    # par exemple 100 shillings 2017 (Elephant) 
                    # référence
                    $self->{isCoin} = 9;
                }
                elsif ($self->{isCoin} eq 9)
                {
                    # pièce suivante
                    $self->{isCoin} = 10;
                }
221
222
223
224
225
226
227
228
229
230
231
            }
        }
        else
        {
            # le titre de la page
            if ($tagname eq "h1")
            {
                $self->{insideSerie} = 1;
            }
            elsif (($tagname eq "span") && ($self->{insideSerie} eq 1))
            {
232
                # attention : il n'y a pas forcément de balise <span> dans la balise <h1>
233
234
235
236
237
238
239
240
241
242
243
                $self->{insideSerie} = 2;
            }

            ### les infos techniques
            if (($tagname eq "section") && ($attr->{id} eq "fiche_caracteristiques"))
            {
                $self->{insideTech} = 1;
                $self->{insideSerie} = 0;
                $self->{insidePicture} = 0;
                $self->{insideCollec} = 0;
                $self->{insideDesc} = 0;
244
245
                $self->{insideEch} = 0;
                $self->{isVoir} = 0 ;
246
247
248
249
250
251
252
            }
            elsif ($tagname eq "td")
            {
                if ($self->{isCountry} eq 1)
                {
                    $self->{isCountry} = 2 ;
                }
253
254
255
256
                elsif ($self->{isAutorit} eq 1)
                {
                    $self->{isAutorit} = 2 ;
                }
257
258
259
260
                elsif ($self->{isPeriod} eq 1)
                {
                    $self->{isPeriod} = 2 ;
                }
261
262
263
264
                elsif ($self->{isType} eq 1)
                {
                    $self->{isType} = 2 ;
                }
265
                elsif ($self->{isYear} eq 1)
266
267
268
                {
                    $self->{isYear} = 2 ;
                }
269
                elsif ($self->{isCalend} eq 1)
270
271
272
                {
                    $self->{isCalend} = 2 ;
                }
273
                elsif ($self->{isValue} eq 1)
274
275
276
                {
                    $self->{isValue} = 2 ;
                }
277
278
279
280
                elsif ($self->{isCurrency} eq 1)
                {
                    $self->{isCurrency} = 2 ;
                }
281
                elsif ($self->{isMetal} eq 1)
282
283
284
                {
                    $self->{isMetal} = 2 ;
                }
285
                elsif ($self->{isWeight} eq 1)
286
287
288
                {
                    $self->{isWeight} = 2 ;
                }
289
                elsif ($self->{isDiameter} eq 1)
290
291
292
                {
                    $self->{isDiameter} = 2 ;
                }
293
                elsif ($self->{isDepth} eq 1)
294
295
296
                {
                    $self->{isDepth} = 2 ;
                }
297
                elsif ($self->{isForm} eq 1)
298
299
300
                {
                    $self->{isForm} = 2 ;
                }
301
                elsif ($self->{isAxis} eq 1)
302
303
304
                {
                    $self->{isAxis} = 2 ;
                }
305
                elsif ($self->{isDemon} eq 1)
306
307
308
                {
                    $self->{isDemon} = 2 ;
                }
309
310
311
312
                elsif ($self->{isNum} eq 1)
                {
                    $self->{isNum} = 2 ;
                }
313
                elsif ($self->{isRef} eq 1)
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
                {
                    $self->{isRef} = 2 ;
                }
            }
            elsif ($tagname eq 'th')
            {
                $self->{isAnalyse} = 1 ;
            }
            elsif (($tagname eq "td") && ($self->{insideTech} eq 1))
            {
                # source
                $self->{insideTech} = 2;
            }
            elsif (($tagname eq "td") && ($self->{insideTech} eq 2))
            {
329
                # pays émetteur
330
331
332
333
334
335
                $self->{insideTech} = 3;
            }
            elsif (($tagname eq "a") && ($self->{isCountry} eq 2))
            {
                $self->{isCountry} = 3 ;
            }
336
337
338
339
340
            elsif (($tagname eq "a") && ($self->{isNum} eq 2))
            {
                $self->{isNum} = 3 ;
            }
            elsif (($tagname eq "a") && ($self->{isRef} eq 2))
341
342
343
344
            {
                $self->{isRef} = 3 ;
            }

345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
            ### les photos
            # attention les photos sont maintenant avant les caractéristiques
            if (($tagname eq "div") && ($attr->{id} eq "fiche_photo"))
            {
                $self->{insidePicture} = 1;
                $self->{insideTech} = 0;
                $self->{insideSerie} = 0;
                $self->{insideCollec} = 0;
                $self->{insideDesc} = 0;
                $self->{insideEch} = 0;
                $self->{isVoir} = 0 ;
            }
            elsif (($tagname eq "a") && ($self->{insidePicture} eq 1))
            {
                # image de l'avers
                my $src1 = $attr->{href};
                
                # le https met la pagaille (pb de certificat ?, bug de GCstar ?)
                if (($src1 =~ /https:/)) {
                    $src1 =~ s/https\:/http\:/;
                }
                $self->{curInfo}->{picture} = $src1;
                $self->{insidePicture} = 2;
            }
            elsif (($tagname eq "img") && ($self->{insidePicture} eq 1) && ($attr->{alt} =~ /avers/))
            {
                if ($self->{curInfo}->{picture} eq "")
                {
                    # petite image de l'avers si pas de grande
                    my $srcp1 = $attr->{src};
                    $self->{curInfo}->{picture} = $srcp1;
                    $self->{insidePicture} = 2;
                }
            }
            elsif (($tagname eq "a") && ($self->{insidePicture} eq 2))
            {
                # image du revers
                my $src2 = $attr->{href};
                
                # le https met la pagaille (pb de certificat ?)
                if (($src2 =~ /https:/)) {
                    $src2 =~ s/https\:/http\:/;
                }
                $self->{curInfo}->{back} = $src2;
                $self->{insidePicture} = 3;
            }
            elsif (($tagname eq "img") && ($self->{insidePicture} eq 2) && ($attr->{alt} =~ /revers/))
            {
                if ($self->{curInfo}->{back} eq "")
                {
                    # petite image du revers si pas de grande
                    my $srcp2 = $attr->{src};
                    $self->{curInfo}->{back} = $srcp2;
                    $self->{insidePicture} = 3;
                }
            }

402
403
404
            ### la description
            if (($tagname eq "section") && ($attr->{id} eq "fiche_descriptions"))
            {
405
406
407
408
409
410
                $self->{insideDesc} = 1 ;
                $self->{insidePicture} = 0 ;
                $self->{insideTech} = 0 ;
                $self->{insideSerie} = 0 ;
                $self->{insideCollec} = 0 ;
                $self->{insideEch} = 0 ;
411
                $self->{isVoir} = 0 ;
412
413
414
415
416
417
            }
            elsif (($tagname eq "p") or ($tagname eq "span"))
            {
                if ($self->{isCommemo} eq 1)
                {
                    $self->{isCommemo} = 2 ;
418
                    $self->{isAtelier} = 0 ;
419
420
421
                    $self->{isAvers} = 0 ;
                    $self->{isRevers} = 0 ;
                    $self->{isTranche} = 0 ;
422
                    $self->{isComment} = 0 ;
423
424
                    $self->{insideCollec} = 0 ;
                    $self->{insideEch} = 0 ;
425
                    $self->{isVoir} = 0 ;
426
427
428
429
                }
                elsif ($self->{isAvers} eq 1)
                {
                    $self->{isAvers} = 2 ;
430
                    $self->{isAtelier} = 0 ;
431
432
433
                    $self->{isCommemo} = 0 ;
                    $self->{isRevers} = 0 ;
                    $self->{isTranche} = 0 ;
434
                    $self->{isComment} = 0 ;
435
436
                    $self->{insideCollec} = 0 ;
                    $self->{insideEch} = 0 ;
437
438
                    $self->{isVoir} = 0 ;
                }
439
440
441
                elsif ($self->{isRevers} eq 1)
                {
                    $self->{isRevers} = 2 ;
442
                    $self->{isAtelier} = 0 ;
443
444
445
                    $self->{isCommemo} = 0 ;
                    $self->{isAvers} = 0 ;
                    $self->{isTranche} = 0 ;
446
                    $self->{isComment} = 0 ;
447
448
                    $self->{insideCollec} = 0 ;
                    $self->{insideEch} = 0 ;
449
                    $self->{isVoir} = 0 ;
450
451
452
453
                }
                elsif ($self->{isTranche} eq 1)
                {
                    $self->{isTranche} = 2 ;
454
455
456
457
458
459
460
461
462
463
464
465
466
                    $self->{isAtelier} = 0 ;
                    $self->{isCommemo} = 0 ;
                    $self->{isAvers} = 0 ;
                    $self->{isRevers} = 0 ;
                    $self->{isComment} = 0 ;
                    $self->{insideCollec} = 0 ;
                    $self->{insideEch} = 0 ;
                    $self->{isVoir} = 0 ;
                }
                elsif ($self->{isAtelier} eq 1)
                {
                    $self->{isAtelier} = 2 ;
                    $self->{isTranche} = 0 ;
467
468
469
                    $self->{isCommemo} = 0 ;
                    $self->{isAvers} = 0 ;
                    $self->{isRevers} = 0 ;
470
                    $self->{isComment} = 0 ;
471
472
                    $self->{insideCollec} = 0 ;
                    $self->{insideEch} = 0 ;
473
                    $self->{isVoir} = 0 ;
474
475
476
                }
                elsif ($self->{isComment} eq 1)
                {
477
                    $self->{isComment} = 2 ;
478
                    $self->{isTranche} = 0 ;
479
                    $self->{isAtelier} = 0 ;
480
481
482
                    $self->{isCommemo} = 0 ;
                    $self->{isAvers} = 0 ;
                    $self->{isRevers} = 0 ;
483
484
                    $self->{insideCollec} = 0 ;
                    $self->{insideEch} = 0 ;
485
                    $self->{isVoir} = 0 ;
486
487
488
                }
                elsif ($self->{isVoir} eq 1)
                {
489
490
                    $self->{isVoir} = 2 ;
                    $self->{isComment} = 0 ;
491
                    $self->{isTranche} = 0 ;
492
                    $self->{isAtelier} = 0 ;
493
494
495
                    $self->{isCommemo} = 0 ;
                    $self->{isAvers} = 0 ;
                    $self->{isRevers} = 0 ;
496
497
498
                    $self->{insideCollec} = 0 ;
                    $self->{insideEch} = 0 ;
                    $self->{insideDesc} = 0 ;
499
500
                }
            }
501
            elsif (($tagname eq "a") && ($self->{isTranche} eq 2))
502
            {
503
504
505
506
507
508
509
                # grande image de la tranche
                my $src3 = $attr->{href};

                # le https met la pagaille (pb de certificat ?)
                if (($src3 =~ /https:/)) {
                    $src3 =~ s/https\:/http\:/;
                }
510
                $self->{curInfo}->{edge1} = $src3;
511
512
                $self->{isTranche} = 3;
            }
513
514
515
516
517
518
519
520
521
522
            elsif (($tagname eq "img") && ($self->{isTranche} eq 3) && ($attr->{class} =~ /haut/))
            {
                if ($self->{curInfo}->{edge1} eq "")
                {
                    # petit image de la tranche
                    my $srcp3 = $attr->{src};
                    $self->{curInfo}->{edge1} = $srcp3;
                    $self->{isTranche} = 4;
                }
            }
523
524
525
            elsif ($tagname eq "h3")
            {
                $self->{isAnalyse2} = 1 ;
526
            }
527
528
529
530

            ### la collection
            if (($tagname eq "table") && ($attr->{class} eq "collection"))
            {
531
532
533
534
535
536
                $self->{insideCollec} = 1 ;
                $self->{insidePicture} = 0 ;
                $self->{insideTech} = 0 ;
                $self->{insideSerie} = 0 ;
                $self->{insideDesc} = 0 ;
                $self->{insideEch} = 0 ;
537
                $self->{isVoir} = 0 ;
538
                $self->{isTranche} = 0 ;
539
                $self->{isAtelier} = 0 ;
540
541
542
543
544
545
546
                $self->{isCommemo} = 0 ;
                $self->{isAvers} = 0 ;
                $self->{isRevers} = 0 ;
                $self->{isComment} = 0 ;
            }
            elsif (($tagname eq "td") && ($attr->{class} eq "date"))
            {
547
                $self->{insideCollec} = 2 ;
548
549
550
            }
            elsif (($tagname eq "td") && ($attr->{class} eq "tirage") && ($self->{isAnnee} eq 1))
            {
551
                $self->{insideCollec} = 3 ;
552
            }
553

554
555
           ### les échanges
           # on arrête de remplir les autres champs
556
           # todo : attention, le site a été refondu complètement dans cette partie
557
558
            if (($tagname eq "section") && ($attr->{id} eq "fiche_echanges"))
            {
559
560
561
562
563
564
                $self->{insideEch} = 1 ;
                $self->{insidePicture} = 0 ;
                $self->{insideTech} = 0 ;
                $self->{insideSerie} = 0 ;
                $self->{insideCollec} = 0 ;
                $self->{insideDesc} = 0 ;
565
566
                $self->{isVoir} = 0 ;
                $self->{isTranche} = 0 ;
567
                $self->{isAtelier} = 0 ;
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
                $self->{isCommemo} = 0 ;
                $self->{isAvers} = 0 ;
                $self->{isRevers} = 0 ;
                $self->{isComment} = 0 ;
            }
        }
    }

    # end
    sub end
    {
        my ($self, $tagname) = @_;
        $self->{inside}->{$tagname}--;
        if ($self->{parsingList})
        {
583

584
585
586
587
588
589
590
591
592
593
        }
        else
        {
            # construction du nom de la monnaie
            # doit correspondre à l'ordre de création du nom dans le modèle GCCoins
            $self->{curInfo}->{name} = $self->{curInfo}->{value} ." ". $self->{curInfo}->{currency} ." ". $self->{curInfo}->{year} ." ". $self->{curInfo}->{series};
        }
    }

    # text
594
    # si zéro pièce trouvé, la fenêtre de nouvelle proposition de recherche (pays, km...) s'affiche
595
596
597
598
599
    sub text
    {
        my ($self, $origtext) = @_;
        if ($self->{parsingList})
        {
600
            # au 04/06/2020 la liste de résultat ne s'affiche plus (modification de l'intitulé pièce en résultat)
601
            # au 25/07/2020 la liste ne renvoi plus le bon nombre de pièces, détection fin de pièce cassé (class resultat_recherche_ad en trop google)
602
            # au 31/07/2021 les jetons ne sont plus trouvés (cf CT=exonumia <> coin)
603
            # TODO : la liste des résultats ne se remplie plus correctement, pb de balise BR
604
            if ((($origtext =~ /(\d+) résultat trouvé/) || ($origtext =~ /(\d+) résultats trouvés/) || ($origtext =~ /(\d+) r..?sultats trouv..?s/) || ($origtext =~ /(\d+) r..?sultat trouv..?/)) && ($1 > 0))
605
606
607
608
609
            {
                $self->{insideResults} = 1;
            }
            elsif ($self->{isCoin} eq 6)
            {
610
611
612
613
                # Enlève les blancs en début de chaine
                $origtext =~ s/^\s*//;

                # nom
614
                $self->{itemsList}[ $self->{itemIdx} ]->{name} .= $origtext;
615
616
617
618
619
620
621
622
623
624
625
                
                # valeur (marche pas)
                if ($origtext =~ /^([0-9]{1,10})/)
                {
                    $self->{curInfo}->{value} .= $1;
                }

                # Enlève les blancs en fin de chaine
                $origtext =~ s/\s*$//;
                # série
                $self->{itemsList}[ $self->{itemIdx} ]->{series} .= $origtext;
626
            }
627
             elsif ($self->{isCoin} eq 7)
628
            {
629
630
                # année
                if ($origtext =~ /([0-9]{1,4}-[0-9]{1,4})/)
631
                {
632
                    $self->{itemsList}[ $self->{itemIdx} ]->{year} .= $1;
633
                }
634
                elsif ($origtext =~ /([0-9]{1,4})/)
635
                {
636
                    $self->{itemsList}[ $self->{itemIdx} ]->{year} .= $1;
637
                }
638
639
640
641
642
643
644
645
646
647
648
             }
              elsif ($self->{isCoin} eq 8)
            {
                # TODO : au 25/07/2020, si commémorative, décalage d'une balise BR
                
                # Enlève les blancs en début de chaine
                $origtext =~ s/^\s*//;

                # métal
                # remplir la colonne métal dans le résultat de la recherche
                # todo : trouver un autre moyen de détection du métal
649
                if ($origtext =~ /Argent |Or |Cuivre|Bronze|Cupro|Bi-m|Alu|Nickel|Zinc|Laiton|Fer |Acier|Alliage|Billon|Maille|Etain/)
650
651
652
653
654
655
656
657
658
659
660
661
662
                {
                    $self->{itemsList}[ $self->{itemIdx} ]->{metal} .= $origtext;
                }
                
                # rattrapage si vide : commémorative ou essai (on prend tout)
                 if ($self->{itemsList}[ $self->{itemIdx} ]->{metal} eq "")
                {
                    # Enlève les blancs en début de chaine
                    $origtext =~ s/^\s*//;
                    # Enlève les blancs en fin de chaine
                    $origtext =~ s/\s*$//;
                    $self->{itemsList}[ $self->{itemIdx} ]->{metal} .= $origtext;
                 }
663
            }
664
              elsif ($self->{isCoin} eq 9)
665
            {
666
667
668
669
                # Enlève les blancs en début de chaine
                $origtext =~ s/^\s*//;

                # référence
670
                # il faut récupérer la première référence Krause (KM) seulement
671
                if ($origtext =~ /(KM\# \d+\D?\.?\d*\D?\d*)|(KM\# \d+\D?\.?\d*\D?\d*)|(KM\#\d+\D?\.?\d*\D?\d*)|(KM\#\d+\D?\.?\d*\D?\d*)\,/)
672
673
674
                {
                    $self->{itemsList}[ $self->{itemIdx} ]->{number1} = $1;
                }
675
                elsif ($origtext =~ /(Y\# \d+\D?\.?\d*\D?\d*)|(Y\# \d+\D?\.?\d*\D?\d*)|(Y\#\d+\D?\.?\d*\D?\d*)|(Y\#\d+\D?\.?\d*\D?\d*)\,/)
676
677
678
                {
                    $self->{itemsList}[ $self->{itemIdx} ]->{number1} = $1;
                }
679
                elsif ($origtext =~ /(C\# \d+\D?\.?\d*\D?\d*)|(C\# \d+\D?\.?\d*\D?\d*)|(C\#\d+\D?\.?\d*\D?\d*)|(C\#\d+\D?\.?\d*\D?\d*)\,/)
680
681
682
                {
                    $self->{itemsList}[ $self->{itemIdx} ]->{number1} = $1;
                }
683
                elsif ($origtext =~ /(X\# \d+\D?\.?\d*\D?\d*)|(X\# \d+\D?\.?\d*\D?\d*)|(X\#\d+\D?\.?\d*\D?\d*)|(X\#\d+\D?\.?\d*\D?\d*)\,/)
684
685
686
                {
                    $self->{itemsList}[ $self->{itemIdx} ]->{number1} = $1;
                }
687
                elsif ($origtext =~ /(KM\# [A-Z]{0,2}\d+\D?\.?\d*\D?\d*)|(KM\# [A-Z]{0,2}\d+\D?\.?\d*\D?\d*)|(KM\#[A-Z]{0,2}\d+\D?\.?\d*\D?\d*)|(KM\#[A-Z]{0,2}\d+\D?\.?\d*\D?\d*)\,/)
688
689
690
                {
                    $self->{itemsList}[ $self->{itemIdx} ]->{number1} = $1;
                }
691
                elsif ($origtext =~ /(Y\# [A-Z]{0,2}\d+\D?\.?\d*\D?\d*)|(Y\# [A-Z]{0,2}\d+\D?\.?\d*\D?\d*)|(Y\#[A-Z]{0,2}\d+\D?\.?\d*\D?\d*)|(Y\#[A-Z]{0,2}\d+\D?\.?\d*\D?\d*)\,/)
692
693
694
                {
                    $self->{itemsList}[ $self->{itemIdx} ]->{number1} = $1;
                }
695
696
                # on vire la virgule de fin
                $self->{itemsList}[ $self->{itemIdx} ]->{number1} =~ s/,//gi;
697
698
699
                
                # en cas d'absence de référence kreuze (antique par exemple)
                 if ($self->{itemsList}[ $self->{itemIdx} ]->{number1} eq "")
700
                {
701
702
703
704
705
706
707
708
                     $self->{itemsList}[ $self->{itemIdx} ]->{number1} .= $origtext;
                 }

            }
              elsif ($self->{isCoin} eq 10)
            {
               # on doit passer à la pièce suivante
                $self->{isCoin} = 0;
709
710
711
712
713
714
715
716
            }
        }
        else
        {
            # Enlève les blancs en début de chaine
            $origtext =~ s/^\s*//;
            # Enlève les blancs en fin de chaine
            $origtext =~ s/\s*$//;
717
            
718
            return if ($origtext eq '');
719
720
721
722
723
724
725
726
727
728
729
730
731
            if ($self->{insideSerie} eq 1)
            {
                if ($self->{inside}->{h1})
                {
                    $self->{curInfo}->{series} .= $origtext;
                }
            }
            elsif ($self->{insideSerie} eq 2)
            {
                # on complète la série avec la balise <span> si elle existe !
                $self->{curInfo}->{series} .= " (" . $origtext . ")";
                $self->{insideSerie} = 0;
            }
732
733

            if ($self->{isAnalyse} eq 1)
734
735
            {
                $self->{isCountry} = 1 if ($origtext =~ m/Emetteur/i);
736
                $self->{isAutorit} = 1 if ($origtext =~ m/Autorit/i);
737
                $self->{isPeriod} = 1 if ($origtext =~ m/P..?riode/i);
738
                $self->{isType} = 1 if ($origtext =~ m/Type/i);
739
740
741
742
                # TODO : au 25/07/2020, il y a confusion avec le mot "Date" sans S dans le tableau des tirages
                # en cas d'année unique, par exemple les commémoratives (cf rattrapage)
                #$self->{isYear} = 1 if (($origtext =~ m/^Dates/i) || ($origtext =~ m/^Date/i));
                $self->{isYear} = 1 if ($origtext =~ m/Dates/i);
743
744
                $self->{isCalend} = 1 if ($origtext =~ m/Calendrier/i);
                $self->{isValue} = 1 if ($origtext =~ m/Valeur/i);
745
                $self->{isCurrency} = 1 if ($origtext =~ m/Devise/i);
746
                $self->{isMetal} = 1 if ($origtext =~ m/Composition/i);
747
748
749
750
751
752
                $self->{isWeight} = 1 if ($origtext =~ m/Poids/i);
                $self->{isDiameter} = 1 if ($origtext =~ m/Diam..?tre/i);
                $self->{isDepth} = 1 if ($origtext =~ m/Epaisseur/i);
                $self->{isForm} = 1 if ($origtext =~ m/Forme/i);
                $self->{isAxis} = 1 if ($origtext =~ m/Orientation/i);
                $self->{isDemon} = 1 if ($origtext =~ m/D..?mon..?tis..?e/i);
753
754
                # TODO : au 31/07/2021, il y a une ligne Numéro en plus
                $self->{isNum} = 1 if ($origtext =~ m/Num..?ro/i);
755
756
757
758
759
760
                $self->{isRef} = 1 if ($origtext =~ m/R..?f..?rences/i);

                $self->{isAnalyse} = 0 ;
            }
            elsif ($self->{isCountry} eq 3)
            {
761
762
                return if ($origtext =~ m/Jetons/i);
                $origtext =~ s/[()]//g;
763
764
765
                $self->{curInfo}->{country} .= $origtext;
                $self->{isCountry} = 0 ;
            }
766
767
768
769
770
771
            elsif ($self->{isAutorit} eq 2)
            {
                # en attendant mieux, on colle en commentaire
                $self->{curInfo}->{comments} .= $origtext."\n";
                $self->{isAutorit} = 0 ;
            }
772
773
774
            elsif ($self->{isPeriod} eq 2)
            {
                # en attendant mieux, on colle en commentaire
775
                $self->{curInfo}->{comments} .= "Période : ".$origtext."\n";
776
777
                $self->{isPeriod} = 0 ;
            }
778
779
780
            elsif ($self->{isType} eq 2)
            {
                $origtext =~ s/,/\./g;
781
782
783
784
                $origtext = 'coin' if ($origtext =~ m/Pi..?ce courante/i);
                $origtext = 'token' if ($origtext =~ m/Jeton/i);
                $origtext = 'medal' if ($origtext =~ m/M..?daille/i);
                $origtext = 'an_coin' if ($origtext =~ m/Pi..?ce circulante comm..?morative/i);
785
786
787
788
                $origtext = 'nc_coin' if ($origtext =~ m/Pi..?ce non circulante/i);
                $self->{curInfo}->{type} = $origtext;
                $self->{isType} = 0 ;
            }
789
790
791
792
            elsif ($self->{isYear} eq 2)
            {
                if ($origtext =~ /^([0-9]{1,4})/)
                {
793
794
795
796
                    # pour le moment c'est la première date d'une fourchette
                    # par exemple prend 1959 quand il y a 1959-1982
                    $self->{curInfo}->{year} = $1;
                    # todo : prendre la date de la recherche initiale (si elle existe)
797
                }
798
                if ($origtext =~ /^([0-9]{1,4}-[0-9]{1,4})/)
799
800
801
802
803
804
805
806
807
808
809
                {
                    $self->{curInfo}->{years_of_coinage} = $1;
                }
                elsif ($origtext =~ /^([0-9]{1,4})/)
                {
                    $self->{curInfo}->{years_of_coinage} = $1;
                }
                $self->{isYear} = 0 ;
            }
            elsif ($self->{isCalend} eq 2)
            {
810
                $self->{curInfo}->{calendar} = $origtext;
811
812
813
814
                $self->{isCalend} = 0 ;
            }
            elsif ($self->{isValue} eq 2)
            {
815
                # on se trouve sur la ligne qui affiche : valeur+devise+(valeur+unité)
816
                # on remplace la virgule par le point
817
                # a cause de la notation américaine des nombres dans GCStar
818
819
820
                $origtext =~ s/,/\./g;
                # on enlève les tabulations
                $origtext =~ s/\t/ /g;
821
                if ($origtext =~ /^([0-9]{1,3} [0-9]{3} [0-9]{3}) /)
Kerenoc's avatar
Kerenoc committed
822
                {
823
824
                   # on se trouve sur un format de nombre avec des espaces
                   # exemple : 1 000 000 Francs CFA (Éléphant d'Afrique)
Kerenoc's avatar
Kerenoc committed
825
826
                    $self->{curInfo}->{value} = $1;
                }
827
                elsif ($origtext =~ /^(\d+) |^(\d+\.?\d*) /)
828
                {
829
830
831
                    # todo : récupérer des valeurs avec décimal
                    # exemple : 2,50 euros The Family of Man
                    $self->{curInfo}->{value} = $1;
832
                }
833
834
                elsif ($origtext =~ /^(\d\/\d+) /)
                {
835
836
                    # on se trouve avec des fractions 1/2, 1/4, 1/8, 1/12, 1/16 ...
                    # il faut transformer en 0.50, 0.25, , 0.125, 0.083, 0.0625 ...
837
838
839
840
841
                    my $val = $1;
                    $val =~ s/1\/2/0\.50/;
                    $val =~ s/1\/4/0\.25/;
                    $val =~ s/1\/8/0\.125/;
                    $val =~ s/1\/12/0\.083/;
842
                    $val =~ s/1\/16/0\.0625/;
843
844
845
846
847
848
849
850
851
                    $self->{curInfo}->{value} = $val;
                }
                
                if ($origtext =~ /^[0-9]{1,3} [0-9]{3} [0-9]{3} (\w+ \w+)|^[0-9]{1,3} [0-9]{3} [0-9]{3} (\w+)/)
                {
                    # on se trouve sur un format de nombre avec des espaces
                    $self->{curInfo}->{currency} = $1;
                }
                elsif (($origtext =~ /^\d+ (\w+ de \w+)/) || ($origtext =~ /^\d+ (\w+ d'\w+)/))
852
853
854
855
                {
                    # si devise et sous-devise (plusieurs mots)
                    # pour "cent d'euro" ou "centime de franc", on récupère tout
                    # attention, il peut n'y avoir qu'un seul mot (cents)
856
                    $self->{curInfo}->{currency} = $1;
857
                }
858
                elsif (($origtext =~ /^\d+ (\w+ \w+)|^\d+\.?\d* (\w+ \w+)/) || ($origtext =~ /^\d+ (\w+)|^\d+\.?\d* (\w+)/))
859
                {
860
861
862
                    # todo : récupérer aussi quand des valeurs avec décimal
                    # exemple : 2,50 euros The Family of Man
                    $self->{curInfo}->{currency} = $1;
863
                }
864
                elsif ($origtext =~ /^\d\/\d (\w+)/)
865
                {
866
                    # les valeurs sous forme de fractions
867
                    $self->{curInfo}->{currency} = $1;
868
869
870
871
                }
                if ($self->{curInfo}->{value} eq "")
                {
                    # si la valeur est vide, on peut rattraper avec la série
872
                    if (($self->{curInfo}->{series} =~ /^(\d+) /) || ($self->{curInfo}->{series} =~ /^(\d\/\d+) /))
873
874
875
876
877
878
879
                    {
                        $self->{curInfo}->{value} = $1;
                    }
                }
                if ($self->{curInfo}->{currency} eq "")
                {
                    # si la devise est vide, on peut rattraper avec la série
880
                    if (($self->{curInfo}->{series} =~ /^\d+ (\w+)/) || ($self->{curInfo}->{series} =~ /^\d\/\d+ (\w+)/))
881
882
883
884
                    {
                        $self->{curInfo}->{currency} = $1;
                    }
                }
885
                $self->{isValue} = 0 ;
886
887
888
889
890
891
892
893
894
895
            }
             elsif ($self->{isDevise} eq 2)
            {
                if ($self->{curInfo}->{currency} eq "")
                {
                    $self->{curInfo}->{currency} = $origtext;
                }
                # TODO : en attendant, juste en commentaire, pas de remplacement de la détection de la devise.
                $self->{curInfo}->{comments} .= $origtext."\n";
                $self->{isDevise} = 0 ;
896
897
898
            }
            elsif ($self->{isMetal} eq 2)
            {
899
900
901
902
903
                # todo : parfois le pour mille est un carré ‰
                # il faudrait mettre le bon caractère
                # problème de codification ISO-8859-1 vers UTF8
                $origtext =~ s/&#8240;/‰/gi;
                $origtext =~ s/&permil;/‰/gi;
904
                $origtext =~ s/‰/‰/g;
905
906
                
                # uniformiser les métaux
907
908
                $origtext =~ s/Cupronickel/Cupro-nickel/gi;
                $origtext =~ s/Bimétallique/Bi-métallique/gi;
909
                # nouveau champ métal avec plusieurs valeurs possibles
910
911
912
913
914
                # chaque valeur séparée par une virgule
                # todo : revoir les types de séparateur existant sur Numista
                # exemple 2 euros All 2007 : Bi-métallique ; centre : maillechort - anneau : cupronickel
                # exemple 2 livres Gib 1998 : Bimétallique : centre en cupronickel, anneau en laiton
                # exemple 20 francs Mon 1992 : Trimétallique : Cu 92%, Al 6%, Ni 2% / nickel / Cu 92%, Al 6%, Ni 2%
915
916
917
918
919
920
921
922
                if ($origtext =~ /(\d+\,?\d*)‰/)
                {
                    # remplacer la virgule décimale par un point sinon 2 métaux au lieu d'un seul
                    # attention, le point peut servir pour le séparateur décimal à la place de la virgule
                    # exemple : argent 999,9‰
                    $origtext =~ s/\,/\./;
                }
                $origtext =~ s/ \: | \(|\)| \; | - | et | ou | \+ | entouré | \/ /\,/gi;
923
                $self->{curInfo}->{metal} .= $origtext;
924
925
926
927
                $self->{isMetal} = 0 ;
            }
            elsif ($self->{isWeight} eq 2)
            {
928
                # on remplace la virgule par le point
929
                $origtext =~ s/,/\./g;
930
931
                # on rajoute la détection des poids de plus de 1 000 g
                if (($origtext =~ /^([0-9]{1,3} [0-9]{3}) g/) || ($origtext =~ /(\d+\.?\d*) g/))
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
                {
                    $self->{curInfo}->{weight} = $1;
                }
                $self->{isWeight} = 0 ;
            }
            elsif ($self->{isDiameter} eq 2)
            {
                $origtext =~ s/,/\./g;
                if ($origtext =~ /(\d+\.?\d*) mm/)
                {
                    $self->{curInfo}->{diameter} = $1;
                }
                $self->{isDiameter} = 0 ;
            }
            elsif ($self->{isDepth} eq 2)
            {
                $origtext =~ s/,/\./g;
                if ($origtext =~ /(\d+\.?\d*) mm/)
                {
                    $self->{curInfo}->{depth} = $1;
                }
                $self->{isDepth} = 0 ;
            }
            elsif ($self->{isForm} eq 2)
            {
                $self->{curInfo}->{form} .= $origtext;
                $self->{isForm} = 0 ;
            }
            elsif ($self->{isAxis} eq 2)
            {
962
963
964
                # orientation
                # Frappe monnaie = Monnaie = monetary
                # Frappe médaille = Médaille = medal
965
                if ($origtext =~ /Frappe monnaie/)
966
967
968
                {
                    $self->{curInfo}->{axis} = "monetary";
                }
969
                if ($origtext =~ /Frappe médaille/)
970
971
972
                {
                    $self->{curInfo}->{axis} = "medal";
                }
973
                $self->{isAxis} = 0 ;
974
975
976
977
            }
            elsif ($self->{isDemon} eq 2)
            {
                # todo : mettre un champs démonétisée dans le modèle de collection GCCoins ?
978
                $self->{curInfo}->{comments} .= "Démonétisée : ".$origtext."\n";
979
980
                $self->{isDemon} = 0 ;
            }
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
            elsif ($self->{isNum} eq 2)
            {
                # test niveau 1
                # rien ?
            }
            elsif ($self->{isNum} eq 3)
            {
                if ($origtext =~ /^(N)/)
                {
                    # TODO pour mise au point
                    $self->{curInfo}->{comments} .= "Numéro : ".$origtext;
                }
                $self->{isNum} = 4 ;
            }
            elsif ($self->{isNum} eq 4)
            {
                if ($origtext =~ /(\# )/)
                {
                    # TODO pour mise au point
                    $self->{curInfo}->{comments} .= $1;
                }
                if ($origtext =~ / (\d+)/)
                {
                    # TODO pour mise au point
                    $self->{curInfo}->{comments} .= $1."\n";
                }
                $self->{isNum} = 0 ;
            }
1009
1010
            elsif ($self->{isRef} eq 2)
            {
1011
                # test niveau 1
1012
                # rien ?
1013
1014
1015
            }
            elsif ($self->{isRef} eq 3)
            {
1016
                # test niveau 2
1017
1018
                # avant le 04/10/2019 le contenu de la balise <abbr> (KM) + la valeur (#757)
                # modification après le 04/10/2019 : KM dans la balise <abbr> et la valeur (#757) en dehors
1019
                # modification après 31/07/2021 : plus de balise <abbr>, maintenant c'est dans un lien <a>
1020
                if ($origtext =~ /^(KM|Y|C|X)/)
1021
                {
1022
                    $self->{curInfo}->{number1} .= $1;
1023
                    $self->{curInfo}->{catalogue1} = "World Coins";
1024
                    $self->{isRef} = 4 ;
1025
                }
1026
1027
1028
            }
            elsif ($self->{isRef} eq 4)
            {
1029
                # la suite de la balise <td> ? (entre a et div) :
1030
1031
1032
1033
1034
                if ($origtext =~ /(\# )/)
                {
                    $self->{curInfo}->{number1} .= $1;
                }
                if ($origtext =~ /(\d+\D?\.?\d*\D?\d*)|([A-Z]{0,2}\d+\D?\.?\d*\D?\d*)|(\d+\D?\.?\d*\D?\d*)\,|([A-Z]{0,2}\d+\D?\.?\d*\D?\d*)\,/)
1035
1036
                {
                    $self->{curInfo}->{number1} .= $1;
1037
1038
                    # on vire la virgule 
                    $self->{curInfo}->{number1} =~ s/,//gi;
1039
1040
                    # on vire l'espace dedans pour faciliter la recherche par référence
                    $self->{curInfo}->{number1} =~ s/ //;
1041
                }
1042
                 $self->{isRef} = 0 ;
1043
            }
1044

1045
1046
1047
1048
1049
1050
                if ($self->{isAnalyse2} eq 1)
                {
                    $self->{isCommemo} = 1 if ($origtext =~ m/Pi..?ce comm..?morative/i);
                    $self->{isAvers} = 1 if ($origtext =~ m/Avers/i);
                    $self->{isRevers} = 1 if ($origtext =~ m/Revers/i);
                    $self->{isTranche} = 1 if ($origtext =~ m/Tranche/i);
1051
                    $self->{isAtelier} = 1 if (($origtext =~ m/Ateliers mon..?taires/i) || ($origtext =~ m/Atelier mon..?taire/i));
1052
1053
                    $self->{isComment} = 1 if ($origtext =~ m/Commentaires/i);
                    $self->{isVoir} = 1 if ($origtext =~ m/Voir aussi/i);
1054
                    $self->{isVoir} = 1 if ($origtext =~ m/Obtenir cette/i);
1055
1056
1057
1058
1059
1060
                    $self->{isRevers} = 0 if ($origtext =~ m/Gestion/i); # zone Gestion de ma collection
                    $self->{isAvers} = 0 if ($origtext =~ m/Gestion/i); # zone Gestion de ma collection

                    $self->{isAnalyse2} = 0 ;
                }
                elsif ($self->{isCommemo} eq 2)
1061
                {
1062
1063
1064
1065
1066
1067
1068
1069
1070
                    if ($self->{inside}->{p})
                    {
                        # permet de prendre l'information des pièces commémoratives
                        $self->{curInfo}->{comments} .= $origtext."\n";
                    }
                    elsif ($self->{inside}->{span})
                    {
                        $self->{curInfo}->{comments} .= $origtext."\n";
                    }
1071
                }
1072
                elsif ($self->{isAvers} eq 2)
1073
                {
1074
                    if ($self->{inside}->{p})
1075
1076
1077
1078
1079
1080
1081
1082
                    {
                        # on insère un saut de ligne avant le mot "inscription :"
                        $origtext =~ s/^Inscription/ \nInscription/;
                        # on insère un saut de ligne avant le mot "traduction :"
                        $origtext =~ s/^Traduction/ \nTraduction/;
                        # on insère un saut de ligne avant le mot "graveur :"
                        $origtext =~ s/^Graveur/ \nGraveur/;
                        $self->{curInfo}->{head} .= $origtext;
1083
1084

                        if (($self->{curInfo}->{head}  =~ /Graveur :(.*), né/) || ($self->{curInfo}->{head}  =~ /Graveur :(.*)/))
1085
                        {
1086
1087
                            # todo : ne pas prendre tout le texte derrière le nom du graveur
                            $self->{curInfo}->{mintmaster} .= $1;
1088
1089
1090
                            $self->{isMintmaster} = 0 ;
                        }
                    }
1091
                }
1092
                elsif ($self->{isRevers} eq 2)
1093
                {
1094
                    if ($self->{inside}->{p})
1095
                    {
1096
1097
1098
1099
1100
1101
1102
                        # on insère un saut de ligne avant le mot "inscription :"
                        $origtext =~ s/^Inscription/ \nInscription/;
                        # on insère un saut de ligne avant le mot "traduction :"
                        $origtext =~ s/^Traduction/ \nTraduction/;
                        # on insère un saut de ligne avant le mot "graveur :"
                        $origtext =~ s/^Graveur/ \nGraveur/;
                        $self->{curInfo}->{tail} .= $origtext;
1103
1104

                        if (($self->{curInfo}->{tail} =~ /Graveur :(.*), né/) || ($self->{curInfo}->{tail} =~ /Graveur :(.*)/))
1105
                        {
1106
1107
                            # todo : ne pas prendre tout le texte derrière le nom du graveur
                            $self->{curInfo}->{mintmaster} .= " ".$1;
1108
1109
                            $self->{isMintmaster} = 0 ;
                        }
1110
1111
                    }
                }
1112
                elsif ($self->{isTranche} eq 2)
1113
                {
1114
                    if ($self->{inside}->{p})
1115
                    {
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
                        # on insère un saut de ligne avant le mot "inscription :"
                        $origtext =~ s/^Inscription/ \nInscription/;
                        # on insère un saut de ligne avant le mot "traduction :"
                        $origtext =~ s/^Traduction/ \nTraduction/;
                        # on insère un saut de ligne avant le mot "graveur :"
                        $origtext =~ s/^Graveur/ \nGraveur/;
                        $self->{curInfo}->{edge} .= $origtext;
                        
                        # enlever le point de fin de ligne pour le type de tranche seulement
                        # todo : ne marche pas avec les phrases complètes
                        $origtext =~ /(.*)\.$/;
                        $self->{curInfo}->{edge_type} .= $1;
                        # si vide on prend tout
                        if ($1 eq "")
                        {
                            $self->{curInfo}->{edge_type} .= $origtext;
                        }
1133
1134
                    }
                }
1135
1136
1137
1138
1139
1140
                elsif ($self->{isAtelier} eq 2)
                {
                    # todo : voir à prendre le contenu d'un tableau (actuellement ne fonctionne pas avec l'allemagne)
                    $self->{curInfo}->{comments} .= $origtext."\n";
                    $self->{isAtelier} = 0 ;
                }
1141
1142
1143
                elsif ($self->{isComment} eq 2)
                {
                    if ($self->{inside}->{p})
1144
                    {
1145
1146
                        $self->{curInfo}->{comments} .= $origtext."\n";
                        $self->{isComment} = 0 ;
1147
1148
                    }
                }
1149
                elsif ($self->{isVoir} eq 2)
1150
                {
1151
                    # rien a prendre (fin de la page)
1152
                    $self->{isVoir} = 0 ;