• Files
• Commits
• Log
• Graph
• Stats

package LIMS::Controller::Audit;

use Moose;
BEGIN { extends 'LIMS::Base'; }
#with (
#	'LIMS::Controller::Roles::DataFile',
#);
use namespace::clean -except => 'meta';
__PACKAGE__->meta->make_immutable(inline_constructor => 0);

use Data::Dumper;

# ------------------------------------------------------------------------------
# default() should never be called direct - redirect to start page:
sub default : StartRunmode {
    my $self = shift; $self->_debug_path($self->get_current_runmode);

    return $self->redirect( $self->query->url );
}

# ------------------------------------------------------------------------------
sub turnaround : Runmode {
    my $self = shift; $self->_debug_path($self->get_current_runmode);
    
    my $selection = $self->param('id'); # eg specimen_type, location, etc
    
    my $data = $self->model('Audit')->turnaround_times($selection); # hashref
    # sort data by requested field (defaults to specimen type):
    my $sorted = $self->_sort_turnaround_data($data); # AoH (sorted)
    
    $self->tt_params(
        data => $sorted,
        start_date => $self->model('Request')->get_first_request_date(),
    );
    
    return $self->tt_process();
}

# ------------------------------------------------------------------------------
sub _sort_turnaround_data {
    my $self = shift;
    my $data = shift;
    
    # default order_by is specimen type:
    my $order_by = $self->query->param('order_by') || 'type';
    
	my %methods = (
		type         => \&_sort_by_specimen_type,
        totals       => \&_sort_by_totals,
        delta_r2a    => \&_sort_by_delta_r2a, # report -> auth diff
        delta_auth   => \&_sort_by_delta_authorise,
        delta_report => \&_sort_by_delta_report,
	);
    
	# get required sort_method:
	my $sort_method = $methods{$order_by};
    
    # get sort order for $data as list of $data keys:
    my $sort_order = $sort_method->($data); # warn Dumper $sort_order;
    
    # create array from $data in requested sort order:    
    while ( my($type, $d) = each %$data ) { # add $data key to its hashref val:
        $d->{type} = $type;
    }
    my @sorted_data = map $data->{$_}, @$sort_order; # add $data vals in sort order
    return \@sorted_data;
}

# ------------------------------------------------------------------------------
sub _sort_by_specimen_type {
    my $data = shift; # warn Dumper $data;
    
    my @sort_order = sort { $a cmp $b } keys %$data;	
	return \@sort_order;
}

# ------------------------------------------------------------------------------
sub _sort_by_totals {
    my $data = shift; # warn Dumper $data; # hashref
    
    my @sort_order = sort { 
		$data->{$a}->{count} <=> $data->{$b}->{count}
        || # 2nd sort by keys (ie specimen type) in case similar counts:
        $a cmp $b        
	} keys %$data; # warn Dumper \@sort_order;
	
	return \@sort_order;
}

# ------------------------------------------------------------------------------
sub _sort_by_delta_report {
    my $data = shift; # warn Dumper $data;
    
    my @sort_order = sort {
		$data->{$a}->{delta_report} / $data->{$a}->{count}
        <=>
        $data->{$b}->{delta_report} / $data->{$b}->{count}
	} keys %$data;
	
	return \@sort_order;
}

# ------------------------------------------------------------------------------
sub _sort_by_delta_r2a {
    my $data = shift; # warn Dumper $data;
    
    my @sort_order = sort {
		(
            $data->{$a}->{delta_authorise} / $data->{$a}->{count} -
            $data->{$a}->{delta_report}    / $data->{$a}->{count}
        )
        <=>
		(
            $data->{$b}->{delta_authorise} / $data->{$b}->{count} -
            $data->{$b}->{delta_report}    / $data->{$b}->{count}
        )
        || $a cmp $b # 2nd sort by keys (ie specimen type) in case similar counts
	} keys %$data;
	
	return \@sort_order;
}

# ------------------------------------------------------------------------------
sub _sort_by_delta_authorise {
    my $data = shift; # warn Dumper $data;
    
    my @sort_order = sort { 
		$data->{$a}->{delta_authorise} / $data->{$a}->{count}
        <=>
        $data->{$b}->{delta_authorise} / $data->{$b}->{count}
	} keys %$data;
	
	return \@sort_order;
}

1;