github.com/mmatczuk/gohan@v0.0.0-20170206152520-30e45d9bdb69/extension/gohanscript/autogen/lib_http.go (about)

     1  package autogen
     2  
     3  // AUTO GENERATED CODE DO NOT MODIFY MANUALLY
     4  import (
     5  	"github.com/cloudwan/gohan/extension/gohanscript"
     6  	"github.com/cloudwan/gohan/extension/gohanscript/lib"
     7  )
     8  
     9  func init() {
    10  
    11  	gohanscript.RegisterStmtParser("http_get",
    12  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
    13  			return func(context *gohanscript.Context) (interface{}, error) {
    14  
    15  				var url string
    16  				iurl := stmt.Arg("url", context)
    17  				if iurl != nil {
    18  					url = iurl.(string)
    19  				}
    20  				var headers map[string]interface{}
    21  				iheaders := stmt.Arg("headers", context)
    22  				if iheaders != nil {
    23  					headers = iheaders.(map[string]interface{})
    24  				}
    25  
    26  				result1,
    27  					err :=
    28  					lib.HTTPGet(
    29  						url, headers)
    30  
    31  				return result1, err
    32  
    33  			}, nil
    34  		})
    35  	gohanscript.RegisterMiniGoFunc("HTTPGet",
    36  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
    37  
    38  			url, _ := args[0].(string)
    39  			headers, _ := args[0].(map[string]interface{})
    40  
    41  			result1,
    42  				err :=
    43  				lib.HTTPGet(
    44  					url, headers)
    45  			return []interface{}{
    46  				result1,
    47  				err}
    48  
    49  		})
    50  
    51  	gohanscript.RegisterStmtParser("http_post",
    52  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
    53  			return func(context *gohanscript.Context) (interface{}, error) {
    54  
    55  				var url string
    56  				iurl := stmt.Arg("url", context)
    57  				if iurl != nil {
    58  					url = iurl.(string)
    59  				}
    60  				var headers map[string]interface{}
    61  				iheaders := stmt.Arg("headers", context)
    62  				if iheaders != nil {
    63  					headers = iheaders.(map[string]interface{})
    64  				}
    65  				var postData map[string]interface{}
    66  				ipostData := stmt.Arg("post_data", context)
    67  				if ipostData != nil {
    68  					postData = ipostData.(map[string]interface{})
    69  				}
    70  
    71  				result1,
    72  					err :=
    73  					lib.HTTPPost(
    74  						url, headers, postData)
    75  
    76  				return result1, err
    77  
    78  			}, nil
    79  		})
    80  	gohanscript.RegisterMiniGoFunc("HTTPPost",
    81  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
    82  
    83  			url, _ := args[0].(string)
    84  			headers, _ := args[0].(map[string]interface{})
    85  			postData, _ := args[0].(map[string]interface{})
    86  
    87  			result1,
    88  				err :=
    89  				lib.HTTPPost(
    90  					url, headers, postData)
    91  			return []interface{}{
    92  				result1,
    93  				err}
    94  
    95  		})
    96  
    97  	gohanscript.RegisterStmtParser("http_put",
    98  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
    99  			return func(context *gohanscript.Context) (interface{}, error) {
   100  
   101  				var url string
   102  				iurl := stmt.Arg("url", context)
   103  				if iurl != nil {
   104  					url = iurl.(string)
   105  				}
   106  				var headers map[string]interface{}
   107  				iheaders := stmt.Arg("headers", context)
   108  				if iheaders != nil {
   109  					headers = iheaders.(map[string]interface{})
   110  				}
   111  				var postData map[string]interface{}
   112  				ipostData := stmt.Arg("post_data", context)
   113  				if ipostData != nil {
   114  					postData = ipostData.(map[string]interface{})
   115  				}
   116  
   117  				result1,
   118  					err :=
   119  					lib.HTTPPut(
   120  						url, headers, postData)
   121  
   122  				return result1, err
   123  
   124  			}, nil
   125  		})
   126  	gohanscript.RegisterMiniGoFunc("HTTPPut",
   127  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   128  
   129  			url, _ := args[0].(string)
   130  			headers, _ := args[0].(map[string]interface{})
   131  			postData, _ := args[0].(map[string]interface{})
   132  
   133  			result1,
   134  				err :=
   135  				lib.HTTPPut(
   136  					url, headers, postData)
   137  			return []interface{}{
   138  				result1,
   139  				err}
   140  
   141  		})
   142  
   143  	gohanscript.RegisterStmtParser("http_patch",
   144  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   145  			return func(context *gohanscript.Context) (interface{}, error) {
   146  
   147  				var url string
   148  				iurl := stmt.Arg("url", context)
   149  				if iurl != nil {
   150  					url = iurl.(string)
   151  				}
   152  				var headers map[string]interface{}
   153  				iheaders := stmt.Arg("headers", context)
   154  				if iheaders != nil {
   155  					headers = iheaders.(map[string]interface{})
   156  				}
   157  				var postData map[string]interface{}
   158  				ipostData := stmt.Arg("post_data", context)
   159  				if ipostData != nil {
   160  					postData = ipostData.(map[string]interface{})
   161  				}
   162  
   163  				result1,
   164  					err :=
   165  					lib.HTTPPatch(
   166  						url, headers, postData)
   167  
   168  				return result1, err
   169  
   170  			}, nil
   171  		})
   172  	gohanscript.RegisterMiniGoFunc("HTTPPatch",
   173  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   174  
   175  			url, _ := args[0].(string)
   176  			headers, _ := args[0].(map[string]interface{})
   177  			postData, _ := args[0].(map[string]interface{})
   178  
   179  			result1,
   180  				err :=
   181  				lib.HTTPPatch(
   182  					url, headers, postData)
   183  			return []interface{}{
   184  				result1,
   185  				err}
   186  
   187  		})
   188  
   189  	gohanscript.RegisterStmtParser("http_delete",
   190  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   191  			return func(context *gohanscript.Context) (interface{}, error) {
   192  
   193  				var url string
   194  				iurl := stmt.Arg("url", context)
   195  				if iurl != nil {
   196  					url = iurl.(string)
   197  				}
   198  				var headers map[string]interface{}
   199  				iheaders := stmt.Arg("headers", context)
   200  				if iheaders != nil {
   201  					headers = iheaders.(map[string]interface{})
   202  				}
   203  
   204  				result1,
   205  					err :=
   206  					lib.HTTPDelete(
   207  						url, headers)
   208  
   209  				return result1, err
   210  
   211  			}, nil
   212  		})
   213  	gohanscript.RegisterMiniGoFunc("HTTPDelete",
   214  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   215  
   216  			url, _ := args[0].(string)
   217  			headers, _ := args[0].(map[string]interface{})
   218  
   219  			result1,
   220  				err :=
   221  				lib.HTTPDelete(
   222  					url, headers)
   223  			return []interface{}{
   224  				result1,
   225  				err}
   226  
   227  		})
   228  
   229  	gohanscript.RegisterStmtParser("http_request",
   230  		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
   231  			return func(context *gohanscript.Context) (interface{}, error) {
   232  
   233  				var url string
   234  				iurl := stmt.Arg("url", context)
   235  				if iurl != nil {
   236  					url = iurl.(string)
   237  				}
   238  				var method string
   239  				imethod := stmt.Arg("method", context)
   240  				if imethod != nil {
   241  					method = imethod.(string)
   242  				}
   243  				var headers map[string]interface{}
   244  				iheaders := stmt.Arg("headers", context)
   245  				if iheaders != nil {
   246  					headers = iheaders.(map[string]interface{})
   247  				}
   248  				var postData map[string]interface{}
   249  				ipostData := stmt.Arg("post_data", context)
   250  				if ipostData != nil {
   251  					postData = ipostData.(map[string]interface{})
   252  				}
   253  
   254  				result1,
   255  					err :=
   256  					lib.HTTPRequest(
   257  						url, method, headers, postData)
   258  
   259  				return result1, err
   260  
   261  			}, nil
   262  		})
   263  	gohanscript.RegisterMiniGoFunc("HTTPRequest",
   264  		func(vm *gohanscript.VM, args []interface{}) []interface{} {
   265  
   266  			url, _ := args[0].(string)
   267  			method, _ := args[0].(string)
   268  			headers, _ := args[0].(map[string]interface{})
   269  			postData, _ := args[0].(map[string]interface{})
   270  
   271  			result1,
   272  				err :=
   273  				lib.HTTPRequest(
   274  					url, method, headers, postData)
   275  			return []interface{}{
   276  				result1,
   277  				err}
   278  
   279  		})
   280  
   281  }