lib/CXGN/BrAPI/v2/Scales.pm

   1 package CXGN::BrAPI::v2::Scales;
   2
   3 use Moose;
   4 use Data::Dumper;
   5 use Try::Tiny;
   6 use List::Util 'max';
   7
   8 has 'bcs_schema' => (
   9     isa => 'Bio::Chado::Schema',
  10     is => 'rw',
  11     required => 1,
  12 );
  13
  14 has 'scale' => (
  15     is => 'ro',
  16     isa => 'HashRef[Any]',
  17 );
  18
  19 has 'cvterm_id' => (
  20     isa => 'Int',
  21     is => 'rw',
  22     required => 0,
  23 );
  24
  25 has 'cv_id' => (
  26     isa => 'Int',
  27     is => 'ro',
  28     lazy => 1,
  29     default => sub {
  30         my $self = shift;
  31         my $cv_id = $self->bcs_schema->resultset("Cv::Cv")->find(
  32             {
  33                 name => 'trait_property'
  34             },
  35             { key => 'cv_c1' }
  36         )->get_column('cv_id');
  37         return $cv_id;
  38     }
  39 );
  40
  41 has 'scale_categories_id' => (
  42     isa => 'Int',
  43     is => 'ro',
  44     lazy => 1,
  45     default => sub {
  46         my $self = shift;
  47         my $scale_categories_id = $self->bcs_schema->resultset("Cv::Cvterm")->find(
  48             {
  49                 name        => 'trait_categories',
  50                 cv_id       => $self->cv_id,
  51                 is_obsolete => 0
  52             },
  53             { key => 'cvterm_c1' }
  54         )->get_column('cvterm_id');
  55         return $scale_categories_id;
  56     }
  57 );
  58
  59 has 'scale_categories_label_id' => (
  60     isa => 'Int',
  61     is => 'ro',
  62     lazy => 1,
  63     default => sub {
  64         my $self = shift;
  65         my $scale_categories_label_id = $self->bcs_schema->resultset("Cv::Cvterm")->find(
  66             {
  67                 name        => 'trait_categories_label',
  68                 cv_id       => $self->cv_id,
  69                 is_obsolete => 0
  70             },
  71             { key => 'cvterm_c1' }
  72         )->get_column('cvterm_id');
  73         return $scale_categories_label_id;
  74     }
  75 );
  76
  77 has 'scale_categories_value_id' => (
  78     isa => 'Int',
  79     is => 'ro',
  80     lazy => 1,
  81     default => sub {
  82         my $self = shift;
  83         my $scale_categories_value_id = $self->bcs_schema->resultset("Cv::Cvterm")->find(
  84             {
  85                 name        => 'trait_categories_value',
  86                 cv_id       => $self->cv_id,
  87                 is_obsolete => 0
  88             },
  89             { key => 'cvterm_c1' }
  90         )->get_column('cvterm_id');
  91         return $scale_categories_value_id;
  92     }
  93 );
  94
  95
  96
  97 has 'scale_format_id' => (
  98     isa => 'Int',
  99     is => 'ro',
 100     lazy => 1,
 101     default => sub {
 102         my $self = shift;
 103         my $scale_format_id = $self->bcs_schema->resultset("Cv::Cvterm")->find(
 104             {
 105                 name        => 'trait_format',
 106                 cv_id       => $self->cv_id,
 107                 is_obsolete => 0
 108             },
 109             { key => 'cvterm_c1' }
 110         )->get_column('cvterm_id');
 111         return $scale_format_id;
 112     }
 113 );
 114
 115 has 'scale_maximum_id' => (
 116     isa => 'Int',
 117     is => 'ro',
 118     lazy => 1,
 119     default => sub {
 120         my $self = shift;
 121         my $scale_maximum_id = $self->bcs_schema->resultset("Cv::Cvterm")->find(
 122             {
 123                 name        => 'trait_maximum',
 124                 cv_id       => $self->cv_id,
 125                 is_obsolete => 0
 126             },
 127             { key => 'cvterm_c1' }
 128         )->get_column('cvterm_id');
 129         return $scale_maximum_id;
 130     }
 131 );
 132
 133 has 'scale_minimum_id' => (
 134     isa => 'Int',
 135     is => 'ro',
 136     lazy => 1,
 137     default => sub {
 138         my $self = shift;
 139         my $scale_minimum_id = $self->bcs_schema->resultset("Cv::Cvterm")->find(
 140             {
 141                 name        => 'trait_minimum',
 142                 cv_id       => $self->cv_id,
 143                 is_obsolete => 0
 144             },
 145             { key => 'cvterm_c1' }
 146         )->get_column('cvterm_id');
 147         return $scale_minimum_id;
 148     }
 149 );
 150
 151 has 'scale_decimal_places_id' => (
 152     isa => 'Int',
 153     is => 'ro',
 154     lazy => 1,
 155     default => sub {
 156         my $self = shift;
 157         my $scale_decimal_places_id = $self->bcs_schema->resultset("Cv::Cvterm")->find(
 158             {
 159                 name        => 'trait_decimal_places',
 160                 cv_id       => $self->cv_id,
 161                 is_obsolete => 0
 162             },
 163             { key => 'cvterm_c1' }
 164         )->get_column('cvterm_id');
 165         return $scale_decimal_places_id;
 166     }
 167 );
 168
 169 has 'scale_db' => (
 170     isa => 'HashRef[Any]',
 171     is => 'ro',
 172     lazy => 1,
 173     default => sub {
 174         my $self = shift;
 175
 176         my %scale;
 177         my %categories;
 178
 179         my $props = $self->bcs_schema()->resultset("Cv::Cvtermprop")->search(
 180             {
 181                 cvterm_id => $self->cvterm_id()
 182             },
 183             {order_by => { -asc => 'rank' }}
 184         );
 185
 186         my $scale_ref = \%scale;
 187         my $data_type;
 188         my $decimal_places;
 189         my $trait_categories;
 190         my $valid_values_max;
 191         my $valid_values_min;
 192         my $additional_info;
 193         my $external_references;
 194         my $ontology_reference;
 195         my $scale_id;
 196         my $scale_name;
 197         my $scale_PUI;
 198         my $units;
 199         $scale_ref->{'validValues'}{'categories'} =undef;
 200
 201         while (my $prop = $props->next()){
 202             my $category = $categories{$prop->get_column('rank')};
 203
 204             if ($prop->get_column('type_id') == $self->scale_categories_id) {
 205                 $trait_categories = $prop->get_column('value');
 206             }
 207
 208             if ($prop->get_column('type_id') == $self->scale_categories_label_id) {
 209                 $category->{'label'} = $prop->get_column('value');
 210                 $categories{$prop->get_column('rank')}=$category;
 211             }
 212
 213             if ($prop->get_column('type_id') == $self->scale_categories_value_id) {
 214                 $category->{'value'} = $prop->get_column('value');
 215                 $categories{$prop->get_column('rank')}=$category;
 216             }
 217
 218             if ($prop->get_column('type_id') == $self->scale_format_id) {
 219                 $data_type = $prop->get_column('value');
 220             }
 221             if ($prop->get_column('type_id') == $self->scale_decimal_places_id) {
 222                 $decimal_places = $prop->get_column('value')+0;
 223             }
 224
 225             if ($prop->get_column('type_id') == $self->scale_maximum_id) {
 226                 $valid_values_max = $prop->get_column('value')+0;
 227             }
 228             if ($prop->get_column('type_id') == $self->scale_minimum_id) {
 229                 $valid_values_min = $prop->get_column('value')+0;
 230             }
 231         }
 232
 233         if ($trait_categories){ #Breedbase categories
 234             my @categories = split(/\//, $trait_categories);
 235             foreach (@categories){
 236                 push @{$scale_ref->{'validValues'}{'categories'}}, {
 237                     'label' => qq|$_|,
 238                     'value' => qq|$_|
 239                 };
 240             }
 241         } elsif (%categories) { #Implemented by BI
 242             my $ref = \%categories;
 243             my $maxkey = max keys %$ref;
 244             my @array = @{$ref}{0 .. $maxkey};
 245             $scale_ref->{'validValues'}{'categories'} = \@array;
 246         }
 247         $scale_ref->{'additionalInfo'} = $additional_info;
 248         $scale_ref->{'dataType'} = $self-> _format_data_type($data_type);
 249         $scale_ref->{'decimalPlaces'} = $decimal_places;
 250         $scale_ref->{'validValues'}{'maximumValue'} = $valid_values_max;
 251         $scale_ref->{'validValues'}{'minimumValue'} = $valid_values_min;
 252         $scale_ref->{'externalReferences'} = $external_references;
 253         $scale_ref->{'ontologyReference'} = $ontology_reference;
 254         $scale_ref->{'scaleDbId'} = $scale_id;
 255         $scale_ref->{'scaleName'} = $scale_name;
 256         $scale_ref->{'scalePUI'} = $scale_PUI;
 257         $scale_ref->{'units'} = $units;
 258
 259         return $scale_ref;
 260     }
 261 );
 262
 263 sub store {
 264     my $self = shift;
 265     my $schema = $self->bcs_schema();
 266     my $cvterm_id = $self->cvterm_id();
 267     my $scale = $self->scale();
 268     my @scale_categories;
 269
 270     if (!defined($cvterm_id)) {
 271         CXGN::BrAPI::Exceptions::ServerException->throw({message => "Error: Scale cvterm_id not specified, cannot store"});
 272     }
 273
 274     # Clear out old scale
 275     $self->delete();
 276
 277     if ($self->scale->{'validValues'}{'categories'}) {
 278         @scale_categories = @{$self->scale->{'validValues'}{'categories'}};
 279     }
 280
 281     my $scale_format_id = $self->scale_format_id;
 282     my $scale_decimal_places_id = $self->scale_decimal_places_id;
 283     my $scale_categories_id = $self->scale_categories_id;
 284     my $scale_categories_label_id = $self->scale_categories_label_id;
 285     my $scale_categories_value_id = $self->scale_categories_value_id;
 286     my $scale_maximum_id = $self->scale_maximum_id;
 287     my $scale_minimum_id = $self->scale_minimum_id;
 288
 289     my $scale_format = $scale->{'dataType'};
 290     my $scale_decimal_places = $scale->{'decimalPlaces'};
 291     my $scale_categories = $scale->{'validValues'}{'categories'};
 292     my $scale_maximum = $scale->{'validValues'}{'max'};
 293     my $scale_minimum = $scale->{'validValues'}{'min'};
 294
 295     my $rank = 0;
 296     my $categories_v1 = "";
 297
 298     my $coderef = sub {
 299
 300         # write category values for v2
 301         foreach my $category (@scale_categories) {
 302             my $label = $category->{'label'};
 303             my $value = $category->{'value'};
 304
 305             # write external reference info to dbxrefprop
 306             my $prop_id = $schema->resultset("Cv::Cvtermprop")->create(
 307                 {
 308                     cvterm_id => $cvterm_id,
 309                     type_id   => $scale_categories_label_id,
 310                     value     => defined $label && $label ne "" ? $label : $value,
 311                     rank      => $rank
 312                 }
 313             );
 314
 315             my $prop_source = $schema->resultset("Cv::Cvtermprop")->create(
 316                 {
 317                     cvterm_id => $cvterm_id,
 318                     type_id   => $scale_categories_value_id,
 319                     value     => $value,
 320                     rank      => $rank
 321                 }
 322             );
 323
 324             $rank++;
 325
 326             # form categories string for v1 call
 327             # For brapi v1, label = meaning, in brapi v2 terms, value = label.
 328             $categories_v1=$categories_v1.$value."=".$label."/";
 329         }
 330
 331         my $format = $schema->resultset("Cv::Cvtermprop")->create(
 332             {
 333                 cvterm_id => $cvterm_id,
 334                 type_id   => $scale_format_id,
 335                 value     => $scale_format,
 336                 rank      => 0
 337             }
 338         );
 339
 340         if (defined($scale_decimal_places) && length($scale_decimal_places)) {
 341             my $decimal_places = $schema->resultset("Cv::Cvtermprop")->create(
 342                 {
 343                     cvterm_id => $cvterm_id,
 344                     type_id   => $scale_decimal_places_id,
 345                     value     => $scale_decimal_places,
 346                     rank      => 0
 347                 }
 348             );
 349         }
 350
 351         # write in format used by v1 calls
 352         if ($scale_categories) {
 353             my $categories = $schema->resultset("Cv::Cvtermprop")->create(
 354                 {
 355                     cvterm_id => $cvterm_id,
 356                     type_id   => $scale_categories_id,
 357                     value     => $categories_v1,
 358                     rank      => 0
 359                 }
 360             );
 361         }
 362
 363         if (defined($scale_maximum) && length($scale_maximum)) {
 364             my $maximum = $schema->resultset("Cv::Cvtermprop")->create(
 365                 {
 366                     cvterm_id => $cvterm_id,
 367                     type_id   => $scale_maximum_id,
 368                     value     => $scale_maximum,
 369                     rank      => 0
 370                 }
 371             );
 372         }
 373
 374         if (defined($scale_minimum) && length($scale_minimum)) {
 375             my $minimum = $schema->resultset("Cv::Cvtermprop")->create(
 376                 {
 377                     cvterm_id => $cvterm_id,
 378                     type_id   => $scale_minimum_id,
 379                     value     => $scale_minimum,
 380                     rank      => 0
 381                 }
 382             );
 383         }
 384
 385     };
 386
 387     my $transaction_error;
 388
 389     try {
 390         $schema->txn_do($coderef);
 391     } catch {
 392         $transaction_error =  $_;
 393     };
 394
 395     if ($transaction_error) {
 396         return {error => "Scale transaction error trying to write to db"}
 397     }
 398
 399     return { success => "Scale added successfully" };
 400
 401 }
 402
 403 sub delete {
 404
 405     my $self = shift;
 406     my $schema = $self->bcs_schema();
 407     my $cvterm_id = $self->cvterm_id();
 408
 409     $schema->resultset("Cv::Cvtermprop")->search(
 410         {   cvterm_id => $cvterm_id,
 411             type_id   => { -in =>
 412                 [
 413                     $self->scale_format_id,
 414                     $self->scale_decimal_places_id,
 415                     $self->scale_categories_id,
 416                     $self->scale_categories_label_id,
 417                     $self->scale_categories_value_id,
 418                     $self->scale_maximum_id,
 419                     $self->scale_minimum_id
 420                 ]
 421             }
 422         }
 423     )->delete;
 424 }
 425
 426 sub _format_data_type {
 427     my $self = shift;
 428     my $value = shift;
 429     my $dataType = "Text"; #Text is the default trait_format for phenotypes in breedbase
 430     $value =~ s/^\s+|\s+$//g;
 431
 432     if ($value) {
 433         my %formats = (
 434             "categorical" => "Ordinal",
 435             "numeric" => "Numerical",
 436             "qualitative" => "Nominal",
 437             "numerical" => "Numerical",
 438             "nominal" => "Nominal",
 439             "code" => "Code",
 440             "date" => "Date" ,
 441             "duration" => "Duration",
 442             "ordinal" => "Ordinal",
 443             "text" => "Text",
 444             "photo" => "Photo",
 445             "multicat" => "Multicat",
 446         );
 447
 448         $dataType = $formats{lc $value} ? $formats{lc $value} : $dataType;
 449     }
 450     return $dataType;
 451 }
 452
 453 1;