$hash{IllLog}          = C4::Context->preference("IllLog");

use Koha::Illrequest::Logger;

=head3 logs

=cut

sub logs {

    my ( $self ) = @_;

    my $logger = Koha::Illrequest::Logger->new;

    return $logger->get_request_logs($self);

}

=head3 status

    $Illrequest->status('CANREQ');

Overloaded I<status> method that, in addition to setting the request status

records the fact that the status has changed

=cut

sub status {

    my ( $self, $new_status ) = @_;

    my $current_status = $self->SUPER::status;

    if ($new_status) {

        # Keep a record of the previous status before we change it,

        # we might need it

        $self->{previous_status} = $current_status;

        my $ret = $self->SUPER::status($new_status)->store;

        if ($ret) {

            my $logger = Koha::Illrequest::Logger->new;

            $logger->log_status_change(

                $self,

                $new_status

            );

        } else {

            delete $self->{previous_status};

        }

        return $ret;

    } else {

        return $current_status;

    }

}

=head3 store

    $Illrequest->store;

Overloaded I<store> method that, in addition to performing the 'store',

possibly records the fact that something happened

=cut

sub store {

    my ( $self, $attrs ) = @_;

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

    $attrs->{log_origin} = 'core';

    if ($ret && defined $attrs) {

        my $logger = Koha::Illrequest::Logger->new;

        $logger->log_maybe($self, $attrs);

    }

    return $ret;

}

package Koha::Illrequest::Logger;

# Copyright 2018 PTFS Europe Ltd

#

# 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, write to the Free Software Foundation, Inc.,

# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

use Modern::Perl;

use JSON qw( to_json from_json );

use C4::Context;

use C4::Templates;

use C4::Log qw( logaction GetLogs );

=head1 NAME

Koha::Illrequest::Logger - Koha ILL Action / Event logger

=head1 SYNOPSIS

Object-oriented class that provides event logging functionality for

ILL requests

=head1 DESCRIPTION

This class provides the ability to log arbitrary actions or events

relating to Illrequest to the action log.

=head1 API

=head2 Class Methods

=head3 new

    my $config = Koha::Illrequest::Logger->new();

Create a new Koha::Illrequest::Logger object, with skeleton logging data

We also set up data of what can be logged, how to do it and how to display

log entries we get back out

=cut

sub new {

    my ( $class ) = @_;

    my $self  = {};

    $self->{data} = {

        modulename => 'ILL'

    };

    $self->{loggers} = {

        status => sub {

            $self->log_status_change(@_);

        }

    };

    my ( $htdocs, $theme, $lang, $base ) =

        C4::Templates::_get_template_file('ill/log/', 'intranet');

    $self->{templates} = {

        STATUS_CHANGE => $base . 'status_change.tt'

    };

    bless $self, $class;

    return $self;

}

=head3 log_maybe

    Koha::IllRequest::Logger->log_maybe($attrs);

Receive request object and an attributes hashref (which may or may

not be defined) If the hashref contains a key matching our "loggers" hashref

then we want to log it

=cut

sub log_maybe {

    my ($self, $req, $attrs) = @_;

    if (defined $req && defined $attrs) {

        foreach my $key (keys %{ $attrs }) {

            if (defined($self->{loggers}->{$key})) {

                $self->{loggers}->{$key}($req, $attrs->{$key});

            }

        }

    }

}

=head3 log_status_change

    Koha::IllRequest::Logger->log_status_change();

Log a request's status change

=cut

sub log_status_change {

    my ( $self, $req, $new_status ) = @_;

    $self->set_data({

        actionname   => 'STATUS_CHANGE',

        objectnumber => $req->id,

        infos        => to_json({

            log_origin    => 'core',

            status_before => $req->{previous_status},

            status_after  => $new_status

        })

    });

    $self->log_something();

}

=head3 log_something

    Koha::IllRequest::Logger->log_something();

If we have the required data set, log an action

=cut

sub log_something {

    my ( $self ) = @_;

    if (

        defined $self->{data}->{modulename} &&

        defined $self->{data}->{actionname} &&

        defined $self->{data}->{objectnumber} &&

        defined $self->{data}->{infos} &&

        C4::Context->preference("IllLog")

    ) {

        logaction(

            $self->{data}->{modulename},

            $self->{data}->{actionname},

            $self->{data}->{objectnumber},

            $self->{data}->{infos}

        );

    }

}

=head3 set_data

    Koha::IllRequest::Logger->set_data({

        key  => 'value',

        key2 => 'value2'

    });

