use C4::Letters;

use C4::Members;

and sends a notice if appropriate

        # If status has changed to cancellation requested, send a notice

        if ($new_status eq 'CANCREQ') {

            $self->send_staff_notice('ILL_REQUEST_CANCEL');

        }

        return {

            error   => 1,

            status  => 'email_failed',

            message => 'Email queueing failed',

            method  => 'generic_confirm',

            stage   => 'draft',

        };

=head3 get_staff_to_address

    my $email = $request->get_staff_to_address();

Get the email address to which staff notices should be sent

=cut

sub get_staff_to_address {

    my ( $self ) = @_;

    # The various places we can get an ILL staff email address from

    # (In order of preference)

    #

    # Dedicated branch address

    my $library = Koha::Libraries->find( $self->branchcode );

    my $branch_ill_to = $library->branchillemail;

    # General purpose ILL address from syspref

    my $syspref = C4::Context->preference("ILLDefaultStaffEmail");

    # Branch general email address

    my $branch_to = $library->branchemail;

    # Last resort

    my $koha_admin = C4::Context->preference('KohaAdminEmailAddress');

    my $to;

    if ($branch_ill_to) {

        $to = $branch_ill_to;

    } elsif ($syspref) {

        $to = $syspref;

    } elsif ($branch_to) {

        $to = $branch_to;

    } elsif ($koha_admin) {

        $to = $koha_admin;

    }

    # $to will not be defined if we didn't find a usable address

    return $to;

}

=head3 send_patron_notice

    my $result = $request->send_patron_notice($notice_code);

Send a specified notice regarding this request to a patron

=cut

sub send_patron_notice {

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

    # We need a notice code

    if (!$notice_code) {

        return {

            error => 'notice_no_type'

        };

    }

    # Map from the notice code to the messaging preference

    my %message_name = (

        ILL_PICKUP_READY   => 'Ill_ready',

        ILL_REQUEST_UNAVAIL => 'Ill_unavailable'

    );

    # Get the patron's messaging preferences

    my $borrower_preferences = C4::Members::Messaging::GetMessagingPreferences({

        borrowernumber => $self->borrowernumber,

        message_name   => $message_name{$notice_code}

    });

    my @transports = keys %{ $borrower_preferences->{transports} };

    # Send the notice to the patron via the chosen transport methods

    # and record the results

    my @success = ();

    my @fail = ();

    for my $transport (@transports) {

        my $letter = $self->get_notice({

            notice_code => $notice_code,

            transport   => $transport

        });

        if ($letter) {

            my $result = C4::Letters::EnqueueLetter({

                letter                 => $letter,

                borrowernumber         => $self->borrowernumber,

                message_transport_type => $transport,

            });

            if ($result) {

                push @success, $transport;

            } else {

                push @fail, $transport;

            }

        } else {

            push @fail, $transport;

        }

    }

    if (scalar @success > 0) {

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

        $logger->log_patron_notice({

            request => $self,

            notice_code => $notice_code

        });

    }

    return {

        result => {

            success => \@success,

            fail    => \@fail

        }

    };

}

=head3 send_staff_notice

    my $result = $request->send_staff_notice($notice_code);

Send a specified notice regarding this request to staff

=cut

sub send_staff_notice {

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

    # We need a notice code

    if (!$notice_code) {

        return {

            error => 'notice_no_type'

        };

    }

    # Get the staff notices that have been assigned for sending in

    # the syspref

    my $staff_to_send = C4::Context->preference('ILLSendStaffNotices');

    # If it hasn't been enabled in the syspref, we don't want to send it

    if ($staff_to_send !~ /\b$notice_code\b/) {

        return {

            error => 'notice_not_enabled'

        };

    }

    my $letter = $self->get_notice({

        notice_code => $notice_code,

        transport   => 'email'

    });

    # Try and get an address to which to send staff notices

    my $to_address = scalar $self->get_staff_to_address;

    my $params = {

        letter                 => $letter,

        borrowernumber         => $self->borrowernumber,

        message_transport_type => 'email',

    };

    if ($to_address) {

        $params->{to_address} = $to_address;

        $params->{from_address} = $to_address;

    } else {

        return {

            error => 'notice_no_create'

        };

    }

    if ($letter) {

        C4::Letters::EnqueueLetter($params)

            or warn "can't enqueue letter $letter";

        return {

            success => 'notice_queued'

        };

    } else {

        return {

            error => 'notice_no_create'

        };

    }

}

=head3 get_notice

    my $notice = $request->get_notice($params);

Return a compiled notice hashref for the passed notice code

and transport type

=cut

