Attachment #107612 for bug #17499

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

Lines 24-30 use Exception::Class ( Link Here

(-)a/Koha/Exceptions.pm (-1 / +7 lines)
24	},	24	},
25	'Koha::Exceptions::MissingParameter' => {	25	'Koha::Exceptions::MissingParameter' => {
26	isa => 'Koha::Exceptions::Exception',	26	isa => 'Koha::Exceptions::Exception',
27	description => 'A required parameter is missing'	27	description => 'A required parameter is missing',
		28	fields => ['parameter'],
		29	},
		30	'Koha::Exceptions::TooManyParameters' => {
		31	isa => 'Koha::Exceptions::Exception',
		32	description => 'Too many parameters given',
		33	fields => ['parameter'],
28	},	34	},
29	'Koha::Exceptions::ParameterTooHigh' => {	35	'Koha::Exceptions::ParameterTooHigh' => {
30	isa => 'Koha::Exceptions::Exception',	36	isa => 'Koha::Exceptions::Exception',




use Koha::Patron::HouseboundRole;
use Koha::Patron::Images;
use Koha::Patron::Modifications;
use Koha::Patron::Message::Preferences;
use Koha::Patron::Relationships;
use Koha::Patrons;
use Koha::Plugins;

    return $attribute->next;
}

=head3 set_default_messaging_preferences

    $patron->set_default_messaging_preferences

Sets default messaging preferences on patron.

See Koha::Patron::Message::Preference(s) for more documentation, especially on
thrown exceptions.

=cut

sub set_default_messaging_preferences {
    my ($self, $categorycode) = @_;

    my $options = Koha::Patron::Message::Preferences->get_options;

    foreach my $option (@$options) {
        # Check that this option has preference configuration for this category
        unless (Koha::Patron::Message::Preferences->search({
            message_attribute_id => $option->{message_attribute_id},
            categorycode         => $categorycode || $self->categorycode,
        })->count) {
            next;
        }

        # Delete current setting
        Koha::Patron::Message::Preferences->search({
             borrowernumber => $self->borrowernumber,
             message_attribute_id => $option->{message_attribute_id},
        })->delete;

        Koha::Patron::Message::Preference->new_from_default({
            borrowernumber => $self->borrowernumber,
            categorycode   => $categorycode || $self->categorycode,
            message_attribute_id => $option->{message_attribute_id},
        });
    }

    return $self;
}

=head3 to_api

    my $json = $patron->to_api;




package Koha::Patron::Message::Attribute;

# Copyright Koha-Suomi Oy 2016
#
# 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.a
#
# 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 Koha::Database;

use base qw(Koha::Object);

=head1 NAME

Koha::Patron::Message::Attribute - Koha Patron Message Attribute object class

=head1 API

=head2 Class Methods

=cut

=head3 type

=cut

sub _type {
    return 'MessageAttribute';
}

=head1 AUTHOR

Lari Taskula <lari.taskula@hypernova.fi>

=cut

1;




package Koha::Patron::Message::Attributes;

# Copyright Koha-Suomi Oy 2016
#
# 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 Koha::Database;
use Koha::Patron::Message::Attribute;

use base qw(Koha::Objects);

=head1 NAME

Koha::Patron::Message::Attributes - Koha Patron Message Attributes object class

=head1 API

=head2 Class Methods

=cut

=head3 type

=cut

sub _type {
    return 'MessageAttribute';
}

sub object_class {
    return 'Koha::Patron::Message::Attribute';
}

=head1 AUTHOR

Lari Taskula <lari.taskula@hypernova.fi>

=cut

1;




package Koha::Patron::Message::Preference;

# Copyright Koha-Suomi Oy 2016
#
# 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.a
#
# 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 Koha::Database;
use Koha::Exceptions;
use Koha::Patron::Categories;
use Koha::Patron::Message::Attributes;
use Koha::Patron::Message::Preferences;
use Koha::Patron::Message::Transport::Preferences;
use Koha::Patron::Message::Transport::Types;
use Koha::Patron::Message::Transports;
use Koha::Patrons;

use base qw(Koha::Object);

=head1 NAME

Koha::Patron::Message::Preference - Koha Patron Message Preference object class

=head1 API

=head2 Class Methods

=cut

=head3 new

my $preference = Koha::Patron::Message::Preference->new({
   borrowernumber => 123,
   #categorycode => 'ABC',
   message_attribute_id => 4,
   message_transport_types => ['email', 'sms'], # see documentation below
   wants_digest => 1,
   days_in_advance => 7,
});

Takes either borrowernumber or categorycode, but not both.

days_in_advance may not be available. See message_attributes table for takes_days
configuration.

wants_digest may not be available. See message_transports table for is_digest
configuration.

You can instantiate a new object without custom validation errors, but when
storing, validation may throw exceptions. See C<validate()> for more
documentation.

C<message_transport_types> is a parameter that is not actually a column in this
Koha-object. Given this parameter, the message transport types will be added as
related transport types for this object. For get and set, you can access them via
subroutine C<message_transport_types()> in this class.

=cut

sub new {
    my ($class, $params) = @_;

    my $types = $params->{'message_transport_types'};
    delete $params->{'message_transport_types'};

    my $self = $class->SUPER::new($params);

    $self->_set_message_transport_types($types);

    return $self;
}

=head3 new_from_default

my $preference = Koha::Patron::Message::Preference->new_from_default({
    borrowernumber => 123,
    categorycode   => 'ABC',   # if not given, patron's categorycode will be used
    message_attribute_id => 1,
});

NOTE: This subroutine initializes and STORES the object (in order to set
message transport types for the preference), so no need to call ->store when
preferences are initialized via this method.

Stores default messaging preference for C<categorycode> to patron for given
C<message_attribute_id>.

Throws Koha::Exceptions::MissingParameter if any of following is missing:
- borrowernumber
- message_attribute_id

Throws Koha::Exceptions::ObjectNotFound if default preferences are not found.

=cut

sub new_from_default {
    my ($class, $params) = @_;

    my @required = qw(borrowernumber message_attribute_id);
    foreach my $p (@required) {
        Koha::Exceptions::MissingParameter->throw(
            error => 'Missing required parameter.',
            parameter => $p,
        ) unless exists $params->{$p};
    }
    unless ($params->{'categorycode'}) {
        my $patron = Koha::Patrons->find($params->{borrowernumber});
        $params->{'categorycode'} = $patron->categorycode;
    }

    my $default = Koha::Patron::Message::Preferences->find({
        categorycode => $params->{'categorycode'},
        message_attribute_id => $params->{'message_attribute_id'},
    });
    Koha::Exceptions::ObjectNotFound->throw(
        error => 'Default messaging preference for given categorycode and'
        .' message_attribute_id cannot be found.',
    ) unless $default;
    $default = $default->unblessed;

    # Add a new messaging preference for patron
    my $self = $class->SUPER::new({
        borrowernumber => $params->{'borrowernumber'},
        message_attribute_id => $default->{'message_attribute_id'},
        days_in_advance => $default->{'days_in_advance'},
        wants_digest => $default->{'wants_digest'},
    })->store;

    # Set default messaging transport types
    my $default_transport_types =
    Koha::Patron::Message::Transport::Preferences->search({
        borrower_message_preference_id =>
                    $default->{'borrower_message_preference_id'}
    });
    while (my $transport = $default_transport_types->next) {
        Koha::Patron::Message::Transport::Preference->new({
            borrower_message_preference_id => $self->borrower_message_preference_id,
            message_transport_type => $transport->message_transport_type,
        })->store;
    }

    return $self;
}

=head3 message_name

$preference->message_name

Gets message_name for this messaging preference.

Setter not implemented.

=cut

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

    if ($self->{'_message_name'}) {
        return $self->{'_message_name'};
    }
    $self->{'_message_name'} = Koha::Patron::Message::Attributes->find({
        message_attribute_id => $self->message_attribute_id,
    })->message_name;
    return $self->{'_message_name'};
}

=head3 message_transport_types

$preference->message_transport_types
Returns a HASHREF of message transport types for this messaging preference, e.g.
if ($preference->message_transport_types->{'email'}) {
    # email is one of the transport preferences
}

$preference->message_transport_types('email', 'sms');
Sets the given message transport types for this messaging preference

=cut

sub message_transport_types {
    my $self = shift;

    unless (@_) {
        if ($self->{'_message_transport_types'}) {
            return $self->{'_message_transport_types'};
        }
        map {
            my $transport = Koha::Patron::Message::Transports->find({
                message_attribute_id => $self->message_attribute_id,
                message_transport_type => $_->message_transport_type,
                is_digest => $self->wants_digest
            });
            unless ($transport) {
                my $logger = Koha::Logger->get;
                $logger->warn(
                    $self->message_name . ' has no transport with '.
                    $_->message_transport_type . ' (digest: '.
                    ($self->wants_digest ? 'yes':'no').').'
                );
            }
            $self->{'_message_transport_types'}->{$_->message_transport_type}
                = $transport ? $transport->letter_code : ' ';
        }
        Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $self->borrower_message_preference_id,
        })->as_list;
        return $self->{'_message_transport_types'} || {};
    }
    else {
        $self->_set_message_transport_types(@_);
        return $self;
    }
}

=head3 set

$preference->set({
    message_transport_types => ['sms', 'phone'],
    wants_digest => 0,
})->store;

Sets preference object values and additionally message_transport_types if given.

=cut

sub set {
    my ($self, $params) = @_;

    my $mtt = $params->{'message_transport_types'};
    delete $params->{'message_transport_types'};

    $self->SUPER::set($params) if $params;
    if ($mtt) {
        $self->message_transport_types($mtt);
    }

    return $self;
}

=head3 store

Makes a validation before actual Koha::Object->store so that proper exceptions
can be thrown. See C<validate()> for documentation about exceptions.

=cut

sub store {
    my $self = shift;

    $self->validate->SUPER::store(@_);

    # store message transport types
    if (exists $self->{'_message_transport_types'}) {
        Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id =>
                $self->borrower_message_preference_id,
        })->delete;
        foreach my $type (keys %{$self->{'_message_transport_types'}}) {
            Koha::Patron::Message::Transport::Preference->new({
                borrower_message_preference_id =>
                    $self->borrower_message_preference_id,
                message_transport_type => $type,
            })->store;
        }
    }

    return $self;
}

=head3 validate

Makes a basic validation for object.

Throws following exceptions regarding parameters.
- Koha::Exceptions::MissingParameter
- Koha::Exceptions::TooManyParameters
- Koha::Exceptions::BadParameter

See $_->parameter to identify the parameter causing the exception.

Throws Koha::Exceptions::DuplicateObject if this preference already exists.

Returns Koha::Patron::Message::Preference object.