Set arbitrary data propert(ies) on the logger object

=cut

sub set_data {

    my ( $self, $data ) = @_;

    foreach my $key (keys %{ $data }) {

        $self->{data}->{$key} = $data->{$key};

    }

}

=head3 get_log_template

    $template_path = get_log_template($origin, $action);

Given a log's origin and action, get the appropriate display template

=cut

sub get_log_template {

    my ($self, $req, $params) = @_;

    my $origin = $params->{origin};

    my $action = $params->{action};

    if ($origin eq 'core') {

        # It's a core log, so we can just get the template path from

        # the hashref above

        return $self->{templates}->{$action};

    } else {

        # It's probably a backend log, so we need to get the path to the

        # template from the backend

        my $backend =$req->{_my_backend};

        return $backend->get_log_template_path($action);

    }

}

=head3 get_request_logs

    $requestlogs = Koha::IllRequest::Logger->get_request_logs($request_id);

Get all logged actions for a given request

=cut

sub get_request_logs {

    my ( $self, $request ) = @_;

    my $logs = GetLogs(

        undef,

        undef,

        undef,

        ['ILL'],

        undef,

        $request->id,

        undef,

        undef

    );

    foreach my $log(@{$logs}) {

        $log->{info} = from_json($log->{info});

        $log->{template} = $self->get_log_template(

        $request,

            {

                origin => $log->{info}->{log_origin},

                action => $log->{action}

            }

        );

    }

    my @sorted = sort {$$b{'timestamp'} <=> $$a{'timestamp'}} @{$logs};

    return \@sorted;

}

=head1 AUTHOR

Andrew Isherwood <andrew.isherwood@ptfs-europe.com>

=cut

1;

$DBversion = 'XXX';  # will be replaced by the RM

if( CheckVersion( $DBversion ) ) {

    $dbh->do( "INSERT IGNORE INTO systempreferences (variable, value, explanation, type) VALUES ('IllLog', 1, 'If ON, log information about ILL requests', 'YesNo')" );

    SetVersion( $DBversion );

    print "Upgrade to $DBversion done (Bug 20750 - Allow timestamped auditing of ILL request events)\n";

}

INSERT IGNORE INTO systempreferences (variable, value, explanation, type) VALUES ('IllLog', 1, 'If ON, log information about ILL requests', 'YesNo');

System preference to determine if logging of ILL requests should occur

('IllLog', 1, '', 'If ON, log information about ILL requests', 'YesNo'),

            - pref: IllLog

              choices:

                  on: Log

                  off: "Don't log"

            - when changes to ILL requests take place

        -

        // Display the modal containing request supplier metadata

        $('#ill-request-display-log').on('click', function(e) {

            e.preventDefault();

            $('#requestLog').modal({show:true});

        });

                        <a title="Display request log" id="ill-request-display-log" class="btn btn-sm btn-default pull-right" href="#">

                            <span class="fa fa-calendar"></span>

                            Display request log

                        </a>

                    <div id="requestLog" class="modal fade" tabindex="-1" role="dialog" aria-labelledby="dataPreviewLabel" aria-hidden="true">

                        <div class="modal-dialog">

                            <div class="modal-content">

                                <div class="modal-header">

                                    <button type="button" class="closebtn" data-dismiss="modal" aria-hidden="true">×</button>

                                    <h3 id="requestLogLabel"> Request log</h3>

                                </div>

                                <div class="modal-body">

                                [% IF request.logs.size > 0 %]

                                    [% FOREACH log IN request.logs %]

                                        [% tpl = log.template %]

                                        [% INCLUDE $tpl %]

                                    [% END %]

                                [% ELSE %]

                                    There are no recorded logs for this request

                                [% END %]

                                </div>

                                <div class="modal-footer">

                                    <button class="btn btn-default" data-dismiss="modal" aria-hidden="true">Close</button>

                                </div>

                            </div>

                        </div>

                    </div>

<p>

[% log.timestamp | $KohaDates with_hours => 1 %] : <b>Status changed </b>

[% IF log.info.status_before %]

from "[% request.capabilities(log.info.status_before).name %]"

[% END %]

to "[% request.capabilities(log.info.status_after).name %]"

</p>

[%        CASE 'ILL'          %]Interlibrary loans

[%        CASE 'STATUS_CHANGE'  %]Change ILL request status

[%        CASE 'BLDSS_STATUS_CHECK'  %]Check ILL request status with BLDSS

t::lib::Mocks::mock_preference('IllLog', 1);