View | Details | Raw Unified | Return to bug 14843
Collapse All | Expand All

(-)a/C4/Letters.pm (-1 / +117 lines)
Lines 935-940 ENDSQL Link Here
935
    return $dbh->last_insert_id(undef,undef,'message_queue', undef);
935
    return $dbh->last_insert_id(undef,undef,'message_queue', undef);
936
}
936
}
937
937
938
=head2 DequeueLetter
939
940
  my $success = DequeueLetter( { message_id => $message_id } )
941
942
Removes a message from message_queue
943
944
return 1 on success, otherwise 0
945
946
=cut
947
948
sub DequeueLetter {
949
    my $params = shift or return;
950
951
    return unless exists $params->{'message_id'} or not $params->{'message_id'};
952
953
    my $dbh       = C4::Context->dbh();
954
    my $statement = << 'ENDSQL';
955
DELETE FROM message_queue
956
WHERE message_id = ?
957
ENDSQL
958
959
    my $sth    = $dbh->prepare($statement);
960
    my $result = $sth->execute(
961
        $params->{'message_id'},              # message_id
962
    );
963
    return ($result > 0);
964
}
965
938
=head2 SendQueuedMessages ([$hashref]) 
966
=head2 SendQueuedMessages ([$hashref]) 
939
967
940
  my $sent = SendQueuedMessages( { verbose => 1 } );
968
  my $sent = SendQueuedMessages( { verbose => 1 } );
Lines 1026-1032 sub GetQueuedMessages { Link Here
1026
1054
1027
    my $dbh = C4::Context->dbh();
1055
    my $dbh = C4::Context->dbh();
1028
    my $statement = << 'ENDSQL';
1056
    my $statement = << 'ENDSQL';
1029
SELECT message_id, borrowernumber, subject, content, message_transport_type, status, time_queued, delivery_note
1057
SELECT message_id, borrowernumber, subject, content, metadata, letter_code, message_transport_type, status, time_queued, to_address, from_address, content_type, delivery_note
1030
FROM message_queue
1058
FROM message_queue
1031
ENDSQL
1059
ENDSQL
1032
1060
Lines 1051-1056 ENDSQL Link Here
1051
    return $sth->fetchall_arrayref({});
1079
    return $sth->fetchall_arrayref({});
1052
}
1080
}
1053
1081
1082
1083
=head2 UpdateQueuedMessage ([$hashref])
1084
1085
  my $message = UpdateQueuedMessage( {
1086
        borrowernumber => '123', message_id => '100',
1087
        letter => { subject => "New subject", content => "New content" },
1088
    } );
1089
1090
Updates the message in message_queue. Message is identified by
1091
required parameter message_id.
1092
1093
returns:
1094
1 on success, otherwise 0
1095
1096
=cut
1097
1098
sub UpdateQueuedMessage {
1099
    my $params = shift;
1100
1101
    if (not $params->{'message_id'}) {
1102
        warn __PACKAGE__."::UpdateQueuedMessage: param message_id is required";
1103
        return;
1104
    }
1105
    
1106
    my $dbh = C4::Context->dbh();
1107
    my $statement = << 'ENDSQL';
1108
UPDATE message_queue
1109
SET
1110
ENDSQL
1111
1112
    my @query_params;
1113
    
1114
    if ($params->{'borrowernumber'}) {
1115
         $statement .= " borrowernumber = ?, ";
1116
         push @query_params, $params->{'borrowernumber'};
1117
    }
1118
    if ($params->{'subject'}) {
1119
         $statement .= " subject = ?, ";
1120
         push @query_params, $params->{'subject'};
1121
    }
1122
    if ($params->{'content'}) {
1123
         $statement .= " content = ?, ";
1124
         push @query_params, $params->{'content'};
1125
    }
1126
    if ($params->{'metadata'}) {
1127
         $statement .= " metadata = ?, ";
1128
         push @query_params, $params->{'metadata'};
1129
    }
1130
    if ($params->{'letter_code'}) {
1131
         $statement .= " letter_code = ?, ";
1132
         push @query_params, $params->{'letter_code'};
1133
    }
1134
    if ($params->{'content_type'}) {
1135
         $statement .= " content_type = ?, ";
1136
         push @query_params, $params->{'content_type'};
1137
    }
1138
    if ($params->{'message_transport_type'}) {
1139
         $statement .= " message_transport_type = ?, ";
1140
         push @query_params, $params->{'message_transport_type'};
1141
    }
1142
    if ($params->{'status'}) {
1143
         $statement .= " status = ?, ";
1144
         push @query_params, $params->{'status'};
1145
    }
1146
    if ($params->{'to_address'}) {
1147
         $statement .= " to_address = ?, ";
1148
         push @query_params, $params->{'to_address'};
1149
    }
1150
    if ($params->{'from_address'}) {
1151
         $statement .= " from_address = ?, ";
1152
         push @query_params, $params->{'from_address'};
1153
    }
1154
    if ($params->{'delivery_note'}) {
1155
         $statement .= " delivery_note = ?, ";
1156
         push @query_params, $params->{'delivery_note'};
1157
    }
1158
    return 0 if $statement =~ /SET(\s*)$/;
1159
    $statement =~ s/,(\s*)$//g; # remove last ,
1160
    
1161
    $statement .= " WHERE message_id = ?";
1162
    push @query_params, $params->{'message_id'};
1163
1164
    my $sth = $dbh->prepare( $statement );
1165
    my $result = $sth->execute( @query_params );
1166
    return ($result > 0);
1167
}
1168
1169
1054
=head2 GetMessageTransportTypes
1170
=head2 GetMessageTransportTypes
1055
1171
1056
  my @mtt = GetMessageTransportTypes();
