This patch implements the REST API's for POST /channels/{channelId}/play
[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                 {}
87         }
88         stasis_http_originate(headers, &args, response);
89 }
90 /*!
91  * \brief Parameter parsing callback for /channels/{channelId}.
92  * \param get_params GET parameters in the HTTP request.
93  * \param path_vars Path variables extracted from the request.
94  * \param headers HTTP headers.
95  * \param[out] response Response to the HTTP request.
96  */
97 static void stasis_http_get_channel_cb(
98     struct ast_variable *get_params, struct ast_variable *path_vars,
99     struct ast_variable *headers, struct stasis_http_response *response)
100 {
101         struct ast_get_channel_args args = {};
102         struct ast_variable *i;
103
104         for (i = path_vars; i; i = i->next) {
105                 if (strcmp(i->name, "channelId") == 0) {
106                         args.channel_id = (i->value);
107                 } else
108                 {}
109         }
110         stasis_http_get_channel(headers, &args, response);
111 }
112 /*!
113  * \brief Parameter parsing callback for /channels/{channelId}.
114  * \param get_params GET parameters in the HTTP request.
115  * \param path_vars Path variables extracted from the request.
116  * \param headers HTTP headers.
117  * \param[out] response Response to the HTTP request.
118  */
119 static void stasis_http_delete_channel_cb(
120     struct ast_variable *get_params, struct ast_variable *path_vars,
121     struct ast_variable *headers, struct stasis_http_response *response)
122 {
123         struct ast_delete_channel_args args = {};
124         struct ast_variable *i;
125
126         for (i = path_vars; i; i = i->next) {
127                 if (strcmp(i->name, "channelId") == 0) {
128                         args.channel_id = (i->value);
129                 } else
130                 {}
131         }
132         stasis_http_delete_channel(headers, &args, response);
133 }
134 /*!
135  * \brief Parameter parsing callback for /channels/{channelId}/dial.
136  * \param get_params GET parameters in the HTTP request.
137  * \param path_vars Path variables extracted from the request.
138  * \param headers HTTP headers.
139  * \param[out] response Response to the HTTP request.
140  */
141 static void stasis_http_dial_cb(
142     struct ast_variable *get_params, struct ast_variable *path_vars,
143     struct ast_variable *headers, struct stasis_http_response *response)
144 {
145         struct ast_dial_args args = {};
146         struct ast_variable *i;
147
148         for (i = get_params; i; i = i->next) {
149                 if (strcmp(i->name, "endpoint") == 0) {
150                         args.endpoint = (i->value);
151                 } else
152                 if (strcmp(i->name, "extension") == 0) {
153                         args.extension = (i->value);
154                 } else
155                 if (strcmp(i->name, "context") == 0) {
156                         args.context = (i->value);
157                 } else
158                 {}
159         }
160         for (i = path_vars; i; i = i->next) {
161                 if (strcmp(i->name, "channelId") == 0) {
162                         args.channel_id = (i->value);
163                 } else
164                 {}
165         }
166         stasis_http_dial(headers, &args, response);
167 }
168 /*!
169  * \brief Parameter parsing callback for /channels/{channelId}/continue.
170  * \param get_params GET parameters in the HTTP request.
171  * \param path_vars Path variables extracted from the request.
172  * \param headers HTTP headers.
173  * \param[out] response Response to the HTTP request.
174  */
175 static void stasis_http_continue_in_dialplan_cb(
176     struct ast_variable *get_params, struct ast_variable *path_vars,
177     struct ast_variable *headers, struct stasis_http_response *response)
178 {
179         struct ast_continue_in_dialplan_args args = {};
180         struct ast_variable *i;
181
182         for (i = path_vars; i; i = i->next) {
183                 if (strcmp(i->name, "channelId") == 0) {
184                         args.channel_id = (i->value);
185                 } else
186                 {}
187         }
188         stasis_http_continue_in_dialplan(headers, &args, response);
189 }
190 /*!
191  * \brief Parameter parsing callback for /channels/{channelId}/answer.
192  * \param get_params GET parameters in the HTTP request.
193  * \param path_vars Path variables extracted from the request.
194  * \param headers HTTP headers.
195  * \param[out] response Response to the HTTP request.
196  */
197 static void stasis_http_answer_channel_cb(
198     struct ast_variable *get_params, struct ast_variable *path_vars,
199     struct ast_variable *headers, struct stasis_http_response *response)
200 {
201         struct ast_answer_channel_args args = {};
202         struct ast_variable *i;
203
204         for (i = path_vars; i; i = i->next) {
205                 if (strcmp(i->name, "channelId") == 0) {
206                         args.channel_id = (i->value);
207                 } else
208                 {}
209         }
210         stasis_http_answer_channel(headers, &args, response);
211 }
212 /*!
213  * \brief Parameter parsing callback for /channels/{channelId}/mute.
214  * \param get_params GET parameters in the HTTP request.
215  * \param path_vars Path variables extracted from the request.
216  * \param headers HTTP headers.
217  * \param[out] response Response to the HTTP request.
218  */
219 static void stasis_http_mute_channel_cb(
220     struct ast_variable *get_params, struct ast_variable *path_vars,
221     struct ast_variable *headers, struct stasis_http_response *response)
222 {
223         struct ast_mute_channel_args args = {};
224         struct ast_variable *i;
225
226         for (i = get_params; i; i = i->next) {
227                 if (strcmp(i->name, "direction") == 0) {
228                         args.direction = (i->value);
229                 } else
230                 {}
231         }
232         for (i = path_vars; i; i = i->next) {
233                 if (strcmp(i->name, "channelId") == 0) {
234                         args.channel_id = (i->value);
235                 } else
236                 {}
237         }
238         stasis_http_mute_channel(headers, &args, response);
239 }
240 /*!
241  * \brief Parameter parsing callback for /channels/{channelId}/unmute.
242  * \param get_params GET parameters in the HTTP request.
243  * \param path_vars Path variables extracted from the request.
244  * \param headers HTTP headers.
245  * \param[out] response Response to the HTTP request.
246  */
247 static void stasis_http_unmute_channel_cb(
248     struct ast_variable *get_params, struct ast_variable *path_vars,
249     struct ast_variable *headers, struct stasis_http_response *response)
250 {
251         struct ast_unmute_channel_args args = {};
252         struct ast_variable *i;
253
254         for (i = get_params; i; i = i->next) {
255                 if (strcmp(i->name, "direction") == 0) {
256                         args.direction = (i->value);
257                 } else
258                 {}
259         }
260         for (i = path_vars; i; i = i->next) {
261                 if (strcmp(i->name, "channelId") == 0) {
262                         args.channel_id = (i->value);
263                 } else
264                 {}
265         }
266         stasis_http_unmute_channel(headers, &args, response);
267 }
268 /*!
269  * \brief Parameter parsing callback for /channels/{channelId}/hold.
270  * \param get_params GET parameters in the HTTP request.
271  * \param path_vars Path variables extracted from the request.
272  * \param headers HTTP headers.
273  * \param[out] response Response to the HTTP request.
274  */
275 static void stasis_http_hold_channel_cb(
276     struct ast_variable *get_params, struct ast_variable *path_vars,
277     struct ast_variable *headers, struct stasis_http_response *response)
278 {
279         struct ast_hold_channel_args args = {};
280         struct ast_variable *i;
281
282         for (i = path_vars; i; i = i->next) {
283                 if (strcmp(i->name, "channelId") == 0) {
284                         args.channel_id = (i->value);
285                 } else
286                 {}
287         }
288         stasis_http_hold_channel(headers, &args, response);
289 }
290 /*!
291  * \brief Parameter parsing callback for /channels/{channelId}/unhold.
292  * \param get_params GET parameters in the HTTP request.
293  * \param path_vars Path variables extracted from the request.
294  * \param headers HTTP headers.
295  * \param[out] response Response to the HTTP request.
296  */
297 static void stasis_http_unhold_channel_cb(
298     struct ast_variable *get_params, struct ast_variable *path_vars,
299     struct ast_variable *headers, struct stasis_http_response *response)
300 {
301         struct ast_unhold_channel_args args = {};
302         struct ast_variable *i;
303
304         for (i = path_vars; i; i = i->next) {
305                 if (strcmp(i->name, "channelId") == 0) {
306                         args.channel_id = (i->value);
307                 } else
308                 {}
309         }
310         stasis_http_unhold_channel(headers, &args, response);
311 }
312 /*!
313  * \brief Parameter parsing callback for /channels/{channelId}/play.
314  * \param get_params GET parameters in the HTTP request.
315  * \param path_vars Path variables extracted from the request.
316  * \param headers HTTP headers.
317  * \param[out] response Response to the HTTP request.
318  */
319 static void stasis_http_play_on_channel_cb(
320     struct ast_variable *get_params, struct ast_variable *path_vars,
321     struct ast_variable *headers, struct stasis_http_response *response)
322 {
323         struct ast_play_on_channel_args args = {};
324         struct ast_variable *i;
325
326         for (i = get_params; i; i = i->next) {
327                 if (strcmp(i->name, "media") == 0) {
328                         args.media = (i->value);
329                 } else
330                 if (strcmp(i->name, "lang") == 0) {
331                         args.lang = (i->value);
332                 } else
333                 {}
334         }
335         for (i = path_vars; i; i = i->next) {
336                 if (strcmp(i->name, "channelId") == 0) {
337                         args.channel_id = (i->value);
338                 } else
339                 {}
340         }
341         stasis_http_play_on_channel(headers, &args, response);
342 }
343 /*!
344  * \brief Parameter parsing callback for /channels/{channelId}/record.
345  * \param get_params GET parameters in the HTTP request.
346  * \param path_vars Path variables extracted from the request.
347  * \param headers HTTP headers.
348  * \param[out] response Response to the HTTP request.
349  */
350 static void stasis_http_record_channel_cb(
351     struct ast_variable *get_params, struct ast_variable *path_vars,
352     struct ast_variable *headers, struct stasis_http_response *response)
353 {
354         struct ast_record_channel_args args = {};
355         struct ast_variable *i;
356
357         for (i = get_params; i; i = i->next) {
358                 if (strcmp(i->name, "name") == 0) {
359                         args.name = (i->value);
360                 } else
361                 if (strcmp(i->name, "format") == 0) {
362                         args.format = (i->value);
363                 } else
364                 if (strcmp(i->name, "maxDurationSeconds") == 0) {
365                         args.max_duration_seconds = atoi(i->value);
366                 } else
367                 if (strcmp(i->name, "maxSilenceSeconds") == 0) {
368                         args.max_silence_seconds = atoi(i->value);
369                 } else
370                 if (strcmp(i->name, "append") == 0) {
371                         args.append = atoi(i->value);
372                 } else
373                 if (strcmp(i->name, "beep") == 0) {
374                         args.beep = atoi(i->value);
375                 } else
376                 if (strcmp(i->name, "terminateOn") == 0) {
377                         args.terminate_on = (i->value);
378                 } else
379                 {}
380         }
381         for (i = path_vars; i; i = i->next) {
382                 if (strcmp(i->name, "channelId") == 0) {
383                         args.channel_id = (i->value);
384                 } else
385                 {}
386         }
387         stasis_http_record_channel(headers, &args, response);
388 }
389
390 /*! \brief REST handler for /api-docs/channels.{format} */
391 static struct stasis_rest_handlers channels_channelId_dial = {
392         .path_segment = "dial",
393         .callbacks = {
394                 [AST_HTTP_POST] = stasis_http_dial_cb,
395         },
396         .num_children = 0,
397         .children = {  }
398 };
399 /*! \brief REST handler for /api-docs/channels.{format} */
400 static struct stasis_rest_handlers channels_channelId_continue = {
401         .path_segment = "continue",
402         .callbacks = {
403                 [AST_HTTP_POST] = stasis_http_continue_in_dialplan_cb,
404         },
405         .num_children = 0,
406         .children = {  }
407 };
408 /*! \brief REST handler for /api-docs/channels.{format} */
409 static struct stasis_rest_handlers channels_channelId_answer = {
410         .path_segment = "answer",
411         .callbacks = {
412                 [AST_HTTP_POST] = stasis_http_answer_channel_cb,
413         },
414         .num_children = 0,
415         .children = {  }
416 };
417 /*! \brief REST handler for /api-docs/channels.{format} */
418 static struct stasis_rest_handlers channels_channelId_mute = {
419         .path_segment = "mute",
420         .callbacks = {
421                 [AST_HTTP_POST] = stasis_http_mute_channel_cb,
422         },
423         .num_children = 0,
424         .children = {  }
425 };
426 /*! \brief REST handler for /api-docs/channels.{format} */
427 static struct stasis_rest_handlers channels_channelId_unmute = {
428         .path_segment = "unmute",
429         .callbacks = {
430                 [AST_HTTP_POST] = stasis_http_unmute_channel_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_hold = {
437         .path_segment = "hold",
438         .callbacks = {
439                 [AST_HTTP_POST] = stasis_http_hold_channel_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_unhold = {
446         .path_segment = "unhold",
447         .callbacks = {
448                 [AST_HTTP_POST] = stasis_http_unhold_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_play = {
455         .path_segment = "play",
456         .callbacks = {
457                 [AST_HTTP_POST] = stasis_http_play_on_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_record = {
464         .path_segment = "record",
465         .callbacks = {
466                 [AST_HTTP_POST] = stasis_http_record_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 = {
473         .path_segment = "channelId",
474         .is_wildcard = 1,
475         .callbacks = {
476                 [AST_HTTP_GET] = stasis_http_get_channel_cb,
477                 [AST_HTTP_DELETE] = stasis_http_delete_channel_cb,
478         },
479         .num_children = 9,
480         .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, }
481 };
482 /*! \brief REST handler for /api-docs/channels.{format} */
483 static struct stasis_rest_handlers channels = {
484         .path_segment = "channels",
485         .callbacks = {
486                 [AST_HTTP_GET] = stasis_http_get_channels_cb,
487                 [AST_HTTP_POST] = stasis_http_originate_cb,
488         },
489         .num_children = 1,
490         .children = { &channels_channelId, }
491 };
492
493 static int load_module(void)
494 {
495         stasis_app_ref();
496         return stasis_http_add_handler(&channels);
497 }
498
499 static int unload_module(void)
500 {
501         stasis_http_remove_handler(&channels);
502         stasis_app_unref();
503         return 0;
504 }
505
506 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT,
507         "RESTful API module - Channel resources",
508         .load = load_module,
509         .unload = unload_module,
510         .nonoptreq = "res_stasis_http,res_stasis",
511         );