sub get_notice {

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

    my $title = $self->illrequestattributes->find(

        { type => 'title' }

    );

    my $author = $self->illrequestattributes->find(

        { type => 'author' }

    );

    my $metahash = $self->metadata;

    my @metaarray = ();

    while (my($key, $value) = each %{$metahash}) {

        push @metaarray, "- $key: $value" if $value;

    }

    my $metastring = join("\n", @metaarray);

    my $letter = C4::Letters::GetPreparedLetter(

        module                 => 'ill',

        letter_code            => $params->{notice_code},

        message_transport_type => $params->{transport},

        lang                   => $self->patron->lang,

        tables                 => {

            illrequests => $self->illrequest_id,

            borrowers   => $self->borrowernumber,

            biblio      => $self->biblio_id,

            branches    => $self->branchcode,

        },

        substitute  => {

            ill_bib_title      => $title ? $title->value : 'N/A',

            ill_bib_author     => $author ? $author->value : 'N/A',

            ill_full_metadata  => $metastring

        }

    );

    return $letter;

}

use Koha::Notice::Template;

        },

        patron_notice => sub {

            $self->log_patron_notice(@_);

=head3 log_patron_notice

    Koha::IllRequest::Logger->log_patron_notice($params);

Receive a hashref containing a request object and params to log,

and log it

=cut

sub log_patron_notice {

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

    if (defined $params->{request} && defined $params->{notice_code}) {

        $self->log_something({

            modulename   => 'ILL',

            actionname   => 'PATRON_NOTICE',

            objectnumber => $params->{request}->id,

            infos        => to_json({

                log_origin    => 'core',

                notice_code => $params->{notice_code}

            })

        });

    }

}

    # Populate a lookup table for all ILL notice types

    my $notice_types = Koha::Notice::Templates->search({

        module => 'ill'

    })->unblessed;

    my $notice_hash;

    foreach my $notice(@{$notice_types}) {

        $notice_hash->{$notice->{code}} = $notice;

    }

        $log->{notice_types} = $notice_hash;

use Koha::Notice::Templates;

        # Get the details for notices that can be sent from here

        my $notices = Koha::Notice::Templates->search(

            {

                module => 'ill',

                code => { -in => [ 'ILL_PICKUP_READY' ,'ILL_REQUEST_UNAVAIL' ] },

            },

            {

                columns => [ qw/code name/ ],

                distinct => 1

            }

        )->unblessed;

            notices    => $notices,

    } elsif ( $op eq "send_notice" ) {

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

        my $request = Koha::Illrequests->find($illrequest_id);

        my $ret = $request->send_patron_notice($params->{notice_code});

        my $append = '';

        if ($ret->{result} && scalar @{$ret->{result}->{success}} > 0) {

            $append .= '&tran_success=' . join(',', @{$ret->{result}->{success}});

        }

        if ($ret->{result} && scalar @{$ret->{result}->{fail}} > 0) {

            $append .= '&tran_fail=' . join(',', @{$ret->{result}->{fail}}.join(','));

        }

        # Redirect to view the whole request

        print $cgi->redirect(

            "/cgi-bin/koha/ill/ill-requests.pl?method=illview&illrequest_id=".

            scalar $params->{illrequest_id} . $append

        );

        exit;

                [% IF whole.success %]

                    <p>[% whole.success | html %]</p>

                [% END %]

                    [% IF tran_success %]

                        [% succ_methods = [] %]

                        [% IF tran_success.match('email') %]

                            [% succ_methods.push('email') %]

                        [% END %]

                        [% IF tran_success.match('sms') %]

                            [% succ_methods.push('SMS') %]

                        [% END %]

                        <div class="alert">

                            The requested notice was queued for delivery by [% succ_methods.join(', ') | html %]

                        </div>

                    [% END %]

                    [% IF tran_fail %]

                        [% fail_methods = [] %]

                        [% IF tran_fail.match('email') %]

                            [% fail_methods.push('email') %]

                        [% END %]

                        [% IF tran_fail.match('sms') %]

                            [% fail_methods.push('SMS') %]

                        [% END %]

                        <div class="alert">

                            The requested notice was NOT queued for delivery by [% fail_methods.join(', ') | html %]

                        </div>

                    [% END %]

                        <div class="dropdown btn-group">

                            <button class="btn btn-default dropdown-toggle" type="button" id="ill-notice-dropdown" data-toggle="dropdown" aria-haspopup="true" aria-expanded="true">

                                <i class="fa fa-envelope"></i> Send notice to patron <span class="caret"></span>

                            </button>

                            <ul class="dropdown-menu" aria-labelledby="ill-notice-dropdown">

                                [% FOREACH notice IN notices %]

                                    <li><a href="/cgi-bin/koha/ill/ill-requests.pl?method=send_notice&amp;illrequest_id=[% request.illrequest_id | uri %]&amp;notice_code=[% notice.code | uri %]">[% notice.name | html %]</a></li>

                                [% END %]

                            </ul>

                        </div>

[% USE KohaDates %]

<p>

[% log.timestamp | $KohaDates with_hours => 1 %] : <b>Patron notice sent: </b>

[% notice_code = log.info.notice_code %]

"[% log.notice_types.$notice_code.name | html %]"

</p>

    # Send a notice to staff alerting them of the update

    $request->send_staff_notice('ILL_REQUEST_MODIFIED');