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