Attachment #133400 for bug #30484

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





=head2 Class methods

=head3 init_processors

    $request->init_processors()

Initialises an empty processors arrayref

=cut

sub init_processors {
    my ( $self ) = @_;

    $self->{processors} = [];
}

=head3 push_processor

    $request->push_processors(sub { ...something... });

Pushes a passed processor function into our processors arrayref

=cut

sub push_processor {
    my ( $self, $processor ) = @_;
    push @{$self->{processors}}, $processor;
}

=head3 statusalias

    my $statusalias = $request->statusalias;

    try {
        $capability = $self->_backend->capabilities($name);
    } catch {
        warn $_;
        return 0;
    };
    # Try to invoke it

    return $self->expandTemplate($result);
}

=head3 backend_get_update

    my $update = backend_get_update($request);

    Given a request, returns an update in a prescribed
    format that can then be passed to update parsers

=cut

sub backend_get_update {
    my ( $self, $delay ) = @_;

    my $response = $self->_backend_capability(
        'get_supplier_update',
        {
            request => $self,
            delay   => $delay
        }
    );
    return $response;
}

=head3 expandTemplate

    my $params = $abstract->expandTemplate($params);

=cut

sub send_patron_notice {
    my ( $self, $notice_code, $additional_text ) = @_;

    # We need a notice code
    if (!$notice_code) {


    # Map from the notice code to the messaging preference
    my %message_name = (
        ILL_PICKUP_READY    => 'Ill_ready',
        ILL_REQUEST_UNAVAIL => 'Ill_unavailable',
        ILL_REQUEST_UPDATE  => 'Ill_update'
    );

    # Get the patron's messaging preferences

    my @fail = ();
    for my $transport (@transports) {
        my $letter = $self->get_notice({
            notice_code     => $notice_code,
            transport       => $transport,
            additional_text => $additional_text
        });
        if ($letter) {
            my $result = C4::Letters::EnqueueLetter({

        substitute  => {
            ill_bib_title      => $title ? $title->value : '',
            ill_bib_author     => $author ? $author->value : '',
            ill_full_metadata  => $metastring,
            additional_text    => $params->{additional_text}
        }
    );

    return $letter;
}


=head3 attach_processors

Receive a Koha::Illrequest::SupplierUpdate and attach
any processors we have for it

=cut

sub attach_processors {
    my ( $self, $update ) = @_;

    foreach my $processor(@{$self->{processors}}) {
        if (
            $processor->{target_source_type} eq $update->{source_type} &&
            $processor->{target_source_name} eq $update->{source_name}
        ) {
            $update->attach_processor($processor);
        }
    }
}

=head3 append_to_note

    append_to_note("Some text");

Append some text to the staff note

=cut

sub append_to_note {
    my ($self, $text) = @_;
    my $current = $self->notesstaff;
    $text = ($current && length $current > 0) ? "$current\n\n$text" : $text;
    $self->notesstaff($text)->store;
}

=head3 id_prefix

    my $prefix = $record->id_prefix;




package Koha::Illrequest::SupplierUpdate;

# Copyright 2022 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, see <http://www.gnu.org/licenses>.

use Modern::Perl;

=head1 NAME

Koha::Illrequest::SupplierUpdate - Represents a single request update from a supplier

=head1 SYNOPSIS

Object-oriented class that provides an object allowing us to interact with
an update from a supplier

=head1 DESCRIPTION

Object-oriented class that provides an object allowing us to interact with
an update from a supplier

=head1 API

=head2 Class Methods

=head3 new

    my $update = Koha::Illrequest::SupplierUpdate->new(
        $source_type,
        $source_name,
        $update
    );

Create a new Koha::Illrequest::SupplierUpdate object.

=cut

sub new {
    my ( $class, $source_type, $source_name, $update, $request ) = @_;
    my $self  = {};

    $self->{source_type} = $source_type;
    $self->{source_name} = $source_name;
    $self->{update} = $update;
    $self->{request} = $request;
    $self->{processors} = [];

    bless $self, $class;

    return $self;
}

=head3 attach_processor

    Koha::Illrequest::SupplierUpdate->attach_processor($processor);

Pushes a processor function onto the 'processors' arrayref

=cut

sub attach_processor {
    my ( $self, $processor ) = @_;
    push(@{$self->{processors}}, $processor);
}

=head3 run_processors

    Koha::Illrequest::SupplierUpdate->run_processors();

Iterates all processors on this object and runs each

=cut

sub run_processors {
    my ( $self ) = @_;
    my $results = [];
    foreach my $processor(@{$self->{processors}}) {
        my $processor_result = {
            name   => $processor->{name},
            result => {
                success => [],
                error   => []
            }
        };
        $processor->run($self, $processor_result->{result});
        push @{$results}, $processor_result;
    }
    return $results;
}

=head1 AUTHOR

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

=cut

1;




package Koha::Illrequest::SupplierUpdateProcessor;

# Copyright 2022 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, see <http://www.gnu.org/licenses>.

use Modern::Perl;

=head1 NAME

Koha::Illrequest::SupplierUpdateProcessor - Represents a SupplerUpdate processor

=head1 SYNOPSIS

Object-oriented class that provides an object allowing us to perform processing on
a SupplierUpdate

=head1 DESCRIPTION

Object-oriented base class that provides an object allowing us to perform processing on
a SupplierUpdate
** This class should not be directly instantiated, it should only be sub-classed **

=head1 API

=head2 Class Methods

=head3 new

    my $processor = Koha::Illrequest::SupplierUpdateProcessor->new(
        $target_source_type,
        $target_source_name
    );

Create a new Koha::Illrequest::SupplierUpdateProcessor object.

=cut

sub new {
    my ( $class, $target_source_type, $target_source_name, $processor_name ) = @_;
    my $self  = {};

    $self->{target_source_type} = $target_source_type;
    $self->{target_source_name} = $target_source_name;
    $self->{name} = $processor_name;

    bless $self, $class;

    return $self;
}

=head3 run

    Koha::Illrequest::SupplierUpdateProcessor->run();

Runs the processor

=cut

sub run {
    my ( $self ) = @_;
    my ( $package, $filename ) = caller;
    warn __PACKAGE__ . " run should only be invoked by a subclass\n";
}

=head1 AUTHOR

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

=cut

1;




#!/usr/bin/perl

# This file is part of Koha.
#
# Copyright (C) 2022 PTFS Europe
#
# 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 Modern::Perl;
use Getopt::Long qw( GetOptions );
use POSIX;

use Koha::Script;
use Koha::Illrequests;

# Command line option values
my $get_help = 0;
my $delay = 0;
my $statuses = "";
my $backend = "";

my $options = GetOptions(
    'h|help'         => \$get_help,
    'statuses=s'     => \$statuses,
    'backend=s'      => \$backend,
    'api-delay:i'    => \$delay
);

if ($get_help) {
    get_help();
    exit 1;
}

if (!$backend) {
    print "No backend specified\n";
    exit 0;
}

# First check we can proceed
my $cfg = Koha::Illrequest::Config->new;
my $backends = $cfg->available_backends;
my $has_branch = $cfg->has_branch;
my $backends_available = ( scalar @{$backends} > 0 );
if (!$has_branch || $backends_available == 0) {
    print "Unable to proceed:\n";
    print "Branch configured: $has_branch\n";
    print "Backends available: $backends_available\n";
    exit 0;
}

# Get all requests with a REQ status
my @statuses_arr = split(/:/, $statuses);
if (scalar @statuses_arr == 0) {
    print "No statuses supplied\n";
    exit 0;
}

my $where = {
    status => { -in => \@statuses_arr },
    backend => $backend
};

my $requests = Koha::Illrequests->search($where);

# The progress log
my $output = [];

while (my $request = $requests->next) {
    my $update = $request->backend_get_update($delay);
    # The log for this request
    my $update_log = {
        request_id     => $request->illrequest_id,
        processed_by   => $request->_backend->name,
        processors_run => []
    };
    if ($update) {
        # Currently we make an assumption, this may need revisiting
        # if we need to extend the functionality:
        #
        # Only the backend that originated the update will want to
        # process it
        #
        # Since each backend's update format is different, it may
        # be necessary for a backend to subclass Koha::Illrequest::SupplierUpdate
        # so it can provide methods (corresponding to a generic interface) that
        # return pertinent info to core ILL when it is processing updates
        #
        # Attach any request processors
        $request->attach_processors($update);
        # Attach any processors from this request's backend
        $request->_backend->attach_processors($update);
        my $processor_results = $update->run_processors($delay);
        # Update our progress log
        $update_log->{processors_run} = $processor_results;
    }
    push @{$output}, $update_log;
}

print_summary($output);

sub print_summary {
    my ( $log ) = @_;

    my $timestamp = POSIX::strftime("%d/%m/%Y %H:%M:%S\n", localtime);
    print "Run details:\n";
    foreach my $entry(@{$log}) {
        my @processors_run = @{$entry->{processors_run}};
        print "Request ID: " . $entry->{request_id} . "\n";
        print "  Processing by: " . $entry->{processed_by} . "\n";
        print "  Number of processors run: " . scalar @processors_run . "\n";
        if (scalar @processors_run > 0) {
            print "  Processor details:\n";
            foreach my $processor(@processors_run) {
                print "    Processor name: " . $processor->{name} . "\n";
                print "    Success messages: " . join(", ", @{$processor->{result}->{success}}) . "\n";
                print "    Error messages: " . join(", ", @{$processor->{result}->{error}}) . "\n";
            }
        }
    }
    print "Job completed at $timestamp\n====================================\n\n"
}

sub get_help {
    print <<"HELP";
$0: Fetch and process outstanding ILL updates

This script will fetch all requests that have the specified
statuses and run any applicable processor scripts on them.
For example, the RapidILL backend provides a processor script
that emails users when their requested electronic resource
request has been fulfilled

Parameters:
    --statuses <statuses> [required] specify the statuses a request must have in order to be processed,
                                     statuses should be separated by a : e.g. REQ:COMP:NEW

    --delay <seconds>                if a processing script needs to make an API call, how long a pause
                                     should be inserted between each API call

    --help or -h                     get help
HELP
}

Return to bug 30484

Lines 116-121 available for request. Link Here

(-)a/Koha/Illrequest.pm (-6 / +95 lines)
116		116
117	=head2 Class methods	117	=head2 Class methods
118		118
		119	=head3 init_processors
		120
		121	$request->init_processors()
		122
		123	Initialises an empty processors arrayref
		124
		125	=cut
		126
		127	sub init_processors {
		128	my ( $self ) = @_;
		129
		130	$self->{processors} = [];
		131	}
		132
		133	=head3 push_processor
		134
		135	$request->push_processors(sub { ...something... });
		136
		137	Pushes a passed processor function into our processors arrayref
		138
		139	=cut
		140
		141	sub push_processor {
		142	my ( $self, $processor ) = @_;
		143	push @{$self->{processors}}, $processor;
		144	}
		145
119	=head3 statusalias	146	=head3 statusalias
120		147
121	my $statusalias = $request->statusalias;	148	my $statusalias = $request->statusalias;
Lines 371-376 sub _backend_capability { Link Here
371	try {	398	try {
372	$capability = $self->_backend->capabilities($name);	399	$capability = $self->_backend->capabilities($name);
373	} catch {	400	} catch {
		401	warn $_;
374	return 0;	402	return 0;
375	};	403	};
376	# Try to invoke it	404	# Try to invoke it
Lines 896-901 sub backend_create { Link Here
896	return $self->expandTemplate($result);	924	return $self->expandTemplate($result);
897	}	925	}
898		926
		927	=head3 backend_get_update
		928
		929	my $update = backend_get_update($request);
		930
		931	Given a request, returns an update in a prescribed
		932	format that can then be passed to update parsers
		933
		934	=cut
		935
		936	sub backend_get_update {
		937	my ( $self, $delay ) = @_;
		938
		939	my $response = $self->_backend_capability(
		940	'get_supplier_update',
		941	{
		942	request => $self,
		943	delay => $delay
		944	}
		945	);
		946	return $response;
		947	}
		948
899	=head3 expandTemplate	949	=head3 expandTemplate
900		950
901	my $params = $abstract->expandTemplate($params);	951	my $params = $abstract->expandTemplate($params);
Lines 1419-1425 Send a specified notice regarding this request to a patron Link Here
1419	=cut	1469	=cut
1420		1470
1421	sub send_patron_notice {	1471	sub send_patron_notice {
1422	my ( $self, $notice_code ) = @_;	1472	my ( $self, $notice_code, $additional_text ) = @_;
1423		1473
1424	# We need a notice code	1474	# We need a notice code
1425	if (!$notice_code) {	1475	if (!$notice_code) {
Lines 1430-1437 sub send_patron_notice { Link Here
1430		1480
1431	# Map from the notice code to the messaging preference	1481	# Map from the notice code to the messaging preference
1432	my %message_name = (	1482	my %message_name = (
1433	ILL_PICKUP_READY => 'Ill_ready',	1483	ILL_PICKUP_READY => 'Ill_ready',
1434	ILL_REQUEST_UNAVAIL => 'Ill_unavailable'	1484	ILL_REQUEST_UNAVAIL => 'Ill_unavailable',
		1485	ILL_REQUEST_UPDATE => 'Ill_update'
1435	);	1486	);
1436		1487
1437	# Get the patron's messaging preferences	1488	# Get the patron's messaging preferences
Lines 1453-1460 sub send_patron_notice { Link Here
1453	my @fail = ();	1504	my @fail = ();
1454	for my $transport (@transports) {	1505	for my $transport (@transports) {
1455	my $letter = $self->get_notice({	1506	my $letter = $self->get_notice({
1456	notice_code => $notice_code,	1507	notice_code => $notice_code,
1457	transport => $transport	1508	transport => $transport,
		1509	additional_text => $additional_text
1458	});	1510	});
1459	if ($letter) {	1511	if ($letter) {
1460	my $result = C4::Letters::EnqueueLetter({	1512	my $result = C4::Letters::EnqueueLetter({
Lines 1595-1607 sub get_notice { Link Here
1595	substitute => {	1647	substitute => {
1596	ill_bib_title => $title ? $title->value : '',	1648	ill_bib_title => $title ? $title->value : '',
1597	ill_bib_author => $author ? $author->value : '',	1649	ill_bib_author => $author ? $author->value : '',
1598	ill_full_metadata => $metastring	1650	ill_full_metadata => $metastring,
		1651	additional_text => $params->{additional_text}
1599	}	1652	}
1600	);	1653	);
1601		1654
1602	return $letter;	1655	return $letter;
1603	}	1656	}
1604		1657
		1658
		1659	=head3 attach_processors
		1660
		1661	Receive a Koha::Illrequest::SupplierUpdate and attach
		1662	any processors we have for it
		1663
		1664	=cut
		1665
		1666	sub attach_processors {
		1667	my ( $self, $update ) = @_;
		1668
		1669	foreach my $processor(@{$self->{processors}}) {
		1670	if (
		1671	$processor->{target_source_type} eq $update->{source_type} &&
		1672	$processor->{target_source_name} eq $update->{source_name}
		1673	) {
		1674	$update->attach_processor($processor);
		1675	}
		1676	}
		1677	}
		1678
		1679	=head3 append_to_note
		1680
		1681	append_to_note("Some text");
		1682
		1683	Append some text to the staff note
		1684
		1685	=cut
		1686
		1687	sub append_to_note {
		1688	my ($self, $text) = @_;
		1689	my $current = $self->notesstaff;
		1690	$text = ($current && length $current > 0) ? "$current\n\n$text" : $text;
		1691	$self->notesstaff($text)->store;
		1692	}
		1693
1605	=head3 id_prefix	1694	=head3 id_prefix
1606		1695
1607	my $prefix = $record->id_prefix;	1696	my $prefix = $record->id_prefix;

Line 0 Link Here

(-)a/Koha/Illrequest/SupplierUpdate.pm (+111 lines)
		1	package Koha::Illrequest::SupplierUpdate;
		2
		3	# Copyright 2022 PTFS Europe Ltd
		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 Modern::Perl;
		21
		22	=head1 NAME
		23
		24	Koha::Illrequest::SupplierUpdate - Represents a single request update from a supplier
		25
		26	=head1 SYNOPSIS
		27
		28	Object-oriented class that provides an object allowing us to interact with
		29	an update from a supplier
		30
		31	=head1 DESCRIPTION
		32
		33	Object-oriented class that provides an object allowing us to interact with
		34	an update from a supplier
		35
		36	=head1 API
		37
		38	=head2 Class Methods
		39
		40	=head3 new
		41
		42	my $update = Koha::Illrequest::SupplierUpdate->new(
		43	$source_type,
		44	$source_name,
		45	$update
		46	);
		47
		48	Create a new Koha::Illrequest::SupplierUpdate object.
		49
		50	=cut
		51
		52	sub new {
		53	my ( $class, $source_type, $source_name, $update, $request ) = @_;
		54	my $self = {};
		55
		56	$self->{source_type} = $source_type;
		57	$self->{source_name} = $source_name;
		58	$self->{update} = $update;
		59	$self->{request} = $request;
		60	$self->{processors} = [];
		61
		62	bless $self, $class;
		63
		64	return $self;
65	}
66
67	=head3 attach_processor
68
69	Koha::Illrequest::SupplierUpdate->attach_processor($processor);
70
71	Pushes a processor function onto the 'processors' arrayref
72
73	=cut
74
75	sub attach_processor {
76	my ( $self, $processor ) = @_;
77	push(@{$self->{processors}}, $processor);
78	}
79
80	=head3 run_processors
81
82	Koha::Illrequest::SupplierUpdate->run_processors();
83
84	Iterates all processors on this object and runs each
85
86	=cut
87
88	sub run_processors {
89	my ( $self ) = @_;
90	my $results = [];
91	foreach my $processor(@{$self->{processors}}) {
92	my $processor_result = {
93	name => $processor->{name},
94	result => {
95	success => [],
96	error => []
97	}
98	};
99	$processor->run($self, $processor_result->{result});
100	push @{$results}, $processor_result;
101	}
102	return $results;
103	}
104
105	=head1 AUTHOR
106
107	Andrew Isherwood <andrew.isherwood@ptfs-europe.com>
108
109	=cut
110
111	1;

Line 0 Link Here

(-)a/Koha/Illrequest/SupplierUpdateProcessor.pm (+85 lines)
		1	package Koha::Illrequest::SupplierUpdateProcessor;
		2
		3	# Copyright 2022 PTFS Europe Ltd
		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 Modern::Perl;
		21
		22	=head1 NAME
		23
		24	Koha::Illrequest::SupplierUpdateProcessor - Represents a SupplerUpdate processor
		25
		26	=head1 SYNOPSIS
		27
		28	Object-oriented class that provides an object allowing us to perform processing on
		29	a SupplierUpdate
		30
		31	=head1 DESCRIPTION
		32
		33	Object-oriented base class that provides an object allowing us to perform processing on
		34	a SupplierUpdate
		35	This class should not be directly instantiated, it should only be sub-classed
		36
		37	=head1 API
		38
		39	=head2 Class Methods
		40
		41	=head3 new
		42
		43	my $processor = Koha::Illrequest::SupplierUpdateProcessor->new(
		44	$target_source_type,
		45	$target_source_name
		46	);
		47
		48	Create a new Koha::Illrequest::SupplierUpdateProcessor object.
		49
		50	=cut
		51
		52	sub new {
		53	my ( $class, $target_source_type, $target_source_name, $processor_name ) = @_;
		54	my $self = {};
		55
		56	$self->{target_source_type} = $target_source_type;
		57	$self->{target_source_name} = $target_source_name;
		58	$self->{name} = $processor_name;
		59
		60	bless $self, $class;
		61
		62	return $self;
		63	}
		64
65	=head3 run
66
67	Koha::Illrequest::SupplierUpdateProcessor->run();
68
69	Runs the processor
70
71	=cut
72
73	sub run {
74	my ( $self ) = @_;
75	my ( $package, $filename ) = caller;
76	warn __PACKAGE__ . " run should only be invoked by a subclass\n";
77	}
78
79	=head1 AUTHOR
80
81	Andrew Isherwood <andrew.isherwood@ptfs-europe.com>
82
83	=cut
84
85	1;

Line 0 Link Here

(-)a/misc/process_ill_updates.pl (-1 / +153 lines)
0	-	1	#!/usr/bin/perl
		2
		3	# This file is part of Koha.
		4	#
		5	# Copyright (C) 2022 PTFS Europe
		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 Modern::Perl;
		21	use Getopt::Long qw( GetOptions );
		22	use POSIX;
		23
		24	use Koha::Script;
		25	use Koha::Illrequests;
		26
		27	# Command line option values
		28	my $get_help = 0;
		29	my $delay = 0;
		30	my $statuses = "";
		31	my $backend = "";
		32
		33	my $options = GetOptions(
		34	'h\|help' => \$get_help,
		35	'statuses=s' => \$statuses,
		36	'backend=s' => \$backend,
		37	'api-delay:i' => \$delay
		38	);
		39
		40	if ($get_help) {
		41	get_help();
		42	exit 1;
		43	}
		44
		45	if (!$backend) {
		46	print "No backend specified\n";
		47	exit 0;
		48	}
		49
		50	# First check we can proceed
		51	my $cfg = Koha::Illrequest::Config->new;
		52	my $backends = $cfg->available_backends;
		53	my $has_branch = $cfg->has_branch;
		54	my $backends_available = ( scalar @{$backends} > 0 );
		55	if (!$has_branch \|\| $backends_available == 0) {
		56	print "Unable to proceed:\n";
		57	print "Branch configured: $has_branch\n";
		58	print "Backends available: $backends_available\n";
		59	exit 0;
		60	}
		61
		62	# Get all requests with a REQ status
		63	my @statuses_arr = split(/:/, $statuses);
		64	if (scalar @statuses_arr == 0) {
		65	print "No statuses supplied\n";
66	exit 0;
67	}
68
69	my $where = {
70	status => { -in => \@statuses_arr },
71	backend => $backend
72	};
73
74	my $requests = Koha::Illrequests->search($where);
75
76	# The progress log
77	my $output = [];
78
79	while (my $request = $requests->next) {
80	my $update = $request->backend_get_update($delay);
81	# The log for this request
82	my $update_log = {
83	request_id => $request->illrequest_id,
84	processed_by => $request->_backend->name,
85	processors_run => []
86	};
87	if ($update) {
88	# Currently we make an assumption, this may need revisiting
89	# if we need to extend the functionality:
90	#
91	# Only the backend that originated the update will want to
92	# process it
93	#
94	# Since each backend's update format is different, it may
95	# be necessary for a backend to subclass Koha::Illrequest::SupplierUpdate
96	# so it can provide methods (corresponding to a generic interface) that
97	# return pertinent info to core ILL when it is processing updates
98	#
99	# Attach any request processors
100	$request->attach_processors($update);
101	# Attach any processors from this request's backend
102	$request->_backend->attach_processors($update);
103	my $processor_results = $update->run_processors($delay);
104	# Update our progress log
105	$update_log->{processors_run} = $processor_results;
106	}
107	push @{$output}, $update_log;
108	}
109
110	print_summary($output);
111
112	sub print_summary {
113	my ( $log ) = @_;
114
115	my $timestamp = POSIX::strftime("%d/%m/%Y %H:%M:%S\n", localtime);
116	print "Run details:\n";
117	foreach my $entry(@{$log}) {
118	my @processors_run = @{$entry->{processors_run}};
119	print "Request ID: " . $entry->{request_id} . "\n";
120	print " Processing by: " . $entry->{processed_by} . "\n";
121	print " Number of processors run: " . scalar @processors_run . "\n";
122	if (scalar @processors_run > 0) {
123	print " Processor details:\n";
124	foreach my $processor(@processors_run) {
125	print " Processor name: " . $processor->{name} . "\n";
126	print " Success messages: " . join(", ", @{$processor->{result}->{success}}) . "\n";
127	print " Error messages: " . join(", ", @{$processor->{result}->{error}}) . "\n";
128	}
129	}
130	}
131	print "Job completed at $timestamp\n====================================\n\n"
132	}
133
134	sub get_help {
135	print <<"HELP";
136	$0: Fetch and process outstanding ILL updates
137
138	This script will fetch all requests that have the specified
139	statuses and run any applicable processor scripts on them.
140	For example, the RapidILL backend provides a processor script
141	that emails users when their requested electronic resource
142	request has been fulfilled
143
144	Parameters:
145	--statuses <statuses> [required] specify the statuses a request must have in order to be processed,
146	statuses should be separated by a : e.g. REQ:COMP:NEW
147
148	--delay <seconds> if a processing script needs to make an API call, how long a pause
149	should be inserted between each API call
150
151	--help or -h get help
152	HELP
153	}