=cut

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

    if ($self->borrowernumber && $self->categorycode) {
        Koha::Exceptions::TooManyParameters->throw(
            error => 'Both borrowernumber and category given, only one accepted',
            parameter => ['borrowernumber', 'categorycode'],
        );
    }
    if (!$self->borrowernumber && !$self->categorycode) {
        Koha::Exceptions::MissingParameter->throw(
            error => 'borrowernumber or category required, none given',
            parameter => ['borrowernumber', 'categorycode'],
        );
    }
    if ($self->borrowernumber) {
        Koha::Exceptions::BadParameter->throw(
            error => 'Patron not found.',
            parameter => 'borrowernumber',
        ) unless Koha::Patrons->find($self->borrowernumber);
    }
    if ($self->categorycode) {
        Koha::Exceptions::BadParameter->throw(
            error => 'Category not found.',
            parameter => 'categorycode',
        ) unless Koha::Patron::Categories->find($self->categorycode);
    }

    if (!$self->in_storage) {
        my $previous = Koha::Patron::Message::Preferences->search({
            borrowernumber => $self->borrowernumber,
            categorycode   => $self->categorycode,
            message_attribute_id => $self->message_attribute_id,
        });
        if ($previous->count) {
            Koha::Exceptions::DuplicateObject->throw(
                error => 'A preference for this borrower/category and'
                .' message_attribute_id already exists',
            );
        }
    }

    my $attr = Koha::Patron::Message::Attributes->find(
        $self->message_attribute_id
    );
    unless ($attr) {
        Koha::Exceptions::BadParameter->throw(
            error => 'Message attribute with id '.$self->message_attribute_id
            .' not found',
            parameter => 'message_attribute_id'
        );
    }
    if (defined $self->days_in_advance) {
        if ($attr && $attr->takes_days == 0) {
            Koha::Exceptions::BadParameter->throw(
                error => 'days_in_advance cannot be defined for '.
                $attr->message_name . '.',
                parameter => 'days_in_advance',
            );
        }
        elsif ($self->days_in_advance < 0 || $self->days_in_advance > 30) {
            Koha::Exceptions::BadParameter->throw(
                error => 'days_in_advance has to be a value between 0-30 for '.
                $attr->message_name . '.',
                parameter => 'days_in_advance',
            );
        }
    }
    if (defined $self->wants_digest) {
        my $transports = Koha::Patron::Message::Transports->search({
            message_attribute_id => $self->message_attribute_id,
            is_digest            => $self->wants_digest ? 1 : 0,
        });
        Koha::Exceptions::BadParameter->throw(
            error => (!$self->wants_digest ? 'Digest must be selected'
                                           : 'Digest cannot be selected')
            . ' for '.$attr->message_name.'.',
            parameter => 'wants_digest',
        ) if $transports->count == 0;
    }

    return $self;
}

sub _set_message_transport_types {
    my $self = shift;

    return unless $_[0];

    $self->{'_message_transport_types'} = undef;
    my $types = ref $_[0] eq "ARRAY" ? $_[0] : [@_];
    return unless $types;
    $self->_validate_message_transport_types({ message_transport_types => $types });
    foreach my $type (@$types) {
        unless (exists $self->{'_message_transport_types'}->{$type}) {
            my $transport = Koha::Patron::Message::Transports->find({
                message_attribute_id => $self->message_attribute_id,
                message_transport_type => $type
            });
            unless ($transport) {
                Koha::Exceptions::BadParameter->throw(
                    error => 'No transport configured for '.$self->message_name.
                        " transport type $type.",
                    parameter => 'message_transport_types'
                );
            }
            if (defined $self->borrowernumber) {
                my $patron = Koha::Patrons->find($self->borrowernumber);
                if ($type eq 'email') {
                    if ( !$patron->email )
                    {
                        Koha::Exceptions::BadParameter->throw(
                            error => 'Patron has not set email address, '.
                                     'cannot use email as message transport',
                            parameter => 'message_transport_types'
                        );
                    }
                }
                elsif ($type eq 'sms') {
                    if ( !$patron->smsalertnumber ){
                        Koha::Exceptions::BadParameter->throw(
                            error => 'Patron has not set sms number, '.
                                     'cannot set sms as message transport',
                            parameter => 'message_transport_types'
                        );
                    }
                }
            }
            $self->{'_message_transport_types'}->{$type}
                = $transport->letter_code;
        }
    }
    return $self;
}

sub _validate_message_transport_types {
    my ($self, $params) = @_;

    if (ref($params) eq 'HASH' && $params->{'message_transport_types'}) {
        if (ref($params->{'message_transport_types'}) ne 'ARRAY') {
            $params->{'message_transport_types'} = [$params->{'message_transport_types'}];
        }
        my $types = $params->{'message_transport_types'};

        foreach my $type (@{$types}) {
            unless (Koha::Patron::Message::Transport::Types->find({
                message_transport_type => $type
            })) {
                Koha::Exceptions::BadParameter->throw(
                    error => "Message transport type '$type' does not exist",
                    parameter => 'message_transport_types',
                );
            }
        }
        return $types;
    }
}

=head3 type

=cut

sub _type {
    return 'BorrowerMessagePreference';
}

=head1 AUTHOR

Lari Taskula <lari.taskula@hypernova.fi>

=cut

1;




package Koha::Patron::Message::Preferences;

# Copyright Koha-Suomi Oy 2016
#
# 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 Koha::Database;
use Koha::Patron::Message::Attributes;
use Koha::Patron::Message::Preference;
use Koha::Patron::Message::Transports;

use base qw(Koha::Objects);

=head1 NAME

Koha::Patron::Message::Preferences - Koha Patron Message Preferences object class

=head1 API

=head2 Class Methods

=cut

=head3 find_with_message_name

Koha::Patron::Message::Preferences->find_with_message_name({
    borrowernumber => 123,
    message_name => 'Hold_Filled',
});

Converts C<message_name> into C<message_attribute_id> and continues find.

=cut

sub find_with_message_name {
    my ($self, $id) = @_;

    if (ref($id) eq "HASH" && $id->{'message_name'}) {
        my $attr = Koha::Patron::Message::Attributes->find({
            message_name => $id->{'message_name'},
        });
        $id->{'message_attribute_id'} = ($attr) ?
                    $attr->message_attribute_id : undef;
        delete $id->{'message_name'};
    }

    return $self->SUPER::find($id);
}

=head3 get_options

my $messaging_options = Koha::Patron::Message::Preferences->get_options

Returns an ARRAYref of HASHrefs on available messaging options.

=cut

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

    my $transports = Koha::Patron::Message::Transports->search(undef,
        {
            join => ['message_attribute'],
            '+select' => ['message_attribute.message_name', 'message_attribute.takes_days'],
            '+as' => ['message_name', 'takes_days'],
        });

    my $choices;
    while (my $transport = $transports->next) {
        my $name = $transport->get_column('message_name');
        $choices->{$name}->{'message_attribute_id'} = $transport->message_attribute_id;
        $choices->{$name}->{'message_name'}         = $name;
        $choices->{$name}->{'takes_days'}           = $transport->get_column('takes_days');
        $choices->{$name}->{'has_digest'}           ||= 1 if $transport->is_digest;
        $choices->{$name}->{'has_digest_off'}       ||= 1 if !$transport->is_digest;
        $choices->{$name}->{'transport_'.$transport->get_column('message_transport_type')} = ' ';
    }

    my @return = values %$choices;
    @return = sort { $a->{message_attribute_id} <=> $b->{message_attribute_id} } @return;

    return \@return;
}

=head3 search_with_message_name

Koha::Patron::Message::Preferences->search_with_message_name({
    borrowernumber => 123,
    message_name => 'Hold_Filled',
});

Converts C<message_name> into C<message_attribute_id> and continues search. Use
Koha::Patron::Message::Preferences->search with a proper join for more complicated
searches.

=cut

sub search_with_message_name {
    my ($self, $params, $attributes) = @_;

    if (ref($params) eq "HASH" && $params->{'message_name'}) {
        my $attr = Koha::Patron::Message::Attributes->find({
            message_name => $params->{'message_name'},
        });
        $params->{'message_attribute_id'} = ($attr) ?
                    $attr->message_attribute_id : undef;
        delete $params->{'message_name'};
    }

    return $self->SUPER::search($params, $attributes);
}

=head3 type

=cut

sub _type {
    return 'BorrowerMessagePreference';
}

sub object_class {
    return 'Koha::Patron::Message::Preference';
}

=head1 AUTHOR

Lari Taskula <lari.taskula@hypernova.fi>

=cut

1;




package Koha::Patron::Message::Transport;

# Copyright Koha-Suomi Oy 2016
#
# 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.a
#
# 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 Koha::Database;

use base qw(Koha::Object);

=head1 NAME

Koha::Patron::Message::Transport - Koha Patron Message Transport object class

=head1 API

=head2 Class Methods

=cut

=head3 type

=cut

sub _type {
    return 'MessageTransport';
}

=head1 AUTHOR

Lari Taskula <lari.taskula@hypernova.fi>

=cut

1;




package Koha::Patron::Message::Transport::Preference;

# Copyright Koha-Suomi Oy 2016
#
# 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.a
#
# 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 Koha::Database;

use base qw(Koha::Object);

=head1 NAME

Koha::Patron::Message::Transport::Preference - Koha Patron Message Transport
Preference object class

=head1 API

=head2 Class Methods

=cut

=head3 type

=cut

sub _type {
    return 'BorrowerMessageTransportPreference';
}

=head1 AUTHOR

Lari Taskula <lari.taskula@hypernova.fi>

=cut

1;




package Koha::Patron::Message::Transport::Preferences;

# Copyright Koha-Suomi Oy 2016
#
# 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 Koha::Database;
use Koha::Patron::Message::Transport::Preference;

use base qw(Koha::Objects);

=head1 NAME

Koha::Patron::Message::Transport::Preferences - Koha Patron Message Transport
Preferences object class

=head1 API

=head2 Class Methods

=cut

=head3 type

=cut

sub _type {
    return 'BorrowerMessageTransportPreference';
}

sub object_class {
    return 'Koha::Patron::Message::Transport::Preference';
}

=head1 AUTHOR

Lari Taskula <lari.taskula@hypernova.fi>

=cut

1;




package Koha::Patron::Message::Transport::Type;

# Copyright Koha-Suomi Oy 2016
#
# 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.a
#
# 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 Koha::Database;

use base qw(Koha::Object);

=head1 NAME

Koha::Patron::Message::Transport::Type - Koha Patron Message Transport Type
object class

=head1 API

=head2 Class Methods

=cut

=head3 type

=cut

sub _type {
    return 'MessageTransportType';
}

=head1 AUTHOR

Lari Taskula <lari.taskula@hypernova.fi>

=cut

1;




package Koha::Patron::Message::Transport::Types;

# Copyright Koha-Suomi Oy 2016
#
# 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 Koha::Database;
use Koha::Patron::Message::Transport::Type;

use base qw(Koha::Objects);

=head1 NAME

Koha::Patron::Message::Transport::Types - Koha Patron Message Transport Types
object class

=head1 API

=head2 Class Methods

=cut

=head3 type

=cut

sub _type {
    return 'MessageTransportType';
}

sub object_class {
    return 'Koha::Patron::Message::Transport::Type';
}

=head1 AUTHOR

Lari Taskula <lari.taskula@hypernova.fi>

=cut

1;




package Koha::Patron::Message::Transports;

# Copyright Koha-Suomi Oy 2016
#
# 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 Koha::Database;
use Koha::Patron::Message::Transport;

use base qw(Koha::Objects);

=head1 NAME

Koha::Patron::Message::Transports - Koha Patron Message Transports object class

=head1 API

=head2 Class Methods

=cut

=head3 type

=cut

sub _type {
    return 'MessageTransport';
}

sub object_class {
    return 'Koha::Patron::Message::Transport';
}

=head1 AUTHOR

Lari Taskula <lari.taskula@hypernova.fi>

=cut

1;




#!/usr/bin/perl

# Copyright 2017 Koha-Suomi Oy
#
# 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;

use Test::More tests => 2;

use Koha::Database;

my $schema  = Koha::Database->new->schema;

