Attachment #135716 for bug #30848

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

Lines 98-103 use C4::Charset qw( Link Here

(-)a/C4/Biblio.pm (-10 / +57 lines)
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	}





use Modern::Perl;

use Koha::Caches;
use Koha::Database;

use base qw(Koha::Object Koha::Object::Limit::Library);


=cut

=head3 store

AuthorisedValue specific store to ensure relevant caches are flushed on change

=cut

sub store {
    my ($self) = @_;

    my $flush = 0;

    if ( !$self->in_storage ) {
        $flush = 1;
    }
    else {
        my $self_from_storage = $self->get_from_storage;
        $flush = 1 if ( $self_from_storage->lib ne $self->lib );
        $flush = 1 if ( $self_from_storage->lib_opac ne $self->lib_opac );
    }

    $self = $self->SUPER::store;

    if ($flush) {
        my $cache = Koha::Caches->get_instance();
        my $key = "AVDescriptions-".$self->category;
        $cache->clear_from_cache($key);
    }

    return $self;
}

=head3 opac_description

my $description = $av->opac_description();

Lines 17-23 package Koha::ClassSource; Link Here

(-)a/Koha/ClassSource.pm (-1 / +28 lines)
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





use Modern::Perl;

use C4::Biblio qw(GetAuthorisedValueDesc);

use Koha::Caches;
use Koha::ClassSources;
use Koha::Libraries;
use Koha::ItemTypes;

use base qw(Koha::RecordProcessor::Base);
our $NAME = 'ExpandAuthorizedValues';

my %authval_per_framework; # Cache for tagfield-tagsubfield to decode per framework.

=head2 filter

Embed items into the MARC::Record object.

    return unless defined $record and ref($record) eq 'MARC::Record';

    my $params        = $self->params;
    my $interface     = $params->{options}->{interface}     // 'opac';
    my $opac          = $interface eq 'opac' ? 1 : 0;
    my $frameworkcode = $params->{options}->{frameworkcode} // q{};
    my $opac          = $interface eq 'opac' ? 1 : 0;
      // GetMarcStructure( 1, $frameworkcode, { unsafe => 1 } );

    my $marcflavour = C4::Context->preference('marcflavour');
    my $coded_fields = _getCodedFields($frameworkcode);

    my $desc_field = $opac ? 'lib_opac' : 'lib';
    for my $tag ( keys %$coded_fields ) {
        for my $field ( $record->field($tag) ) {
            my @new_subfields = ();
            for my $subfield ( $field->subfields() ) {
                my ( $letter, $value ) = @$subfield;

                # Replace the field value with the authorised value
                # *except* for MARC21 field 942$n (suppression in opac)
                if ( !( $tag eq '942' && $subfield->[0] eq 'n' )
                    || $marcflavour eq 'UNIMARC' )
                {
                    $value = GetAuthorisedValueDesc( $tag, $letter, $value, '', $coded_fields, undef, $opac ) if $coded_fields->{$tag}->{$letter};
                            $marcstructure, undef, $opac )
                          if $av->{$tag}->{$letter};
                    }
                    push( @new_subfields, $letter, $value );
                }
                push( @new_subfields, $letter, $value );
                    MARC::Field->new(
                        $tag,                 $field->indicator(1),
                        $field->indicator(2), @new_subfields
                    )
                );
            }
            $field->replace_with(
                MARC::Field->new(
                    $tag,                 $field->indicator(1),
                    $field->indicator(2), @new_subfields
                )
            );
        }
    }

    return $record;
}

sub _getCodedFields {
    my ($frameworkcode) = @_;
    $frameworkcode //= "";

    my $cache     = Koha::Caches->get_instance();
    my $cache_key = "MarcCodedFields-$frameworkcode";
    my $cached    = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
    return $cached if $cached;

    my $coded_fields = {
        map {
            $_->tagfield => {
                $_->tagsubfield => {
                    'authorised_value' => $_->authorised_value
                }
            }
        } Koha::MarcSubfieldStructures->search(
            {
                frameworkcode    => $frameworkcode,
                authorised_value => { '>' => '' }
            },
            {
                columns  => [ 'tagfield', 'tagsubfield', 'authorised_value' ],
                order_by => [ 'tagfield', 'tagsubfield' ]
            }
        )->as_list
    };

    $cache->set_in_cache( $cache_key, $coded_fields );
    return $coded_fields;
}

