Open-ILS/src/perlmods/OpenILS/Application/Circ/Survey.pm

   1 package OpenILS::Application::Circ::Survey;
   2 use base qw/OpenSRF::Application/;
   3 use strict; use warnings;
   4 use OpenSRF::EX qw/:try/;
   5 use OpenILS::Application::AppUtils;
   6 use Data::Dumper;
   7 use Time::HiRes qw(time);
   8
   9 my $apputils = "OpenILS::Application::AppUtils";
  10
  11 #open-ils.storage.direct.action.survey.search.*
  12
  13
  14
  15
  16 # - creates a new survey
  17 # expects a survey complete with questions and answers
  18
  19 __PACKAGE__->register_method(
  20         method  => "add_survey",
  21         api_name        => "open-ils.circ.survey.create");
  22
  23 sub add_survey {
  24         my( $self, $client, $user_session, $survey ) = @_;
  25
  26         my $user_obj = $apputils->check_user_session($user_session);
  27         my $session = $apputils->start_db_session();
  28         my $err = undef; my $id;
  29
  30         warn "Creating new survey\n" . Dumper($survey) . "\n";
  31
  32
  33         try {
  34
  35                 $survey = _add_survey($session, $survey);
  36                 _add_questions($session, $survey);
  37                 $apputils->commit_db_session($session);
  38
  39         } catch Error with {
  40                 my $e = shift;
  41                 $err = "Error creating survey: $e\n";
  42                 $apputils->rollback_db_session($session);
  43         };
  44
  45         if($err) { throw OpenSRF::EX::ERROR ($err); }
  46
  47         # re-retrieve the survey from the db and return it
  48         return $self->get_fleshed_survey( $client, $survey->id() );
  49 }
  50
  51
  52 sub _add_survey {
  53         my($session, $survey) = @_;
  54         my $req = $session->request(
  55                 "open-ils.storage.direct.action.survey.create",
  56                 $survey );
  57
  58         my $id = $req->gather(1);
  59
  60         if(!$id) {
  61                 throw OpenSRF::EX::ERROR
  62                         ("Unable to create new survey " . $survey->name());
  63         }
  64
  65         warn "Created new survey with id $id\n";
  66         $survey->id($id);
  67         return $survey;
  68 }
  69
  70 sub _update_survey {
  71         my($session, $survey) = @_;
  72 }
  73
  74 sub _add_questions {
  75         my($session, $survey) = @_;
  76
  77         # create new questions in the db
  78         if( $survey->questions() ) {
  79                 for my $question (@{$survey->questions()}){
  80
  81                         $question->survey($survey->id());
  82                         my $virtual_id = $question->id();
  83                         $question->clear_id();
  84
  85
  86                         warn "Creating new question: " . $question->question() . "\n";
  87                         warn Dumper $question;
  88
  89                         my $req = $session->request(
  90                                 'open-ils.storage.direct.action.survey_question.create',
  91                                 $question );
  92                         my $new_id = $req->gather(1);
  93
  94                         if(!$new_id) {
  95                                 throw OpenSRF::EX::ERROR
  96                                         ("Error creating new survey question " . $question->question() . "\n")
  97                         }
  98
  99                         warn "added new question with id $new_id\n";
 100
 101                         # now update the responses to this question
 102                         if($question->answers()) {
 103                                 for my $answer (@{$question->answers()}) {
 104                                         $answer->question($new_id);
 105                                         _add_answer($session,$answer);
 106                                 }
 107                         }
 108                 }
 109         }
 110 }
 111
 112
 113 sub _add_answer {
 114         my($session, $answer) = @_;
 115         warn "Adding answer " . $answer->answer() . "\n";
 116         $answer->clear_id();
 117         my $req = $session->request(
 118                 "open-ils.storage.direct.action.survey_answer.create",
 119                 $answer );
 120         my $id = $req->gather(1);
 121         if(!$id) {
 122                 throw OpenSRF::EX::ERROR
 123                         ("Error creating survey answer " . $answer->answer() );
 124         }
 125
 126         warn "Added new answer with id $id\n";
 127 }
 128
 129
 130
 131 # retrieve surveys for a specific org subtree.
 132 __PACKAGE__->register_method(
 133         method  => "get_required_surveys",
 134         api_name        => "open-ils.circ.survey.retrieve.required");
 135
 136 sub get_required_surveys {
 137         my( $self, $client, $user_session ) = @_;
 138
 139         warn "Retrieving required surveys\n";
 140
 141         my $user_obj = $apputils->check_user_session($user_session);
 142         my $surveys = $apputils->simple_scalar_request(
 143                 "open-ils.storage",
 144                 "open-ils.storage.action.survey.required.atomic",
 145                 $user_obj->home_ou() );
 146
 147         if($surveys) {
 148                 warn "Retrieved " . scalar(@$surveys)." required surveys\n";
 149         }
 150
 151         my @fleshed;
 152         for my $survey (@$surveys) {
 153                 push(@fleshed, $self->get_fleshed_survey($client, $survey));
 154         }
 155         return \@fleshed;
 156
 157 }
 158
 159 __PACKAGE__->register_method(
 160         method  => "get_survey_responses",
 161         api_name        => "open-ils.circ.survey.response.retrieve");
 162
 163 sub get_survey_responses {
 164         my( $self, $client, $user_session, $survey_id, $user_id ) = @_;
 165
 166         warn "retrieing responses $user_session $survey_id $user_id\n";
 167         if(!$user_id) {
 168                 my $user_obj = $apputils->check_user_session($user_session);
 169                 $user_id = $user_obj->id;
 170         }
 171
 172         my $res = $apputils->simple_scalar_request(
 173                 "open-ils.storage",
 174                 "open-ils.storage.direct.action.survey_response.search.atomic",
 175                 { usr => $user_id, survey => $survey_id } );
 176
 177         warn "Surveys: " .  Dumper($res);
 178
 179         if( $res && ref($res) and $res->[0]) {
 180                 return [ sort { $a->id() <=> $b->id() } @$res ];
 181         }
 182
 183         return [];
 184 }
 185
 186 __PACKAGE__->register_method(
 187         method  => "get_all_surveys",
 188         api_name        => "open-ils.circ.survey.retrieve.all");
 189
 190 sub get_all_surveys {
 191         my( $self, $client, $user_session ) = @_;
 192
 193         my $user_obj = $apputils->check_user_session($user_session);
 194         my $surveys = $apputils->simple_scalar_request(
 195                 "open-ils.storage",
 196                 "open-ils.storage.action.survey.all.atomic",
 197                 $user_obj->home_ou() );
 198
 199         my @fleshed;
 200         for my $survey (@$surveys) {
 201                 push(@fleshed, $self->get_fleshed_survey($client, $survey));
 202         }
 203         return \@fleshed;
 204 }
 205
 206
 207
 208
 209 __PACKAGE__->register_method(
 210         method  => "get_fleshed_survey",
 211         api_name        => "open-ils.circ.survey.fleshed.retrieve");
 212
 213 sub get_fleshed_survey {
 214         my( $self, $client, $survey_id ) = @_;
 215
 216         my $session = OpenSRF::AppSession->create("open-ils.storage");
 217
 218         warn "Searching for survey $survey_id\n";
 219
 220         my $survey;
 221         if( ref($survey_id) and
 222                         (ref($survey_id) =~ /^Fieldmapper/)) {
 223                 $survey = $survey_id;
 224
 225         } else {
 226
 227                 my $sreq = $session->request(
 228                         "open-ils.storage.direct.action.survey.retrieve",
 229                         $survey_id );
 230                 $survey = $sreq->gather(1);
 231                 if(! $survey) { return undef; }
 232         }
 233
 234         $survey->questions([]);
 235
 236
 237         warn "Grabbing survey questions\n";
 238         my $qreq = $session->request(
 239                 "open-ils.storage.direct.action.survey_question.search.survey",
 240                 $survey->id() );
 241
 242         my $questions = $qreq->gather(1);
 243
 244         if($questions) {
 245
 246                 for my $question (@$questions) {
 247
 248                         # add this question to the survey
 249                         push( @{$survey->questions()}, $question );
 250
 251                         warn "Grabbing question answers\n";
 252
 253                         my $ans_req = $session->request(
 254                                 "open-ils.storage.direct.action.survey_answer.search.question",
 255                                 $question->id() );
 256
 257                         # add this array of answers to this question
 258                         $question->answers( $ans_req->gather(1) );
 259
 260                 }
 261         }
 262
 263         $session->disconnect();
 264         return $survey;
 265
 266 }
 267
 268
 269
 270 __PACKAGE__->register_method(
 271         method  => "submit_survey",
 272         api_name        => "open-ils.circ.survey.submit.session");
 273
 274 __PACKAGE__->register_method(
 275         method  => "submit_survey",
 276         api_name        => "open-ils.circ.survey.submit.user_id");
 277
 278 __PACKAGE__->register_method(
 279         method  => "submit_survey",
 280         api_name        => "open-ils.circ.survey.submit.anon");
 281
 282
 283 sub submit_survey {
 284         my( $self, $client, $responses ) = @_;
 285
 286         if(!$responses) {
 287                 throw OpenSRF::EX::ERROR
 288                         ("No survey object sent in update");
 289         }
 290
 291         use Data::Dumper;
 292         warn "Submitting survey " . Dumper($responses) . "\n";
 293
 294         if(!ref($responses)) { $responses = [$responses]; }
 295
 296         my $session = $apputils->start_db_session();
 297
 298         my $group_id = $session->request(
 299                 "open-ils.storage.action.survey_response.next_group_id")->gather(1);
 300
 301         my %already_seen;
 302         for my $res (@$responses) {
 303
 304                 my $id;
 305
 306                 if($self->api_name =~ /session/) {
 307                         if( ! ($id = $already_seen{$res->usr}) ) {
 308                                 my $user_obj = $apputils->check_user_session($res->usr);
 309                                 $id = $user_obj->id;
 310                                 $already_seen{$res->usr} = $id;
 311                         }
 312                         $res->usr($id);
 313                 } elsif( $self->api_name =~ /anon/ ) {
 314                         $res->clear_usr();
 315                 }
 316
 317                 warn "Submitting response with question " .
 318                         $res->question . " and group $group_id \n";
 319
 320                 $res->response_group_id($group_id);
 321                 my $req = $session->request(
 322                         "open-ils.storage.direct.action.survey_response.create",
 323                         $res );
 324                 my $newid = $req->gather(1);
 325                 warn "New response id: $newid\n";
 326
 327                 if(!$newid) {
 328                         throw OpenSRF::EX::ERROR
 329                                 ("Error creating new survey response");
 330                 }
 331         }
 332
 333         $apputils->commit_db_session($session);
 334         warn "survey response update completed\n";
 335
 336         return 1;
 337 }
 338
 339
 340 __PACKAGE__->register_method(
 341         method  => "get_random_survey",
 342         api_name        => "open-ils.circ.survey.retrieve.opac.random");
 343
 344 sub get_random_survey {
 345         my( $self, $client, $user_session ) = @_;
 346
 347         warn "retrieving random survey\n";
 348         my $user_obj = $apputils->check_user_session($user_session);
 349         my $surveys = $apputils->simple_scalar_request(
 350                 "open-ils.storage",
 351                 "open-ils.storage.action.survey.opac.atomic",
 352                 $user_obj->home_ou() );
 353
 354         my $random = int(rand(scalar(@$surveys)));
 355         warn "Random survey index for process $$ is $random\n";
 356         my $surv = $surveys->[$random];
 357
 358         return $self->get_fleshed_survey($client, $surv);
 359
 360 }
 361
 362 __PACKAGE__->register_method(
 363         method  => "get_random_survey_global",
 364         api_name        => "open-ils.circ.survey.retrieve.opac.random.global");
 365
 366 sub get_random_survey_global {
 367         my( $self, $client ) = @_;
 368
 369         warn "retrieving random global survey\n";
 370         my $surveys = $apputils->simple_scalar_request(
 371                 "open-ils.storage",
 372                 "open-ils.storage.direct.action.survey.search.atomic",
 373                 # XXX grab the org tree to get the root id...
 374                 { owner => 1, opac => 't' } );
 375
 376         my $random = int(rand(scalar(@$surveys)));
 377         warn "Random survey index for process $$ is $random\n";
 378         my $surv = $surveys->[$random];
 379
 380         return $self->get_fleshed_survey($client, $surv);
 381
 382 }
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393 1;
 394
 395
 396
 397
 398