subtest 'Test class imports' => sub {
    plan tests => 2;

    use_ok('Koha::Patron::Message::Attribute');
    use_ok('Koha::Patron::Message::Attributes');
};

subtest 'Test Koha::Patron::Message::Attributes' => sub {
    plan tests => 6;

    $schema->storage->txn_begin;

    Koha::Patron::Message::Attribute->new({
        message_name => 'Test_Attribute'
    })->store;
    Koha::Patron::Message::Attribute->new({
        message_name => 'Test_Attribute2',
        takes_days   => 1
    })->store;

    my $attribute  = Koha::Patron::Message::Attributes->find({
        message_name => 'Test_Attribute' });
    my $attribute2 = Koha::Patron::Message::Attributes->find({
        message_name => 'Test_Attribute2' });

    is($attribute->message_name, 'Test_Attribute',
       'Added a new messaging attribute.');
    is($attribute->takes_days, 0,
       'For that messaging attribute, takes_days is disabled by default.');
    is($attribute2->message_name, 'Test_Attribute2',
       'Added another messaging attribute.');
    is($attribute2->takes_days, 1,
       'takes_days is enabled for that message attribute (as expected).');

    $attribute->delete;
    $attribute2->delete;
    is(Koha::Patron::Message::Attributes->find({
        message_name => 'Test_Attribute' }), undef,
       'Deleted the first message attribute.');
    is(Koha::Patron::Message::Attributes->find({
        message_name => 'Test_Attribute2' }), undef,
       'Deleted the second message attribute.');

    $schema->storage->txn_rollback;
};

1;




#!/usr/bin/perl

# Copyright 2017 Koha-Suomi Oy
#
# 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;

use Test::More tests => 7;

use t::lib::Mocks;
use t::lib::TestBuilder;

use C4::Context;

use Koha::Notice::Templates;
use Koha::Patron::Categories;
use Koha::Patron::Message::Attributes;
use Koha::Patron::Message::Transport::Types;
use Koha::Patron::Message::Transports;
use Koha::Patrons;

use File::Temp qw/tempfile/;
use Log::Log4perl;

my $schema  = Koha::Database->new->schema;
my $builder = t::lib::TestBuilder->new;

subtest 'Test class imports' => sub {
    plan tests => 2;

    use_ok('Koha::Patron::Message::Preference');
    use_ok('Koha::Patron::Message::Preferences');
};

subtest 'Test Koha::Patron::Message::Preferences' => sub {
    plan tests => 2;

    $schema->storage->txn_begin;

    my $attribute = build_a_test_attribute();
    my $letter = build_a_test_letter();
    my $mtt = build_a_test_transport_type();
    Koha::Patron::Message::Transport->new({
        message_attribute_id   => $attribute->message_attribute_id,
        message_transport_type => $mtt->message_transport_type,
        is_digest              => 0,
        letter_module          => $letter->module,
        letter_code            => $letter->code,
    })->store;

    subtest 'Test for a patron' => sub {
        plan tests => 3;

        my $patron = build_a_test_patron();
        Koha::Patron::Message::Preference->new({
            borrowernumber       => $patron->borrowernumber,
            message_attribute_id => $attribute->message_attribute_id,
            wants_digest         => 0,
            days_in_advance      => undef,
        })->store;

        my $preference = Koha::Patron::Message::Preferences->find({
            borrowernumber       => $patron->borrowernumber,
            message_attribute_id => $attribute->message_attribute_id
        });
        ok($preference->borrower_message_preference_id > 0,
           'Added a new messaging preference for patron.');

        subtest 'Test set not throwing an exception on duplicate object' => sub {
            plan tests => 1;

            Koha::Patron::Message::Attributes->find({
                message_attribute_id => $attribute->message_attribute_id
            })->set({ takes_days => 1 })->store;
            $preference->set({ days_in_advance => 1 })->store;
            is(ref($preference), 'Koha::Patron::Message::Preference',
             'Updating the preference does not cause duplicate object exception');
        };

        $preference->delete;
        is(Koha::Patron::Message::Preferences->search({
            borrowernumber       => $patron->borrowernumber,
            message_attribute_id => $attribute->message_attribute_id
        })->count, 0, 'Deleted the messaging preference.');
    };

    subtest 'Test for a category' => sub {
        my $category = build_a_test_category();
        Koha::Patron::Message::Preference->new({
            categorycode         => $category->categorycode,
            message_attribute_id => $attribute->message_attribute_id,
            wants_digest         => 0,
            days_in_advance      => undef,
        })->store;

        my $preference = Koha::Patron::Message::Preferences->find({
            categorycode         => $category->categorycode,
            message_attribute_id => $attribute->message_attribute_id
        });
        ok($preference->borrower_message_preference_id > 0,
           'Added a new messaging preference for category.');

        $preference->delete;
        is(Koha::Patron::Message::Preferences->search({
            categorycode         => $category->categorycode,
            message_attribute_id => $attribute->message_attribute_id
        })->count, 0, 'Deleted the messaging preference.');
    };

    $schema->storage->txn_rollback;
};

subtest 'Test Koha::Patron::Message::Preferences->get_options' => sub {
    plan tests => 2;

    subtest 'Test method availability and return value' => sub {
        plan tests => 3;

        ok(Koha::Patron::Message::Preferences->can('get_options'),
            'Method get_options is available.');
        ok(my $options = Koha::Patron::Message::Preferences->get_options,
            'Called get_options successfully.');
        is(ref($options), 'ARRAY', 'get_options returns a ARRAYref');
    };

    subtest 'Make sure options are correct' => sub {
        $schema->storage->txn_begin;
        my $options = Koha::Patron::Message::Preferences->get_options;

        foreach my $option (@$options) {
            my $n = $option->{'message_name'};
            my $attr = Koha::Patron::Message::Attributes->find($option->{'message_attribute_id'});
            is($option->{'message_attribute_id'}, $attr->message_attribute_id,
               '$n: message_attribute_id is set');
            is($option->{'message_name'}, $attr->message_name, '$n: message_name is set');
            is($option->{'takes_days'}, $attr->takes_days, '$n: takes_days is set');
            my $transports = Koha::Patron::Message::Transports->search({
                message_attribute_id => $option->{'message_attribute_id'},
                is_digest => $option->{'has_digest'} || 0,
            });
            while (my $trnzport = $transports->next) {
                is($option->{'has_digest'} || 0, $trnzport->is_digest, '$n: has_digest is set for '.$trnzport->message_transport_type);
                is($option->{'transport_'.$trnzport->message_transport_type}, ' ', '$n: transport_'.$trnzport->message_transport_type.' is set');
            }
        }

        $schema->storage->txn_rollback;
    };
};

subtest 'Add preferences from defaults' => sub {
    plan tests => 3;

    $schema->storage->txn_begin;

    my $patron = build_a_test_patron();
    my ($default, $mtt1, $mtt2) = build_a_test_category_preference({
        patron => $patron,
    });
    ok(Koha::Patron::Message::Preference->new_from_default({
        borrowernumber       => $patron->borrowernumber,
        categorycode         => $patron->categorycode,
        message_attribute_id => $default->message_attribute_id,
    })->store, 'Added a default preference to patron.');
    ok(my $pref = Koha::Patron::Message::Preferences->find({
        borrowernumber       => $patron->borrowernumber,
        message_attribute_id => $default->message_attribute_id,
    }), 'Found the default preference from patron.');
    is(Koha::Patron::Message::Transport::Preferences->search({
        borrower_message_preference_id => $pref->borrower_message_preference_id
    })->count, 2, 'Found the two transport types that we set earlier');

    $schema->storage->txn_rollback;
};

subtest 'Test Koha::Patron::Message::Preference->message_transport_types' => sub {
    plan tests => 4;

    ok(Koha::Patron::Message::Preference->can('message_transport_types'),
       'Method message_transport_types available');

    subtest 'get message_transport_types' => sub {
        plan tests => 5;

        $schema->storage->txn_begin;

        my $patron = build_a_test_patron();
        my ($preference, $mtt1, $mtt2) = build_a_test_complete_preference({
            patron => $patron
        });
        Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
        })->delete;
        Koha::Patron::Message::Transport::Preference->new({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
            message_transport_type => $mtt1->message_transport_type,
        })->store;
        Koha::Patron::Message::Transport::Preference->new({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
            message_transport_type => $mtt2->message_transport_type,
        })->store;
        my $stored_transports = Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
        });
        my $transport1 = Koha::Patron::Message::Transports->find({
            message_attribute_id => $preference->message_attribute_id,
            message_transport_type => $mtt1->message_transport_type,
        });
        my $transport2 = Koha::Patron::Message::Transports->find({
            message_attribute_id => $preference->message_attribute_id,
            message_transport_type => $mtt2->message_transport_type,
        });
        my $transports = $preference->message_transport_types;
        is(keys %{$transports}, $stored_transports->count,
           '->message_transport_types gets correct amount of transport types.');
        is($transports->{$stored_transports->next->message_transport_type},
           $transport1->letter_code, 'Found correct message transport type and letter code.');
        is($transports->{$stored_transports->next->message_transport_type},
           $transport2->letter_code, 'Found correct message transport type and letter code.');
        ok(!$preference->message_transport_types->{'nonexistent'},
           'Didn\'t find nonexistent transport type.');

        subtest 'test logging of warnings by invalid message transport type' => sub {
            plan tests => 2;

            my $log = mytempfile();
            my $conf = mytempfile( <<"HERE"
log4perl.logger.opac = WARN, OPAC
log4perl.appender.OPAC=Log::Log4perl::Appender::TestBuffer
log4perl.appender.OPAC.filename=$log
log4perl.appender.OPAC.mode=append
log4perl.appender.OPAC.layout=SimpleLayout
log4perl.logger.intranet = WARN, INTRANET
log4perl.appender.INTRANET=Log::Log4perl::Appender::TestBuffer
log4perl.appender.INTRANET.filename=$log
log4perl.appender.INTRANET.mode=append
log4perl.appender.INTRANET.layout=SimpleLayout
HERE
            );
            t::lib::Mocks::mock_config('log4perl_conf', $conf);
            my $appenders = Log::Log4perl->appenders;
            my $appender = Log::Log4perl->appenders->{OPAC};

            my $pref = Koha::Patron::Message::Preferences->find(
                $preference->borrower_message_preference_id
            );
            my $transports = $pref->message_transport_types;
            is($appender, undef, 'Nothing in buffer yet');

            my $mtt_new = build_a_test_transport_type();
            Koha::Patron::Message::Transport::Preference->new({
                borrower_message_preference_id =>
                                $pref->borrower_message_preference_id,
                message_transport_type => $mtt_new->message_transport_type,
            })->store;
            $pref = Koha::Patron::Message::Preferences->find(
                $pref->borrower_message_preference_id
            );
            $transports = $pref->message_transport_types;
            $appender = Log::Log4perl->appenders->{OPAC};
            my $name = $pref->message_name;
            my $tt = $mtt_new->message_transport_type;
            like($appender->buffer, qr/WARN - $name has no transport with $tt/,
                 'Logged invalid message transport type');
        };

        $schema->storage->txn_rollback;
    };

    subtest 'set message_transport_types' => sub {
        plan tests => 12;

        $schema->storage->txn_begin;

        my $patron = build_a_test_patron();
        my ($preference, $mtt1, $mtt2) = build_a_test_complete_preference({
            patron => $patron
        });

        my $mtt1_str = $mtt1->message_transport_type;
        my $mtt2_str = $mtt2->message_transport_type;
        # 1/3, use message_transport_types(list)
        Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
        })->delete;
        ok($preference->message_transport_types($mtt1_str, $mtt2_str)->store,
           '1/3 Set returned true.');
        my $stored_transports = Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
            '-or' => [
                message_transport_type => $mtt1_str,
                message_transport_type => $mtt2_str
            ]
        });
        is($stored_transports->count, 2, 'Two transports selected');

        # 2/3, use message_transport_types(ARRAYREF)
        Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
        })->delete;
        ok($preference->message_transport_types([$mtt1_str, $mtt2_str])->store,
           '2/3 Set returned true.');
        $stored_transports = Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
            '-or' => [
                message_transport_type => $mtt1_str,
                message_transport_type => $mtt2_str
            ]
        });
        is($stored_transports->count, 2, 'Two transports selected');

        # 3/3, use set({ message_transport_types => ARRAYREF })
        Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
        })->delete;
        ok($preference->set({
            message_transport_types => [$mtt1_str, $mtt2_str]})->store,
           '3/3 Set returned true.');
        $stored_transports = Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
            '-or' => [
                message_transport_type => $mtt1_str,
                message_transport_type => $mtt2_str
            ]
        });
        is($stored_transports->count, 2, 'Two transports selected');

        # Test email and smsalertnumber validation
        eval { Koha::Patron::Message::Transport::Types->new({
                message_transport_type => 'email'
            })->store };
        eval { Koha::Patron::Message::Transport::Types->new({
                message_transport_type => 'sms'
            })->store };
        Koha::Patron::Message::Transport->new({
            message_attribute_id   => $preference->message_attribute_id,
            message_transport_type => 'email',
            is_digest              => 1
        })->store;
        Koha::Patron::Message::Transport->new({
            message_attribute_id   => $preference->message_attribute_id,
            message_transport_type => 'sms',
            is_digest              => 1
        })->store;
        $patron->set({ email => '', smsalertnumber => '' })->store;
        eval {
            $preference->message_transport_types('email')->store;
        };
        is (ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with invalid message_transport_type'
            .' => Koha::Exceptions::BadParameter');
        is ($@->parameter, 'message_transport_types', 'The previous exception '
            .' tells us it was the message_transport_types');
        like ($@->error, qr/^Patron has not set email address/, 'Exception '
            .' is because of patron has not set email address.');
        eval {
            $preference->message_transport_types('sms')->store;
        };
        is (ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with invalid message_transport_type'
            .' => Koha::Exceptions::BadParameter');
        is ($@->parameter, 'message_transport_types', 'The previous exception '
            .' tells us it was the message_transport_types');
        like ($@->error, qr/^Patron has not set sms number/, 'Exception '
            .' is because of patron has not set sms number.');

        $schema->storage->txn_rollback;
    };

    subtest 'new message_transport_types' => sub {
        plan tests => 3;

        $schema->storage->txn_begin;

        my $patron    = build_a_test_patron();
        my $letter    = build_a_test_letter();
        my $attribute = build_a_test_attribute();
        my $mtt       = build_a_test_transport_type();
        Koha::Patron::Message::Transport->new({
            message_attribute_id   => $attribute->message_attribute_id,
            message_transport_type => $mtt->message_transport_type,
            is_digest              => 0,
            letter_module          => $letter->module,
            letter_code            => $letter->code,
        })->store;
        ok(my $preference = Koha::Patron::Message::Preference->new({
            borrowernumber => $patron->borrowernumber,
            message_attribute_id => $attribute->message_attribute_id,
            wants_digest => 0,
            days_in_advance => undef,
            message_transport_types => $mtt->message_transport_type,
        })->store, 'Added a new messaging preference and transport types to patron.');
        ok($preference->message_transport_types->{$mtt->message_transport_type},
           'The transport type is stored in the object.');
        my $stored_transports = Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $preference->borrower_message_preference_id,
        });
        is($stored_transports->next->message_transport_type, $mtt->message_transport_type,
           'The transport type is stored in the database.');

        $schema->storage->txn_rollback;
    };
};

