github.com/mmatczuk/gohan@v0.0.0-20170206152520-30e45d9bdb69/extension/gohanscript/autogen/lib_gohan.go (about) 1 package autogen 2 3 // AUTO GENERATED CODE DO NOT MODIFY MANUALLY 4 import ( 5 "github.com/cloudwan/gohan/db" 6 "github.com/cloudwan/gohan/db/transaction" 7 "github.com/cloudwan/gohan/extension/gohanscript" 8 "github.com/cloudwan/gohan/extension/gohanscript/lib" 9 ) 10 11 func init() { 12 13 gohanscript.RegisterStmtParser("gohan_schema", 14 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 15 return func(context *gohanscript.Context) (interface{}, error) { 16 17 var schemaID string 18 ischemaID := stmt.Arg("schema_id", context) 19 if ischemaID != nil { 20 schemaID = ischemaID.(string) 21 } 22 23 result1, 24 err := 25 lib.GohanSchema( 26 schemaID) 27 28 return result1, err 29 30 }, nil 31 }) 32 gohanscript.RegisterMiniGoFunc("GohanSchema", 33 func(vm *gohanscript.VM, args []interface{}) []interface{} { 34 35 schemaID, _ := args[0].(string) 36 37 result1, 38 err := 39 lib.GohanSchema( 40 schemaID) 41 return []interface{}{ 42 result1, 43 err} 44 45 }) 46 47 gohanscript.RegisterStmtParser("gohan_schemas", 48 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 49 return func(context *gohanscript.Context) (interface{}, error) { 50 51 result1 := 52 lib.GohanSchemas() 53 54 return result1, nil 55 56 }, nil 57 }) 58 gohanscript.RegisterMiniGoFunc("GohanSchemas", 59 func(vm *gohanscript.VM, args []interface{}) []interface{} { 60 61 result1 := 62 lib.GohanSchemas() 63 return []interface{}{ 64 result1} 65 66 }) 67 68 gohanscript.RegisterStmtParser("gohan_policies", 69 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 70 return func(context *gohanscript.Context) (interface{}, error) { 71 72 result1 := 73 lib.GohanPolicies() 74 75 return result1, nil 76 77 }, nil 78 }) 79 gohanscript.RegisterMiniGoFunc("GohanPolicies", 80 func(vm *gohanscript.VM, args []interface{}) []interface{} { 81 82 result1 := 83 lib.GohanPolicies() 84 return []interface{}{ 85 result1} 86 87 }) 88 89 gohanscript.RegisterStmtParser("read_config", 90 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 91 return func(context *gohanscript.Context) (interface{}, error) { 92 93 var path string 94 ipath := stmt.Arg("path", context) 95 if ipath != nil { 96 path = ipath.(string) 97 } 98 99 err := 100 lib.ReadConfig( 101 path) 102 103 return nil, err 104 105 }, nil 106 }) 107 gohanscript.RegisterMiniGoFunc("ReadConfig", 108 func(vm *gohanscript.VM, args []interface{}) []interface{} { 109 110 path, _ := args[0].(string) 111 112 err := 113 lib.ReadConfig( 114 path) 115 return []interface{}{ 116 err} 117 118 }) 119 120 gohanscript.RegisterStmtParser("get_config", 121 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 122 return func(context *gohanscript.Context) (interface{}, error) { 123 124 var key string 125 ikey := stmt.Arg("key", context) 126 if ikey != nil { 127 key = ikey.(string) 128 } 129 var defaultValue interface{} 130 idefaultValue := stmt.Arg("default_value", context) 131 if idefaultValue != nil { 132 defaultValue = idefaultValue.(interface{}) 133 } 134 135 result1 := 136 lib.GetConfig( 137 key, defaultValue) 138 139 return result1, nil 140 141 }, nil 142 }) 143 gohanscript.RegisterMiniGoFunc("GetConfig", 144 func(vm *gohanscript.VM, args []interface{}) []interface{} { 145 146 key, _ := args[0].(string) 147 defaultValue, _ := args[0].(interface{}) 148 149 result1 := 150 lib.GetConfig( 151 key, defaultValue) 152 return []interface{}{ 153 result1} 154 155 }) 156 157 gohanscript.RegisterStmtParser("gohan_load_schema", 158 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 159 return func(context *gohanscript.Context) (interface{}, error) { 160 161 var src string 162 isrc := stmt.Arg("src", context) 163 if isrc != nil { 164 src = isrc.(string) 165 } 166 167 result1, 168 err := 169 lib.GohanLoadSchema( 170 src) 171 172 return result1, err 173 174 }, nil 175 }) 176 gohanscript.RegisterMiniGoFunc("GohanLoadSchema", 177 func(vm *gohanscript.VM, args []interface{}) []interface{} { 178 179 src, _ := args[0].(string) 180 181 result1, 182 err := 183 lib.GohanLoadSchema( 184 src) 185 return []interface{}{ 186 result1, 187 err} 188 189 }) 190 191 gohanscript.RegisterStmtParser("connect_db", 192 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 193 return func(context *gohanscript.Context) (interface{}, error) { 194 195 var dbType string 196 idbType := stmt.Arg("db_type", context) 197 if idbType != nil { 198 dbType = idbType.(string) 199 } 200 var connection string 201 iconnection := stmt.Arg("connection", context) 202 if iconnection != nil { 203 connection = iconnection.(string) 204 } 205 var maxOpenConn int 206 imaxOpenConn := stmt.Arg("max_open_conn", context) 207 if imaxOpenConn != nil { 208 maxOpenConn = imaxOpenConn.(int) 209 } 210 211 result1, 212 err := 213 lib.ConnectDB( 214 dbType, connection, maxOpenConn) 215 216 return result1, err 217 218 }, nil 219 }) 220 gohanscript.RegisterMiniGoFunc("ConnectDB", 221 func(vm *gohanscript.VM, args []interface{}) []interface{} { 222 223 dbType, _ := args[0].(string) 224 connection, _ := args[0].(string) 225 maxOpenConn, _ := args[0].(int) 226 227 result1, 228 err := 229 lib.ConnectDB( 230 dbType, connection, maxOpenConn) 231 return []interface{}{ 232 result1, 233 err} 234 235 }) 236 237 gohanscript.RegisterStmtParser("init_db", 238 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 239 return func(context *gohanscript.Context) (interface{}, error) { 240 241 var dbType string 242 idbType := stmt.Arg("db_type", context) 243 if idbType != nil { 244 dbType = idbType.(string) 245 } 246 var connection string 247 iconnection := stmt.Arg("connection", context) 248 if iconnection != nil { 249 connection = iconnection.(string) 250 } 251 var dropOnCreate bool 252 idropOnCreate := stmt.Arg("drop_on_create", context) 253 if idropOnCreate != nil { 254 dropOnCreate = idropOnCreate.(bool) 255 } 256 var cascade bool 257 icascade := stmt.Arg("cascade", context) 258 if icascade != nil { 259 cascade = icascade.(bool) 260 } 261 262 err := 263 lib.InitDB( 264 dbType, connection, dropOnCreate, cascade) 265 266 return nil, err 267 268 }, nil 269 }) 270 gohanscript.RegisterMiniGoFunc("InitDB", 271 func(vm *gohanscript.VM, args []interface{}) []interface{} { 272 273 dbType, _ := args[0].(string) 274 connection, _ := args[0].(string) 275 dropOnCreate, _ := args[0].(bool) 276 cascade, _ := args[0].(bool) 277 278 err := 279 lib.InitDB( 280 dbType, connection, dropOnCreate, cascade) 281 return []interface{}{ 282 err} 283 284 }) 285 286 gohanscript.RegisterStmtParser("db_begin", 287 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 288 return func(context *gohanscript.Context) (interface{}, error) { 289 290 var connection db.DB 291 iconnection := stmt.Arg("connection", context) 292 if iconnection != nil { 293 connection = iconnection.(db.DB) 294 } 295 296 result1, 297 err := 298 lib.DBBegin( 299 connection) 300 301 return result1, err 302 303 }, nil 304 }) 305 gohanscript.RegisterMiniGoFunc("DBBegin", 306 func(vm *gohanscript.VM, args []interface{}) []interface{} { 307 308 connection, _ := args[0].(db.DB) 309 310 result1, 311 err := 312 lib.DBBegin( 313 connection) 314 return []interface{}{ 315 result1, 316 err} 317 318 }) 319 320 gohanscript.RegisterStmtParser("db_commit", 321 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 322 return func(context *gohanscript.Context) (interface{}, error) { 323 324 var tx transaction.Transaction 325 itx := stmt.Arg("tx", context) 326 if itx != nil { 327 tx = itx.(transaction.Transaction) 328 } 329 330 err := 331 lib.DBCommit( 332 tx) 333 334 return nil, err 335 336 }, nil 337 }) 338 gohanscript.RegisterMiniGoFunc("DBCommit", 339 func(vm *gohanscript.VM, args []interface{}) []interface{} { 340 341 tx, _ := args[0].(transaction.Transaction) 342 343 err := 344 lib.DBCommit( 345 tx) 346 return []interface{}{ 347 err} 348 349 }) 350 351 gohanscript.RegisterStmtParser("db_close", 352 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 353 return func(context *gohanscript.Context) (interface{}, error) { 354 355 var tx transaction.Transaction 356 itx := stmt.Arg("tx", context) 357 if itx != nil { 358 tx = itx.(transaction.Transaction) 359 } 360 361 err := 362 lib.DBClose( 363 tx) 364 365 return nil, err 366 367 }, nil 368 }) 369 gohanscript.RegisterMiniGoFunc("DBClose", 370 func(vm *gohanscript.VM, args []interface{}) []interface{} { 371 372 tx, _ := args[0].(transaction.Transaction) 373 374 err := 375 lib.DBClose( 376 tx) 377 return []interface{}{ 378 err} 379 380 }) 381 382 gohanscript.RegisterStmtParser("db_get", 383 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 384 return func(context *gohanscript.Context) (interface{}, error) { 385 386 var tx transaction.Transaction 387 itx := stmt.Arg("tx", context) 388 if itx != nil { 389 tx = itx.(transaction.Transaction) 390 } 391 var schemaID string 392 ischemaID := stmt.Arg("schema_id", context) 393 if ischemaID != nil { 394 schemaID = ischemaID.(string) 395 } 396 var id string 397 iid := stmt.Arg("id", context) 398 if iid != nil { 399 id = iid.(string) 400 } 401 var tenantID string 402 itenantID := stmt.Arg("tenant_id", context) 403 if itenantID != nil { 404 tenantID = itenantID.(string) 405 } 406 407 result1, 408 err := 409 lib.DBGet( 410 tx, schemaID, id, tenantID) 411 412 return result1, err 413 414 }, nil 415 }) 416 gohanscript.RegisterMiniGoFunc("DBGet", 417 func(vm *gohanscript.VM, args []interface{}) []interface{} { 418 419 tx, _ := args[0].(transaction.Transaction) 420 schemaID, _ := args[0].(string) 421 id, _ := args[0].(string) 422 tenantID, _ := args[0].(string) 423 424 result1, 425 err := 426 lib.DBGet( 427 tx, schemaID, id, tenantID) 428 return []interface{}{ 429 result1, 430 err} 431 432 }) 433 434 gohanscript.RegisterStmtParser("db_create", 435 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 436 return func(context *gohanscript.Context) (interface{}, error) { 437 438 var tx transaction.Transaction 439 itx := stmt.Arg("tx", context) 440 if itx != nil { 441 tx = itx.(transaction.Transaction) 442 } 443 var schemaID string 444 ischemaID := stmt.Arg("schema_id", context) 445 if ischemaID != nil { 446 schemaID = ischemaID.(string) 447 } 448 var data map[string]interface{} 449 idata := stmt.Arg("data", context) 450 if idata != nil { 451 data = idata.(map[string]interface{}) 452 } 453 454 err := 455 lib.DBCreate( 456 tx, schemaID, data) 457 458 return nil, err 459 460 }, nil 461 }) 462 gohanscript.RegisterMiniGoFunc("DBCreate", 463 func(vm *gohanscript.VM, args []interface{}) []interface{} { 464 465 tx, _ := args[0].(transaction.Transaction) 466 schemaID, _ := args[0].(string) 467 data, _ := args[0].(map[string]interface{}) 468 469 err := 470 lib.DBCreate( 471 tx, schemaID, data) 472 return []interface{}{ 473 err} 474 475 }) 476 477 gohanscript.RegisterStmtParser("db_list", 478 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 479 return func(context *gohanscript.Context) (interface{}, error) { 480 481 var tx transaction.Transaction 482 itx := stmt.Arg("tx", context) 483 if itx != nil { 484 tx = itx.(transaction.Transaction) 485 } 486 var schemaID string 487 ischemaID := stmt.Arg("schema_id", context) 488 if ischemaID != nil { 489 schemaID = ischemaID.(string) 490 } 491 var filter map[string]interface{} 492 ifilter := stmt.Arg("filter", context) 493 if ifilter != nil { 494 filter = ifilter.(map[string]interface{}) 495 } 496 497 result1, 498 err := 499 lib.DBList( 500 tx, schemaID, filter) 501 502 return result1, err 503 504 }, nil 505 }) 506 gohanscript.RegisterMiniGoFunc("DBList", 507 func(vm *gohanscript.VM, args []interface{}) []interface{} { 508 509 tx, _ := args[0].(transaction.Transaction) 510 schemaID, _ := args[0].(string) 511 filter, _ := args[0].(map[string]interface{}) 512 513 result1, 514 err := 515 lib.DBList( 516 tx, schemaID, filter) 517 return []interface{}{ 518 result1, 519 err} 520 521 }) 522 523 gohanscript.RegisterStmtParser("db_update", 524 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 525 return func(context *gohanscript.Context) (interface{}, error) { 526 527 var tx transaction.Transaction 528 itx := stmt.Arg("tx", context) 529 if itx != nil { 530 tx = itx.(transaction.Transaction) 531 } 532 var schemaID string 533 ischemaID := stmt.Arg("schema_id", context) 534 if ischemaID != nil { 535 schemaID = ischemaID.(string) 536 } 537 var data map[string]interface{} 538 idata := stmt.Arg("data", context) 539 if idata != nil { 540 data = idata.(map[string]interface{}) 541 } 542 543 err := 544 lib.DBUpdate( 545 tx, schemaID, data) 546 547 return nil, err 548 549 }, nil 550 }) 551 gohanscript.RegisterMiniGoFunc("DBUpdate", 552 func(vm *gohanscript.VM, args []interface{}) []interface{} { 553 554 tx, _ := args[0].(transaction.Transaction) 555 schemaID, _ := args[0].(string) 556 data, _ := args[0].(map[string]interface{}) 557 558 err := 559 lib.DBUpdate( 560 tx, schemaID, data) 561 return []interface{}{ 562 err} 563 564 }) 565 566 gohanscript.RegisterStmtParser("db_delete", 567 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 568 return func(context *gohanscript.Context) (interface{}, error) { 569 570 var tx transaction.Transaction 571 itx := stmt.Arg("tx", context) 572 if itx != nil { 573 tx = itx.(transaction.Transaction) 574 } 575 var schemaID string 576 ischemaID := stmt.Arg("schema_id", context) 577 if ischemaID != nil { 578 schemaID = ischemaID.(string) 579 } 580 var id string 581 iid := stmt.Arg("id", context) 582 if iid != nil { 583 id = iid.(string) 584 } 585 586 err := 587 lib.DBDelete( 588 tx, schemaID, id) 589 590 return nil, err 591 592 }, nil 593 }) 594 gohanscript.RegisterMiniGoFunc("DBDelete", 595 func(vm *gohanscript.VM, args []interface{}) []interface{} { 596 597 tx, _ := args[0].(transaction.Transaction) 598 schemaID, _ := args[0].(string) 599 id, _ := args[0].(string) 600 601 err := 602 lib.DBDelete( 603 tx, schemaID, id) 604 return []interface{}{ 605 err} 606 607 }) 608 609 gohanscript.RegisterStmtParser("db_query", 610 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 611 return func(context *gohanscript.Context) (interface{}, error) { 612 613 var tx transaction.Transaction 614 itx := stmt.Arg("tx", context) 615 if itx != nil { 616 tx = itx.(transaction.Transaction) 617 } 618 var schemaID string 619 ischemaID := stmt.Arg("schema_id", context) 620 if ischemaID != nil { 621 schemaID = ischemaID.(string) 622 } 623 var sql string 624 isql := stmt.Arg("sql", context) 625 if isql != nil { 626 sql = isql.(string) 627 } 628 var arguments []interface{} 629 iarguments := stmt.Arg("arguments", context) 630 if iarguments != nil { 631 arguments = iarguments.([]interface{}) 632 } 633 634 result1, 635 err := 636 lib.DBQuery( 637 tx, schemaID, sql, arguments) 638 639 return result1, err 640 641 }, nil 642 }) 643 gohanscript.RegisterMiniGoFunc("DBQuery", 644 func(vm *gohanscript.VM, args []interface{}) []interface{} { 645 646 tx, _ := args[0].(transaction.Transaction) 647 schemaID, _ := args[0].(string) 648 sql, _ := args[0].(string) 649 arguments, _ := args[0].([]interface{}) 650 651 result1, 652 err := 653 lib.DBQuery( 654 tx, schemaID, sql, arguments) 655 return []interface{}{ 656 result1, 657 err} 658 659 }) 660 661 gohanscript.RegisterStmtParser("db_exec", 662 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 663 return func(context *gohanscript.Context) (interface{}, error) { 664 665 var tx transaction.Transaction 666 itx := stmt.Arg("tx", context) 667 if itx != nil { 668 tx = itx.(transaction.Transaction) 669 } 670 var sql string 671 isql := stmt.Arg("sql", context) 672 if isql != nil { 673 sql = isql.(string) 674 } 675 var arguments []interface{} 676 iarguments := stmt.Arg("arguments", context) 677 if iarguments != nil { 678 arguments = iarguments.([]interface{}) 679 } 680 681 err := 682 lib.DBExec( 683 tx, sql, arguments) 684 685 return nil, err 686 687 }, nil 688 }) 689 gohanscript.RegisterMiniGoFunc("DBExec", 690 func(vm *gohanscript.VM, args []interface{}) []interface{} { 691 692 tx, _ := args[0].(transaction.Transaction) 693 sql, _ := args[0].(string) 694 arguments, _ := args[0].([]interface{}) 695 696 err := 697 lib.DBExec( 698 tx, sql, arguments) 699 return []interface{}{ 700 err} 701 702 }) 703 704 gohanscript.RegisterStmtParser("db_column", 705 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 706 return func(context *gohanscript.Context) (interface{}, error) { 707 708 var schemaID string 709 ischemaID := stmt.Arg("schema_id", context) 710 if ischemaID != nil { 711 schemaID = ischemaID.(string) 712 } 713 var join bool 714 ijoin := stmt.Arg("join", context) 715 if ijoin != nil { 716 join = ijoin.(bool) 717 } 718 719 result1, 720 err := 721 lib.DBColumn( 722 schemaID, join) 723 724 return result1, err 725 726 }, nil 727 }) 728 gohanscript.RegisterMiniGoFunc("DBColumn", 729 func(vm *gohanscript.VM, args []interface{}) []interface{} { 730 731 schemaID, _ := args[0].(string) 732 join, _ := args[0].(bool) 733 734 result1, 735 err := 736 lib.DBColumn( 737 schemaID, join) 738 return []interface{}{ 739 result1, 740 err} 741 742 }) 743 744 gohanscript.RegisterStmtParser("error", 745 func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) { 746 return func(context *gohanscript.Context) (interface{}, error) { 747 748 var code int 749 icode := stmt.Arg("code", context) 750 if icode != nil { 751 code = icode.(int) 752 } 753 var name string 754 iname := stmt.Arg("name", context) 755 if iname != nil { 756 name = iname.(string) 757 } 758 var message string 759 imessage := stmt.Arg("message", context) 760 if imessage != nil { 761 message = imessage.(string) 762 } 763 764 err := 765 lib.Error( 766 code, name, message) 767 768 return nil, err 769 770 }, nil 771 }) 772 gohanscript.RegisterMiniGoFunc("Error", 773 func(vm *gohanscript.VM, args []interface{}) []interface{} { 774 775 code, _ := args[0].(int) 776 name, _ := args[0].(string) 777 message, _ := args[1].(string) 778 779 err := 780 lib.Error( 781 code, name, message) 782 return []interface{}{ 783 err} 784 785 }) 786 787 }