Koha/C4/AuthoritiesMarc.pm
Galen Charlton 27c312b721 Bug 11533: fix authority searching with no sorting when QueryParser is enabled
This patch fixes an issue where chosing 'None' as the sort order
for an authority search would result in zero hits if QueryParser is
eanbled.

This patch also adds some additional test cases.

To test:

[1] Enable QueryParser.
[2] Perform an authority search in the staff interface that
    uses 'Heading A-Z' as the sort order and returns hits.
[3] Run the same search, but with the sort order set to 'None'.
    No hits are returned.
[4] Apply the patch.
[5] Do step 3 again.  This time, hits should be returned.
[6] Verify that prove -v t/db_dependent/Search.t passes.

Signed-off-by: Galen Charlton <gmc@esilibrary.com>
Signed-off-by: Tomas Cohen Arazi <tomascohen@gmail.com>
Signed-off-by: Kyle M Hall <kyle@bywatersolutions.com>
Signed-off-by: Galen Charlton <gmc@esilibrary.com>
2014-01-24 14:02:48 +00:00

1623 lines
55 KiB
Perl

package C4::AuthoritiesMarc;
# Copyright 2000-2002 Katipo Communications
#
# This file is part of Koha.
#
# Koha 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.
#
# Koha 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 Koha; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
use strict;
use warnings;
use C4::Context;
use MARC::Record;
use C4::Biblio;
use C4::Search;
use C4::AuthoritiesMarc::MARC21;
use C4::AuthoritiesMarc::UNIMARC;
use C4::Charset;
use C4::Log;
use Koha::Authority;
use vars qw($VERSION @ISA @EXPORT);
BEGIN {
# set the version for version checking
$VERSION = 3.07.00.049;
require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(
&GetTagsLabels
&GetAuthType
&GetAuthTypeCode
&GetAuthMARCFromKohaField
&AddAuthority
&ModAuthority
&DelAuthority
&GetAuthority
&GetAuthorityXML
&CountUsage
&CountUsageChildren
&SearchAuthorities
&BuildSummary
&BuildAuthHierarchies
&BuildAuthHierarchy
&GenerateHierarchy
&merge
&FindDuplicateAuthority
&GuessAuthTypeCode
&GuessAuthId
);
}
=head1 NAME
C4::AuthoritiesMarc
=head2 GetAuthMARCFromKohaField
( $tag, $subfield ) = &GetAuthMARCFromKohaField ($kohafield,$authtypecode);
returns tag and subfield linked to kohafield
Comment :
Suppose Kohafield is only linked to ONE subfield
=cut
sub GetAuthMARCFromKohaField {
#AUTHfind_marc_from_kohafield
my ( $kohafield,$authtypecode ) = @_;
my $dbh=C4::Context->dbh;
return 0, 0 unless $kohafield;
$authtypecode="" unless $authtypecode;
my $marcfromkohafield;
my $sth = $dbh->prepare("select tagfield,tagsubfield from auth_subfield_structure where kohafield= ? and authtypecode=? ");
$sth->execute($kohafield,$authtypecode);
my ($tagfield,$tagsubfield) = $sth->fetchrow;
return ($tagfield,$tagsubfield);
}
=head2 SearchAuthorities
(\@finalresult, $nbresults)= &SearchAuthorities($tags, $and_or,
$excluding, $operator, $value, $offset,$length,$authtypecode,
$sortby[, $skipmetadata])
returns ref to array result and count of results returned
=cut
sub SearchAuthorities {
my ($tags, $and_or, $excluding, $operator, $value, $offset,$length,$authtypecode,$sortby,$skipmetadata) = @_;
# warn Dumper($tags, $and_or, $excluding, $operator, $value, $offset,$length,$authtypecode,$sortby);
my $dbh=C4::Context->dbh;
my $query;
my $qpquery = '';
my $QParser;
$QParser = C4::Context->queryparser if (C4::Context->preference('UseQueryParser'));
my $attr = '';
# the marclist may contain "mainentry". In this case, search the tag_to_report, that depends on
# the authtypecode. Then, search on $a of this tag_to_report
# also store main entry MARC tag, to extract it at end of search
my $mainentrytag;
##first set the authtype search and may be multiple authorities
if ($authtypecode) {
my $n=0;
my @authtypecode;
my @auths=split / /,$authtypecode ;
foreach my $auth (@auths){
$query .=" \@attr 1=authtype \@attr 5=100 ".$auth; ##No truncation on authtype
push @authtypecode ,$auth;
$n++;
}
if ($n>1){
while ($n>1){$query= "\@or ".$query;$n--;}
}
if ($QParser) {
$qpquery .= '(authtype:' . join('|| authtype:', @auths) . ')';
}
}
my $dosearch;
my $and=" \@and " ;
my $q2;
my $attr_cnt = 0;
for(my $i = 0 ; $i <= $#{$value} ; $i++)
{
if (@$value[$i]){
if ( @$tags[$i] eq "mainmainentry" ) {
$attr = " \@attr 1=Heading-Main ";
}
elsif ( @$tags[$i] eq "mainentry" ) {
$attr = " \@attr 1=Heading ";
}
elsif ( @$tags[$i] eq "match" ) {
$attr = " \@attr 1=Match ";
}
elsif ( @$tags[$i] eq "match-heading" ) {
$attr = " \@attr 1=Match-heading ";
}
elsif ( @$tags[$i] eq "see-from" ) {
$attr = " \@attr 1=Match-heading-see-from ";
}
elsif ( @$tags[$i] eq "thesaurus" ) {
$attr = " \@attr 1=Subject-heading-thesaurus ";
}
else { # Assume any if no index was specified
$attr = " \@attr 1=Any ";
}
if ( @$operator[$i] eq 'is' ) {
$attr .= " \@attr 4=1 \@attr 5=100 "
; ##Phrase, No truncation,all of subfield field must match
}
elsif ( @$operator[$i] eq "=" ) {
$attr .= " \@attr 4=107 "; #Number Exact match
}
elsif ( @$operator[$i] eq "start" ) {
$attr .= " \@attr 3=2 \@attr 4=1 \@attr 5=1 "
; #Firstinfield Phrase, Right truncated
}
elsif ( @$operator[$i] eq "exact" ) {
$attr .= " \@attr 4=1 \@attr 5=100 \@attr 6=3 "
; ##Phrase, No truncation,all of subfield field must match
}
else {
$attr .= " \@attr 5=1 \@attr 4=6 "
; ## Word list, right truncated, anywhere
if ($sortby eq 'Relevance') {
$attr .= "\@attr 2=102 ";
}
}
@$value[$i] =~ s/"/\\"/g; # Escape the double-quotes in the search value
$attr =$attr."\"".@$value[$i]."\"";
$q2 .=$attr;
$dosearch=1;
++$attr_cnt;
if ($QParser) {
$qpquery .= " $tags->[$i]:\"$value->[$i]\"";
}
}#if value
}
##Add how many queries generated
if (defined $query && $query=~/\S+/){
$query= $and x $attr_cnt . $query . (defined $q2 ? $q2 : '');
} else {
$query= $q2;
}
## Adding order
#$query=' @or @attr 7=2 @attr 1=Heading 0 @or @attr 7=1 @attr 1=Heading 1'.$query if ($sortby eq "HeadingDsc");
my $orderstring;
if ($sortby eq 'HeadingAsc') {
$orderstring = '@attr 7=1 @attr 1=Heading 0';
} elsif ($sortby eq 'HeadingDsc') {
$orderstring = '@attr 7=2 @attr 1=Heading 0';
} elsif ($sortby eq 'AuthidAsc') {
$orderstring = '@attr 7=1 @attr 4=109 @attr 1=Local-Number 0';
} elsif ($sortby eq 'AuthidDsc') {
$orderstring = '@attr 7=2 @attr 4=109 @attr 1=Local-Number 0';
}
if ($QParser) {
$qpquery .= ' all:all' unless $value->[0];
if ( $value->[0] =~ m/^qp=(.*)$/ ) {
$qpquery = $1;
}
$qpquery .= " #$sortby" unless $sortby eq '';
$QParser->parse( $qpquery );
$query = $QParser->target_syntax('authorityserver');
} else {
$query=($query?$query:"\@attr 1=_ALLRECORDS \@attr 2=103 ''");
$query="\@or $orderstring $query" if $orderstring;
}
$offset=0 unless $offset;
my $counter = $offset;
$length=10 unless $length;
my @oAuth;
my $i;
$oAuth[0]=C4::Context->Zconn("authorityserver" , 1);
my $Anewq= new ZOOM::Query::PQF($query,$oAuth[0]);
my $oAResult;
$oAResult= $oAuth[0]->search($Anewq) ;
while (($i = ZOOM::event(\@oAuth)) != 0) {
my $ev = $oAuth[$i-1]->last_event();
last if $ev == ZOOM::Event::ZEND;
}
my($error, $errmsg, $addinfo, $diagset) = $oAuth[0]->error_x();
if ($error) {
warn "oAuth error: $errmsg ($error) $addinfo $diagset\n";
goto NOLUCK;
}
my $nbresults;
$nbresults=$oAResult->size();
my $nremains=$nbresults;
my @result = ();
my @finalresult = ();
if ($nbresults>0){
##Find authid and linkid fields
##we may be searching multiple authoritytypes.
## FIXME this assumes that all authid and linkid fields are the same for all authority types
# my ($authidfield,$authidsubfield)=GetAuthMARCFromKohaField($dbh,"auth_header.authid",$authtypecode[0]);
# my ($linkidfield,$linkidsubfield)=GetAuthMARCFromKohaField($dbh,"auth_header.linkid",$authtypecode[0]);
while (($counter < $nbresults) && ($counter < ($offset + $length))) {
##Here we have to extract MARC record and $authid from ZEBRA AUTHORITIES
my $rec=$oAResult->record($counter);
my $marcdata=$rec->raw();
my $authrecord;
my $separator=C4::Context->preference('authoritysep');
$authrecord = MARC::File::USMARC::decode($marcdata);
my $authid=$authrecord->field('001')->data();
my %newline;
$newline{authid} = $authid;
if ( !$skipmetadata ) {
my $summary =
BuildSummary( $authrecord, $authid, GetAuthTypeCode($authid) );
my $query_auth_tag =
"SELECT auth_tag_to_report FROM auth_types WHERE authtypecode=?";
my $sth = $dbh->prepare($query_auth_tag);
$sth->execute($authtypecode);
my $auth_tag_to_report = $sth->fetchrow;
my $reported_tag;
my $mainentry = $authrecord->field($auth_tag_to_report);
if ($mainentry) {
foreach ( $mainentry->subfields() ) {
$reported_tag .= '$' . $_->[0] . $_->[1];
}
}
my $thisauthtype = GetAuthType(GetAuthTypeCode($authid));
unless (defined $thisauthtype) {
$thisauthtype = GetAuthType($authtypecode) if $authtypecode;
}
$newline{authtype} = defined($thisauthtype) ?
$thisauthtype->{'authtypetext'} : '';
$newline{summary} = $summary;
$newline{even} = $counter % 2;
$newline{reported_tag} = $reported_tag;
}
$counter++;
push @finalresult, \%newline;
}## while counter
###
if (! $skipmetadata) {
for (my $z=0; $z<@finalresult; $z++){
my $count=CountUsage($finalresult[$z]{authid});
$finalresult[$z]{used}=$count;
}# all $z's
}
}## if nbresult
NOLUCK:
$oAResult->destroy();
# $oAuth[0]->destroy();
return (\@finalresult, $nbresults);
}
=head2 CountUsage
$count= &CountUsage($authid)
counts Usage of Authid in bibliorecords.
=cut
sub CountUsage {
my ($authid) = @_;
### ZOOM search here
my $query;
$query= "an:".$authid;
my ($err,$res,$result) = C4::Search::SimpleSearch($query,0,10);
if ($err) {
warn "Error: $err from search $query";
$result = 0;
}
return $result;
}
=head2 CountUsageChildren
$count= &CountUsageChildren($authid)
counts Usage of narrower terms of Authid in bibliorecords.
=cut
sub CountUsageChildren {
my ($authid) = @_;
}
=head2 GetAuthTypeCode
$authtypecode= &GetAuthTypeCode($authid)
returns authtypecode of an authid
=cut
sub GetAuthTypeCode {
#AUTHfind_authtypecode
my ($authid) = @_;
my $dbh=C4::Context->dbh;
my $sth = $dbh->prepare("select authtypecode from auth_header where authid=?");
$sth->execute($authid);
my $authtypecode = $sth->fetchrow;
return $authtypecode;
}
=head2 GuessAuthTypeCode
my $authtypecode = GuessAuthTypeCode($record);
Get the record and tries to guess the adequate authtypecode from its content.
=cut
sub GuessAuthTypeCode {
my ($record, $heading_fields) = @_;
return unless defined $record;
$heading_fields //= {
"MARC21"=>{
'100'=>{authtypecode=>'PERSO_NAME'},
'110'=>{authtypecode=>'CORPO_NAME'},
'111'=>{authtypecode=>'MEETI_NAME'},
'130'=>{authtypecode=>'UNIF_TITLE'},
'148'=>{authtypecode=>'CHRON_TERM'},
'150'=>{authtypecode=>'TOPIC_TERM'},
'151'=>{authtypecode=>'GEOGR_NAME'},
'155'=>{authtypecode=>'GENRE/FORM'},
'180'=>{authtypecode=>'GEN_SUBDIV'},
'181'=>{authtypecode=>'GEO_SUBDIV'},
'182'=>{authtypecode=>'CHRON_SUBD'},
'185'=>{authtypecode=>'FORM_SUBD'},
},
#200 Personal name 700, 701, 702 4-- with embedded 700, 701, 702 600
# 604 with embedded 700, 701, 702
#210 Corporate or meeting name 710, 711, 712 4-- with embedded 710, 711, 712 601 604 with embedded 710, 711, 712
#215 Territorial or geographic name 710, 711, 712 4-- with embedded 710, 711, 712 601, 607 604 with embedded 710, 711, 712
#216 Trademark 716 [Reserved for future use]
#220 Family name 720, 721, 722 4-- with embedded 720, 721, 722 602 604 with embedded 720, 721, 722
#230 Title 500 4-- with embedded 500 605
#240 Name and title (embedded 200, 210, 215, or 220 and 230) 4-- with embedded 7-- and 500 7-- 604 with embedded 7-- and 500 500
#245 Name and collective title (embedded 200, 210, 215, or 220 and 235) 4-- with embedded 7-- and 501 604 with embedded 7-- and 501 7-- 501
#250 Topical subject 606
#260 Place access 620
#280 Form, genre or physical characteristics 608
#
#
# Could also be represented with :
#leader position 9
#a = personal name entry
#b = corporate name entry
#c = territorial or geographical name
#d = trademark
#e = family name
#f = uniform title
#g = collective uniform title
#h = name/title
#i = name/collective uniform title
#j = topical subject
#k = place access
#l = form, genre or physical characteristics
"UNIMARC"=>{
'200'=>{authtypecode=>'NP'},
'210'=>{authtypecode=>'CO'},
'215'=>{authtypecode=>'SNG'},
'216'=>{authtypecode=>'TM'},
'220'=>{authtypecode=>'FAM'},
'230'=>{authtypecode=>'TU'},
'235'=>{authtypecode=>'CO_UNI_TI'},
'240'=>{authtypecode=>'SAUTTIT'},
'245'=>{authtypecode=>'NAME_COL'},
'250'=>{authtypecode=>'SNC'},
'260'=>{authtypecode=>'PA'},
'280'=>{authtypecode=>'GENRE/FORM'},
}
};
foreach my $field (keys %{$heading_fields->{uc(C4::Context->preference('marcflavour'))} }) {
return $heading_fields->{uc(C4::Context->preference('marcflavour'))}->{$field}->{'authtypecode'} if (defined $record->field($field));
}
return;
}
=head2 GuessAuthId
my $authtid = GuessAuthId($record);
Get the record and tries to guess the adequate authtypecode from its content.
=cut
sub GuessAuthId {
my ($record) = @_;
return unless ($record && $record->field('001'));
# my $authtypecode=GuessAuthTypeCode($record);
# my ($tag,$subfield)=GetAuthMARCFromKohaField("auth_header.authid",$authtypecode);
# if ($tag > 010) {return $record->subfield($tag,$subfield)}
# else {return $record->field($tag)->data}
return $record->field('001')->data;
}
=head2 GetTagsLabels
$tagslabel= &GetTagsLabels($forlibrarian,$authtypecode)
returns a ref to hashref of authorities tag and subfield structure.
tagslabel usage :
$tagslabel->{$tag}->{$subfield}->{'attribute'}
where attribute takes values in :
lib
tab
mandatory
repeatable
authorised_value
authtypecode
value_builder
kohafield
seealso
hidden
isurl
link
=cut
sub GetTagsLabels {
my ($forlibrarian,$authtypecode)= @_;
my $dbh=C4::Context->dbh;
$authtypecode="" unless $authtypecode;
my $sth;
my $libfield = ($forlibrarian == 1)? 'liblibrarian' : 'libopac';
# check that authority exists
$sth=$dbh->prepare("SELECT count(*) FROM auth_tag_structure WHERE authtypecode=?");
$sth->execute($authtypecode);
my ($total) = $sth->fetchrow;
$authtypecode="" unless ($total >0);
$sth= $dbh->prepare(
"SELECT auth_tag_structure.tagfield,auth_tag_structure.liblibrarian,auth_tag_structure.libopac,auth_tag_structure.mandatory,auth_tag_structure.repeatable
FROM auth_tag_structure
WHERE authtypecode=?
ORDER BY tagfield"
);
$sth->execute($authtypecode);
my ( $liblibrarian, $libopac, $tag, $res, $tab, $mandatory, $repeatable );
while ( ( $tag, $liblibrarian, $libopac, $mandatory, $repeatable ) = $sth->fetchrow ) {
$res->{$tag}->{lib} = ($forlibrarian or !$libopac)?$liblibrarian:$libopac;
$res->{$tag}->{tab} = " "; # XXX
$res->{$tag}->{mandatory} = $mandatory;
$res->{$tag}->{repeatable} = $repeatable;
}
$sth= $dbh->prepare(
"SELECT tagfield,tagsubfield,liblibrarian,libopac,tab, mandatory, repeatable,authorised_value,frameworkcode as authtypecode,value_builder,kohafield,seealso,hidden,isurl,defaultvalue
FROM auth_subfield_structure
WHERE authtypecode=?
ORDER BY tagfield,tagsubfield"
);
$sth->execute($authtypecode);
my $subfield;
my $authorised_value;
my $value_builder;
my $kohafield;
my $seealso;
my $hidden;
my $isurl;
my $link;
my $defaultvalue;
while (
( $tag, $subfield, $liblibrarian, , $libopac, $tab,
$mandatory, $repeatable, $authorised_value, $authtypecode,
$value_builder, $kohafield, $seealso, $hidden,
$isurl, $defaultvalue, $link )
= $sth->fetchrow
)
{
$res->{$tag}->{$subfield}->{lib} = ($forlibrarian or !$libopac)?$liblibrarian:$libopac;
$res->{$tag}->{$subfield}->{tab} = $tab;
$res->{$tag}->{$subfield}->{mandatory} = $mandatory;
$res->{$tag}->{$subfield}->{repeatable} = $repeatable;
$res->{$tag}->{$subfield}->{authorised_value} = $authorised_value;
$res->{$tag}->{$subfield}->{authtypecode} = $authtypecode;
$res->{$tag}->{$subfield}->{value_builder} = $value_builder;
$res->{$tag}->{$subfield}->{kohafield} = $kohafield;
$res->{$tag}->{$subfield}->{seealso} = $seealso;
$res->{$tag}->{$subfield}->{hidden} = $hidden;
$res->{$tag}->{$subfield}->{isurl} = $isurl;
$res->{$tag}->{$subfield}->{link} = $link;
$res->{$tag}->{$subfield}->{defaultvalue} = $defaultvalue;
}
return $res;
}
=head2 AddAuthority
$authid= &AddAuthority($record, $authid,$authtypecode)
Either Create Or Modify existing authority.
returns authid of the newly created authority
=cut
sub AddAuthority {
# pass the MARC::Record to this function, and it will create the records in the authority table
my ($record,$authid,$authtypecode) = @_;
my $dbh=C4::Context->dbh;
my $leader=' nz a22 o 4500';#Leader for incomplete MARC21 record
# if authid empty => true add, find a new authid number
my $format;
if (uc(C4::Context->preference('marcflavour')) eq 'UNIMARC') {
$format= 'UNIMARCAUTH';
}
else {
$format= 'MARC21';
}
#update date/time to 005 for marc and unimarc
my $time=POSIX::strftime("%Y%m%d%H%M%S",localtime);
my $f5=$record->field('005');
if (!$f5) {
$record->insert_fields_ordered( MARC::Field->new('005',$time.".0") );
}
else {
$f5->update($time.".0");
}
SetUTF8Flag($record);
if ($format eq "MARC21") {
if (!$record->leader) {
$record->leader($leader);
}
if (!$record->field('003')) {
$record->insert_fields_ordered(
MARC::Field->new('003',C4::Context->preference('MARCOrgCode'))
);
}
my $date=POSIX::strftime("%y%m%d",localtime);
if (!$record->field('008')) {
# Get a valid default value for field 008
my $default_008 = C4::Context->preference('MARCAuthorityControlField008');
if(!$default_008 or length($default_008)<34) {
$default_008 = '|| aca||aabn | a|a d';
}
else {
$default_008 = substr($default_008,0,34);
}
$record->insert_fields_ordered( MARC::Field->new('008',$date.$default_008) );
}
if (!$record->field('040')) {
$record->insert_fields_ordered(
MARC::Field->new('040','','',
'a' => C4::Context->preference('MARCOrgCode'),
'c' => C4::Context->preference('MARCOrgCode')
)
);
}
}
if ($format eq "UNIMARCAUTH") {
$record->leader(" nx j22 ") unless ($record->leader());
my $date=POSIX::strftime("%Y%m%d",localtime);
my $defaultfield100 = C4::Context->preference('UNIMARCAuthorityField100');
if (my $string=$record->subfield('100',"a")){
$string=~s/fre50/frey50/;
$record->field('100')->update('a'=>$string);
}
elsif ($record->field('100')){
$record->field('100')->update('a'=>$date.$defaultfield100);
} else {
$record->append_fields(
MARC::Field->new('100',' ',' '
,'a'=>$date.$defaultfield100)
);
}
}
my ($auth_type_tag, $auth_type_subfield) = get_auth_type_location($authtypecode);
if (!$authid and $format eq "MARC21") {
# only need to do this fix when modifying an existing authority
C4::AuthoritiesMarc::MARC21::fix_marc21_auth_type_location($record, $auth_type_tag, $auth_type_subfield);
}
if (my $field=$record->field($auth_type_tag)){
$field->update($auth_type_subfield=>$authtypecode);
}
else {
$record->add_fields($auth_type_tag,'','', $auth_type_subfield=>$authtypecode);
}
my $auth_exists=0;
my $oldRecord;
if (!$authid) {
my $sth=$dbh->prepare("select max(authid) from auth_header");
$sth->execute;
($authid)=$sth->fetchrow;
$authid=$authid+1;
##Insert the recordID in MARC record
unless ($record->field('001') && $record->field('001')->data() eq $authid){
$record->delete_field($record->field('001'));
$record->insert_fields_ordered(MARC::Field->new('001',$authid));
}
} else {
$auth_exists=$dbh->do(qq(select authid from auth_header where authid=?),undef,$authid);
# warn "auth_exists = $auth_exists";
}
if ($auth_exists>0){
$oldRecord=GetAuthority($authid);
$record->add_fields('001',$authid) unless ($record->field('001'));
# warn "\n\n\n enregistrement".$record->as_formatted;
my $sth=$dbh->prepare("update auth_header set authtypecode=?,marc=?,marcxml=? where authid=?");
$sth->execute($authtypecode,$record->as_usmarc,$record->as_xml_record($format),$authid) or die $sth->errstr;
$sth->finish;
}
else {
my $sth=$dbh->prepare("insert into auth_header (authid,datecreated,authtypecode,marc,marcxml) values (?,now(),?,?,?)");
$sth->execute($authid,$authtypecode,$record->as_usmarc,$record->as_xml_record($format));
$sth->finish;
logaction( "AUTHORITIES", "ADD", $authid, "authority" ) if C4::Context->preference("AuthoritiesLog");
}
ModZebra($authid,'specialUpdate',"authorityserver",$oldRecord,$record);
return ($authid);
}
=head2 DelAuthority
$authid= &DelAuthority($authid)
Deletes $authid
=cut
sub DelAuthority {
my ($authid) = @_;
my $dbh=C4::Context->dbh;
logaction( "AUTHORITIES", "DELETE", $authid, "authority" ) if C4::Context->preference("AuthoritiesLog");
ModZebra($authid,"recordDelete","authorityserver",GetAuthority($authid),undef);
my $sth = $dbh->prepare("DELETE FROM auth_header WHERE authid=?");
$sth->execute($authid);
}
=head2 ModAuthority
$authid= &ModAuthority($authid,$record,$authtypecode)
Modifies authority record, optionally updates attached biblios.
=cut
sub ModAuthority {
my ($authid,$record,$authtypecode)=@_; # deprecated $merge parameter removed
my $dbh=C4::Context->dbh;
#Now rewrite the $record to table with an add
my $oldrecord=GetAuthority($authid);
$authid=AddAuthority($record,$authid,$authtypecode);
# If a library thinks that updating all biblios is a long process and wishes
# to leave that to a cron job, use misc/migration_tools/merge_authority.pl.
# In that case set system preference "dontmerge" to 1. Otherwise biblios will
# be updated.
unless(C4::Context->preference('dontmerge') eq '1'){
&merge($authid,$oldrecord,$authid,$record);
} else {
# save a record in need_merge_authorities table
my $sqlinsert="INSERT INTO need_merge_authorities (authid, done) ".
"VALUES (?,?)";
$dbh->do($sqlinsert,undef,($authid,0));
}
logaction( "AUTHORITIES", "MODIFY", $authid, "authority BEFORE=>" . $oldrecord->as_formatted ) if C4::Context->preference("AuthoritiesLog");
return $authid;
}
=head2 GetAuthorityXML
$marcxml= &GetAuthorityXML( $authid)
returns xml form of record $authid
=cut
sub GetAuthorityXML {
# Returns MARC::XML of the authority passed in parameter.
my ( $authid ) = @_;
if (uc(C4::Context->preference('marcflavour')) eq 'UNIMARC') {
my $dbh=C4::Context->dbh;
my $sth = $dbh->prepare("select marcxml from auth_header where authid=? " );
$sth->execute($authid);
my ($marcxml)=$sth->fetchrow;
return $marcxml;
}
else {
# for MARC21, call GetAuthority instead of
# getting the XML directly since we may
# need to fix up the location of the authority
# code -- note that this is reasonably safe
# because GetAuthorityXML is used only by the
# indexing processes like zebraqueue_start.pl
my $record = GetAuthority($authid);
return $record->as_xml_record('MARC21');
}
}
=head2 GetAuthority
$record= &GetAuthority( $authid)
Returns MARC::Record of the authority passed in parameter.
=cut
sub GetAuthority {
my ($authid)=@_;
my $authority = Koha::Authority->get_from_authid($authid);
return unless $authority;
return ($authority->record);
}
=head2 GetAuthType
$result = &GetAuthType($authtypecode)
If the authority type specified by C<$authtypecode> exists,
returns a hashref of the type's fields. If the type
does not exist, returns undef.
=cut
sub GetAuthType {
my ($authtypecode) = @_;
my $dbh=C4::Context->dbh;
my $sth;
if (defined $authtypecode){ # NOTE - in MARC21 framework, '' is a valid authority
# type (FIXME but why?)
$sth=$dbh->prepare("select * from auth_types where authtypecode=?");
$sth->execute($authtypecode);
if (my $res = $sth->fetchrow_hashref) {
return $res;
}
}
return;
}
=head2 FindDuplicateAuthority
$record= &FindDuplicateAuthority( $record, $authtypecode)
return $authid,Summary if duplicate is found.
Comments : an improvement would be to return All the records that match.
=cut
sub FindDuplicateAuthority {
my ($record,$authtypecode)=@_;
# warn "IN for ".$record->as_formatted;
my $dbh = C4::Context->dbh;
# warn "".$record->as_formatted;
my $sth = $dbh->prepare("select auth_tag_to_report from auth_types where authtypecode=?");
$sth->execute($authtypecode);
my ($auth_tag_to_report) = $sth->fetchrow;
$sth->finish;
# warn "record :".$record->as_formatted." auth_tag_to_report :$auth_tag_to_report";
# build a request for SearchAuthorities
my $QParser;
$QParser = C4::Context->queryparser if (C4::Context->preference('UseQueryParser'));
my $op;
if ($QParser) {
$op = '&&';
} else {
$op = 'and';
}
my $query='at:'.$authtypecode.' ';
my $filtervalues=qr([\001-\040\!\'\"\`\#\$\%\&\*\+,\-\./:;<=>\?\@\(\)\{\[\]\}_\|\~]);
if ($record->field($auth_tag_to_report)) {
foreach ($record->field($auth_tag_to_report)->subfields()) {
$_->[1]=~s/$filtervalues/ /g; $query.= " $op he:\"".$_->[1]."\"" if ($_->[0]=~/[A-z]/);
}
}
my ($error, $results, $total_hits) = C4::Search::SimpleSearch( $query, 0, 1, [ "authorityserver" ] );
# there is at least 1 result => return the 1st one
if (!defined $error && @{$results} ) {
my $marcrecord = MARC::File::USMARC::decode($results->[0]);
return $marcrecord->field('001')->data,BuildSummary($marcrecord,$marcrecord->field('001')->data,$authtypecode);
}
# no result, returns nothing
return;
}
=head2 BuildSummary
$summary= &BuildSummary( $record, $authid, $authtypecode)
Returns a hashref with a summary of the specified record.
Comment : authtypecode can be infered from both record and authid.
Moreover, authid can also be inferred from $record.
Would it be interesting to delete those things.
=cut
sub BuildSummary {
## give this a Marc record to return summary
my ($record,$authid,$authtypecode)=@_;
my $dbh=C4::Context->dbh;
my %summary;
# handle $authtypecode is NULL or eq ""
if ($authtypecode) {
my $authref = GetAuthType($authtypecode);
$summary{authtypecode} = $authref->{authtypecode};
$summary{type} = $authref->{authtypetext};
$summary{summary} = $authref->{summary};
}
my $marc21subfields = 'abcdfghjklmnopqrstuvxyz68';
my %marc21controlrefs = ( 'a' => 'earlier',
'b' => 'later',
'd' => 'acronym',
'f' => 'musical',
'g' => 'broader',
'h' => 'narrower',
'n' => 'notapplicable',
'i' => 'subfi',
't' => 'parent'
);
my %unimarc_relation_from_code = (
g => 'broader',
h => 'narrower',
a => 'seealso',
);
my %thesaurus;
$thesaurus{'1'}="Peuples";
$thesaurus{'2'}="Anthroponymes";
$thesaurus{'3'}="Oeuvres";
$thesaurus{'4'}="Chronologie";
$thesaurus{'5'}="Lieux";
$thesaurus{'6'}="Sujets";
#thesaurus a remplir
my $reported_tag;
# if the library has a summary defined, use it. Otherwise, build a standard one
# FIXME - it appears that the summary field in the authority frameworks
# can work as a display template. However, this doesn't
# suit the MARC21 version, so for now the "templating"
# feature will be enabled only for UNIMARC for backwards
# compatibility.
if ($summary{summary} and C4::Context->preference('marcflavour') eq 'UNIMARC') {
my @fields = $record->fields();
# $reported_tag = '$9'.$result[$counter];
my @stringssummary;
foreach my $field (@fields) {
my $tag = $field->tag();
my $tagvalue = $field->as_string();
my $localsummary= $summary{summary};
$localsummary =~ s/\[(.?.?.?.?)$tag\*(.*?)\]/$1$tagvalue$2\[$1$tag$2\]/g;
if ($tag<10) {
if ($tag eq '001') {
$reported_tag.='$3'.$field->data();
}
} else {
my @subf = $field->subfields;
for my $i (0..$#subf) {
my $subfieldcode = $subf[$i][0];
my $subfieldvalue = $subf[$i][1];
my $tagsubf = $tag.$subfieldcode;
$localsummary =~ s/\[(.?.?.?.?)$tagsubf(.*?)\]/$1$subfieldvalue$2\[$1$tagsubf$2\]/g;
}
}
push @stringssummary, $localsummary if ($localsummary ne $summary{summary});
}
my $resultstring;
$resultstring = join(" -- ",@stringssummary);
$resultstring =~ s/\[(.*?)\]//g;
$resultstring =~ s/\n/<br>/g;
$summary{summary} = $resultstring;
}
my @authorized;
my @notes;
my @seefrom;
my @seealso;
my @otherscript;
if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
# construct UNIMARC summary, that is quite different from MARC21 one
# accepted form
foreach my $field ($record->field('2..')) {
push @authorized, {
heading => $field->as_string('abcdefghijlmnopqrstuvwxyz'),
hemain => $field->subfield('a'),
field => $field->tag(),
};
}
# rejected form(s)
foreach my $field ($record->field('3..')) {
push @notes, { note => $field->subfield('a'), field => $field->tag() };
}
foreach my $field ($record->field('4..')) {
my $thesaurus = $field->subfield('2') ? "thes. : ".$thesaurus{"$field->subfield('2')"}." : " : '';
push @seefrom, {
heading => $thesaurus . $field->as_string('abcdefghijlmnopqrstuvwxyz'),
hemain => $field->subfield('a'),
type => 'seefrom',
field => $field->tag(),
};
}
# see :
@seealso = map {
my $type = $unimarc_relation_from_code{$_->subfield('5') || 'a'};
my $heading = $_->as_string('abcdefgjxyz');
{
field => $_->tag,
type => $type,
heading => $heading,
hemain => $_->subfield('a'),
search => $heading,
authid => $_->subfield('9'),
}
} $record->field('5..');
# Other forms
@otherscript = map { {
lang => length ($_->subfield('8')) == 6 ? substr ($_->subfield('8'), 3, 3) : $_->subfield('8') || '',
term => $_->subfield('a') . ($_->subfield('b') ? ', ' . $_->subfield('b') : ''),
direction => 'ltr',
field => $_->tag,
} } $record->field('7..');
} else {
# construct MARC21 summary
# FIXME - looping over 1XX is questionable
# since MARC21 authority should have only one 1XX
my $subfields_to_report;
foreach my $field ($record->field('1..')) {
my $tag = $field->tag();
next if "152" eq $tag;
# FIXME - 152 is not a good tag to use
# in MARC21 -- purely local tags really ought to be
# 9XX
if ($tag eq '100') {
$subfields_to_report = 'abcdefghjklmnopqrstvxyz';
} elsif ($tag eq '110') {
$subfields_to_report = 'abcdefghklmnoprstvxyz';
} elsif ($tag eq '111') {
$subfields_to_report = 'acdefghklnpqstvxyz';
} elsif ($tag eq '130') {
$subfields_to_report = 'adfghklmnoprstvxyz';
} elsif ($tag eq '148') {
$subfields_to_report = 'abvxyz';
} elsif ($tag eq '150') {
$subfields_to_report = 'abvxyz';
} elsif ($tag eq '151') {
$subfields_to_report = 'avxyz';
} elsif ($tag eq '155') {
$subfields_to_report = 'abvxyz';
} elsif ($tag eq '180') {
$subfields_to_report = 'vxyz';
} elsif ($tag eq '181') {
$subfields_to_report = 'vxyz';
} elsif ($tag eq '182') {
$subfields_to_report = 'vxyz';
} elsif ($tag eq '185') {
$subfields_to_report = 'vxyz';
}
if ($subfields_to_report) {
push @authorized, {
heading => $field->as_string($subfields_to_report),
hemain => $field->subfield( substr($subfields_to_report, 0, 1) ),
field => $tag,
};
} else {
push @authorized, {
heading => $field->as_string(),
hemain => $field->subfield('a'),
field => $tag,
};
}
}
foreach my $field ($record->field('4..')) { #See From
my $type = 'seefrom';
$type = ($marc21controlrefs{substr $field->subfield('w'), 0, 1} || '') if ($field->subfield('w'));
if ($type eq 'notapplicable') {
$type = substr $field->subfield('w'), 2, 1;
$type = 'earlier' if $type && $type ne 'n';
}
if ($type eq 'subfi') {
push @seefrom, {
heading => $field->as_string($marc21subfields),
hemain => $field->subfield( substr($marc21subfields, 0, 1) ),
type => ($field->subfield('i') || ''),
field => $field->tag(),
};
} else {
push @seefrom, {
heading => $field->as_string($marc21subfields),
hemain => $field->subfield( substr($marc21subfields, 0, 1) ),
type => $type,
field => $field->tag(),
};
}
}
foreach my $field ($record->field('5..')) { #See Also
my $type = 'seealso';
$type = ($marc21controlrefs{substr $field->subfield('w'), 0, 1} || '') if ($field->subfield('w'));
if ($type eq 'notapplicable') {
$type = substr $field->subfield('w'), 2, 1;
$type = 'earlier' if $type && $type ne 'n';
}
if ($type eq 'subfi') {
push @seealso, {
heading => $field->as_string($marc21subfields),
hemain => $field->subfield( substr($marc21subfields, 0, 1) ),
type => $field->subfield('i'),
field => $field->tag(),
search => $field->as_string($marc21subfields) || '',
authid => $field->subfield('9') || ''
};
} else {
push @seealso, {
heading => $field->as_string($marc21subfields),
hemain => $field->subfield( substr($marc21subfields, 0, 1) ),
type => $type,
field => $field->tag(),
search => $field->as_string($marc21subfields) || '',
authid => $field->subfield('9') || ''
};
}
}
foreach my $field ($record->field('6..')) {
push @notes, { note => $field->as_string(), field => $field->tag() };
}
foreach my $field ($record->field('880')) {
my $linkage = $field->subfield('6');
my $category = substr $linkage, 0, 1;
if ($category eq '1') {
$category = 'preferred';
} elsif ($category eq '4') {
$category = 'seefrom';
} elsif ($category eq '5') {
$category = 'seealso';
}
my $type;
if ($field->subfield('w')) {
$type = $marc21controlrefs{substr $field->subfield('w'), '0'};
} else {
$type = $category;
}
my $direction = $linkage =~ m#/r$# ? 'rtl' : 'ltr';
push @otherscript, { term => $field->as_string($subfields_to_report), category => $category, type => $type, direction => $direction, linkage => $linkage };
}
}
$summary{mainentry} = $authorized[0]->{heading};
$summary{mainmainentry} = $authorized[0]->{hemain};
$summary{authorized} = \@authorized;
$summary{notes} = \@notes;
$summary{seefrom} = \@seefrom;
$summary{seealso} = \@seealso;
$summary{otherscript} = \@otherscript;
return \%summary;
}
=head2 GetAuthorizedHeading
$heading = &GetAuthorizedHeading({ record => $record, authid => $authid })
Takes a MARC::Record object describing an authority record or an authid, and
returns a string representation of the first authorized heading. This routine
should be considered a temporary shim to ease the future migration of authority
data from C4::AuthoritiesMarc to the object-oriented Koha::*::Authority.
=cut
sub GetAuthorizedHeading {
my $args = shift;
my $record;
unless ($record = $args->{record}) {
return unless $args->{authid};
$record = GetAuthority($args->{authid});
}
return unless (ref $record eq 'MARC::Record');
if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
# construct UNIMARC summary, that is quite different from MARC21 one
# accepted form
foreach my $field ($record->field('2..')) {
return $field->as_string('abcdefghijlmnopqrstuvwxyz');
}
} else {
foreach my $field ($record->field('1..')) {
my $tag = $field->tag();
next if "152" eq $tag;
# FIXME - 152 is not a good tag to use
# in MARC21 -- purely local tags really ought to be
# 9XX
if ($tag eq '100') {
return $field->as_string('abcdefghjklmnopqrstvxyz68');
} elsif ($tag eq '110') {
return $field->as_string('abcdefghklmnoprstvxyz68');
} elsif ($tag eq '111') {
return $field->as_string('acdefghklnpqstvxyz68');
} elsif ($tag eq '130') {
return $field->as_string('adfghklmnoprstvxyz68');
} elsif ($tag eq '148') {
return $field->as_string('abvxyz68');
} elsif ($tag eq '150') {
return $field->as_string('abvxyz68');
} elsif ($tag eq '151') {
return $field->as_string('avxyz68');
} elsif ($tag eq '155') {
return $field->as_string('abvxyz68');
} elsif ($tag eq '180') {
return $field->as_string('vxyz68');
} elsif ($tag eq '181') {
return $field->as_string('vxyz68');
} elsif ($tag eq '182') {
return $field->as_string('vxyz68');
} elsif ($tag eq '185') {
return $field->as_string('vxyz68');
} else {
return $field->as_string();
}
}
}
return;
}
=head2 BuildAuthHierarchies
$text= &BuildAuthHierarchies( $authid, $force)
return text containing trees for hierarchies
for them to be stored in auth_header
Example of text:
122,1314,2452;1324,2342,3,2452
=cut
sub BuildAuthHierarchies{
my $authid = shift @_;
# warn "authid : $authid";
my $force = shift @_ || (C4::Context->preference('marcflavour') eq 'UNIMARC' ? 0 : 1);
my @globalresult;
my $dbh=C4::Context->dbh;
my $hierarchies;
my $data = GetHeaderAuthority($authid);
if ($data->{'authtrees'} and not $force){
return $data->{'authtrees'};
# } elsif ($data->{'authtrees'}){
# $hierarchies=$data->{'authtrees'};
} else {
my $record = GetAuthority($authid);
my $found;
return unless $record;
foreach my $field ($record->field('5..')){
my $broader = 0;
$broader = 1 if (
(C4::Context->preference('marcflavour') eq 'UNIMARC' && $field->subfield('5') && $field->subfield('5') eq 'g') ||
(C4::Context->preference('marcflavour') ne 'UNIMARC' && $field->subfield('w') && substr($field->subfield('w'), 0, 1) eq 'g'));
if ($broader) {
my $subfauthid=_get_authid_subfield($field) || '';
next if ($subfauthid eq $authid);
my $parentrecord = GetAuthority($subfauthid);
next unless $parentrecord;
my $localresult=$hierarchies;
my $trees;
$trees = BuildAuthHierarchies($subfauthid);
my @trees;
if ($trees=~/;/){
@trees = split(/;/,$trees);
} else {
push @trees, $trees;
}
foreach (@trees){
$_.= ",$authid";
}
@globalresult = (@globalresult,@trees);
$found=1;
}
$hierarchies=join(";",@globalresult);
}
#Unless there is no ancestor, I am alone.
$hierarchies="$authid" unless ($hierarchies);
}
AddAuthorityTrees($authid,$hierarchies);
return $hierarchies;
}
=head2 BuildAuthHierarchy
$ref= &BuildAuthHierarchy( $record, $class,$authid)
return a hashref in order to display hierarchy for record and final Authid $authid
"loopparents"
"loopchildren"
"class"
"loopauthid"
"current_value"
"value"
=cut
sub BuildAuthHierarchy{
my $record = shift @_;
my $class = shift @_;
my $authid_constructed = shift @_;
return unless ($record && $record->field('001'));
my $authid=$record->field('001')->data();
my %cell;
my $parents=""; my $children="";
my (@loopparents,@loopchildren);
my $marcflavour = C4::Context->preference('marcflavour');
my $relationshipsf = $marcflavour eq 'UNIMARC' ? '5' : 'w';
foreach my $field ($record->field('5..')){
my $subfauthid=_get_authid_subfield($field);
if ($subfauthid && $field->subfield($relationshipsf) && $field->subfield('a')){
my $relationship = substr($field->subfield($relationshipsf), 0, 1);
if ($relationship eq 'h'){
push @loopchildren, { "authid"=>$subfauthid,"value"=>$field->subfield('a')};
}
elsif ($relationship eq 'g'){
push @loopparents, { "authid"=>$subfauthid,"value"=>$field->subfield('a')};
}
# brothers could get in there with an else
}
}
$cell{"parents"}=\@loopparents;
$cell{"children"}=\@loopchildren;
$cell{"class"}=$class;
$cell{"authid"}=$authid;
$cell{"current_value"} =1 if ($authid eq $authid_constructed);
$cell{"value"}=C4::Context->preference('marcflavour') eq 'UNIMARC' ? $record->subfield('2..',"a") : $record->subfield('1..', 'a');
return \%cell;
}
=head2 BuildAuthHierarchyBranch
$branch = &BuildAuthHierarchyBranch( $tree, $authid[, $cnt])
Return a data structure representing an authority hierarchy
given a list of authorities representing a single branch in
an authority hierarchy tree. $authid is the current node in
the tree (which may or may not be somewhere in the middle).
$cnt represents the level of the upper-most item, and is only
used when BuildAuthHierarchyBranch is called recursively (i.e.,
don't ever pass in anything but zero to it).
=cut
sub BuildAuthHierarchyBranch {
my ($tree, $authid, $cnt) = @_;
$cnt |= 0;
my $elementdata = GetAuthority(shift @$tree);
my $branch = BuildAuthHierarchy($elementdata,"child".$cnt, $authid);
if (scalar @$tree > 0) {
my $nextBranch = BuildAuthHierarchyBranch($tree, $authid, ++$cnt);
my $nextAuthid = $nextBranch->{authid};
my $found;
# If we already have the next branch listed as a child, let's
# replace the old listing with the new one. If not, we will add
# the branch at the end.
foreach my $cell (@{$branch->{children}}) {
if ($cell->{authid} eq $nextAuthid) {
$cell = $nextBranch;
$found = 1;
last;
}
}
push @{$branch->{children}}, $nextBranch unless $found;
}
return $branch;
}
=head2 GenerateHierarchy
$hierarchy = &GenerateHierarchy($authid);
Return an arrayref holding one or more "trees" representing
authority hierarchies.
=cut
sub GenerateHierarchy {
my ($authid) = @_;
my $trees = BuildAuthHierarchies($authid);
my @trees = split /;/,$trees ;
push @trees,$trees unless (@trees);
my @loophierarchies;
foreach my $tree (@trees){
my @tree=split /,/,$tree;
push @tree, $tree unless (@tree);
my $branch = BuildAuthHierarchyBranch(\@tree, $authid);
push @loophierarchies, [ $branch ];
}
return \@loophierarchies;
}
sub _get_authid_subfield{
my ($field)=@_;
return $field->subfield('9')||$field->subfield('3');
}
=head2 GetHeaderAuthority
$ref= &GetHeaderAuthority( $authid)
return a hashref in order auth_header table data
=cut
sub GetHeaderAuthority{
my $authid = shift @_;
my $sql= "SELECT * from auth_header WHERE authid = ?";
my $dbh=C4::Context->dbh;
my $rq= $dbh->prepare($sql);
$rq->execute($authid);
my $data= $rq->fetchrow_hashref;
return $data;
}
=head2 AddAuthorityTrees
$ref= &AddAuthorityTrees( $authid, $trees)
return success or failure
=cut
sub AddAuthorityTrees{
my $authid = shift @_;
my $trees = shift @_;
my $sql= "UPDATE IGNORE auth_header set authtrees=? WHERE authid = ?";
my $dbh=C4::Context->dbh;
my $rq= $dbh->prepare($sql);
return $rq->execute($trees,$authid);
}
=head2 merge
$ref= &merge(mergefrom,$MARCfrom,$mergeto,$MARCto)
Could add some feature : Migrating from a typecode to an other for instance.
Then we should add some new parameter : bibliotargettag, authtargettag
=cut
sub merge {
my ($mergefrom,$MARCfrom,$mergeto,$MARCto) = @_;
my ($counteditedbiblio,$countunmodifiedbiblio,$counterrors)=(0,0,0);
my $dbh=C4::Context->dbh;
my $authtypecodefrom = GetAuthTypeCode($mergefrom);
my $authtypecodeto = GetAuthTypeCode($mergeto);
# warn "mergefrom : $authtypecodefrom $mergefrom mergeto : $authtypecodeto $mergeto ";
# return if authority does not exist
return "error MARCFROM not a marcrecord ".Data::Dumper::Dumper($MARCfrom) if scalar($MARCfrom->fields()) == 0;
return "error MARCTO not a marcrecord".Data::Dumper::Dumper($MARCto) if scalar($MARCto->fields()) == 0;
# search the tag to report
my $sth = $dbh->prepare("select auth_tag_to_report from auth_types where authtypecode=?");
$sth->execute($authtypecodefrom);
my ($auth_tag_to_report_from) = $sth->fetchrow;
$sth->execute($authtypecodeto);
my ($auth_tag_to_report_to) = $sth->fetchrow;
my @record_to;
@record_to = $MARCto->field($auth_tag_to_report_to)->subfields() if $MARCto->field($auth_tag_to_report_to);
my @record_from;
@record_from = $MARCfrom->field($auth_tag_to_report_from)->subfields() if $MARCfrom->field($auth_tag_to_report_from);
my @reccache;
# search all biblio tags using this authority.
#Getting marcbiblios impacted by the change.
#zebra connection
my $oConnection=C4::Context->Zconn("biblioserver",0);
# We used to use XML syntax here, but that no longer works.
# Thankfully, we don't need it.
my $query;
$query= "an=".$mergefrom;
my $oResult = $oConnection->search(new ZOOM::Query::CCL2RPN( $query, $oConnection ));
my $count = 0;
if ($oResult) {
$count=$oResult->size();
}
my $z=0;
while ( $z<$count ) {
my $rec;
$rec=$oResult->record($z);
my $marcdata = $rec->raw();
my $marcrecordzebra= MARC::Record->new_from_usmarc($marcdata);
my ( $biblionumbertagfield, $biblionumbertagsubfield ) = &GetMarcFromKohaField( "biblio.biblionumber", '' );
my $i = ($biblionumbertagfield < 10) ? $marcrecordzebra->field($biblionumbertagfield)->data : $marcrecordzebra->subfield($biblionumbertagfield, $biblionumbertagsubfield);
my $marcrecorddb=GetMarcBiblio($i);
push @reccache, $marcrecorddb;
$z++;
}
$oResult->destroy();
#warn scalar(@reccache)." biblios to update";
# Get All candidate Tags for the change
# (This will reduce the search scope in marc records).
$sth = $dbh->prepare("select distinct tagfield from marc_subfield_structure where authtypecode=?");
$sth->execute($authtypecodefrom);
my @tags_using_authtype;
while (my ($tagfield) = $sth->fetchrow) {
push @tags_using_authtype,$tagfield ;
}
my $tag_to=0;
if ($authtypecodeto ne $authtypecodefrom){
# If many tags, take the first
$sth->execute($authtypecodeto);
$tag_to=$sth->fetchrow;
#warn $tag_to;
}
# BulkEdit marc records
# May be used as a template for a bulkedit field
foreach my $marcrecord(@reccache){
my $update;
foreach my $tagfield (@tags_using_authtype){
# warn "tagfield : $tagfield ";
foreach my $field ($marcrecord->field($tagfield)){
# biblio is linked to authority with $9 subfield containing authid
my $auth_number=$field->subfield("9");
my $tag=$field->tag();
if ($auth_number==$mergefrom) {
my $field_to=MARC::Field->new(($tag_to?$tag_to:$tag),$field->indicator(1),$field->indicator(2),"9"=>$mergeto);
my $exclude='9';
foreach my $subfield (grep {$_->[0] ne '9'} @record_to) {
$field_to->add_subfields($subfield->[0] =>$subfield->[1]);
$exclude.= $subfield->[0];
}
$exclude='['.$exclude.']';
# add subfields in $field not included in @record_to
my @restore= grep {$_->[0]!~/$exclude/} $field->subfields();
foreach my $subfield (@restore) {
$field_to->add_subfields($subfield->[0] =>$subfield->[1]);
}
$marcrecord->delete_field($field);
$marcrecord->insert_grouped_field($field_to);
$update=1;
}
}#for each tag
}#foreach tagfield
my ($bibliotag,$bibliosubf) = GetMarcFromKohaField("biblio.biblionumber","") ;
my $biblionumber;
if ($bibliotag<10){
$biblionumber=$marcrecord->field($bibliotag)->data;
}
else {
$biblionumber=$marcrecord->subfield($bibliotag,$bibliosubf);
}
unless ($biblionumber){
warn "pas de numéro de notice bibliographique dans : ".$marcrecord->as_formatted;
next;
}
if ($update==1){
&ModBiblio($marcrecord,$biblionumber,GetFrameworkCode($biblionumber)) ;
$counteditedbiblio++;
warn $counteditedbiblio if (($counteditedbiblio % 10) and $ENV{DEBUG});
}
}#foreach $marc
return $counteditedbiblio;
# now, find every other authority linked with this authority
# now, find every other authority linked with this authority
# my $oConnection=C4::Context->Zconn("authorityserver");
# my $query;
# # att 9210 Auth-Internal-authtype
# # att 9220 Auth-Internal-LN
# # ccl.properties to add for authorities
# $query= "= ".$mergefrom;
# my $oResult = $oConnection->search(new ZOOM::Query::CCL2RPN( $query, $oConnection ));
# my $count=$oResult->size() if ($oResult);
# my @reccache;
# my $z=0;
# while ( $z<$count ) {
# my $rec;
# $rec=$oResult->record($z);
# my $marcdata = $rec->raw();
# push @reccache, $marcdata;
# $z++;
# }
# $oResult->destroy();
# foreach my $marc(@reccache){
# my $update;
# my $marcrecord;
# $marcrecord = MARC::File::USMARC::decode($marc);
# foreach my $tagfield (@tags_using_authtype){
# $tagfield=substr($tagfield,0,3);
# my @tags = $marcrecord->field($tagfield);
# foreach my $tag (@tags){
# my $tagsubs=$tag->subfield("9");
# #warn "$tagfield:$tagsubs:$mergefrom";
# if ($tagsubs== $mergefrom) {
# $tag->update("9" =>$mergeto);
# foreach my $subfield (@record_to) {
# # warn "$subfield,$subfield->[0],$subfield->[1]";
# $tag->update($subfield->[0] =>$subfield->[1]);
# }#for $subfield
# }
# $marcrecord->delete_field($tag);
# $marcrecord->add_fields($tag);
# $update=1;
# }#for each tag
# }#foreach tagfield
# my $authoritynumber = TransformMarcToKoha($dbh,$marcrecord,"") ;
# if ($update==1){
# &ModAuthority($marcrecord,$authoritynumber,GetAuthTypeCode($authoritynumber)) ;
# }
#
# }#foreach $marc
}#sub
=head2 get_auth_type_location
my ($tag, $subfield) = get_auth_type_location($auth_type_code);
Get the tag and subfield used to store the heading type
for indexing purposes. The C<$auth_type> parameter is
optional; if it is not supplied, assume ''.
This routine searches the MARC authority framework
for the tag and subfield whose kohafield is
C<auth_header.authtypecode>; if no such field is
defined in the framework, default to the hardcoded value
specific to the MARC format.
=cut
sub get_auth_type_location {
my $auth_type_code = @_ ? shift : '';
my ($tag, $subfield) = GetAuthMARCFromKohaField('auth_header.authtypecode', $auth_type_code);
if (defined $tag and defined $subfield and $tag != 0 and $subfield ne '' and $subfield ne ' ') {
return ($tag, $subfield);
} else {
if (C4::Context->preference('marcflavour') eq "MARC21") {
return C4::AuthoritiesMarc::MARC21::default_auth_type_location();
} else {
return C4::AuthoritiesMarc::UNIMARC::default_auth_type_location();
}
}
}
END { } # module clean-up code here (global destructor)
1;
__END__
=head1 AUTHOR
Koha Development Team <http://koha-community.org/>
Paul POULAIN paul.poulain@free.fr
=cut