Attachment #126413 for bug #14367

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




use MARC::File::XML;
use POSIX qw( strftime );
use Module::Load::Conditional qw( can_load );
use JSON qw(encode_json decode_json);

use C4::Koha;
use C4::Log qw( logaction );    # logaction

use Koha::SearchEngine::Indexer;
use Koha::Libraries;
use Koha::Util::MARC;
use Koha::MetadataRecord::History;

=head1 NAME


                BiblioAutoLink( $record, $frameworkcode );
            }

            # now add the record (history parameter is undef: no history yet)
            ModBiblioMarc( $record, $biblionumber, undef ) unless $defer_marc_save;

            # update OAI-PMH sets
            if(C4::Context->preference("OAI-PMH:AutoUpdateSets")) {

    # update biblionumber and biblioitemnumber in MARC
    # FIXME - this is assuming a 1 to 1 relationship between
    # biblios and biblioitems
    my $sth = $dbh->prepare("select biblioitems.biblioitemnumber, biblio_metadata.history from biblioitems INNER JOIN biblio_metadata ON biblioitems.biblionumber = biblio_metadata.biblionumber WHERE biblioitems.biblionumber=?");
    $sth->execute($biblionumber);
    my ($biblioitemnumber, $history) = $sth->fetchrow;
    $sth->finish();
    _koha_marc_update_bib_ids( $record, $frameworkcode, $biblionumber, $biblioitemnumber );


    _koha_marc_update_biblioitem_cn_sort( $record, $oldbiblio, $frameworkcode );

    # update the MARC record (that now contains biblio and items) with the new record data
    &ModBiblioMarc( $record, $biblionumber, $history );

    # modify the other koha tables
    _koha_modify_biblio( $dbh, $oldbiblio, $frameworkcode );

sub ModBiblioMarc {
    # pass the MARC::Record to this function, and it will create the records in
    # the marcxml field
    my ( $record, $biblionumber, $history ) = @_;
    if ( !$record ) {
        carp 'ModBiblioMarc passed an undefined record';
        return;

    my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
    $indexer->index_records( $biblionumber, "specialUpdate", "biblioserver" );

    # Decode JSON history, create new record, update and re-encode to JSON.
    my $historylength = 10;
    eval {
        $history = decode_json($history);
        1;
    } or do {
        $history = undef;
    };
    my $newrecord = HistoryRecordNew($record);
    my $newhistory = HistoryUpdate($newrecord, $historylength, $history);
    $newhistory = encode_json($newhistory);

    $m_rs->update({ metadata => $record->as_xml_record($encoding), history => $newhistory });

    ModZebra( $biblionumber, "specialUpdate", "biblioserver", $record );
    return $biblionumber;
}





package Koha::MetadataRecord::History;

# Copyright 2016 Aleisha Amohia <aleisha@catalyst.net.nz>
#
# 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 3 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, see <http://www.gnu.org/licenses>.

use strict;
use warnings;

use C4::Charset qw( StripNonXmlChars );
use JSON qw(decode_json);

use vars qw(@ISA @EXPORT);

BEGIN {
    require Exporter;
    @ISA = qw( Exporter );

    push @EXPORT, qw(
        &GetMarcBiblioHistory
        &HistoryUpdate
        &HistoryParse
        &HistoryMapUsers
        &HistoryBorrowerDetails
        &HistoryRecordNew
    );
 }

=head1 NAME

Koha::MetadataRecord::History - tracking changes to MARC records

=head1 DESCRIPTION

Koha::MetadataRecord::History not only tracks changes to MARC records and presents them in a log, but also allows users to
roll them back, either in batch to a previous point in the history or separately for each field (so you can roll back changes
to a field without changing fields that may have been changed after this one).

=head2 GetMarcBiblioHistory

    my ($record, $history) = GetMarcBiblio($biblionumber, [$embeditems]);

Returns MARC::Record representing bib identified by C<$biblionumber>.  If no bib exists, returns undef.
C<$biblionumber>.  If no bib exists, returns undef.
C<$embeditems>.  If set to true, items data are included.
The MARC record contains biblio data, and items data if $embeditems is set to true.

=cut

sub GetMarcBiblioHistory {
    my $biblionumber = shift;
    my $embeditems   = shift || 0;
    if (not defined $biblionumber) {
        warn "GetMarcBiblio called with undefined biblionumber";
        return;
    }
    my $dbh = C4::Context->dbh;
    my $sth = $dbh->prepare("SELECT metadata,history FROM biblio_metadata WHERE biblionumber=? ");
    $sth->execute($biblionumber);
    my $row = $sth->fetchrow_hashref;
    my $marcxml = StripNonXmlChars( $row->{'metadata'} );
    MARC::File::XML->default_record_format( C4::Context->preference('marcflavour') );
    my $record = MARC::Record->new();
    my ($history, $borrowers) = HistoryParse( $row->{'history'} );
    $borrowers = HistoryBorrowerDetails( $borrowers );
    $history = HistoryMapUsers( $history, $borrowers );
    if ($marcxml) {
        $record = eval { MARC::Record::new_from_xml( $marcxml, "utf8", C4::Context->preference('marcflavour') ) };
        if ($@) { warn " problem with :$biblionumber : $@ \n$marcxml"; }
            return unless $record;
            C4::Biblio::_koha_marc_update_bib_ids($record, '', $biblionumber, $biblionumber);
            C4::Biblio::EmbedItemsInMarcBiblio($record, $biblionumber) if ($embeditems);
            return ($record, $history);
    } else {
        return;
    }
}

=head2 HistoryParse

Input format (JSON): [ { datetime, borrowernumber, marcxml } ]
Output format: { tag } { subfield } [ { borrowernumber, data, datetime } ]

=cut

sub HistoryParse {
    my $json = shift;
    if (!defined $json) {
        warn "HistoryParse: Missing JSON parameter";
        return;
    }
    my $input = decode_json($json);
    # Reindex the dataset; order all values by datetime under each tag name.
    my $borrowers = { };
    my $output = { };
    for my $item (@{$input}) {
        my $datetime = $item->{datetime};
        $borrowers->{ $item->{borrowernumber }} = undef;
        my $record = MARC::File::XML::decode($item->{marcxml});
        for my $field ($record->fields()) {
            my $tag = $field->tag();
            $output->{$tag} = {} unless defined $output->{$tag};
            for my $subfield ($field->subfields()) {
                # Build hash ref structure.
                my $subfield_tag = @{$subfield}[0];
                $output->{$tag}->{$subfield_tag} = []
                unless defined $output->{$tag}->{$subfield_tag};
                push( @{ $output->{$tag}->{$subfield_tag} }, HistoryParsedRecordNew(
                    @{ $subfield }[1], $item->{borrowernumber}, $datetime));
                }
            }
        }
    return ( $output, $borrowers );
}

=head2 HistoryBorrowerDetails

Take a hashref with borrowernumbers as keys, returns new hash with the
borrowernumber as key to hash containing firstname, surname and title.

=cut

sub HistoryBorrowerDetails {
    my $borrowernumbers = shift;
    my $dbh = C4::Context->dbh;
    my $output = { };
    my @numbers = keys %{$borrowernumbers};
    if (@numbers > 0) {
        # We now need to look up the numeric user id's and map to name and title strings.
        my $sth = $dbh->prepare(qq{SELECT
            borrowernumber, title, firstname, surname
            FROM borrowers
            WHERE borrowernumber IN}
            . '(' . join(',', ('?') x @numbers) . ')');
        $sth->execute(@numbers)
            or die ('BorrowerDetails: Unable to execute SELECT statement');
        while (my $row = $sth->fetchrow_hashref()) {
            $output->{ $row->{borrowernumber} } = { };
            $output->{ $row->{borrowernumber} }->{title}     = $row->{title};
            $output->{ $row->{borrowernumber} }->{firstname} = $row->{firstname};
            $output->{ $row->{borrowernumber} }->{surname}   = $row->{surname};
        }
        $sth->finish();
    }
    return $output;
}

=head2 HistoryMapUsers

=cut

sub HistoryMapUsers {
    my ($history, $borrowers) = @_;
    my $mappedhistory = { };
    for my $tag (keys %{ $history }) {
        $mappedhistory->{ $tag } = { };
        for my $field (keys %{ $history->{ $tag } }) {
            $mappedhistory->{ $tag }->{ $field } = [ ];
            for my $entry (@{ $history->{ $tag }->{ $field } }) {
                # C4::Dates does not allow me to print time, only dates.
                #my $newtime = C4::Dates->new( $history->{ $tag }->{ $field }->{ $time }->{timestamp}, 'iso' )->output('syspref');
                my $newitem = { };
                my $user = $borrowers->{ $entry->{borrowernumber} };

                # Maybe change this to work on original instead of copy?
                $newitem->{title}          = $user->{title};
                $newitem->{firstname}      = $user->{firstname};
                $newitem->{surname}        = $user->{surname};
                $newitem->{borrowernumber} = $entry->{borrowernumber};
                $newitem->{data}           = $entry->{data};
                $newitem->{datetime}       = $entry->{datetime};

                push ( @{ $mappedhistory->{ $tag }->{ $field } } , $newitem);
            }
        }
    }
    return $mappedhistory;
}

=head2 HistoryParsedRecordNew

=cut

sub HistoryParsedRecordNew {
    my ($value, $borrowernumber, $datetime) = @_;
    my $newrecord = {
        data           => $value,
        borrowernumber => $borrowernumber,
        datetime       => $datetime,
    };
    return $newrecord;
}

=head2 HistoryRecordNew

=cut

sub HistoryRecordNew {
    my ( $record ) = @_;
    my $encoding = C4::Context->preference("marcflavour");
    my $hash_record = {
        borrowernumber => C4::Context->userenv()->{number},
        datetime       => POSIX::strftime('%Y-%m-%d %T', localtime(time)),
        marcxml        => $record->as_xml_record($encoding),
    };
    return $hash_record;
}

=head2 HistoryUpdate

=cut

sub HistoryUpdate {
    my ( $record, $limit, $collection ) = @_;
    if ( !$record ) {
        warn "HistoryUpdate: Called with undefined record";
        return;
    }
    if ( ref($record) ne 'HASH' ) {
        warn "HistoryUpdate: Record parameter is not a hashref";
        return;
    }
    $limit = 10 unless defined $limit;
    # We need something to append history to, even if there is none.
    $collection = [] unless defined $collection;
    # Truncate history to $histsize - 1, need space for new entry.
    splice(@{$collection}, $limit - 1);
    push(@{$collection}, $record);
    # Sort the resulting array, newest entries first.
    # Removed; used to be integer timestamps. Is now MySQL date strings.
    #@{$collection} = sort { $a->{timestamp} < $b->{timestamp} } @{$collection};
    @{$collection} = sort { $a->{datetime} lt $b->{datetime} } @{$collection};
    return $collection;
}

1;

__END__

=head1 AUTHOR

Koha Development Team <http://koha-community.org/>

Paul POULAIN paul.poulain@free.fr

Joshua Ferraro jmf@liblime.com

=cut




use C4::Charset qw( SetMarcUnicodeFlag );
use Koha::BiblioFrameworks;
use Koha::DateUtils qw( dt_from_string );
use C4::Koha;
use Koha::ItemTypes;
use Koha::MetadataRecord::History;
use Koha::Libraries;

use Koha::BiblioFrameworks;

use MARC::File::USMARC;
use MARC::File::XML;
use URI::Escape qw( uri_escape_utf8 );

=cut

sub create_input {

    my ( $tag, $subfield, $value, $index_tag, $tabloop, $rec, $authorised_values_sth,$cgi, $history ) = @_;

    my $index_subfield = CreateKey(); # create a specifique key for each subfield

    my $taghistory = $history->{$tag}->{$subfield};

    $value =~ s/"/&quot;/g;

    # if there is no value provided but a default value in parameters, get it
    if ( $value eq '' ) {
        $value = $tagslib->{$tag}->{$subfield}->{defaultvalue} // q{};

        # And <<USER>> with surname (?)
        my $username=(C4::Context->userenv?C4::Context->userenv->{'surname'}:"superlibrarian");
        $value=~s/<<USER>>/$username/g;

    }
    my $dbh = C4::Context->dbh;


        value          => $value,
        maxlength      => $tagslib->{$tag}->{$subfield}->{maxlength},
        random         => CreateKey(),
        history        => $taghistory,
    );

    if(exists $mandatory_z3950->{$tag.$subfield}){

            maxlength => $subfield_data{maxlength},
            readonly  => ($is_readonly) ? 1 : 0,
            authtype  => $tagslib->{$tag}->{$subfield}->{authtypecode},
            history   => $taghistory,
        };

    # it's a plugin field

                javascript     => $plugin->javascript,
                plugin         => $plugin->name,
                noclick        => $plugin->noclick,
                history        => $taghistory,
            };
        } else {
            warn $plugin->errstr;

                size      => 67,
                maxlength => $subfield_data{maxlength},
                readonly  => 0,
                history   => $taghistory,
            };
        }


            value     => $value,
            size      => 67,
            maxlength => $subfield_data{maxlength},
            history   => $taghistory,
        };

    }

                id        => $subfield_data{id},
                name      => $subfield_data{id},
                value     => $value,
                history   => $taghistory,
            };

        }

                size      => 67,
                maxlength => $subfield_data{maxlength},
                readonly  => 0,
                history   => $taghistory,
            };

        }

}

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

    # fill arrays
    my @loop_data = ();
    #my $tag;

    my $branch_limit = C4::Context->userenv ? C4::Context->userenv->{"branch"} : "";
    my $query = "SELECT authorised_value, lib

		}
		# loop through each field
                foreach my $field (@fields) {
                    
                    my @subfields_data;
                    if ( $tag < 10 ) {
                        my ( $value, $subfield );

                            @subfields_data,
                            &create_input(
                                $tag, $subfield, $value, $index_tag, $tabloop, $record,
                                $authorised_values_sth,$input, $history
                            )
                        );
                    }

                                @subfields_data,
                                &create_input(
                                    $tag, $subfield, $value, $index_tag, $tabloop,
                                    $record, $authorised_values_sth,$input, $history
                                )
                            );
                        }

                            @subfields_data,
                            &create_input(
                                $tag, $subfield, '', $index_tag, $tabloop, $record,
                                $authorised_values_sth,$input, $history
                            )
                        );
                    }

                        @subfields_data,
                        &create_input(
                            $tag, $subfield->{subfield}, '', $index_tag, $tabloop, $record,
                            $authorised_values_sth,$input, $history
                        )
                    );
                }

                        tagfirstsubfield => $subfields_data[0],
                        fixedfield       => $tag < 10?1:0,
                    );

                    push @loop_data, \%tag_data ;
                }
            }

