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         my $user_obj = $apputils->check_user_session($user_session);
 140         return $apputils->simple_scalar_request(
 141                 "open-ils.storage",
 142                 "open-ils.storage.action.survey.required.atomic",
 143                 $user_obj->home_ou() );
 144 }
 145
 146 __PACKAGE__->register_method(
 147         method  => "get_survey_responses",
 148         api_name        => "open-ils.circ.survey.response.retrieve");
 149
 150 sub get_survey_responses {
 151         my( $self, $client, $user_session, $survey_id, $user_id ) = @_;
 152
 153         warn "retrieing responses $user_session $survey_id $user_id\n";
 154         if(!$user_id) {
 155                 my $user_obj = $apputils->check_user_session($user_session);
 156                 $user_id = $user_obj->id;
 157         }
 158
 159         my $res = $apputils->simple_scalar_request(
 160                 "open-ils.storage",
 161                 "open-ils.storage.direct.action.survey_response.search.atomic",
 162                 { usr => $user_id, survey => $survey_id } );
 163
 164         warn "Surveys: " .  Dumper($res);
 165
 166         if( $res && ref($res) and $res->[0]) {
 167                 return [ sort { $a->id() <=> $b->id() } @$res ];
 168         }
 169
 170         return [];
 171 }
 172
 173 __PACKAGE__->register_method(
 174         method  => "get_all_surveys",
 175         api_name        => "open-ils.circ.survey.retrieve.all");
 176
 177 sub get_all_surveys {
 178         my( $self, $client, $user_session ) = @_;
 179
 180         my $user_obj = $apputils->check_user_session($user_session);
 181         my $surveys = $apputils->simple_scalar_request(
 182                 "open-ils.storage",
 183                 "open-ils.storage.action.survey.all.atomic",
 184                 $user_obj->home_ou() );
 185
 186         my @fleshed;
 187         for my $survey (@$surveys) {
 188                 push(@fleshed, $self->get_fleshed_survey($client, $survey));
 189         }
 190         return \@fleshed;
 191 }
 192
 193
 194
 195
 196 __PACKAGE__->register_method(
 197         method  => "get_fleshed_survey",
 198         api_name        => "open-ils.circ.survey.fleshed.retrieve");
 199
 200 sub get_fleshed_survey {
 201         my( $self, $client, $survey_id ) = @_;
 202
 203         my $session = OpenSRF::AppSession->create("open-ils.storage");
 204
 205         warn "Searching for survey $survey_id\n";
 206
 207         my $survey;
 208         if( ref($survey_id) and
 209                         (ref($survey_id) =~ /^Fieldmapper/)) {
 210                 $survey = $survey_id;
 211
 212         } else {
 213
 214                 my $sreq = $session->request(
 215                         "open-ils.storage.direct.action.survey.retrieve",
 216                         $survey_id );
 217                 $survey = $sreq->gather(1);
 218                 if(! $survey) { return undef; }
 219         }
 220
 221         $survey->questions([]);
 222
 223
 224         warn "Grabbing survey questions\n";
 225         my $qreq = $session->request(
 226                 "open-ils.storage.direct.action.survey_question.search.survey",
 227                 $survey->id() );
 228
 229         my $questions = $qreq->gather(1);
 230
 231         if($questions) {
 232
 233                 for my $question (@$questions) {
 234
 235                         # add this question to the survey
 236                         push( @{$survey->questions()}, $question );
 237
 238                         warn "Grabbing question answers\n";
 239
 240                         my $ans_req = $session->request(
 241                                 "open-ils.storage.direct.action.survey_answer.search.question",
 242                                 $question->id() );
 243
 244                         # add this array of answers to this question
 245                         $question->answers( $ans_req->gather(1) );
 246
 247                 }
 248         }
 249
 250         $session->disconnect();
 251         return $survey;
 252
 253 }
 254
 255
 256
 257 __PACKAGE__->register_method(
 258         method  => "submit_survey",
 259         api_name        => "open-ils.circ.survey.submit.session");
 260
 261 __PACKAGE__->register_method(
 262         method  => "submit_survey",
 263         api_name        => "open-ils.circ.survey.submit.user_id");
 264
 265 __PACKAGE__->register_method(
 266         method  => "submit_survey",
 267         api_name        => "open-ils.circ.survey.submit.anon");
 268
 269
 270 sub submit_survey {
 271         my( $self, $client, $responses ) = @_;
 272
 273         if(!$responses) {
 274                 throw OpenSRF::EX::ERROR
 275                         ("No survey object sent in update");
 276         }
 277
 278         use Data::Dumper;
 279         warn "Submitting survey " . Dumper($responses) . "\n";
 280
 281         if(!ref($responses)) { $responses = [$responses]; }
 282
 283         my $session = $apputils->start_db_session();
 284
 285         my $group_id = $session->request(
 286                 "open-ils.storage.action.survey_response.next_group_id")->gather(1);
 287
 288         my %already_seen;
 289         for my $res (@$responses) {
 290
 291                 my $id;
 292
 293                 if($self->api_name =~ /session/) {
 294                         if( ! ($id = $already_seen{$res->usr}) ) {
 295                                 my $user_obj = $apputils->check_user_session($res->usr);
 296                                 $id = $user_obj->id;
 297                                 $already_seen{$res->usr} = $id;
 298                         }
 299                         $res->usr($id);
 300                 } elsif( $self->api_name =~ /anon/ ) {
 301                         $res->clear_usr();
 302                 }
 303
 304                 warn "Submitting response with question " .
 305                         $res->question . " and group $group_id \n";
 306
 307                 $res->response_group_id($group_id);
 308                 my $req = $session->request(
 309                         "open-ils.storage.direct.action.survey_response.create",
 310                         $res );
 311                 my $newid = $req->gather(1);
 312                 warn "New response id: $newid\n";
 313
 314                 if(!$newid) {
 315                         throw OpenSRF::EX::ERROR
 316                                 ("Error creating new survey response");
 317                 }
 318         }
 319
 320         $apputils->commit_db_session($session);
 321         warn "survey response update completed\n";
 322
 323         return 1;
 324 }
 325
 326
 327 __PACKAGE__->register_method(
 328         method  => "get_random_survey",
 329         api_name        => "open-ils.circ.survey.retrieve.opac.random");
 330
 331 sub get_random_survey {
 332         my( $self, $client, $user_session ) = @_;
 333
 334         warn "retrieving random survey\n";
 335         my $user_obj = $apputils->check_user_session($user_session);
 336         my $surveys = $apputils->simple_scalar_request(
 337                 "open-ils.storage",
 338                 "open-ils.storage.action.survey.opac.atomic",
 339                 $user_obj->home_ou() );
 340
 341         my $random = int(rand(scalar(@$surveys)));
 342         warn "Random survey index for process $$ is $random\n";
 343         my $surv = $surveys->[$random];
 344
 345         return $self->get_fleshed_survey($client, $surv);
 346
 347 }
 348
 349 __PACKAGE__->register_method(
 350         method  => "get_random_survey_global",
 351         api_name        => "open-ils.circ.survey.retrieve.opac.random.global");
 352
 353 sub get_random_survey_global {
 354         my( $self, $client ) = @_;
 355
 356         warn "retrieving random global survey\n";
 357         my $surveys = $apputils->simple_scalar_request(
 358                 "open-ils.storage",
 359                 "open-ils.storage.direct.action.survey.search.atomic",
 360                 # XXX grab the org tree to get the root id...
 361                 { owner => 1, opac => 't' } );
 362
 363         my $random = int(rand(scalar(@$surveys)));
 364         warn "Random survey index for process $$ is $random\n";
 365         my $surv = $surveys->[$random];
 366
 367         return $self->get_fleshed_survey($client, $surv);
 368
 369 }
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380 1;
 381
 382
 383
 384
 385