ARI: Implement channel dial.
[asterisk/asterisk.git] / res / res_stasis_http_channels.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_stasis_http_resource.c.mustache
25  */
26
27 /*! \file
28  *
29  * \brief Channel resources
30  *
31  * \author David M. Lee, II <dlee@digium.com>
32  */
33
34 /*** MODULEINFO
35         <depend type="module">res_stasis_http</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 "stasis_http/resource_channels.h"
47
48 /*!
49  * \brief Parameter parsing callback for /channels.
50  * \param get_params GET parameters in the HTTP request.
51  * \param path_vars Path variables extracted from the request.
52  * \param headers HTTP headers.
53  * \param[out] response Response to the HTTP request.
54  */
55 static void stasis_http_get_channels_cb(
56     struct ast_variable *get_params, struct ast_variable *path_vars,
57     struct ast_variable *headers, struct stasis_http_response *response)
58 {
59         struct ast_get_channels_args args = {};
60         stasis_http_get_channels(headers, &args, response);
61 }
62 /*!
63  * \brief Parameter parsing callback for /channels.
64  * \param get_params GET parameters in the HTTP request.
65  * \param path_vars Path variables extracted from the request.
66  * \param headers HTTP headers.
67  * \param[out] response Response to the HTTP request.
68  */
69 static void stasis_http_originate_cb(
70     struct ast_variable *get_params, struct ast_variable *path_vars,
71     struct ast_variable *headers, struct stasis_http_response *response)
72 {
73         struct ast_originate_args args = {};
74         struct ast_variable *i;
75
76         for (i = get_params; i; i = i->next) {
77                 if (strcmp(i->name, "endpoint") == 0) {
78                         args.endpoint = (i->value);
79                 } else
80                 if (strcmp(i->name, "extension") == 0) {
81                         args.extension = (i->value);
82                 } else
83                 if (strcmp(i->name, "context") == 0) {
84                         args.context = (i->value);
85                 } else
86                 if (strcmp(i->name, "priority") == 0) {
87                         args.priority = atol(i->value);
88                 } else
89                 if (strcmp(i->name, "app") == 0) {
90                         args.app = (i->value);
91                 } else
92                 if (strcmp(i->name, "appArgs") == 0) {
93                         args.app_args = (i->value);
94                 } else
95                 if (strcmp(i->name, "callerId") == 0) {
96                         args.caller_id = (i->value);
97                 } else
98                 if (strcmp(i->name, "timeout") == 0) {
99                         args.timeout = atoi(i->value);
100                 } else
101                 {}
102         }
103         stasis_http_originate(headers, &args, response);
104 }
105 /*!
106  * \brief Parameter parsing callback for /channels/{channelId}.
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 stasis_http_get_channel_cb(
113     struct ast_variable *get_params, struct ast_variable *path_vars,
114     struct ast_variable *headers, struct stasis_http_response *response)
115 {
116         struct ast_get_channel_args args = {};
117         struct ast_variable *i;
118
119         for (i = path_vars; i; i = i->next) {
120                 if (strcmp(i->name, "channelId") == 0) {
121                         args.channel_id = (i->value);
122                 } else
123                 {}
124         }
125         stasis_http_get_channel(headers, &args, response);
126 }
127 /*!
128  * \brief Parameter parsing callback for /channels/{channelId}.
129  * \param get_params GET parameters in the HTTP request.
130  * \param path_vars Path variables extracted from the request.
131  * \param headers HTTP headers.
132  * \param[out] response Response to the HTTP request.
133  */
134 static void stasis_http_delete_channel_cb(
135     struct ast_variable *get_params, struct ast_variable *path_vars,
136     struct ast_variable *headers, struct stasis_http_response *response)
137 {
138         struct ast_delete_channel_args args = {};
139         struct ast_variable *i;
140
141         for (i = path_vars; i; i = i->next) {
142                 if (strcmp(i->name, "channelId") == 0) {
143                         args.channel_id = (i->value);
144                 } else
145                 {}
146         }
147         stasis_http_delete_channel(headers, &args, response);
148 }
149 /*!
150  * \brief Parameter parsing callback for /channels/{channelId}/dial.
151  * \param get_params GET parameters in the HTTP request.
152  * \param path_vars Path variables extracted from the request.
153  * \param headers HTTP headers.
154  * \param[out] response Response to the HTTP request.
155  */
156 static void stasis_http_dial_cb(
157     struct ast_variable *get_params, struct ast_variable *path_vars,
158     struct ast_variable *headers, struct stasis_http_response *response)
159 {
160         struct ast_dial_args args = {};
161         struct ast_variable *i;
162
163         for (i = get_params; i; i = i->next) {
164                 if (strcmp(i->name, "endpoint") == 0) {
165                         args.endpoint = (i->value);
166                 } else
167                 if (strcmp(i->name, "extension") == 0) {
168                         args.extension = (i->value);
169                 } else
170                 if (strcmp(i->name, "context") == 0) {
171                         args.context = (i->value);
172                 } else
173                 if (strcmp(i->name, "timeout") == 0) {
174                         args.timeout = atoi(i->value);
175                 } else
176                 {}
177         }
178         for (i = path_vars; i; i = i->next) {
179                 if (strcmp(i->name, "channelId") == 0) {
180                         args.channel_id = (i->value);
181                 } else
182                 {}
183         }
184         stasis_http_dial(headers, &args, response);
185 }
186 /*!
187  * \brief Parameter parsing callback for /channels/{channelId}/continue.
188  * \param get_params GET parameters in the HTTP request.
189  * \param path_vars Path variables extracted from the request.
190  * \param headers HTTP headers.
191  * \param[out] response Response to the HTTP request.
192  */
193 static void stasis_http_continue_in_dialplan_cb(
194     struct ast_variable *get_params, struct ast_variable *path_vars,
195     struct ast_variable *headers, struct stasis_http_response *response)
196 {
197         struct ast_continue_in_dialplan_args args = {};
198         struct ast_variable *i;
199
200         for (i = get_params; i; i = i->next) {
201                 if (strcmp(i->name, "context") == 0) {
202                         args.context = (i->value);
203                 } else
204                 if (strcmp(i->name, "extension") == 0) {
205                         args.extension = (i->value);
206                 } else
207                 if (strcmp(i->name, "priority") == 0) {
208                         args.priority = atoi(i->value);
209                 } else
210                 {}
211         }
212         for (i = path_vars; i; i = i->next) {
213                 if (strcmp(i->name, "channelId") == 0) {
214                         args.channel_id = (i->value);
215                 } else
216                 {}
217         }
218         stasis_http_continue_in_dialplan(headers, &args, response);
219 }
220 /*!
221  * \brief Parameter parsing callback for /channels/{channelId}/answer.
222  * \param get_params GET parameters in the HTTP request.
223  * \param path_vars Path variables extracted from the request.
224  * \param headers HTTP headers.
225  * \param[out] response Response to the HTTP request.
226  */
227 static void stasis_http_answer_channel_cb(
228     struct ast_variable *get_params, struct ast_variable *path_vars,
229     struct ast_variable *headers, struct stasis_http_response *response)
230 {
231         struct ast_answer_channel_args args = {};
232         struct ast_variable *i;
233
234         for (i = path_vars; i; i = i->next) {
235                 if (strcmp(i->name, "channelId") == 0) {
236                         args.channel_id = (i->value);
237                 } else
238                 {}
239         }
240         stasis_http_answer_channel(headers, &args, response);
241 }
242 /*!
243  * \brief Parameter parsing callback for /channels/{channelId}/mute.
244  * \param get_params GET parameters in the HTTP request.
245  * \param path_vars Path variables extracted from the request.
246  * \param headers HTTP headers.
247  * \param[out] response Response to the HTTP request.
248  */
249 static void stasis_http_mute_channel_cb(
250     struct ast_variable *get_params, struct ast_variable *path_vars,
251     struct ast_variable *headers, struct stasis_http_response *response)
252 {
253         struct ast_mute_channel_args args = {};
254         struct ast_variable *i;
255
256         for (i = get_params; i; i = i->next) {
257                 if (strcmp(i->name, "direction") == 0) {
258                         args.direction = (i->value);
259                 } else
260                 {}
261         }
262         for (i = path_vars; i; i = i->next) {
263                 if (strcmp(i->name, "channelId") == 0) {
264                         args.channel_id = (i->value);
265                 } else
266                 {}
267         }
268         stasis_http_mute_channel(headers, &args, response);
269 }
270 /*!
271  * \brief Parameter parsing callback for /channels/{channelId}/unmute.
272  * \param get_params GET parameters in the HTTP request.
273  * \param path_vars Path variables extracted from the request.
274  * \param headers HTTP headers.
275  * \param[out] response Response to the HTTP request.
276  */
277 static void stasis_http_unmute_channel_cb(
278     struct ast_variable *get_params, struct ast_variable *path_vars,
279     struct ast_variable *headers, struct stasis_http_response *response)
280 {
281         struct ast_unmute_channel_args args = {};
282         struct ast_variable *i;
283
284         for (i = get_params; i; i = i->next) {
285                 if (strcmp(i->name, "direction") == 0) {
286                         args.direction = (i->value);
287                 } else
288                 {}
289         }
290         for (i = path_vars; i; i = i->next) {
291                 if (strcmp(i->name, "channelId") == 0) {
292                         args.channel_id = (i->value);
293                 } else
294                 {}
295         }
296         stasis_http_unmute_channel(headers, &args, response);
297 }
298 /*!
299  * \brief Parameter parsing callback for /channels/{channelId}/hold.
300  * \param get_params GET parameters in the HTTP request.
301  * \param path_vars Path variables extracted from the request.
302  * \param headers HTTP headers.
303  * \param[out] response Response to the HTTP request.
304  */
305 static void stasis_http_hold_channel_cb(
306     struct ast_variable *get_params, struct ast_variable *path_vars,
307     struct ast_variable *headers, struct stasis_http_response *response)
308 {
309         struct ast_hold_channel_args args = {};
310         struct ast_variable *i;
311
312         for (i = path_vars; i; i = i->next) {
313                 if (strcmp(i->name, "channelId") == 0) {
314                         args.channel_id = (i->value);
315                 } else
316                 {}
317         }
318         stasis_http_hold_channel(headers, &args, response);
319 }
320 /*!
321  * \brief Parameter parsing callback for /channels/{channelId}/unhold.
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 stasis_http_unhold_channel_cb(
328     struct ast_variable *get_params, struct ast_variable *path_vars,
329     struct ast_variable *headers, struct stasis_http_response *response)
330 {
331         struct ast_unhold_channel_args args = {};
332         struct ast_variable *i;
333
334         for (i = path_vars; i; i = i->next) {
335                 if (strcmp(i->name, "channelId") == 0) {
336                         args.channel_id = (i->value);
337                 } else
338                 {}
339         }
340         stasis_http_unhold_channel(headers, &args, response);
341 }
342 /*!
343  * \brief Parameter parsing callback for /channels/{channelId}/play.
344  * \param get_params GET parameters in the HTTP request.
345  * \param path_vars Path variables extracted from the request.
346  * \param headers HTTP headers.
347  * \param[out] response Response to the HTTP request.
348  */
349 static void stasis_http_play_on_channel_cb(
350     struct ast_variable *get_params, struct ast_variable *path_vars,
351     struct ast_variable *headers, struct stasis_http_response *response)
352 {
353         struct ast_play_on_channel_args args = {};
354         struct ast_variable *i;
355
356         for (i = get_params; i; i = i->next) {
357                 if (strcmp(i->name, "media") == 0) {
358                         args.media = (i->value);
359                 } else
360                 if (strcmp(i->name, "lang") == 0) {
361                         args.lang = (i->value);
362                 } else
363                 if (strcmp(i->name, "offsetms") == 0) {
364                         args.offsetms = atoi(i->value);
365                 } else
366                 if (strcmp(i->name, "skipms") == 0) {
367                         args.skipms = atoi(i->value);
368                 } else
369                 {}
370         }
371         for (i = path_vars; i; i = i->next) {
372                 if (strcmp(i->name, "channelId") == 0) {
373                         args.channel_id = (i->value);
374                 } else
375                 {}
376         }
377         stasis_http_play_on_channel(headers, &args, response);
378 }
379 /*!
380  * \brief Parameter parsing callback for /channels/{channelId}/record.
381  * \param get_params GET parameters in the HTTP request.
382  * \param path_vars Path variables extracted from the request.
383  * \param headers HTTP headers.
384  * \param[out] response Response to the HTTP request.
385  */
386 static void stasis_http_record_channel_cb(
387     struct ast_variable *get_params, struct ast_variable *path_vars,
388     struct ast_variable *headers, struct stasis_http_response *response)
389 {
390         struct ast_record_channel_args args = {};
391         struct ast_variable *i;
392
393         for (i = get_params; i; i = i->next) {
394                 if (strcmp(i->name, "name") == 0) {
395                         args.name = (i->value);
396                 } else
397                 if (strcmp(i->name, "format") == 0) {
398                         args.format = (i->value);
399                 } else
400                 if (strcmp(i->name, "maxDurationSeconds") == 0) {
401                         args.max_duration_seconds = atoi(i->value);
402                 } else
403                 if (strcmp(i->name, "maxSilenceSeconds") == 0) {
404                         args.max_silence_seconds = atoi(i->value);
405                 } else
406                 if (strcmp(i->name, "append") == 0) {
407                         args.append = atoi(i->value);
408                 } else
409                 if (strcmp(i->name, "beep") == 0) {
410                         args.beep = atoi(i->value);
411                 } else
412                 if (strcmp(i->name, "terminateOn") == 0) {
413                         args.terminate_on = (i->value);
414                 } else
415                 {}
416         }
417         for (i = path_vars; i; i = i->next) {
418                 if (strcmp(i->name, "channelId") == 0) {
419                         args.channel_id = (i->value);
420                 } else
421                 {}
422         }
423         stasis_http_record_channel(headers, &args, response);
424 }
425
426 /*! \brief REST handler for /api-docs/channels.{format} */
427 static struct stasis_rest_handlers channels_channelId_dial = {
428         .path_segment = "dial",
429         .callbacks = {
430                 [AST_HTTP_POST] = stasis_http_dial_cb,
431         },
432         .num_children = 0,
433         .children = {  }
434 };
435 /*! \brief REST handler for /api-docs/channels.{format} */
436 static struct stasis_rest_handlers channels_channelId_continue = {
437         .path_segment = "continue",
438         .callbacks = {
439                 [AST_HTTP_POST] = stasis_http_continue_in_dialplan_cb,
440         },
441         .num_children = 0,
442         .children = {  }
443 };
444 /*! \brief REST handler for /api-docs/channels.{format} */
445 static struct stasis_rest_handlers channels_channelId_answer = {
446         .path_segment = "answer",
447         .callbacks = {
448                 [AST_HTTP_POST] = stasis_http_answer_channel_cb,
449         },
450         .num_children = 0,
451         .children = {  }
452 };
453 /*! \brief REST handler for /api-docs/channels.{format} */
454 static struct stasis_rest_handlers channels_channelId_mute = {
455         .path_segment = "mute",
456         .callbacks = {
457                 [AST_HTTP_POST] = stasis_http_mute_channel_cb,
458         },
459         .num_children = 0,
460         .children = {  }
461 };
462 /*! \brief REST handler for /api-docs/channels.{format} */
463 static struct stasis_rest_handlers channels_channelId_unmute = {
464         .path_segment = "unmute",
465         .callbacks = {
466                 [AST_HTTP_POST] = stasis_http_unmute_channel_cb,
467         },
468         .num_children = 0,
469         .children = {  }
470 };
471 /*! \brief REST handler for /api-docs/channels.{format} */
472 static struct stasis_rest_handlers channels_channelId_hold = {
473         .path_segment = "hold",
474         .callbacks = {
475                 [AST_HTTP_POST] = stasis_http_hold_channel_cb,
476         },
477         .num_children = 0,
478         .children = {  }
479 };
480 /*! \brief REST handler for /api-docs/channels.{format} */
481 static struct stasis_rest_handlers channels_channelId_unhold = {
482         .path_segment = "unhold",
483         .callbacks = {
484                 [AST_HTTP_POST] = stasis_http_unhold_channel_cb,
485         },
486         .num_children = 0,
487         .children = {  }
488 };
489 /*! \brief REST handler for /api-docs/channels.{format} */
490 static struct stasis_rest_handlers channels_channelId_play = {
491         .path_segment = "play",
492         .callbacks = {
493                 [AST_HTTP_POST] = stasis_http_play_on_channel_cb,
494         },
495         .num_children = 0,
496         .children = {  }
497 };
498 /*! \brief REST handler for /api-docs/channels.{format} */
499 static struct stasis_rest_handlers channels_channelId_record = {
500         .path_segment = "record",
501         .callbacks = {
502                 [AST_HTTP_POST] = stasis_http_record_channel_cb,
503         },
504         .num_children = 0,
505         .children = {  }
506 };
507 /*! \brief REST handler for /api-docs/channels.{format} */
508 static struct stasis_rest_handlers channels_channelId = {
509         .path_segment = "channelId",
510         .is_wildcard = 1,
511         .callbacks = {
512                 [AST_HTTP_GET] = stasis_http_get_channel_cb,
513                 [AST_HTTP_DELETE] = stasis_http_delete_channel_cb,
514         },
515         .num_children = 9,
516         .children = { &channels_channelId_dial,&channels_channelId_continue,&channels_channelId_answer,&channels_channelId_mute,&channels_channelId_unmute,&channels_channelId_hold,&channels_channelId_unhold,&channels_channelId_play,&channels_channelId_record, }
517 };
518 /*! \brief REST handler for /api-docs/channels.{format} */
519 static struct stasis_rest_handlers channels = {
520         .path_segment = "channels",
521         .callbacks = {
522                 [AST_HTTP_GET] = stasis_http_get_channels_cb,
523                 [AST_HTTP_POST] = stasis_http_originate_cb,
524         },
525         .num_children = 1,
526         .children = { &channels_channelId, }
527 };
528
529 static int load_module(void)
530 {
531         stasis_app_ref();
532         return stasis_http_add_handler(&channels);
533 }
534
535 static int unload_module(void)
536 {
537         stasis_http_remove_handler(&channels);
538         stasis_app_unref();
539         return 0;
540 }
541
542 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - Channel resources",
543         .load = load_module,
544         .unload = unload_module,
545         .nonoptreq = "res_stasis_http,res_stasis",
546         );