subtest 'Test Koha::Patron::Message::Preference->message_name' => sub {
    plan tests => 1;

    $schema->storage->txn_begin;

    my $patron      = build_a_test_patron();
    my $attribute   = build_a_test_attribute();
    my ($preference, $mtt1, $mtt2) = build_a_test_complete_preference({
        patron => $patron,
        attr   => $attribute,
    });
    my $message_name_pref = Koha::Patron::Message::Preferences->search_with_message_name({
        borrowernumber => $patron->{'borrowernumber'},
        message_name => $attribute->message_name,
    })->next;
    is($message_name_pref->message_name, $attribute->message_name, "Found preference with message_name");

    $schema->storage->txn_rollback;
};

subtest 'Test adding a new preference with invalid parameters' => sub {
    plan tests => 4;

    subtest 'Missing parameters' => sub {
        plan tests => 1;

        eval { Koha::Patron::Message::Preference->new->store };
        is(ref $@, 'Koha::Exceptions::MissingParameter',
            'Adding a message preference without parameters'
            .' => Koha::Exceptions::MissingParameter');
    };

    subtest 'Too many parameters' => sub {
        plan tests => 1;

        $schema->storage->txn_begin;

        my $patron = build_a_test_patron();
        eval { Koha::Patron::Message::Preference->new({
            borrowernumber => $patron->borrowernumber,
            categorycode   => $patron->categorycode,
        })->store };
        is(ref $@, 'Koha::Exceptions::TooManyParameters',
            'Adding a message preference for both borrowernumber and categorycode'
            .' => Koha::Exceptions::TooManyParameters');

        $schema->storage->txn_rollback;
    };

    subtest 'Bad parameter' => sub {
        plan tests => 22;

        $schema->storage->txn_begin;

        eval { Koha::Patron::Message::Preference->new({
                borrowernumber => -999,
            })->store };
        is(ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with invalid borrowernumber'
            .' => Koha::Exceptions::BadParameter');
        is ($@->parameter, 'borrowernumber', 'The previous exception tells us it'
            .' was the borrowernumber.');

        eval { Koha::Patron::Message::Preference->new({
                categorycode => 'nonexistent',
            })->store };
        is(ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with invalid categorycode'
            .' => Koha::Exceptions::BadParameter');
        is($@->parameter, 'categorycode', 'The previous exception tells us it'
            .' was the categorycode.');

        my $attribute = build_a_test_attribute({ takes_days => 0 });
        my $patron    = build_a_test_patron();
        eval { Koha::Patron::Message::Preference->new({
                borrowernumber => $patron->borrowernumber,
                message_attribute_id => $attribute->message_attribute_id,
                days_in_advance => 10,
            })->store };
        is(ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with days in advance option when not'
            .' available => Koha::Exceptions::BadParameter');
        is($@->parameter, 'days_in_advance', 'The previous exception tells us it'
            .' was the days_in_advance.');

        $attribute->set({ takes_days => 1 })->store;
        eval { Koha::Patron::Message::Preference->new({
                borrowernumber => $patron->borrowernumber,
                message_attribute_id => $attribute->message_attribute_id,
                days_in_advance => 31,
            })->store };
        is(ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with days in advance option too large'
            .' => Koha::Exceptions::BadParameter');
        is($@->parameter, 'days_in_advance', 'The previous exception tells us it'
            .' was the days_in_advance.');

        eval { Koha::Patron::Message::Preference->new({
                borrowernumber => $patron->borrowernumber,
                message_transport_types => ['nonexistent']
            })->store };
        is (ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with invalid message_transport_type'
            .' => Koha::Exceptions::BadParameter');
        is ($@->parameter, 'message_transport_types', 'The previous exception '
            .'tells us it was the message_transport_types.');

        my $mtt_new = build_a_test_transport_type();
        eval {
            Koha::Patron::Message::Preference->new({
                borrowernumber => $patron->borrowernumber,
                message_attribute_id => $attribute->message_attribute_id,
                message_transport_types => [$mtt_new->message_transport_type],
                wants_digest => 1,
            })->store };
        is (ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with invalid message_transport_type'
           .' => Koha::Exceptions::BadParameter');
        is ($@->parameter, 'message_transport_types', 'The previous exception '
            .'tells us it was the message_transport_types.');
        like ($@->error, qr/^No transport configured/, 'Exception is because of '
            .'given message_transport_type is not a valid option.');

        eval {
            Koha::Patron::Message::Preference->new({
                borrowernumber => $patron->borrowernumber,
                message_attribute_id => $attribute->message_attribute_id,
                message_transport_types => [],
                wants_digest => 1,
            })->store };
        is (ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with invalid message_transport_type'
            .' => Koha::Exceptions::BadParameter');
        is ($@->parameter, 'wants_digest', 'The previous exception tells us it'
            .' was the wants_digest');
        like ($@->error, qr/^Digest cannot be selected/, 'Exception s because of'
            .' given digest is not available for this transport.');

        eval {
            Koha::Patron::Message::Preference->new({
                borrowernumber => $patron->borrowernumber,
                message_attribute_id => $attribute->message_attribute_id,
                message_transport_types => [],
                wants_digest => 0,
            })->store };
        is (ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with invalid message_transport_type'
            .' => Koha::Exceptions::BadParameter');
        is ($@->parameter, 'wants_digest', 'The previous exception tells us it'
            .' was the wants_digest');
        like ($@->error, qr/^Digest must be selected/, 'Exception s because of'
            .' digest has to be on for this transport.');

        eval {
            Koha::Patron::Message::Preference->new({
                borrowernumber => $patron->borrowernumber,
                message_attribute_id => -1,
                message_transport_types => [],
            })->store };
        is (ref $@, 'Koha::Exceptions::BadParameter',
            'Adding a message preference with invalid message_transport_type'
            .' => Koha::Exceptions::BadParameter');
        is ($@->parameter, 'message_attribute_id', 'The previous exception tells'
            .' us it was the message_attribute_id');
        like ($@->error, qr/^Message attribute with id -1 not found/, 'Exception '
            .' is because of given message attribute id is not found.');

        $schema->storage->txn_rollback;
    };

    subtest 'Duplicate object' => sub {
        plan tests => 2;

        $schema->storage->txn_begin;

        my $attribute = build_a_test_attribute();
        my $letter = build_a_test_letter();
        my $mtt = build_a_test_transport_type();
        Koha::Patron::Message::Transport->new({
            message_attribute_id   => $attribute->message_attribute_id,
            message_transport_type => $mtt->message_transport_type,
            is_digest              => 0,
            letter_module          => $letter->module,
            letter_code            => $letter->code,
        })->store;
        my $patron    = build_a_test_patron();
        my $preference = Koha::Patron::Message::Preference->new({
            borrowernumber => $patron->borrowernumber,
            message_attribute_id => $attribute->message_attribute_id,
            wants_digest => 0,
            days_in_advance => undef,
        })->store;
        ok($preference->borrower_message_preference_id,
           'Added a new messaging preference for patron.');
        eval { Koha::Patron::Message::Preference->new({
            borrowernumber => $patron->borrowernumber,
            message_attribute_id => $attribute->message_attribute_id,
            wants_digest => 0,
            days_in_advance => undef,
        })->store };
        is(ref $@, 'Koha::Exceptions::DuplicateObject',
                'Adding a duplicate preference'
                .' => Koha::Exceptions::DuplicateObject');

        $schema->storage->txn_rollback;
    };
};

sub build_a_test_attribute {
    my ($params) = @_;

    $params->{takes_days} = $params->{takes_days} && $params->{takes_days} > 0
                            ? 1 : 0;

    my $attribute = $builder->build({
        source => 'MessageAttribute',
        value => $params,
    });

    return Koha::Patron::Message::Attributes->find(
        $attribute->{message_attribute_id}
    );
}

