Attachment #172112 for bug #37902

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





use Mojo::Base 'Mojolicious::Plugin';
use List::MoreUtils qw( any );
use Scalar::Util    qw( reftype );
use JSON            qw( decode_json );

use Koha::Exceptions;
use Koha::Exceptions::REST;

            my $filtered_params;
            my $path_params;

            my $reserved_words    = _reserved_words();
            my @query_param_names = keys %{ $c->req->params->to_hash };

            foreach my $param ( keys %{$params} ) {
                if ( grep { $param eq $_ } @{$reserved_words} ) {
                    $reserved_params->{$param} = $params->{$param};
                } elsif ( grep { $param eq $_ } @query_param_names ) {
                elsif ( grep { $param eq $_ } @query_param_names ) {
                    $filtered_params->{$param} = $params->{$param};
                } else {
                else {
                    $path_params->{$param} = $params->{$param};
                }
            }

            );
            my @order_by_params;

            foreach my $order_by_style (@order_by_styles) {
                if ( defined $args->{params}->{$order_by_style}
                    and ref( $args->{params}->{$order_by_style} ) eq 'ARRAY' )
                {
                    push( @order_by_params, @{ $args->{params}->{$order_by_style} } );
                } else {
                    push @order_by_params, $args->{params}->{$order_by_style}
                        if defined $args->{params}->{$order_by_style};
                }


            my @THE_order_by;

            foreach my $order_by_param (@order_by_params) {
                my $order_by;
                $order_by = [ split( /,/, $order_by_param ) ]
                    if ( !reftype($order_by_param) && index( ',', $order_by_param ) == -1 );

                if ($order_by) {
                    if ( reftype($order_by) and reftype($order_by) eq 'ARRAY' ) {
                        my @order_by =
                            map { _build_order_atom( { string => $_, result_set => $result_set } ) } @{$order_by};
                        push( @THE_order_by, @order_by );
                    } else {
                        push @THE_order_by, _build_order_atom( { string => $order_by, result_set => $result_set } );
                    }
                }
            }

            my ( $c, $args ) = @_;
            my $attributes = $args->{attributes};
            my $result_set = $args->{result_set};
            my $embed      = $c->stash('koha.embed');
            return unless defined $embed;

            my @prefetches;
            foreach my $key ( sort keys( %{$embed} ) ) {
                my $parsed = _parse_prefetch( $key, $embed, $result_set );
                push @prefetches, $parsed if defined $parsed;
            }

            if ( scalar(@prefetches) ) {
                $attributes->{prefetch} = \@prefetches;
            }
        }

            my $match = $reserved_params->{_match} // 'contains';

            foreach my $param ( keys %{$filtered_params} ) {
                if ( $match eq 'exact' || $filtered_params->{$param} =~ m[^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}] ) {
                    $params->{$param} = $filtered_params->{$param};
                } elsif ( $match eq 'contains' ) {
                elsif ( $match eq 'contains' ) {
                    $params->{$param} =
                        { like => '%' . $filtered_params->{$param} . '%' };
                } elsif ( $match eq 'starts_with' ) {
                elsif ( $match eq 'starts_with' ) {
                    $params->{$param} = { like => $filtered_params->{$param} . '%' };
                } elsif ( $match eq 'ends_with' ) {
                elsif ( $match eq 'ends_with' ) {
                    $params->{$param} = { like => '%' . $filtered_params->{$param} };
                } else {

                    # We should never reach here, because the OpenAPI plugin should
                    # prevent invalid params to be passed
                    Koha::Exceptions::WrongParameter->throw("Invalid value for _match param ($match)");
                        "Invalid value for _match param ($match)");
                }
            }



            $q_params = decode_json($q_params) unless reftype $q_params;

            my $params = _parse_dbic_query( $q_params, $result_set );

            return $params unless scalar( keys %{$filtered_params} );
            return { '-and' => [ $params, $filtered_params ] };
        }
    );


                next unless $param->{name} eq 'x-koha-embed';
                $embed_spec = $param->{items}->{enum};
            }
            Koha::Exceptions::BadParameter->throw("Embedding objects is not allowed on this endpoint.")
                unless defined($embed_spec);
              unless defined($embed_spec);

            if ($embed_header) {
                my $THE_embed = {};
                foreach my $embed_req ( split /\s*,\s*/, $embed_header ) {
                    if ( $embed_req eq '+strings' ) {    # special case
                        $c->stash( 'koha.strings' => 1 );
                    } else {
                    else {
                        _merge_embed( _parse_embed($embed_req), $THE_embed );
                    }
                }

                $c->stash( 'koha.embed' => $THE_embed )
                    if $THE_embed;
            }

            return $c;

    $app->helper(
        'stash_overrides' => sub {

            my ($c) = @_;

            my $override_header = $c->req->headers->header('x-koha-override') || q{};


=cut

sub _build_order_atom {
    my ($args)     = @_;
    my $string     = $args->{string};
    my $result_set = $args->{result_set};

    my $param = $string;
    $param =~ s/^(\+|\-|\s)//;
    if ($result_set) {
        my $model_param = _from_api_param( $param, $result_set );
        $param = $model_param if defined $model_param;
    }

    if (   $string =~ m/^\+/
        or $string =~ m/^\s/ )
    {
        # asc order operator present
        return { -asc => $param };
    } elsif ( $string =~ m/^\-/ ) {

        # desc order operator present
        return { -desc => $param };
    } else {

        # no order operator present
        return $param;
    }

    my $result;
    my ( $curr, $next ) = split /\s*\.\s*/, $string, 2;

    if ($next) {
        $result->{$curr} = { children => _parse_embed($next) };
    } else {
    else {
        if ( $curr =~ m/^(?<relation>.*)[\+|:]count/ ) {
            my $key = $+{relation} . "_count";
            $result->{$key} = { is_count => 1 };
        } elsif ( $curr =~ m/^(?<relation>.*)\+strings/ ) {
        elsif ( $curr =~ m/^(?<relation>.*)\+strings/ ) {
            my $key = $+{relation};
            $result->{$key} = { strings => 1 };
        } else {
        else {
            $result->{$curr} = {};
        }
    }

sub _merge_embed {
    my ( $structure, $embed ) = @_;

    my ($root) = keys %{$structure};

    if ( any { $root eq $_ } keys %{$embed} ) {

    if ( any { $root eq $_ } keys %{ $embed } ) {
        # Recurse
        _merge_embed( $structure->{$root}, $embed->{$root} );
    } else {

        # Embed
        $embed->{$root} = $structure->{$root};
    }
}

sub _parse_prefetch {
    my ( $key, $embed, $result_set ) = @_;

    my $pref_key = $key;
    $pref_key =~ s/_count$// if $embed->{$key}->{is_count};

    return $pref_key unless defined $embed->{$key}->{children} && defined $ko_class;

    my @prefetches;
    foreach my $child ( sort keys( %{ $embed->{$key}->{children} } ) ) {
        my $parsed = _parse_prefetch( $child, $embed->{$key}->{children}, $ko_class->new );
        push @prefetches, $parsed if defined $parsed;
    }

    return $pref_key unless scalar(@prefetches);

    return { $pref_key => $prefetches[0] } if scalar(@prefetches) eq 1;

    return { $pref_key => \@prefetches };
}

sub _from_api_param {
    my ( $key, $result_set ) = @_;

    if ( $key =~ /\./ ) {

        my ( $curr, $next ) = split /\s*\.\s*/, $key, 2;

        return $curr . '.' . _from_api_param( $next, $result_set ) if $curr eq 'me';

        my $ko_class = $result_set->prefetch_whitelist->{$curr};



        $result_set = $ko_class->new;

        if ( $next =~ /\./ ) {
            return _from_api_param( $next, $result_set );
        } else {
            return
                $curr . '.'
                . (
                  $result_set->from_api_mapping && defined $result_set->from_api_mapping->{$next}
                ? $result_set->from_api_mapping->{$next}
                : $next
                );
        }
    } else {
        return defined $result_set->from_api_mapping->{$key} ? $result_set->from_api_mapping->{$key} : $key;

}

sub _parse_dbic_query {
    my ( $q_params, $result_set ) = @_;

    if ( reftype($q_params) && reftype($q_params) eq 'HASH' ) {
        my $parsed_hash;
        foreach my $key ( keys %{$q_params} ) {
            if ( $key =~ /-?(not_?)?bool/i ) {
                $parsed_hash->{$key} = _from_api_param( $q_params->{$key}, $result_set );
                next;
            }
            my $k = _from_api_param( $key, $result_set );
            $parsed_hash->{$k} = _parse_dbic_query( $q_params->{$key}, $result_set );
        }
        return $parsed_hash;
    } elsif ( reftype($q_params) && reftype($q_params) eq 'ARRAY' ) {
        my @mapped = map { _parse_dbic_query( $_, $result_set ) } @$q_params;
        return \@mapped;
    } else {
        return $q_params;





use C4::Context;
use C4::Circulation qw( AddIssue );
use C4::Biblio      qw( AddBiblio );

use Koha::Database;



    $schema->storage->txn_begin;

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

    my $object = Koha::Patron->new();
    $object->categorycode($categorycode);
    $object->branchcode($branchcode);
    $object->surname("Test Surname");
    $object->store->discard_changes;
    is( $object->is_changed(), 0, "Object is unchanged" );

    $object->store();
    is( $object->is_changed(), 0, "Object no longer marked as changed after being stored" );

    $object->set( { firstname => 'Test Firstname' } );
    is( $object->is_changed(), 1, "Object is changed after Set" );
    $object->store();
    is( $object->is_changed(), 0, "Object no longer marked as changed after being stored" );

    # Test make_column_dirty
    is( $object->make_column_dirty('firstname'), '', 'make_column_dirty returns empty string on success' );
    is( $object->make_column_dirty('firstname'), 1,  'make_column_dirty returns 1 if already dirty' );
    is( $object->is_changed,                     1,  "Object is changed after make dirty" );
    $object->store;
    is( $object->is_changed, 0, "Store clears dirty mark" );
    $object->make_column_dirty('firstname');


    $schema->storage->txn_begin;

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

    my $object = Koha::Patron->new();
    is( $object->in_storage, 0, "Object is not in storage" );
    $object->categorycode($categorycode);
    $object->branchcode($branchcode);
    $object->surname("Test Surname");
    $object->store();
    is( $object->in_storage, 1, "Object is now stored" );

    is( $object->in_storage, 1 );

    my $borrowernumber = $object->borrowernumber;
    my $patron         = $schema->resultset('Borrower')->find($borrowernumber);
    is( $patron->surname(), "Test Surname", "Object found in database" );

    $object->delete();
    $patron = $schema->resultset('Borrower')->find($borrowernumber);
    ok( !$patron, "Object no longer found in database" );
    is( $object->in_storage, 0, "Object is not in storage" );

    $schema->storage->txn_rollback;


    $schema->storage->txn_begin;

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

    my $patron = Koha::Patron->new( { categorycode => $categorycode, branchcode => $branchcode } )->store;
    is( $patron->id, $patron->borrowernumber );

    $schema->storage->txn_rollback;


    $schema->storage->txn_begin;

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

    my $patron = Koha::Patron->new( { categorycode => $categorycode, branchcode => $branchcode } )->store;
    is(
        $patron->get_column('borrowernumber'), $patron->borrowernumber,
        'get_column should retrieve the correct value'
    );

    $schema->storage->txn_rollback;
};


    $schema->storage->txn_begin;

    my $dt             = dt_from_string();
    my $borrowernumber = $builder->build(
        {
            source => 'Borrower',
            value  => {
                lost            => 1,
                sms_provider_id => undef,
                gonenoaddress   => 0,
                updated_on      => $dt,
                lastseen        => $dt,
            }
        }
    )->{borrowernumber};

    my $patron        = Koha::Patrons->find($borrowernumber);
    my $lost          = $patron->TO_JSON()->{lost};
    my $gonenoaddress = $patron->TO_JSON->{gonenoaddress};
    my $updated_on    = $patron->TO_JSON->{updated_on};
    my $lastseen      = $patron->TO_JSON->{lastseen};

    ok( $lost->isa('JSON::PP::Boolean'), 'Boolean attribute type is correct' );
    is( $lost, 1, 'Boolean attribute value is correct (true)' );


    is( $patron->TO_JSON->{sms_provider_id}, undef, 'Undef values should not be casted to 0' );

    ok( !isvstring( $patron->borrowernumber ), 'Integer values are not coded as strings' );

    my $rfc3999_regex = qr/
            (?<year>\d{4})

            (?<second>\d{2})
            (([Zz])|([\+|\-]([01][0-9]|2[0-3]):[0-5][0-9]))
        /xms;
    like( $updated_on, $rfc3999_regex, "Date-time $updated_on formatted correctly" );
    like( $lastseen,   $rfc3999_regex, "Date-time $lastseen formatted correctly" );

    # Test JSON doesn't receive strings
    my $order = $builder->build_object( { class => 'Koha::Acquisition::Orders' } );
    $order = Koha::Acquisition::Orders->find( $order->ordernumber );
    is_deeply( $order->TO_JSON, decode_json( encode_json( $order->TO_JSON ) ), 'Orders are similar' );



    $schema->storage->txn_begin;

    my $city = $builder->build_object( { class => 'Koha::Cities' } );

    # THE mapping
    # cityid       => 'city_id',


    # Lets emulate an undef
    my $city_class = Test::MockModule->new('Koha::City');
    $city_class->mock(
        'to_api_mapping',
        sub {
            return {
                cityid       => 'city_id',


    $api_city = $city->to_api;

    is( $api_city->{city_id}, $city->cityid,       'Attribute translated correctly' );
    is( $api_city->{country}, $city->city_country, 'Attribute translated correctly' );
    is( $api_city->{name},    $city->city_name,    'Attribute translated correctly' );
    is( $api_city->{state},   $city->city_state,   'Attribute translated correctly' );
    ok( !exists $api_city->{postal_code}, 'Attribute removed' );

    # Pick a class that won't have a mapping for the API
    my $action_log = $builder->build_object( { class => 'Koha::ActionLogs' } );
    is_deeply( $action_log->to_api, $action_log->TO_JSON, 'If no overloaded to_api_mapping method, return TO_JSON' );

    my $biblio = $builder->build_sample_biblio();
    my $item   = $builder->build_sample_item( { biblionumber => $biblio->biblionumber } );
    my $hold   = $builder->build_object( { class => 'Koha::Holds', value => { itemnumber => $item->itemnumber } } );

    my $embeds = { 'items' => {} };

    my $biblio_api = $biblio->to_api( { embed => $embeds } );

    ok( exists $biblio_api->{items}, 'Items where embedded in biblio results' );
    is( $biblio_api->{items}->[0]->{item_id}, $item->itemnumber, 'Item matches' );
    ok( !exists $biblio_api->{items}->[0]->{holds}, 'No holds info should be embedded yet' );

    $embeds = (
        {
            'items'      => { 'children' => { 'holds' => {} } },
                'children' => {
                    'holds' => {}
                }
            },
            'biblioitem' => {}
        }
    );
    $biblio_api = $biblio->to_api( { embed => $embeds } );

    ok( exists $biblio_api->{items}, 'Items where embedded in biblio results' );
    is( $biblio_api->{items}->[0]->{item_id}, $item->itemnumber, 'Item still matches' );
    ok( exists $biblio_api->{items}->[0]->{holds}, 'Holds info should be embedded' );
    is( $biblio_api->{items}->[0]->{holds}->[0]->{hold_id}, $hold->reserve_id, 'Hold matches' );
    is_deeply( $biblio_api->{biblioitem}, $biblio->biblioitem->to_api, 'More than one root' );

    my $_strings = {
        location => {

        }
    );

    my $hold_api = $hold->to_api( { embed => { 'item' => { strings => 1 } } } );
        {
            embed => { 'item' => { strings => 1 } }
        }
    );

    is( ref( $hold_api->{item} ),     'HASH',            'Single nested object works correctly' );
    is( $hold_api->{item}->{item_id}, $item->itemnumber, 'Object embedded correctly' );
    is_deeply(
        $hold_api->{item}->{_strings},

    );

    # biblio with no items
    my $new_biblio     = $builder->build_sample_biblio;
    my $new_biblio_api = $new_biblio->to_api( { embed => $embeds } );

    is_deeply( $new_biblio_api->{items}, [], 'Empty list if no items' );

    my $biblio_class = Test::MockModule->new('Koha::Biblio');
    $biblio_class->mock( 'undef_result', sub { return; } );

    $new_biblio_api = $new_biblio->to_api( { embed => ( { 'undef_result' => {} } ) } );
    ok( exists $new_biblio_api->{undef_result}, 'If a method returns undef, then the attribute is defined' );
    is( $new_biblio_api->{undef_result}, undef, 'If a method returns undef, then the attribute is undef' );

    $biblio_class->mock(
        'items',
        sub { return [ bless { itemnumber => 1 }, 'Somethings' ]; }
    );

    throws_ok {
        $new_biblio_api = $new_biblio->to_api( { embed => { 'items' => { children => { asd => {} } } } } );
            { embed => { 'items' => { children => { asd => {} } } } } );
    }
    'Koha::Exception',
        "An exception is thrown if a blessed object to embed doesn't implement to_api";

    is(
        $@->message,

        "Exception message correct"
    );


    my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
    $builder->build_object(
        {


    subtest 'public request tests' => sub {

        my @all_attrs    = Koha::Libraries->columns();
        my $public_attrs = { map { $_ => 1 } @{ Koha::Library->public_read_list() } };
        my $mapping      = Koha::Library->to_api_mapping;

        plan tests => scalar @all_attrs * 2;

        # Create a sample library
        my $library = $builder->build_object( { class => 'Koha::Libraries' } );

        my $unprivileged_representation = $library->to_api( { public => 1 } );
        my $privileged_representation   = $library->to_api;

        foreach my $attr (@all_attrs) {

                        exists $unprivileged_representation->{$mapped},
                        "Attribute '$attr' is present when public"
                    );
                } else {
                else {
                    ok(
                        !exists $unprivileged_representation->{$mapped},
                        "Attribute '$attr' is not present when public"
                    );
                }
            } else {
            else {
                ok(
                    !exists $privileged_representation->{$attr},
                    "Unmapped attribute '$attr' is not present when privileged"

        $schema->storage->txn_begin;

        # new category
        my $category = $builder->build_object( { class => 'Koha::AuthorisedValueCategories' } );

        # add two countries
        my $argentina = $builder->build_object(
            {
                class => 'Koha::AuthorisedValues',
                value => {
                    category => $category->category_name,
                    lib      => 'AR (Argentina)',

            }
        );
        my $france = $builder->build_object(
            {
                class => 'Koha::AuthorisedValues',
                value => {
                    category => $category->category_name,
                    lib      => 'FR (France)',

        $city_mock->mock( 'public_read_list', sub { return [ 'city_id', 'city_country', 'city_name', 'city_state' ] } );

        my $cordoba = $builder->build_object(
            {
                class => 'Koha::Cities',
                value => { city_country => $argentina->authorised_value, city_name => 'Cordoba' }
            }
        );
        my $marseille = $builder->build_object(
            {
                class => 'Koha::Cities',
                value => { city_country => $france->authorised_value, city_name => 'Marseille' }
            }
        );


    $schema->storage->txn_begin;

    my $action_log = $builder->build_object( { class => 'Koha::ActionLogs' } );
    is_deeply( $action_log->to_api_mapping, {}, 'If no to_api_mapping present, return empty hashref' );

    $schema->storage->txn_rollback;


    $schema->storage->txn_begin;

    my $city = $builder->build_object( { class => 'Koha::Cities' } );

    # Lets emulate an undef
    my $city_class = Test::MockModule->new('Koha::City');
    $city_class->mock(
        'to_api_mapping',
        sub {
            return {
                cityid       => 'city_id',

        'Mapping returns correctly, undef ommited'
    );

    $city_class->unmock('to_api_mapping');
    $city_class->mock(
        'to_api_mapping',
        sub {
            return {
                cityid       => 'city_id',

    );

    # Get a fresh object
    $city = $builder->build_object( { class => 'Koha::Cities' } );
    is_deeply(
        $city->from_api_mapping,
        {

        'Fresh mapping loaded'
    );

    $city_class->unmock('to_api_mapping');
    $city_class->mock( 'to_api_mapping', undef );

    # Get a fresh object
    $city = $builder->build_object( { class => 'Koha::Cities' } );
    is_deeply(
        $city->from_api_mapping,
        {},
        'No to_api_mapping then empty hashref'
    );

    $city_class->unmock('to_api_mapping');
    $city_class->mock( 'to_api_mapping', sub { return; } );

    # Get a fresh object
    $city = $builder->build_object( { class => 'Koha::Cities' } );
    is_deeply(
        $city->from_api_mapping,
        {},


    $schema->storage->txn_begin;

    my $city           = $builder->build_object( { class => 'Koha::Cities' } );
    my $city_unblessed = $city->unblessed;
    my $attrs          = {
        name        => 'Cordoba',
        country     => 'Argentina',
        postal_code => '5000'
    };
    $city->set_from_api($attrs);

    is( $city->city_state,   $city_unblessed->{city_state}, 'Untouched attributes are preserved' );
    is( $city->city_name,    $attrs->{name},                'city_name updated correctly' );
    is( $city->city_country, $attrs->{country},             'city_country updated correctly' );
    is( $city->city_zipcode, $attrs->{postal_code},         'city_zipcode updated correctly' );

    $schema->storage->txn_rollback;
};

    };
    my $city = Koha::City->new_from_api($attrs);

    is( ref($city),          'Koha::City',          'Object type is correct' );
    is( $city->city_name,    $attrs->{name},        'city_name updated correctly' );
    is( $city->city_country, $attrs->{country},     'city_country updated correctly' );
    is( $city->city_zipcode, $attrs->{postal_code}, 'city_zipcode updated correctly' );

    $schema->storage->txn_rollback;


        my $attrs = $patron->attributes_from_api(
            {
                updated_on    => '2019-12-27T14:53:00Z',
                last_seen     => '2019-12-27T14:53:00Z',
                date_of_birth => '2019-12-27',
            }
        );

        ok(
            exists $attrs->{updated_on},
            'No translation takes place if no mapping'
        );
        is(
            $attrs->{updated_on},
            '2019-12-27 14:53:00',
            'Given an rfc3339 formatted datetime string, a timestamp field is converted into an SQL formatted datetime string'
        );

        ok(
            exists $attrs->{lastseen},
            'Translation takes place because of the defined mapping'
        );
        is(
            $attrs->{lastseen},
            '2019-12-27 14:53:00',
            'Given an rfc3339 formatted datetime string, a datetime field is converted into an SQL formatted datetime string'
        );

        ok(
            exists $attrs->{dateofbirth},
            'Translation takes place because of the defined mapping'
        );
        is(
            $attrs->{dateofbirth},
            '2019-12-27',

                    },
                    { '=' => '2019-12-31 23:59:00' }
                ],
                updated_on  => { '>' => '2019-12-27 14:53:00' },
                dateofbirth => [ { '>', '2019-12-27' }, { '=' => '2019-12-31' } ]
            }
        );

        $attrs = $patron->attributes_from_api(
            {
                last_seen     => undef,
                date_of_birth => undef,
            }
        );

        ok(
            exists $attrs->{lastseen},
            'undef parameter is not skipped (Bug 29157)'
        );
        is(
            $attrs->{lastseen},
            undef,
            'Given undef, a datetime field is set to undef (Bug 29157)'
        );

        ok(
            exists $attrs->{dateofbirth},
            'undef parameter is not skipped (Bug 29157)'
        );
        is(
            $attrs->{dateofbirth},
            undef,
            'Given undef, a date field is set to undef (Bug 29157)'
        );

        throws_ok {
            $attrs = $patron->attributes_from_api(
                {
                    date_of_birth => '20141205',
                }
            );
        }
        'Koha::Exceptions::BadParameter',
            'Koha::Exceptions::BadParameter',
            'Bad date throws an exception';

        is(


    $schema->storage->txn_begin;

    my $branchcode = $builder->build( { source => 'Branch' } )->{branchcode};
    my $library    = Koha::Libraries->find($branchcode);
    $library->update( { branchname => 'New_Name', branchcity => 'AMS' } );
    is( $library->branchname, 'New_Name', 'Changed name with update' );
    is( $library->branchcity, 'AMS',      'Changed city too' );
    is( $library->is_changed, 0,          'Change should be stored already' );
    try {
        $library->update(
            {
                branchcity => 'NYC', not_a_column => 53, branchname => 'Name3',
            }
        );
        fail('It should not be possible to update an unexisting column without an error from Koha::Object/DBIx');
    } catch {
        ok( $_->isa('Koha::Exceptions::Object'), 'Caught error when updating wrong column' );
        $library->discard_changes;    #requery after failing update
    };

    # Check if the columns are not updated
    is( $library->branchcity, 'AMS',      'First column not updated' );
    is( $library->branchname, 'New_Name', 'Third column not updated' );

    $schema->storage->txn_rollback;

    $schema->storage->txn_begin;

    # Create a library to make sure its ID doesn't exist on the DB
    my $library    = $builder->build_object( { class => 'Koha::Libraries' } );
    my $branchcode = $library->branchcode;
    $library->delete;

    my $library_group = Koha::Library::Group->new(
        {
            branchcode => $library->branchcode,
            title      => 'a title',
        }
    );


    {
        local *STDERR;
        open STDERR, '>', '/dev/null';
        throws_ok { $library_group->store }
        'Koha::Exceptions::Object::FKConstraint',
            'Koha::Exceptions::Object::FKConstraint',
            'Exception is thrown correctly';
        is(
            $@->message,

            'Exception field is correct'
        );

        $library_group = $builder->build_object( { class => 'Koha::Library::Groups' } );

        my $new_library_group = Koha::Library::Group->new(
            {
                branchcode => $library_group->branchcode,
                title      => $library_group->title,
            }
        );

        throws_ok { $new_library_group->store }
        'Koha::Exceptions::Object::DuplicateID',
            'Koha::Exceptions::Object::DuplicateID',
            'Exception is thrown correctly';

        is(

        );

        like(
            $@->duplicate_id,
            qr/(library_groups\.)?title/,
            'Exception field is correct (note that MySQL 8 is displaying the tablename)'
        );
        close STDERR;
    }

    # Successful test
    $library_group->set( { title => 'Manuel' } );
    my $ret = $library_group->store;
    is( ref($ret), 'Koha::Library::Group', 'store() returns the object on success' );


            {
                categorycode    => $patron_category->categorycode,
                branchcode      => $library->branchcode,
                dateofbirth     => "",                               # date will be set to NULL
                sms_provider_id => "",                               # Integer will be set to NULL
                privacy         => "",                               # privacy cannot be NULL but has a default value
            }
        )->store;
    };
    is( $@,                       '',    'No error should be raised by ->store if empty strings are passed' );
    is( $patron->privacy,         1,     'Default value for privacy should be set to 1' );
    is( $patron->dateofbirth,     undef, 'dateofbirth must have been set to undef' );
    is( $patron->sms_provider_id, undef, 'sms_provider_id must have been set to undef' );

    my $itemtype = eval {
        Koha::ItemType->new(
            {
                itemtype     => 'IT4test',
                rentalcharge => "",
                notforloan   => "",
                hideinopac   => "",
            }
        )->store;
    };
    is( $@,                      '',    'No error should be raised by ->store if empty strings are passed' );
    is( $itemtype->rentalcharge, undef, 'decimal DEFAULT NULL should default to null' );
    is( $itemtype->hideinopac,   0,     'int NOT NULL DEFAULT 0 should default to 0' );

    my $currency = eval {
        Koha::Acquisition::Currency->new(
            {
                currency => 'Cur_test',
                active   => 'IT4test',
            }
        )->store;
    };
    is( $currency->active, undef, 'int DEFAULT NULL should default to null' );

    subtest 'Bad value tests' => sub {

        plan tests => 3;

        my $patron = $builder->build_object( { class => 'Koha::Patrons' } );


        try {
            local *STDERR;

            close STDERR;
        } catch {
            ok( $_->isa('Koha::Exceptions::Object::BadValue'), 'Exception thrown correctly' );
            like( $_->property, qr/(borrowers\.)?lastseen/, 'Column should be the expected one' )
                ;    # The table name is not always displayed, it depends on the DBMS version
            is( $_->value, 'wrong_value', 'Value should be the expected one' );
        };
    };


    # FIXME It's very painful to create an issue in tests!
    my $library = $builder->build_object( { class => 'Koha::Libraries' } );
    t::lib::Mocks::mock_userenv( { branchcode => $library->branchcode } );

    my $patron_category = $builder->build(
        {

        }
    );
    my $patron_data = {
        firstname    => 'firstname',
        surname      => 'surname',
        categorycode => $patron_category->{categorycode},
        branchcode   => $library->branchcode,
    };
    my $patron         = Koha::Patron->new($patron_data)->store;
    my ($biblionumber) = AddBiblio( MARC::Record->new, '' );
    my $biblio         = Koha::Biblios->find($biblionumber);
    my $itemtype       = $builder->build( { source => 'Itemtype' } )->{itemtype};
    my $item           = $builder->build_object(
        {
            class => 'Koha::Items',
            value => {

        }
    );

    my $issue    = AddIssue( $patron, $item->barcode, dt_from_string()->subtract( days => 1 ) );
    my $overdues = Koha::Patrons->find( $patron->id )->overdues;    # Koha::Patron->overdues prefetches
    my $overdue  = $overdues->next->unblessed_all_relateds;
    is( $overdue->{issue_id},   $issue->issue_id, 'unblessed_all_relateds has field from the original table (issues)' );
    is( $overdue->{title},      $biblio->title,   'unblessed_all_relateds has field from other tables (biblio)' );
    is( $overdue->{homebranch}, $item->homebranch, 'unblessed_all_relateds has field from other tables (items)' );

    $schema->storage->txn_rollback;

    Koha::Biblios->find( $biblio->biblionumber )->title($new_title)->store;

    is( $biblio->title, $old_title, 'current $biblio should not be modified' );
    is(
        $biblio->get_from_storage->title,
        $new_title, 'get_from_storage should return an updated object'
    );

    Koha::Biblios->find( $biblio->biblionumber )->delete;
    is( ref($biblio), 'Koha::Biblio', 'current $biblio should not be deleted' );
    is(
        $biblio->get_from_storage, undef,
        'get_from_storage should return undef if the object has been deleted'
    );

    $schema->storage->txn_rollback;
};


    $schema->storage->txn_begin;

    my $item      = $builder->build_sample_item;
    my $item_info = $item->unblessed;
    $item = $item->set_or_blank($item_info);
    is_deeply( $item->unblessed, $item_info, 'set_or_blank assign the correct value if unchanged' );

    # int not null
    delete $item_info->{itemlost};
    $item = $item->set_or_blank($item_info);
    is( $item->itemlost, 0, 'set_or_blank should have set itemlost to 0, default value defined in DB' );

    # int nullable
    delete $item_info->{restricted};
    $item = $item->set_or_blank($item_info);
    is( $item->restricted, undef, 'set_or_blank should have set restristed to null' );

    # datetime nullable
    delete $item_info->{dateaccessioned};
    $item = $item->set_or_blank($item_info);
    is( $item->dateaccessioned, undef, 'set_or_blank should have set dateaccessioned to null' );

    # timestamp not null
    delete $item_info->{timestamp};
    $item = $item->set_or_blank($item_info);
    isnt( $item->timestamp, undef, 'set_or_blank should have set timestamp to a correct value' );

    $schema->storage->txn_rollback;
};

    my @messages = @{ $patron->object_messages };
    is( scalar @messages, 0, 'No messages' );

    $patron->add_message( { message => "message_1" } );
    $patron->add_message( { message => "message_2" } );

    @messages = @{ $patron->object_messages };

    is( scalar @messages,      2,                       'Messages are returned' );
    is( ref( $messages[0] ),   'Koha::Object::Message', 'Right type returned' );
    is( ref( $messages[1] ),   'Koha::Object::Message', 'Right type returned' );
    is( $messages[0]->message, 'message_1',             'Right message recorded' );

    my $patron_id = $builder->build_object( { class => 'Koha::Patrons' } )->id;

    my $patron_id = $builder->build_object({ class => 'Koha::Patrons' })->id;
    # get a patron from the DB, ->new is not called, ->object_messages should initialize _messages as an empty arrayref
    $patron = Koha::Patrons->find($patron_id);

    isnt( $patron->object_messages, undef, '->messages initializes the array if required' );
    is( scalar @{ $patron->object_messages }, 0, '->messages returns an empty arrayref' );

        }
    );

    my $patron_1 = $builder->build_object( { class => 'Koha::Patrons', value => { branchcode => $library_1->id } } );
    my $patron_2 = $builder->build_object( { class => 'Koha::Patrons', value => { branchcode => $library_2->id } } );
    );
    my $patron_2 = $builder->build_object(
        { class => 'Koha::Patrons', value => { branchcode => $library_2->id } }
    );

    t::lib::Mocks::mock_userenv( { patron => $patron } );

- 

Return to bug 37902

Lines 19-26 use Modern::Perl; Link Here

(-)a/Koha/REST/Plugin/Query.pm (-89 / +87 lines)
19		19
20	use Mojo::Base 'Mojolicious::Plugin';	20	use Mojo::Base 'Mojolicious::Plugin';
21	use List::MoreUtils qw( any );	21	use List::MoreUtils qw( any );
22	use Scalar::Util qw( reftype );	22	use Scalar::Util qw( reftype );
23	use JSON qw( decode_json );	23	use JSON qw( decode_json );
24		24
25	use Koha::Exceptions;	25	use Koha::Exceptions;
26	use Koha::Exceptions::REST;	26	use Koha::Exceptions::REST;
Lines 58-74 Generates the DBIC query from the query parameters. Link Here
58	my $filtered_params;	58	my $filtered_params;
59	my $path_params;	59	my $path_params;
60		60
61	my $reserved_words = _reserved_words();	61	my $reserved_words = _reserved_words();
62	my @query_param_names = keys %{$c->req->params->to_hash};	62	my @query_param_names = keys %{ $c->req->params->to_hash };
63		63
64	foreach my $param ( keys %{$params} ) {	64	foreach my $param ( keys %{$params} ) {
65	if ( grep { $param eq $_ } @{$reserved_words} ) {	65	if ( grep { $param eq $_ } @{$reserved_words} ) {
66	$reserved_params->{$param} = $params->{$param};	66	$reserved_params->{$param} = $params->{$param};
67	}	67	} elsif ( grep { $param eq $_ } @query_param_names ) {
68	elsif ( grep { $param eq $_ } @query_param_names ) {
69	$filtered_params->{$param} = $params->{$param};	68	$filtered_params->{$param} = $params->{$param};
70	}	69	} else {
71	else {
72	$path_params->{$param} = $params->{$param};	70	$path_params->{$param} = $params->{$param};
73	}	71	}
74	}	72	}
Lines 97-107 Generates the DBIC order_by attributes based on I<$params>, and merges into I<$a Link Here
97	);	95	);
98	my @order_by_params;	96	my @order_by_params;
99		97
100	foreach my $order_by_style ( @order_by_styles ) {	98	foreach my $order_by_style (@order_by_styles) {
101	if ( defined $args->{params}->{$order_by_style} and ref($args->{params}->{$order_by_style}) eq 'ARRAY' ) {	99	if ( defined $args->{params}->{$order_by_style}
102	push( @order_by_params, @{$args->{params}->{$order_by_style} });	100	and ref( $args->{params}->{$order_by_style} ) eq 'ARRAY' )
103	}	101	{
104	else {	102	push( @order_by_params, @{ $args->{params}->{$order_by_style} } );
		103	} else {
105	push @order_by_params, $args->{params}->{$order_by_style}	104	push @order_by_params, $args->{params}->{$order_by_style}
106	if defined $args->{params}->{$order_by_style};	105	if defined $args->{params}->{$order_by_style};
107	}	106	}
Lines 109-126 Generates the DBIC order_by attributes based on I<$params>, and merges into I<$a Link Here
109		108
110	my @THE_order_by;	109	my @THE_order_by;
111		110
112	foreach my $order_by_param ( @order_by_params ) {	111	foreach my $order_by_param (@order_by_params) {
113	my $order_by;	112	my $order_by;
114	$order_by = [ split(/,/, $order_by_param) ]	113	$order_by = [ split( /,/, $order_by_param ) ]
115	if ( !reftype($order_by_param) && index(',',$order_by_param) == -1);	114	if ( !reftype($order_by_param) && index( ',', $order_by_param ) == -1 );
116		115
117	if ($order_by) {	116	if ($order_by) {
118	if ( reftype($order_by) and reftype($order_by) eq 'ARRAY' ) {	117	if ( reftype($order_by) and reftype($order_by) eq 'ARRAY' ) {
119	my @order_by = map { _build_order_atom({ string => $_, result_set => $result_set }) } @{ $order_by };	118	my @order_by =
120	push( @THE_order_by, @order_by);	119	map { _build_order_atom( { string => $_, result_set => $result_set } ) } @{$order_by};
121	}	120	push( @THE_order_by, @order_by );
122	else {	121	} else {
123	push @THE_order_by, _build_order_atom({ string => $order_by, result_set => $result_set });	122	push @THE_order_by, _build_order_atom( { string => $order_by, result_set => $result_set } );
124	}	123	}
125	}	124	}
126	}	125	}
Lines 145-160 Generates the DBIC prefetch attribute based on embedded relations, and merges in Link Here
145	my ( $c, $args ) = @_;	144	my ( $c, $args ) = @_;
146	my $attributes = $args->{attributes};	145	my $attributes = $args->{attributes};
147	my $result_set = $args->{result_set};	146	my $result_set = $args->{result_set};
148	my $embed = $c->stash('koha.embed');	147	my $embed = $c->stash('koha.embed');
149	return unless defined $embed;	148	return unless defined $embed;
150		149
151	my @prefetches;	150	my @prefetches;
152	foreach my $key (sort keys(%{$embed})) {	151	foreach my $key ( sort keys( %{$embed} ) ) {
153	my $parsed = _parse_prefetch($key, $embed, $result_set);	152	my $parsed = _parse_prefetch( $key, $embed, $result_set );
154	push @prefetches, $parsed if defined $parsed;	153	push @prefetches, $parsed if defined $parsed;
155	}	154	}
156		155
157	if(scalar(@prefetches)) {	156	if ( scalar(@prefetches) ) {
158	$attributes->{prefetch} = \@prefetches;	157	$attributes->{prefetch} = \@prefetches;
159	}	158	}
160	}	159	}
Lines 195-218 is raised. Link Here
195	my $match = $reserved_params->{_match} // 'contains';	194	my $match = $reserved_params->{_match} // 'contains';
196		195
197	foreach my $param ( keys %{$filtered_params} ) {	196	foreach my $param ( keys %{$filtered_params} ) {
198	if ( $match eq 'exact' \|\| $filtered_params->{$param} =~ m[^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}]) {	197	if ( $match eq 'exact' \|\| $filtered_params->{$param} =~ m[^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}] ) {
199	$params->{$param} = $filtered_params->{$param};	198	$params->{$param} = $filtered_params->{$param};
200	}	199	} elsif ( $match eq 'contains' ) {
201	elsif ( $match eq 'contains' ) {
202	$params->{$param} =	200	$params->{$param} =
203	{ like => '%' . $filtered_params->{$param} . '%' };	201	{ like => '%' . $filtered_params->{$param} . '%' };
204	}	202	} elsif ( $match eq 'starts_with' ) {
205	elsif ( $match eq 'starts_with' ) {
206	$params->{$param} = { like => $filtered_params->{$param} . '%' };	203	$params->{$param} = { like => $filtered_params->{$param} . '%' };
207	}	204	} elsif ( $match eq 'ends_with' ) {
208	elsif ( $match eq 'ends_with' ) {
209	$params->{$param} = { like => '%' . $filtered_params->{$param} };	205	$params->{$param} = { like => '%' . $filtered_params->{$param} };
210	}	206	} else {
211	else {	207
212	# We should never reach here, because the OpenAPI plugin should	208	# We should never reach here, because the OpenAPI plugin should
213	# prevent invalid params to be passed	209	# prevent invalid params to be passed
214	Koha::Exceptions::WrongParameter->throw(	210	Koha::Exceptions::WrongParameter->throw("Invalid value for _match param ($match)");
215	"Invalid value for _match param ($match)");
216	}	211	}
217	}	212	}
218		213
Lines 235-244 Merges parameters from $q_params into $filtered_params. Link Here
235		230
236	$q_params = decode_json($q_params) unless reftype $q_params;	231	$q_params = decode_json($q_params) unless reftype $q_params;
237		232
238	my $params = _parse_dbic_query($q_params, $result_set);	233	my $params = _parse_dbic_query( $q_params, $result_set );
239		234
240	return $params unless scalar(keys %{$filtered_params});	235	return $params unless scalar( keys %{$filtered_params} );
241	return {'-and' => [$params, $filtered_params ]};	236	return { '-and' => [ $params, $filtered_params ] };
242	}	237	}
243	);	238	);
244		239
Lines 264-286 Unwraps and stashes the x-koha-embed headers for use later query construction Link Here
264	next unless $param->{name} eq 'x-koha-embed';	259	next unless $param->{name} eq 'x-koha-embed';
265	$embed_spec = $param->{items}->{enum};	260	$embed_spec = $param->{items}->{enum};
266	}	261	}
267	Koha::Exceptions::BadParameter->throw(	262	Koha::Exceptions::BadParameter->throw("Embedding objects is not allowed on this endpoint.")
268	"Embedding objects is not allowed on this endpoint.")	263	unless defined($embed_spec);
269	unless defined($embed_spec);
270		264
271	if ($embed_header) {	265	if ($embed_header) {
272	my $THE_embed = {};	266	my $THE_embed = {};
273	foreach my $embed_req ( split /\s,\s/, $embed_header ) {	267	foreach my $embed_req ( split /\s,\s/, $embed_header ) {
274	if ( $embed_req eq '+strings' ) { # special case	268	if ( $embed_req eq '+strings' ) { # special case
275	$c->stash( 'koha.strings' => 1 );	269	$c->stash( 'koha.strings' => 1 );
276	}	270	} else {
277	else {
278	_merge_embed( _parse_embed($embed_req), $THE_embed );	271	_merge_embed( _parse_embed($embed_req), $THE_embed );
279	}	272	}
280	}	273	}
281		274
282	$c->stash( 'koha.embed' => $THE_embed )	275	$c->stash( 'koha.embed' => $THE_embed )
283	if $THE_embed;	276	if $THE_embed;
284	}	277	}
285		278
286	return $c;	279	return $c;
Lines 308-314 reference: https://metacpan.org/changes/distribution/JSON-Validator#L14 Link Here
308	$app->helper(	301	$app->helper(
309	'stash_overrides' => sub {	302	'stash_overrides' => sub {
310		303
311	my ( $c ) = @_;	304	my ($c) = @_;
312		305
313	my $override_header = $c->req->headers->header('x-koha-override') \|\| q{};	306	my $override_header = $c->req->headers->header('x-koha-override') \|\| q{};
314		307
Lines 349-375 according to the following rules: Link Here
349	=cut	342	=cut
350		343
351	sub _build_order_atom {	344	sub _build_order_atom {
352	my ( $args ) = @_;	345	my ($args) = @_;
353	my $string = $args->{string};	346	my $string = $args->{string};
354	my $result_set = $args->{result_set};	347	my $result_set = $args->{result_set};
355		348
356	my $param = $string;	349	my $param = $string;
357	$param =~ s/^(\+\|\-\|\s)//;	350	$param =~ s/^(\+\|\-\|\s)//;
358	if ( $result_set ) {	351	if ($result_set) {
359	my $model_param = _from_api_param($param, $result_set);	352	my $model_param = _from_api_param( $param, $result_set );
360	$param = $model_param if defined $model_param;	353	$param = $model_param if defined $model_param;
361	}	354	}
362		355
363	if ( $string =~ m/^\+/ or	356	if ( $string =~ m/^\+/
364	$string =~ m/^\s/ ) {	357	or $string =~ m/^\s/ )
		358	{
365	# asc order operator present	359	# asc order operator present
366	return { -asc => $param };	360	return { -asc => $param };
367	}	361	} elsif ( $string =~ m/^\-/ ) {
368	elsif ( $string =~ m/^\-/ ) {	362
369	# desc order operator present	363	# desc order operator present
370	return { -desc => $param };	364	return { -desc => $param };
371	}	365	} else {
372	else {	366
373	# no order operator present	367	# no order operator present
374	return $param;	368	return $param;
375	}	369	}
Lines 390-408 sub _parse_embed { Link Here
390	my $result;	384	my $result;
391	my ( $curr, $next ) = split /\s\.\s/, $string, 2;	385	my ( $curr, $next ) = split /\s\.\s/, $string, 2;
392		386
393	if ( $next ) {	387	if ($next) {
394	$result->{$curr} = { children => _parse_embed( $next ) };	388	$result->{$curr} = { children => _parse_embed($next) };
395	}	389	} else {
396	else {
397	if ( $curr =~ m/^(?<relation>.*)[\+\|:]count/ ) {	390	if ( $curr =~ m/^(?<relation>.*)[\+\|:]count/ ) {
398	my $key = $+{relation} . "_count";	391	my $key = $+{relation} . "_count";
399	$result->{$key} = { is_count => 1 };	392	$result->{$key} = { is_count => 1 };
400	}	393	} elsif ( $curr =~ m/^(?<relation>.*)\+strings/ ) {
401	elsif ( $curr =~ m/^(?<relation>.*)\+strings/ ) {
402	my $key = $+{relation};	394	my $key = $+{relation};
403	$result->{$key} = { strings => 1 };	395	$result->{$key} = { strings => 1 };
404	}	396	} else {
405	else {
406	$result->{$curr} = {};	397	$result->{$curr} = {};
407	}	398	}
408	}	399	}
Lines 421-440 Merges the hash referenced by I<$parsed_embed> into I<$global_embed>. Link Here
421	sub _merge_embed {	412	sub _merge_embed {
422	my ( $structure, $embed ) = @_;	413	my ( $structure, $embed ) = @_;
423		414
424	my ($root) = keys %{ $structure };	415	my ($root) = keys %{$structure};
		416
		417	if ( any { $root eq $_ } keys %{$embed} ) {
425		418
426	if ( any { $root eq $_ } keys %{ $embed } ) {
427	# Recurse	419	# Recurse
428	_merge_embed( $structure->{$root}, $embed->{$root} );	420	_merge_embed( $structure->{$root}, $embed->{$root} );
429	}	421	} else {
430	else {	422
431	# Embed	423	# Embed
432	$embed->{$root} = $structure->{$root};	424	$embed->{$root} = $structure->{$root};
433	}	425	}
434	}	426	}
435		427
436	sub _parse_prefetch {	428	sub _parse_prefetch {
437	my ( $key, $embed, $result_set) = @_;	429	my ( $key, $embed, $result_set ) = @_;
438		430
439	my $pref_key = $key;	431	my $pref_key = $key;
440	$pref_key =~ s/_count$// if $embed->{$key}->{is_count};	432	$pref_key =~ s/_count$// if $embed->{$key}->{is_count};
Lines 444-469 sub _parse_prefetch { Link Here
444	return $pref_key unless defined $embed->{$key}->{children} && defined $ko_class;	436	return $pref_key unless defined $embed->{$key}->{children} && defined $ko_class;
445		437
446	my @prefetches;	438	my @prefetches;
447	foreach my $child (sort keys(%{$embed->{$key}->{children}})) {	439	foreach my $child ( sort keys( %{ $embed->{$key}->{children} } ) ) {
448	my $parsed = _parse_prefetch($child, $embed->{$key}->{children}, $ko_class->new);	440	my $parsed = _parse_prefetch( $child, $embed->{$key}->{children}, $ko_class->new );
449	push @prefetches, $parsed if defined $parsed;	441	push @prefetches, $parsed if defined $parsed;
450	}	442	}
451		443
452	return $pref_key unless scalar(@prefetches);	444	return $pref_key unless scalar(@prefetches);
453		445
454	return {$pref_key => $prefetches[0]} if scalar(@prefetches) eq 1;	446	return { $pref_key => $prefetches[0] } if scalar(@prefetches) eq 1;
455		447
456	return {$pref_key => \@prefetches};	448	return { $pref_key => \@prefetches };
457	}	449	}
458		450
459	sub _from_api_param {	451	sub _from_api_param {
460	my ($key, $result_set) = @_;	452	my ( $key, $result_set ) = @_;
461		453
462	if($key =~ /\./) {	454	if ( $key =~ /\./ ) {
463		455
464	my ($curr, $next) = split /\s\.\s/, $key, 2;	456	my ( $curr, $next ) = split /\s\.\s/, $key, 2;
465		457
466	return $curr.'.'._from_api_param($next, $result_set) if $curr eq 'me';	458	return $curr . '.' . _from_api_param( $next, $result_set ) if $curr eq 'me';
467		459
468	my $ko_class = $result_set->prefetch_whitelist->{$curr};	460	my $ko_class = $result_set->prefetch_whitelist->{$curr};
469		461
Lines 472-481 sub _from_api_param { Link Here
472		464
473	$result_set = $ko_class->new;	465	$result_set = $ko_class->new;
474		466
475	if ($next =~ /\./) {	467	if ( $next =~ /\./ ) {
476	return _from_api_param($next, $result_set);	468	return _from_api_param( $next, $result_set );
477	} else {	469	} else {
478	return $curr.'.'.($result_set->from_api_mapping && defined $result_set->from_api_mapping->{$next} ? $result_set->from_api_mapping->{$next}:$next);	470	return
		471	$curr . '.'
		472	. (
		473	$result_set->from_api_mapping && defined $result_set->from_api_mapping->{$next}
		474	? $result_set->from_api_mapping->{$next}
		475	: $next
		476	);
479	}	477	}
480	} else {	478	} else {
481	return defined $result_set->from_api_mapping->{$key} ? $result_set->from_api_mapping->{$key} : $key;	479	return defined $result_set->from_api_mapping->{$key} ? $result_set->from_api_mapping->{$key} : $key;
Lines 483-503 sub _from_api_param { Link Here
483	}	481	}
484		482
485	sub _parse_dbic_query {	483	sub _parse_dbic_query {
486	my ($q_params, $result_set) = @_;	484	my ( $q_params, $result_set ) = @_;
487		485
488	if(reftype($q_params) && reftype($q_params) eq 'HASH') {	486	if ( reftype($q_params) && reftype($q_params) eq 'HASH' ) {
489	my $parsed_hash;	487	my $parsed_hash;
490	foreach my $key (keys %{$q_params}) {	488	foreach my $key ( keys %{$q_params} ) {
491	if($key =~ /-?(not_?)?bool/i ) {	489	if ( $key =~ /-?(not_?)?bool/i ) {
492	$parsed_hash->{$key} = _from_api_param($q_params->{$key}, $result_set);	490	$parsed_hash->{$key} = _from_api_param( $q_params->{$key}, $result_set );
493	next;	491	next;
494	}	492	}
495	my $k = _from_api_param($key, $result_set);	493	my $k = _from_api_param( $key, $result_set );
496	$parsed_hash->{$k} = _parse_dbic_query($q_params->{$key}, $result_set);	494	$parsed_hash->{$k} = _parse_dbic_query( $q_params->{$key}, $result_set );
497	}	495	}
498	return $parsed_hash;	496	return $parsed_hash;
499	} elsif (reftype($q_params) && reftype($q_params) eq 'ARRAY') {	497	} elsif ( reftype($q_params) && reftype($q_params) eq 'ARRAY' ) {
500	my @mapped = map{ _parse_dbic_query($_, $result_set) } @$q_params;	498	my @mapped = map { _parse_dbic_query( $_, $result_set ) } @$q_params;
501	return \@mapped;	499	return \@mapped;
502	} else {	500	} else {
503	return $q_params;	501	return $q_params;