1172
  my @mtt = GetMessageTransportTypes();
(-)a/Koha/REST/V1/Messages.pm (+262 lines)
Line 0 Link Here
1
package Koha::REST::V1::Messages;
2
3
use Modern::Perl;
4
5
use Mojo::Base 'Mojolicious::Controller';
6
7
use C4::Letters;
8
use Data::Dumper;
9
10
11
12
=head2 list_messages($c, $args, $cb)
13
14
Lists all messages from message_queue.
15
16
=cut
17
sub list_messages {
18
    my ($c, $args, $cb) = @_;
19
20
    my $messages = C4::Letters::GetQueuedMessages();
21
22
    if (@$messages > 0) {
23
        my $return_messages;
24
        foreach my $message (@$messages){
25
            push @$return_messages, _set_default_values({ message => $message });
26
        }
27
        return $c->$cb($return_messages , 200);
28
    }
29
    $c->$cb({ error => "No messages found." }, 404);
30
}
31
32
33
34
=head2 create_message($c, $args, $cb)
35
36
Creates a new message into message queue.
37
38
=cut
39
sub create_message {
40
    my ($c, $args, $cb) = @_;
41
42
    # Content is required. Check for missing content.
43
    if (exists $args->{body}->{content}) {
44
        my $content = $args->{body}->{content};
45
        $content =~ s/\s+//g if(defined $content);
46
        if ( not $content ) {
47
            return $c->$cb({ error => "Property cannot be empty in: /body/content" }, 400);
48
        }
49
    } else {
50
        return $c->$cb({ error => "Missing property: /body/content" }, 400);
51
    }
52
    
53
    if (exists $args->{body}->{borrowernumber}) {
54
        my $content = $args->{body}->{borrowernumber};
55
        $content =~ s/\s+//g if(defined $content);
56
        if ( not $content ) {
57
            return $c->$cb({ error => "Property cannot be empty in: /body/borrowernumber" }, 400);
58
        }
59
    } else {
60
        return $c->$cb({ error => "Missing property: /body/borrowernumber" }, 400);
61
    }
62
    
63
    
64
    # message_transport_type is required. Check for missing parameter.
65
    my $transport_type = $args->{body}->{message_transport_type};
66
    $transport_type =~ s/\s+//g if(defined $transport_type);
67
    if ( not $transport_type ) {
68
        return $c->$cb({ error => "Missing property: /body/message_transport_type" }, 400);
69
    }
70
    
71
    # message_transport_type also must be one of the predefined values
72
    my $transport_types = C4::Letters::GetMessageTransportTypes();
73
    if ( !grep( /^$transport_type$/, @$transport_types ) ) {
74
        return $c->$cb({ error => "Invalid value '".$transport_type."' in: /body/message_transport_type. Valid values are ". join(', ', @$transport_types) }, 400);
75
    }
76
    
77
    # Make some changes in names of parameters due to inconsistent naming in C4::Letters
78
    
79
    # Enqueue the letter
80
    my $message = C4::Letters::EnqueueLetter(_convert_to_enqueue({ message => $args->{'body'} }));
81
    
82
    # Check if the message was enqueued
83
    if ($message){
84
        # Get the newly created message and return it
85
        $message = C4::Letters::GetMessage( $message );
86
        
87
        $message = _set_default_values({ message => $message });
88
        
89
        return $c->$cb($message, 201);
90
    }
91
    $c->$cb({ error => "Message could not be created." }, 404)
92
}
93
94
95
96
=head2 update_message($c, $args, $cb)
97
98
Updates the message in message_queue.
99
100
=cut
101
sub update_message {
102
    my ($c, $args, $cb) = @_;
103
104
    # Content is required. Check for missing content.
105
    if (exists $args->{body}->{content}) {
106
        my $content = $args->{body}->{content};
107
        $content =~ s/\s+//g if(defined $content);
108
        if ( $content eq '' ) {
109
            return $c->$cb({ error => "Property cannot be empty in: /body/content" }, 400);
110
        }
111
    }
112
    
113
    if (exists $args->{body}->{message_transport_type}) {
114
        my $transport_type = $args->{body}->{message_transport_type};
115
        # message_transport_type also must be one of the predefined values
116
        my $transport_types = C4::Letters::GetMessageTransportTypes();
117
        if ( !grep( /^$transport_type$/, @$transport_types ) ) {
118
            return $c->$cb({ error => "Invalid value '".$transport_type
119
                            ."' in: /body/message_transport_type. Valid values are "
120
                            . join(', ', @$transport_types) }, 400);
121
        }
122
    }
123
124
    # create update hash
125
    my $update = $args->{'body'};
126
    $update->{'message_id'} = $args->{'messagenumber'};
127
    
128
    my $message = C4::Letters::UpdateQueuedMessage( $update );
129
    return $c->$cb({ error => "Message could not be found." }, 404) if not $message;
130
    
131
    $message = C4::Letters::GetMessage($args->{'messagenumber'});
132
    
133
    if ($message){
134
        $message = _set_default_values({ message => $message });
135
        return $c->$cb($message, 200);
136
    }
137
    $c->$cb({ error => "Message could not be updated." }, 404);
138
}
139
140
141
142
=head2 delete_message($c, $args, $cb)
143
144
Delete the message from message_queue.
145
146
=cut
147
sub delete_message {
148
    my ($c, $args, $cb) = @_;
149
150
    my $message = C4::Letters::DequeueLetter({ message_id => $args->{'messagenumber'} });
151
    
152
    if ($message){
153
        return $c->$cb('', 204);
154
    }
155
    
156
    $c->$cb({ error => "Message could not be found." }, 404)
157
}
158
159
160
161
=head2 get_message($c, $args, $cb)
162
163
Returns a message from message_queue.
164
165
=cut
166
sub get_message {
167
    my ($c, $args, $cb) = @_;
168
169
    my $message = C4::Letters::GetMessage($args->{'messagenumber'});
170
171
    if ($message) {
172
        my $message = _set_default_values({ message => $message });
173
        
174
        return $c->$cb($message, 200);
175
    }
176
    
177
    return $c->$cb({ error => "Could not find the message" }, 404);
178
}
179
180
181
182
=head2 create_resend($c, $args, $cb)
183
184
Attempts to resend a message.
185
186
=cut
187
sub create_resend {
188
    my ($c, $args, $cb) = @_;
189
190
191
    my $message = C4::Letters::GetMessage($args->{'messagenumber'});
192
193
    if ($message) {
194
        if (C4::Letters::ResendMessage($args->{'messagenumber'})) {
195
            
196
            return $c->$cb('', 204);
197
        }
198
    }
199
    
200
    return $c->$cb({ error => "Could not find the message" }, 404);
201
}
202
203
204
205
=head2 _set_default_values({ message => $message })
206
207
=cut
208
sub _set_default_values {
209
    my $params = shift;
210
    
211
    return unless exists $params->{'message'} or not defined $params->{'message'};
212
    
213
    # Convert the returned message into C4::Letters::EnqueueLetter format
214
    return {
215
        message_id => int($params->{'message'}->{'message_id'}),
216
        borrowernumber => int($params->{'message'}->{'borrowernumber'}),
217
        subject => $params->{'message'}->{'subject'} || '',
218
        content => $params->{'message'}->{'content'} || '',
219
        letter_code => $params->{'message'}->{'letter_code'} || '',
220
        content_type => $params->{'message'}->{'content_type'} || '',
221
        metadata => $params->{'message'}->{'metadata'} || '',
222
        message_transport_type => $params->{'message'}->{'message_transport_type'} || '',
223
        to_address => $params->{'message'}->{'to_address'} || '',
224
        from_address => $params->{'message'}->{'from_address'} || '',
225
        delivery_note => $params->{'message'}->{'delivery_note'} || '',
226
        status => $params->{'message'}->{'status'} || '',
227
        time_queued => $params->{'message'}->{'time_queued'} || ''
228
    };
229
}
230
231
232
233
=head2 _convert_to_message({ message => $message })
234
235
Due to inconsistent naming in C4::Letters::EnqueueLetter, we use the
236
database format and convert it in this function into the format that
237
EnqueueLetter supports.
238
239
=cut
240
sub _convert_to_enqueue {
241
    my $params = shift;
242
    
243
    return unless exists $params->{'message'} or not defined $params->{'message'};
244
    
245
    # Convert the returned message into C4::Letters::EnqueueLetter format
246
    return {
247
        borrowernumber => int($params->{'message'}->{'borrowernumber'}),
248
        letter => {
249
            title => $params->{'message'}->{'subject'} || '',
250
            content => $params->{'message'}->{'content'} || '',
251
            code => $params->{'message'}->{'letter_code'} || '',
252
            'content-type' => $params->{'message'}->{'content_type'} || '',
253
            metadata => $params->{'message'}->{'metadata'} || '',
254
        },
255
        message_transport_type => $params->{'message'}->{'message_transport_type'} || '',
256
        to_address => $params->{'message'}->{'to_address'} || '',
257
        from_address => $params->{'message'}->{'from_address'} || '',
258
        delivery_note => $params->{'message'}->{'delivery_note'} || ''
259
    };
260
}
261
262
1;
(-)a/api/v1/swagger.json (+262 lines)
Lines 309-314 Link Here
309
          }
