File Coverage

blib/lib/XAS/Service/Search.pm

Criterion	Covered	Total	%
statement	15	112	13.3
branch	0	50	0.0
condition	0	5	0.0
subroutine	5	12	41.6
pod	2	2	100.0
total	22	181	12.1

package XAS::Service::Search;

our $VERSION = '0.01';

use XAS::Service::Profiles;
use XAS::Service::Profiles::Search;
use XAS::Constants 'HASHREF ARRAYREF';

use XAS::Class
  version   => $VERSION,
  base      => 'XAS::Base',
  mixin     => 'XAS::Service::CheckParameters',
  accessors => 'profile',
  utils     => ':validation',
  codec     => 'JSON',
  vars => {
    PARAMS => {
      -columns => { type => ARRAYREF },
    }
  }
;

use Data::Dumper;

# ----------------------------------------------------------------------
# Public Methods
# ----------------------------------------------------------------------

sub build {
    my $self = shift;
    my ($multi) = validate_params(\@_, [
        { isa => 'Hash::MultiValue' },
    ]);

    my $opts;
    my $options = {};
    my $criteria = {};
    my $params = $multi->as_hashref;

    # internal routines

    my $comparison = sub {
        my $filter = shift;

        if ($filter->{'comparison'} eq 'lt') {

            $criteria->{$filter->{'field'}} = {'<', $filter->{'value'}};

        } elsif ($filter->{'comparison'} eq 'le') {

            $criteria->{$filter->{'field'}} = {'<=', $filter->{'value'}};

        } elsif ($filter->{'comparison'} eq 'gt') {

            $criteria->{$filter->{'field'}} = {'>', $filter->{'value'}};

        } elsif ($filter->{'comparison'} eq 'ge') {

            $criteria->{$filter->{'field'}} = {'>=', $filter->{'value'}};

        } elsif ($filter->{'comparison'} eq 'lk') {

            $criteria->{$filter->{'field'}} = {-like => [$filter->{'value'} . '%']};

        } elsif ($filter->{'comparison'} eq 'eq') {

            $criteria->{$filter->{'field'}} = $filter->{'value'};

        } elsif ($filter->{'comparison'} eq 'be') {

            my $begin = shift(@{$filter->{'value'}});
            my $end   = shift(@{$filter->{'value'}});

            $criteria->{$filter->{'field'}} = {-between => [$begin, $end]};

        }

    };

    # build the options

    if (defined($params->{'start'}) && defined($params->{'limit'})) {

        my $pager = $self->_dbpage($params->{'start'}, $params->{'limit'});

        $options->{'page'} = $pager->{'page'};
        $options->{'rows'} = $pager->{'rows'};

        delete $params->{'start'};
        delete $params->{'limit'};

    }

    if (defined($params->{'sort'})) {

        $params->{'sort'} = decode($params->{'sort'});
        $options->{'order_by'} = $self->_order_by($params->{'sort'});

        delete $params->{'sort'};

    }

    if (defined($params->{'group'})) {

        $params->{'group'} = decode($params->{'group'});
        $options->{'group_by'} = $self->_group_by($params->{'group'});

        delete $params->{'group'};

    }

    # user defined options

    if (defined($params->{'options'})) {

        my $hash = $params->{'options'};

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

            $options->{$key} = $value;

        }

    }

    # build the criteria

    if (defined($params->{'filter'})) {

        my $filters = decode($params->{'filter'});

        while (my $filter = shift(@$filters)) {

            $self->check_parameters($filter, 'filter');

            if ($filter->{'type'} eq 'string') {

                if (defined($filter->{'comparison'})) {

                    $comparison->($filter);

                } else {

                    $criteria->{$filter->{'field'}} = $filter->{'value'};

                }

            } elsif ($filter->{'type'} eq 'number') {

                if (defined($filter->{'comparison'})) {

                    $comparison->($filter);

                } else {

                    $criteria->{$filter->{'field'}} = $filter->{'value'};

                }

            } elsif ($filter->{'type'} eq 'list') {

                while (my $x = shift(@{$filter->{'value'}})) {

                    push(@{$criteria->{$filter->{'field'}}}, $x);

                }

            } elsif ($filter->{'type'} eq 'boolean') {

                my $b = sprintf("%s", $filter->{'value'});

                $criteria->{$filter->{'field'}} = 'f' if ($b eq '0');
                $criteria->{$filter->{'field'}} = 't' if ($b eq '1');

            } elsif ($filter->{'type'} eq 'date') {

                if (defined($filter->{'comparison'})) {

                    $comparison->($filter);

                } else {

                    $criteria->{$filter->{'field'}} = $filter->{'value'};

                }

            }

        }

    }

    return $criteria, $options;

}

# ----------------------------------------------------------------------
# Private Methods
# ----------------------------------------------------------------------

sub init {
    my $class = shift;

    my $self = $class->SUPER::init(@_);

    my $fields = $self->columns->[0];
    my $search = XAS::Service::Profiles::Search->new($fields);

    $self->{'profile'} = XAS::Service::Profiles->new($search);

    return $self;

}

#
# General purpose rounding function.
#
# To round a number to the nearest integer, use round($x). To round it to
# the nearest 10, use round($x, 1). Nearest 100 is round($x, 2) and so on.
# You can also round to the nearest tenth, hundredth, etc., by using a
# negative second argument: round(5.28, -1) == 5.3.
#
sub _roundup {
    my $self   = shift;
    my $n      = shift;
    my $places = shift;

    my $factor = 10 ** ($places || 0);
    return (int(($n * $factor) + ($n < 0 ? -1 : 1) * 0.5) / $factor);

}

#
# Find the "page" in a "paged" db retrieval
#
sub _dbpage {
    my $self  = shift;
    my $start = shift;
    my $limit = shift;

    my $params = {
        start => $start,
        limit => $limit
    };

    $self->check_parameters($params, 'pager');

    return {
        page => $self->_roundup(($start / $limit) + 1),
        rows => $limit
    }

}

sub _order_by {
    my $self = shift;
    my $ob   = shift;

    my @d;

    foreach my $x (@$ob) {

        my $y;
        my $z = $self->check_parameters($x, 'sort');

        $y->{'-asc'}  = $z->{'field'} if ($z->{'direction'} eq 'ASC');
        $y->{'-desc'} = $z->{'field'} if ($z->{'direction'} eq 'DESC');

        push(@d, $y);

    }

    return \@d;

}

sub _group_by {
    my ($self, $ob) = @_;

    my @d;
    my $columns = $self->columns->[0];

    foreach my $x (@$ob) {

        my $y = $self->check_parameters($x, 'group');
        my $z = $y->{'field'};

        push(@d, $z);

    }

    foreach my $x (@$columns) {

        push(@d, 'me.' . $x);

    };

    return \@d;

}

1;

__END__