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