fe3d343ee2acac875ae87ff92bca2b6bdcf0c6c4
[asterisk/asterisk.git] / res / res_ari_recordings.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012 - 2013, Digium, Inc.
5  *
6  * David M. Lee, II <dlee@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*
20  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
21  * !!!!!                               DO NOT EDIT                        !!!!!
22  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
23  * This file is generated by a mustache template. Please see the original
24  * template in rest-api-templates/res_ari_resource.c.mustache
25  */
26
27 /*! \file
28  *
29  * \brief Recording resources
30  *
31  * \author David M. Lee, II <dlee@digium.com>
32  */
33
34 /*** MODULEINFO
35         <depend type="module">res_ari</depend>
36         <depend type="module">res_ari_model</depend>
37         <depend type="module">res_stasis</depend>
38         <support_level>core</support_level>
39  ***/
40
41 #include "asterisk.h"
42
43 #include "asterisk/app.h"
44 #include "asterisk/module.h"
45 #include "asterisk/stasis_app.h"
46 #include "ari/resource_recordings.h"
47 #if defined(AST_DEVMODE)
48 #include "ari/ari_model_validators.h"
49 #endif
50
51 #define MAX_VALS 128
52
53 /*!
54  * \brief Parameter parsing callback for /recordings/stored.
55  * \param get_params GET parameters in the HTTP request.
56  * \param path_vars Path variables extracted from the request.
57  * \param headers HTTP headers.
58  * \param[out] response Response to the HTTP request.
59  */
60 static void ast_ari_recordings_list_stored_cb(
61         struct ast_tcptls_session_instance *ser,
62         struct ast_variable *get_params, struct ast_variable *path_vars,
63         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
64 {
65         struct ast_ari_recordings_list_stored_args args = {};
66 #if defined(AST_DEVMODE)
67         int is_valid;
68         int code;
69 #endif /* AST_DEVMODE */
70
71         ast_ari_recordings_list_stored(headers, &args, response);
72 #if defined(AST_DEVMODE)
73         code = response->response_code;
74
75         switch (code) {
76         case 0: /* Implementation is still a stub, or the code wasn't set */
77                 is_valid = response->message == NULL;
78                 break;
79         case 500: /* Internal Server Error */
80         case 501: /* Not Implemented */
81                 is_valid = 1;
82                 break;
83         default:
84                 if (200 <= code && code <= 299) {
85                         is_valid = ast_ari_validate_list(response->message,
86                                 ast_ari_validate_stored_recording_fn());
87                 } else {
88                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored\n", code);
89                         is_valid = 0;
90                 }
91         }
92
93         if (!is_valid) {
94                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored\n");
95                 ast_ari_response_error(response, 500,
96                         "Internal Server Error", "Response validation failed");
97         }
98 #endif /* AST_DEVMODE */
99
100 fin: __attribute__((unused))
101         return;
102 }
103 /*!
104  * \brief Parameter parsing callback for /recordings/stored/{recordingName}.
105  * \param get_params GET parameters in the HTTP request.
106  * \param path_vars Path variables extracted from the request.
107  * \param headers HTTP headers.
108  * \param[out] response Response to the HTTP request.
109  */
110 static void ast_ari_recordings_get_stored_cb(
111         struct ast_tcptls_session_instance *ser,
112         struct ast_variable *get_params, struct ast_variable *path_vars,
113         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
114 {
115         struct ast_ari_recordings_get_stored_args args = {};
116         struct ast_variable *i;
117 #if defined(AST_DEVMODE)
118         int is_valid;
119         int code;
120 #endif /* AST_DEVMODE */
121
122         for (i = path_vars; i; i = i->next) {
123                 if (strcmp(i->name, "recordingName") == 0) {
124                         args.recording_name = (i->value);
125                 } else
126                 {}
127         }
128         ast_ari_recordings_get_stored(headers, &args, response);
129 #if defined(AST_DEVMODE)
130         code = response->response_code;
131
132         switch (code) {
133         case 0: /* Implementation is still a stub, or the code wasn't set */
134                 is_valid = response->message == NULL;
135                 break;
136         case 500: /* Internal Server Error */
137         case 501: /* Not Implemented */
138         case 404: /* Recording not found */
139                 is_valid = 1;
140                 break;
141         default:
142                 if (200 <= code && code <= 299) {
143                         is_valid = ast_ari_validate_stored_recording(
144                                 response->message);
145                 } else {
146                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}\n", code);
147                         is_valid = 0;
148                 }
149         }
150
151         if (!is_valid) {
152                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}\n");
153                 ast_ari_response_error(response, 500,
154                         "Internal Server Error", "Response validation failed");
155         }
156 #endif /* AST_DEVMODE */
157
158 fin: __attribute__((unused))
159         return;
160 }
161 /*!
162  * \brief Parameter parsing callback for /recordings/stored/{recordingName}.
163  * \param get_params GET parameters in the HTTP request.
164  * \param path_vars Path variables extracted from the request.
165  * \param headers HTTP headers.
166  * \param[out] response Response to the HTTP request.
167  */
168 static void ast_ari_recordings_delete_stored_cb(
169         struct ast_tcptls_session_instance *ser,
170         struct ast_variable *get_params, struct ast_variable *path_vars,
171         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
172 {
173         struct ast_ari_recordings_delete_stored_args args = {};
174         struct ast_variable *i;
175 #if defined(AST_DEVMODE)
176         int is_valid;
177         int code;
178 #endif /* AST_DEVMODE */
179
180         for (i = path_vars; i; i = i->next) {
181                 if (strcmp(i->name, "recordingName") == 0) {
182                         args.recording_name = (i->value);
183                 } else
184                 {}
185         }
186         ast_ari_recordings_delete_stored(headers, &args, response);
187 #if defined(AST_DEVMODE)
188         code = response->response_code;
189
190         switch (code) {
191         case 0: /* Implementation is still a stub, or the code wasn't set */
192                 is_valid = response->message == NULL;
193                 break;
194         case 500: /* Internal Server Error */
195         case 501: /* Not Implemented */
196         case 404: /* Recording not found */
197                 is_valid = 1;
198                 break;
199         default:
200                 if (200 <= code && code <= 299) {
201                         is_valid = ast_ari_validate_void(
202                                 response->message);
203                 } else {
204                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}\n", code);
205                         is_valid = 0;
206                 }
207         }
208
209         if (!is_valid) {
210                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}\n");
211                 ast_ari_response_error(response, 500,
212                         "Internal Server Error", "Response validation failed");
213         }
214 #endif /* AST_DEVMODE */
215
216 fin: __attribute__((unused))
217         return;
218 }
219 /*!
220  * \brief Parameter parsing callback for /recordings/stored/{recordingName}/file.
221  * \param get_params GET parameters in the HTTP request.
222  * \param path_vars Path variables extracted from the request.
223  * \param headers HTTP headers.
224  * \param[out] response Response to the HTTP request.
225  */
226 static void ast_ari_recordings_get_stored_file_cb(
227         struct ast_tcptls_session_instance *ser,
228         struct ast_variable *get_params, struct ast_variable *path_vars,
229         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
230 {
231         struct ast_ari_recordings_get_stored_file_args args = {};
232         struct ast_variable *i;
233 #if defined(AST_DEVMODE)
234         int is_valid;
235         int code;
236 #endif /* AST_DEVMODE */
237
238         for (i = path_vars; i; i = i->next) {
239                 if (strcmp(i->name, "recordingName") == 0) {
240                         args.recording_name = (i->value);
241                 } else
242                 {}
243         }
244         ast_ari_recordings_get_stored_file(ser, headers, &args, response);
245 #if defined(AST_DEVMODE)
246         code = response->response_code;
247
248         switch (code) {
249         case 0: /* Implementation is still a stub, or the code wasn't set */
250                 is_valid = response->message == NULL;
251                 break;
252         case 500: /* Internal Server Error */
253         case 501: /* Not Implemented */
254         case 403: /* The recording file could not be opened */
255         case 404: /* Recording not found */
256                 is_valid = 1;
257                 break;
258         default:
259                 if (200 <= code && code <= 299) {
260                         /* No validation on a raw binary response */
261                         is_valid = 1;
262                 } else {
263                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}/file\n", code);
264                         is_valid = 0;
265                 }
266         }
267
268         if (!is_valid) {
269                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}/file\n");
270                 ast_ari_response_error(response, 500,
271                         "Internal Server Error", "Response validation failed");
272         }
273 #endif /* AST_DEVMODE */
274
275 fin: __attribute__((unused))
276         return;
277 }
278 int ast_ari_recordings_copy_stored_parse_body(
279         struct ast_json *body,
280         struct ast_ari_recordings_copy_stored_args *args)
281 {
282         struct ast_json *field;
283         /* Parse query parameters out of it */
284         field = ast_json_object_get(body, "destinationRecordingName");
285         if (field) {
286                 args->destination_recording_name = ast_json_string_get(field);
287         }
288         return 0;
289 }
290
291 /*!
292  * \brief Parameter parsing callback for /recordings/stored/{recordingName}/copy.
293  * \param get_params GET parameters in the HTTP request.
294  * \param path_vars Path variables extracted from the request.
295  * \param headers HTTP headers.
296  * \param[out] response Response to the HTTP request.
297  */
298 static void ast_ari_recordings_copy_stored_cb(
299         struct ast_tcptls_session_instance *ser,
300         struct ast_variable *get_params, struct ast_variable *path_vars,
301         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
302 {
303         struct ast_ari_recordings_copy_stored_args args = {};
304         struct ast_variable *i;
305 #if defined(AST_DEVMODE)
306         int is_valid;
307         int code;
308 #endif /* AST_DEVMODE */
309
310         for (i = get_params; i; i = i->next) {
311                 if (strcmp(i->name, "destinationRecordingName") == 0) {
312                         args.destination_recording_name = (i->value);
313                 } else
314                 {}
315         }
316         for (i = path_vars; i; i = i->next) {
317                 if (strcmp(i->name, "recordingName") == 0) {
318                         args.recording_name = (i->value);
319                 } else
320                 {}
321         }
322         if (ast_ari_recordings_copy_stored_parse_body(body, &args)) {
323                 ast_ari_response_alloc_failed(response);
324                 goto fin;
325         }
326         ast_ari_recordings_copy_stored(headers, &args, response);
327 #if defined(AST_DEVMODE)
328         code = response->response_code;
329
330         switch (code) {
331         case 0: /* Implementation is still a stub, or the code wasn't set */
332                 is_valid = response->message == NULL;
333                 break;
334         case 500: /* Internal Server Error */
335         case 501: /* Not Implemented */
336         case 404: /* Recording not found */
337         case 409: /* A recording with the same name already exists on the system */
338                 is_valid = 1;
339                 break;
340         default:
341                 if (200 <= code && code <= 299) {
342                         is_valid = ast_ari_validate_stored_recording(
343                                 response->message);
344                 } else {
345                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}/copy\n", code);
346                         is_valid = 0;
347                 }
348         }
349
350         if (!is_valid) {
351                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}/copy\n");
352                 ast_ari_response_error(response, 500,
353                         "Internal Server Error", "Response validation failed");
354         }
355 #endif /* AST_DEVMODE */
356
357 fin: __attribute__((unused))
358         return;
359 }
360 /*!
361  * \brief Parameter parsing callback for /recordings/live/{recordingName}.
362  * \param get_params GET parameters in the HTTP request.
363  * \param path_vars Path variables extracted from the request.
364  * \param headers HTTP headers.
365  * \param[out] response Response to the HTTP request.
366  */
367 static void ast_ari_recordings_get_live_cb(
368         struct ast_tcptls_session_instance *ser,
369         struct ast_variable *get_params, struct ast_variable *path_vars,
370         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
371 {
372         struct ast_ari_recordings_get_live_args args = {};
373         struct ast_variable *i;
374 #if defined(AST_DEVMODE)
375         int is_valid;
376         int code;
377 #endif /* AST_DEVMODE */
378
379         for (i = path_vars; i; i = i->next) {
380                 if (strcmp(i->name, "recordingName") == 0) {
381                         args.recording_name = (i->value);
382                 } else
383                 {}
384         }
385         ast_ari_recordings_get_live(headers, &args, response);
386 #if defined(AST_DEVMODE)
387         code = response->response_code;
388
389         switch (code) {
390         case 0: /* Implementation is still a stub, or the code wasn't set */
391                 is_valid = response->message == NULL;
392                 break;
393         case 500: /* Internal Server Error */
394         case 501: /* Not Implemented */
395         case 404: /* Recording not found */
396                 is_valid = 1;
397                 break;
398         default:
399                 if (200 <= code && code <= 299) {
400                         is_valid = ast_ari_validate_live_recording(
401                                 response->message);
402                 } else {
403                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}\n", code);
404                         is_valid = 0;
405                 }
406         }
407
408         if (!is_valid) {
409                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}\n");
410                 ast_ari_response_error(response, 500,
411                         "Internal Server Error", "Response validation failed");
412         }
413 #endif /* AST_DEVMODE */
414
415 fin: __attribute__((unused))
416         return;
417 }
418 /*!
419  * \brief Parameter parsing callback for /recordings/live/{recordingName}.
420  * \param get_params GET parameters in the HTTP request.
421  * \param path_vars Path variables extracted from the request.
422  * \param headers HTTP headers.
423  * \param[out] response Response to the HTTP request.
424  */
425 static void ast_ari_recordings_cancel_cb(
426         struct ast_tcptls_session_instance *ser,
427         struct ast_variable *get_params, struct ast_variable *path_vars,
428         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
429 {
430         struct ast_ari_recordings_cancel_args args = {};
431         struct ast_variable *i;
432 #if defined(AST_DEVMODE)
433         int is_valid;
434         int code;
435 #endif /* AST_DEVMODE */
436
437         for (i = path_vars; i; i = i->next) {
438                 if (strcmp(i->name, "recordingName") == 0) {
439                         args.recording_name = (i->value);
440                 } else
441                 {}
442         }
443         ast_ari_recordings_cancel(headers, &args, response);
444 #if defined(AST_DEVMODE)
445         code = response->response_code;
446
447         switch (code) {
448         case 0: /* Implementation is still a stub, or the code wasn't set */
449                 is_valid = response->message == NULL;
450                 break;
451         case 500: /* Internal Server Error */
452         case 501: /* Not Implemented */
453         case 404: /* Recording not found */
454                 is_valid = 1;
455                 break;
456         default:
457                 if (200 <= code && code <= 299) {
458                         is_valid = ast_ari_validate_void(
459                                 response->message);
460                 } else {
461                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}\n", code);
462                         is_valid = 0;
463                 }
464         }
465
466         if (!is_valid) {
467                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}\n");
468                 ast_ari_response_error(response, 500,
469                         "Internal Server Error", "Response validation failed");
470         }
471 #endif /* AST_DEVMODE */
472
473 fin: __attribute__((unused))
474         return;
475 }
476 /*!
477  * \brief Parameter parsing callback for /recordings/live/{recordingName}/stop.
478  * \param get_params GET parameters in the HTTP request.
479  * \param path_vars Path variables extracted from the request.
480  * \param headers HTTP headers.
481  * \param[out] response Response to the HTTP request.
482  */
483 static void ast_ari_recordings_stop_cb(
484         struct ast_tcptls_session_instance *ser,
485         struct ast_variable *get_params, struct ast_variable *path_vars,
486         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
487 {
488         struct ast_ari_recordings_stop_args args = {};
489         struct ast_variable *i;
490 #if defined(AST_DEVMODE)
491         int is_valid;
492         int code;
493 #endif /* AST_DEVMODE */
494
495         for (i = path_vars; i; i = i->next) {
496                 if (strcmp(i->name, "recordingName") == 0) {
497                         args.recording_name = (i->value);
498                 } else
499                 {}
500         }
501         ast_ari_recordings_stop(headers, &args, response);
502 #if defined(AST_DEVMODE)
503         code = response->response_code;
504
505         switch (code) {
506         case 0: /* Implementation is still a stub, or the code wasn't set */
507                 is_valid = response->message == NULL;
508                 break;
509         case 500: /* Internal Server Error */
510         case 501: /* Not Implemented */
511         case 404: /* Recording not found */
512                 is_valid = 1;
513                 break;
514         default:
515                 if (200 <= code && code <= 299) {
516                         is_valid = ast_ari_validate_void(
517                                 response->message);
518                 } else {
519                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/stop\n", code);
520                         is_valid = 0;
521                 }
522         }
523
524         if (!is_valid) {
525                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/stop\n");
526                 ast_ari_response_error(response, 500,
527                         "Internal Server Error", "Response validation failed");
528         }
529 #endif /* AST_DEVMODE */
530
531 fin: __attribute__((unused))
532         return;
533 }
534 /*!
535  * \brief Parameter parsing callback for /recordings/live/{recordingName}/pause.
536  * \param get_params GET parameters in the HTTP request.
537  * \param path_vars Path variables extracted from the request.
538  * \param headers HTTP headers.
539  * \param[out] response Response to the HTTP request.
540  */
541 static void ast_ari_recordings_pause_cb(
542         struct ast_tcptls_session_instance *ser,
543         struct ast_variable *get_params, struct ast_variable *path_vars,
544         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
545 {
546         struct ast_ari_recordings_pause_args args = {};
547         struct ast_variable *i;
548 #if defined(AST_DEVMODE)
549         int is_valid;
550         int code;
551 #endif /* AST_DEVMODE */
552
553         for (i = path_vars; i; i = i->next) {
554                 if (strcmp(i->name, "recordingName") == 0) {
555                         args.recording_name = (i->value);
556                 } else
557                 {}
558         }
559         ast_ari_recordings_pause(headers, &args, response);
560 #if defined(AST_DEVMODE)
561         code = response->response_code;
562
563         switch (code) {
564         case 0: /* Implementation is still a stub, or the code wasn't set */
565                 is_valid = response->message == NULL;
566                 break;
567         case 500: /* Internal Server Error */
568         case 501: /* Not Implemented */
569         case 404: /* Recording not found */
570         case 409: /* Recording not in session */
571                 is_valid = 1;
572                 break;
573         default:
574                 if (200 <= code && code <= 299) {
575                         is_valid = ast_ari_validate_void(
576                                 response->message);
577                 } else {
578                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/pause\n", code);
579                         is_valid = 0;
580                 }
581         }
582
583         if (!is_valid) {
584                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/pause\n");
585                 ast_ari_response_error(response, 500,
586                         "Internal Server Error", "Response validation failed");
587         }
588 #endif /* AST_DEVMODE */
589
590 fin: __attribute__((unused))
591         return;
592 }
593 /*!
594  * \brief Parameter parsing callback for /recordings/live/{recordingName}/pause.
595  * \param get_params GET parameters in the HTTP request.
596  * \param path_vars Path variables extracted from the request.
597  * \param headers HTTP headers.
598  * \param[out] response Response to the HTTP request.
599  */
600 static void ast_ari_recordings_unpause_cb(
601         struct ast_tcptls_session_instance *ser,
602         struct ast_variable *get_params, struct ast_variable *path_vars,
603         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
604 {
605         struct ast_ari_recordings_unpause_args args = {};
606         struct ast_variable *i;
607 #if defined(AST_DEVMODE)
608         int is_valid;
609         int code;
610 #endif /* AST_DEVMODE */
611
612         for (i = path_vars; i; i = i->next) {
613                 if (strcmp(i->name, "recordingName") == 0) {
614                         args.recording_name = (i->value);
615                 } else
616                 {}
617         }
618         ast_ari_recordings_unpause(headers, &args, response);
619 #if defined(AST_DEVMODE)
620         code = response->response_code;
621
622         switch (code) {
623         case 0: /* Implementation is still a stub, or the code wasn't set */
624                 is_valid = response->message == NULL;
625                 break;
626         case 500: /* Internal Server Error */
627         case 501: /* Not Implemented */
628         case 404: /* Recording not found */
629         case 409: /* Recording not in session */
630                 is_valid = 1;
631                 break;
632         default:
633                 if (200 <= code && code <= 299) {
634                         is_valid = ast_ari_validate_void(
635                                 response->message);
636                 } else {
637                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/pause\n", code);
638                         is_valid = 0;
639                 }
640         }
641
642         if (!is_valid) {
643                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/pause\n");
644                 ast_ari_response_error(response, 500,
645                         "Internal Server Error", "Response validation failed");
646         }
647 #endif /* AST_DEVMODE */
648
649 fin: __attribute__((unused))
650         return;
651 }
652 /*!
653  * \brief Parameter parsing callback for /recordings/live/{recordingName}/mute.
654  * \param get_params GET parameters in the HTTP request.
655  * \param path_vars Path variables extracted from the request.
656  * \param headers HTTP headers.
657  * \param[out] response Response to the HTTP request.
658  */
659 static void ast_ari_recordings_mute_cb(
660         struct ast_tcptls_session_instance *ser,
661         struct ast_variable *get_params, struct ast_variable *path_vars,
662         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
663 {
664         struct ast_ari_recordings_mute_args args = {};
665         struct ast_variable *i;
666 #if defined(AST_DEVMODE)
667         int is_valid;
668         int code;
669 #endif /* AST_DEVMODE */
670
671         for (i = path_vars; i; i = i->next) {
672                 if (strcmp(i->name, "recordingName") == 0) {
673                         args.recording_name = (i->value);
674                 } else
675                 {}
676         }
677         ast_ari_recordings_mute(headers, &args, response);
678 #if defined(AST_DEVMODE)
679         code = response->response_code;
680
681         switch (code) {
682         case 0: /* Implementation is still a stub, or the code wasn't set */
683                 is_valid = response->message == NULL;
684                 break;
685         case 500: /* Internal Server Error */
686         case 501: /* Not Implemented */
687         case 404: /* Recording not found */
688         case 409: /* Recording not in session */
689                 is_valid = 1;
690                 break;
691         default:
692                 if (200 <= code && code <= 299) {
693                         is_valid = ast_ari_validate_void(
694                                 response->message);
695                 } else {
696                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/mute\n", code);
697                         is_valid = 0;
698                 }
699         }
700
701         if (!is_valid) {
702                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/mute\n");
703                 ast_ari_response_error(response, 500,
704                         "Internal Server Error", "Response validation failed");
705         }
706 #endif /* AST_DEVMODE */
707
708 fin: __attribute__((unused))
709         return;
710 }
711 /*!
712  * \brief Parameter parsing callback for /recordings/live/{recordingName}/mute.
713  * \param get_params GET parameters in the HTTP request.
714  * \param path_vars Path variables extracted from the request.
715  * \param headers HTTP headers.
716  * \param[out] response Response to the HTTP request.
717  */
718 static void ast_ari_recordings_unmute_cb(
719         struct ast_tcptls_session_instance *ser,
720         struct ast_variable *get_params, struct ast_variable *path_vars,
721         struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
722 {
723         struct ast_ari_recordings_unmute_args args = {};
724         struct ast_variable *i;
725 #if defined(AST_DEVMODE)
726         int is_valid;
727         int code;
728 #endif /* AST_DEVMODE */
729
730         for (i = path_vars; i; i = i->next) {
731                 if (strcmp(i->name, "recordingName") == 0) {
732                         args.recording_name = (i->value);
733                 } else
734                 {}
735         }
736         ast_ari_recordings_unmute(headers, &args, response);
737 #if defined(AST_DEVMODE)
738         code = response->response_code;
739
740         switch (code) {
741         case 0: /* Implementation is still a stub, or the code wasn't set */
742                 is_valid = response->message == NULL;
743                 break;
744         case 500: /* Internal Server Error */
745         case 501: /* Not Implemented */
746         case 404: /* Recording not found */
747         case 409: /* Recording not in session */
748                 is_valid = 1;
749                 break;
750         default:
751                 if (200 <= code && code <= 299) {
752                         is_valid = ast_ari_validate_void(
753                                 response->message);
754                 } else {
755                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/mute\n", code);
756                         is_valid = 0;
757                 }
758         }
759
760         if (!is_valid) {
761                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/mute\n");
762                 ast_ari_response_error(response, 500,
763                         "Internal Server Error", "Response validation failed");
764         }
765 #endif /* AST_DEVMODE */
766
767 fin: __attribute__((unused))
768         return;
769 }
770
771 /*! \brief REST handler for /api-docs/recordings.json */
772 static struct stasis_rest_handlers recordings_stored_recordingName_file = {
773         .path_segment = "file",
774         .callbacks = {
775                 [AST_HTTP_GET] = ast_ari_recordings_get_stored_file_cb,
776         },
777         .num_children = 0,
778         .children = {  }
779 };
780 /*! \brief REST handler for /api-docs/recordings.json */
781 static struct stasis_rest_handlers recordings_stored_recordingName_copy = {
782         .path_segment = "copy",
783         .callbacks = {
784                 [AST_HTTP_POST] = ast_ari_recordings_copy_stored_cb,
785         },
786         .num_children = 0,
787         .children = {  }
788 };
789 /*! \brief REST handler for /api-docs/recordings.json */
790 static struct stasis_rest_handlers recordings_stored_recordingName = {
791         .path_segment = "recordingName",
792         .is_wildcard = 1,
793         .callbacks = {
794                 [AST_HTTP_GET] = ast_ari_recordings_get_stored_cb,
795                 [AST_HTTP_DELETE] = ast_ari_recordings_delete_stored_cb,
796         },
797         .num_children = 2,
798         .children = { &recordings_stored_recordingName_file,&recordings_stored_recordingName_copy, }
799 };
800 /*! \brief REST handler for /api-docs/recordings.json */
801 static struct stasis_rest_handlers recordings_stored = {
802         .path_segment = "stored",
803         .callbacks = {
804                 [AST_HTTP_GET] = ast_ari_recordings_list_stored_cb,
805         },
806         .num_children = 1,
807         .children = { &recordings_stored_recordingName, }
808 };
809 /*! \brief REST handler for /api-docs/recordings.json */
810 static struct stasis_rest_handlers recordings_live_recordingName_stop = {
811         .path_segment = "stop",
812         .callbacks = {
813                 [AST_HTTP_POST] = ast_ari_recordings_stop_cb,
814         },
815         .num_children = 0,
816         .children = {  }
817 };
818 /*! \brief REST handler for /api-docs/recordings.json */
819 static struct stasis_rest_handlers recordings_live_recordingName_pause = {
820         .path_segment = "pause",
821         .callbacks = {
822                 [AST_HTTP_POST] = ast_ari_recordings_pause_cb,
823                 [AST_HTTP_DELETE] = ast_ari_recordings_unpause_cb,
824         },
825         .num_children = 0,
826         .children = {  }
827 };
828 /*! \brief REST handler for /api-docs/recordings.json */
829 static struct stasis_rest_handlers recordings_live_recordingName_mute = {
830         .path_segment = "mute",
831         .callbacks = {
832                 [AST_HTTP_POST] = ast_ari_recordings_mute_cb,
833                 [AST_HTTP_DELETE] = ast_ari_recordings_unmute_cb,
834         },
835         .num_children = 0,
836         .children = {  }
837 };
838 /*! \brief REST handler for /api-docs/recordings.json */
839 static struct stasis_rest_handlers recordings_live_recordingName = {
840         .path_segment = "recordingName",
841         .is_wildcard = 1,
842         .callbacks = {
843                 [AST_HTTP_GET] = ast_ari_recordings_get_live_cb,
844                 [AST_HTTP_DELETE] = ast_ari_recordings_cancel_cb,
845         },
846         .num_children = 3,
847         .children = { &recordings_live_recordingName_stop,&recordings_live_recordingName_pause,&recordings_live_recordingName_mute, }
848 };
849 /*! \brief REST handler for /api-docs/recordings.json */
850 static struct stasis_rest_handlers recordings_live = {
851         .path_segment = "live",
852         .callbacks = {
853         },
854         .num_children = 1,
855         .children = { &recordings_live_recordingName, }
856 };
857 /*! \brief REST handler for /api-docs/recordings.json */
858 static struct stasis_rest_handlers recordings = {
859         .path_segment = "recordings",
860         .callbacks = {
861         },
862         .num_children = 2,
863         .children = { &recordings_stored,&recordings_live, }
864 };
865
866 static int unload_module(void)
867 {
868         ast_ari_remove_handler(&recordings);
869         stasis_app_unref();
870         return 0;
871 }
872
873 static int load_module(void)
874 {
875         int res = 0;
876
877         CHECK_ARI_MODULE_LOADED();
878
879
880         stasis_app_ref();
881         res |= ast_ari_add_handler(&recordings);
882         if (res) {
883                 unload_module();
884                 return AST_MODULE_LOAD_DECLINE;
885         }
886
887         return AST_MODULE_LOAD_SUCCESS;
888 }
889
890 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - Recording resources",
891         .support_level = AST_MODULE_SUPPORT_CORE,
892         .load = load_module,
893         .unload = unload_module,
894         .nonoptreq = "res_ari,res_stasis",
895 );