ARI: Add recording controls
[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_stasis</depend>
37         <support_level>core</support_level>
38  ***/
39
40 #include "asterisk.h"
41
42 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
43
44 #include "asterisk/app.h"
45 #include "asterisk/module.h"
46 #include "asterisk/stasis_app.h"
47 #include "ari/resource_recordings.h"
48 #if defined(AST_DEVMODE)
49 #include "ari/ari_model_validators.h"
50 #endif
51
52 #define MAX_VALS 128
53
54 /*!
55  * \brief Parameter parsing callback for /recordings/stored.
56  * \param get_params GET parameters in the HTTP request.
57  * \param path_vars Path variables extracted from the request.
58  * \param headers HTTP headers.
59  * \param[out] response Response to the HTTP request.
60  */
61 static void ast_ari_get_stored_recordings_cb(
62         struct ast_variable *get_params, struct ast_variable *path_vars,
63         struct ast_variable *headers, struct ast_ari_response *response)
64 {
65         struct ast_get_stored_recordings_args args = {};
66 #if defined(AST_DEVMODE)
67         int is_valid;
68         int code;
69 #endif /* AST_DEVMODE */
70
71         ast_ari_get_stored_recordings(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_get_stored_recording_cb(
111         struct ast_variable *get_params, struct ast_variable *path_vars,
112         struct ast_variable *headers, struct ast_ari_response *response)
113 {
114         struct ast_get_stored_recording_args args = {};
115         struct ast_variable *i;
116 #if defined(AST_DEVMODE)
117         int is_valid;
118         int code;
119 #endif /* AST_DEVMODE */
120
121         for (i = path_vars; i; i = i->next) {
122                 if (strcmp(i->name, "recordingName") == 0) {
123                         args.recording_name = (i->value);
124                 } else
125                 {}
126         }
127         ast_ari_get_stored_recording(headers, &args, response);
128 #if defined(AST_DEVMODE)
129         code = response->response_code;
130
131         switch (code) {
132         case 0: /* Implementation is still a stub, or the code wasn't set */
133                 is_valid = response->message == NULL;
134                 break;
135         case 500: /* Internal Server Error */
136         case 501: /* Not Implemented */
137                 is_valid = 1;
138                 break;
139         default:
140                 if (200 <= code && code <= 299) {
141                         is_valid = ast_ari_validate_stored_recording(
142                                 response->message);
143                 } else {
144                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}\n", code);
145                         is_valid = 0;
146                 }
147         }
148
149         if (!is_valid) {
150                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}\n");
151                 ast_ari_response_error(response, 500,
152                         "Internal Server Error", "Response validation failed");
153         }
154 #endif /* AST_DEVMODE */
155
156 fin: __attribute__((unused))
157         return;
158 }
159 /*!
160  * \brief Parameter parsing callback for /recordings/stored/{recordingName}.
161  * \param get_params GET parameters in the HTTP request.
162  * \param path_vars Path variables extracted from the request.
163  * \param headers HTTP headers.
164  * \param[out] response Response to the HTTP request.
165  */
166 static void ast_ari_delete_stored_recording_cb(
167         struct ast_variable *get_params, struct ast_variable *path_vars,
168         struct ast_variable *headers, struct ast_ari_response *response)
169 {
170         struct ast_delete_stored_recording_args args = {};
171         struct ast_variable *i;
172 #if defined(AST_DEVMODE)
173         int is_valid;
174         int code;
175 #endif /* AST_DEVMODE */
176
177         for (i = path_vars; i; i = i->next) {
178                 if (strcmp(i->name, "recordingName") == 0) {
179                         args.recording_name = (i->value);
180                 } else
181                 {}
182         }
183         ast_ari_delete_stored_recording(headers, &args, response);
184 #if defined(AST_DEVMODE)
185         code = response->response_code;
186
187         switch (code) {
188         case 0: /* Implementation is still a stub, or the code wasn't set */
189                 is_valid = response->message == NULL;
190                 break;
191         case 500: /* Internal Server Error */
192         case 501: /* Not Implemented */
193                 is_valid = 1;
194                 break;
195         default:
196                 if (200 <= code && code <= 299) {
197                         is_valid = ast_ari_validate_void(
198                                 response->message);
199                 } else {
200                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}\n", code);
201                         is_valid = 0;
202                 }
203         }
204
205         if (!is_valid) {
206                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}\n");
207                 ast_ari_response_error(response, 500,
208                         "Internal Server Error", "Response validation failed");
209         }
210 #endif /* AST_DEVMODE */
211
212 fin: __attribute__((unused))
213         return;
214 }
215 /*!
216  * \brief Parameter parsing callback for /recordings/live.
217  * \param get_params GET parameters in the HTTP request.
218  * \param path_vars Path variables extracted from the request.
219  * \param headers HTTP headers.
220  * \param[out] response Response to the HTTP request.
221  */
222 static void ast_ari_get_live_recordings_cb(
223         struct ast_variable *get_params, struct ast_variable *path_vars,
224         struct ast_variable *headers, struct ast_ari_response *response)
225 {
226         struct ast_get_live_recordings_args args = {};
227 #if defined(AST_DEVMODE)
228         int is_valid;
229         int code;
230 #endif /* AST_DEVMODE */
231
232         ast_ari_get_live_recordings(headers, &args, response);
233 #if defined(AST_DEVMODE)
234         code = response->response_code;
235
236         switch (code) {
237         case 0: /* Implementation is still a stub, or the code wasn't set */
238                 is_valid = response->message == NULL;
239                 break;
240         case 500: /* Internal Server Error */
241         case 501: /* Not Implemented */
242                 is_valid = 1;
243                 break;
244         default:
245                 if (200 <= code && code <= 299) {
246                         is_valid = ast_ari_validate_list(response->message,
247                                 ast_ari_validate_live_recording_fn());
248                 } else {
249                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live\n", code);
250                         is_valid = 0;
251                 }
252         }
253
254         if (!is_valid) {
255                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live\n");
256                 ast_ari_response_error(response, 500,
257                         "Internal Server Error", "Response validation failed");
258         }
259 #endif /* AST_DEVMODE */
260
261 fin: __attribute__((unused))
262         return;
263 }
264 /*!
265  * \brief Parameter parsing callback for /recordings/live/{recordingName}.
266  * \param get_params GET parameters in the HTTP request.
267  * \param path_vars Path variables extracted from the request.
268  * \param headers HTTP headers.
269  * \param[out] response Response to the HTTP request.
270  */
271 static void ast_ari_get_live_recording_cb(
272         struct ast_variable *get_params, struct ast_variable *path_vars,
273         struct ast_variable *headers, struct ast_ari_response *response)
274 {
275         struct ast_get_live_recording_args args = {};
276         struct ast_variable *i;
277 #if defined(AST_DEVMODE)
278         int is_valid;
279         int code;
280 #endif /* AST_DEVMODE */
281
282         for (i = path_vars; i; i = i->next) {
283                 if (strcmp(i->name, "recordingName") == 0) {
284                         args.recording_name = (i->value);
285                 } else
286                 {}
287         }
288         ast_ari_get_live_recording(headers, &args, response);
289 #if defined(AST_DEVMODE)
290         code = response->response_code;
291
292         switch (code) {
293         case 0: /* Implementation is still a stub, or the code wasn't set */
294                 is_valid = response->message == NULL;
295                 break;
296         case 500: /* Internal Server Error */
297         case 501: /* Not Implemented */
298         case 404: /* Recording not found */
299                 is_valid = 1;
300                 break;
301         default:
302                 if (200 <= code && code <= 299) {
303                         is_valid = ast_ari_validate_live_recording(
304                                 response->message);
305                 } else {
306                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}\n", code);
307                         is_valid = 0;
308                 }
309         }
310
311         if (!is_valid) {
312                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}\n");
313                 ast_ari_response_error(response, 500,
314                         "Internal Server Error", "Response validation failed");
315         }
316 #endif /* AST_DEVMODE */
317
318 fin: __attribute__((unused))
319         return;
320 }
321 /*!
322  * \brief Parameter parsing callback for /recordings/live/{recordingName}.
323  * \param get_params GET parameters in the HTTP request.
324  * \param path_vars Path variables extracted from the request.
325  * \param headers HTTP headers.
326  * \param[out] response Response to the HTTP request.
327  */
328 static void ast_ari_cancel_recording_cb(
329         struct ast_variable *get_params, struct ast_variable *path_vars,
330         struct ast_variable *headers, struct ast_ari_response *response)
331 {
332         struct ast_cancel_recording_args args = {};
333         struct ast_variable *i;
334 #if defined(AST_DEVMODE)
335         int is_valid;
336         int code;
337 #endif /* AST_DEVMODE */
338
339         for (i = path_vars; i; i = i->next) {
340                 if (strcmp(i->name, "recordingName") == 0) {
341                         args.recording_name = (i->value);
342                 } else
343                 {}
344         }
345         ast_ari_cancel_recording(headers, &args, response);
346 #if defined(AST_DEVMODE)
347         code = response->response_code;
348
349         switch (code) {
350         case 0: /* Implementation is still a stub, or the code wasn't set */
351                 is_valid = response->message == NULL;
352                 break;
353         case 500: /* Internal Server Error */
354         case 501: /* Not Implemented */
355         case 404: /* Recording not found */
356                 is_valid = 1;
357                 break;
358         default:
359                 if (200 <= code && code <= 299) {
360                         is_valid = ast_ari_validate_void(
361                                 response->message);
362                 } else {
363                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}\n", code);
364                         is_valid = 0;
365                 }
366         }
367
368         if (!is_valid) {
369                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}\n");
370                 ast_ari_response_error(response, 500,
371                         "Internal Server Error", "Response validation failed");
372         }
373 #endif /* AST_DEVMODE */
374
375 fin: __attribute__((unused))
376         return;
377 }
378 /*!
379  * \brief Parameter parsing callback for /recordings/live/{recordingName}/stop.
380  * \param get_params GET parameters in the HTTP request.
381  * \param path_vars Path variables extracted from the request.
382  * \param headers HTTP headers.
383  * \param[out] response Response to the HTTP request.
384  */
385 static void ast_ari_stop_recording_cb(
386         struct ast_variable *get_params, struct ast_variable *path_vars,
387         struct ast_variable *headers, struct ast_ari_response *response)
388 {
389         struct ast_stop_recording_args args = {};
390         struct ast_variable *i;
391 #if defined(AST_DEVMODE)
392         int is_valid;
393         int code;
394 #endif /* AST_DEVMODE */
395
396         for (i = path_vars; i; i = i->next) {
397                 if (strcmp(i->name, "recordingName") == 0) {
398                         args.recording_name = (i->value);
399                 } else
400                 {}
401         }
402         ast_ari_stop_recording(headers, &args, response);
403 #if defined(AST_DEVMODE)
404         code = response->response_code;
405
406         switch (code) {
407         case 0: /* Implementation is still a stub, or the code wasn't set */
408                 is_valid = response->message == NULL;
409                 break;
410         case 500: /* Internal Server Error */
411         case 501: /* Not Implemented */
412         case 404: /* Recording not found */
413                 is_valid = 1;
414                 break;
415         default:
416                 if (200 <= code && code <= 299) {
417                         is_valid = ast_ari_validate_void(
418                                 response->message);
419                 } else {
420                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/stop\n", code);
421                         is_valid = 0;
422                 }
423         }
424
425         if (!is_valid) {
426                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/stop\n");
427                 ast_ari_response_error(response, 500,
428                         "Internal Server Error", "Response validation failed");
429         }
430 #endif /* AST_DEVMODE */
431
432 fin: __attribute__((unused))
433         return;
434 }
435 /*!
436  * \brief Parameter parsing callback for /recordings/live/{recordingName}/pause.
437  * \param get_params GET parameters in the HTTP request.
438  * \param path_vars Path variables extracted from the request.
439  * \param headers HTTP headers.
440  * \param[out] response Response to the HTTP request.
441  */
442 static void ast_ari_pause_recording_cb(
443         struct ast_variable *get_params, struct ast_variable *path_vars,
444         struct ast_variable *headers, struct ast_ari_response *response)
445 {
446         struct ast_pause_recording_args args = {};
447         struct ast_variable *i;
448 #if defined(AST_DEVMODE)
449         int is_valid;
450         int code;
451 #endif /* AST_DEVMODE */
452
453         for (i = path_vars; i; i = i->next) {
454                 if (strcmp(i->name, "recordingName") == 0) {
455                         args.recording_name = (i->value);
456                 } else
457                 {}
458         }
459         ast_ari_pause_recording(headers, &args, response);
460 #if defined(AST_DEVMODE)
461         code = response->response_code;
462
463         switch (code) {
464         case 0: /* Implementation is still a stub, or the code wasn't set */
465                 is_valid = response->message == NULL;
466                 break;
467         case 500: /* Internal Server Error */
468         case 501: /* Not Implemented */
469         case 404: /* Recording not found */
470         case 409: /* Recording not in session */
471                 is_valid = 1;
472                 break;
473         default:
474                 if (200 <= code && code <= 299) {
475                         is_valid = ast_ari_validate_void(
476                                 response->message);
477                 } else {
478                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/pause\n", code);
479                         is_valid = 0;
480                 }
481         }
482
483         if (!is_valid) {
484                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/pause\n");
485                 ast_ari_response_error(response, 500,
486                         "Internal Server Error", "Response validation failed");
487         }
488 #endif /* AST_DEVMODE */
489
490 fin: __attribute__((unused))
491         return;
492 }
493 /*!
494  * \brief Parameter parsing callback for /recordings/live/{recordingName}/unpause.
495  * \param get_params GET parameters in the HTTP request.
496  * \param path_vars Path variables extracted from the request.
497  * \param headers HTTP headers.
498  * \param[out] response Response to the HTTP request.
499  */
500 static void ast_ari_unpause_recording_cb(
501         struct ast_variable *get_params, struct ast_variable *path_vars,
502         struct ast_variable *headers, struct ast_ari_response *response)
503 {
504         struct ast_unpause_recording_args args = {};
505         struct ast_variable *i;
506 #if defined(AST_DEVMODE)
507         int is_valid;
508         int code;
509 #endif /* AST_DEVMODE */
510
511         for (i = path_vars; i; i = i->next) {
512                 if (strcmp(i->name, "recordingName") == 0) {
513                         args.recording_name = (i->value);
514                 } else
515                 {}
516         }
517         ast_ari_unpause_recording(headers, &args, response);
518 #if defined(AST_DEVMODE)
519         code = response->response_code;
520
521         switch (code) {
522         case 0: /* Implementation is still a stub, or the code wasn't set */
523                 is_valid = response->message == NULL;
524                 break;
525         case 500: /* Internal Server Error */
526         case 501: /* Not Implemented */
527         case 404: /* Recording not found */
528         case 409: /* Recording not in session */
529                 is_valid = 1;
530                 break;
531         default:
532                 if (200 <= code && code <= 299) {
533                         is_valid = ast_ari_validate_void(
534                                 response->message);
535                 } else {
536                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/unpause\n", code);
537                         is_valid = 0;
538                 }
539         }
540
541         if (!is_valid) {
542                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/unpause\n");
543                 ast_ari_response_error(response, 500,
544                         "Internal Server Error", "Response validation failed");
545         }
546 #endif /* AST_DEVMODE */
547
548 fin: __attribute__((unused))
549         return;
550 }
551 /*!
552  * \brief Parameter parsing callback for /recordings/live/{recordingName}/mute.
553  * \param get_params GET parameters in the HTTP request.
554  * \param path_vars Path variables extracted from the request.
555  * \param headers HTTP headers.
556  * \param[out] response Response to the HTTP request.
557  */
558 static void ast_ari_mute_recording_cb(
559         struct ast_variable *get_params, struct ast_variable *path_vars,
560         struct ast_variable *headers, struct ast_ari_response *response)
561 {
562         struct ast_mute_recording_args args = {};
563         struct ast_variable *i;
564 #if defined(AST_DEVMODE)
565         int is_valid;
566         int code;
567 #endif /* AST_DEVMODE */
568
569         for (i = path_vars; i; i = i->next) {
570                 if (strcmp(i->name, "recordingName") == 0) {
571                         args.recording_name = (i->value);
572                 } else
573                 {}
574         }
575         ast_ari_mute_recording(headers, &args, response);
576 #if defined(AST_DEVMODE)
577         code = response->response_code;
578
579         switch (code) {
580         case 0: /* Implementation is still a stub, or the code wasn't set */
581                 is_valid = response->message == NULL;
582                 break;
583         case 500: /* Internal Server Error */
584         case 501: /* Not Implemented */
585         case 404: /* Recording not found */
586         case 409: /* Recording not in session */
587                 is_valid = 1;
588                 break;
589         default:
590                 if (200 <= code && code <= 299) {
591                         is_valid = ast_ari_validate_void(
592                                 response->message);
593                 } else {
594                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/mute\n", code);
595                         is_valid = 0;
596                 }
597         }
598
599         if (!is_valid) {
600                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/mute\n");
601                 ast_ari_response_error(response, 500,
602                         "Internal Server Error", "Response validation failed");
603         }
604 #endif /* AST_DEVMODE */
605
606 fin: __attribute__((unused))
607         return;
608 }
609 /*!
610  * \brief Parameter parsing callback for /recordings/live/{recordingName}/unmute.
611  * \param get_params GET parameters in the HTTP request.
612  * \param path_vars Path variables extracted from the request.
613  * \param headers HTTP headers.
614  * \param[out] response Response to the HTTP request.
615  */
616 static void ast_ari_unmute_recording_cb(
617         struct ast_variable *get_params, struct ast_variable *path_vars,
618         struct ast_variable *headers, struct ast_ari_response *response)
619 {
620         struct ast_unmute_recording_args args = {};
621         struct ast_variable *i;
622 #if defined(AST_DEVMODE)
623         int is_valid;
624         int code;
625 #endif /* AST_DEVMODE */
626
627         for (i = path_vars; i; i = i->next) {
628                 if (strcmp(i->name, "recordingName") == 0) {
629                         args.recording_name = (i->value);
630                 } else
631                 {}
632         }
633         ast_ari_unmute_recording(headers, &args, response);
634 #if defined(AST_DEVMODE)
635         code = response->response_code;
636
637         switch (code) {
638         case 0: /* Implementation is still a stub, or the code wasn't set */
639                 is_valid = response->message == NULL;
640                 break;
641         case 500: /* Internal Server Error */
642         case 501: /* Not Implemented */
643         case 404: /* Recording not found */
644         case 409: /* Recording not in session */
645                 is_valid = 1;
646                 break;
647         default:
648                 if (200 <= code && code <= 299) {
649                         is_valid = ast_ari_validate_void(
650                                 response->message);
651                 } else {
652                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/unmute\n", code);
653                         is_valid = 0;
654                 }
655         }
656
657         if (!is_valid) {
658                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/unmute\n");
659                 ast_ari_response_error(response, 500,
660                         "Internal Server Error", "Response validation failed");
661         }
662 #endif /* AST_DEVMODE */
663
664 fin: __attribute__((unused))
665         return;
666 }
667
668 /*! \brief REST handler for /api-docs/recordings.{format} */
669 static struct stasis_rest_handlers recordings_stored_recordingName = {
670         .path_segment = "recordingName",
671         .is_wildcard = 1,
672         .callbacks = {
673                 [AST_HTTP_GET] = ast_ari_get_stored_recording_cb,
674                 [AST_HTTP_DELETE] = ast_ari_delete_stored_recording_cb,
675         },
676         .num_children = 0,
677         .children = {  }
678 };
679 /*! \brief REST handler for /api-docs/recordings.{format} */
680 static struct stasis_rest_handlers recordings_stored = {
681         .path_segment = "stored",
682         .callbacks = {
683                 [AST_HTTP_GET] = ast_ari_get_stored_recordings_cb,
684         },
685         .num_children = 1,
686         .children = { &recordings_stored_recordingName, }
687 };
688 /*! \brief REST handler for /api-docs/recordings.{format} */
689 static struct stasis_rest_handlers recordings_live_recordingName_stop = {
690         .path_segment = "stop",
691         .callbacks = {
692                 [AST_HTTP_POST] = ast_ari_stop_recording_cb,
693         },
694         .num_children = 0,
695         .children = {  }
696 };
697 /*! \brief REST handler for /api-docs/recordings.{format} */
698 static struct stasis_rest_handlers recordings_live_recordingName_pause = {
699         .path_segment = "pause",
700         .callbacks = {
701                 [AST_HTTP_POST] = ast_ari_pause_recording_cb,
702         },
703         .num_children = 0,
704         .children = {  }
705 };
706 /*! \brief REST handler for /api-docs/recordings.{format} */
707 static struct stasis_rest_handlers recordings_live_recordingName_unpause = {
708         .path_segment = "unpause",
709         .callbacks = {
710                 [AST_HTTP_POST] = ast_ari_unpause_recording_cb,
711         },
712         .num_children = 0,
713         .children = {  }
714 };
715 /*! \brief REST handler for /api-docs/recordings.{format} */
716 static struct stasis_rest_handlers recordings_live_recordingName_mute = {
717         .path_segment = "mute",
718         .callbacks = {
719                 [AST_HTTP_POST] = ast_ari_mute_recording_cb,
720         },
721         .num_children = 0,
722         .children = {  }
723 };
724 /*! \brief REST handler for /api-docs/recordings.{format} */
725 static struct stasis_rest_handlers recordings_live_recordingName_unmute = {
726         .path_segment = "unmute",
727         .callbacks = {
728                 [AST_HTTP_POST] = ast_ari_unmute_recording_cb,
729         },
730         .num_children = 0,
731         .children = {  }
732 };
733 /*! \brief REST handler for /api-docs/recordings.{format} */
734 static struct stasis_rest_handlers recordings_live_recordingName = {
735         .path_segment = "recordingName",
736         .is_wildcard = 1,
737         .callbacks = {
738                 [AST_HTTP_GET] = ast_ari_get_live_recording_cb,
739                 [AST_HTTP_DELETE] = ast_ari_cancel_recording_cb,
740         },
741         .num_children = 5,
742         .children = { &recordings_live_recordingName_stop,&recordings_live_recordingName_pause,&recordings_live_recordingName_unpause,&recordings_live_recordingName_mute,&recordings_live_recordingName_unmute, }
743 };
744 /*! \brief REST handler for /api-docs/recordings.{format} */
745 static struct stasis_rest_handlers recordings_live = {
746         .path_segment = "live",
747         .callbacks = {
748                 [AST_HTTP_GET] = ast_ari_get_live_recordings_cb,
749         },
750         .num_children = 1,
751         .children = { &recordings_live_recordingName, }
752 };
753 /*! \brief REST handler for /api-docs/recordings.{format} */
754 static struct stasis_rest_handlers recordings = {
755         .path_segment = "recordings",
756         .callbacks = {
757         },
758         .num_children = 2,
759         .children = { &recordings_stored,&recordings_live, }
760 };
761
762 static int load_module(void)
763 {
764         int res = 0;
765         stasis_app_ref();
766         res |= ast_ari_add_handler(&recordings);
767         return res;
768 }
769
770 static int unload_module(void)
771 {
772         ast_ari_remove_handler(&recordings);
773         stasis_app_unref();
774         return 0;
775 }
776
777 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - Recording resources",
778         .load = load_module,
779         .unload = unload_module,
780         .nonoptreq = "res_ari,res_stasis",
781         );