309
          }
310
        }
310
        }
311
      }
311
      }
312
    },
313
    "/messages": {
314
      "get": {
315
        "x-mojo-controller": "Koha::REST::V1::Messages",
316
        "operationId": "listMessages",
317
        "x-koha-permission": {
318
          "messages": "get_message"
319
        },
320
        "tags": ["messages"],
321
        "produces": [
322
          "application/json"
323
        ],
324
        "responses": {
325
          "200": {
326
            "description": "A list of messages",
327
            "schema": {
328
              "type": "array",
329
              "items": {
330
                "$ref" : "#/definitions/message"
331
              }
332
            }
333
          },
334
          "404": {
335
            "description": "Messages not found",
336
            "schema": {
337
              "$ref": "#/definitions/error"
338
            }
339
          }
340
        }
341
      },
342
      "post": {
343
        "x-mojo-controller": "Koha::REST::V1::Messages",
344
        "operationId": "createMessage",
345
        "x-koha-permission": {
346
          "messages": "create_message"
347
        },
348
        "tags": ["messages"],
349
        "parameters": [
350
          {
351
            "name": "body",
352
            "in": "body",
353
            "description": "A JSON object containing informations about the new message",
354
            "required": true,
355
            "schema": { "$ref": "#/definitions/message" }
356
          }
357
        ],
358
        "produces": [
359
          "application/json"
360
        ],
361
        "responses": {
362
          "201": {
363
            "description": "A message",
364
            "schema": {
365
                "$ref": "#/definitions/message"
366
            }
367
          },
368
          "400": {
369
            "description": "Missing or wrong parameters",
370
            "schema": { "$ref": "#/definitions/error" }
371
          }
372
        }
373
      }
374
    },
