lib/MojoFacets/Data.pm

   1 package MojoFacets::Data;
   2
   3 use strict;
   4 use warnings;
   5
   6 use base 'Mojolicious::Controller';
   7
   8 use Data::Dump qw(dump);
   9 use File::Slurp;
  10 use JSON;
  11 use Encode;
  12
  13 sub index {
  14         my $self = shift;
  15
  16         my $path = $self->app->home->rel_dir('data');
  17         die "no data dir $path" unless -d $path;
  18
  19         opendir(my $dir, $path) || die $!;
  20         my @files =
  21                 grep { -f "$path/$_" && $_ =~ m/\.js(on)?$/ }
  22                 readdir $dir;
  23         close($dir);
  24
  25         $self->render( files => [ @files ] );
  26 }
  27
  28 our $data;
  29 our $stats;
  30
  31 sub load {
  32         my $self = shift;
  33
  34         my $path = $self->app->home->rel_file( 'data/' . $self->param('path') );
  35         die "$path $!" unless -r $path;
  36
  37         $self->session('path' => $self->param('path'));
  38
  39         # we could use Mojo::JSON here, but it's too slow
  40 #       $data = from_json read_file $path;
  41         $data = read_file $path;
  42         Encode::_utf8_on($data);
  43         warn "# json snippet: ", substr($data,0,200);
  44         $data = from_json $data;
  45
  46         $stats = {};
  47
  48         foreach my $e ( @{ $data->{items} } ) {
  49                 foreach my $n ( keys %$e ) {
  50                         $stats->{$n}->{count}++;
  51                         $stats->{$n}->{number}++
  52                                 if $e->{$n} =~ m/^[-+]?([0-9]*\.[0-9]+|[0-9]+)$/;
  53                         $stats->{$n}->{array} += $#{ $e->{$n} } + 1
  54                                 if ref $e->{$n} eq 'ARRAY';
  55                 }
  56         }
  57
  58         foreach my $n ( keys %$stats ) {
  59                 next unless defined $stats->{$n}->{array};
  60                 delete $stats->{$n}->{array}
  61                         if $stats->{$n}->{array} == $stats->{$n}->{count};
  62         }
  63
  64         warn dump($stats);
  65
  66         $self->redirect_to( '/data/columns' );
  67 }
  68
  69
  70 sub columns {
  71     my $self = shift;
  72
  73     $self->render(
  74                 message => 'Select columns to display',
  75                 stats => $stats,
  76                 checked => $self->_checked( $self->_perm_array('columns') ),
  77         );
  78 }
  79
  80 sub _perm_array {
  81     my ($self,$name) = @_;
  82
  83         my @array = $self->param($name);
  84
  85         if ( @array ) {
  86                 $self->session($name => [ @array ]);
  87         } elsif ( my $session = $self->session($name) ) {
  88                 if ( ref $session eq 'ARRAY' ) {
  89                         @array = @$session;
  90                 } else {
  91                         die "$name not array ",dump($session);
  92                 }
  93         }
  94         warn "# $name ",dump @array;
  95         return @array;
  96 }
  97
  98 sub _perm_scalar {
  99     my ($self,$name,$default) = @_;
 100
 101         my $scalar = $self->param($name);
 102
 103         if ( defined $scalar ) {
 104                 $self->session($name => $scalar);
 105         } else {
 106                 $scalar = $self->session($name);
 107         }
 108
 109         if ( ! defined $scalar ) {
 110                 $scalar = $default;
 111                 die "no default for $name" unless defined $scalar;
 112                 $self->session($name => $scalar);
 113         }
 114
 115         warn "# $name ",dump $scalar;
 116         return $scalar;
 117 }
 118
 119 sub filter {
 120         my $self = shift;
 121
 122         my $name = $self->param('filter_name') || die "name?";
 123         my @vals = $self->param('filter_vals');
 124
 125         warn "# filter $name vals ",dump(@vals);
 126
 127         my $filters = $self->session('filters');
 128         if ( @vals ) {
 129                 $filters->{$name} = [ @vals ];
 130         } else {
 131                 delete $filters->{$name};
 132         }
 133         $self->session( 'filters' => $filters );
 134
 135         warn "# filters ",dump($self->session('filters'));
 136
 137         $self->session( 'offset' => 0 );
 138
 139         $self->redirect_to('/data/table');
 140 }
 141
 142 sub _filter_item {
 143         my ( $self, $filters, $i ) = @_;
 144         my $pass = 1;
 145         foreach my $n ( keys %$filters ) {
 146                 if ( ! defined $i->{$n} ) {
 147                         $pass = 0;
 148                         last;
 149                 }
 150                 foreach my $v ( @{ $i->{$n} } ) { # FIXME not array?
 151                         $pass = 0 unless grep { m/^\Q$v\E$/ } @{ $filters->{$n} };
 152                 }
 153         }
 154         return $pass;
 155 }
 156
 157 sub _data_items {
 158         my $self = shift;
 159         my $filters = $self->session('filters');
 160         grep {
 161                 $filters ? $self->_filter_item( $filters, $_ ) : 1;
 162         } @{ $data->{items} };
 163 }
 164
 165 sub table {
 166     my $self = shift;
 167
 168         $self->redirect_to('/data/index') unless $data->{items};
 169
 170         my @columns = $self->_perm_array('columns');
 171         my $order   = $self->_perm_scalar('order', $columns[0]);
 172         my $offset  = $self->_perm_scalar('offset', 0);
 173         my $limit   = $self->_perm_scalar('limit', 20);
 174
 175         my @sorted = sort {
 176                 ( $a->{$order} || '' ) cmp ( $b->{$order} || '' ) # FIXME - multi-level sort
 177         } $self->_data_items;
 178
 179 #       warn "# sorted ", dump @sorted;
 180
 181         my $rows = $#sorted + 1;
 182
 183         warn "$rows $offset $limit";
 184
 185         $self->render(
 186                 order => $order,
 187                 offset => $offset,
 188                 limit => $limit,
 189                 sorted => [ splice @sorted, $offset, $limit ],
 190                 columns => [ @columns ],
 191                 rows => $rows,
 192         );
 193
 194 }
 195
 196
 197 sub facet {
 198         my $self = shift;
 199
 200         my $facet;
 201         my $name = $self->param('name') || die "no name";
 202
 203         foreach my $i ( $self->_data_items ) {
 204                 next unless exists $i->{$name};
 205                 if ( ref $i->{$name} eq 'ARRAY' ) {
 206                         $facet->{$_}++ foreach @{ $i->{$name} };
 207                 } else {
 208                         $facet->{ $i->{$name} }++;
 209                 }
 210         }
 211
 212 #       warn "# facet $name ",dump $facet;
 213
 214         my $checked;
 215         if ( my $f = $self->session('filters') ) {
 216                 if ( defined $f->{$name} ) {
 217                         $checked = $self->_checked( @{ $f->{$name} } );
 218                 }
 219         }
 220
 221         my $sort = $self->param('sort') || 'c';
 222
 223         my @facet_names = sort {
 224                 $sort =~ m/a/i ? lc $a cmp lc $b :
 225                 $sort =~ m/d/i ? lc $b cmp lc $a :
 226                         $facet->{$b} <=> $facet->{$a}
 227                 ;
 228         } keys %$facet;
 229
 230         $self->render( name => $name, facet => $facet, checked => $checked,
 231                 facet_names => \@facet_names, sort => $sort,
 232         );
 233 }
 234
 235 sub _checked {
 236         my $self = shift;
 237         my $checked;
 238         $checked->{$_}++ foreach @_;
 239         warn "# _checked ",dump($checked);
 240         return $checked;
 241 }
 242
 243 1;