lib/SGN/Controller/AJAX/TrackingActivity.pm

   1
   2 package SGN::Controller::AJAX::TrackingActivity;
   3
   4 use Moose;
   5 use CXGN::Stock::Order;
   6 use CXGN::Stock::OrderBatch;
   7 use Data::Dumper;
   8 use JSON;
   9 use DateTime;
  10 use CXGN::People::Person;
  11 use CXGN::Contact;
  12 use CXGN::Trial::Download;
  13 use CXGN::Stock::TrackingActivity::TrackingIdentifier;
  14 use CXGN::Stock::TrackingActivity::ActivityInfo;
  15 use CXGN::TrackingActivity::AddActivityProject;
  16 use CXGN::TrackingActivity::ActivityProject;
  17 use SGN::Model::Cvterm;
  18 use CXGN::Location::LocationLookup;
  19 use CXGN::List;
  20
  21 use File::Basename qw | basename dirname|;
  22 use File::Copy;
  23 use File::Slurp;
  24 use File::Spec::Functions;
  25 use Digest::MD5;
  26 use File::Path qw(make_path);
  27 use File::Spec::Functions qw / catfile catdir/;
  28
  29 use LWP::UserAgent;
  30 use LWP::Simple;
  31 use HTML::Entities;
  32 use URI::Encode qw(uri_encode uri_decode);
  33 use Tie::UrlEncoder; our(%urlencode);
  34
  35
  36 BEGIN { extends 'Catalyst::Controller::REST' }
  37
  38 __PACKAGE__->config(
  39     default   => 'application/json',
  40     stash_key => 'rest',
  41     map       => { 'application/json' => 'JSON', 'text/html' => 'JSON' },
  42    );
  43
  44
  45 sub create_tracking_activity_project : Path('/ajax/tracking_activity/create_tracking_activity_project') : ActionClass('REST'){ }
  46
  47 sub create_tracking_activity_project_POST : Args(0) {
  48     my $self = shift;
  49     my $c = shift;
  50
  51     my $user = $c->user();
  52     if (!$user) {
  53         $c->res->redirect( uri( path => '/user/login', query => { goto_url => $c->req->uri->path_query } ) );
  54         return;
  55     }
  56
  57     if (!($user->has_role('submitter') or $user->has_role('curator'))) {
  58         $c->stash->{rest} = { error => "You do not have sufficient privileges to create tracking activity project." };
  59         return;
  60     }
  61
  62     my $user_id = $c->user()->get_object()->get_sp_person_id();
  63     my $schema = $c->dbic_schema('Bio::Chado::Schema', 'sgn_chado');
  64     my $dbh = $c->dbc->dbh;
  65
  66     my $project_name = $c->req->param("project_name");
  67     my $activity_type = $c->req->param("activity_type");
  68     my $breeding_program_id = $c->req->param("breeding_program");
  69     my $project_location = $c->req->param("project_location");
  70     my $year = $c->req->param("year");
  71     my $project_description = $c->req->param("project_description");
  72
  73     my $geolocation_lookup = CXGN::Location::LocationLookup->new(schema =>$schema);
  74     $geolocation_lookup->set_location_name($project_location);
  75     if(!$geolocation_lookup->get_geolocation()){
  76         $c->stash->{rest}={error => "Location not found"};
  77         return;
  78     }
  79
  80     my $error;
  81     eval{
  82         my $add_activity_project = CXGN::TrackingActivity::AddActivityProject->new({
  83             bcs_schema => $schema,
  84             dbh => $dbh,
  85             breeding_program_id => $breeding_program_id,
  86             year => $year,
  87             project_description => $project_description,
  88             activity_project_name => $project_name,
  89             activity_type => $activity_type,
  90             nd_geolocation_id => $geolocation_lookup->get_geolocation()->nd_geolocation_id(),
  91             owner_id => $user_id
  92         });
  93
  94         my $return = $add_activity_project->save_activity_project();
  95         if (!$return){
  96             $c->stash->{rest} = {error => "Error saving project",};
  97             return;
  98         }
  99
 100 #        if ($return->{error}){
 101 #            $error = $return->{error};
 102 #        }
 103     };
 104
 105     if ($@) {
 106         $c->stash->{rest} = {error => $@};
 107         return;
 108     };
 109
 110
 111     if ($error){
 112         $c->stash->{rest} = {error => $error};
 113     } else {
 114         $c->stash->{rest} = {success => 1};
 115     }
 116
 117 }
 118
 119
 120 sub generate_tracking_identifiers : Path('/ajax/tracking_activity/generate_tracking_identifiers') : ActionClass('REST'){ }
 121
 122 sub generate_tracking_identifiers_POST : Args(0) {
 123     my $self = shift;
 124     my $c = shift;
 125
 126     if (!$c->user()) {
 127         $c->stash->{rest} = { error_string => "You must be logged in to generate tracking identifiers." };
 128         return;
 129     }
 130     if (!($c->user()->has_role('submitter') or $c->user()->has_role('curator'))) {
 131         $c->stash->{rest} = { error_string => "You do not have sufficient privileges to generate tracking identifiers." };
 132         return;
 133     }
 134
 135     my $user_id = $c->user()->get_object()->get_sp_person_id();
 136     my $schema = $c->dbic_schema('Bio::Chado::Schema', 'sgn_chado');
 137     my $phenome_schema = $c->dbic_schema("CXGN::Phenome::Schema");
 138     my $dbh = $c->dbc->dbh();
 139
 140     my $project_name = $c->req->param("project_name");
 141     my $list_id = $c->req->param("list_id");
 142     my $project_id;
 143     my $project_rs = $schema->resultset("Project::Project")->find( { name => $project_name });
 144     if (!$project_rs) {
 145         $c->stash->{rest} = { error_string => "Error! Project name: $project_name was not found in the database.\n" };
 146         return;
 147     } else {
 148         $project_id = $project_rs->project_id();
 149     }
 150
 151     my $activity_project = CXGN::TrackingActivity::ActivityProject->new(bcs_schema => $schema, trial_id => $project_id);
 152     my $all_identifiers = $activity_project->get_project_active_identifiers();
 153     my $last_number = scalar (@$all_identifiers);
 154
 155     my $list = CXGN::List->new( { dbh=>$dbh, list_id=>$list_id });
 156     my $material_names = $list->elements();
 157
 158     my @check_identifier_names;
 159     my @tracking_identifiers;
 160     my @error_messages;
 161     foreach my $name (sort @$material_names) {
 162         $last_number++;
 163         my $tracking_id = $project_name.":".$name."_"."T".(sprintf "%04d", $last_number);
 164         push @tracking_identifiers, [$tracking_id, $name];
 165         push @check_identifier_names, $tracking_id;
 166     }
 167
 168     my $rs = $schema->resultset("Stock::Stock")->search({
 169         'is_obsolete' => { '!=' => 't' },
 170         'uniquename' => { -in => \@check_identifier_names }
 171     });
 172     while (my $r=$rs->next){
 173         push @error_messages, "Tracking identifier name already exists in database: ".$r->uniquename;
 174     }
 175
 176     if (scalar(@error_messages) >= 1) {
 177         $c->stash->{rest} = { error_string => \@error_messages};
 178         return;
 179     }
 180
 181     foreach my $identifier_info (@tracking_identifiers) {
 182         my $tracking_identifier = $identifier_info->[0];
 183         my $material = $identifier_info->[1];
 184
 185         my $tracking_obj = CXGN::Stock::TrackingActivity::TrackingIdentifier->new({
 186             schema => $schema,
 187             phenome_schema => $phenome_schema,
 188             tracking_identifier => $tracking_identifier,
 189             material => $material,
 190             project_id => $project_id,
 191             user_id => $user_id
 192          });
 193
 194         my $return = $tracking_obj->store();
 195         if (!$return){
 196             $c->stash->{rest} = {error_string => "Error generating tracking identifier",};
 197             return;
 198         }
 199     }
 200
 201     $c->stash->{rest} = { success => 1};
 202
 203 }
 204
 205
 206 sub activity_info_save : Path('/ajax/tracking_activity/save') : ActionClass('REST'){ }
 207
 208 sub activity_info_save_POST : Args(0) {
 209     my $self = shift;
 210     my $c = shift;
 211
 212     if (!$c->user()) {
 213         $c->stash->{rest} = { error => "You must be logged in to add new information." };
 214         return;
 215     }
 216     if (!($c->user()->has_role('submitter') or $c->user()->has_role('curator'))) {
 217         $c->stash->{rest} = { error => "You do not have sufficient privileges to record new information." };
 218         return;
 219     }
 220
 221     my $user_id = $c->user()->get_object()->get_sp_person_id();
 222
 223     my $tracking_identifier = $c->req->param("tracking_identifier");
 224     my $selected_type = $c->req->param("selected_type");
 225     my $input = $c->req->param("input");
 226     my $notes = $c->req->param("notes");
 227     my $record_timestamp = $c->req->param("record_timestamp");
 228
 229     my $schema = $c->dbic_schema('Bio::Chado::Schema', 'sgn_chado');
 230
 231     my $add_activity_info = CXGN::Stock::TrackingActivity::ActivityInfo->new({
 232         schema => $schema,
 233         tracking_identifier => $tracking_identifier,
 234         selected_type => $selected_type,
 235         input => $input,
 236         timestamp => $record_timestamp,
 237         operator_id => $user_id,
 238         notes => $notes,
 239     });
 240     my $return = $add_activity_info->add_info();
 241 #    print STDERR "ADD INFO =".Dumper ($add_activity_info->add_info())."\n";
 242
 243     if (!$return){
 244         $c->stash->{rest} = {error => "Error saving info",};
 245         return;
 246     } else {
 247         $c->stash->{rest} = $return;
 248     }
 249
 250 }
 251
 252
 253 sub get_activity_details :Path('/ajax/tracking_activity/details') :Args(1) {
 254     my $self = shift;
 255     my $c = shift;
 256     my $identifier_id = shift;
 257     my $schema = $c->dbic_schema('Bio::Chado::Schema', 'sgn_chado');
 258     my $dbh = $c->dbc->dbh;
 259
 260     my @details;
 261     my $tracking_activities = $c->config->{tracking_activities};
 262     my @activity_types = split ',',$tracking_activities;
 263
 264     my $tracking_data_json_cvterm_id  =  SGN::Model::Cvterm->get_cvterm_row($schema, 'tracking_tissue_culture_json', 'stock_property')->cvterm_id();
 265     my $activity_info_rs = $schema->resultset("Stock::Stockprop")->find({stock_id => $identifier_id, type_id => $tracking_data_json_cvterm_id});
 266     if ($activity_info_rs) {
 267         my $activity_json = $activity_info_rs->value();
 268         my $info = JSON::Any->jsonToObj($activity_json);
 269         my %info_hash = %{$info};
 270         foreach my $type (@activity_types){
 271             my $empty_string;
 272             my @each_type_details = ();
 273             my $each_timestamp_string;
 274             my $each_type_string;
 275             if ($info_hash{$type}) {
 276                 my @each_type_details = ();
 277                 my $details = {};
 278                 my %details_hash = ();
 279                 $details = $info_hash{$type};
 280                 %details_hash = %{$details};
 281 #                print STDERR "DETAILS HASH =".Dumper(\%details_hash);
 282                 foreach my $timestamp (sort keys %details_hash) {
 283                     my @each_timestamp_details = ();
 284                     push @each_timestamp_details, "timestamp".":"."".$timestamp;
 285                     my $operator_id = $details_hash{$timestamp}{'operator_id'};
 286
 287                     my $person= CXGN::People::Person->new($dbh, $operator_id);
 288                     my $operator_name = $person->get_first_name()." ".$person->get_last_name();
 289
 290                     push @each_timestamp_details, "operator".":"."".$operator_name;
 291                     my $input = $details_hash{$timestamp}{'input'};
 292                     push @each_timestamp_details, "count".":"."".$input;
 293                     my $notes = $details_hash{$timestamp}{'notes'};
 294                     push @each_timestamp_details, "notes".":"."".$notes;
 295
 296                     push @each_timestamp_details, $empty_string;
 297
 298                     $each_timestamp_string = join("<br>", @each_timestamp_details);
 299                     push @each_type_details, $each_timestamp_string;
 300                 }
 301
 302                 $each_type_string = join("<br>", @each_type_details);
 303 #                print STDERR "EACH TYPE STRING =".Dumper($each_type_string)."\n";
 304                 push @details, $each_type_string;
 305             } else {
 306                 my $empty_string;
 307                 push @details, $empty_string;
 308             }
 309         }
 310     } else {
 311         foreach my $type (@activity_types) {
 312             push @details, 'NA';
 313         }
 314     }
 315
 316     my @all_details;
 317     push @all_details, [@details];
 318
 319 #    print STDERR "ALL DETAILS =".Dumper(\@all_details)."\n";
 320
 321     $c->stash->{rest} = { data => \@all_details };
 322
 323 }
 324
 325
 326 sub get_activity_summary :Path('/ajax/tracking_activity/summary') :Args(1) {
 327     my $self = shift;
 328     my $c = shift;
 329     my $identifier_id = shift;
 330     my $schema = $c->dbic_schema('Bio::Chado::Schema', 'sgn_chado');
 331
 332     my @summary = ();
 333     my $tracking_activities = $c->config->{tracking_activities};
 334     my @activity_types = split ',',$tracking_activities;
 335
 336     my $tracking_data_json_cvterm_id  =  SGN::Model::Cvterm->get_cvterm_row($schema, 'tracking_tissue_culture_json', 'stock_property')->cvterm_id();
 337     my $activity_info_rs = $schema->resultset("Stock::Stockprop")->find({stock_id => $identifier_id, type_id => $tracking_data_json_cvterm_id});
 338     if ($activity_info_rs) {
 339         my $input;
 340         my $activity_json = $activity_info_rs->value();
 341         my $info = JSON::Any->jsonToObj($activity_json);
 342         my %info_hash = %{$info};
 343         foreach my $type (@activity_types){
 344             my $empty_string;
 345             my @each_type_details = ();
 346             my $each_timestamp_string;
 347             my $each_type_string;
 348             if ($info_hash{$type}) {
 349                 my $details = {};
 350                 my %details_hash = ();
 351                 $details = $info_hash{$type};
 352                 %details_hash = %{$details};
 353                 my $input = 0;
 354                 foreach my $key (keys %details_hash) {
 355                     $input += $details_hash{$key}{'input'};
 356                 }
 357                 push @summary, $input;
 358             } else {
 359                 push @summary, $input;
 360             }
 361         }
 362     } else {
 363         foreach my $type (@activity_types) {
 364             push @summary, 'NA';
 365         }
 366     }
 367
 368     my @all_summary;
 369     push @all_summary, [@summary];
 370
 371     $c->stash->{rest} = { data => \@all_summary };
 372
 373 }
 374
 375 sub get_project_active_identifiers :Path('/ajax/tracking_activity/project_active_identifiers') :Args(1) {
 376     my $self = shift;
 377     my $c = shift;
 378     my $project_id = shift;
 379     my $schema = $c->dbic_schema('Bio::Chado::Schema', 'sgn_chado');
 380     my $tracking_activities = $c->config->{tracking_activities};
 381     my @activity_types = split ',',$tracking_activities;
 382
 383     my $activity_project = CXGN::TrackingActivity::ActivityProject->new(bcs_schema => $schema, trial_id => $project_id);
 384     my $all_identifier_info = $activity_project->get_project_active_identifiers();
 385     my @all_identifiers;
 386     foreach my $identifier_info (@$all_identifier_info) {
 387         my @row = ();
 388         my $identifier_id = $identifier_info->[0];
 389         my $identifier_name = $identifier_info->[1];
 390         my $material_id = $identifier_info->[2];
 391         my $material_name = $identifier_info->[3];
 392         push @row, qq{<a href="/activity/details/$identifier_id">$identifier_name</a>};
 393         push @row, qq{<a href="/stock/$material_id/view">$material_name</a>};
 394         my $progress = $identifier_info->[5];
 395         my $input;
 396         if ($progress) {
 397             my $progress_ref = JSON::Any->jsonToObj($progress);
 398             my %progress_hash = %{$progress_ref};
 399             foreach my $type (@activity_types){
 400                 if ($progress_hash{$type}) {
 401                     my $details = {};
 402                     my %details_hash = ();
 403                     $details = $progress_hash{$type};
 404                     %details_hash = %{$details};
 405                     my $input = 0;
 406                     foreach my $key (keys %details_hash) {
 407                         $input += $details_hash{$key}{'input'};
 408                     }
 409                     push @row, $input
 410                 } else {
 411                     push @row, $input;
 412                 }
 413             }
 414         } else {
 415             foreach my $type (@activity_types) {
 416                 push @row, $input;
 417             }
 418         }
 419         push @row, $identifier_name;
 420         push @all_identifiers,[@row];
 421     }
 422
 423     $c->stash->{rest} = { data => \@all_identifiers };
 424
 425 }
 426
 427
 428 sub get_project_active_identifier_names :Path('/ajax/tracking_activity/project_active_identifier_names') :Args(1) {
 429     my $self = shift;
 430     my $c = shift;
 431     my $project_id = shift;
 432     my $schema = $c->dbic_schema('Bio::Chado::Schema', 'sgn_chado');
 433
 434     my $activity_project = CXGN::TrackingActivity::ActivityProject->new(bcs_schema => $schema, trial_id => $project_id);
 435     my $all_identifier_info = $activity_project->get_project_active_identifiers();
 436     my @identifier_names;
 437     foreach my $identifier_info (@$all_identifier_info) {
 438         push @identifier_names, $identifier_info->[1];
 439     }
 440
 441     $c->stash->{rest} = { data => \@identifier_names };
 442
 443 }
 444
 445
 446
 447 1;