sub build_a_test_category {
    my $categorycode   = $builder->build({
        source => 'Category' })->{categorycode};

    return Koha::Patron::Categories->find($categorycode);
}

sub build_a_test_letter {
    my ($params) = @_;

    my $mtt = $params->{mtt} ? $params->{mtt} : 'email';
    my $branchcode     = $builder->build({
        source => 'Branch' })->{branchcode};
    my $letter = $builder->build({
        source => 'Letter',
        value => {
            branchcode => '',
            is_html => 0,
            message_transport_type => $mtt
        }
    });

    return Koha::Notice::Templates->find({
        module     => $letter->{module},
        code       => $letter->{code},
        branchcode => $letter->{branchcode},
    });
}

sub build_a_test_patron {
    my $categorycode   = $builder->build({
        source => 'Category' })->{categorycode};
    my $branchcode     = $builder->build({
        source => 'Branch' })->{branchcode};
    my $borrowernumber = $builder->build({
        source => 'Borrower' })->{borrowernumber};

    return Koha::Patrons->find($borrowernumber);
}

sub build_a_test_transport_type {
    my $mtt = $builder->build({
        source => 'MessageTransportType' });

    return Koha::Patron::Message::Transport::Types->find(
        $mtt->{message_transport_type}
    );
}

sub build_a_test_category_preference {
    my ($params) = @_;

    my $patron = $params->{patron};
    my $attr = $params->{attr}
                    ? $params->{attr}
                    : build_a_test_attribute($params->{days_in_advance});

    my $letter = $params->{letter} ? $params->{letter} : build_a_test_letter();
    my $mtt1 = $params->{mtt1} ? $params->{mtt1} : build_a_test_transport_type();
    my $mtt2 = $params->{mtt2} ? $params->{mtt2} : build_a_test_transport_type();

    Koha::Patron::Message::Transport->new({
        message_attribute_id   => $attr->message_attribute_id,
        message_transport_type => $mtt1->message_transport_type,
        is_digest              => $params->{digest} ? 1 : 0,
        letter_module          => $letter->module,
        letter_code            => $letter->code,
    })->store;

    Koha::Patron::Message::Transport->new({
        message_attribute_id   => $attr->message_attribute_id,
        message_transport_type => $mtt2->message_transport_type,
        is_digest              => $params->{digest} ? 1 : 0,
        letter_module          => $letter->module,
        letter_code            => $letter->code,
    })->store;

    my $default = Koha::Patron::Message::Preference->new({
        categorycode         => $patron->categorycode,
        message_attribute_id => $attr->message_attribute_id,
        wants_digest         => $params->{digest} ? 1 : 0,
        days_in_advance      => $params->{days_in_advance}
                                 ? $params->{days_in_advance} : undef,
    })->store;

    Koha::Patron::Message::Transport::Preference->new({
        borrower_message_preference_id => $default->borrower_message_preference_id,
        message_transport_type         => $mtt1->message_transport_type,
    })->store;
    Koha::Patron::Message::Transport::Preference->new({
        borrower_message_preference_id => $default->borrower_message_preference_id,
        message_transport_type         => $mtt2->message_transport_type,
    })->store;

    return ($default, $mtt1, $mtt2);
}

sub build_a_test_complete_preference {
    my ($params) = @_;

    my ($default, $mtt1, $mtt2) = build_a_test_category_preference($params);
    my $patron = $params->{patron};
    $patron->set_default_messaging_preferences;
    return (Koha::Patron::Message::Preferences->search({
        borrowernumber => $patron->borrowernumber
    })->next, $mtt1, $mtt2);
}

sub mytempfile {
    my ( $fh, $fn ) = tempfile( SUFFIX => '.logger.test', UNLINK => 1 );
    print $fh $_[0]//'';
    close $fh;
    return $fn;
}

1;




#!/usr/bin/perl

# Copyright 2017 Koha-Suomi Oy
#
# 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;

use Test::More tests => 2;

use t::lib::Mocks;
use t::lib::TestBuilder;

use Koha::Notice::Templates;
use Koha::Patron::Categories;
use Koha::Patron::Message::Attributes;
use Koha::Patron::Message::Preferences;
use Koha::Patron::Message::Transport::Types;
use Koha::Patron::Message::Transports;
use Koha::Patrons;

my $schema  = Koha::Database->new->schema;
my $builder = t::lib::TestBuilder->new;

subtest 'Test class imports' => sub {
    plan tests => 2;

    use_ok('Koha::Patron::Message::Transport::Preference');
    use_ok('Koha::Patron::Message::Transport::Preferences');
};

subtest 'Test Koha::Patron::Message::Transport::Preferences' => sub {
    plan tests => 2;

    $schema->storage->txn_begin;

    my $attribute = build_a_test_attribute();
    my $mtt       = build_a_test_transport_type();
    my $letter    = build_a_test_letter({
        mtt => $mtt->message_transport_type
    });
    Koha::Patron::Message::Transport->new({
        message_attribute_id   => $attribute->message_attribute_id,
        message_transport_type => $mtt->message_transport_type,
        is_digest              => 0,
        letter_module          => $letter->module,
        letter_code            => $letter->code,
    })->store;

    subtest 'For a patron' => sub {
        my $patron    = build_a_test_patron();
        my $preference = Koha::Patron::Message::Preference->new({
            borrowernumber       => $patron->borrowernumber,
            message_attribute_id => $attribute->message_attribute_id,
            wants_digest         => 0,
            days_in_advance      => undef,
        })->store;

        my $pref_id = $preference->borrower_message_preference_id;
        my $transport_pref = Koha::Patron::Message::Transport::Preference->new({
            borrower_message_preference_id => $pref_id,
            message_transport_type => $mtt->message_transport_type,
        })->store;
        is(ref($transport_pref), 'Koha::Patron::Message::Transport::Preference',
           'Added a new messaging transport preference for patron.');

        $transport_pref->delete;
        is(Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $pref_id,
            message_transport_type => $mtt->message_transport_type,
        })->count, 0, 'Deleted the messaging transport preference.');
    };

    subtest 'For a category' => sub {
        my $category   = build_a_test_category();
        my $preference = Koha::Patron::Message::Preference->new({
            categorycode         => $category->categorycode,
            message_attribute_id => $attribute->message_attribute_id,
            wants_digest         => 0,
            days_in_advance      => undef,
        })->store;

        my $pref_id = $preference->borrower_message_preference_id;
        my $transport_pref = Koha::Patron::Message::Transport::Preference->new({
            borrower_message_preference_id => $pref_id,
            message_transport_type => $mtt->message_transport_type,
        })->store;
        is(ref($transport_pref), 'Koha::Patron::Message::Transport::Preference',
           'Added a new messaging transport preference for category.');

        $transport_pref->delete;
        is(Koha::Patron::Message::Transport::Preferences->search({
            borrower_message_preference_id => $pref_id,
            message_transport_type => $mtt->message_transport_type,
        })->count, 0, 'Deleted the messaging transport preference.');
    };

    $schema->storage->txn_rollback;
};

sub build_a_test_attribute {
    my ($params) = @_;

    $params->{takes_days} = $params->{takes_days} && $params->{takes_days} > 0
                            ? 1 : 0;

    my $attribute = $builder->build({
        source => 'MessageAttribute',
        value => $params,
    });

    return Koha::Patron::Message::Attributes->find(
        $attribute->{message_attribute_id}
    );
}

sub build_a_test_category {
    my $categorycode   = $builder->build({
        source => 'Category' })->{categorycode};

    return Koha::Patron::Categories->find($categorycode);
}

sub build_a_test_letter {
    my ($params) = @_;

    my $mtt = $params->{mtt} ? $params->{mtt} : 'email';
    my $branchcode     = $builder->build({
        source => 'Branch' })->{branchcode};
    my $letter = $builder->build({
        source => 'Letter',
        value => {
            branchcode => '',
            is_html => 0,
            message_transport_type => $mtt
        }
    });

    return Koha::Notice::Templates->find({
        module => $letter->{module},
        code   => $letter->{code},
        branchcode => $letter->{branchcode},
    });
}

sub build_a_test_patron {
    my $categorycode   = $builder->build({
        source => 'Category' })->{categorycode};
    my $branchcode     = $builder->build({
        source => 'Branch' })->{branchcode};
    my $borrowernumber = $builder->build({
        source => 'Borrower' })->{borrowernumber};

    return Koha::Patrons->find($borrowernumber);
}

sub build_a_test_transport_type {
    my $mtt = $builder->build({
        source => 'MessageTransportType' });

    return Koha::Patron::Message::Transport::Types->find(
        $mtt->{message_transport_type}
    );
}

1;




#!/usr/bin/perl

# Copyright 2017 Koha-Suomi Oy
#
# 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;

use Test::More tests => 2;

use Koha::Database;

my $schema  = Koha::Database->new->schema;

subtest 'Test class imports' => sub {
    plan tests => 2;

    use_ok('Koha::Patron::Message::Transport::Type');
    use_ok('Koha::Patron::Message::Transport::Types');
};

subtest 'Test Koha::Patron::Message::Transport::Types' => sub {
    plan tests => 2;

    $schema->storage->txn_begin;

    my $transport_type = Koha::Patron::Message::Transport::Type->new({
        message_transport_type => 'test'
    })->store;

    is($transport_type->message_transport_type, 'test',
       'Added a new message transport type.');

    $transport_type->delete;
    is(Koha::Patron::Message::Transport::Types->find('test'), undef,
       'Deleted the message transport type.');

    $schema->storage->txn_rollback;
};

1;




#!/usr/bin/perl

# Copyright 2017 Koha-Suomi Oy
#
# 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;

use Test::More tests => 2;

use t::lib::TestBuilder;

use Koha::Notice::Templates;
use Koha::Patron::Message::Attributes;
use Koha::Patron::Message::Transport::Types;

my $schema  = Koha::Database->new->schema;
my $builder = t::lib::TestBuilder->new;

subtest 'Test class imports' => sub {
    plan tests => 2;

    use_ok('Koha::Patron::Message::Transport');
    use_ok('Koha::Patron::Message::Transports');
};

subtest 'Test Koha::Patron::Message::Transports' => sub {
    plan tests => 2;

    $schema->storage->txn_begin;

    my $attribute = build_a_test_attribute();
    my $mtt       = build_a_test_transport_type();
    my $letter    = build_a_test_letter({
        mtt => $mtt->message_transport_type
    });

    my $transport = Koha::Patron::Message::Transport->new({
        message_attribute_id   => $attribute->message_attribute_id,
        message_transport_type => $mtt->message_transport_type,
        is_digest              => 0,
        letter_module          => $letter->module,
        letter_code            => $letter->code,
    })->store;

    is($transport->message_attribute_id, $attribute->message_attribute_id,
       'Added a new messaging transport.');

    $transport->delete;
    is(Koha::Patron::Message::Transports->search({
        message_attribute_id => $attribute->message_attribute_id,
        message_transport_type => $mtt->message_transport_type,
        is_digest => 0
    })->count, 0, 'Deleted the messaging transport.');

    $schema->storage->txn_rollback;
};

sub build_a_test_attribute {
    my ($params) = @_;

    $params->{takes_days} = $params->{takes_days} && $params->{takes_days} > 0
                            ? 1 : 0;

    my $attribute = $builder->build({
        source => 'MessageAttribute',
        value => $params,
    });

    return Koha::Patron::Message::Attributes->find(
        $attribute->{message_attribute_id}
    );
}

