Attachment #135425 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";
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 C4::Biblio qw(GetAuthorisedValueDesc);

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

    my $opac          = $interface eq 'opac' ? 1 : 0;

    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};
                        my $category = $av->{$tag}->{$letter}->{category};
                        $value = $av->{$tag}->{$letter}->{$category}->{$value}
                          ->{$desc_field} || $value;
                    }
                    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
                AND authorised_value!=''
                AND frameworkcode=?"
    );
    $sth->execute($frameworkcode);
    my $av_structure = {};
    while ( my ( $tag, $letter, $category ) = $sth->fetchrow() ) {
        $av_structure->{$tag}->{$letter}->{category} = $category;
        if ( $category eq 'branches' ) {
            my $libraries = {
                map {
                    $_->branchcode => {
                        lib_opac => $_->branchname,
                        lib => $_->branchname
                    }
                } Koha::Libraries->search()->as_list
            };
            $av_structure->{$tag}->{$letter}->{$category} = $libraries;
        }
        elsif ( $category eq 'itemtypes' ) {
            my $itemtypes = {
                map {
                    $_->itemtype => {
                        lib_opac => $_->translated_description,
                        lib      => $_->translated_description
                    }
                } Koha::ItemTypes->search()->as_list
            };
            $av_structure->{$tag}->{$letter}->{$category} = $itemtypes;
        }
        elsif ( $category eq 'cn_source' ) {
            my $cn_sources = {
                map {
                    $_->cn_source => {
                        lib_opac => $_->description,
                        lib => $_->description
                    }
                } Koha::ClassSources->search()->as_list
            };
            $av_structure->{$tag}->{$letter}->{$category} = $cn_sources;
        }
        else {
            my $authorised_values = {
                map {
                    $_->{authorised_value} =>
                      { lib => $_->lib, lib_opac => $_->lib_opac }
                } @{ Koha::AuthorisedValues->search(
                        { category => $category },
                        {
                            columns => [ 'authorised_value', 'lib_opac', 'lib' ]
                        }
                    )->unblessed
                }
            }
        } 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;
- 

Return to bug 30848

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

(-)a/Koha/Filter/MARC/ExpandAuthorizedValues.pm (-89 / +43 lines)
49		49
50	use Modern::Perl;	50	use Modern::Perl;
51		51
		52	use C4::Biblio qw(GetAuthorisedValueDesc);
		53
52	use Koha::Caches;	54	use Koha::Caches;
53	use Koha::ClassSources;	55	use Koha::ClassSources;
54	use Koha::Libraries;	56	use Koha::Libraries;
Lines 75-187 sub filter { Link Here
75	my $opac = $interface eq 'opac' ? 1 : 0;	77	my $opac = $interface eq 'opac' ? 1 : 0;
76		78
77	my $marcflavour = C4::Context->preference('marcflavour');	79	my $marcflavour = C4::Context->preference('marcflavour');
78	my $av = _getAuthorisedValues4MARCSubfields($frameworkcode);	80	my $coded_fields = _getCodedFields($frameworkcode);
79		81
80	my $desc_field = $opac ? 'lib_opac' : 'lib';	82	my $desc_field = $opac ? 'lib_opac' : 'lib';
81	foreach my $tag ( keys %$av ) {	83	for my $tag ( keys %$coded_fields ) {
82	foreach my $field ( $record->field($tag) ) {	84	for my $field ( $record->field($tag) ) {
83	if ( $av->{$tag} ) {	85	my @new_subfields = ();
84	my @new_subfields = ();	86	for my $subfield ( $field->subfields() ) {
85	for my $subfield ( $field->subfields() ) {	87	my ( $letter, $value ) = @$subfield;
86	my ( $letter, $value ) = @$subfield;	88
87		89	# Replace the field value with the authorised value
88	# Replace the field value with the authorised value	90	# except for MARC21 field 942$n (suppression in opac)
89	# except for MARC21 field 942$n (suppression in opac)	91	if ( !( $tag eq '942' && $subfield->[0] eq 'n' )
90	if ( !( $tag eq '942' && $subfield->[0] eq 'n' )	92	\|\| $marcflavour eq 'UNIMARC' )
91	\|\| $marcflavour eq 'UNIMARC' )	93	{
92	{	94	$value = GetAuthorisedValueDesc( $tag, $letter, $value, '', $coded_fields, undef, $opac ) if $coded_fields->{$tag}->{$letter};
93	my $category = $av->{$tag}->{$letter}->{category};
94	$value = $av->{$tag}->{$letter}->{$category}->{$value}
95	->{$desc_field} \|\| $value;
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	$frameworkcode //= "";	112	$frameworkcode //= "";
115		113
116	my $cache = Koha::Caches->get_instance();	114	my $cache = Koha::Caches->get_instance();
117	my $cache_key = "MarcAVStructure-$frameworkcode";	115	my $cache_key = "MarcCodedFields-$frameworkcode";
118	my $cached = $cache->get_from_cache( $cache_key, { unsafe => 1 } );	116	my $cached = $cache->get_from_cache( $cache_key, { unsafe => 1 } );
119	return $cached if $cached;	117	return $cached if $cached;
120		118
121	my $dbh = C4::Context->dbh;	119	my $coded_fields = {
122	my $sth = $dbh->prepare(	120	map {
123	"SELECT DISTINCT tagfield, tagsubfield, authorised_value	121	$_->tagfield => {
124	FROM marc_subfield_structure	122	$_->tagsubfield => {
125	WHERE authorised_value IS NOT NULL	123	'authorised_value' => $_->authorised_value
126	AND authorised_value!=''
127	AND frameworkcode=?"
128	);
129	$sth->execute($frameworkcode);
130	my $av_structure = {};
131	while ( my ( $tag, $letter, $category ) = $sth->fetchrow() ) {
132	$av_structure->{$tag}->{$letter}->{category} = $category;
133	if ( $category eq 'branches' ) {
134	my $libraries = {
135	map {
136	$_->branchcode => {
137	lib_opac => $_->branchname,
138	lib => $_->branchname
139	}
140	} Koha::Libraries->search()->as_list
141	};
142	$av_structure->{$tag}->{$letter}->{$category} = $libraries;
143	}
144	elsif ( $category eq 'itemtypes' ) {
145	my $itemtypes = {
146	map {
147	$_->itemtype => {
148	lib_opac => $_->translated_description,
149	lib => $_->translated_description
150	}
151	} Koha::ItemTypes->search()->as_list
152	};
153	$av_structure->{$tag}->{$letter}->{$category} = $itemtypes;
154	}
155	elsif ( $category eq 'cn_source' ) {
156	my $cn_sources = {
157	map {
158	$_->cn_source => {
159	lib_opac => $_->description,
160	lib => $_->description
161	}
162	} Koha::ClassSources->search()->as_list
163	};
164	$av_structure->{$tag}->{$letter}->{$category} = $cn_sources;
165	}
166	else {
167	my $authorised_values = {
168	map {
169	$_->{authorised_value} =>
170	{ lib => $_->lib, lib_opac => $_->lib_opac }
171	} @{ Koha::AuthorisedValues->search(
172	{ category => $category },
173	{
174	columns => [ 'authorised_value', 'lib_opac', 'lib' ]
175	}
176	)->unblessed
177	}	124	}
178	};	125	}
179	$av_structure->{$tag}->{$letter}->{$category} = $authorised_values;	126	} Koha::MarcSubfieldStructures->search(
180	}	127	{
181	}	128	frameworkcode => $frameworkcode,
		129	authorised_value => { '>' => '' }
		130	},
		131	{
		132	columns => [ 'tagfield', 'tagsubfield', 'authorised_value' ],
		133	order_by => [ 'tagfield', 'tagsubfield' ]
		134	}
		135	)->as_list
		136	};
182		137
183	$cache->set_in_cache( $cache_key, $av_structure );	138	$cache->set_in_cache( $cache_key, $coded_fields );
184	return $av_structure;	139	return $coded_fields;
185	}	140	}
186		141
187	1;	142	1;
188	-