[Koha-cvs] CVS: koha/authorities authorities-home.pl,NONE,1.1 authorities.pl,NONE,1.1

[Paul POULAIN]

Update of /cvsroot/koha/koha/authorities
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv7438/authorities

Added Files:
        authorities-home.pl authorities.pl 
Log Message:
MARC authority management (1st draft. works really poorly)

--- NEW FILE ---
#!/usr/bin/perl
# WARNING: 4-character tab stops here

# 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., 59 Temple Place,
# Suite 330, Boston, MA  02111-1307 USA

use strict;
require Exporter;
use CGI;
use C4::Auth;
use HTML::Template;
use C4::Context;
use C4::Search;
use C4::Auth;
use C4::Output;
use C4::Interface::CGI::Output;
use C4::AuthoritiesMarc;
use C4::SearchMarc;
use C4::Catalogue;
use C4::Koha; # XXX subfield_is_koha_internal_p

# Creates the list of active tags using the active MARC configuration
sub create_marclist {
        my $dbh = C4::Context->dbh;
        my $tagslib = AUTHgettagslib($dbh,1);
        my @marcarray;
        push @marcarray,"";
        my $widest_menu_item_width = 0;
        for (my $pass = 1; $pass <= 2; $pass += 1)
        {
                for (my $tabloop = 0; $tabloop<=9;$tabloop++)
                {
                        my $separator_inserted_p = 0; # FIXME... should not 
use!!
                        foreach my $tag (sort(keys (%{$tagslib})))
                        {
                                foreach my $subfield (sort(keys 
%{$tagslib->{$tag}}))
                                {
                                        next if 
subfield_is_koha_internal_p($subfield);
                                        next unless 
($tagslib->{$tag}->{$subfield}->{tab} eq $tabloop);
                                        my $menu_item = "$tag$subfield - 
$tagslib->{$tag}->{$subfield}->{lib}";
                                        if ($pass == 1)
                                        {
                                                $widest_menu_item_width = 
length $menu_item if($widest_menu_item_width < length $menu_item);
                                        } else {
                                                if (!$separator_inserted_p)
                                                {
                                                        my $w = 
int(($widest_menu_item_width - 3 + 0.5)/2);
                                                        my $s = ('-' x ($w * 
4/5));
                                                        push @marcarray,  "$s 
$tabloop $s";
                                                        $separator_inserted_p = 
1;
                                                }
                                        push @marcarray, $menu_item;
                                        }
                                }
                        }
                }
        }
        return address@hidden;
}