1;





use C4::Koha qw( getitemtypeimagelocation );
use C4::Languages;
use Koha::Caches;
use Koha::Database;
use Koha::CirculationRules;
use Koha::Localizations;


=cut

=head3 store

ItemType specific store to ensure relevant caches are flushed on change

=cut

sub store {
    my ($self) = @_;

    my $flush = 0;

    if ( !$self->in_storage ) {
        $flush = 1;
    }
    else {
        my $self_from_storage = $self->get_from_storage;
        $flush = 1 if ( $self_from_storage->description ne $self->description );
    }

    $self = $self->SUPER::store;

    if ($flush) {
        my $cache = Koha::Caches->get_instance();
        my $key = "enItemTypeDescriptions";
        $cache->clear_from_cache($key);
    }

    return $self;
}

=head3 image_location

=cut





use C4::Context;

use Koha::Caches;
use Koha::Database;
use Koha::StockRotationStages;
use Koha::SMTP::Servers;


=head2 Class methods

=head3 store

Library specific store to ensure relevant caches are flushed on change

=cut

sub store {
    my ($self) = @_;

    my $flush = 0;

    if ( !$self->in_storage ) {
        $flush = 1;
    }
    else {
        my $self_from_storage = $self->get_from_storage;
        $flush = 1 if ( $self_from_storage->branchname ne $self->branchname );
    }

    $self = $self->SUPER::store;

    if ($flush) {
        my $cache = Koha::Caches->get_instance();
        $cache->clear_from_cache('LibraryNames');
    }

    return $self;
}

=head3 stockrotationstages

  my $stages = Koha::Library->stockrotationstages;





use base qw(Koha::Object);

=head1 NAME

Koha::Localization - Koha Localization type Object class

=head1 API

=head2 Class methods

=cut

=head3 store

Localization specific store to ensure relevant caches are flushed on change

=cut

sub store {
    my ($self) = @_;
    $self = $self->SUPER::store;

    if ($self->entity eq 'itemtypes') {
        my $cache = Koha::Caches->get_instance();
        my $key = $self->lang."ItemTypeDescriptions";
        $cache->clear_from_cache($key);
    }

    return $self;
}

sub _type {
    return 'Localization';
}

Lines 80-85 if ( $op eq 'add_form' ) { Link Here

(-)a/admin/biblio_framework.pl (+2 lines)
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

Lines 309-314 elsif ( $op eq 'add_validate' ) { Link Here

(-)a/admin/marc_subfields_structure.pl (+2 lines)
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

Lines 155-160 if ($op eq 'add_form') { Link Here

(-)a/admin/marctagstructure.pl (+2 lines)
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 ##################################

Lines 62-67 subtest 'ExpandAuthorizedValues tests' => sub { Link Here

(-)a/t/db_dependent/Koha/Filter/ExpandAuthorizedValues.t (-1 / +1 lines)
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

Lines 19-25 package Koha::AuthorisedValue; Link Here

(-)a/Koha/AuthorisedValue.pm (-1 / +32 lines)
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();

Lines 49-61 Filter to replace Koha AV codes in MARC::Records with their Koha AV descriptions Link Here

(-)a/Koha/Filter/MARC/ExpandAuthorizedValues.pm (-50 / +59 lines)
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;

Lines 20-25 use Modern::Perl; Link Here

(-)a/Koha/ItemType.pm (+31 lines)
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

Lines 22-27 use Modern::Perl; Link Here

(-)a/Koha/Library.pm (+30 lines)
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;

Lines 21-26 use Koha::Database; Link Here

(-)a/Koha/Localization.pm (+29 lines)
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	}