sub build_a_test_letter {
    my ($params) = @_;

    my $mtt = $params->{mtt} ? $params->{mtt} : 'email';
    my $branchcode     = $builder->build({
        source => 'Branch' })->{branchcode};
    my $letter = $builder->build({
        source => 'Letter',
        value => {
            branchcode => '',
            is_html => 0,
            message_transport_type => $mtt
        }
    });

    return Koha::Notice::Templates->find({
        module => $letter->{module},
        code   => $letter->{code},
        branchcode => $letter->{branchcode},
    });
}

sub build_a_test_transport_type {
    my $mtt = $builder->build({
        source => 'MessageTransportType' });

    return Koha::Patron::Message::Transport::Types->find(
        $mtt->{message_transport_type}
    );
}

1;

Return to bug 17499

Lines 43-48 use Koha::Patron::HouseboundProfile; Link Here

(-)a/Koha/Patron.pm (+42 lines)
43	use Koha::Patron::HouseboundRole;	43	use Koha::Patron::HouseboundRole;
44	use Koha::Patron::Images;	44	use Koha::Patron::Images;
45	use Koha::Patron::Modifications;	45	use Koha::Patron::Modifications;
		46	use Koha::Patron::Message::Preferences;
46	use Koha::Patron::Relationships;	47	use Koha::Patron::Relationships;
47	use Koha::Patrons;	48	use Koha::Patrons;
48	use Koha::Plugins;	49	use Koha::Plugins;
Lines 1627-1632 sub get_extended_attribute { Link Here
1627	return $attribute->next;	1628	return $attribute->next;
1628	}	1629	}
1629		1630
		1631	=head3 set_default_messaging_preferences
		1632
		1633	$patron->set_default_messaging_preferences
		1634
		1635	Sets default messaging preferences on patron.
		1636
		1637	See Koha::Patron::Message::Preference(s) for more documentation, especially on
		1638	thrown exceptions.
		1639
		1640	=cut
		1641
		1642	sub set_default_messaging_preferences {
		1643	my ($self, $categorycode) = @_;
		1644
		1645	my $options = Koha::Patron::Message::Preferences->get_options;
		1646
		1647	foreach my $option (@$options) {
		1648	# Check that this option has preference configuration for this category
		1649	unless (Koha::Patron::Message::Preferences->search({
		1650	message_attribute_id => $option->{message_attribute_id},
		1651	categorycode => $categorycode \|\| $self->categorycode,
		1652	})->count) {
		1653	next;
		1654	}
		1655
		1656	# Delete current setting
		1657	Koha::Patron::Message::Preferences->search({
		1658	borrowernumber => $self->borrowernumber,
		1659	message_attribute_id => $option->{message_attribute_id},
		1660	})->delete;
		1661
		1662	Koha::Patron::Message::Preference->new_from_default({
		1663	borrowernumber => $self->borrowernumber,
		1664	categorycode => $categorycode \|\| $self->categorycode,
		1665	message_attribute_id => $option->{message_attribute_id},
		1666	});
		1667	}
		1668
		1669	return $self;
		1670	}
		1671
1630	=head3 to_api	1672	=head3 to_api
1631		1673
1632	my $json = $patron->to_api;	1674	my $json = $patron->to_api;

Line 0 Link Here

(-)a/Koha/Patron/Message/Attribute.pm (+50 lines)
	1	package Koha::Patron::Message::Attribute;
	2
	3	# Copyright Koha-Suomi Oy 2016
	4	#
	5	# This file is part of Koha.
	6	#
	7	# Koha is free software; you can redistribute it and/or modify it under the
	8	# terms of the GNU General Public License as published by the Free Software
	9	# Foundation; either version 3 of the License, or (at your option) any later
	10	# version.a
	11	#
	12	# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
	13	# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	14	# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License along
	17	# with Koha; if not, write to the Free Software Foundation, Inc.,
	18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	19
	20	use Modern::Perl;
	21
	22	use Koha::Database;
	23
	24	use base qw(Koha::Object);
	25
	26	=head1 NAME
	27
	28	Koha::Patron::Message::Attribute - Koha Patron Message Attribute object class
	29
	30	=head1 API
	31
	32	=head2 Class Methods
	33
	34	=cut
	35
	36	=head3 type
	37
	38	=cut
	39
	40	sub _type {
	41	return 'MessageAttribute';
	42	}
	43
	44	=head1 AUTHOR
	45
	46	Lari Taskula <lari.taskula@hypernova.fi>
	47
	48	=cut
	49
	50	1;

Line 0 Link Here

(-)a/Koha/Patron/Message/Attributes.pm (+55 lines)
	1	package Koha::Patron::Message::Attributes;
	2
	3	# Copyright Koha-Suomi Oy 2016
	4	#
	5	# This file is part of Koha.
	6	#
	7	# Koha is free software; you can redistribute it and/or modify it under the
	8	# terms of the GNU General Public License as published by the Free Software
	9	# Foundation; either version 3 of the License, or (at your option) any later
	10	# version.
	11	#
	12	# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
	13	# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	14	# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License along
	17	# with Koha; if not, write to the Free Software Foundation, Inc.,
	18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	19
	20	use Modern::Perl;
	21
	22	use Koha::Database;
	23	use Koha::Patron::Message::Attribute;
	24
	25	use base qw(Koha::Objects);
	26
	27	=head1 NAME
	28
	29	Koha::Patron::Message::Attributes - Koha Patron Message Attributes object class
	30
	31	=head1 API
	32
	33	=head2 Class Methods
	34
	35	=cut
	36
	37	=head3 type
	38
	39	=cut
	40
	41	sub _type {
	42	return 'MessageAttribute';
	43	}
	44
	45	sub object_class {
	46	return 'Koha::Patron::Message::Attribute';
	47	}
	48
	49	=head1 AUTHOR
	50
	51	Lari Taskula <lari.taskula@hypernova.fi>
	52
	53	=cut
	54
	55	1;

Line 0 Link Here

(-)a/Koha/Patron/Message/Preference.pm (+473 lines)
		1	package Koha::Patron::Message::Preference;
		2
		3	# Copyright Koha-Suomi Oy 2016
		4	#
		5	# This file is part of Koha.
		6	#
		7	# Koha is free software; you can redistribute it and/or modify it under the
		8	# terms of the GNU General Public License as published by the Free Software
		9	# Foundation; either version 3 of the License, or (at your option) any later
		10	# version.a
		11	#
		12	# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
		13	# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
		14	# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
		15	#
		16	# You should have received a copy of the GNU General Public License along
		17	# with Koha; if not, write to the Free Software Foundation, Inc.,
		18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
		19
		20	use Modern::Perl;
		21
		22	use Koha::Database;
		23	use Koha::Exceptions;
		24	use Koha::Patron::Categories;
		25	use Koha::Patron::Message::Attributes;
		26	use Koha::Patron::Message::Preferences;
		27	use Koha::Patron::Message::Transport::Preferences;
		28	use Koha::Patron::Message::Transport::Types;
		29	use Koha::Patron::Message::Transports;
		30	use Koha::Patrons;
		31
		32	use base qw(Koha::Object);
		33
		34	=head1 NAME
		35
		36	Koha::Patron::Message::Preference - Koha Patron Message Preference object class
		37
		38	=head1 API
		39
		40	=head2 Class Methods
		41
		42	=cut
		43
		44	=head3 new
		45
		46	my $preference = Koha::Patron::Message::Preference->new({
		47	borrowernumber => 123,
		48	#categorycode => 'ABC',
		49	message_attribute_id => 4,
		50	message_transport_types => ['email', 'sms'], # see documentation below
		51	wants_digest => 1,
		52	days_in_advance => 7,
		53	});
		54
		55	Takes either borrowernumber or categorycode, but not both.
		56
		57	days_in_advance may not be available. See message_attributes table for takes_days
		58	configuration.
		59
		60	wants_digest may not be available. See message_transports table for is_digest
		61	configuration.
		62
		63	You can instantiate a new object without custom validation errors, but when
		64	storing, validation may throw exceptions. See C<validate()> for more