375
    "/messages/{messagenumber}": {
376
      "put": {
377
        "x-mojo-controller": "Koha::REST::V1::Messages",
378
        "operationId": "updateMessage",
379
        "x-koha-permission": {
380
          "messages": "update_message"
381
        },
382
        "tags": ["messages"],
383
        "parameters": [
384
          {
385
            "name": "body",
386
            "in": "body",
387
            "description": "A JSON object containing informations about the new message",
388
            "required": false,
389
            "schema": { "$ref": "#/definitions/message" }
390
          },
391
          {
392
            "$ref": "#/parameters/messagenumberPathParam"
393
          }
394
        ],
395
        "produces": [
396
          "application/json"
397
        ],
398
        "responses": {
399
          "200": {
400
            "description": "A message",
401
            "schema": {
402
              "$ref" : "#/definitions/message"
403
            }
404
          },
405
          "400": {
406
            "description": "Missing or wrong parameters",
407
            "schema": { "$ref": "#/definitions/error" }
408
          },
409
          "404": {
410
            "description": "Message not found",
411
            "schema": {
412
              "$ref": "#/definitions/error"
413
            }
414
          }
415
        }
416
      },
417
      "delete": {
418
        "x-mojo-controller": "Koha::REST::V1::Messages",
419
        "operationId": "deleteMessage",
420
        "x-koha-permission": {
421
          "messages": "delete_message"
422
        },
423
        "tags": ["messages"],
424
        "parameters": [
425
          {
426
            "$ref": "#/parameters/messagenumberPathParam"
427
          }
428
        ],
429
        "produces": [
430
          "application/json"
431
        ],
432
        "responses": {
433
          "204": {
434
            "description": "Deleting the message succeeded.",
435
            "schema": {
436
              "type": "string"
437
            }
438
          },
439
          "404": {
440
            "description": "Message not found.",
441
            "schema": {
442
              "$ref": "#/definitions/error"
443
            }
444
          }
445
        }
446
      },
447
      "get": {
448
        "x-mojo-controller": "Koha::REST::V1::Messages",
449
        "operationId": "getMessage",
450
        "x-koha-permission": {
451
          "messages": "get_message"
452
        },
453
        "tags": ["messages"],
454
        "parameters": [
455
          {
456
            "$ref": "#/parameters/messagenumberPathParam"
457
          }
458
        ],
459
        "produces": [
460
          "application/json"
461
        ],
462
        "responses": {
463
          "200": {
464
            "description": "A message",
465
            "schema": {
466
              "$ref" : "#/definitions/message"
467
            }
468
          },
469
          "404": {
470
            "description": "Message not found",
471
            "schema": {
472
              "$ref": "#/definitions/error"
473
            }
474
          }
475
        }
476
      }
477
    },
