View | Details | Raw Unified | Return to bug 30848
Collapse All | Expand All

(-)a/C4/Biblio.pm (-10 / +57 lines)
Lines 98-103 use C4::Charset qw( Link Here
98
    SetUTF8Flag
98
    SetUTF8Flag
99
    StripNonXmlChars
99
    StripNonXmlChars
100
);
100
);
101
use C4::Languages;
101
use C4::Linker;
102
use C4::Linker;
102
use C4::OAI::Sets;
103
use C4::OAI::Sets;
103
use C4::Items qw( GetHiddenItemnumbers GetMarcItem );
104
use C4::Items qw( GetHiddenItemnumbers GetMarcItem );
Lines 1464-1488 descriptions rather than normal ones when they exist. Link Here
1464
sub GetAuthorisedValueDesc {
1465
sub GetAuthorisedValueDesc {
1465
    my ( $tag, $subfield, $value, $framework, $tagslib, $category, $opac ) = @_;
1466
    my ( $tag, $subfield, $value, $framework, $tagslib, $category, $opac ) = @_;
1466
1467
1468
    my $cache     = Koha::Caches->get_instance();
1469
    my $cache_key;
1467
    if ( !$category ) {
1470
    if ( !$category ) {
1468
1471
1469
        return $value unless defined $tagslib->{$tag}->{$subfield}->{'authorised_value'};
1472
        return $value unless defined $tagslib->{$tag}->{$subfield}->{'authorised_value'};
1470
1473
1471
        #---- branch
1474
        #---- branch
1472
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "branches" ) {
1475
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "branches" ) {
1473
            my $branch = Koha::Libraries->find($value);
1476
            $cache_key = "LibraryNames";
1474
            return $branch? $branch->branchname: q{};
1477
            my $libraries = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
1478
            if ( !$libraries ) {
1479
                $libraries = {
1480
                    map { $_->branchcode => $_->branchname }
1481
                      Koha::Libraries->search( {},
1482
                        { columns => [ 'branchcode', 'branchname' ] } )
1483
                      ->as_list
1484
                };
1485
                $cache->set_in_cache($cache_key, $libraries);
1486
            }
1487
            return $libraries->{$value};
1475
        }
1488
        }
1476
1489
1477
        #---- itemtypes
1490
        #---- itemtypes
1478
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "itemtypes" ) {
1491
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "itemtypes" ) {
1479
            my $itemtype = Koha::ItemTypes->find( $value );
1492
            my $lang = C4::Languages::getlanguage;
1480
            return $itemtype ? $itemtype->translated_description : q||;
1493
            $lang //= 'en';
1494
            $cache_key = $lang . 'ItemTypeDescriptions';
1495
            my $itypes = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
1496
            if ( !$itypes ) {
1497
                $itypes =
1498
                  { map { $_->itemtype => $_->translated_description }
1499
                      Koha::ItemTypes->search()->as_list };
1500
                $cache->set_in_cache( $cache_key, $itypes );
1501
            }
1502
            return $itypes->{$value};
1481
        }
1503
        }
1482
1504
1483
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "cn_source" ) {
1505
        if ( $tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "cn_source" ) {
1484
            my $source = GetClassSource($value);
1506
            $cache_key = "ClassSources";
1485
            return $source ? $source->{description} : q||;
1507
            my $cn_sources = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
1508
            if ( !$cn_sources ) {
1509
                $cn_sources = {
1510
                    map { $_->cn_source => $_->description }
1511
                      Koha::ClassSources->search( {},
1512
                        { columns => [ 'cn_source', 'description' ] } )
1513
                      ->as_list
1514
                };
1515
                $cache->set_in_cache($cache_key, $cn_sources);
1516
            }
1517
            return $cn_sources->{$value};
1486
        }
1518
        }
1487
1519
1488
        #---- "true" authorized value
1520
        #---- "true" authorized value
