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