# Creates a scrolling list with the associated default value.
# Using more than one scrolling list in a CGI assigns the same default value to 
all the
# scrolling lists on the page !?!? That's why this function was written.
sub create_scrolling_list {
        my ($params) = @_;
        my $scrollist = sprintf("<select name=\"%s\" size=\"%d\" 
onChange='%s'>\n", $params->{'name'}, $params->{'size'}, $params->{'onChange'});

        foreach my $tag (@{$params->{'values'}})
        {
                my $selected = "selected " if($params->{'default'} eq $tag);
                $scrollist .= sprintf("<option %svalue=\"%s\">%s</option>\n", 
$selected, $tag, $tag);
        }

        $scrollist .= "</select>\n";

        return $scrollist;
}

my $query=new CGI;
my $op = $query->param('op');
my $authtypecode = $query->param('authtypecode');
my $dbh = C4::Context->dbh;

my $startfrom=$query->param('startfrom');
$startfrom=0 if(!defined $startfrom);
my ($template, $loggedinuser, $cookie);
my $resultsperpage;

my $authtypes = getauthtypes;
my @authtypesloop;
foreach my $thisauthtype (keys %$authtypes) {
        my $selected = 1 if $thisauthtype eq $authtypecode;
        my %row =(value => $thisauthtype,
                                selected => $selected,
                                authtypetext => 
$authtypes->{$thisauthtype}{'authtypetext'},
                        );
        warn "X = $authtypes->{$thisauthtype}{'authtypetext'}";
        push @authtypesloop, \%row;
}

if ($op eq "do_search") {
        my @marclist = $query->param('marclist');
        my @and_or = $query->param('and_or');
        my @excluding = $query->param('excluding');
        my @operator = $query->param('operator');
        my @value = $query->param('value');

        $resultsperpage= $query->param('resultsperpage');
        $resultsperpage = 19 if(!defined $resultsperpage);
        my $orderby = $query->param('orderby');

        # builds tag and subfield arrays
        my @tags;

        foreach my $marc (@marclist) {
                if ($marc) {
                        my ($tag,$subfield) = 
MARCfind_marc_from_kohafield($dbh,$marc);
                        if ($tag) {
                                push @tags,$dbh->quote("$tag$subfield");
                        } else {
                                push @tags, $dbh->quote(substr($marc,0,4));
                        }
                } else {
                        push @tags, "";
                }
        }
        findseealso($dbh,address@hidden);
        my ($results,$total) = catalogsearch($dbh, 
address@hidden,address@hidden,
                                                                                
address@hidden, address@hidden, address@hidden,
                                                                                
$startfrom*$resultsperpage, $resultsperpage,$orderby);

        ($template, $loggedinuser, $cookie)
                = get_template_and_user({template_name => 
"authorities/authorities-home.tmpl",
                                query => $query,
                                type => 'intranet',
                                authnotrequired => 0,
                                flagsrequired => {borrowers => 1},
                                flagsrequired => {catalogue => 1},
                                debug => 1,
                                });

        # multi page display gestion
        my $displaynext=0;
        my $displayprev=$startfrom;
        if(($total - (($startfrom+1)*($resultsperpage))) > 0 ){
                $displaynext = 1;
        }

        my @field_data = ();


        for(my $i = 0 ; $i <= $#marclist ; $i++)
        {
                push @field_data, { term => "marclist", val=>$marclist[$i] };
                push @field_data, { term => "and_or", val=>$and_or[$i] };
                push @field_data, { term => "excluding", val=>$excluding[$i] };
                push @field_data, { term => "operator", val=>$operator[$i] };
                push @field_data, { term => "value", val=>$value[$i] };
        }

        my @numbers = ();

        if ($total>$resultsperpage)
        {
                for (my $i=1; $i<$total/$resultsperpage+1; $i++)
                {
                        if ($i<16)
                        {
                        my $highlight=0;
                        ($startfrom==($i-1)) && ($highlight=1);
                        push @numbers, { number => $i,
                                        highlight => $highlight ,
                                        searchdata=> address@hidden,
                                        startfrom => ($i-1)};
                        }
        }
        }

        my $from = $startfrom*$resultsperpage+1;
        my $to;

        if($total < (($startfrom+1)*$resultsperpage))
        {
                $to = $total;
        } else {
                $to = (($startfrom+1)*$resultsperpage);
        }
        $template->param(result => $results,
                                                        startfrom=> $startfrom,
                                                        displaynext=> 
$displaynext,
                                                        displayprev=> 
$displayprev,
                                                        resultsperpage => 
$resultsperpage,
                                                        startfromnext => 
$startfrom+1,
                                                        startfromprev => 
$startfrom-1,
                                                        
searchdata=>address@hidden,
                                                        total=>$total,
                                                        from=>$from,
                                                        to=>$to,
                                                        numbers=>address@hidden,
                                                        );

} elsif ($op eq "AddStatement") {

        ($template, $loggedinuser, $cookie)
                = get_template_and_user({template_name => 
"authorities/authorities-home.tmpl",
                                query => $query,
                                type => 'intranet',
                                authnotrequired => 0,
                                flagsrequired => {catalogue => 1},
                                debug => 1,
                                });

        # Gets the entered information
        my @marcfields = $query->param('marclist');
        my @and_or = $query->param('and_or');
        my @excluding = $query->param('excluding');
        my @operator = $query->param('operator');
        my @value = $query->param('value');

        my @statements = ();

        # List of the marc tags to display
        my $marcarray = create_marclist();

        my $nbstatements = $query->param('nbstatements');
        $nbstatements = 1 if(!defined $nbstatements);

        for(my $i = 0 ; $i < $nbstatements ; $i++)
        {
                my %fields = ();

                # Recreates the old scrolling lists with the previously 
selected values
                my $marclist = create_scrolling_list({name=>"marclist",
                                        values=> $marcarray,
                                        size=> 1,
                                        default=>$marcfields[$i],
                                        onChange => "sql_update()"}
                                        );

                $fields{'marclist'} = $marclist;
                $fields{'first'} = 1 if($i == 0);

                # Restores the and/or parameters (no need to test the 'and' for 
activation because it's the default value)
                $fields{'or'} = 1 if($and_or[$i] eq "or");

                #Restores the "not" parameters
                $fields{'not'} = 1 if($excluding[$i]);

                #Restores the operators (most common operators first);
                if($operator[$i] eq "=") { $fields{'eq'} = 1; }
                elsif($operator[$i] eq "contains") { $fields{'contains'} = 1; }
                elsif($operator[$i] eq "start") { $fields{'start'} = 1; }
                elsif($operator[$i] eq ">") { $fields{'gt'} = 1; }      
#greater than
                elsif($operator[$i] eq ">=") { $fields{'ge'} = 1; } #greater or 
equal
                elsif($operator[$i] eq "<") { $fields{'lt'} = 1; } #lower than
                elsif($operator[$i] eq "<=") { $fields{'le'} = 1; } #lower or 
equal

                #Restores the value
                $fields{'value'} = $value[$i];

                push @statements, \%fields;
        }
        $nbstatements++;

        # The new scrolling list
        my $marclist = create_scrolling_list({name=>"marclist",
                                values=> $marcarray,
                                size=>1,
                                onChange => "sql_update()"});
        push @statements, {"marclist" => $marclist };

        $template->param("statements" => address@hidden,
                                                "nbstatements" => 
$nbstatements);

}
else {
        ($template, $loggedinuser, $cookie)
                = get_template_and_user({template_name => 
"authorities/authorities-home.tmpl",
                                query => $query,
                                type => 'intranet',
                                authnotrequired => 0,
                                flagsrequired => {catalogue => 1},
                                debug => 1,
                                });
        #$template->param(loggedinuser => $loggedinuser);

        my $marcarray = create_marclist();

        my $marclist = CGI::scrolling_list(-name=>"marclist",
                                        -values=> $marcarray,
                                        -size=>1,
                                        -multiple=>0,
                                        -onChange => "sql_update()",
                                        );

        my @statements = ();

        # Considering initial search with 3 criterias
        push @statements, { "marclist" => $marclist, "first" => 1 };
        push @statements, { "marclist" => $marclist, "first" => 0 };
        push @statements, { "marclist" => $marclist, "first" => 0 };
        my $sth=$dbh->prepare("Select itemtype,description from itemtypes order 
by description");
        $sth->execute;
        my  @itemtype;
        my %itemtypes;
        push @itemtype, "";
        $itemtypes{''} = "";
        while (my ($value,$lib) = $sth->fetchrow_array) {
                push @itemtype, $value;
                $itemtypes{$value}=$lib;
        }

        my $CGIitemtype=CGI::scrolling_list( -name     => 'value',
                                -values   => address@hidden,
                                -labels   => \%itemtypes,
                                -size     => 1,
                                -multiple => 0 );
        $sth->finish;

        my @branches;
        my @select_branch;
        my %select_branches;
        my ($count2,@branches)=branches();
        push @select_branch, "";
        $select_branches{''} = "";
        for (my $i=0;$i<$count2;$i++){
                push @select_branch, $branches[$i]->{'branchcode'};#
                $select_branches{$branches[$i]->{'branchcode'}} = 
$branches[$i]->{'branchname'};
        }
        my $CGIbranch=CGI::scrolling_list( -name     => 'value',
                                -values   => address@hidden,
                                -labels   => \%select_branches,
                                -size     => 1,
                                -multiple => 0 );
        $sth->finish;


        $template->param("statements" => address@hidden,
                        "nbstatements" => 3,
                        CGIitemtype => $CGIitemtype,
                        CGIbranch => $CGIbranch,
                        );
}

$template->param(authtypesloop => address@hidden);

# Print the page
output_html_with_http_headers $query, $cookie, $template->output;

# Local Variables:
# tab-width: 4
# End:

--- NEW FILE ---
#!/usr/bin/perl

# $Id: authorities.pl,v 1.1 2004/06/07 07:36:46 tipaul Exp $

# 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., 59 Temple Place,
# Suite 330, Boston, MA  02111-1307 USA

use strict;
use CGI;
use C4::Auth;
use C4::Output;
use C4::Interface::CGI::Output;
use C4::AuthoritiesMarc;
use C4::Context;
use C4::Koha; # XXX subfield_is_koha_internal_p
use HTML::Template;
use MARC::File::USMARC;

use vars qw( $tagslib);
use vars qw( $authorised_values_sth);
use vars qw( $is_a_modif );

=item find_value

    ($indicators, $value) = find_value($tag, $subfield, $record,$encoding);

Find the given $subfield in the given $tag in the given
MARC::Record $record.  If the subfield is found, returns
the (indicators, value) pair; otherwise, (undef, undef) is
returned.

=cut

sub find_value {
        my ($tagfield,$insubfield,$record,$encoding) = @_;
        my @result;
        my $indicator;
        if ($tagfield <10) {
                if ($record->field($tagfield)) {
                        push @result, $record->field($tagfield)->data();
                } else {
                        push @result,"";
                }
        } else {
                foreach my $field ($record->field($tagfield)) {
                        my @subfields = $field->subfields();
                        foreach my $subfield (@subfields) {
                                if (@$subfield[0] eq $insubfield) {
                                        push 
@result,char_decode(@$subfield[1],$encoding);
                                        $indicator = 
$field->indicator(1).$field->indicator(2);
                                }
                        }
                }
        }
        return($indicator,@result);
}


=item build_authorized_values_list

=cut

sub build_authorized_values_list ($$$$$) {
        my($tag, $subfield, $value, $dbh,$authorised_values_sth) = @_;

        my @authorised_values;
        my %authorised_lib;

        # builds list, depending on authorised value...

        #---- branch
        if ($tagslib->{$tag}->{$subfield}->{'authorised_value'} eq "branches" ) 
{
        my $sth=$dbh->prepare("select branchcode,branchname from branches order 
by branchname");
        $sth->execute;
        push @authorised_values, ""
                unless ($tagslib->{$tag}->{$subfield}->{mandatory});

        while (my ($branchcode,$branchname) = $sth->fetchrow_array) {
                push @authorised_values, $branchcode;
                $authorised_lib{$branchcode}=$branchname;
        }

        #----- itemtypes
        } elsif ($tagslib->{$tag}->{$subfield}->{authorised_value} eq 
"itemtypes") {
                my $sth=$dbh->prepare("select itemtype,description from 
itemtypes order by description");
                $sth->execute;
                push @authorised_values, "" unless 
($tagslib->{$tag}->{$subfield}->{mandatory});
        
                while (my ($itemtype,$description) = $sth->fetchrow_array) {
                        push @authorised_values, $itemtype;
                        $authorised_lib{$itemtype}=$description;
                }
#               $value=$itemtype unless ($value);

        #---- "true" authorised value
        } else {
                
$authorised_values_sth->execute($tagslib->{$tag}->{$subfield}->{authorised_value});

                push @authorised_values, "" unless 
($tagslib->{$tag}->{$subfield}->{mandatory});
        
                while (my ($value,$lib) = 
$authorised_values_sth->fetchrow_array) {
                        push @authorised_values, $value;
                        $authorised_lib{$value}=$lib;
                }
    }
    return CGI::scrolling_list( -name     => 'field_value',
                                -values   => address@hidden,
                                -default  => $value,
                                -labels   => \%authorised_lib,
                                -size     => 1,
                                -multiple => 0 );
}

=item create_input
 builds the <input ...> entry for a subfield.
=cut
sub create_input () {
        my ($tag,$subfield,$value,$i,$rec,$authorised_values_sth) = @_;
        $value =~ s/"/&quot;/g;
        my $dbh = C4::Context->dbh;
        my %subfield_data;
        $subfield_data{tag}=$tag;
        $subfield_data{subfield}=$subfield;
        $subfield_data{marc_lib}="<span 
id=\"error$i\">".$tagslib->{$tag}->{$subfield}->{lib}."</span>";
        $subfield_data{tag_mandatory}=$tagslib->{$tag}->{mandatory};
        $subfield_data{mandatory}=$tagslib->{$tag}->{$subfield}->{mandatory};
        $subfield_data{repeatable}=$tagslib->{$tag}->{$subfield}->{repeatable};
#       $subfield_data{kohafield}=$tagslib->{$tag}->{$subfield}->{kohafield};
        if ($tagslib->{$tag}->{$subfield}->{authorised_value}) {
                $subfield_data{marc_value}= build_authorized_values_list($tag, 
$subfield, $value, $dbh,$authorised_values_sth);
        } elsif ($tagslib->{$tag}->{$subfield}->{thesaurus_category}) {
                $subfield_data{marc_value}="<input type=\"text\" 
name=\"field_value\"  size=47 maxlength=255 DISABLE READONLY> <a 
href=\"javascript:Dopop('../thesaurus_popup.pl?category=$tagslib->{$tag}->{$subfield}->{thesaurus_category}&index=$i',$i)\">...</a>";
        } elsif ($tagslib->{$tag}->{$subfield}->{'value_builder'}) {
                my 
$plugin="../value_builder/".$tagslib->{$tag}->{$subfield}->{'value_builder'};
                require $plugin;
                my $extended_param = plugin_parameters($dbh,$rec,$tagslib,$i,0);
                my ($function_name,$javascript) = 
plugin_javascript($dbh,$rec,$tagslib,$i,0);
                $subfield_data{marc_value}="<input type=\"text\" 
name=\"field_value\"  value=\"$value\" DISABLE READONLY size=47 maxlength=255 
OnFocus=\"javascript:Focus$function_name($i)\" 
OnBlur=\"javascript:Blur$function_name($i)\"> <a 
href=\"javascript:Clic$function_name($i)\">...</a> $javascript";
        } elsif  ($tag eq '') {
                $subfield_data{marc_value}="<input type=\"hidden\" 
name=\"field_value\" size=50 maxlength=255>"; #"
        } else {
                $subfield_data{marc_value}="<input type=\"text\" 
name=\"field_value\" value=\"$value\" size=50 maxlength=255>"; #"
        }
        return \%subfield_data;
}

sub build_tabs ($$$$) {
    my($template, $record, $dbh,$encoding) = @_;

    # fill arrays
    my @loop_data =();
    my $tag;
    my $i=0;
        my $authorised_values_sth = $dbh->prepare("select authorised_value,lib
                from authorised_values
                where category=? order by lib");

        my @loop_data = ();
        foreach my $tag (sort(keys (%{$tagslib}))) {
                my $indicator;
# if MARC::Record is not empty => use it as master loop, then add missing 
subfields that should be in the tab.
# if MARC::Record is empty => use tab as master loop.
                if ($record ne -1 && $record->field($tag)) {
                        my @fields = $record->field($tag);
                        foreach my $field (@fields)  {
                                my @subfields_data;
                                if ($tag<10) {
                                        my $value=$field->data();
                                        my $subfield="@";
                                        next if 
($tagslib->{$tag}->{$subfield}->{tab} eq -1);
                                        push(@subfields_data, 
&create_input($tag,$subfield,char_decode($value,$encoding),$i,$record,$authorised_values_sth));
                                        $i++;
                                } else {
                                        my @subfields=$field->subfields();
                                        foreach my $subfieldcount 
(0..$#subfields) {
                                                my 
$subfield=$subfields[$subfieldcount][0];
                                                my 
$value=$subfields[$subfieldcount][1];
                                                next if (length $subfield !=1);
                                                next if 
($tagslib->{$tag}->{$subfield}->{tab} eq -1);
                                                push(@subfields_data, 
&create_input($tag,$subfield,char_decode($value,$encoding),$i,$record,$authorised_values_sth));
                                                $i++;
                                        }
                                }
# now, loop again to add parameter subfield that are not in the MARC::Record
                                foreach my $subfield (sort( keys 
%{$tagslib->{$tag}})) {
                                        next if (length $subfield !=1);
                                        next if 
($tagslib->{$tag}->{$subfield}->{tab} eq -1);
                                        next if ($tag<10);
                                        next if 
(defined($record->field($tag)->subfield($subfield)));
                                        push(@subfields_data, 
&create_input($tag,$subfield,'',$i,$record,$authorised_values_sth));
                                        $i++;
                                }
                                if ($#subfields_data >= 0) {
                                        my %tag_data;
                                        $tag_data{tag} = $tag;
                                        $tag_data{tag_lib} = 
$tagslib->{$tag}->{lib};
                                        $tag_data{repeatable} = 
$tagslib->{$tag}->{repeatable};
                                        $tag_data{indicator} = 
$record->field($tag)->indicator(1). $record->field($tag)->indicator(2) if 
($tag>=10);
                                        $tag_data{subfield_loop} = 
address@hidden;
                                        push (@loop_data, \%tag_data);
                                }
# If there is more than 1 field, add an empty hidden field as separator.
                                if ($#fields >=1) {
                                        my @subfields_data;
                                        my %tag_data;
                                        push(@subfields_data, 
&create_input('','','',$i,$record,$authorised_values_sth));
                                        $tag_data{tag} = '';
                                        $tag_data{tag_lib} = '';
                                        $tag_data{indicator} = '';
                                        $tag_data{subfield_loop} = 
address@hidden;
                                        push (@loop_data, \%tag_data);
                                        $i++;
                                }
                        }
# if breeding is empty
                } else {
                        my @subfields_data;
                        foreach my $subfield (sort(keys %{$tagslib->{$tag}})) {
                                next if (length $subfield !=1);
                                next if ($tagslib->{$tag}->{$subfield}->{tab} 
eq -1);
                                push(@subfields_data, 
&create_input($tag,$subfield,'',$i,$record,$authorised_values_sth));
                                $i++;
                        }
                        if ($#subfields_data >= 0) {
                                my %tag_data;
                                $tag_data{tag} = $tag;
                                $tag_data{tag_lib} = $tagslib->{$tag}->{lib};
                                $tag_data{indicator} = $indicator;
                                $tag_data{subfield_loop} = address@hidden;
                                push (@loop_data, \%tag_data);
                        }
                }
        }
        $template->param("0XX" =>address@hidden);
}


sub build_hidden_data () {
    # build hidden data =>
    # we store everything, even if we show only requested subfields.

    my @loop_data =();
    my $i=0;
    foreach my $tag (keys %{$tagslib}) {
        my $previous_tag = '';

        # loop through each subfield
        foreach my $subfield (keys %{$tagslib->{$tag}}) {
            next if ($subfield eq 'lib');
            next if ($subfield eq 'tab');
            next if ($subfield eq 'mandatory');
                next if ($subfield eq 'repeatable');
            next if ($tagslib->{$tag}->{$subfield}->{'tab'}  ne "-1");
            my %subfield_data;
            $subfield_data{marc_lib}=$tagslib->{$tag}->{$subfield}->{lib};
            
$subfield_data{marc_mandatory}=$tagslib->{$tag}->{$subfield}->{mandatory};
            
$subfield_data{marc_repeatable}=$tagslib->{$tag}->{$subfield}->{repeatable};
            $subfield_data{marc_value}="<input type=\"hidden\" 
name=\"field_value[]\">";
            push(@loop_data, \%subfield_data);
            $i++
        }
    }
}


# ======================== 
#          MAIN 
#=========================
my $input = new CGI;
my $error = $input->param('error');
my $authid=$input->param('authid'); # if authid exists, it's a modif, not a new 
authority.
my $z3950 = $input->param('z3950');
my $op = $input->param('op');
my $authtypecode = $input->param('authtypecode');
my $dbh = C4::Context->dbh;
$authtypecode = &AUTHfind_authtypecode($dbh,$authid) if $authid;
my ($template, $loggedinuser, $cookie)
    = get_template_and_user({template_name => "authorities/authorities.tmpl",
                             query => $input,
                             type => "intranet",
                             authnotrequired => 0,
                             flagsrequired => {editcatalogue => 1},
                             debug => 1,
                             });

$tagslib = AUTHgettagslib($dbh,1,$authtypecode);
my $record=-1;
my $encoding="";
$record = AUTHgetauth($dbh,$authid) if ($authid);

$is_a_modif=0;
my ($oldbiblionumtagfield,$oldbiblionumtagsubfield);
my 
($oldbiblioitemnumtagfield,$oldbiblioitemnumtagsubfield,$bibitem,$oldbiblioitemnumber);
if ($authid) {
        $is_a_modif=1;
        # if it's a modif, retrieve old biblio and bibitem numbers for the 
future modification of old-DB.
#       ($oldbiblionumtagfield,$oldbiblionumtagsubfield) = 
&MARCfind_marc_from_kohafield($dbh,"biblio.biblionumber");
#       ($oldbiblioitemnumtagfield,$oldbiblioitemnumtagsubfield) = 
&MARCfind_marc_from_kohafield($dbh,"biblioitems.biblioitemnumber");
#       # search biblioitems value
#       my $sth=$dbh->prepare("select biblioitemnumber from biblioitems where 
biblionumber=?");
#       $sth->execute($oldbiblionumber);
#       ($oldbiblioitemnumber) = $sth->fetchrow;
}
#------------------------------------------------------------------------------------------------------------------------------
if ($op eq "add") {
#------------------------------------------------------------------------------------------------------------------------------
        # rebuild
        my @tags = $input->param('tag');
        my @subfields = $input->param('subfield');
        my @values = $input->param('field_value');
        # build indicator hash.
        my @ind_tag = $input->param('ind_tag');
        my @indicator = $input->param('indicator');
        my %indicators;
        for (my $i=0;$i<=$#ind_tag;$i++) {
                $indicators{$ind_tag[$i]} = $indicator[$i];
        }
        my $record = 
AUTHhtml2marc($dbh,address@hidden,address@hidden,address@hidden,%indicators);
# MARC::Record built => now, record in DB
        if ($is_a_modif) {
                 AUTHmodauthority($dbh,$record,$authid,$authtypecode);
        } else {
                ($authid) = 
AUTHaddauthority($dbh,$record,$authid,$authtypecode);
        }
#------------------------------------------------------------------------------------------------------------------------------
} elsif ($op eq "addfield") {
#------------------------------------------------------------------------------------------------------------------------------
        my $addedfield = $input->param('addfield_field');
        my @tags = $input->param('tag');
        my @subfields = $input->param('subfield');
        my @values = $input->param('field_value');
        # build indicator hash.
        my @ind_tag = $input->param('ind_tag');
        my @indicator = $input->param('indicator');
        splice(@tags,$addedfield,0,$tags[$addedfield]);
        splice(@subfields,$addedfield,0,$subfields[$addedfield]);
        splice(@values,$addedfield,0,$values[$addedfield]);
        splice(@ind_tag,$addedfield,0,$ind_tag[$addedfield]);
        my %indicators;
        for (my $i=0;$i<=$#ind_tag;$i++) {
                $indicators{$ind_tag[$i]} = $indicator[$i];
        }
# search the part of the array to duplicate.
        my $start=0;
        my $end=0;
        my $started;
        for (my $i=0;$i<=$#tags;$i++) {
                $start=$i if ($start eq 0 && $tags[$i] == $addedfield);
                $end=$i if ($start>0 && $tags[$i] eq $addedfield);
                last if ($start>0 && $tags[$i] ne $addedfield);
        }
# add an empty line in all arrays. This forces a new field in MARC::Record.
        splice(@tags,$end+1,0,'');
        splice(@subfields,$end+1,0,'');
        splice(@values,$end+1,0,'');
        splice(@ind_tag,$end+1,0,'');
        splice(@indicator,$end+1,0,'');
# then duplicate the field.
        splice(@tags,$end+2,0,@tags[$start..$end]);
        splice(@subfields,$end+2,0,@subfields[$start..$end]);
        splice(@values,$end+2,0,@values[$start..$end]);
        splice(@ind_tag,$end+2,0,@ind_tag[$start..$end]);
        splice(@indicator,$end+2,0,@indicator[$start..$end]);

        my %indicators;
        for (my $i=0;$i<=$#ind_tag;$i++) {
                $indicators{$ind_tag[$i]} = $indicator[$i];
        }
        my $record = 
MARChtml2marc($dbh,address@hidden,address@hidden,address@hidden,%indicators);
        build_tabs ($template, $record, $dbh,$encoding);
        build_hidden_data;
        $template->param(
                authid                       => $authid,
                oldbiblionumtagfield        => $oldbiblionumtagfield,
                oldbiblionumtagsubfield     => $oldbiblionumtagsubfield,
                oldbiblioitemnumtagfield    => $oldbiblioitemnumtagfield,
                oldbiblioitemnumtagsubfield => $oldbiblioitemnumtagsubfield,
                oldbiblioitemnumber         => $oldbiblioitemnumber );
} elsif ($op eq "delete") {
#------------------------------------------------------------------------------------------------------------------------------
        &AUTHdelauthority($dbh,$authid);
}
#------------------------------------------------------------------------------------------------------------------------------
#------------------------------------------------------------------------------------------------------------------------------
# MAIN
#------------------------------------------------------------------------------------------------------------------------------
build_tabs ($template, $record, $dbh,$encoding);
build_hidden_data;
$template->param(
        authid                       => $authid,
        oldbiblionumtagfield        => $oldbiblionumtagfield,
        oldbiblionumtagsubfield     => $oldbiblionumtagsubfield,
        oldbiblioitemnumtagfield    => $oldbiblioitemnumtagfield,
        oldbiblioitemnumtagsubfield => $oldbiblioitemnumtagsubfield,
        oldbiblioitemnumber         => $oldbiblioitemnumber );
$template->param(
                authtypecode => $authtypecode,
                );
output_html_with_http_headers $input, $cookie, $template->output;