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