# -- Global

my $record   = -1;
my $history  = undef;
my $encoding = "";
my (
	$biblionumbertagfield,

);

if (($biblionumber) && !($breedingid)){
    ($record, $history) = GetMarcBiblioHistory($biblionumber);
}
if ($breedingid) {
    ( $record, $encoding ) = MARCfindbreeding( $breedingid ) ;

        else {
            ( $biblionumber, $oldbibitemnum ) = AddBiblio( $record, $frameworkcode );
        }
        if ($redirect eq "items" || (defined $mode && $mode ne "popup" && !$is_a_modif && $redirect ne "view" && $redirect ne "just_save")){
	    if ($frameworkcode eq 'FA'){
		print $input->redirect(
            '/cgi-bin/koha/cataloguing/additem.pl?'

        }
    } else {
    # it may be a duplicate, warn the user and do nothing
        build_tabs ($template, $record, $dbh,$encoding, $input, $history);
        $template->param(
            biblionumber             => $biblionumber,
            biblioitemnumber         => $biblioitemnumber,

            $record = $urecord;
        };
    }

    build_tabs( $template, $record, $dbh, $encoding, $input, $history );
    $template->param(
        biblionumber             => $biblionumber,
        biblionumbertagfield        => $biblionumbertagfield,

Line 0 Link Here

(-)a/installer/data/mysql/atomicupdate/bug_14367_-_add_history_column.perl (+9 lines)
	1	$DBversion = 'XXX';
	2	if( CheckVersion( $DBversion ) ) {
	3	unless( column_exists( 'biblio_metadata', 'history' ) ) {
	4	$dbh->do(q\|ALTER TABLE biblio_metadata ADD history longtext default NULL AFTER metadata\|);
	5	}
	6
	7	SetVersion( $DBversion );
	8	print "Upgrade to $DBversion done (Bug 14367: Add column biblio_metadata.history)\n";
	9	}

Lines 80-85 ul li.tag li.subfield_line.ui-sortable-helper::before { Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/css/addbiblio.css (+23 lines)
80	text-decoration : none;	80	text-decoration : none;
81	}	81	}
82		82
		83	.buttonHistory {
		84	font-weight : bold;
		85	text-decoration : none;
		86	}
		87
83	a.expandfield {	88	a.expandfield {
84	text-decoration : none;	89	text-decoration : none;
85	}	90	}
Lines 232-237 a.tagnum { Link Here
232	.linktools a:hover { background-color: #FFC; }	237	.linktools a:hover { background-color: #FFC; }
233	.subfield_controls { margin: 0 .5em; }	238	.subfield_controls { margin: 0 .5em; }
234		239
		240	.readonly { border-width : 1px; border-style: inset; padding-left : 15px; background: #EEE url(../img/locked.png) center left no-repeat; width:29em; }
		241	.subfield_history { margin : 0 .5em; float: right; }
		242
235	#cataloguing_additem_itemlist {	243	#cataloguing_additem_itemlist {
236	margin-bottom : 1em;	244	margin-bottom : 1em;
237	}	245	}
Lines 252-257 tbody tr.active td { Link Here
252	width: 100%;	260	width: 100%;
253	z-index: 1000;	261	z-index: 1000;
254	}	262	}
		263
255	#loading div {	264	#loading div {
256	background : transparent url(../img/loading.gif) top left no-repeat;	265	background : transparent url(../img/loading.gif) top left no-repeat;
257	font-size : 175%;	266	font-size : 175%;
Lines 442-444 tbody tr.active td { Link Here
442	border-bottom: 1px solid #b9d8d9;	451	border-bottom: 1px solid #b9d8d9;
443	border-radius: 0;	452	border-radius: 0;
444	}	453	}
		454
		455	.history_container {
		456	display: none;
		457	}
		458
		459	.history_table {
		460	width: 100%;
		461	display: none;
		462	float: right;
		463	clear: both;
		464	font-size: 75%;
		465	width: 75%;
		466	margin: 0.3em;
		467	}




[% USE raw %]
[% USE Asset %]
[% USE Koha %]
[% USE KohaDates %]
[% INCLUDE 'doc-head-open.inc' %]
<title>[% IF ( biblionumber ) %]Editing [% title | html %] (Record number [% biblionumber | html %])[% ELSE %]Add MARC record[% END %] &rsaquo; Cataloging &rsaquo; Koha</title>
[% INCLUDE 'doc-head-close.inc' %]

    var Sticky;
    $(document).ready(function() {

        $(".input_marceditor").click(function(){
            var tag = $(this).attr('id');
            historyToggle(tag + '_history');
            return false;
        });

        $(".tag_editor").click(function(){
            var tag = $(this).attr('id');
            openAuth(this.parentNode.parentNode.getElementsByTagName('input')[1].id, tag, 'biblio');
            return false;
        });

        $(".buttonHistory").click(function(){
            var tag = $(this).attr('id');
            HistoryToggle(tag + '_history');
            return false;
        });

        $(".hist_rollback").click(function(){
            var tag = $(this).attr('data-tag');
            var value = $(this).attr('data-history');
            HistoryRollback(tag, value);
            return false;
        });

        [% IF bib_doesnt_exist %]
            $("#addbibliotabs").hide();
            $("#toolbar").hide();

                                                <div class="subfield_controls">
                                                    [% IF ( mv.type == 'text' ) %]
                                                        [% IF ( mv.authtype ) %]
                                                            <a id="[%- mv.authtype | html %]" href="#" class="buttonDot tag_editor" onclick="openAuth(this.parentNode.parentNode.getElementsByTagName('input')[1].id,'[%- mv.authtype | html -%]','biblio'); return false;" tabindex="1" title="Tag editor">Tag editor</a>
                                                        [% END %]
                                                    [% ELSIF ( mv.type == 'text_complex' ) %]
                                                            [% IF mv.noclick %]
                                                                <span class="buttonDot tag_editor disabled" tabindex="-1" title="Field autofilled by plugin"></span>
                                                            [% ELSE %]
                                                                [% IF mv.plugin == "upload.pl" %]
                                                                    <a href="#" id="buttonDot_[% mv.id | html %]" class="buttonDot tag_editor upload framework_plugin" tabindex="2"><i class="fa fa-upload" aria-hidden="true"></i> Upload</a>
                                                                [% ELSE %]
                                                                    <a href="#" id="buttonDot_[% mv.id | html %]" class="buttonDot tag_editor framework_plugin" tabindex="2" title="Tag editor">Tag editor</a>
                                                                [% END %]
                                                            [% END %]
                                                        </span>

                                                        </a>
                                                    [% END %]
                                                </div>

                                                [% IF ( subfield_loo.history ) %]
                                                <span class="subfield_history">
                                                    <a href="#" class="buttonHistory" id="[%- mv.id | html -%]">
                                                        <img src="[% interface | html %]/[% theme | html %]/img/icon-history.png" alt="History" title="Display history for this field" />
                                                    </a>
                                                </span>

                                                <table class="history_table" id="[%- mv.id | html -%]_history" name="[%- mv.name | html -%]_history">
                                                    <tr>
                                                        <th>Value</th>
                                                        <th>Date</th>
                                                        <th>User</th>
                                                    </tr>
                                                    [% FOREACH hist IN subfield_loo.history %]
                                                    <tr>
                                                        <td><a href="#" data-tag='[%- mv.id | html -%]' data-history='[% hist.data | html %]' class='hist_rollback'>[% hist.data | html %]</a></td>
                                                        <td>[% hist.datetime | $KohaDates with_hours = 1 %]</td>
                                                        <td>[% hist.title | html %] [% hist.firstname | html %] [% hist.surname | html %]</td>
                                                    </tr>
                                                    [% END %]
                                                </table>
                                                [% END %]
                                            </li> <!-- /.subfield_line -->
                                            <!-- End of the line -->
                                        [% END # /FOREACH subfield_loop %]




    window.open("../authorities/auth_finder.pl?source="+source+"&authtypecode="+authtype+"&index="+tagsubfieldid+"&value_mainstr="+encodeURIComponent(mainmainstring)+"&value_main="+encodeURIComponent(mainstring), "_blank",'width=700,height=550,toolbar=false,scrollbars=yes');
}

function HistoryToggle (tagid)
{
	$('#' + tagid).toggle();
}

function HistoryRollback (tagid, value)
{
	$('#' + tagid).val(value);
}

function ExpandField(index) {
    var original = document.getElementById(index); //original <li>
    var lis = original.getElementsByTagName('li');




#!/usr/bin/perl

use Modern::Perl;
use t::lib::TestBuilder;
use t::lib::Mocks;
use Test::More tests => 6;
use POSIX qw(strftime);

use MARC::Record;
use MARC::Field;
use JSON qw(encode_json);

use Koha::MetadataRecord::History;

BEGIN {
    use_ok('C4::Biblio');
}

our $dbh = C4::Context->dbh;
$dbh->{AutoCommit} = 0;
$dbh->{RaiseError} = 0;

$dbh->do(q|DELETE FROM issues|);
$dbh->do(q|DELETE FROM items|);
$dbh->do(q|DELETE FROM borrowers|);
$dbh->do(q|DELETE FROM branches|);
$dbh->do(q|DELETE FROM categories|);
$dbh->do(q|DELETE FROM biblioitems|);

my $builder = t::lib::TestBuilder->new();

my $branch = $builder->build(
    {
        source => 'Branch',
    }
);

my $category = $builder->build(
    {
        source => 'Category',
    }
);

my $patron1 = $builder->build(
    {
        source => 'Borrower',
        value  => {
            title        => 'Mr/Mrs',
            firstname    => 'First name',
            surname      => 'Surname',
            categorycode => $category->{categorycode},
            branchcode   => $branch->{branchcode},
        },
    }
);

my $patron2 = $builder->build(
    {
        source => 'Borrower',
        value  => {
            title        => 'Mr/Mrs 2',
            firstname    => 'First name 2',
            surname      => 'Surname 2',
            categorycode => $category->{categorycode},
            branchcode   => $branch->{branchcode},
        },
    }
);

my $biblio = $builder->build(
    {
        source => 'Biblio',
        value  => {
            branchcode => $branch->{branchcode},
        },
    }
);

C4::Context->_new_userenv('DUMMY_SESSION_ID');
C4::Context->set_userenv( $patron1->{borrowernumber},
    $patron1->{userid}, 'usercnum', $patron1->{firstname}, $patron1->{surname},
    $branch->{branchcode}, 'My library', 0 );

# Item with no pre-existing history backlog.
my $record1 = MARC::Record->new();
my $field1  = MARC::Field->new(
    245, '1', '0',
    'a' => 'First Title',
    'c' => 'Some dude'
);
$record1->append_fields($field1);

my $record2 = MARC::Record->new();
my $field2  = MARC::Field->new(
    245, '1', '0',
    'a' => 'Second Title',
    'c' => 'Former dude'
);
$record2->append_fields($field2);

my $biblioitem1 = $builder->build(
    {
        source => 'Biblioitem',
        value  => {
            marcxml => $record1->as_xml(),
            history => undef,
        }
    }
);

# items{tagname}{subfield}{timestamp}{borrowernumber|timestamp|marcxml}
my $items = [
    {
        borrowernumber => $patron1->{borrowernumber},
        datetime       => '2012-08-12 12:00:10',
        marcxml        => $record1->as_xml(),
    },
    {
        borrowernumber => $patron2->{borrowernumber},
        datetime       => '2012-08-12 12:00:10',
        marcxml        => $record2->as_xml(),
    }
];

# Item with previous history entries.
my $biblioitem2 = $builder->build(
    {
        source => 'Biblioitem',
        value  => {
            marcxml => $record2->as_xml(),
            history => encode_json($items),
        }
    }
);

my $expected_history = {
    245 => {
        a => [
            {
                borrowernumber => $patron1->{borrowernumber},
                data           => 'First Title',
                datetime       => '2012-08-12 12:00:10'
            },
            {
                borrowernumber => $patron2->{borrowernumber},
                data           => 'Second Title',
                datetime       => '2012-08-12 12:00:10'
            },
        ],
        c => [
            {
                borrowernumber => $patron1->{borrowernumber},
                data           => 'Some dude',
                datetime       => '2012-08-12 12:00:10'
            },
            {
                borrowernumber => $patron2->{borrowernumber},
                data           => 'Former dude',
                datetime       => '2012-08-12 12:00:10'
            },
        ],
    },
};

my $expected_users = {
    $patron1->{borrowernumber} => undef,
    $patron2->{borrowernumber} => undef,
};

# Tests the decoding and reindexing of the data, without any borrower
# information implanted into the history itself.

my ( $history, $users ) = C4::Biblio::HistoryParse( encode_json($items) );

is_deeply( $history, $expected_history, 'HistoryParse: Output' );
is_deeply( $users,   $expected_users,   'HistoryParse: Users' );

# Tests the extraction of full borrower details based on the borrowernumber.
my $expected_details = {
    $patron1->{borrowernumber} => {
        firstname => $patron1->{firstname},
        surname   => $patron1->{surname},
        title     => $patron1->{title},
    },
    $patron2->{borrowernumber} => {
        firstname => $patron2->{firstname},
        surname   => $patron2->{surname},
        title     => $patron2->{title},
    }
};

my $details = HistoryBorrowerDetails($expected_users);
is_deeply( $details, $expected_details, 'HistoryBorrowerDetails: Output' );

{
    my $expected_mapped_history = {
        245 => {
            a => [
                {
                    borrowernumber => $patron1->{borrowernumber},
                    data           => 'First Title',
                    firstname      => $patron1->{firstname},
                    surname        => $patron1->{surname},
                    title          => $patron1->{title},
                    datetime       => '2012-08-12 12:00:10'
                },
                {
                    borrowernumber => $patron2->{borrowernumber},
                    data           => 'Second Title',
                    firstname      => $patron2->{firstname},
                    surname        => $patron2->{surname},
                    title          => $patron2->{title},
                    datetime       => '2012-08-12 12:00:10'
                },
            ],
            c => [
                {
                    borrowernumber => $patron1->{borrowernumber},
                    data           => 'Some dude',
                    firstname      => $patron1->{firstname},
                    surname        => $patron1->{surname},
                    title          => $patron1->{title},
                    datetime       => '2012-08-12 12:00:10'
                },
                {
                    borrowernumber => $patron2->{borrowernumber},
                    data           => 'Former dude',
                    firstname      => $patron2->{firstname},
                    surname        => $patron2->{surname},
                    title          => $patron2->{title},
                    datetime       => '2012-08-12 12:00:10'
                },
            ]
        }
    };

    $history = C4::Biblio::HistoryMapUsers( $expected_history, $details );

    is_deeply( $history, $expected_mapped_history, 'HistoryMapUsers: Output' );

  #my $record;
  #( $record, $history ) = GetMarcBiblioHistory( $biblioitem2->{biblionumber} );

    #is_deeply( $record, $record2 );
    #is_deeply( $history, $expected_mapped_history );
}

# The C4::Context will provide the expected user borrowernumber.
my $record = HistoryRecordNew($record1);

my $expected_record = {
    borrowernumber => C4::Context->userenv()->{number},
    marcxml        => $record1->as_xml_record(),
    datetime       => POSIX::strftime( '%Y-%m-%d %T', localtime ),
};
is_deeply( $record, $expected_record );

Return to bug 14367

Lines 87-92 use MARC::File::USMARC; Link Here

(-)a/C4/Biblio.pm (-6 / +23 lines)
87	use MARC::File::XML;	87	use MARC::File::XML;
88	use POSIX qw( strftime );	88	use POSIX qw( strftime );
89	use Module::Load::Conditional qw( can_load );	89	use Module::Load::Conditional qw( can_load );
		90	use JSON qw(encode_json decode_json);
90		91
91	use C4::Koha;	92	use C4::Koha;
92	use C4::Log qw( logaction ); # logaction	93	use C4::Log qw( logaction ); # logaction
Lines 114-119 use Koha::SearchEngine; Link Here
114	use Koha::SearchEngine::Indexer;	115	use Koha::SearchEngine::Indexer;
115	use Koha::Libraries;	116	use Koha::Libraries;
116	use Koha::Util::MARC;	117	use Koha::Util::MARC;
		118	use Koha::MetadataRecord::History;
117		119
118	=head1 NAME	120	=head1 NAME
119		121
Lines 289-296 sub AddBiblio { Link Here
289	BiblioAutoLink( $record, $frameworkcode );	291	BiblioAutoLink( $record, $frameworkcode );
290	}	292	}
291		293
292	# now add the record	294	# now add the record (history parameter is undef: no history yet)
293	ModBiblioMarc( $record, $biblionumber ) unless $defer_marc_save;	295	ModBiblioMarc( $record, $biblionumber, undef ) unless $defer_marc_save;
294		296
295	# update OAI-PMH sets	297	# update OAI-PMH sets
296	if(C4::Context->preference("OAI-PMH:AutoUpdateSets")) {	298	if(C4::Context->preference("OAI-PMH:AutoUpdateSets")) {
Lines 370-378 sub ModBiblio { Link Here
370	# update biblionumber and biblioitemnumber in MARC	372	# update biblionumber and biblioitemnumber in MARC
371	# FIXME - this is assuming a 1 to 1 relationship between	373	# FIXME - this is assuming a 1 to 1 relationship between
372	# biblios and biblioitems	374	# biblios and biblioitems
373	my $sth = $dbh->prepare("select biblioitemnumber from biblioitems where biblionumber=?");	375	my $sth = $dbh->prepare("select biblioitems.biblioitemnumber, biblio_metadata.history from biblioitems INNER JOIN biblio_metadata ON biblioitems.biblionumber = biblio_metadata.biblionumber WHERE biblioitems.biblionumber=?");
374	$sth->execute($biblionumber);	376	$sth->execute($biblionumber);
375	my ($biblioitemnumber) = $sth->fetchrow;	377	my ($biblioitemnumber, $history) = $sth->fetchrow;
376	$sth->finish();	378	$sth->finish();
377	_koha_marc_update_bib_ids( $record, $frameworkcode, $biblionumber, $biblioitemnumber );	379	_koha_marc_update_bib_ids( $record, $frameworkcode, $biblionumber, $biblioitemnumber );
378		380
Lines 383-389 sub ModBiblio { Link Here
383	_koha_marc_update_biblioitem_cn_sort( $record, $oldbiblio, $frameworkcode );	385	_koha_marc_update_biblioitem_cn_sort( $record, $oldbiblio, $frameworkcode );
384		386
385	# update the MARC record (that now contains biblio and items) with the new record data	387	# update the MARC record (that now contains biblio and items) with the new record data
386	&ModBiblioMarc( $record, $biblionumber );	388	&ModBiblioMarc( $record, $biblionumber, $history );
387		389
388	# modify the other koha tables	390	# modify the other koha tables
389	_koha_modify_biblio( $dbh, $oldbiblio, $frameworkcode );	391	_koha_modify_biblio( $dbh, $oldbiblio, $frameworkcode );
Lines 2932-2938 Function exported, but should NOT be used, unless you really know what you're do Link Here
2932	sub ModBiblioMarc {	2934	sub ModBiblioMarc {
2933	# pass the MARC::Record to this function, and it will create the records in	2935	# pass the MARC::Record to this function, and it will create the records in
2934	# the marcxml field	2936	# the marcxml field
2935	my ( $record, $biblionumber ) = @_;	2937	my ( $record, $biblionumber, $history ) = @_;
2936	if ( !$record ) {	2938	if ( !$record ) {
2937	carp 'ModBiblioMarc passed an undefined record';	2939	carp 'ModBiblioMarc passed an undefined record';
2938	return;	2940	return;
Lines 3000-3005 sub ModBiblioMarc { Link Here
3000	my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });	3002	my $indexer = Koha::SearchEngine::Indexer->new({ index => $Koha::SearchEngine::BIBLIOS_INDEX });
3001	$indexer->index_records( $biblionumber, "specialUpdate", "biblioserver" );	3003	$indexer->index_records( $biblionumber, "specialUpdate", "biblioserver" );
3002		3004
		3005	# Decode JSON history, create new record, update and re-encode to JSON.
		3006	my $historylength = 10;
		3007	eval {
		3008	$history = decode_json($history);
		3009	1;
		3010	} or do {
		3011	$history = undef;
		3012	};
		3013	my $newrecord = HistoryRecordNew($record);
		3014	my $newhistory = HistoryUpdate($newrecord, $historylength, $history);
		3015	$newhistory = encode_json($newhistory);
		3016
		3017	$m_rs->update({ metadata => $record->as_xml_record($encoding), history => $newhistory });
		3018
		3019	ModZebra( $biblionumber, "specialUpdate", "biblioserver", $record );
3003	return $biblionumber;	3020	return $biblionumber;
3004	}	3021	}
3005		3022

Lines 46-57 use C4::ImportBatch qw( GetImportRecordMarc ); Link Here

(-)a/cataloguing/addbiblio.pl (-19 / +30 lines)
46	use C4::Charset qw( SetMarcUnicodeFlag );	46	use C4::Charset qw( SetMarcUnicodeFlag );
47	use Koha::BiblioFrameworks;	47	use Koha::BiblioFrameworks;
48	use Koha::DateUtils qw( dt_from_string );	48	use Koha::DateUtils qw( dt_from_string );
49		49	use C4::Koha;
50	use Koha::ItemTypes;	50	use Koha::ItemTypes;
		51	use Koha::MetadataRecord::History;
51	use Koha::Libraries;	52	use Koha::Libraries;
52
53	use Koha::BiblioFrameworks;
54
55	use MARC::File::USMARC;	53	use MARC::File::USMARC;
56	use MARC::File::XML;	54	use MARC::File::XML;
57	use URI::Escape qw( uri_escape_utf8 );	55	use URI::Escape qw( uri_escape_utf8 );
Lines 283-292 sub GetMandatoryFieldZ3950 { Link Here
283	=cut	281	=cut
284		282
285	sub create_input {	283	sub create_input {
286	my ( $tag, $subfield, $value, $index_tag, $tabloop, $rec, $authorised_values_sth,$cgi ) = @_;	284
287		285	my ( $tag, $subfield, $value, $index_tag, $tabloop, $rec, $authorised_values_sth,$cgi, $history ) = @_;
		286
288	my $index_subfield = CreateKey(); # create a specifique key for each subfield	287	my $index_subfield = CreateKey(); # create a specifique key for each subfield
289		288
		289	my $taghistory = $history->{$tag}->{$subfield};
		290
		291	$value =~ s/"/"/g;
		292
290	# if there is no value provided but a default value in parameters, get it	293	# if there is no value provided but a default value in parameters, get it
291	if ( $value eq '' ) {	294	if ( $value eq '' ) {
292	$value = $tagslib->{$tag}->{$subfield}->{defaultvalue} // q{};	295	$value = $tagslib->{$tag}->{$subfield}->{defaultvalue} // q{};
Lines 304-310 sub create_input { Link Here
304	# And <<USER>> with surname (?)	307	# And <<USER>> with surname (?)
305	my $username=(C4::Context->userenv?C4::Context->userenv->{'surname'}:"superlibrarian");	308	my $username=(C4::Context->userenv?C4::Context->userenv->{'surname'}:"superlibrarian");
306	$value=~s/<<USER>>/$username/g;	309	$value=~s/<<USER>>/$username/g;
307		310
308	}	311	}
309	my $dbh = C4::Context->dbh;	312	my $dbh = C4::Context->dbh;
310		313
Lines 327-332 sub create_input { Link Here
327	value => $value,	330	value => $value,
328	maxlength => $tagslib->{$tag}->{$subfield}->{maxlength},	331	maxlength => $tagslib->{$tag}->{$subfield}->{maxlength},
329	random => CreateKey(),	332	random => CreateKey(),
		333	history => $taghistory,
330	);	334	);
331		335
332	if(exists $mandatory_z3950->{$tag.$subfield}){	336	if(exists $mandatory_z3950->{$tag.$subfield}){
Lines 385-390 sub create_input { Link Here
385	maxlength => $subfield_data{maxlength},	389	maxlength => $subfield_data{maxlength},
386	readonly => ($is_readonly) ? 1 : 0,	390	readonly => ($is_readonly) ? 1 : 0,
387	authtype => $tagslib->{$tag}->{$subfield}->{authtypecode},	391	authtype => $tagslib->{$tag}->{$subfield}->{authtypecode},
		392	history => $taghistory,
388	};	393	};
389		394
390	# it's a plugin field	395	# it's a plugin field
Lines 407-412 sub create_input { Link Here
407	javascript => $plugin->javascript,	412	javascript => $plugin->javascript,
408	plugin => $plugin->name,	413	plugin => $plugin->name,
409	noclick => $plugin->noclick,	414	noclick => $plugin->noclick,
		415	history => $taghistory,
410	};	416	};
411	} else {	417	} else {
412	warn $plugin->errstr;	418	warn $plugin->errstr;
Lines 419-424 sub create_input { Link Here
419	size => 67,	425	size => 67,
420	maxlength => $subfield_data{maxlength},	426	maxlength => $subfield_data{maxlength},
421	readonly => 0,	427	readonly => 0,
		428	history => $taghistory,
422	};	429	};
423	}	430	}
424		431
Lines 431-436 sub create_input { Link Here
431	value => $value,	438	value => $value,
432	size => 67,	439	size => 67,
433	maxlength => $subfield_data{maxlength},	440	maxlength => $subfield_data{maxlength},
		441	history => $taghistory,
434	};	442	};
435		443
436	}	444	}
Lines 451-456 sub create_input { Link Here
451	id => $subfield_data{id},	459	id => $subfield_data{id},
452	name => $subfield_data{id},	460	name => $subfield_data{id},
453	value => $value,	461	value => $value,
		462	history => $taghistory,
454	};	463	};
455		464
456	}	465	}
Lines 463-468 sub create_input { Link Here
463	size => 67,	472	size => 67,
464	maxlength => $subfield_data{maxlength},	473	maxlength => $subfield_data{maxlength},
465	readonly => 0,	474	readonly => 0,
		475	history => $taghistory,
466	};	476	};
467		477
468	}	478	}
Lines 488-498 sub format_indicator { Link Here
488	}	498	}
489		499
490	sub build_tabs {	500	sub build_tabs {
491	my ( $template, $record, $dbh, $encoding,$input ) = @_;	501	my ( $template, $record, $dbh, $encoding, $input, $history ) = @_;
492		502
493	# fill arrays	503	# fill arrays
494	my @loop_data = ();	504	my @loop_data = ();
495	my $tag;	505	#my $tag;
496		506
497	my $branch_limit = C4::Context->userenv ? C4::Context->userenv->{"branch"} : "";	507	my $branch_limit = C4::Context->userenv ? C4::Context->userenv->{"branch"} : "";
498	my $query = "SELECT authorised_value, lib	508	my $query = "SELECT authorised_value, lib
Lines 548-554 sub build_tabs { Link Here
548	}	558	}
549	# loop through each field	559	# loop through each field
550	foreach my $field (@fields) {	560	foreach my $field (@fields) {
551
552	my @subfields_data;	561	my @subfields_data;
553	if ( $tag < 10 ) {	562	if ( $tag < 10 ) {
554	my ( $value, $subfield );	563	my ( $value, $subfield );
Lines 568-574 sub build_tabs { Link Here
568	@subfields_data,	577	@subfields_data,
569	&create_input(	578	&create_input(
570	$tag, $subfield, $value, $index_tag, $tabloop, $record,	579	$tag, $subfield, $value, $index_tag, $tabloop, $record,
571	$authorised_values_sth,$input	580	$authorised_values_sth,$input, $history
572	)	581	)
573	);	582	);
574	}	583	}
Lines 583-589 sub build_tabs { Link Here
583	@subfields_data,	592	@subfields_data,
584	&create_input(	593	&create_input(
585	$tag, $subfield, $value, $index_tag, $tabloop,	594	$tag, $subfield, $value, $index_tag, $tabloop,
586	$record, $authorised_values_sth,$input	595	$record, $authorised_values_sth,$input, $history
587	)	596	)
588	);	597	);
589	}	598	}
Lines 613-619 sub build_tabs { Link Here
613	@subfields_data,	622	@subfields_data,
614	&create_input(	623	&create_input(
615	$tag, $subfield, '', $index_tag, $tabloop, $record,	624	$tag, $subfield, '', $index_tag, $tabloop, $record,
616	$authorised_values_sth,$input	625	$authorised_values_sth,$input, $history
617	)	626	)
618	);	627	);
619	}	628	}
Lines 669-675 sub build_tabs { Link Here
669	@subfields_data,	678	@subfields_data,
670	&create_input(	679	&create_input(
671	$tag, $subfield->{subfield}, '', $index_tag, $tabloop, $record,	680	$tag, $subfield->{subfield}, '', $index_tag, $tabloop, $record,
672	$authorised_values_sth,$input	681	$authorised_values_sth,$input, $history
673	)	682	)
674	);	683	);
675	}	684	}
Lines 687-693 sub build_tabs { Link Here
687	tagfirstsubfield => $subfields_data[0],	696	tagfirstsubfield => $subfields_data[0],
688	fixedfield => $tag < 10?1:0,	697	fixedfield => $tag < 10?1:0,
689	);	698	);
690		699
691	push @loop_data, \%tag_data ;	700	push @loop_data, \%tag_data ;
692	}	701	}
693	}	702	}
Lines 789-794 $mandatory_z3950 = GetMandatoryFieldZ3950($frameworkcode); Link Here
789	# -- Global	798	# -- Global
790		799
791	my $record = -1;	800	my $record = -1;
		801	my $history = undef;