Lines 1491-1500 sub GetAuthorisedValueDesc { Link Here
1491
1523
1492
    my $dbh = C4::Context->dbh;
1524
    my $dbh = C4::Context->dbh;
1493
    if ( $category ne "" ) {
1525
    if ( $category ne "" ) {
1494
        my $sth = $dbh->prepare( "SELECT lib, lib_opac FROM authorised_values WHERE category = ? AND authorised_value = ?" );
1526
        $cache_key = "AVDescriptions-" . $category;
1495
        $sth->execute( $category, $value );
1527
        my $av_descriptions = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
1496
        my $data = $sth->fetchrow_hashref;
1528
        if ( !$av_descriptions ) {
1497
        return ( $opac && $data->{'lib_opac'} ) ? $data->{'lib_opac'} : $data->{'lib'};
1529
            $av_descriptions = {
1530
                map {
1531
                    $_->authorised_value =>
1532
                      { lib => $_->lib, lib_opac => $_->lib_opac }
1533
                } Koha::AuthorisedValues->search(
1534
                    { category => $category },
1535
                    {
1536
                        columns => [ 'authorised_value', 'lib_opac', 'lib' ]
1537
                    }
1538
                )->as_list
1539
            };
1540
            $cache->set_in_cache($cache_key, $av_descriptions);
1541
        }
1542
        return ( $opac && $av_descriptions->{$value}->{'lib_opac'} )
1543
          ? $av_descriptions->{$value}->{'lib_opac'}
1544
          : $av_descriptions->{$value}->{'lib'};
1498
    } else {
1545
    } else {
1499
        return $value;    # if nothing is found return the original value
1546
        return $value;    # if nothing is found return the original value
1500
    }
1547
    }
(-)a/Koha/AuthorisedValue.pm (-1 / +32 lines)
Lines 19-25 package Koha::AuthorisedValue; Link Here
19
19
20
use Modern::Perl;
20
use Modern::Perl;
21
21
22
22
use Koha::Caches;
23
use Koha::Database;
23
use Koha::Database;
24
24
25
use base qw(Koha::Object Koha::Object::Limit::Library);
25
use base qw(Koha::Object Koha::Object::Limit::Library);
Lines 34-39 Koha::AuthorisedValue - Koha Authorised value Object class Link Here
34
34
35
=cut
35
=cut
36
36
37
=head3 store
38
39
AuthorisedValue specific store to ensure relevant caches are flushed on change
40
41
=cut
42
43
sub store {
44
    my ($self) = @_;
45
46
    my $flush = 0;
47
48
    if ( !$self->in_storage ) {
49
        $flush = 1;
50
    }
51
    else {
52
        my $self_from_storage = $self->get_from_storage;
53
        $flush = 1 if ( $self_from_storage->lib ne $self->lib );
54
        $flush = 1 if ( $self_from_storage->lib_opac ne $self->lib_opac );
55
    }
56
57
    $self = $self->SUPER::store;
58
59
    if ($flush) {
60
        my $cache = Koha::Caches->get_instance();
61
        my $key = "AVDescriptions-".$self->category;
62
        $cache->clear_from_cache($key);
63
    }
64
65
    return $self;
66
}
67
37
=head3 opac_description
68
=head3 opac_description
38
69
39
my $description = $av->opac_description();
70
my $description = $av->opac_description();
(-)a/Koha/ClassSource.pm (-1 / +28 lines)
Lines 17-23 package Koha::ClassSource; Link Here
17
17
18
use Modern::Perl;
18
use Modern::Perl;
19
19
20
20
use Koha::Caches;
21
use Koha::Database;
21
use Koha::Database;
22
22
23
use base qw(Koha::Object);
23
use base qw(Koha::Object);
Lines 30-37 Koha::ClassSource - Koha Classfication Source Object class Link Here
30
30
31
=head2 Class Methods
31
=head2 Class Methods
32
32
33
=head3 store
34
35
ClassSource specific store to ensure relevant caches are flushed on change
36
33
=cut
37
=cut
34
38
39
sub store {
40
    my ($self) = @_;
41
42
    my $flush = 0;
43
44
    if ( !$self->in_storage ) {
45
        $flush = 1;
46
    }
47
    else {
48
        my $self_from_storage = $self->get_from_storage;
49
        $flush = 1 if ( $self_from_storage->description ne $self->description );
50
    }
51
52
    $self = $self->SUPER::store;
53
54
    if ($flush) {
55
        my $cache = Koha::Caches->get_instance();
56
        $cache->clear_from_cache('ClassSources');
57
    }
58
59
    return $self;
60
}
61
35
=head3 _type
62
=head3 _type
36
63
37
Returns name of corresponding DBIC resultset
64
Returns name of corresponding DBIC resultset
(-)a/Koha/Filter/MARC/ExpandAuthorizedValues.pm (-50 / +59 lines)
Lines 49-61 Filter to replace Koha AV codes in MARC::Records with their Koha AV descriptions Link Here
49
49
50
use Modern::Perl;
50
use Modern::Perl;
51
51
52
use C4::Biblio qw( GetAuthorisedValueDesc GetMarcStructure );
52
use C4::Biblio qw(GetAuthorisedValueDesc);
53
54
use Koha::Caches;
55
use Koha::ClassSources;
56
use Koha::Libraries;
57
use Koha::ItemTypes;
53
58
54
use base qw(Koha::RecordProcessor::Base);
59
use base qw(Koha::RecordProcessor::Base);
55
our $NAME = 'ExpandAuthorizedValues';
60
our $NAME = 'ExpandAuthorizedValues';
56
61
57
my %authval_per_framework; # Cache for tagfield-tagsubfield to decode per framework.
58
59
=head2 filter
62
=head2 filter
60
63
61
Embed items into the MARC::Record object.
64
Embed items into the MARC::Record object.
Lines 69-133 sub filter { Link Here
69
    return unless defined $record and ref($record) eq 'MARC::Record';
72
    return unless defined $record and ref($record) eq 'MARC::Record';
70
73
71
    my $params        = $self->params;
74
    my $params        = $self->params;
72
    my $interface     = $params->{options}->{interface} // 'opac';
75
    my $interface     = $params->{options}->{interface}     // 'opac';
73
    my $opac          = $interface eq 'opac' ? 1 : 0;
74
    my $frameworkcode = $params->{options}->{frameworkcode} // q{};
76
    my $frameworkcode = $params->{options}->{frameworkcode} // q{};
75
    my $marcstructure = $params->{options}->{marcstructure}
77
    my $opac          = $interface eq 'opac' ? 1 : 0;
76
      // GetMarcStructure( 1, $frameworkcode, { unsafe => 1 } );
77
78
78
    my $marcflavour = C4::Context->preference('marcflavour');
79
    my $marcflavour = C4::Context->preference('marcflavour');
79
    my $av          = _getAuthorisedValues4MARCSubfields($frameworkcode);
80
    my $coded_fields = _getCodedFields($frameworkcode);
80
    foreach my $tag ( keys %$av ) {
81
81
        foreach my $field ( $record->field($tag) ) {
82
    my $desc_field = $opac ? 'lib_opac' : 'lib';
82
            if ( $av->{$tag} ) {
83
    for my $tag ( keys %$coded_fields ) {
83
                my @new_subfields = ();
84
        for my $field ( $record->field($tag) ) {
84
                for my $subfield ( $field->subfields() ) {
85
            my @new_subfields = ();
85
                    my ( $letter, $value ) = @$subfield;
86
            for my $subfield ( $field->subfields() ) {
86
87
                my ( $letter, $value ) = @$subfield;
87
                    # Replace the field value with the authorised value
88
88
                    # *except* for MARC21 field 942$n (suppression in opac)
89
                # Replace the field value with the authorised value
89
                    if ( !( $tag eq '942' && $subfield->[0] eq 'n' )
90
                # *except* for MARC21 field 942$n (suppression in opac)
90
                        || $marcflavour eq 'UNIMARC' )
91
                if ( !( $tag eq '942' && $subfield->[0] eq 'n' )
91
                    {
92
                    || $marcflavour eq 'UNIMARC' )
92
                        $value =
93
                {
93
                          GetAuthorisedValueDesc( $tag, $letter, $value, '',
94
                    $value = GetAuthorisedValueDesc( $tag, $letter, $value, '', $coded_fields, undef, $opac ) if $coded_fields->{$tag}->{$letter};
94
                            $marcstructure, undef, $opac )
95
                          if $av->{$tag}->{$letter};
96
                    }
97
                    push( @new_subfields, $letter, $value );
98
                }
95
                }
99
                $field->replace_with(
96
                push( @new_subfields, $letter, $value );
100
                    MARC::Field->new(
101
                        $tag,                 $field->indicator(1),
102
                        $field->indicator(2), @new_subfields
103
                    )
104
                );
105
            }
97
            }
98
            $field->replace_with(
99
                MARC::Field->new(
100
                    $tag,                 $field->indicator(1),
101
                    $field->indicator(2), @new_subfields
102
                )
103
            );
106
        }
104
        }
107
    }
105
    }
108
106
109
    return $record;
107
    return $record;
110
}
108
}
111
109
112
sub _getAuthorisedValues4MARCSubfields {
110
sub _getCodedFields {
113
    my ($frameworkcode) = @_;
111
    my ($frameworkcode) = @_;
114
    unless ( $authval_per_framework{$frameworkcode} ) {
112
    $frameworkcode //= "";
115
        my $dbh = C4::Context->dbh;
113
116
        my $sth = $dbh->prepare(
114
    my $cache     = Koha::Caches->get_instance();
117
            "SELECT DISTINCT tagfield, tagsubfield
115
    my $cache_key = "MarcCodedFields-$frameworkcode";
118
             FROM marc_subfield_structure
116
    my $cached    = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
119
             WHERE authorised_value IS NOT NULL
117
    return $cached if $cached;
120
                AND authorised_value!=''
118
121
                AND frameworkcode=?"
119
    my $coded_fields = {
122
        );
120
        map {
123
        $sth->execute($frameworkcode);
121
            $_->tagfield => {
124
        my $av = {};
122
                $_->tagsubfield => {
125
        while ( my ( $tag, $letter ) = $sth->fetchrow() ) {
123
                    'authorised_value' => $_->authorised_value
126
            $av->{$tag}->{$letter} = 1;
124
                }
127
        }
125
            }
128
        $authval_per_framework{$frameworkcode} = $av;
126
        } Koha::MarcSubfieldStructures->search(
129
    }
127
            {
130
    return $authval_per_framework{$frameworkcode};
128
                frameworkcode    => $frameworkcode,
129
                authorised_value => { '>' => '' }
130
            },
131
            {
132
                columns  => [ 'tagfield', 'tagsubfield', 'authorised_value' ],
133
                order_by => [ 'tagfield', 'tagsubfield' ]
134
            }
135
        )->as_list
136
    };
137
138
    $cache->set_in_cache( $cache_key, $coded_fields );
139
    return $coded_fields;
131
}
140
}
132
141
133
1;
142
1;
(-)a/Koha/ItemType.pm (+31 lines)
Lines 20-25 use Modern::Perl; Link Here
20
20
21
use C4::Koha qw( getitemtypeimagelocation );
21
use C4::Koha qw( getitemtypeimagelocation );
22
use C4::Languages;
22
use C4::Languages;
23
use Koha::Caches;
23
use Koha::Database;
24
use Koha::Database;
24
use Koha::CirculationRules;
25
use Koha::CirculationRules;
25
use Koha::Localizations;
26
use Koha::Localizations;
Lines 36-41 Koha::ItemType - Koha Item type Object class Link Here
36
37
37
=cut
38
=cut
38
39
40
=head3 store
41
42
ItemType specific store to ensure relevant caches are flushed on change
43
44
=cut
45
46
sub store {
47
    my ($self) = @_;
48
49
    my $flush = 0;
50
51
    if ( !$self->in_storage ) {
52
        $flush = 1;
53
    }
54
    else {
55
        my $self_from_storage = $self->get_from_storage;
56
        $flush = 1 if ( $self_from_storage->description ne $self->description );
57
    }
58
59
    $self = $self->SUPER::store;
60
61
    if ($flush) {
62
        my $cache = Koha::Caches->get_instance();
63
        my $key = "enItemTypeDescriptions";
64
        $cache->clear_from_cache($key);
65
    }
66
67
    return $self;
68
}
69
39
=head3 image_location
70
=head3 image_location
40
71
41
=cut
72
=cut
(-)a/Koha/Library.pm (+30 lines)
Lines 22-27 use Modern::Perl; Link Here
22
22
23
use C4::Context;
23
use C4::Context;
24
24
25
use Koha::Caches;
25
use Koha::Database;
26
use Koha::Database;
26
use Koha::StockRotationStages;
27
use Koha::StockRotationStages;
27
use Koha::SMTP::Servers;
28
use Koha::SMTP::Servers;
Lines 36-41 Koha::Library - Koha Library Object class Link Here
36
37
37
=head2 Class methods
38
=head2 Class methods
38
39
40
=head3 store
41
42
Library specific store to ensure relevant caches are flushed on change
43
44
=cut
45
46
sub store {
47
    my ($self) = @_;
48
49
    my $flush = 0;
50
51
    if ( !$self->in_storage ) {
52
        $flush = 1;
53
    }
54
    else {
55
        my $self_from_storage = $self->get_from_storage;
56
        $flush = 1 if ( $self_from_storage->branchname ne $self->branchname );
57
    }
58
59
    $self = $self->SUPER::store;
60
61
    if ($flush) {
62
        my $cache = Koha::Caches->get_instance();
63
        $cache->clear_from_cache('LibraryNames');
64
    }
65
66
    return $self;
67
}
68
39
=head3 stockrotationstages
69
=head3 stockrotationstages
40
70
41
  my $stages = Koha::Library->stockrotationstages;
