lib/SGN/Controller/solGS/combinedTrials.pm

   1 package SGN::Controller::solGS::combinedTrials;
   2
   3 use Moose;
   4 use namespace::autoclean;
   5
   6 use String::CRC;
   7 use URI::FromHash 'uri';
   8 use File::Path qw / mkpath  /;
   9 use File::Spec::Functions qw / catfile catdir/;
  10 use File::Temp qw / tempfile tempdir /;
  11 use File::Slurp qw /write_file read_file :edit prepend_file/;
  12 use File::Copy;
  13 use File::Basename;
  14 use Cache::File;
  15 use Try::Tiny;
  16 use List::MoreUtils qw /uniq/;
  17 use Scalar::Util qw /weaken reftype/;
  18 use Array::Utils qw(:all);
  19 use CXGN::Tools::Run;
  20 use JSON;
  21
  22
  23 BEGIN { extends 'Catalyst::Controller' }
  24
  25
  26 sub get_combined_pops_id :Path('/solgs/get/combined/populations/id') Args() {
  27     my ($self, $c) = @_;
  28
  29     my @pops_ids = $c->req->param('trials[]');
  30
  31     my $combo_pops_id;
  32     my $ret->{status} = 0;
  33
  34     if (@pops_ids > 1)
  35     {
  36         $c->stash->{pops_ids_list} = \@pops_ids;
  37         $self->create_combined_pops_id($c);
  38         my $combo_pops_id = $c->stash->{combo_pops_id};
  39
  40         my $ids = join(',', @pops_ids);
  41         my $entry = "\n" . $combo_pops_id . "\t" . $ids;
  42         $c->controller("solGS::solGS")->catalogue_combined_pops($c, $entry);
  43
  44         $ret->{combo_pops_id} = $combo_pops_id;
  45         $ret->{status} = 1;
  46     }
  47
  48     $ret = to_json($ret);
  49
  50     $c->res->content_type('application/json');
  51     $c->res->body($ret);
  52
  53 }
  54
  55
  56 sub prepare_data_for_trials :Path('/solgs/retrieve/populations/data') Args() {
  57     my ($self, $c) = @_;
  58
  59     my @pops_ids = $c->req->param('trials[]');
  60
  61     my $combo_pops_id;
  62     my $ret->{status} = 0;
  63
  64     my $solgs_controller = $c->controller('solGS::solGS');
  65     my $not_matching_pops;
  66     my @g_files;
  67
  68     if (scalar(@pops_ids) > 1)
  69     {
  70         $c->stash->{pops_ids_list} = \@pops_ids;
  71         $self->create_combined_pops_id($c);
  72         my $combo_pops_id = $c->stash->{combo_pops_id};
  73
  74         my $ids = join(',', @pops_ids);
  75         my $entry = "\n" . $combo_pops_id . "\t" . $ids;
  76         $solgs_controller->catalogue_combined_pops($c, $entry);
  77
  78         $self->prepare_multi_pops_data($c);
  79
  80         my $geno_files = $c->stash->{multi_pops_geno_files};
  81         @g_files = split(/\t/, $geno_files);
  82
  83         $solgs_controller->compare_genotyping_platforms($c, \@g_files);
  84         $not_matching_pops =  $c->stash->{pops_with_no_genotype_match};
  85
  86         if (!$not_matching_pops)
  87         {
  88             $self->save_common_traits_acronyms($c);
  89         }
  90         else
  91         {
  92             $ret->{not_matching_pops} = $not_matching_pops;
  93         }
  94
  95         $ret->{combined_pops_id} = $combo_pops_id;
  96     }
  97     else
  98     {
  99         my $pop_id = $pops_ids[0];
 100
 101         $c->stash->{pop_id} = $pop_id;
 102         $solgs_controller->phenotype_file($c);
 103         $solgs_controller->genotype_file($c);
 104
 105         $ret->{redirect_url} = "/solgs/population/$pop_id";
 106     }
 107
 108     $ret = to_json($ret);
 109
 110     $c->res->content_type('application/json');
 111     $c->res->body($ret);
 112
 113 }
 114
 115
 116 sub combined_trials_page :Path('/solgs/populations/combined') Args(1) {
 117     my ($self, $c, $combo_pops_id) = @_;
 118
 119     $c->stash->{pop_id} = $combo_pops_id;
 120     $c->stash->{combo_pops_id} = $combo_pops_id;
 121
 122     $self->save_common_traits_acronyms($c);
 123
 124     my $solgs_controller = $c->controller('solGS::solGS');
 125
 126     $solgs_controller->get_all_traits($c);
 127     #$solgs_controller->select_traits($c);
 128     $solgs_controller->get_acronym_pairs($c);
 129
 130     $self->combined_trials_desc($c);
 131
 132     $c->stash->{template} = $solgs_controller->template('/population/combined/combined.mas');
 133
 134 }
 135
 136
 137 sub model_combined_trials_trait :Path('/solgs/model/combined/trials') Args(3) {
 138     my ($self, $c, $combo_pops_id, $trait_txt, $trait_id) = @_;
 139
 140     $c->stash->{combo_pops_id} = $combo_pops_id;
 141     $c->stash->{trait_id}      = $trait_id;
 142
 143     $self->combine_trait_data($c);
 144     $self->build_model_combined_trials_trait($c);
 145
 146     $c->controller('solGS::solGS')->gebv_kinship_file($c);
 147     my $gebv_file = $c->stash->{gebv_kinship_file};
 148
 149     if ( -s $gebv_file )
 150     {
 151         $c->res->redirect("/solgs/model/combined/populations/$combo_pops_id/trait/$trait_id");
 152         $c->detach();
 153     }
 154
 155 }
 156
 157
 158 sub models_combined_trials :Path('/solgs/models/combined/trials') Args(1) {
 159     my ($self, $c, $combo_pops_id) = @_;
 160
 161     $c->stash->{combo_pops_id} = $combo_pops_id;
 162     $c->stash->{model_id} = $combo_pops_id;
 163     $c->stash->{pop_id} = $combo_pops_id;
 164     $c->stash->{data_set_type} = 'combined populations';
 165
 166     my @traits_ids = $c->req->param('trait_id[]');
 167     my $req = $c->req->param('source');
 168     my @traits_pages;
 169
 170     my $solgs_controller = $c->controller('solGS::solGS');
 171
 172     if (!@traits_ids) {
 173
 174         $solgs_controller->analyzed_traits($c);
 175         my @analyzed_traits  = @{ $c->stash->{analyzed_traits} };
 176
 177         foreach my $tr (@analyzed_traits)
 178         {
 179             my $acronym_pairs = $solgs_controller->get_acronym_pairs($c);
 180             my $trait_name;
 181             if ($acronym_pairs)
 182             {
 183                 foreach my $r (@$acronym_pairs)
 184                 {
 185                     if ($r->[0] eq $tr)
 186                     {
 187                         $trait_name = $r->[1];
 188                         $trait_name =~ s/\n//g;
 189                         $c->stash->{trait_name} = $trait_name;
 190                         $c->stash->{trait_abbr} = $r->[0];
 191                     }
 192                 }
 193             }
 194
 195             my $trait_id   = $c->model('solGS::solGS')->get_trait_id($trait_name);
 196             my $trait_abbr = $c->stash->{trait_abbr};
 197
 198             $solgs_controller->get_model_accuracy_value($c, $combo_pops_id, $trait_abbr);
 199             my $accuracy_value = $c->stash->{accuracy_value};
 200
 201             $c->controller("solGS::Heritability")->get_heritability($c);
 202             my $heritability = $c->stash->{heritability};
 203
 204             push @traits_pages,
 205             [ qq | <a href="/solgs/model/combined/populations/$combo_pops_id/trait/$trait_id" onclick="solGS.waitPage()">$trait_abbr</a>|, $accuracy_value, $heritability];
 206         }
 207     }
 208     elsif (scalar(@traits_ids) == 1)
 209     {
 210         my $trait_id = $traits_ids[0];
 211         $c->res->redirect("/solgs/model/combined/trials/$combo_pops_id/trait/$trait_id");
 212         $c->detach();
 213     }
 214     elsif (scalar(@traits_ids) > 1)
 215     {
 216         foreach my $trait_id (@traits_ids)
 217         {
 218             $c->stash->{trait_id} = $trait_id;
 219             $solgs_controller->get_trait_details($c, $trait_id);
 220             my $tr_abbr = $c->stash->{trait_abbr};
 221
 222             $self->combine_trait_data($c);
 223             $self->build_model_combined_trials_trait($c);
 224
 225             $solgs_controller->get_model_accuracy_value($c, $combo_pops_id, $tr_abbr);
 226             my $accuracy_value = $c->stash->{accuracy_value};
 227
 228             $c->controller("solGS::Heritability")->get_heritability($c);
 229             my $heritability = $c->stash->{heritability};
 230
 231             push @traits_pages,
 232             [ qq | <a href="/solgs/model/combined/populations/$combo_pops_id/trait/$trait_id" onclick="solGS.waitPage()">$tr_abbr</a>|, $accuracy_value, $heritability];
 233
 234         }
 235     }
 236
 237     if ($req =~ /AJAX/)
 238     {
 239         my $ret->{status} = 'success';
 240         $ret = to_json($ret);
 241
 242         $c->res->content_type('application/json');
 243         $c->res->body($ret);
 244     }
 245     else
 246     {
 247         $solgs_controller->analyzed_traits($c);
 248         my $analyzed_traits = $c->stash->{analyzed_traits};
 249
 250         $c->stash->{trait_pages} = \@traits_pages;
 251         $c->stash->{template}    = $solgs_controller->template('/population/combined/multiple_traits_output.mas');
 252
 253         $self->combined_trials_desc($c);
 254
 255         my $project_name = $c->stash->{project_name};
 256         my $project_desc = $c->stash->{project_desc};
 257
 258         my @model_desc = ([qq | <a href="/solgs/populations/combined/$combo_pops_id">$project_name</a> |, $project_desc, \@traits_pages]);
 259         $c->stash->{model_data} = \@model_desc;
 260         $c->stash->{pop_id} = $combo_pops_id;
 261         $solgs_controller->get_acronym_pairs($c);
 262     }
 263 }
 264
 265
 266 sub display_combined_pops_result :Path('/solgs/model/combined/populations/') Args(3){
 267     my ($self, $c,  $combo_pops_id, $trait_key,  $trait_id,) = @_;
 268
 269     $c->stash->{data_set_type} = 'combined populations';
 270     $c->stash->{combo_pops_id} = $combo_pops_id;
 271
 272     my $pops_cvs = $c->req->param('combined_populations');
 273     my $solgs_controller = $c->controller('solGS::solGS');
 274
 275     if ($pops_cvs)
 276     {
 277         my @pops = split(',', $pops_cvs);
 278         $c->stash->{trait_combo_pops} = \@pops;
 279     }
 280     else
 281     {
 282         $solgs_controller->get_combined_pops_list($c, $combo_pops_id);
 283         $c->stash->{trait_combo_pops} = $c->stash->{combined_pops_list};
 284     }
 285
 286     $solgs_controller->get_trait_details($c, $trait_id);
 287     $solgs_controller->trait_phenotype_stat($c);
 288     $solgs_controller->validation_file($c);
 289     $solgs_controller->model_accuracy($c);
 290     $solgs_controller->gebv_kinship_file($c);
 291     $solgs_controller->blups_file($c);
 292     $solgs_controller->download_urls($c);
 293     $solgs_controller->gebv_marker_file($c);
 294     $solgs_controller->top_markers($c);
 295     $solgs_controller->combined_pops_summary($c);
 296     $solgs_controller->model_parameters($c);
 297
 298     $c->stash->{template} = $solgs_controller->template('/model/combined/populations/trait.mas');
 299 }
 300
 301
 302 sub selection_combined_pops_trait :Path('/solgs/selection/') Args(6) {
 303     my ($self, $c, $selection_pop_id,
 304         $model_key, $combined_key, $model_id,
 305         $trait_key, $trait_id) = @_;
 306
 307     $c->stash->{combo_pops_id}        = $model_id;
 308     $c->stash->{trait_id}             = $trait_id;
 309     $c->stash->{prediction_pop_id}    = $selection_pop_id;
 310     $c->stash->{data_set_type}        = 'combined populations';
 311     $c->stash->{combined_populations} = 1;
 312
 313     $c->controller('solGS::solGS')->get_trait_details($c, $trait_id);
 314
 315     if ($selection_pop_id =~ /uploaded/)
 316     {
 317         $c->controller('solGS::solGS')->uploaded_population_summary($c, $selection_pop_id);
 318         $c->stash->{selection_pop_id} = $c->stash->{project_id};
 319         $c->stash->{selection_pop_name} = $c->stash->{project_name};
 320         $c->stash->{selection_pop_desc} = $c->stash->{project_desc};
 321         $c->stash->{selection_pop_owner} = $c->stash->{owner};
 322     }
 323     else
 324     {
 325         $c->controller('solGS::solGS')->get_project_details($c, $selection_pop_id);
 326         $c->stash->{selection_pop_id} = $c->stash->{project_id};
 327         $c->stash->{selection_pop_name} = $c->stash->{project_name};
 328         $c->stash->{selection_pop_desc} = $c->stash->{project_desc};
 329
 330         $c->controller('solGS::solGS')->get_project_owners($c, $selection_pop_id);
 331         $c->stash->{selection_pop_owner} = $c->stash->{project_owners};
 332     }
 333
 334     my $mr_cnt_args = {'selection_pop' => 1,  'selection_pop_id' => $selection_pop_id};
 335     my $sel_pop_mr_cnt = $c->controller('solGS::solGS')->get_markers_count($c, $mr_cnt_args);
 336     $c->stash->{selection_markers_cnt} = $sel_pop_mr_cnt;
 337
 338     my $protocol = $c->config->{default_genotyping_protocol};
 339     $protocol = 'N/A' if !$protocol;
 340     $c->stash->{protocol} = $protocol;
 341
 342     my $identifier    = $model_id . '_' . $selection_pop_id;
 343     $c->controller('solGS::solGS')->prediction_pop_gebvs_file($c, $identifier, $trait_id);
 344     my $gebvs_file = $c->stash->{prediction_pop_gebvs_file};
 345
 346     my @stock_rows = read_file($gebvs_file);
 347     $c->stash->{selection_stocks_cnt} = scalar(@stock_rows) - 1;
 348
 349     $c->controller('solGS::solGS')->top_blups($c, $gebvs_file);
 350
 351     $c->stash->{blups_download_url} = qq | <a href="/solgs/download/prediction/model/$model_id/prediction/$selection_pop_id/$trait_id">Download all GEBVs</a>|;
 352
 353     $c->stash->{template} = $c->controller('solGS::solGS')->template('/selection/combined/selection_trait.mas');
 354 }
 355
 356
 357 sub build_model_combined_trials_trait {
 358     my ($self, $c) = @_;
 359
 360     my $solgs_controller = $c->controller('solGS::solGS');
 361     $c->stash->{data_set_type} = 'combined populations';
 362
 363     $solgs_controller->gebv_kinship_file($c);
 364     my $gebv_file = $c->stash->{gebv_kinship_file};
 365
 366     unless  ( -s $gebv_file )
 367     {
 368         my $combined_pops_pheno_file = $c->stash->{trait_combined_pheno_file};
 369         my $combined_pops_geno_file  = $c->stash->{trait_combined_geno_file};
 370
 371         $c->stash->{pop_id} = $c->stash->{combo_pops_id};
 372         $solgs_controller->get_rrblup_output($c);
 373     }
 374 }
 375
 376
 377 sub combine_trait_data {
 378     my ($self, $c) = @_;
 379
 380     my $combo_pops_id = $c->stash->{combo_pops_id};
 381     my $trait_id      = $c->stash->{trait_id};
 382
 383     my $solgs_controller = $c->controller('solGS::solGS');
 384     $solgs_controller->get_trait_details($c, $trait_id);
 385
 386     $solgs_controller->cache_combined_pops_data($c);
 387
 388     my $combined_pops_pheno_file = $c->stash->{trait_combined_pheno_file};
 389     my $combined_pops_geno_file  = $c->stash->{trait_combined_geno_file};
 390
 391     my $geno_cnt  = (split(/\s+/, qx / wc -l $combined_pops_geno_file /))[0];
 392     my $pheno_cnt = (split(/\s+/, qx / wc -l $combined_pops_pheno_file /))[0];
 393
 394     unless ( $geno_cnt > 10  && $pheno_cnt > 10 )
 395     {
 396         $self->get_combined_pops_arrayref($c);
 397         my $combined_pops_list = $c->stash->{arrayref_combined_pops_ids};
 398         $c->stash->{trait_combine_populations} = $combined_pops_list;
 399
 400         $self->prepare_multi_pops_data($c);
 401
 402         my $background_job = $c->stash->{background_job};
 403         my $prerequisite_jobs = $c->stash->{prerequisite_jobs};
 404
 405         if ($background_job)
 406         {
 407             if ($prerequisite_jobs =~ /^:+$/)
 408             {
 409                 $prerequisite_jobs = undef;
 410             }
 411
 412             if ($prerequisite_jobs)
 413             {
 414                 $c->stash->{dependency}      =  $prerequisite_jobs;
 415                 $c->stash->{dependency_type} = 'download_data';
 416             }
 417         }
 418
 419         $solgs_controller->r_combine_populations($c);
 420     }
 421
 422 }
 423
 424
 425 sub combine_data_build_model {
 426     my ($self, $c) = @_;
 427
 428     my $trait_id = $c->stash->{trait_id};
 429     $c->controller('solGS::solGS')->get_trait_details($c, $trait_id);
 430
 431     $self->combine_trait_data($c);
 432
 433     my $combine_job_id = $c->stash->{combine_pops_job_id};
 434
 435     if ($combine_job_id)
 436     {
 437         $c->stash->{dependency} = "'" . $combine_job_id . "'";
 438
 439         if (!$c->stash->{dependency_type})
 440         {
 441             $c->stash->{dependency_type} = 'combine_populations';
 442         }
 443     }
 444
 445     $self->build_model_combined_trials_trait($c);
 446
 447 }
 448
 449
 450 sub combined_trials_desc {
 451     my ($self, $c) = @_;
 452
 453     my $combo_pops_id = $c->stash->{combo_pops_id};
 454
 455     $self->get_combined_pops_arrayref($c);
 456     my $combined_pops_list = $c->stash->{arrayref_combined_pops_ids};
 457
 458     my $solgs_controller = $c->controller('solGS::solGS');
 459
 460     my $desc = 'This training population is a combination of ';
 461
 462     my $projects_owners;
 463     my $s_pop_id;
 464
 465     foreach my $pop_id (@$combined_pops_list)
 466     {
 467         my $pr_rs = $c->model('solGS::solGS')->project_details($pop_id);
 468
 469         while (my $row = $pr_rs->next)
 470         {
 471             my $pr_id   = $row->id;
 472             my $pr_name = $row->name;
 473             $desc .= qq | <a href="/solgs/population/$pr_id">$pr_name</a>|;
 474             $desc .= $pop_id == $combined_pops_list->[-1] ? '.' : ' and ';
 475         }
 476
 477         $solgs_controller->get_project_owners($c, $_);
 478         my $project_owners = $c->stash->{project_owners};
 479
 480         unless (!$project_owners)
 481         {
 482              $projects_owners.= $projects_owners ? ', ' . $project_owners : $project_owners;
 483         }
 484
 485         $s_pop_id = $pop_id;
 486         $s_pop_id =~ s/\s+//;
 487     }
 488
 489     $c->stash->{pop_id} = $s_pop_id;
 490     $solgs_controller->filtered_training_genotype_file($c);
 491     my $filtered_geno_file  = $c->stash->{filtered_training_genotype_file};
 492
 493     my $markers_no;
 494     my @geno_lines;
 495     my $dir = $c->{stash}->{solgs_cache_dir};
 496
 497     if (-s $filtered_geno_file)
 498     {
 499         @geno_lines = read_file($filtered_geno_file);
 500         $markers_no = scalar(split('\t', $geno_lines[0])) - 1;
 501     }
 502     else
 503     {
 504         my $geno_exp  = "genotype_data_${s_pop_id}.txt";
 505         my $geno_file = $solgs_controller->grep_file($dir, $geno_exp);
 506         @geno_lines   = read_file($geno_file);
 507         $markers_no   = scalar(split ('\t', $geno_lines[0])) - 1;
 508     }
 509
 510     my $trait_exp        = "traits_acronym_pop_${combo_pops_id}";
 511     my $traits_list_file = $solgs_controller->grep_file($dir, $trait_exp);
 512
 513     my @traits_list = read_file($traits_list_file);
 514     my $traits_no   = scalar(@traits_list) - 1;
 515
 516     my $stock_no  = scalar(@geno_lines) - 1;
 517
 518     my $training_pop = "Training population $combo_pops_id";
 519
 520     my $protocol = $c->config->{default_genotyping_protocol};
 521     $protocol = 'N/A' if !$protocol;
 522
 523     $c->stash(stocks_no    => $stock_no,
 524               markers_no   => $markers_no,
 525               traits_no    => $traits_no,
 526               project_desc => $desc,
 527               project_name => $training_pop,
 528               owner        => $projects_owners,
 529               protocol     => $protocol,
 530         );
 531 }
 532
 533
 534 sub find_common_traits {
 535     my ($self, $c) = @_;
 536
 537     my $combo_pops_id = $c->stash->{combo_pops_id};
 538
 539     $self->get_combined_pops_arrayref($c);
 540     my $combined_pops_list = $c->stash->{arrayref_combined_pops_ids};
 541
 542     my $solgs_controller = $c->controller('solGS::solGS');
 543
 544     my @common_traits;
 545     foreach my $pop_id (@$combined_pops_list)
 546     {
 547         $c->stash->{pop_id} = $pop_id;
 548
 549         $solgs_controller->get_single_trial_traits($c);
 550         $solgs_controller->traits_list_file($c);
 551         my $traits_list_file = $c->stash->{traits_list_file};
 552
 553         my $traits = read_file($traits_list_file);
 554         my @trial_traits = split(/\t/, $traits);
 555
 556         if (@common_traits)
 557         {
 558             @common_traits = intersect(@common_traits, @trial_traits);
 559         }
 560         else
 561         {
 562             @common_traits = @trial_traits;
 563         }
 564     }
 565
 566     $c->stash->{common_traits} = \@common_traits;
 567 }
 568
 569
 570 sub save_common_traits_acronyms {
 571     my ($self, $c) = @_;
 572
 573     my $combo_pops_id = $c->stash->{combo_pops_id};
 574
 575     $self->find_common_traits($c);
 576     my $common_traits = $c->stash->{common_traits};
 577
 578     $c->stash->{pop_id} = $combo_pops_id;
 579     $c->controller('solGS::solGS')->traits_list_file($c);
 580     my $traits_file = $c->stash->{traits_list_file};
 581     write_file($traits_file, join("\t", @$common_traits)) if $traits_file;
 582
 583 }
 584
 585
 586 sub get_combined_pops_arrayref {
 587    my ($self, $c) = @_;
 588
 589    my $combo_pops_id = $c->stash->{combo_pops_id};
 590
 591    $c->controller('solGS::solGS')->get_combined_pops_list($c, $combo_pops_id);
 592    my $pops_list = $c->stash->{combined_pops_list};
 593
 594    $c->stash->{arrayref_combined_pops_ids} = $pops_list;
 595
 596 }
 597
 598
 599 sub prepare_multi_pops_data {
 600    my ($self, $c) = @_;
 601
 602    $self->get_combined_pops_arrayref($c);
 603    my $combined_pops_list = $c->stash->{arrayref_combined_pops_ids};
 604
 605    my $solgs_controller = $c->controller('solGS::solGS');
 606
 607    $solgs_controller->multi_pops_phenotype_data($c, $combined_pops_list);
 608    $solgs_controller->multi_pops_genotype_data($c, $combined_pops_list);
 609    $solgs_controller->multi_pops_geno_files($c, $combined_pops_list);
 610    $solgs_controller->multi_pops_pheno_files($c, $combined_pops_list);
 611
 612    my @all_jobs = (@{$c->stash->{multi_pops_pheno_jobs_ids}},
 613                    @{$c->stash->{multi_pops_geno_jobs_ids}});
 614
 615    my $prerequisite_jobs;
 616
 617    if (@all_jobs && scalar(@all_jobs) > 1)
 618    {
 619        $prerequisite_jobs = join(':', @all_jobs);
 620
 621    }
 622    else
 623    {
 624        if (@all_jobs && scalar(@all_jobs) == 1) { $prerequisite_jobs = $all_jobs[0];}
 625    }
 626
 627    if ($prerequisite_jobs =~ /^:+$/) {$prerequisite_jobs = undef;}
 628
 629    $c->stash->{prerequisite_jobs} = $prerequisite_jobs;
 630
 631 }
 632
 633
 634 sub create_combined_pops_id {
 635     my ($self, $c) = @_;
 636
 637     $c->stash->{combo_pops_id} = crc(join('', @{$c->stash->{pops_ids_list}}));
 638
 639 }
 640
 641
 642 sub begin : Private {
 643     my ($self, $c) = @_;
 644
 645     $c->controller("solGS::solGS")->get_solgs_dirs($c);
 646
 647 }
 648
 649
 650 #####
 651 1;
 652 #####