01ad49a653f5dcc4de1b690fe3d7d55da65ff11c
[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                 is_valid = 1;
299                 break;
300         default:
301                 if (200 <= code && code <= 299) {
302                         is_valid = ast_ari_validate_live_recording(
303                                 response->message);
304                 } else {
305                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}\n", code);
306                         is_valid = 0;
307                 }
308         }
309
310         if (!is_valid) {
311                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}\n");
312                 ast_ari_response_error(response, 500,
313                         "Internal Server Error", "Response validation failed");
314         }
315 #endif /* AST_DEVMODE */
316
317 fin: __attribute__((unused))
318         return;
319 }
320 /*!
321  * \brief Parameter parsing callback for /recordings/live/{recordingName}.
322  * \param get_params GET parameters in the HTTP request.
323  * \param path_vars Path variables extracted from the request.
324  * \param headers HTTP headers.
325  * \param[out] response Response to the HTTP request.
326  */
327 static void ast_ari_cancel_recording_cb(
328         struct ast_variable *get_params, struct ast_variable *path_vars,
329         struct ast_variable *headers, struct ast_ari_response *response)
330 {
331         struct ast_cancel_recording_args args = {};
332         struct ast_variable *i;
333 #if defined(AST_DEVMODE)
334         int is_valid;
335         int code;
336 #endif /* AST_DEVMODE */
337
338         for (i = path_vars; i; i = i->next) {
339                 if (strcmp(i->name, "recordingName") == 0) {
340                         args.recording_name = (i->value);
341                 } else
342                 {}
343         }
344         ast_ari_cancel_recording(headers, &args, response);
345 #if defined(AST_DEVMODE)
346         code = response->response_code;
347
348         switch (code) {
349         case 0: /* Implementation is still a stub, or the code wasn't set */
350                 is_valid = response->message == NULL;
351                 break;
352         case 500: /* Internal Server Error */
353         case 501: /* Not Implemented */
354                 is_valid = 1;
355                 break;
356         default:
357                 if (200 <= code && code <= 299) {
358                         is_valid = ast_ari_validate_void(
359                                 response->message);
360                 } else {
361                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}\n", code);
362                         is_valid = 0;
363                 }
364         }
365
366         if (!is_valid) {
367                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}\n");
368                 ast_ari_response_error(response, 500,
369                         "Internal Server Error", "Response validation failed");
370         }
371 #endif /* AST_DEVMODE */
372
373 fin: __attribute__((unused))
374         return;
375 }
376 /*!
377  * \brief Parameter parsing callback for /recordings/live/{recordingName}/stop.
378  * \param get_params GET parameters in the HTTP request.
379  * \param path_vars Path variables extracted from the request.
380  * \param headers HTTP headers.
381  * \param[out] response Response to the HTTP request.
382  */
383 static void ast_ari_stop_recording_cb(
384         struct ast_variable *get_params, struct ast_variable *path_vars,
385         struct ast_variable *headers, struct ast_ari_response *response)
386 {
387         struct ast_stop_recording_args args = {};
388         struct ast_variable *i;
389 #if defined(AST_DEVMODE)
390         int is_valid;
391         int code;
392 #endif /* AST_DEVMODE */
393
394         for (i = path_vars; i; i = i->next) {
395                 if (strcmp(i->name, "recordingName") == 0) {
396                         args.recording_name = (i->value);
397                 } else
398                 {}
399         }
400         ast_ari_stop_recording(headers, &args, response);
401 #if defined(AST_DEVMODE)
402         code = response->response_code;
403
404         switch (code) {
405         case 0: /* Implementation is still a stub, or the code wasn't set */
406                 is_valid = response->message == NULL;
407                 break;
408         case 500: /* Internal Server Error */
409         case 501: /* Not Implemented */
410                 is_valid = 1;
411                 break;
412         default:
413                 if (200 <= code && code <= 299) {
414                         is_valid = ast_ari_validate_void(
415                                 response->message);
416                 } else {
417                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/stop\n", code);
418                         is_valid = 0;
419                 }
420         }
421
422         if (!is_valid) {
423                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/stop\n");
424                 ast_ari_response_error(response, 500,
425                         "Internal Server Error", "Response validation failed");
426         }
427 #endif /* AST_DEVMODE */
428
429 fin: __attribute__((unused))
430         return;
431 }
432 /*!
433  * \brief Parameter parsing callback for /recordings/live/{recordingName}/pause.
434  * \param get_params GET parameters in the HTTP request.
435  * \param path_vars Path variables extracted from the request.
436  * \param headers HTTP headers.
437  * \param[out] response Response to the HTTP request.
438  */
439 static void ast_ari_pause_recording_cb(
440         struct ast_variable *get_params, struct ast_variable *path_vars,
441         struct ast_variable *headers, struct ast_ari_response *response)
442 {
443         struct ast_pause_recording_args args = {};
444         struct ast_variable *i;
445 #if defined(AST_DEVMODE)
446         int is_valid;
447         int code;
448 #endif /* AST_DEVMODE */
449
450         for (i = path_vars; i; i = i->next) {
451                 if (strcmp(i->name, "recordingName") == 0) {
452                         args.recording_name = (i->value);
453                 } else
454                 {}
455         }
456         ast_ari_pause_recording(headers, &args, response);
457 #if defined(AST_DEVMODE)
458         code = response->response_code;
459
460         switch (code) {
461         case 0: /* Implementation is still a stub, or the code wasn't set */
462                 is_valid = response->message == NULL;
463                 break;
464         case 500: /* Internal Server Error */
465         case 501: /* Not Implemented */
466                 is_valid = 1;
467                 break;
468         default:
469                 if (200 <= code && code <= 299) {
470                         is_valid = ast_ari_validate_void(
471                                 response->message);
472                 } else {
473                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/pause\n", code);
474                         is_valid = 0;
475                 }
476         }
477
478         if (!is_valid) {
479                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/pause\n");
480                 ast_ari_response_error(response, 500,
481                         "Internal Server Error", "Response validation failed");
482         }
483 #endif /* AST_DEVMODE */
484
485 fin: __attribute__((unused))
486         return;
487 }
488 /*!
489  * \brief Parameter parsing callback for /recordings/live/{recordingName}/unpause.
490  * \param get_params GET parameters in the HTTP request.
491  * \param path_vars Path variables extracted from the request.
492  * \param headers HTTP headers.
493  * \param[out] response Response to the HTTP request.
494  */
495 static void ast_ari_unpause_recording_cb(
496         struct ast_variable *get_params, struct ast_variable *path_vars,
497         struct ast_variable *headers, struct ast_ari_response *response)
498 {
499         struct ast_unpause_recording_args args = {};
500         struct ast_variable *i;
501 #if defined(AST_DEVMODE)
502         int is_valid;
503         int code;
504 #endif /* AST_DEVMODE */
505
506         for (i = path_vars; i; i = i->next) {
507                 if (strcmp(i->name, "recordingName") == 0) {
508                         args.recording_name = (i->value);
509                 } else
510                 {}
511         }
512         ast_ari_unpause_recording(headers, &args, response);
513 #if defined(AST_DEVMODE)
514         code = response->response_code;
515
516         switch (code) {
517         case 0: /* Implementation is still a stub, or the code wasn't set */
518                 is_valid = response->message == NULL;
519                 break;
520         case 500: /* Internal Server Error */
521         case 501: /* Not Implemented */
522                 is_valid = 1;
523                 break;
524         default:
525                 if (200 <= code && code <= 299) {
526                         is_valid = ast_ari_validate_void(
527                                 response->message);
528                 } else {
529                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/unpause\n", code);
530                         is_valid = 0;
531                 }
532         }
533
534         if (!is_valid) {
535                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/unpause\n");
536                 ast_ari_response_error(response, 500,
537                         "Internal Server Error", "Response validation failed");
538         }
539 #endif /* AST_DEVMODE */
540
541 fin: __attribute__((unused))
542         return;
543 }
544 /*!
545  * \brief Parameter parsing callback for /recordings/live/{recordingName}/mute.
546  * \param get_params GET parameters in the HTTP request.
547  * \param path_vars Path variables extracted from the request.
548  * \param headers HTTP headers.
549  * \param[out] response Response to the HTTP request.
550  */
551 static void ast_ari_mute_recording_cb(
552         struct ast_variable *get_params, struct ast_variable *path_vars,
553         struct ast_variable *headers, struct ast_ari_response *response)
554 {
555         struct ast_mute_recording_args args = {};
556         struct ast_variable *i;
557 #if defined(AST_DEVMODE)
558         int is_valid;
559         int code;
560 #endif /* AST_DEVMODE */
561
562         for (i = path_vars; i; i = i->next) {
563                 if (strcmp(i->name, "recordingName") == 0) {
564                         args.recording_name = (i->value);
565                 } else
566                 {}
567         }
568         ast_ari_mute_recording(headers, &args, response);
569 #if defined(AST_DEVMODE)
570         code = response->response_code;
571
572         switch (code) {
573         case 0: /* Implementation is still a stub, or the code wasn't set */
574                 is_valid = response->message == NULL;
575                 break;
576         case 500: /* Internal Server Error */
577         case 501: /* Not Implemented */
578                 is_valid = 1;
579                 break;
580         default:
581                 if (200 <= code && code <= 299) {
582                         is_valid = ast_ari_validate_void(
583                                 response->message);
584                 } else {
585                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/mute\n", code);
586                         is_valid = 0;
587                 }
588         }
589
590         if (!is_valid) {
591                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/mute\n");
592                 ast_ari_response_error(response, 500,
593                         "Internal Server Error", "Response validation failed");
594         }
595 #endif /* AST_DEVMODE */
596
597 fin: __attribute__((unused))
598         return;
599 }
600 /*!
601  * \brief Parameter parsing callback for /recordings/live/{recordingName}/unmute.
602  * \param get_params GET parameters in the HTTP request.
603  * \param path_vars Path variables extracted from the request.
604  * \param headers HTTP headers.
605  * \param[out] response Response to the HTTP request.
606  */
607 static void ast_ari_unmute_recording_cb(
608         struct ast_variable *get_params, struct ast_variable *path_vars,
609         struct ast_variable *headers, struct ast_ari_response *response)
610 {
611         struct ast_unmute_recording_args args = {};
612         struct ast_variable *i;
613 #if defined(AST_DEVMODE)
614         int is_valid;
615         int code;
616 #endif /* AST_DEVMODE */
617
618         for (i = path_vars; i; i = i->next) {
619                 if (strcmp(i->name, "recordingName") == 0) {
620                         args.recording_name = (i->value);
621                 } else
622                 {}
623         }
624         ast_ari_unmute_recording(headers, &args, response);
625 #if defined(AST_DEVMODE)
626         code = response->response_code;
627
628         switch (code) {
629         case 0: /* Implementation is still a stub, or the code wasn't set */
630                 is_valid = response->message == NULL;
631                 break;
632         case 500: /* Internal Server Error */
633         case 501: /* Not Implemented */
634                 is_valid = 1;
635                 break;
636         default:
637                 if (200 <= code && code <= 299) {
638                         is_valid = ast_ari_validate_void(
639                                 response->message);
640                 } else {
641                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/unmute\n", code);
642                         is_valid = 0;
643                 }
644         }
645
646         if (!is_valid) {
647                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/unmute\n");
648                 ast_ari_response_error(response, 500,
649                         "Internal Server Error", "Response validation failed");
650         }
651 #endif /* AST_DEVMODE */
652
653 fin: __attribute__((unused))
654         return;
655 }
656
657 /*! \brief REST handler for /api-docs/recordings.{format} */
658 static struct stasis_rest_handlers recordings_stored_recordingName = {
659         .path_segment = "recordingName",
660         .is_wildcard = 1,
661         .callbacks = {
662                 [AST_HTTP_GET] = ast_ari_get_stored_recording_cb,
663                 [AST_HTTP_DELETE] = ast_ari_delete_stored_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_stored = {
670         .path_segment = "stored",
671         .callbacks = {
672                 [AST_HTTP_GET] = ast_ari_get_stored_recordings_cb,
673         },
674         .num_children = 1,
675         .children = { &recordings_stored_recordingName, }
676 };
677 /*! \brief REST handler for /api-docs/recordings.{format} */
678 static struct stasis_rest_handlers recordings_live_recordingName_stop = {
679         .path_segment = "stop",
680         .callbacks = {
681                 [AST_HTTP_POST] = ast_ari_stop_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_pause = {
688         .path_segment = "pause",
689         .callbacks = {
690                 [AST_HTTP_POST] = ast_ari_pause_recording_cb,
691         },
692         .num_children = 0,
693         .children = {  }
694 };
695 /*! \brief REST handler for /api-docs/recordings.{format} */
696 static struct stasis_rest_handlers recordings_live_recordingName_unpause = {
697         .path_segment = "unpause",
698         .callbacks = {
699                 [AST_HTTP_POST] = ast_ari_unpause_recording_cb,
700         },
701         .num_children = 0,
702         .children = {  }
703 };
704 /*! \brief REST handler for /api-docs/recordings.{format} */
705 static struct stasis_rest_handlers recordings_live_recordingName_mute = {
706         .path_segment = "mute",
707         .callbacks = {
708                 [AST_HTTP_POST] = ast_ari_mute_recording_cb,
709         },
710         .num_children = 0,
711         .children = {  }
712 };
713 /*! \brief REST handler for /api-docs/recordings.{format} */
714 static struct stasis_rest_handlers recordings_live_recordingName_unmute = {
715         .path_segment = "unmute",
716         .callbacks = {
717                 [AST_HTTP_POST] = ast_ari_unmute_recording_cb,
718         },
719         .num_children = 0,
720         .children = {  }
721 };
722 /*! \brief REST handler for /api-docs/recordings.{format} */
723 static struct stasis_rest_handlers recordings_live_recordingName = {
724         .path_segment = "recordingName",
725         .is_wildcard = 1,
726         .callbacks = {
727                 [AST_HTTP_GET] = ast_ari_get_live_recording_cb,
728                 [AST_HTTP_DELETE] = ast_ari_cancel_recording_cb,
729         },
730         .num_children = 5,
731         .children = { &recordings_live_recordingName_stop,&recordings_live_recordingName_pause,&recordings_live_recordingName_unpause,&recordings_live_recordingName_mute,&recordings_live_recordingName_unmute, }
732 };
733 /*! \brief REST handler for /api-docs/recordings.{format} */
734 static struct stasis_rest_handlers recordings_live = {
735         .path_segment = "live",
736         .callbacks = {
737                 [AST_HTTP_GET] = ast_ari_get_live_recordings_cb,
738         },
739         .num_children = 1,
740         .children = { &recordings_live_recordingName, }
741 };
742 /*! \brief REST handler for /api-docs/recordings.{format} */
743 static struct stasis_rest_handlers recordings = {
744         .path_segment = "recordings",
745         .callbacks = {
746         },
747         .num_children = 2,
748         .children = { &recordings_stored,&recordings_live, }
749 };
750
751 static int load_module(void)
752 {
753         int res = 0;
754         stasis_app_ref();
755         res |= ast_ari_add_handler(&recordings);
756         return res;
757 }
758
759 static int unload_module(void)
760 {
761         ast_ari_remove_handler(&recordings);
762         stasis_app_unref();
763         return 0;
764 }
765
766 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - Recording resources",
767         .load = load_module,
768         .unload = unload_module,
769         .nonoptreq = "res_ari,res_stasis",
770         );