lib/SGN/Controller/AJAX/QualityControl.pm

   1 package SGN::Controller::AJAX::QualityControl;
   2
   3 use Moose;
   4 use namespace::autoclean;
   5
   6 use Carp qw/ carp confess croak /;
   7 use Cache::File;
   8 use CXGN::Tools::Run;
   9 use File::Temp qw / tempfile tempdir /;
  10 use File::Spec::Functions qw / catfile catdir/;
  11 use File::Slurp qw /write_file read_file/;
  12 use File::Path qw / mkpath  /;
  13 use File::Copy;
  14 use File::Basename;
  15 use CXGN::Phenome::Population;
  16 use JSON;
  17 use Try::Tiny;
  18 use Scalar::Util qw /weaken reftype/;
  19 use Storable qw/ nstore retrieve /;
  20 BEGIN { extends 'Catalyst::Controller' }
  21
  22
  23 sub check_pheno_qc_result :Path('/phenotype/qualityControl/check/result/') Args(1) {
  24     my ($self, $c, $pop_id) = @_;
  25
  26     $c->stash->{pop_id} = $pop_id;
  27
  28     $self->pheno_qualityControl_output_files($c);
  29     my $qc_output_file = $c->stash->{qc_messages_json_file};
  30
  31     my $ret->{result} = undef;
  32
  33     if (-s $qc_output_file && $pop_id =~ /\d+/)
  34     {
  35     $ret->{result} = 1;
  36     }
  37
  38     $ret = to_json($ret);
  39
  40     $c->res->content_type('application/json');
  41     $c->res->body($ret);
  42
  43 }
  44
  45
  46 sub qualityControl_phenotype_data :Path('/qualityControl/phenotype/data/') Args(0) {
  47     my ($self, $c) = @_;
  48
  49     my $pop_id = $c->req->param('population_id');
  50     $c->stash->{pop_id} = $pop_id;
  51
  52     my $referer = $c->req->referer;
  53
  54     my $phenotype_file;
  55
  56     if ($referer =~ /qtl/)
  57     {
  58     my $phenotype_dir = $c->stash->{solqtl_cache_dir};
  59         $phenotype_file   = 'phenodata_' . $pop_id;
  60         $phenotype_file   = $c->controller('solGS::Files')->grep_file($phenotype_dir, $phenotype_file);
  61     }
  62     else
  63     {
  64     $c->controller('solGS::Files')->phenotype_file_name($c, $pop_id);
  65     $phenotype_file = $c->stash->{phenotype_file_name};
  66     }
  67
  68     unless (-s $phenotype_file)
  69     {
  70         $self->create_qualityControl_phenodata_file($c);
  71         $phenotype_file =  $c->stash->{phenotype_file_name};
  72     }
  73
  74     my $ret->{result} = undef;
  75
  76     if (-s $phenotype_file)
  77     {
  78         $ret->{result} = 1;
  79     }
  80
  81     $ret = to_json($ret);
  82
  83     $c->res->content_type('application/json');
  84     $c->res->body($ret);
  85
  86 }
  87
  88
  89
  90 sub trait_acronyms {
  91     my ($self, $c) = @_;
  92
  93     my $pop_id = $c->stash->{pop_id};
  94     $c->controller('solGS::Trait')->get_all_traits($c, $pop_id);
  95     $c->controller('solGS::Trait')->get_acronym_pairs($c, $pop_id);
  96
  97 }
  98
  99
 100 sub create_qualityControl_phenodata_file {
 101     my ($self, $c)  = @_;
 102
 103     my $referer = $c->req->referer;
 104
 105     my $phenotype_file;
 106     my $pop_id = $c->stash->{pop_id};
 107
 108     if ($referer =~ /qtl/)
 109     {
 110         my $pheno_exp = "phenodata_${pop_id}";
 111         my $dir       = $c->stash->{solqtl_cache_dir};
 112
 113         $phenotype_file = $c->controller('solGS::Files')->grep_file($dir, $pheno_exp);
 114
 115         unless ($phenotype_file)
 116     {
 117             my $pop =  CXGN::Phenome::Population->new($c->dbc->dbh, $pop_id);
 118             $phenotype_file =  $pop->phenotype_file($c);
 119         }
 120
 121     }
 122     else
 123     {
 124     $self->qc_pheno_query_jobs_file($c);
 125     my $queries =$c->stash->{qc_pheno_query_jobs_file};
 126
 127     $c->stash->{dependent_jobs} = $queries;
 128     $c->controller('solGS::solGS')->run_async($c);
 129
 130     $c->controller("solGS::Files")->phenotype_file_name($c, $pop_id);
 131     $phenotype_file = $c->stash->{phenotype_file_name};
 132     }
 133
 134
 135     my $qc_cache_dir = $c->stash->{qualityControl_cache_dir};
 136
 137     copy($phenotype_file, $qc_cache_dir)
 138     or die "could not copy $phenotype_file to $qc_cache_dir";
 139
 140     my $file = basename($phenotype_file);
 141     $c->stash->{phenotype_file_name} = catfile($qc_cache_dir, $file);
 142
 143 }
 144
 145
 146 sub create_qualityControl_dir {
 147     my ($self, $c) = @_;
 148
 149     $c->controller('solGS::Files')->get_solgs_dirs($c);
 150
 151 }
 152
 153
 154 sub pheno_qualityControl_output_files {
 155     my ($self, $c) = @_;
 156
 157     my $pop_id = $c->stash->{pop_id};
 158
 159     $self->create_qualityControl_dir($c);
 160     my $qc_cache_dir = $c->stash->{qualityControl_cache_dir};
 161
 162     my $file_cache  = Cache::File->new(cache_root => $qc_cache_dir);
 163     $file_cache->purge();
 164
 165     my $key_table = 'qc_messages_table_' . $pop_id;
 166     my $key_json  = 'qc_messages_json_' . $pop_id;
 167     my $qc_messages_file      = $file_cache->get($key_table);
 168     my $qc_messages_json_file = $file_cache->get($key_json);
 169
 170     unless ($qc_messages_file && $qc_messages_json_file )
 171     {
 172         $qc_messages_file = catfile($qc_cache_dir, "qc_messages_table_${pop_id}");
 173
 174         write_file($qc_messages_file);
 175         $file_cache->set($key_table, $qc_messages_file, '30 days');
 176
 177         $qc_messages_json_file = catfile($qc_cache_dir, "qc_messages_json_${pop_id}");
 178
 179         write_file($qc_messages_json_file);
 180         $file_cache->set($key_json, $qc_messages_json_file, '30 days');
 181     }
 182
 183     $c->stash->{qc_messages_table_file} = $qc_messages_file;
 184     $c->stash->{qc_messages_json_file}  = $qc_messages_json_file;
 185 }
 186
 187
 188
 189 sub pheno_qualityControl_analysis_output :Path('/phenotypic/qualityControl/analysis/output') Args(0) {
 190     my ($self, $c) = @_;
 191
 192     my $pop_id = $c->req->param('population_id');
 193     $c->stash->{pop_id} = $pop_id;
 194
 195     $self->pheno_qualityControl_output_files($c);
 196     my $qc_json_file = $c->stash->{qc_messages_json_file};
 197     my $qc_table_file = $c->stash->{qc_messages_table_file};
 198     my $ret->{status} = 'failed';
 199
 200     if (!-s $qc_json_file)
 201     {
 202         $self->run_pheno_qualityControl_analysis($c);
 203         $qc_json_file = $c->stash->{qc_messages_json_file};
 204         $qc_table_file = $c->stash->{qc_messages_table_file};
 205     }
 206
 207     if (-s $qc_json_file)
 208     {
 209     # $self->trait_acronyms($c);
 210     # my $acronyms = $c->stash->{acronym};
 211
 212     # $ret->{acronyms} = $acronyms;
 213     $ret->{status}   = 'success';
 214
 215     my $data = $c->controller('solGS::Utils')->read_file_data($qc_table_file);
 216     $ret->{data} = $data;
 217     #$ret->{data}     = read_file($qc_json_file);
 218     }
 219
 220     $ret = to_json($ret);
 221
 222     $c->res->content_type('application/json');
 223     $c->res->body($ret);
 224
 225 }
 226
 227
 228
 229 sub download_phenotypic_qualityControl : Path('/download/phenotypic/qualityControl/population') Args(1) {
 230     my ($self, $c, $id) = @_;
 231
 232     $self->create_qualityControl_dir($c);
 233     my $qc_dir = $c->stash->{qualityControl_cache_dir};
 234     my $qc_file = catfile($qc_dir,  "qc_messages_table_${id}");
 235
 236     unless (!-e $qc_file || -s $qc_file <= 1)
 237     {
 238     my @qc_data;
 239     my $count=1;
 240
 241     foreach my $row ( read_file($qc_file) )
 242     {
 243         if ($count==1) {  $row = 'Traits,' . $row;}
 244         $row =~ s/NA//g;
 245         $row = join(",", split(/\s/, $row));
 246         $row .= "\n";
 247
 248         push @qc_data, [ $row ];
 249         $count++;
 250     }
 251
 252     $c->res->content_type("text/plain");
 253     $c->res->body(join "",  map{ $_->[0] } @qc_data);
 254     }
 255 }
 256
 257
 258 sub temp_pheno_qc_output_file {
 259     my ($self, $c) = @_;
 260
 261     my $pop_id = $c->stash->{pop_id};
 262     $self->pheno_qualityControl_output_files($c);
 263
 264     my $files = join ("\t",
 265               $c->stash->{qc_messages_table_file},
 266               $c->stash->{qc_messages_json_file},
 267     );
 268
 269     my $tmp_dir = $c->stash->{qualityControl_temp_dir};
 270     my $name = "pheno_qc_output_files_${pop_id}";
 271     my $tempfile =  $c->controller('solGS::Files')->create_tempfile($tmp_dir, $name);
 272     write_file($tempfile, $files);
 273
 274     $c->stash->{temp_pheno_qc_output_file} = $tempfile;
 275
 276 }
 277
 278
 279 sub temp_pheno_qc_input_file {
 280     my ($self, $c) = @_;
 281
 282     my $pop_id = $c->stash->{pop_id};
 283
 284     $c->controller("solGS::Files")->phenotype_file_name($c, $pop_id);
 285     #$self->create_qualityControl_phenodata_file($c);
 286
 287     my $pheno_file = $c->stash->{phenotype_file_name};
 288
 289     $c->controller("solGS::Files")->formatted_phenotype_file($c);
 290     my $formatted_pheno_file = $c->stash->{formatted_phenotype_file};
 291
 292     $c->controller("solGS::Files")->phenotype_metadata_file($c);
 293     my $metadata_file = $c->stash->{phenotype_metadata_file};
 294
 295     my $files = join ("\t",
 296               $pheno_file,
 297               $formatted_pheno_file,
 298               $metadata_file,
 299               $c->req->referer,
 300     );
 301
 302     my $tmp_dir = $c->stash->{qualityControl_temp_dir};
 303     my $name = "pheno_qc_input_files_${pop_id}";
 304     my $tempfile =  $c->controller('solGS::Files')->create_tempfile($tmp_dir, $name);
 305     write_file($tempfile, $files);
 306     $c->stash->{temp_pheno_qc_input_file} = $tempfile;
 307
 308 }
 309
 310
 311
 312 sub run_pheno_qualityControl_analysis {
 313     my ($self, $c) = @_;
 314
 315     my $pop_id = $c->stash->{pop_id};
 316
 317     $self->temp_pheno_qc_input_file($c);
 318     $self->temp_pheno_qc_output_file($c);
 319
 320     $c->stash->{qc_input_files}  = $c->stash->{temp_pheno_qc_input_file};
 321     $c->stash->{qc_output_files} = $c->stash->{temp_pheno_qc_output_file};
 322
 323     $c->stash->{qualityControl_type} = "pheno-qualityControl";
 324
 325     $c->stash->{qualityControl_script} = "R/qualityControl/qc_rscript.R";
 326
 327     $self->run_qualityControl_analysis($c);
 328
 329     $self->trait_acronyms($c);
 330 }
 331
 332
 333 sub run_qualityControl_analysis {
 334     my ($self, $c) = @_;
 335
 336     my $pop_id = $c->stash->{pop_id};
 337     my $qc_type = $c->stash->{qualityControl_type};
 338
 339     $self->qc_pheno_query_jobs_file($c);
 340     my $queries_file = $c->stash->{qc_pheno_query_jobs_file};
 341
 342     $self->qc_pheno_r_jobs_file($c);
 343     my $r_jobs_file = $c->stash->{qc_pheno_r_jobs_file};
 344
 345     $c->stash->{prerequisite_jobs} = $queries_file if $queries_file;
 346     $c->stash->{dependent_jobs} = $r_jobs_file;
 347
 348     $c->controller('solGS::solGS')->run_async($c);
 349
 350 }
 351
 352
 353 sub qc_pheno_r_jobs {
 354     my ($self, $c) = @_;
 355
 356     my $pop_id = $c->stash->{trial_id} || $c->stash->{pop_id};
 357
 358     my $input_file = $c->stash->{qc_input_files};
 359     my $output_file = $c->stash->{qc_output_files};
 360
 361     my $qc_type = $c->stash->{qualityControl_type};
 362
 363     $c->stash->{input_files}  = $input_file;
 364     $c->stash->{output_files} = $output_file;
 365     $c->stash->{r_temp_file}  = "${qc_type}-${pop_id}";
 366     $c->stash->{r_script}     = $c->stash->{qualityControl_script};
 367
 368     $c->stash->{analysis_tempfiles_dir} = $c->stash->{qualityControl_temp_dir};
 369
 370     $c->controller('solGS::AsyncJob')->get_cluster_r_job_args($c);
 371     my $jobs  = $c->stash->{cluster_r_job_args};
 372
 373     if (reftype $jobs ne 'ARRAY')
 374     {
 375     $jobs = [$jobs];
 376     }
 377
 378     $c->stash->{qc_pheno_r_jobs} = $jobs;
 379
 380 }
 381
 382
 383 sub qc_pheno_r_jobs_file {
 384     my ($self, $c) = @_;
 385
 386     $self->qc_pheno_r_jobs($c);
 387     my $jobs = $c->stash->{qc_pheno_r_jobs};
 388
 389     my $temp_dir = $c->stash->{qualityControl_temp_dir};
 390     my $jobs_file =  $c->controller('solGS::Files')->create_tempfile($temp_dir, 'qc-r-jobs-file');
 391
 392     nstore $jobs, $jobs_file
 393     or croak "qualityControl r jobs : $! serializing qualityControl r jobs to $jobs_file";
 394
 395     $c->stash->{qc_pheno_r_jobs_file} = $jobs_file;
 396
 397 }
 398
 399 sub qc_pheno_query_jobs {
 400     my ($self, $c) = @_;
 401
 402     my $trial_id = $c->stash->{pop_id} || $c->stash->{trial_id};
 403
 404     $c->controller('solGS::AsyncJob')->get_trials_phenotype_query_jobs_args($c, [$trial_id]);
 405     my $jobs = $c->stash->{trials_phenotype_query_jobs_args};
 406
 407     if (reftype $jobs ne 'ARRAY')
 408     {
 409         $jobs = [$jobs];
 410     }
 411
 412     $c->stash->{qc_pheno_query_jobs} = $jobs;
 413
 414 }
 415
 416
 417 sub qc_pheno_query_jobs_file {
 418     my ($self, $c) = @_;
 419
 420     $self->qc_pheno_query_jobs($c);
 421     my $jobs = $c->stash->{qc_pheno_query_jobs};
 422
 423     my $jobs_file;
 424
 425     if ($jobs->[0])
 426     {
 427         my $temp_dir = $c->stash->{qualityControl_temp_dir};
 428         $jobs_file =  $c->controller('solGS::Files')->create_tempfile($temp_dir, 'pheno-qc-query-jobs-file');
 429
 430         nstore $jobs, $jobs_file
 431             or croak "qualityControl pheno query jobs : $! serializing qualityControl phenoquery jobs to $jobs_file";
 432     }
 433
 434     $c->stash->{qc_pheno_query_jobs_file} = $jobs_file;
 435
 436 }
 437
 438
 439 sub begin : Private {
 440     my ($self, $c) = @_;
 441
 442     $c->controller('solGS::Files')->get_solgs_dirs($c);
 443
 444 }
 445
 446
 447
 448 ####
 449 1;
 450 ####