65	documentation.
66
67	C<message_transport_types> is a parameter that is not actually a column in this
68	Koha-object. Given this parameter, the message transport types will be added as
69	related transport types for this object. For get and set, you can access them via
70	subroutine C<message_transport_types()> in this class.
71
72	=cut
73
74	sub new {
75	my ($class, $params) = @_;
76
77	my $types = $params->{'message_transport_types'};
78	delete $params->{'message_transport_types'};
79
80	my $self = $class->SUPER::new($params);
81
82	$self->_set_message_transport_types($types);
83
84	return $self;
85	}
86
87	=head3 new_from_default
88
89	my $preference = Koha::Patron::Message::Preference->new_from_default({
90	borrowernumber => 123,
91	categorycode => 'ABC', # if not given, patron's categorycode will be used
92	message_attribute_id => 1,
93	});
94
95	NOTE: This subroutine initializes and STORES the object (in order to set
96	message transport types for the preference), so no need to call ->store when
97	preferences are initialized via this method.
98
99	Stores default messaging preference for C<categorycode> to patron for given
100	C<message_attribute_id>.
101
102	Throws Koha::Exceptions::MissingParameter if any of following is missing:
103	- borrowernumber
104	- message_attribute_id
105
106	Throws Koha::Exceptions::ObjectNotFound if default preferences are not found.
107
108	=cut
109
110	sub new_from_default {
111	my ($class, $params) = @_;
112
113	my @required = qw(borrowernumber message_attribute_id);
114	foreach my $p (@required) {
115	Koha::Exceptions::MissingParameter->throw(
116	error => 'Missing required parameter.',
117	parameter => $p,
118	) unless exists $params->{$p};
119	}
120	unless ($params->{'categorycode'}) {
121	my $patron = Koha::Patrons->find($params->{borrowernumber});
122	$params->{'categorycode'} = $patron->categorycode;
123	}
124
125	my $default = Koha::Patron::Message::Preferences->find({
126	categorycode => $params->{'categorycode'},
127	message_attribute_id => $params->{'message_attribute_id'},
128	});
129	Koha::Exceptions::ObjectNotFound->throw(
130	error => 'Default messaging preference for given categorycode and'
131	.' message_attribute_id cannot be found.',
132	) unless $default;
133	$default = $default->unblessed;
134
135	# Add a new messaging preference for patron
136	my $self = $class->SUPER::new({
137	borrowernumber => $params->{'borrowernumber'},
138	message_attribute_id => $default->{'message_attribute_id'},
139	days_in_advance => $default->{'days_in_advance'},
140	wants_digest => $default->{'wants_digest'},
141	})->store;
142
143	# Set default messaging transport types
144	my $default_transport_types =
145	Koha::Patron::Message::Transport::Preferences->search({
146	borrower_message_preference_id =>
147	$default->{'borrower_message_preference_id'}
148	});
149	while (my $transport = $default_transport_types->next) {
150	Koha::Patron::Message::Transport::Preference->new({
151	borrower_message_preference_id => $self->borrower_message_preference_id,
152	message_transport_type => $transport->message_transport_type,
153	})->store;
154	}
155
156	return $self;
157	}
158
159	=head3 message_name
160
161	$preference->message_name
162
163	Gets message_name for this messaging preference.
164
165	Setter not implemented.
166
167	=cut
168
169	sub message_name {
170	my ($self) = @_;
171
172	if ($self->{'_message_name'}) {
173	return $self->{'_message_name'};
174	}
175	$self->{'_message_name'} = Koha::Patron::Message::Attributes->find({
176	message_attribute_id => $self->message_attribute_id,
177	})->message_name;
178	return $self->{'_message_name'};
179	}
180
181	=head3 message_transport_types
182
183	$preference->message_transport_types
184	Returns a HASHREF of message transport types for this messaging preference, e.g.
185	if ($preference->message_transport_types->{'email'}) {
186	# email is one of the transport preferences
187	}
188
189	$preference->message_transport_types('email', 'sms');
190	Sets the given message transport types for this messaging preference
191
192	=cut
193
194	sub message_transport_types {
195	my $self = shift;
196
197	unless (@_) {
198	if ($self->{'_message_transport_types'}) {
199	return $self->{'_message_transport_types'};
200	}
201	map {
202	my $transport = Koha::Patron::Message::Transports->find({
203	message_attribute_id => $self->message_attribute_id,
204	message_transport_type => $_->message_transport_type,
205	is_digest => $self->wants_digest
206	});
207	unless ($transport) {
208	my $logger = Koha::Logger->get;
209	$logger->warn(
210	$self->message_name . ' has no transport with '.
211	$_->message_transport_type . ' (digest: '.
212	($self->wants_digest ? 'yes':'no').').'
213	);
214	}
215	$self->{'_message_transport_types'}->{$_->message_transport_type}
216	= $transport ? $transport->letter_code : ' ';
217	}
218	Koha::Patron::Message::Transport::Preferences->search({
219	borrower_message_preference_id => $self->borrower_message_preference_id,
220	})->as_list;
221	return $self->{'_message_transport_types'} \|\| {};
222	}
223	else {
224	$self->_set_message_transport_types(@_);
225	return $self;
226	}
227	}
228
229	=head3 set
230
231	$preference->set({
232	message_transport_types => ['sms', 'phone'],
233	wants_digest => 0,
234	})->store;
235
236	Sets preference object values and additionally message_transport_types if given.
237
238	=cut
239
240	sub set {
241	my ($self, $params) = @_;
242
243	my $mtt = $params->{'message_transport_types'};
244	delete $params->{'message_transport_types'};
245
246	$self->SUPER::set($params) if $params;
247	if ($mtt) {
248	$self->message_transport_types($mtt);
249	}
250
251	return $self;
252	}
253
254	=head3 store
255
256	Makes a validation before actual Koha::Object->store so that proper exceptions
257	can be thrown. See C<validate()> for documentation about exceptions.
258
259	=cut
260
261	sub store {
262	my $self = shift;
263
264	$self->validate->SUPER::store(@_);
265
266	# store message transport types
267	if (exists $self->{'_message_transport_types'}) {
268	Koha::Patron::Message::Transport::Preferences->search({
269	borrower_message_preference_id =>
270	$self->borrower_message_preference_id,
271	})->delete;
272	foreach my $type (keys %{$self->{'_message_transport_types'}}) {
273	Koha::Patron::Message::Transport::Preference->new({
274	borrower_message_preference_id =>
275	$self->borrower_message_preference_id,
276	message_transport_type => $type,
277	})->store;
278	}
279	}
280
281	return $self;
282	}
283
284	=head3 validate
285
286	Makes a basic validation for object.
287
288	Throws following exceptions regarding parameters.
289	- Koha::Exceptions::MissingParameter
290	- Koha::Exceptions::TooManyParameters
291	- Koha::Exceptions::BadParameter
292
293	See $_->parameter to identify the parameter causing the exception.
294
295	Throws Koha::Exceptions::DuplicateObject if this preference already exists.
296
297	Returns Koha::Patron::Message::Preference object.
298
299	=cut
300
301	sub validate {
302	my ($self) = @_;
303
304	if ($self->borrowernumber && $self->categorycode) {
305	Koha::Exceptions::TooManyParameters->throw(
306	error => 'Both borrowernumber and category given, only one accepted',
307	parameter => ['borrowernumber', 'categorycode'],
308	);
309	}
310	if (!$self->borrowernumber && !$self->categorycode) {
311	Koha::Exceptions::MissingParameter->throw(
312	error => 'borrowernumber or category required, none given',
313	parameter => ['borrowernumber', 'categorycode'],
314	);
315	}
316	if ($self->borrowernumber) {
317	Koha::Exceptions::BadParameter->throw(
318	error => 'Patron not found.',
319	parameter => 'borrowernumber',
320	) unless Koha::Patrons->find($self->borrowernumber);
321	}
322	if ($self->categorycode) {
323	Koha::Exceptions::BadParameter->throw(
324	error => 'Category not found.',
325	parameter => 'categorycode',
326	) unless Koha::Patron::Categories->find($self->categorycode);
327	}
328
329	if (!$self->in_storage) {
330	my $previous = Koha::Patron::Message::Preferences->search({
331	borrowernumber => $self->borrowernumber,
332	categorycode => $self->categorycode,
333	message_attribute_id => $self->message_attribute_id,
334	});
335	if ($previous->count) {
336	Koha::Exceptions::DuplicateObject->throw(
337	error => 'A preference for this borrower/category and'
338	.' message_attribute_id already exists',
339	);
340	}
341	}
342
343	my $attr = Koha::Patron::Message::Attributes->find(
344	$self->message_attribute_id
345	);
346	unless ($attr) {
347	Koha::Exceptions::BadParameter->throw(
348	error => 'Message attribute with id '.$self->message_attribute_id
349	.' not found',
350	parameter => 'message_attribute_id'
351	);
352	}
353	if (defined $self->days_in_advance) {
354	if ($attr && $attr->takes_days == 0) {
355	Koha::Exceptions::BadParameter->throw(
356	error => 'days_in_advance cannot be defined for '.
357	$attr->message_name . '.',
358	parameter => 'days_in_advance',
359	);
360	}
361	elsif ($self->days_in_advance < 0 \|\| $self->days_in_advance > 30) {
362	Koha::Exceptions::BadParameter->throw(
363	error => 'days_in_advance has to be a value between 0-30 for '.
364	$attr->message_name . '.',
365	parameter => 'days_in_advance',
366	);
367	}
368	}
369	if (defined $self->wants_digest) {
370	my $transports = Koha::Patron::Message::Transports->search({
371	message_attribute_id => $self->message_attribute_id,
372	is_digest => $self->wants_digest ? 1 : 0,
373	});
374	Koha::Exceptions::BadParameter->throw(
375	error => (!$self->wants_digest ? 'Digest must be selected'
376	: 'Digest cannot be selected')
377	. ' for '.$attr->message_name.'.',
378	parameter => 'wants_digest',
379	) if $transports->count == 0;
380	}
381
382	return $self;
383	}
384
385	sub _set_message_transport_types {
386	my $self = shift;
387
388	return unless $_[0];
389
390	$self->{'_message_transport_types'} = undef;
391	my $types = ref $_[0] eq "ARRAY" ? $_[0] : [@_];
392	return unless $types;
393	$self->_validate_message_transport_types({ message_transport_types => $types });
394	foreach my $type (@$types) {
395	unless (exists $self->{'_message_transport_types'}->{$type}) {
396	my $transport = Koha::Patron::Message::Transports->find({
397	message_attribute_id => $self->message_attribute_id,
398	message_transport_type => $type
399	});
400	unless ($transport) {
401	Koha::Exceptions::BadParameter->throw(
402	error => 'No transport configured for '.$self->message_name.
403	" transport type $type.",
404	parameter => 'message_transport_types'
405	);
406	}
407	if (defined $self->borrowernumber) {
408	my $patron = Koha::Patrons->find($self->borrowernumber);
409	if ($type eq 'email') {
410	if ( !$patron->email )
411	{
412	Koha::Exceptions::BadParameter->throw(
413	error => 'Patron has not set email address, '.
414	'cannot use email as message transport',
415	parameter => 'message_transport_types'
416	);
417	}
418	}
419	elsif ($type eq 'sms') {
420	if ( !$patron->smsalertnumber ){
421	Koha::Exceptions::BadParameter->throw(
422	error => 'Patron has not set sms number, '.
423	'cannot set sms as message transport',
424	parameter => 'message_transport_types'
425	);
426	}
427	}
428	}
429	$self->{'_message_transport_types'}->{$type}
430	= $transport->letter_code;
431	}
432	}
433	return $self;
434	}
435
436	sub _validate_message_transport_types {
437	my ($self, $params) = @_;
438
439	if (ref($params) eq 'HASH' && $params->{'message_transport_types'}) {
440	if (ref($params->{'message_transport_types'}) ne 'ARRAY') {
441	$params->{'message_transport_types'} = [$params->{'message_transport_types'}];
442	}
443	my $types = $params->{'message_transport_types'};
444
445	foreach my $type (@{$types}) {
446	unless (Koha::Patron::Message::Transport::Types->find({
447	message_transport_type => $type
448	})) {
449	Koha::Exceptions::BadParameter->throw(
450	error => "Message transport type '$type' does not exist",
451	parameter => 'message_transport_types',
452	);
453	}
454	}
455	return $types;
456	}
457	}
458
459	=head3 type
460
461	=cut
462
463	sub _type {
464	return 'BorrowerMessagePreference';
465	}
466
467	=head1 AUTHOR
468
469	Lari Taskula <lari.taskula@hypernova.fi>
470
471	=cut
472
473	1;

Line 0 Link Here

(-)a/Koha/Patron/Message/Preferences.pm (+146 lines)
		1	package Koha::Patron::Message::Preferences;
		2
		3	# Copyright Koha-Suomi Oy 2016
		4	#
		5	# This file is part of Koha.
		6	#
		7	# Koha is free software; you can redistribute it and/or modify it under the
		8	# terms of the GNU General Public License as published by the Free Software
		9	# Foundation; either version 3 of the License, or (at your option) any later
		10	# version.
		11	#
		12	# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
		13	# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
		14	# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
		15	#
		16	# You should have received a copy of the GNU General Public License along
		17	# with Koha; if not, write to the Free Software Foundation, Inc.,
		18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
		19
		20	use Modern::Perl;
		21
		22	use Koha::Database;
		23	use Koha::Patron::Message::Attributes;
		24	use Koha::Patron::Message::Preference;
		25	use Koha::Patron::Message::Transports;
		26
		27	use base qw(Koha::Objects);
		28
		29	=head1 NAME
		30
		31	Koha::Patron::Message::Preferences - Koha Patron Message Preferences object class
		32
		33	=head1 API
		34
		35	=head2 Class Methods
		36
		37	=cut
		38
		39	=head3 find_with_message_name
		40
		41	Koha::Patron::Message::Preferences->find_with_message_name({
		42	borrowernumber => 123,
		43	message_name => 'Hold_Filled',
		44	});
		45
		46	Converts C<message_name> into C<message_attribute_id> and continues find.
		47
		48	=cut
		49
		50	sub find_with_message_name {
		51	my ($self, $id) = @_;
		52
		53	if (ref($id) eq "HASH" && $id->{'message_name'}) {
		54	my $attr = Koha::Patron::Message::Attributes->find({
		55	message_name => $id->{'message_name'},
		56	});
		57	$id->{'message_attribute_id'} = ($attr) ?
		58	$attr->message_attribute_id : undef;
		59	delete $id->{'message_name'};
		60	}
		61
		62	return $self->SUPER::find($id);
		63	}
		64