792	my $encoding = "";	802	my $encoding = "";
793	my (	803	my (
794	$biblionumbertagfield,	804	$biblionumbertagfield,
Lines 799-805 my ( Link Here
799	);	809	);
800		810
801	if (($biblionumber) && !($breedingid)){	811	if (($biblionumber) && !($breedingid)){
802	$record = GetMarcBiblio({ biblionumber => $biblionumber });	812	($record, $history) = GetMarcBiblioHistory($biblionumber);
803	}	813	}
804	if ($breedingid) {	814	if ($breedingid) {
805	( $record, $encoding ) = MARCfindbreeding( $breedingid ) ;	815	( $record, $encoding ) = MARCfindbreeding( $breedingid ) ;
Lines 869-875 if ( $op eq "addbiblio" ) { Link Here
869	else {	879	else {
870	( $biblionumber, $oldbibitemnum ) = AddBiblio( $record, $frameworkcode );	880	( $biblionumber, $oldbibitemnum ) = AddBiblio( $record, $frameworkcode );
871	}	881	}
872	if ($redirect eq "items" \|\| ($mode ne "popup" && !$is_a_modif && $redirect ne "view" && $redirect ne "just_save")){	882	if ($redirect eq "items" \|\| (defined $mode && $mode ne "popup" && !$is_a_modif && $redirect ne "view" && $redirect ne "just_save")){
873	if ($frameworkcode eq 'FA'){	883	if ($frameworkcode eq 'FA'){
874	print $input->redirect(	884	print $input->redirect(
875	'/cgi-bin/koha/cataloguing/additem.pl?'	885	'/cgi-bin/koha/cataloguing/additem.pl?'
Lines 928-934 if ( $op eq "addbiblio" ) { Link Here
928	}	938	}
929	} else {	939	} else {
930	# it may be a duplicate, warn the user and do nothing	940	# it may be a duplicate, warn the user and do nothing
931	build_tabs ($template, $record, $dbh,$encoding,$input);	941	build_tabs ($template, $record, $dbh,$encoding, $input, $history);
932	$template->param(	942	$template->param(
933	biblionumber => $biblionumber,	943	biblionumber => $biblionumber,
934	biblioitemnumber => $biblioitemnumber,	944	biblioitemnumber => $biblioitemnumber,
Lines 975-981 elsif ( $op eq "delete" ) { Link Here
975	$record = $urecord;	985	$record = $urecord;
976	};	986	};
977	}	987	}
978	build_tabs( $template, $record, $dbh, $encoding,$input );	988
		989	build_tabs( $template, $record, $dbh, $encoding, $input, $history );
979	$template->param(	990	$template->param(
980	biblionumber => $biblionumber,	991	biblionumber => $biblionumber,
981	biblionumbertagfield => $biblionumbertagfield,	992	biblionumbertagfield => $biblionumbertagfield,

Line 0 Link Here

(-)a/Koha/MetadataRecord/History.pm (+261 lines)
		1	package Koha::MetadataRecord::History;
		2
		3	# Copyright 2016 Aleisha Amohia <aleisha@catalyst.net.nz>
		4	#
		5	# This file is part of Koha.
		6	#
		7	# Koha is free software; you can redistribute it and/or modify it
		8	# under the terms of the GNU General Public License as published by
		9	# the Free Software Foundation; either version 3 of the License, or
		10	# (at your option) any later version.
		11	#
		12	# Koha is distributed in the hope that it will be useful, but
		13	# WITHOUT ANY WARRANTY; without even the implied warranty of
		14	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	# GNU General Public License for more details.
		16	#
		17	# You should have received a copy of the GNU General Public License
		18	# along with Koha; if not, see <http://www.gnu.org/licenses>.
		19
		20	use strict;
		21	use warnings;
		22
		23	use C4::Charset qw( StripNonXmlChars );
		24	use JSON qw(decode_json);
		25
		26	use vars qw(@ISA @EXPORT);
		27
		28	BEGIN {
		29	require Exporter;
		30	@ISA = qw( Exporter );
		31
		32	push @EXPORT, qw(
		33	&GetMarcBiblioHistory
		34	&HistoryUpdate
		35	&HistoryParse
		36	&HistoryMapUsers
		37	&HistoryBorrowerDetails
		38	&HistoryRecordNew
		39	);
		40	}
		41
		42	=head1 NAME
		43
		44	Koha::MetadataRecord::History - tracking changes to MARC records
		45
		46	=head1 DESCRIPTION
		47
		48	Koha::MetadataRecord::History not only tracks changes to MARC records and presents them in a log, but also allows users to
		49	roll them back, either in batch to a previous point in the history or separately for each field (so you can roll back changes
		50	to a field without changing fields that may have been changed after this one).
		51
		52	=head2 GetMarcBiblioHistory
		53
		54	my ($record, $history) = GetMarcBiblio($biblionumber, [$embeditems]);
		55
		56	Returns MARC::Record representing bib identified by C<$biblionumber>. If no bib exists, returns undef.
		57	C<$biblionumber>. If no bib exists, returns undef.
		58	C<$embeditems>. If set to true, items data are included.
		59	The MARC record contains biblio data, and items data if $embeditems is set to true.
		60
		61	=cut
		62
		63	sub GetMarcBiblioHistory {
		64	my $biblionumber = shift;
65	my $embeditems = shift \|\| 0;
66	if (not defined $biblionumber) {
67	warn "GetMarcBiblio called with undefined biblionumber";
68	return;
69	}
70	my $dbh = C4::Context->dbh;
71	my $sth = $dbh->prepare("SELECT metadata,history FROM biblio_metadata WHERE biblionumber=? ");
72	$sth->execute($biblionumber);
73	my $row = $sth->fetchrow_hashref;
74	my $marcxml = StripNonXmlChars( $row->{'metadata'} );
75	MARC::File::XML->default_record_format( C4::Context->preference('marcflavour') );
76	my $record = MARC::Record->new();
77	my ($history, $borrowers) = HistoryParse( $row->{'history'} );
78	$borrowers = HistoryBorrowerDetails( $borrowers );
79	$history = HistoryMapUsers( $history, $borrowers );
80	if ($marcxml) {
81	$record = eval { MARC::Record::new_from_xml( $marcxml, "utf8", C4::Context->preference('marcflavour') ) };
82	if ($@) { warn " problem with :$biblionumber : $@ \n$marcxml"; }
83	return unless $record;
84	C4::Biblio::_koha_marc_update_bib_ids($record, '', $biblionumber, $biblionumber);
85	C4::Biblio::EmbedItemsInMarcBiblio($record, $biblionumber) if ($embeditems);
86	return ($record, $history);
87	} else {
88	return;
89	}
90	}
91
92	=head2 HistoryParse
93
94	Input format (JSON): [ { datetime, borrowernumber, marcxml } ]
95	Output format: { tag } { subfield } [ { borrowernumber, data, datetime } ]
96
97	=cut
98
99	sub HistoryParse {
100	my $json = shift;
101	if (!defined $json) {
102	warn "HistoryParse: Missing JSON parameter";
103	return;
104	}
105	my $input = decode_json($json);
106	# Reindex the dataset; order all values by datetime under each tag name.
107	my $borrowers = { };
108	my $output = { };
109	for my $item (@{$input}) {
110	my $datetime = $item->{datetime};
111	$borrowers->{ $item->{borrowernumber }} = undef;
112	my $record = MARC::File::XML::decode($item->{marcxml});
113	for my $field ($record->fields()) {
114	my $tag = $field->tag();
115	$output->{$tag} = {} unless defined $output->{$tag};
116	for my $subfield ($field->subfields()) {
117	# Build hash ref structure.
118	my $subfield_tag = @{$subfield}[0];
119	$output->{$tag}->{$subfield_tag} = []
120	unless defined $output->{$tag}->{$subfield_tag};
121	push( @{ $output->{$tag}->{$subfield_tag} }, HistoryParsedRecordNew(
122	@{ $subfield }[1], $item->{borrowernumber}, $datetime));
123	}
124	}
125	}
126	return ( $output, $borrowers );
127	}
128
129	=head2 HistoryBorrowerDetails
130
131	Take a hashref with borrowernumbers as keys, returns new hash with the
132	borrowernumber as key to hash containing firstname, surname and title.
133
134	=cut
135
136	sub HistoryBorrowerDetails {
137	my $borrowernumbers = shift;
138	my $dbh = C4::Context->dbh;
139	my $output = { };
140	my @numbers = keys %{$borrowernumbers};
141	if (@numbers > 0) {
142	# We now need to look up the numeric user id's and map to name and title strings.
143	my $sth = $dbh->prepare(qq{SELECT
144	borrowernumber, title, firstname, surname
145	FROM borrowers
146	WHERE borrowernumber IN}
147	. '(' . join(',', ('?') x @numbers) . ')');
148	$sth->execute(@numbers)
149	or die ('BorrowerDetails: Unable to execute SELECT statement');
150	while (my $row = $sth->fetchrow_hashref()) {
151	$output->{ $row->{borrowernumber} } = { };
152	$output->{ $row->{borrowernumber} }->{title} = $row->{title};
153	$output->{ $row->{borrowernumber} }->{firstname} = $row->{firstname};
154	$output->{ $row->{borrowernumber} }->{surname} = $row->{surname};
155	}
156	$sth->finish();
157	}
158	return $output;
159	}
160
161	=head2 HistoryMapUsers
162
163	=cut
164
165	sub HistoryMapUsers {
166	my ($history, $borrowers) = @_;
167	my $mappedhistory = { };
168	for my $tag (keys %{ $history }) {
169	$mappedhistory->{ $tag } = { };
170	for my $field (keys %{ $history->{ $tag } }) {
171	$mappedhistory->{ $tag }->{ $field } = [ ];
172	for my $entry (@{ $history->{ $tag }->{ $field } }) {
173	# C4::Dates does not allow me to print time, only dates.
174	#my $newtime = C4::Dates->new( $history->{ $tag }->{ $field }->{ $time }->{timestamp}, 'iso' )->output('syspref');
175	my $newitem = { };
176	my $user = $borrowers->{ $entry->{borrowernumber} };
177
178	# Maybe change this to work on original instead of copy?
179	$newitem->{title} = $user->{title};
180	$newitem->{firstname} = $user->{firstname};
181	$newitem->{surname} = $user->{surname};
182	$newitem->{borrowernumber} = $entry->{borrowernumber};
183	$newitem->{data} = $entry->{data};
184	$newitem->{datetime} = $entry->{datetime};
185
186	push ( @{ $mappedhistory->{ $tag }->{ $field } } , $newitem);
187	}
188	}
189	}
190	return $mappedhistory;
191	}
192
193	=head2 HistoryParsedRecordNew
194
195	=cut
196
197	sub HistoryParsedRecordNew {
198	my ($value, $borrowernumber, $datetime) = @_;
199	my $newrecord = {
200	data => $value,
201	borrowernumber => $borrowernumber,
202	datetime => $datetime,
203	};
204	return $newrecord;
205	}
206
207	=head2 HistoryRecordNew
208
209	=cut
210
211	sub HistoryRecordNew {
212	my ( $record ) = @_;
213	my $encoding = C4::Context->preference("marcflavour");
214	my $hash_record = {
215	borrowernumber => C4::Context->userenv()->{number},
216	datetime => POSIX::strftime('%Y-%m-%d %T', localtime(time)),
217	marcxml => $record->as_xml_record($encoding),
218	};
219	return $hash_record;
220	}
221
222	=head2 HistoryUpdate
223
224	=cut
225
226	sub HistoryUpdate {
227	my ( $record, $limit, $collection ) = @_;
228	if ( !$record ) {
229	warn "HistoryUpdate: Called with undefined record";
230	return;
231	}
232	if ( ref($record) ne 'HASH' ) {
233	warn "HistoryUpdate: Record parameter is not a hashref";
234	return;
235	}
236	$limit = 10 unless defined $limit;
237	# We need something to append history to, even if there is none.
238	$collection = [] unless defined $collection;
239	# Truncate history to $histsize - 1, need space for new entry.
240	splice(@{$collection}, $limit - 1);
241	push(@{$collection}, $record);
242	# Sort the resulting array, newest entries first.
243	# Removed; used to be integer timestamps. Is now MySQL date strings.
244	#@{$collection} = sort { $a->{timestamp} < $b->{timestamp} } @{$collection};
245	@{$collection} = sort { $a->{datetime} lt $b->{datetime} } @{$collection};
246	return $collection;
247	}
248
249	1;
250
251	__END__
252
253	=head1 AUTHOR
254
255	Koha Development Team <http://koha-community.org/>
256
257	Paul POULAIN paul.poulain@free.fr
258
259	Joshua Ferraro jmf@liblime.com
260
261	=cut

Lines 1-6 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/cataloguing/addbiblio.tt (-3 / +52 lines)
1	[% USE raw %]	1	[% USE raw %]
2	[% USE Asset %]	2	[% USE Asset %]
3	[% USE Koha %]	3	[% USE Koha %]
		4	[% USE KohaDates %]
4	[% INCLUDE 'doc-head-open.inc' %]	5	[% INCLUDE 'doc-head-open.inc' %]
5	<title>[% IF ( biblionumber ) %]Editing [% title \| html %] (Record number [% biblionumber \| html %])[% ELSE %]Add MARC record[% END %] &rsaquo; Cataloging &rsaquo; Koha</title>	6	<title>[% IF ( biblionumber ) %]Editing [% title \| html %] (Record number [% biblionumber \| html %])[% ELSE %]Add MARC record[% END %] &rsaquo; Cataloging &rsaquo; Koha</title>
6	[% INCLUDE 'doc-head-close.inc' %]	7	[% INCLUDE 'doc-head-close.inc' %]
Lines 26-31 Link Here
26	var Sticky;	27	var Sticky;
27	$(document).ready(function() {	28	$(document).ready(function() {
28		29
		30	$(".input_marceditor").click(function(){
		31	var tag = $(this).attr('id');
		32	historyToggle(tag + '_history');
		33	return false;
		34	});
		35
		36	$(".tag_editor").click(function(){
		37	var tag = $(this).attr('id');
		38	openAuth(this.parentNode.parentNode.getElementsByTagName('input')[1].id, tag, 'biblio');
		39	return false;
		40	});
		41
		42	$(".buttonHistory").click(function(){
		43	var tag = $(this).attr('id');
		44	HistoryToggle(tag + '_history');
		45	return false;
		46	});
		47
		48	$(".hist_rollback").click(function(){
		49	var tag = $(this).attr('data-tag');
		50	var value = $(this).attr('data-history');
		51	HistoryRollback(tag, value);
		52	return false;
		53	});
		54
29	[% IF bib_doesnt_exist %]	55	[% IF bib_doesnt_exist %]
30	$("#addbibliotabs").hide();	56	$("#addbibliotabs").hide();
31	$("#toolbar").hide();	57	$("#toolbar").hide();
Lines 1096-1111 function PopupMARCFieldDoc(field) { Link Here
1096	<div class="subfield_controls">	1122	<div class="subfield_controls">
1097	[% IF ( mv.type == 'text' ) %]	1123	[% IF ( mv.type == 'text' ) %]
1098	[% IF ( mv.authtype ) %]	1124	[% IF ( mv.authtype ) %]
1099	<a href="#" class="buttonDot tag_editor" onclick="openAuth(this.parentNode.parentNode.getElementsByTagName('input')[1].id,'[%- mv.authtype \| html -%]','biblio'); return false;" tabindex="1" title="Tag editor">Tag editor</a>	1125	<a id="[%- mv.authtype \| html %]" href="#" class="buttonDot tag_editor" onclick="openAuth(this.parentNode.parentNode.getElementsByTagName('input')[1].id,'[%- mv.authtype \| html -%]','biblio'); return false;" tabindex="1" title="Tag editor">Tag editor</a>
1100	[% END %]	1126	[% END %]
1101	[% ELSIF ( mv.type == 'text_complex' ) %]	1127	[% ELSIF ( mv.type == 'text_complex' ) %]
1102	[% IF mv.noclick %]	1128	[% IF mv.noclick %]
1103	<span class="buttonDot tag_editor disabled" tabindex="-1" title="Field autofilled by plugin"></span>	1129	<span class="buttonDot tag_editor disabled" tabindex="-1" title="Field autofilled by plugin"></span>
1104	[% ELSE %]	1130	[% ELSE %]
1105	[% IF mv.plugin == "upload.pl" %]	1131	[% IF mv.plugin == "upload.pl" %]
1106	<a href="#" id="buttonDot_[% mv.id \| html %]" class="tag_editor upload framework_plugin" tabindex="1"><i class="fa fa-upload" aria-hidden="true"></i> Upload</a>	1132	<a href="#" id="buttonDot_[% mv.id \| html %]" class="buttonDot tag_editor upload framework_plugin" tabindex="2"><i class="fa fa-upload" aria-hidden="true"></i> Upload</a>
1107	[% ELSE %]	1133	[% ELSE %]
1108	<a href="#" id="buttonDot_[% mv.id \| html %]" class="buttonDot tag_editor framework_plugin" tabindex="1" title="Tag editor">Tag editor</a>	1134	<a href="#" id="buttonDot_[% mv.id \| html %]" class="buttonDot tag_editor framework_plugin" tabindex="2" title="Tag editor">Tag editor</a>
1109	[% END %]	1135	[% END %]
1110	[% END %]	1136	[% END %]
1111	</span>	1137	</span>
Lines 1119-1124 function PopupMARCFieldDoc(field) { Link Here
1119	</a>	1145	</a>
1120	[% END %]	1146	[% END %]
1121	</div>	1147	</div>
		1148
		1149	[% IF ( subfield_loo.history ) %]
		1150	<span class="subfield_history">
		1151	<a href="#" class="buttonHistory" id="[%- mv.id \| html -%]">
		1152	<img src="[% interface \| html %]/[% theme \| html %]/img/icon-history.png" alt="History" title="Display history for this field" />
		1153	</a>
		1154	</span>
		1155
		1156	<table class="history_table" id="[%- mv.id \| html -%]_history" name="[%- mv.name \| html -%]_history">
		1157	<tr>
		1158	<th>Value</th>
		1159	<th>Date</th>
		1160	<th>User</th>
		1161	</tr>
		1162	[% FOREACH hist IN subfield_loo.history %]
		1163	<tr>
		1164	<td><a href="#" data-tag='[%- mv.id \| html -%]' data-history='[% hist.data \| html %]' class='hist_rollback'>[% hist.data \| html %]</a></td>
		1165	<td>[% hist.datetime \| $KohaDates with_hours = 1 %]</td>
		1166	<td>[% hist.title \| html %] [% hist.firstname \| html %] [% hist.surname \| html %]</td>
		1167	</tr>
		1168	[% END %]
		1169	</table>
		1170	[% END %]
1122	</li> <!-- /.subfield_line -->	1171	</li> <!-- /.subfield_line -->
1123	<!-- End of the line -->	1172	<!-- End of the line -->
1124	[% END # /FOREACH subfield_loop %]	1173	[% END # /FOREACH subfield_loop %]

Lines 58-63 function openAuth(tagsubfieldid,authtype,source) { Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/js/cataloging.js (+10 lines)
58	window.open("../authorities/auth_finder.pl?source="+source+"&authtypecode="+authtype+"&index="+tagsubfieldid+"&value_mainstr="+encodeURIComponent(mainmainstring)+"&value_main="+encodeURIComponent(mainstring), "_blank",'width=700,height=550,toolbar=false,scrollbars=yes');	58	window.open("../authorities/auth_finder.pl?source="+source+"&authtypecode="+authtype+"&index="+tagsubfieldid+"&value_mainstr="+encodeURIComponent(mainmainstring)+"&value_main="+encodeURIComponent(mainstring), "_blank",'width=700,height=550,toolbar=false,scrollbars=yes');
59	}	59	}
60		60
		61	function HistoryToggle (tagid)
		62	{
		63	$('#' + tagid).toggle();
		64	}
		65
		66	function HistoryRollback (tagid, value)
		67	{
		68	$('#' + tagid).val(value);
		69	}
		70
61	function ExpandField(index) {	71	function ExpandField(index) {
62	var original = document.getElementById(index); //original <li>	72	var original = document.getElementById(index); //original <li>
63	var lis = original.getElementsByTagName('li');	73	var lis = original.getElementsByTagName('li');

Line 0 Link Here

(-)a/t/db_dependent/BiblioHistory.t (-1 / +256 lines)
0	-	1	#!/usr/bin/perl
		2
		3	use Modern::Perl;
		4	use t::lib::TestBuilder;
		5	use t::lib::Mocks;
		6	use Test::More tests => 6;
		7	use POSIX qw(strftime);
		8
		9	use MARC::Record;
		10	use MARC::Field;
		11	use JSON qw(encode_json);
		12
		13	use Koha::MetadataRecord::History;
		14
		15	BEGIN {
		16	use_ok('C4::Biblio');
		17	}
		18
		19	our $dbh = C4::Context->dbh;
		20	$dbh->{AutoCommit} = 0;
		21	$dbh->{RaiseError} = 0;
		22
		23	$dbh->do(q\|DELETE FROM issues\|);
		24	$dbh->do(q\|DELETE FROM items\|);
		25	$dbh->do(q\|DELETE FROM borrowers\|);
		26	$dbh->do(q\|DELETE FROM branches\|);
		27	$dbh->do(q\|DELETE FROM categories\|);
		28	$dbh->do(q\|DELETE FROM biblioitems\|);
		29
		30	my $builder = t::lib::TestBuilder->new();
		31
		32	my $branch = $builder->build(
		33	{
		34	source => 'Branch',
		35	}
		36	);
		37
		38	my $category = $builder->build(
		39	{
		40	source => 'Category',
		41	}
		42	);
		43
		44	my $patron1 = $builder->build(
		45	{
		46	source => 'Borrower',
		47	value => {
		48	title => 'Mr/Mrs',
		49	firstname => 'First name',
		50	surname => 'Surname',
		51	categorycode => $category->{categorycode},
		52	branchcode => $branch->{branchcode},
		53	},
		54	}
		55	);
		56
		57	my $patron2 = $builder->build(
		58	{
		59	source => 'Borrower',
		60	value => {
		61	title => 'Mr/Mrs 2',
		62	firstname => 'First name 2',
		63	surname => 'Surname 2',
		64	categorycode => $category->{categorycode},
		65	branchcode => $branch->{branchcode},
66	},
67	}
68	);
69
70	my $biblio = $builder->build(
71	{
72	source => 'Biblio',
73	value => {
74	branchcode => $branch->{branchcode},
75	},
76	}
77	);
78
79	C4::Context->_new_userenv('DUMMY_SESSION_ID');
80	C4::Context->set_userenv( $patron1->{borrowernumber},
81	$patron1->{userid}, 'usercnum', $patron1->{firstname}, $patron1->{surname},
82	$branch->{branchcode}, 'My library', 0 );
83
84	# Item with no pre-existing history backlog.
85	my $record1 = MARC::Record->new();
86	my $field1 = MARC::Field->new(
87	245, '1', '0',
88	'a' => 'First Title',
89	'c' => 'Some dude'
90	);
91	$record1->append_fields($field1);
92
93	my $record2 = MARC::Record->new();
94	my $field2 = MARC::Field->new(
95	245, '1', '0',
96	'a' => 'Second Title',
97	'c' => 'Former dude'
98	);
99	$record2->append_fields($field2);
100
101	my $biblioitem1 = $builder->build(
102	{
103	source => 'Biblioitem',
104	value => {
105	marcxml => $record1->as_xml(),
106	history => undef,
107	}
108	}
109	);
110
111	# items{tagname}{subfield}{timestamp}{borrowernumber\|timestamp\|marcxml}
112	my $items = [
113	{
114	borrowernumber => $patron1->{borrowernumber},
115	datetime => '2012-08-12 12:00:10',
116	marcxml => $record1->as_xml(),
117	},
118	{
119	borrowernumber => $patron2->{borrowernumber},
120	datetime => '2012-08-12 12:00:10',
121	marcxml => $record2->as_xml(),
122	}
123	];
124
125	# Item with previous history entries.
126	my $biblioitem2 = $builder->build(
127	{
128	source => 'Biblioitem',
129	value => {
130	marcxml => $record2->as_xml(),
131	history => encode_json($items),
132	}
133	}
134	);
135
136	my $expected_history = {
137	245 => {
138	a => [
139	{
140	borrowernumber => $patron1->{borrowernumber},
141	data => 'First Title',
142	datetime => '2012-08-12 12:00:10'
143	},
144	{
145	borrowernumber => $patron2->{borrowernumber},
146	data => 'Second Title',
147	datetime => '2012-08-12 12:00:10'
148	},
149	],
150	c => [
151	{
152	borrowernumber => $patron1->{borrowernumber},
153	data => 'Some dude',
154	datetime => '2012-08-12 12:00:10'
155	},
156	{
157	borrowernumber => $patron2->{borrowernumber},
158	data => 'Former dude',
159	datetime => '2012-08-12 12:00:10'
160	},
161	],
162	},
163	};
164
165	my $expected_users = {
166	$patron1->{borrowernumber} => undef,
167	$patron2->{borrowernumber} => undef,
168	};
169
170	# Tests the decoding and reindexing of the data, without any borrower
171	# information implanted into the history itself.
172
173	my ( $history, $users ) = C4::Biblio::HistoryParse( encode_json($items) );
174
175	is_deeply( $history, $expected_history, 'HistoryParse: Output' );
176	is_deeply( $users, $expected_users, 'HistoryParse: Users' );
177
178	# Tests the extraction of full borrower details based on the borrowernumber.
179	my $expected_details = {
180	$patron1->{borrowernumber} => {
181	firstname => $patron1->{firstname},
182	surname => $patron1->{surname},
183	title => $patron1->{title},
184	},
185	$patron2->{borrowernumber} => {
186	firstname => $patron2->{firstname},
187	surname => $patron2->{surname},
188	title => $patron2->{title},
189	}
190	};
191
192	my $details = HistoryBorrowerDetails($expected_users);
193	is_deeply( $details, $expected_details, 'HistoryBorrowerDetails: Output' );
194
195	{
196	my $expected_mapped_history = {
197	245 => {
198	a => [
199	{
200	borrowernumber => $patron1->{borrowernumber},
201	data => 'First Title',
202	firstname => $patron1->{firstname},
203	surname => $patron1->{surname},
204	title => $patron1->{title},
205	datetime => '2012-08-12 12:00:10'
206	},
207	{
208	borrowernumber => $patron2->{borrowernumber},
209	data => 'Second Title',
210	firstname => $patron2->{firstname},
211	surname => $patron2->{surname},
212	title => $patron2->{title},
213	datetime => '2012-08-12 12:00:10'
214	},
215	],
216	c => [
217	{
218	borrowernumber => $patron1->{borrowernumber},
219	data => 'Some dude',
220	firstname => $patron1->{firstname},
221	surname => $patron1->{surname},
222	title => $patron1->{title},
223	datetime => '2012-08-12 12:00:10'
224	},
225	{
226	borrowernumber => $patron2->{borrowernumber},
227	data => 'Former dude',
228	firstname => $patron2->{firstname},
229	surname => $patron2->{surname},
230	title => $patron2->{title},
231	datetime => '2012-08-12 12:00:10'
232	},
233	]
234	}
235	};
236
237	$history = C4::Biblio::HistoryMapUsers( $expected_history, $details );
238
239	is_deeply( $history, $expected_mapped_history, 'HistoryMapUsers: Output' );
240
241	#my $record;
242	#( $record, $history ) = GetMarcBiblioHistory( $biblioitem2->{biblionumber} );
243
244	#is_deeply( $record, $record2 );
245	#is_deeply( $history, $expected_mapped_history );
246	}
247
248	# The C4::Context will provide the expected user borrowernumber.
249	my $record = HistoryRecordNew($record1);
250
251	my $expected_record = {
252	borrowernumber => C4::Context->userenv()->{number},
253	marcxml => $record1->as_xml_record(),
254	datetime => POSIX::strftime( '%Y-%m-%d %T', localtime ),
255	};
256	is_deeply( $record, $expected_record );