71
  my $stages = Koha::Library->stockrotationstages;
(-)a/Koha/Localization.pm (+29 lines)
Lines 21-26 use Koha::Database; Link Here
21
21
22
use base qw(Koha::Object);
22
use base qw(Koha::Object);
23
23
24
=head1 NAME
25
26
Koha::Localization - Koha Localization type Object class
27
28
=head1 API
29
30
=head2 Class methods
31
32
=cut
33
34
=head3 store
35
36
Localization specific store to ensure relevant caches are flushed on change
37
38
=cut
39
40
sub store {
41
    my ($self) = @_;
42
    $self = $self->SUPER::store;
43
44
    if ($self->entity eq 'itemtypes') {
45
        my $cache = Koha::Caches->get_instance();
46
        my $key = $self->lang."ItemTypeDescriptions";
47
        $cache->clear_from_cache($key);
48
    }
49
50
    return $self;
51
}
52
24
sub _type {
53
sub _type {
25
    return 'Localization';
54
    return 'Localization';
26
}
55
}
(-)a/admin/biblio_framework.pl (+2 lines)
Lines 80-85 if ( $op eq 'add_form' ) { Link Here
80
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
80
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
81
    $cache->clear_from_cache("default_value_for_mod_marc-");
81
    $cache->clear_from_cache("default_value_for_mod_marc-");
82
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
82
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
83
    $cache->clear_from_cache("MarcCodedFields-$frameworkcode");
83
    $op = 'list';
84
    $op = 'list';
84
} elsif ( $op eq 'delete_confirm' ) {
85
} elsif ( $op eq 'delete_confirm' ) {
85
    my $framework = Koha::BiblioFrameworks->find($frameworkcode);
86
    my $framework = Koha::BiblioFrameworks->find($frameworkcode);
Lines 111-116 if ( $op eq 'add_form' ) { Link Here
111
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
112
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
112
    $cache->clear_from_cache("default_value_for_mod_marc-");
113
    $cache->clear_from_cache("default_value_for_mod_marc-");
113
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
114
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
115
    $cache->clear_from_cache("MarcCodedFields-$frameworkcode");
114
    $op = 'list';
116
    $op = 'list';
115
}
117
}
116
118
(-)a/admin/marc_subfields_structure.pl (+2 lines)
Lines 309-314 elsif ( $op eq 'add_validate' ) { Link Here
309
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
309
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
310
    $cache->clear_from_cache("default_value_for_mod_marc-");
310
    $cache->clear_from_cache("default_value_for_mod_marc-");
311
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
311
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
312
    $cache->clear_from_cache("MarcCodedFields-$frameworkcode");
312
313
313
    print $input->redirect("/cgi-bin/koha/admin/marc_subfields_structure.pl?tagfield=$tagfield&frameworkcode=$frameworkcode");
314
    print $input->redirect("/cgi-bin/koha/admin/marc_subfields_structure.pl?tagfield=$tagfield&frameworkcode=$frameworkcode");
314
    exit;
315
    exit;
Lines 347-352 elsif ( $op eq 'delete_confirmed' ) { Link Here
347
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
348
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
348
    $cache->clear_from_cache("default_value_for_mod_marc-");
349
    $cache->clear_from_cache("default_value_for_mod_marc-");
349
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
350
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
351
    $cache->clear_from_cache("MarcCodedFields-$frameworkcode");
350
    print $input->redirect("/cgi-bin/koha/admin/marc_subfields_structure.pl?tagfield=$tagfield&frameworkcode=$frameworkcode");
352
    print $input->redirect("/cgi-bin/koha/admin/marc_subfields_structure.pl?tagfield=$tagfield&frameworkcode=$frameworkcode");
351
    exit;
353
    exit;
352
354
(-)a/admin/marctagstructure.pl (+2 lines)
Lines 155-160 if ($op eq 'add_form') { Link Here
155
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
155
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
156
    $cache->clear_from_cache("default_value_for_mod_marc-");
156
    $cache->clear_from_cache("default_value_for_mod_marc-");
157
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
157
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
158
    $cache->clear_from_cache("MarcCodedFields-$frameworkcode");
158
    print $input->redirect("/cgi-bin/koha/admin/marctagstructure.pl?searchfield=$tagfield&frameworkcode=$frameworkcode");
159
    print $input->redirect("/cgi-bin/koha/admin/marctagstructure.pl?searchfield=$tagfield&frameworkcode=$frameworkcode");
159
    exit;
160
    exit;
160
													# END $OP eq ADD_VALIDATE
161
													# END $OP eq ADD_VALIDATE
Lines 180-185 if ($op eq 'add_form') { Link Here
180
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
181
    $cache->clear_from_cache("MarcStructure-1-$frameworkcode");
181
    $cache->clear_from_cache("default_value_for_mod_marc-");
182
    $cache->clear_from_cache("default_value_for_mod_marc-");
182
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
183
    $cache->clear_from_cache("MarcSubfieldStructure-$frameworkcode");
184
    $cache->clear_from_cache("MarcCodedFields-$frameworkcode");
183
    $template->param( searchfield => $searchfield );
185
    $template->param( searchfield => $searchfield );
184
													# END $OP eq DELETE_CONFIRMED
186
													# END $OP eq DELETE_CONFIRMED
185
################## ITEMTYPE_CREATE ##################################
187
################## ITEMTYPE_CREATE ##################################
(-)a/t/db_dependent/Koha/Filter/ExpandAuthorizedValues.t (-1 / +1 lines)
Lines 62-67 subtest 'ExpandAuthorizedValues tests' => sub { Link Here
62
    my $cache = Koha::Caches->get_instance;
62
    my $cache = Koha::Caches->get_instance;
63
    $cache->clear_from_cache("MarcStructure-0-");
63
    $cache->clear_from_cache("MarcStructure-0-");
64
    $cache->clear_from_cache("MarcStructure-1-");
64
    $cache->clear_from_cache("MarcStructure-1-");
65
    $cache->clear_from_cache("MarcCodedFields-");
65
    $cache->clear_from_cache("default_value_for_mod_marc-");
66
    $cache->clear_from_cache("default_value_for_mod_marc-");
66
    $cache->clear_from_cache("MarcSubfieldStructure-");
67
    $cache->clear_from_cache("MarcSubfieldStructure-");
67
68
68
- 

Return to bug 30848