65	=head3 get_options
66
67	my $messaging_options = Koha::Patron::Message::Preferences->get_options
68
69	Returns an ARRAYref of HASHrefs on available messaging options.
70
71	=cut
72
73	sub get_options {
74	my ($self) = @_;
75
76	my $transports = Koha::Patron::Message::Transports->search(undef,
77	{
78	join => ['message_attribute'],
79	'+select' => ['message_attribute.message_name', 'message_attribute.takes_days'],
80	'+as' => ['message_name', 'takes_days'],
81	});
82
83	my $choices;
84	while (my $transport = $transports->next) {
85	my $name = $transport->get_column('message_name');
86	$choices->{$name}->{'message_attribute_id'} = $transport->message_attribute_id;
87	$choices->{$name}->{'message_name'} = $name;
88	$choices->{$name}->{'takes_days'} = $transport->get_column('takes_days');
89	$choices->{$name}->{'has_digest'} \|\|= 1 if $transport->is_digest;
90	$choices->{$name}->{'has_digest_off'} \|\|= 1 if !$transport->is_digest;
91	$choices->{$name}->{'transport_'.$transport->get_column('message_transport_type')} = ' ';
92	}
93
94	my @return = values %$choices;
95	@return = sort { $a->{message_attribute_id} <=> $b->{message_attribute_id} } @return;
96
97	return \@return;
98	}
99
100	=head3 search_with_message_name
101
102	Koha::Patron::Message::Preferences->search_with_message_name({
103	borrowernumber => 123,
104	message_name => 'Hold_Filled',
105	});
106
107	Converts C<message_name> into C<message_attribute_id> and continues search. Use
108	Koha::Patron::Message::Preferences->search with a proper join for more complicated
109	searches.
110
111	=cut
112
113	sub search_with_message_name {
114	my ($self, $params, $attributes) = @_;
115
116	if (ref($params) eq "HASH" && $params->{'message_name'}) {
117	my $attr = Koha::Patron::Message::Attributes->find({
118	message_name => $params->{'message_name'},
119	});
120	$params->{'message_attribute_id'} = ($attr) ?
121	$attr->message_attribute_id : undef;
122	delete $params->{'message_name'};
123	}
124
125	return $self->SUPER::search($params, $attributes);
126	}
127
128	=head3 type
129
130	=cut
131
132	sub _type {
133	return 'BorrowerMessagePreference';
134	}
135
136	sub object_class {
137	return 'Koha::Patron::Message::Preference';
138	}
139
140	=head1 AUTHOR
141
142	Lari Taskula <lari.taskula@hypernova.fi>
143
144	=cut
145
146	1;

Line 0 Link Here

(-)a/Koha/Patron/Message/Transport.pm (+50 lines)
	1	package Koha::Patron::Message::Transport;
	2
	3	# Copyright Koha-Suomi Oy 2016
	4	#
	5	# This file is part of Koha.
	6	#
	7	# Koha is free software; you can redistribute it and/or modify it under the
	8	# terms of the GNU General Public License as published by the Free Software
	9	# Foundation; either version 3 of the License, or (at your option) any later
	10	# version.a
	11	#
	12	# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
	13	# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	14	# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License along
	17	# with Koha; if not, write to the Free Software Foundation, Inc.,
	18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	19
	20	use Modern::Perl;
	21
	22	use Koha::Database;
	23
	24	use base qw(Koha::Object);
	25
	26	=head1 NAME
	27
	28	Koha::Patron::Message::Transport - Koha Patron Message Transport object class
	29
	30	=head1 API
	31
	32	=head2 Class Methods
	33
	34	=cut
	35
	36	=head3 type
	37
	38	=cut
	39
	40	sub _type {
	41	return 'MessageTransport';
	42	}
	43
	44	=head1 AUTHOR
	45
	46	Lari Taskula <lari.taskula@hypernova.fi>
	47
	48	=cut
	49
	50	1;

Line 0 Link Here

(-)a/Koha/Patron/Message/Transport/Preference.pm (+51 lines)
	1	package Koha::Patron::Message::Transport::Preference;
	2
	3	# Copyright Koha-Suomi Oy 2016
	4	#
	5	# This file is part of Koha.
	6	#
	7	# Koha is free software; you can redistribute it and/or modify it under the
	8	# terms of the GNU General Public License as published by the Free Software
	9	# Foundation; either version 3 of the License, or (at your option) any later
	10	# version.a
	11	#
	12	# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
	13	# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	14	# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License along
	17	# with Koha; if not, write to the Free Software Foundation, Inc.,
	18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	19
	20	use Modern::Perl;
	21
	22	use Koha::Database;
	23
	24	use base qw(Koha::Object);
	25
	26	=head1 NAME
	27
	28	Koha::Patron::Message::Transport::Preference - Koha Patron Message Transport
	29	Preference object class
	30
	31	=head1 API
	32
	33	=head2 Class Methods
	34
	35	=cut
	36
	37	=head3 type
	38
	39	=cut
	40
	41	sub _type {
	42	return 'BorrowerMessageTransportPreference';
	43	}
	44
	45	=head1 AUTHOR
	46
	47	Lari Taskula <lari.taskula@hypernova.fi>
	48
	49	=cut
	50
	51	1;

Line 0 Link Here

(-)a/Koha/Patron/Message/Transport/Type.pm (+51 lines)
	1	package Koha::Patron::Message::Transport::Type;
	2
	3	# Copyright Koha-Suomi Oy 2016
	4	#
	5	# This file is part of Koha.
	6	#
	7	# Koha is free software; you can redistribute it and/or modify it under the
	8	# terms of the GNU General Public License as published by the Free Software
	9	# Foundation; either version 3 of the License, or (at your option) any later
	10	# version.a
	11	#
	12	# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
	13	# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	14	# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License along
	17	# with Koha; if not, write to the Free Software Foundation, Inc.,
	18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	19
	20	use Modern::Perl;
	21
	22	use Koha::Database;
	23
	24	use base qw(Koha::Object);
	25
	26	=head1 NAME
	27
	28	Koha::Patron::Message::Transport::Type - Koha Patron Message Transport Type
	29	object class
	30
	31	=head1 API
	32
	33	=head2 Class Methods
	34
	35	=cut
	36
	37	=head3 type
	38
	39	=cut
	40
	41	sub _type {
	42	return 'MessageTransportType';
	43	}
	44
	45	=head1 AUTHOR
	46
	47	Lari Taskula <lari.taskula@hypernova.fi>
	48
	49	=cut
	50
	51	1;

Line 0 Link Here

(-)a/Koha/Patron/Message/Transport/Types.pm (+56 lines)
	1	package Koha::Patron::Message::Transport::Types;
	2
	3	# Copyright Koha-Suomi Oy 2016
	4	#
	5	# This file is part of Koha.
	6	#
	7	# Koha is free software; you can redistribute it and/or modify it under the
	8	# terms of the GNU General Public License as published by the Free Software
	9	# Foundation; either version 3 of the License, or (at your option) any later
	10	# version.
	11	#
	12	# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
	13	# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	14	# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License along
	17	# with Koha; if not, write to the Free Software Foundation, Inc.,
	18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	19
	20	use Modern::Perl;
	21
	22	use Koha::Database;
	23	use Koha::Patron::Message::Transport::Type;
	24
	25	use base qw(Koha::Objects);
	26
	27	=head1 NAME
	28
	29	Koha::Patron::Message::Transport::Types - Koha Patron Message Transport Types
	30	object class
	31
	32	=head1 API
	33
	34	=head2 Class Methods
	35
	36	=cut
	37
	38	=head3 type
	39
	40	=cut
	41
	42	sub _type {
	43	return 'MessageTransportType';
	44	}
	45
	46	sub object_class {
	47	return 'Koha::Patron::Message::Transport::Type';
	48	}
	49
	50	=head1 AUTHOR
	51
	52	Lari Taskula <lari.taskula@hypernova.fi>
	53
	54	=cut
	55
	56	1;

Line 0 Link Here

(-)a/Koha/Patron/Message/Transports.pm (+55 lines)
	1	package Koha::Patron::Message::Transports;
	2
	3	# Copyright Koha-Suomi Oy 2016
	4	#
	5	# This file is part of Koha.
	6	#
	7	# Koha is free software; you can redistribute it and/or modify it under the
	8	# terms of the GNU General Public License as published by the Free Software
	9	# Foundation; either version 3 of the License, or (at your option) any later
	10	# version.
	11	#
	12	# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
	13	# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	14	# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
	15	#
	16	# You should have received a copy of the GNU General Public License along
	17	# with Koha; if not, write to the Free Software Foundation, Inc.,
	18	# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	19
	20	use Modern::Perl;
	21
	22	use Koha::Database;
	23	use Koha::Patron::Message::Transport;
	24
	25	use base qw(Koha::Objects);
	26
	27	=head1 NAME
	28
	29	Koha::Patron::Message::Transports - Koha Patron Message Transports object class
	30
	31	=head1 API
	32
	33	=head2 Class Methods
	34
	35	=cut
	36
	37	=head3 type
	38
	39	=cut
	40
	41	sub _type {
	42	return 'MessageTransport';
	43	}
	44
	45	sub object_class {
	46	return 'Koha::Patron::Message::Transport';
	47	}
	48
	49	=head1 AUTHOR
	50
	51	Lari Taskula <lari.taskula@hypernova.fi>
	52
	53	=cut
	54
	55	1;

Line 0 Link Here

(-)a/t/db_dependent/Koha/Patron/Message/Attributes.t (+74 lines)
		1	#!/usr/bin/perl
		2
		3	# Copyright 2017 Koha-Suomi Oy
		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	use Test::More tests => 2;
		23
		24	use Koha::Database;
		25
		26	my $schema = Koha::Database->new->schema;
		27
		28	subtest 'Test class imports' => sub {
		29	plan tests => 2;
		30
		31	use_ok('Koha::Patron::Message::Attribute');
		32	use_ok('Koha::Patron::Message::Attributes');
		33	};
		34
		35	subtest 'Test Koha::Patron::Message::Attributes' => sub {
		36	plan tests => 6;
		37
		38	$schema->storage->txn_begin;
		39
		40	Koha::Patron::Message::Attribute->new({
		41	message_name => 'Test_Attribute'
		42	})->store;
		43	Koha::Patron::Message::Attribute->new({
		44	message_name => 'Test_Attribute2',
		45	takes_days => 1
		46	})->store;
		47
		48	my $attribute = Koha::Patron::Message::Attributes->find({
		49	message_name => 'Test_Attribute' });
		50	my $attribute2 = Koha::Patron::Message::Attributes->find({
		51	message_name => 'Test_Attribute2' });
		52
		53	is($attribute->message_name, 'Test_Attribute',
		54	'Added a new messaging attribute.');
		55	is($attribute->takes_days, 0,
		56	'For that messaging attribute, takes_days is disabled by default.');
		57	is($attribute2->message_name, 'Test_Attribute2',
		58	'Added another messaging attribute.');
		59	is($attribute2->takes_days, 1,
		60	'takes_days is enabled for that message attribute (as expected).');
		61
		62	$attribute->delete;
		63	$attribute2->delete;
		64	is(Koha::Patron::Message::Attributes->find({
65	message_name => 'Test_Attribute' }), undef,
66	'Deleted the first message attribute.');
67	is(Koha::Patron::Message::Attributes->find({
68	message_name => 'Test_Attribute2' }), undef,
69	'Deleted the second message attribute.');
70
71	$schema->storage->txn_rollback;
72	};
73
74	1;