478
    "/messages/{messagenumber}/resend": {
479
      "post": {
480
        "x-mojo-controller": "Koha::REST::V1::Messages",
481
        "operationId": "createResend",
482
        "description": "Resends a message.",
483
        "x-koha-permission": {
484
          "messages": "resend_message"
485
        },
486
        "tags": ["messages"],
487
        "parameters": [
488
          {
489
            "$ref": "#/parameters/messagenumberPathParam"
490
          }
491
        ],
492
        "produces": [
493
          "application/json"
494
        ],
495
        "responses": {
496
          "204": {
497
            "description": "Resending the message succeeded.",
498
            "schema": {
499
              "type": "string"
500
            }
501
          },
502
          "404": {
503
            "description": "Message not found",
504
            "schema": {
505
              "$ref": "#/definitions/error"
506
            }
507
          }
508
        }
509
      }
312
    }
510
    }
313
  },
511
  },
314
  "definitions": {
512
  "definitions": {
Lines 485-496 Link Here
485
    "borrowernumber": {
683
    "borrowernumber": {
486
      "description": "Borrower internal identifier"
684
      "description": "Borrower internal identifier"
487
    },
685
    },
686
488
    "branchcode": {
687
    "branchcode": {
489
      "description": "Branch code"
688
      "description": "Branch code"
490
    },
689
    },
491
    "itemnumber": {
690
    "itemnumber": {
492
      "description": "Item internal identifier"
691
      "description": "Item internal identifier"
493
    },
692
    },
693
    "message": {
694
      "type": "object",
695
      "properties": {
696
        "message_id": {
697
          "description": "Message internal identifier",
698
          "type": "integer"
699
        },
700
        "time_queued": {
701
          "description": "Date and time of when message was placed in queue",
702
          "type": "string"
703
        },
704
        "borrowernumber": {
705
          "$ref": "#/definitions/borrowernumber"
706
        },
707
        "subject": {
708
          "description": "Subject of the message",
709
          "type": "string"
710
        },
711
        "content": {
712
          "description": "Content of the message",
713
          "type": "string"
714
        },
715
        "metadata": {
716
          "description": "",
717
          "type": "string"
718
        },
719
        "letter_code": {
720
          "description": "",
721
          "type": "string"
722
        },
723
        "content_type": {
724
          "description": "Content type",
725
          "type": "string"
726
        },
727
        "message_transport_type": {
728
          "description": "Transport method. Values accepted by default are 'email', 'sms', 'phone' and 'print'",
729
          "type": "string"
730
        },
731
        "status": {
732
          "description": "Delivery status",
733
          "type": "string"
734
        },
735
        "to_address": {
736
          "description": "Destination email address",
737
          "type": "string"
738
        },
739
        "from_address": {
740
          "description": "Source address of email",
741
          "type": "string"
742
        },
743
        "delivery_note": {
744
          "description": "Additional delivery notes",
745
          "type": "string"
746
        }
747
      }
748
    },
494
    "error": {
749
    "error": {
495
      "type": "object",
750
      "type": "object",
496
      "properties": {
751
      "properties": {
Lines 529-534 Link Here
529
      "description": "Internal item identifier",
784
      "description": "Internal item identifier",
530
      "required": "true",
785
      "required": "true",
531
      "type": "integer"
786
      "type": "integer"
787
    },
788
    "messagenumberPathParam": {
789
      "name": "messagenumber",
790
      "in": "path",
791
      "description": "Internal message identifier",
792
      "required": "true",
793
      "type": "integer"
532
    }
794
    }
533
  },
795
  },
534
  "securityDefinitions": {
796
  "securityDefinitions": {
(-)a/installer/data/mysql/atomicupdate/Bug14767-Add_Permissions_for_message_queue_REST_operations.pl (+38 lines)
Line 0 Link Here
1
#!/usr/bin/perl
2
3
# Copyright Open Source Freedom Fighters
4
#
5
# This file is part of Koha.
6
#
7
# Koha is free software; you can redistribute it and/or modify it under the
8
# terms of the GNU General Public License as published by the Free Software
9
# Foundation; either version 3 of the License, or (at your option) any later
10
# version.
11
#
12
# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
13
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14
# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
15
#
16
# You should have received a copy of the GNU General Public License along
17
# with Koha; if not, write to the Free Software Foundation, Inc.,
18
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19
20
use C4::Context;
21
use Koha::AtomicUpdater;
22
23
my $dbh = C4::Context->dbh();
24
my $atomicUpdater = Koha::AtomicUpdater->new();
25
26
unless($atomicUpdater->find('Bug14767-Add_Permissions_for_message_queue_REST_operations.pl')) {
27
28
    use Koha::Auth::PermissionManager;
29
    my $pm = Koha::Auth::PermissionManager->new();
30
    $pm->addPermissionModule({module => 'messages', description => 'Permission regarding notifications and messages in message queue.'});
31
    $pm->addPermission({module => 'messages', code => 'get_message', description => "Allows to get the messages in message queue."});
32
    $pm->addPermission({module => 'messages', code => 'create_message', description => "Allows to create a new message and queue it."});
33
    $pm->addPermission({module => 'messages', code => 'update_message', description => "Allows to update messages in message queue."});
34
    $pm->addPermission({module => 'messages', code => 'delete_message', description => "Allows to delete a message and queue it."});
35
    $pm->addPermission({module => 'messages', code => 'resend_message', description => "Allows to resend messages in message queue."});
36
37
    print "Upgrade done (Bug 14767: Add Pemissions for message queue REST operations)\n";
38
}
(-)a/t/db_dependent/Api/V1/Messages.pm (+272 lines)
Line 0 Link Here
1
package t::db_dependent::Api::V1::Messages;
2
3
use Modern::Perl;
4
use Test::More;
5
6
use t::lib::TestObjects::ObjectFactory;
7
use t::lib::TestObjects::MessageQueueFactory;
8
9
use C4::Letters;
10
11
sub get200 {
12
    my ($class, $restTest, $driver) = @_;
13
    my $testContext = $restTest->get_testContext();
14
    my $activeUser = $restTest->get_activeBorrower();
15
    my $path = $restTest->get_routePath();
16
    
17
    #Create the test context.
18
    my $messages = t::lib::TestObjects::MessageQueueFactory->createTestGroup(
19
                        {
20
                            subject => "The quick brown fox",
21
                            content => "Jumps over the lazy dog.",
22
                            cardnumber => $activeUser->{'_result'}->{'_column_data'}->{cardnumber},
23
                            message_transport_type => 'sms',
24
                            from_address => '11A001@example.com',
25
                        }, undef, $testContext, undef, undef);
26
27
    my $messagenumber = $messages->{'11A001@example.com'}->{message_id};
28
    
29
    $driver->get_ok($path => {Accept => 'text/json'});
30
    $driver->status_is(200);
31
32
    $driver->json_has("message_id", "Message id in JSON.");
33
34
    t::lib::TestObjects::ObjectFactory->tearDownTestContext($testContext);
35
    return 1;
36
}
37
38
sub get404 {
39
    my ($class, $restTest, $driver) = @_;
40
    my $path = $restTest->get_routePath();
41
    my $testContext = $restTest->get_testContext();
42
    
43
    # clear test context before checking for 404
44
    t::lib::TestObjects::ObjectFactory->tearDownTestContext($testContext);
45
    
46
    $driver->get_ok($path => {Accept => 'text/json'});
47
    $driver->status_is(404);
48
    
49
    return 1;
50
}
51
52
sub get_n_200 {
53
    my ($class, $restTest, $driver) = @_;
54
    my $testContext = $restTest->get_testContext();
55
    my $activeUser = $restTest->get_activeBorrower();
56
    my $path = $restTest->get_routePath();
57
    
58
    #Create the test context.
59
    my $messages = t::lib::TestObjects::MessageQueueFactory->createTestGroup(
60
                        {
61
                            subject => "The quick brown fox",
62
                            content => "Jumps over the lazy dog.",
63
                            cardnumber => $activeUser->{'_result'}->{'_column_data'}->{cardnumber},
64
                            message_transport_type => 'sms',
65
                            from_address => '11A002@example.com',
66
                        }, undef, $testContext, undef, undef);
67
68
    my $messagenumber = $messages->{'11A002@example.com'}->{message_id};
69
    $path =~ s/\{messagenumber\}/$messagenumber/;
70
           
71
    $driver->get_ok($path => {Accept => 'text/json'});
72
    $driver->status_is(200);
73
74
    $driver->json_is('/message_id' => $messagenumber, "Message $messagenumber found!");
75
76
    t::lib::TestObjects::ObjectFactory->tearDownTestContext($testContext);
77
    return 1;
78
}
79
80
sub get_n_404 {
81
    my ($class, $restTest, $driver) = @_;
82
    my $path = $restTest->get_routePath();
83
           
84
    $path =~ s/\{messagenumber\}/12349329003007/;
85
    $driver->get_ok($path => {Accept => 'text/json'});
86
    $driver->status_is(404);
87
    
88
    return 1;
89
}
90
91
sub post201 {
92
    my ($class, $restTest, $driver) = @_;
93
    my $path = $restTest->get_routePath();
94
    my $activeUser = $restTest->get_activeBorrower();
95
    
96
    $driver->post_ok($path => {Accept => 'text/json'} => json => {
97
            subject => "hello",
98
            content => "world",
99
            message_transport_type => "email",
100
            borrowernumber => $activeUser->{'_result'}->{'_column_data'}->{borrowernumber},
101
        });
102
    $driver->status_is(201);
103
    
104
    # dequeue the message right after so that get 404 tests will work
105
    my $json = $driver->tx->res->json();
106
    C4::Letters::DequeueLetter({ message_id => $json->{message_id} });
107
    
108
    return 1;
109
}
110
111
sub post400 {
112
    my ($class, $restTest, $driver) = @_;
113
    my $path = $restTest->get_routePath();
114
    my $activeUser = $restTest->get_activeBorrower();
115
    
116
    #post with missing mandatory parameters
117
    $driver->post_ok($path => {Accept => 'text/json'} => json => {
118
            subject => "hello"
119
        });
120
    $driver->status_is(400);
121
    
122
    return 1;
123
}
124
125
sub post_n_resend204 {
126
    my ($class, $restTest, $driver) = @_;
127
    my $testContext = $restTest->get_testContext();
128
    my $activeUser = $restTest->get_activeBorrower();
129
    my $path = $restTest->get_routePath();
130
    
131
    #Create the test context.
132
    my $messages = t::lib::TestObjects::MessageQueueFactory->createTestGroup(
133
                        {
134
                            subject => "The quick brown fox",
135
                            content => "Jumps over the lazy dog.",
136
                            cardnumber => $activeUser->{'_result'}->{'_column_data'}->{cardnumber},
137
                            message_transport_type => 'sms',
138
                            from_address => '11A003@example.com',
139
                        }, undef, $testContext, undef, undef);
140
141
    # send and get the message
142
    C4::Letters::SendQueuedMessages();
143
    my $message = C4::Letters::GetMessage($messages->{'11A003@example.com'}->{message_id});
144
    my $messagenumber = $messages->{'11A003@example.com'}->{message_id};
145
    $path =~ s/\{messagenumber\}/$messagenumber/;
146
           
147
    # sms status should be failed
148
    is($message->{status}, "failed", "Send failed correctly");
149
    
150
    $driver->post_ok($path => {Accept => 'text/json'});
151
    $driver->status_is(204);
152
153
    $message = C4::Letters::GetMessage($messages->{'11A003@example.com'}->{message_id});
154
    is($message->{status}, "pending", "Resend set message status to pending correctly");
155
    
156
    t::lib::TestObjects::ObjectFactory->tearDownTestContext($testContext);
157
    
158
    return 1;
159
}
160
161
sub post_n_resend404 {
162
    my ($class, $restTest, $driver) = @_;
163
    my $path = $restTest->get_routePath();
164
165
    $path =~ s/\{messagenumber\}/12349329003007/;
166
    $driver->post_ok($path => {Accept => 'text/json'});
167
    $driver->status_is(404);
168
169
    return 1;
170
}
171
172
sub put_n_200 {
173
    my ($class, $restTest, $driver) = @_;
174
    my $testContext = $restTest->get_testContext();
175
    my $activeUser = $restTest->get_activeBorrower();
176
    my $path = $restTest->get_routePath();
177
    
178
    #Create the test context.
179
    my $messages = t::lib::TestObjects::MessageQueueFactory->createTestGroup(
180
                        {
181
                            subject => "The quick brown fox",
182
                            content => "Jumps over the lazy dog.",
183
                            cardnumber => $activeUser->{'_result'}->{'_column_data'}->{cardnumber},
184
                            message_transport_type => 'sms',
185
                            from_address => '11A003@example.com',
186
                        }, undef, $testContext, undef, undef);
187
188
    my $messagenumber = $messages->{'11A003@example.com'}->{message_id};
189
    $path =~ s/\{messagenumber\}/$messagenumber/;
190
           
191
    $driver->put_ok($path => {Accept => 'text/json'} => json => {
192
            subject => "hello",
193
            content => "world",
194
        });
195
    $driver->status_is(200);
196
    
197
    my $json = $driver->tx->res->json();
198
    is($json->{subject}, "hello", "Put updated message subject correctly");
199
    
200
    t::lib::TestObjects::ObjectFactory->tearDownTestContext($testContext);
201
    
202
    return 1;
203
}
204
205
sub put_n_400 {
206
    my ($class, $restTest, $driver) = @_;
207
    my $testContext = $restTest->get_testContext();
208
    my $activeUser = $restTest->get_activeBorrower();
209
    my $path = $restTest->get_routePath();
210
    
211
    $path =~ s/\{messagenumber\}/12349329003007/;
212
    $driver->put_ok($path => {Accept => 'text/json'} => json => {
213
            message_transport_type => "hello", #invalid transport type
214
        });
215
    $driver->status_is(400);
216
    
217
    return 1;
218
}
219
220
sub put_n_404 {
221
    my ($class, $restTest, $driver) = @_;
222
    my $path = $restTest->get_routePath();
223
           
224
    $path =~ s/\{messagenumber\}/12349329003007/;
225
    $driver->put_ok($path => {Accept => 'text/json'});
226
    $driver->status_is(404);
227
    
228
    return 1;
229
}
230
231
sub delete_n_204 {
232
    my ($class, $restTest, $driver) = @_;
233
    my $testContext = $restTest->get_testContext();
234
    my $activeUser = $restTest->get_activeBorrower();
235
    my $path = $restTest->get_routePath();
236
    
237
    #Create the test context.
238
    my $messages = t::lib::TestObjects::MessageQueueFactory->createTestGroup(
239
                        {
240
                            subject => "The quick brown fox",
241
                            content => "Jumps over the lazy dog.",
242
                            cardnumber => $activeUser->{'_result'}->{'_column_data'}->{cardnumber},
243
                            message_transport_type => 'sms',
244
                            from_address => '11A004@example.com',
245
                        }, undef, $testContext, undef, undef);
246
247
    my $messagenumber = $messages->{'11A004@example.com'}->{message_id};
248
    $path =~ s/\{messagenumber\}/$messagenumber/;
249
           
250
    $driver->delete_ok($path => {Accept => 'text/json'});
251
    $driver->status_is(204);
252
    
253
    # if DELETE was successfull, delete it from testContext too.
254
    if ($driver->{tx}->{res}->{code} == 204) {
255
        delete $restTest->{testContext}->{messagequeue}->{'11A004@example.com'};
256
    }
257
    
258
    return 1;
259
}
260
261
sub delete_n_404 {
262
    my ($class, $restTest, $driver) = @_;
263
    my $path = $restTest->get_routePath();
264
           
265
    $path =~ s/\{messagenumber\}/12349329003007/;
266
    $driver->delete_ok($path => {Accept => 'text/json'});
267
    $driver->status_is(404);
268
    
269
    return 1;
270
}
271
272
1;
(-)a/t/db_dependent/Letters.t (-2 / +14 lines)
Lines 18-24 Link Here
18
# along with Koha; if not, see <http://www.gnu.org/licenses>.
18
# along with Koha; if not, see <http://www.gnu.org/licenses>.
19
19
20
use Modern::Perl;
20
use Modern::Perl;
21
use Test::More tests => 74;
21
use Test::More tests => 79;
22
use Test::MockModule;
22
use Test::MockModule;
23
use Test::Warn;
23
use Test::Warn;
24
24
Lines 134-139 is( $messages->[0]->{message_transport_type}, $my_message->{message_transport_ty Link Here
134
is( $messages->[0]->{status}, 'pending', 'EnqueueLetter stores the status pending correctly' );
134
is( $messages->[0]->{status}, 'pending', 'EnqueueLetter stores the status pending correctly' );
135
is( $messages->[0]->{delivery_note}, '', 'Delivery note for successful message correctly empty');
135
is( $messages->[0]->{delivery_note}, '', 'Delivery note for successful message correctly empty');
136
136
137
my $message_by_id = C4::Letters::GetQueuedMessages({ message_id => $messages->[0]->{message_id} });
138
is ($messages->[0]->{message_id}, $message_by_id->[0]->{message_id}, "GetQueuedMessages by message_id gets correct one");
139
137
# SendQueuedMessages
140
# SendQueuedMessages
138
my $messages_processed = C4::Letters::SendQueuedMessages();
141
my $messages_processed = C4::Letters::SendQueuedMessages();
139
is($messages_processed, 1, 'all queued messages processed');
142
is($messages_processed, 1, 'all queued messages processed');
Lines 158-163 is( $resent, undef, 'ResendMessage should return undef if not message_id given' Link Here
158
# Delivery notes
161
# Delivery notes
159
is($messages->[0]->{delivery_note}, 'Missing SMS number', 'Delivery note for no smsalertnumber correctly set');
162
is($messages->[0]->{delivery_note}, 'Missing SMS number', 'Delivery note for no smsalertnumber correctly set');
160
163
164
# UpdateQueuedMessage
165
is(C4::Letters::UpdateQueuedMessage({ message_id => $messages->[0]->{message_id}, content => "changed content" } ), 1, "Message updated correctly");
166
$messages = C4::Letters::GetQueuedMessages();
167
is($messages->[0]->{content}, "changed content", "Message content was changed correctly");
168
161
# Test connectivity Exception (Bug 14791)
169
# Test connectivity Exception (Bug 14791)
162
ModMember(borrowernumber => $borrowernumber, smsalertnumber => "+1234567890");
170
ModMember(borrowernumber => $borrowernumber, smsalertnumber => "+1234567890");
163
warning_is { $messages_processed = C4::Letters::SendQueuedMessages(); }
171
warning_is { $messages_processed = C4::Letters::SendQueuedMessages(); }
Lines 169-174 is( $messages->[0]->{status}, 'pending', Link Here
169
is( $messages->[0]->{delivery_note}, 'Connection failed. Attempting to resend.',
177
is( $messages->[0]->{delivery_note}, 'Connection failed. Attempting to resend.',
170
    'Message has correct delivery note about resending' );
178
    'Message has correct delivery note about resending' );
171
179
180
#DequeueLetter
181
is(C4::Letters::DequeueLetter( { message_id => $messages->[0]->{message_id} } ), 1, "message successfully dequeued");
182
$messages = C4::Letters::GetQueuedMessages();
183
is( @$messages, 0, 'no messages left after dequeue' );
184
172
# GetLetters
185
# GetLetters
173
my $letters = C4::Letters::GetLetters();
186
my $letters = C4::Letters::GetLetters();
174
is( @$letters, 0, 'GetLetters returns the correct number of letters' );
187
is( @$letters, 0, 'GetLetters returns the correct number of letters' );
175
- 

Return to bug 14843