github.com/s7techlab/cckit@v0.10.5/examples/fabcar/fabcar.pb.gw.go (about) 1 // Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. 2 // source: fabcar/fabcar.proto 3 4 /* 5 Package fabcar is a reverse proxy. 6 7 It translates gRPC into RESTful JSON APIs. 8 */ 9 package fabcar 10 11 import ( 12 "context" 13 "io" 14 "net/http" 15 16 "github.com/golang/protobuf/descriptor" 17 "github.com/golang/protobuf/proto" 18 "github.com/grpc-ecosystem/grpc-gateway/runtime" 19 "github.com/grpc-ecosystem/grpc-gateway/utilities" 20 "google.golang.org/grpc" 21 "google.golang.org/grpc/codes" 22 "google.golang.org/grpc/grpclog" 23 "google.golang.org/grpc/metadata" 24 "google.golang.org/grpc/status" 25 "google.golang.org/protobuf/types/known/emptypb" 26 ) 27 28 // Suppress "imported and not used" errors 29 var _ codes.Code 30 var _ io.Reader 31 var _ status.Status 32 var _ = runtime.String 33 var _ = utilities.NewDoubleArray 34 var _ = descriptor.ForMessage 35 var _ = metadata.Join 36 37 func request_FabCarService_CreateMaker_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 38 var protoReq CreateMakerRequest 39 var metadata runtime.ServerMetadata 40 41 newReader, berr := utilities.IOReaderFactory(req.Body) 42 if berr != nil { 43 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) 44 } 45 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { 46 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 47 } 48 49 msg, err := client.CreateMaker(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 50 return msg, metadata, err 51 52 } 53 54 func local_request_FabCarService_CreateMaker_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 55 var protoReq CreateMakerRequest 56 var metadata runtime.ServerMetadata 57 58 newReader, berr := utilities.IOReaderFactory(req.Body) 59 if berr != nil { 60 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) 61 } 62 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { 63 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 64 } 65 66 msg, err := server.CreateMaker(ctx, &protoReq) 67 return msg, metadata, err 68 69 } 70 71 func request_FabCarService_DeleteMaker_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 72 var protoReq MakerName 73 var metadata runtime.ServerMetadata 74 75 var ( 76 val string 77 ok bool 78 err error 79 _ = err 80 ) 81 82 val, ok = pathParams["name"] 83 if !ok { 84 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") 85 } 86 87 protoReq.Name, err = runtime.String(val) 88 89 if err != nil { 90 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) 91 } 92 93 msg, err := client.DeleteMaker(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 94 return msg, metadata, err 95 96 } 97 98 func local_request_FabCarService_DeleteMaker_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 99 var protoReq MakerName 100 var metadata runtime.ServerMetadata 101 102 var ( 103 val string 104 ok bool 105 err error 106 _ = err 107 ) 108 109 val, ok = pathParams["name"] 110 if !ok { 111 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") 112 } 113 114 protoReq.Name, err = runtime.String(val) 115 116 if err != nil { 117 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) 118 } 119 120 msg, err := server.DeleteMaker(ctx, &protoReq) 121 return msg, metadata, err 122 123 } 124 125 func request_FabCarService_GetMaker_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 126 var protoReq MakerName 127 var metadata runtime.ServerMetadata 128 129 var ( 130 val string 131 ok bool 132 err error 133 _ = err 134 ) 135 136 val, ok = pathParams["name"] 137 if !ok { 138 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") 139 } 140 141 protoReq.Name, err = runtime.String(val) 142 143 if err != nil { 144 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) 145 } 146 147 msg, err := client.GetMaker(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 148 return msg, metadata, err 149 150 } 151 152 func local_request_FabCarService_GetMaker_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 153 var protoReq MakerName 154 var metadata runtime.ServerMetadata 155 156 var ( 157 val string 158 ok bool 159 err error 160 _ = err 161 ) 162 163 val, ok = pathParams["name"] 164 if !ok { 165 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") 166 } 167 168 protoReq.Name, err = runtime.String(val) 169 170 if err != nil { 171 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) 172 } 173 174 msg, err := server.GetMaker(ctx, &protoReq) 175 return msg, metadata, err 176 177 } 178 179 func request_FabCarService_ListMakers_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 180 var protoReq emptypb.Empty 181 var metadata runtime.ServerMetadata 182 183 msg, err := client.ListMakers(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 184 return msg, metadata, err 185 186 } 187 188 func local_request_FabCarService_ListMakers_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 189 var protoReq emptypb.Empty 190 var metadata runtime.ServerMetadata 191 192 msg, err := server.ListMakers(ctx, &protoReq) 193 return msg, metadata, err 194 195 } 196 197 func request_FabCarService_CreateCar_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 198 var protoReq CreateCarRequest 199 var metadata runtime.ServerMetadata 200 201 newReader, berr := utilities.IOReaderFactory(req.Body) 202 if berr != nil { 203 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) 204 } 205 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { 206 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 207 } 208 209 msg, err := client.CreateCar(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 210 return msg, metadata, err 211 212 } 213 214 func local_request_FabCarService_CreateCar_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 215 var protoReq CreateCarRequest 216 var metadata runtime.ServerMetadata 217 218 newReader, berr := utilities.IOReaderFactory(req.Body) 219 if berr != nil { 220 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) 221 } 222 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { 223 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 224 } 225 226 msg, err := server.CreateCar(ctx, &protoReq) 227 return msg, metadata, err 228 229 } 230 231 func request_FabCarService_UpdateCar_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 232 var protoReq UpdateCarRequest 233 var metadata runtime.ServerMetadata 234 235 newReader, berr := utilities.IOReaderFactory(req.Body) 236 if berr != nil { 237 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) 238 } 239 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { 240 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 241 } 242 243 var ( 244 val string 245 ok bool 246 err error 247 _ = err 248 ) 249 250 val, ok = pathParams["id"] 251 if !ok { 252 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 253 } 254 255 protoReq.Id, err = runtime.StringSlice(val, ",") 256 257 if err != nil { 258 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 259 } 260 261 msg, err := client.UpdateCar(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 262 return msg, metadata, err 263 264 } 265 266 func local_request_FabCarService_UpdateCar_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 267 var protoReq UpdateCarRequest 268 var metadata runtime.ServerMetadata 269 270 newReader, berr := utilities.IOReaderFactory(req.Body) 271 if berr != nil { 272 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) 273 } 274 if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF { 275 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 276 } 277 278 var ( 279 val string 280 ok bool 281 err error 282 _ = err 283 ) 284 285 val, ok = pathParams["id"] 286 if !ok { 287 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 288 } 289 290 protoReq.Id, err = runtime.StringSlice(val, ",") 291 292 if err != nil { 293 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 294 } 295 296 msg, err := server.UpdateCar(ctx, &protoReq) 297 return msg, metadata, err 298 299 } 300 301 func request_FabCarService_DeleteCar_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 302 var protoReq CarId 303 var metadata runtime.ServerMetadata 304 305 var ( 306 val string 307 ok bool 308 err error 309 _ = err 310 ) 311 312 val, ok = pathParams["id"] 313 if !ok { 314 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 315 } 316 317 protoReq.Id, err = runtime.StringSlice(val, ",") 318 319 if err != nil { 320 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 321 } 322 323 msg, err := client.DeleteCar(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 324 return msg, metadata, err 325 326 } 327 328 func local_request_FabCarService_DeleteCar_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 329 var protoReq CarId 330 var metadata runtime.ServerMetadata 331 332 var ( 333 val string 334 ok bool 335 err error 336 _ = err 337 ) 338 339 val, ok = pathParams["id"] 340 if !ok { 341 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 342 } 343 344 protoReq.Id, err = runtime.StringSlice(val, ",") 345 346 if err != nil { 347 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 348 } 349 350 msg, err := server.DeleteCar(ctx, &protoReq) 351 return msg, metadata, err 352 353 } 354 355 func request_FabCarService_GetCar_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 356 var protoReq CarId 357 var metadata runtime.ServerMetadata 358 359 var ( 360 val string 361 ok bool 362 err error 363 _ = err 364 ) 365 366 val, ok = pathParams["id"] 367 if !ok { 368 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 369 } 370 371 protoReq.Id, err = runtime.StringSlice(val, ",") 372 373 if err != nil { 374 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 375 } 376 377 msg, err := client.GetCar(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 378 return msg, metadata, err 379 380 } 381 382 func local_request_FabCarService_GetCar_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 383 var protoReq CarId 384 var metadata runtime.ServerMetadata 385 386 var ( 387 val string 388 ok bool 389 err error 390 _ = err 391 ) 392 393 val, ok = pathParams["id"] 394 if !ok { 395 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 396 } 397 398 protoReq.Id, err = runtime.StringSlice(val, ",") 399 400 if err != nil { 401 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 402 } 403 404 msg, err := server.GetCar(ctx, &protoReq) 405 return msg, metadata, err 406 407 } 408 409 func request_FabCarService_GetCarView_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 410 var protoReq CarId 411 var metadata runtime.ServerMetadata 412 413 var ( 414 val string 415 ok bool 416 err error 417 _ = err 418 ) 419 420 val, ok = pathParams["id"] 421 if !ok { 422 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 423 } 424 425 protoReq.Id, err = runtime.StringSlice(val, ",") 426 427 if err != nil { 428 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 429 } 430 431 msg, err := client.GetCarView(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 432 return msg, metadata, err 433 434 } 435 436 func local_request_FabCarService_GetCarView_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 437 var protoReq CarId 438 var metadata runtime.ServerMetadata 439 440 var ( 441 val string 442 ok bool 443 err error 444 _ = err 445 ) 446 447 val, ok = pathParams["id"] 448 if !ok { 449 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 450 } 451 452 protoReq.Id, err = runtime.StringSlice(val, ",") 453 454 if err != nil { 455 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 456 } 457 458 msg, err := server.GetCarView(ctx, &protoReq) 459 return msg, metadata, err 460 461 } 462 463 func request_FabCarService_ListCars_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 464 var protoReq emptypb.Empty 465 var metadata runtime.ServerMetadata 466 467 msg, err := client.ListCars(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 468 return msg, metadata, err 469 470 } 471 472 func local_request_FabCarService_ListCars_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 473 var protoReq emptypb.Empty 474 var metadata runtime.ServerMetadata 475 476 msg, err := server.ListCars(ctx, &protoReq) 477 return msg, metadata, err 478 479 } 480 481 var ( 482 filter_FabCarService_UpdateCarOwners_0 = &utilities.DoubleArray{Encoding: map[string]int{"car_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 483 ) 484 485 func request_FabCarService_UpdateCarOwners_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 486 var protoReq UpdateCarOwnersRequest 487 var metadata runtime.ServerMetadata 488 489 var ( 490 val string 491 ok bool 492 err error 493 _ = err 494 ) 495 496 val, ok = pathParams["car_id"] 497 if !ok { 498 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 499 } 500 501 protoReq.CarId, err = runtime.StringSlice(val, ",") 502 503 if err != nil { 504 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 505 } 506 507 if err := req.ParseForm(); err != nil { 508 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 509 } 510 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FabCarService_UpdateCarOwners_0); err != nil { 511 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 512 } 513 514 msg, err := client.UpdateCarOwners(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 515 return msg, metadata, err 516 517 } 518 519 func local_request_FabCarService_UpdateCarOwners_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 520 var protoReq UpdateCarOwnersRequest 521 var metadata runtime.ServerMetadata 522 523 var ( 524 val string 525 ok bool 526 err error 527 _ = err 528 ) 529 530 val, ok = pathParams["car_id"] 531 if !ok { 532 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 533 } 534 535 protoReq.CarId, err = runtime.StringSlice(val, ",") 536 537 if err != nil { 538 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 539 } 540 541 if err := req.ParseForm(); err != nil { 542 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 543 } 544 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FabCarService_UpdateCarOwners_0); err != nil { 545 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 546 } 547 548 msg, err := server.UpdateCarOwners(ctx, &protoReq) 549 return msg, metadata, err 550 551 } 552 553 func request_FabCarService_DeleteCarOwner_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 554 var protoReq CarOwnerId 555 var metadata runtime.ServerMetadata 556 557 var ( 558 val string 559 ok bool 560 err error 561 _ = err 562 ) 563 564 val, ok = pathParams["car_id"] 565 if !ok { 566 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 567 } 568 569 protoReq.CarId, err = runtime.StringSlice(val, ",") 570 571 if err != nil { 572 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 573 } 574 575 val, ok = pathParams["first_name"] 576 if !ok { 577 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "first_name") 578 } 579 580 protoReq.FirstName, err = runtime.String(val) 581 582 if err != nil { 583 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "first_name", err) 584 } 585 586 val, ok = pathParams["second_name"] 587 if !ok { 588 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "second_name") 589 } 590 591 protoReq.SecondName, err = runtime.String(val) 592 593 if err != nil { 594 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "second_name", err) 595 } 596 597 msg, err := client.DeleteCarOwner(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 598 return msg, metadata, err 599 600 } 601 602 func local_request_FabCarService_DeleteCarOwner_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 603 var protoReq CarOwnerId 604 var metadata runtime.ServerMetadata 605 606 var ( 607 val string 608 ok bool 609 err error 610 _ = err 611 ) 612 613 val, ok = pathParams["car_id"] 614 if !ok { 615 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 616 } 617 618 protoReq.CarId, err = runtime.StringSlice(val, ",") 619 620 if err != nil { 621 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 622 } 623 624 val, ok = pathParams["first_name"] 625 if !ok { 626 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "first_name") 627 } 628 629 protoReq.FirstName, err = runtime.String(val) 630 631 if err != nil { 632 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "first_name", err) 633 } 634 635 val, ok = pathParams["second_name"] 636 if !ok { 637 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "second_name") 638 } 639 640 protoReq.SecondName, err = runtime.String(val) 641 642 if err != nil { 643 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "second_name", err) 644 } 645 646 msg, err := server.DeleteCarOwner(ctx, &protoReq) 647 return msg, metadata, err 648 649 } 650 651 func request_FabCarService_GetCarOwner_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 652 var protoReq CarOwnerId 653 var metadata runtime.ServerMetadata 654 655 var ( 656 val string 657 ok bool 658 err error 659 _ = err 660 ) 661 662 val, ok = pathParams["car_id"] 663 if !ok { 664 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 665 } 666 667 protoReq.CarId, err = runtime.StringSlice(val, ",") 668 669 if err != nil { 670 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 671 } 672 673 val, ok = pathParams["first_name"] 674 if !ok { 675 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "first_name") 676 } 677 678 protoReq.FirstName, err = runtime.String(val) 679 680 if err != nil { 681 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "first_name", err) 682 } 683 684 val, ok = pathParams["second_name"] 685 if !ok { 686 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "second_name") 687 } 688 689 protoReq.SecondName, err = runtime.String(val) 690 691 if err != nil { 692 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "second_name", err) 693 } 694 695 msg, err := client.GetCarOwner(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 696 return msg, metadata, err 697 698 } 699 700 func local_request_FabCarService_GetCarOwner_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 701 var protoReq CarOwnerId 702 var metadata runtime.ServerMetadata 703 704 var ( 705 val string 706 ok bool 707 err error 708 _ = err 709 ) 710 711 val, ok = pathParams["car_id"] 712 if !ok { 713 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 714 } 715 716 protoReq.CarId, err = runtime.StringSlice(val, ",") 717 718 if err != nil { 719 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 720 } 721 722 val, ok = pathParams["first_name"] 723 if !ok { 724 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "first_name") 725 } 726 727 protoReq.FirstName, err = runtime.String(val) 728 729 if err != nil { 730 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "first_name", err) 731 } 732 733 val, ok = pathParams["second_name"] 734 if !ok { 735 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "second_name") 736 } 737 738 protoReq.SecondName, err = runtime.String(val) 739 740 if err != nil { 741 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "second_name", err) 742 } 743 744 msg, err := server.GetCarOwner(ctx, &protoReq) 745 return msg, metadata, err 746 747 } 748 749 func request_FabCarService_ListCarOwners_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 750 var protoReq CarId 751 var metadata runtime.ServerMetadata 752 753 var ( 754 val string 755 ok bool 756 err error 757 _ = err 758 ) 759 760 val, ok = pathParams["id"] 761 if !ok { 762 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 763 } 764 765 protoReq.Id, err = runtime.StringSlice(val, ",") 766 767 if err != nil { 768 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 769 } 770 771 msg, err := client.ListCarOwners(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 772 return msg, metadata, err 773 774 } 775 776 func local_request_FabCarService_ListCarOwners_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 777 var protoReq CarId 778 var metadata runtime.ServerMetadata 779 780 var ( 781 val string 782 ok bool 783 err error 784 _ = err 785 ) 786 787 val, ok = pathParams["id"] 788 if !ok { 789 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 790 } 791 792 protoReq.Id, err = runtime.StringSlice(val, ",") 793 794 if err != nil { 795 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 796 } 797 798 msg, err := server.ListCarOwners(ctx, &protoReq) 799 return msg, metadata, err 800 801 } 802 803 var ( 804 filter_FabCarService_UpdateCarDetails_0 = &utilities.DoubleArray{Encoding: map[string]int{"car_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} 805 ) 806 807 func request_FabCarService_UpdateCarDetails_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 808 var protoReq UpdateCarDetailsRequest 809 var metadata runtime.ServerMetadata 810 811 var ( 812 val string 813 ok bool 814 err error 815 _ = err 816 ) 817 818 val, ok = pathParams["car_id"] 819 if !ok { 820 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 821 } 822 823 protoReq.CarId, err = runtime.StringSlice(val, ",") 824 825 if err != nil { 826 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 827 } 828 829 if err := req.ParseForm(); err != nil { 830 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 831 } 832 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FabCarService_UpdateCarDetails_0); err != nil { 833 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 834 } 835 836 msg, err := client.UpdateCarDetails(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 837 return msg, metadata, err 838 839 } 840 841 func local_request_FabCarService_UpdateCarDetails_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 842 var protoReq UpdateCarDetailsRequest 843 var metadata runtime.ServerMetadata 844 845 var ( 846 val string 847 ok bool 848 err error 849 _ = err 850 ) 851 852 val, ok = pathParams["car_id"] 853 if !ok { 854 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 855 } 856 857 protoReq.CarId, err = runtime.StringSlice(val, ",") 858 859 if err != nil { 860 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 861 } 862 863 if err := req.ParseForm(); err != nil { 864 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 865 } 866 if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_FabCarService_UpdateCarDetails_0); err != nil { 867 return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) 868 } 869 870 msg, err := server.UpdateCarDetails(ctx, &protoReq) 871 return msg, metadata, err 872 873 } 874 875 func request_FabCarService_DeleteCarDetail_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 876 var protoReq CarDetailId 877 var metadata runtime.ServerMetadata 878 879 var ( 880 val string 881 e int32 882 ok bool 883 err error 884 _ = err 885 ) 886 887 val, ok = pathParams["car_id"] 888 if !ok { 889 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 890 } 891 892 protoReq.CarId, err = runtime.StringSlice(val, ",") 893 894 if err != nil { 895 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 896 } 897 898 val, ok = pathParams["type"] 899 if !ok { 900 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "type") 901 } 902 903 e, err = runtime.Enum(val, DetailType_value) 904 905 if err != nil { 906 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "type", err) 907 } 908 909 protoReq.Type = DetailType(e) 910 911 msg, err := client.DeleteCarDetail(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 912 return msg, metadata, err 913 914 } 915 916 func local_request_FabCarService_DeleteCarDetail_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 917 var protoReq CarDetailId 918 var metadata runtime.ServerMetadata 919 920 var ( 921 val string 922 e int32 923 ok bool 924 err error 925 _ = err 926 ) 927 928 val, ok = pathParams["car_id"] 929 if !ok { 930 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 931 } 932 933 protoReq.CarId, err = runtime.StringSlice(val, ",") 934 935 if err != nil { 936 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 937 } 938 939 val, ok = pathParams["type"] 940 if !ok { 941 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "type") 942 } 943 944 e, err = runtime.Enum(val, DetailType_value) 945 946 if err != nil { 947 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "type", err) 948 } 949 950 protoReq.Type = DetailType(e) 951 952 msg, err := server.DeleteCarDetail(ctx, &protoReq) 953 return msg, metadata, err 954 955 } 956 957 func request_FabCarService_GetCarDetail_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 958 var protoReq CarDetailId 959 var metadata runtime.ServerMetadata 960 961 var ( 962 val string 963 e int32 964 ok bool 965 err error 966 _ = err 967 ) 968 969 val, ok = pathParams["car_id"] 970 if !ok { 971 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 972 } 973 974 protoReq.CarId, err = runtime.StringSlice(val, ",") 975 976 if err != nil { 977 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 978 } 979 980 val, ok = pathParams["type"] 981 if !ok { 982 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "type") 983 } 984 985 e, err = runtime.Enum(val, DetailType_value) 986 987 if err != nil { 988 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "type", err) 989 } 990 991 protoReq.Type = DetailType(e) 992 993 msg, err := client.GetCarDetail(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 994 return msg, metadata, err 995 996 } 997 998 func local_request_FabCarService_GetCarDetail_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 999 var protoReq CarDetailId 1000 var metadata runtime.ServerMetadata 1001 1002 var ( 1003 val string 1004 e int32 1005 ok bool 1006 err error 1007 _ = err 1008 ) 1009 1010 val, ok = pathParams["car_id"] 1011 if !ok { 1012 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "car_id") 1013 } 1014 1015 protoReq.CarId, err = runtime.StringSlice(val, ",") 1016 1017 if err != nil { 1018 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "car_id", err) 1019 } 1020 1021 val, ok = pathParams["type"] 1022 if !ok { 1023 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "type") 1024 } 1025 1026 e, err = runtime.Enum(val, DetailType_value) 1027 1028 if err != nil { 1029 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "type", err) 1030 } 1031 1032 protoReq.Type = DetailType(e) 1033 1034 msg, err := server.GetCarDetail(ctx, &protoReq) 1035 return msg, metadata, err 1036 1037 } 1038 1039 func request_FabCarService_ListCarDetails_0(ctx context.Context, marshaler runtime.Marshaler, client FabCarServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1040 var protoReq CarId 1041 var metadata runtime.ServerMetadata 1042 1043 var ( 1044 val string 1045 ok bool 1046 err error 1047 _ = err 1048 ) 1049 1050 val, ok = pathParams["id"] 1051 if !ok { 1052 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 1053 } 1054 1055 protoReq.Id, err = runtime.StringSlice(val, ",") 1056 1057 if err != nil { 1058 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 1059 } 1060 1061 msg, err := client.ListCarDetails(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) 1062 return msg, metadata, err 1063 1064 } 1065 1066 func local_request_FabCarService_ListCarDetails_0(ctx context.Context, marshaler runtime.Marshaler, server FabCarServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { 1067 var protoReq CarId 1068 var metadata runtime.ServerMetadata 1069 1070 var ( 1071 val string 1072 ok bool 1073 err error 1074 _ = err 1075 ) 1076 1077 val, ok = pathParams["id"] 1078 if !ok { 1079 return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id") 1080 } 1081 1082 protoReq.Id, err = runtime.StringSlice(val, ",") 1083 1084 if err != nil { 1085 return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err) 1086 } 1087 1088 msg, err := server.ListCarDetails(ctx, &protoReq) 1089 return msg, metadata, err 1090 1091 } 1092 1093 // RegisterFabCarServiceHandlerServer registers the http handlers for service FabCarService to "mux". 1094 // UnaryRPC :call FabCarServiceServer directly. 1095 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. 1096 // Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterFabCarServiceHandlerFromEndpoint instead. 1097 func RegisterFabCarServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server FabCarServiceServer) error { 1098 1099 mux.Handle("POST", pattern_FabCarService_CreateMaker_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1100 ctx, cancel := context.WithCancel(req.Context()) 1101 defer cancel() 1102 var stream runtime.ServerTransportStream 1103 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1104 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1105 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1106 if err != nil { 1107 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1108 return 1109 } 1110 resp, md, err := local_request_FabCarService_CreateMaker_0(rctx, inboundMarshaler, server, req, pathParams) 1111 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1112 ctx = runtime.NewServerMetadataContext(ctx, md) 1113 if err != nil { 1114 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1115 return 1116 } 1117 1118 forward_FabCarService_CreateMaker_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1119 1120 }) 1121 1122 mux.Handle("DELETE", pattern_FabCarService_DeleteMaker_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1123 ctx, cancel := context.WithCancel(req.Context()) 1124 defer cancel() 1125 var stream runtime.ServerTransportStream 1126 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1127 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1128 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1129 if err != nil { 1130 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1131 return 1132 } 1133 resp, md, err := local_request_FabCarService_DeleteMaker_0(rctx, inboundMarshaler, server, req, pathParams) 1134 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1135 ctx = runtime.NewServerMetadataContext(ctx, md) 1136 if err != nil { 1137 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1138 return 1139 } 1140 1141 forward_FabCarService_DeleteMaker_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1142 1143 }) 1144 1145 mux.Handle("GET", pattern_FabCarService_GetMaker_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1146 ctx, cancel := context.WithCancel(req.Context()) 1147 defer cancel() 1148 var stream runtime.ServerTransportStream 1149 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1150 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1151 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1152 if err != nil { 1153 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1154 return 1155 } 1156 resp, md, err := local_request_FabCarService_GetMaker_0(rctx, inboundMarshaler, server, req, pathParams) 1157 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1158 ctx = runtime.NewServerMetadataContext(ctx, md) 1159 if err != nil { 1160 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1161 return 1162 } 1163 1164 forward_FabCarService_GetMaker_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1165 1166 }) 1167 1168 mux.Handle("GET", pattern_FabCarService_ListMakers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1169 ctx, cancel := context.WithCancel(req.Context()) 1170 defer cancel() 1171 var stream runtime.ServerTransportStream 1172 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1173 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1174 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1175 if err != nil { 1176 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1177 return 1178 } 1179 resp, md, err := local_request_FabCarService_ListMakers_0(rctx, inboundMarshaler, server, req, pathParams) 1180 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1181 ctx = runtime.NewServerMetadataContext(ctx, md) 1182 if err != nil { 1183 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1184 return 1185 } 1186 1187 forward_FabCarService_ListMakers_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1188 1189 }) 1190 1191 mux.Handle("POST", pattern_FabCarService_CreateCar_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1192 ctx, cancel := context.WithCancel(req.Context()) 1193 defer cancel() 1194 var stream runtime.ServerTransportStream 1195 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1196 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1197 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1198 if err != nil { 1199 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1200 return 1201 } 1202 resp, md, err := local_request_FabCarService_CreateCar_0(rctx, inboundMarshaler, server, req, pathParams) 1203 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1204 ctx = runtime.NewServerMetadataContext(ctx, md) 1205 if err != nil { 1206 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1207 return 1208 } 1209 1210 forward_FabCarService_CreateCar_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1211 1212 }) 1213 1214 mux.Handle("PUT", pattern_FabCarService_UpdateCar_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1215 ctx, cancel := context.WithCancel(req.Context()) 1216 defer cancel() 1217 var stream runtime.ServerTransportStream 1218 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1219 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1220 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1221 if err != nil { 1222 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1223 return 1224 } 1225 resp, md, err := local_request_FabCarService_UpdateCar_0(rctx, inboundMarshaler, server, req, pathParams) 1226 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1227 ctx = runtime.NewServerMetadataContext(ctx, md) 1228 if err != nil { 1229 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1230 return 1231 } 1232 1233 forward_FabCarService_UpdateCar_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1234 1235 }) 1236 1237 mux.Handle("DELETE", pattern_FabCarService_DeleteCar_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1238 ctx, cancel := context.WithCancel(req.Context()) 1239 defer cancel() 1240 var stream runtime.ServerTransportStream 1241 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1242 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1243 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1244 if err != nil { 1245 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1246 return 1247 } 1248 resp, md, err := local_request_FabCarService_DeleteCar_0(rctx, inboundMarshaler, server, req, pathParams) 1249 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1250 ctx = runtime.NewServerMetadataContext(ctx, md) 1251 if err != nil { 1252 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1253 return 1254 } 1255 1256 forward_FabCarService_DeleteCar_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1257 1258 }) 1259 1260 mux.Handle("GET", pattern_FabCarService_GetCar_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1261 ctx, cancel := context.WithCancel(req.Context()) 1262 defer cancel() 1263 var stream runtime.ServerTransportStream 1264 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1265 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1266 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1267 if err != nil { 1268 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1269 return 1270 } 1271 resp, md, err := local_request_FabCarService_GetCar_0(rctx, inboundMarshaler, server, req, pathParams) 1272 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1273 ctx = runtime.NewServerMetadataContext(ctx, md) 1274 if err != nil { 1275 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1276 return 1277 } 1278 1279 forward_FabCarService_GetCar_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1280 1281 }) 1282 1283 mux.Handle("GET", pattern_FabCarService_GetCarView_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1284 ctx, cancel := context.WithCancel(req.Context()) 1285 defer cancel() 1286 var stream runtime.ServerTransportStream 1287 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1288 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1289 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1290 if err != nil { 1291 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1292 return 1293 } 1294 resp, md, err := local_request_FabCarService_GetCarView_0(rctx, inboundMarshaler, server, req, pathParams) 1295 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1296 ctx = runtime.NewServerMetadataContext(ctx, md) 1297 if err != nil { 1298 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1299 return 1300 } 1301 1302 forward_FabCarService_GetCarView_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1303 1304 }) 1305 1306 mux.Handle("GET", pattern_FabCarService_ListCars_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1307 ctx, cancel := context.WithCancel(req.Context()) 1308 defer cancel() 1309 var stream runtime.ServerTransportStream 1310 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1311 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1312 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1313 if err != nil { 1314 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1315 return 1316 } 1317 resp, md, err := local_request_FabCarService_ListCars_0(rctx, inboundMarshaler, server, req, pathParams) 1318 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1319 ctx = runtime.NewServerMetadataContext(ctx, md) 1320 if err != nil { 1321 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1322 return 1323 } 1324 1325 forward_FabCarService_ListCars_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1326 1327 }) 1328 1329 mux.Handle("PUT", pattern_FabCarService_UpdateCarOwners_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1330 ctx, cancel := context.WithCancel(req.Context()) 1331 defer cancel() 1332 var stream runtime.ServerTransportStream 1333 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1334 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1335 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1336 if err != nil { 1337 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1338 return 1339 } 1340 resp, md, err := local_request_FabCarService_UpdateCarOwners_0(rctx, inboundMarshaler, server, req, pathParams) 1341 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1342 ctx = runtime.NewServerMetadataContext(ctx, md) 1343 if err != nil { 1344 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1345 return 1346 } 1347 1348 forward_FabCarService_UpdateCarOwners_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1349 1350 }) 1351 1352 mux.Handle("DELETE", pattern_FabCarService_DeleteCarOwner_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1353 ctx, cancel := context.WithCancel(req.Context()) 1354 defer cancel() 1355 var stream runtime.ServerTransportStream 1356 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1357 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1358 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1359 if err != nil { 1360 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1361 return 1362 } 1363 resp, md, err := local_request_FabCarService_DeleteCarOwner_0(rctx, inboundMarshaler, server, req, pathParams) 1364 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1365 ctx = runtime.NewServerMetadataContext(ctx, md) 1366 if err != nil { 1367 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1368 return 1369 } 1370 1371 forward_FabCarService_DeleteCarOwner_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1372 1373 }) 1374 1375 mux.Handle("GET", pattern_FabCarService_GetCarOwner_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1376 ctx, cancel := context.WithCancel(req.Context()) 1377 defer cancel() 1378 var stream runtime.ServerTransportStream 1379 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1380 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1381 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1382 if err != nil { 1383 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1384 return 1385 } 1386 resp, md, err := local_request_FabCarService_GetCarOwner_0(rctx, inboundMarshaler, server, req, pathParams) 1387 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1388 ctx = runtime.NewServerMetadataContext(ctx, md) 1389 if err != nil { 1390 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1391 return 1392 } 1393 1394 forward_FabCarService_GetCarOwner_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1395 1396 }) 1397 1398 mux.Handle("GET", pattern_FabCarService_ListCarOwners_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1399 ctx, cancel := context.WithCancel(req.Context()) 1400 defer cancel() 1401 var stream runtime.ServerTransportStream 1402 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1403 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1404 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1405 if err != nil { 1406 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1407 return 1408 } 1409 resp, md, err := local_request_FabCarService_ListCarOwners_0(rctx, inboundMarshaler, server, req, pathParams) 1410 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1411 ctx = runtime.NewServerMetadataContext(ctx, md) 1412 if err != nil { 1413 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1414 return 1415 } 1416 1417 forward_FabCarService_ListCarOwners_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1418 1419 }) 1420 1421 mux.Handle("PUT", pattern_FabCarService_UpdateCarDetails_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1422 ctx, cancel := context.WithCancel(req.Context()) 1423 defer cancel() 1424 var stream runtime.ServerTransportStream 1425 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1426 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1427 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1428 if err != nil { 1429 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1430 return 1431 } 1432 resp, md, err := local_request_FabCarService_UpdateCarDetails_0(rctx, inboundMarshaler, server, req, pathParams) 1433 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1434 ctx = runtime.NewServerMetadataContext(ctx, md) 1435 if err != nil { 1436 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1437 return 1438 } 1439 1440 forward_FabCarService_UpdateCarDetails_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1441 1442 }) 1443 1444 mux.Handle("DELETE", pattern_FabCarService_DeleteCarDetail_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1445 ctx, cancel := context.WithCancel(req.Context()) 1446 defer cancel() 1447 var stream runtime.ServerTransportStream 1448 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1449 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1450 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1451 if err != nil { 1452 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1453 return 1454 } 1455 resp, md, err := local_request_FabCarService_DeleteCarDetail_0(rctx, inboundMarshaler, server, req, pathParams) 1456 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1457 ctx = runtime.NewServerMetadataContext(ctx, md) 1458 if err != nil { 1459 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1460 return 1461 } 1462 1463 forward_FabCarService_DeleteCarDetail_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1464 1465 }) 1466 1467 mux.Handle("GET", pattern_FabCarService_GetCarDetail_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1468 ctx, cancel := context.WithCancel(req.Context()) 1469 defer cancel() 1470 var stream runtime.ServerTransportStream 1471 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1472 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1473 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1474 if err != nil { 1475 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1476 return 1477 } 1478 resp, md, err := local_request_FabCarService_GetCarDetail_0(rctx, inboundMarshaler, server, req, pathParams) 1479 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1480 ctx = runtime.NewServerMetadataContext(ctx, md) 1481 if err != nil { 1482 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1483 return 1484 } 1485 1486 forward_FabCarService_GetCarDetail_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1487 1488 }) 1489 1490 mux.Handle("GET", pattern_FabCarService_ListCarDetails_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1491 ctx, cancel := context.WithCancel(req.Context()) 1492 defer cancel() 1493 var stream runtime.ServerTransportStream 1494 ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) 1495 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1496 rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) 1497 if err != nil { 1498 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1499 return 1500 } 1501 resp, md, err := local_request_FabCarService_ListCarDetails_0(rctx, inboundMarshaler, server, req, pathParams) 1502 md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) 1503 ctx = runtime.NewServerMetadataContext(ctx, md) 1504 if err != nil { 1505 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1506 return 1507 } 1508 1509 forward_FabCarService_ListCarDetails_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1510 1511 }) 1512 1513 return nil 1514 } 1515 1516 // RegisterFabCarServiceHandlerFromEndpoint is same as RegisterFabCarServiceHandler but 1517 // automatically dials to "endpoint" and closes the connection when "ctx" gets done. 1518 func RegisterFabCarServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { 1519 conn, err := grpc.Dial(endpoint, opts...) 1520 if err != nil { 1521 return err 1522 } 1523 defer func() { 1524 if err != nil { 1525 if cerr := conn.Close(); cerr != nil { 1526 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) 1527 } 1528 return 1529 } 1530 go func() { 1531 <-ctx.Done() 1532 if cerr := conn.Close(); cerr != nil { 1533 grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) 1534 } 1535 }() 1536 }() 1537 1538 return RegisterFabCarServiceHandler(ctx, mux, conn) 1539 } 1540 1541 // RegisterFabCarServiceHandler registers the http handlers for service FabCarService to "mux". 1542 // The handlers forward requests to the grpc endpoint over "conn". 1543 func RegisterFabCarServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { 1544 return RegisterFabCarServiceHandlerClient(ctx, mux, NewFabCarServiceClient(conn)) 1545 } 1546 1547 // RegisterFabCarServiceHandlerClient registers the http handlers for service FabCarService 1548 // to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "FabCarServiceClient". 1549 // Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "FabCarServiceClient" 1550 // doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in 1551 // "FabCarServiceClient" to call the correct interceptors. 1552 func RegisterFabCarServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client FabCarServiceClient) error { 1553 1554 mux.Handle("POST", pattern_FabCarService_CreateMaker_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1555 ctx, cancel := context.WithCancel(req.Context()) 1556 defer cancel() 1557 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1558 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1559 if err != nil { 1560 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1561 return 1562 } 1563 resp, md, err := request_FabCarService_CreateMaker_0(rctx, inboundMarshaler, client, req, pathParams) 1564 ctx = runtime.NewServerMetadataContext(ctx, md) 1565 if err != nil { 1566 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1567 return 1568 } 1569 1570 forward_FabCarService_CreateMaker_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1571 1572 }) 1573 1574 mux.Handle("DELETE", pattern_FabCarService_DeleteMaker_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1575 ctx, cancel := context.WithCancel(req.Context()) 1576 defer cancel() 1577 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1578 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1579 if err != nil { 1580 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1581 return 1582 } 1583 resp, md, err := request_FabCarService_DeleteMaker_0(rctx, inboundMarshaler, client, req, pathParams) 1584 ctx = runtime.NewServerMetadataContext(ctx, md) 1585 if err != nil { 1586 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1587 return 1588 } 1589 1590 forward_FabCarService_DeleteMaker_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1591 1592 }) 1593 1594 mux.Handle("GET", pattern_FabCarService_GetMaker_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1595 ctx, cancel := context.WithCancel(req.Context()) 1596 defer cancel() 1597 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1598 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1599 if err != nil { 1600 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1601 return 1602 } 1603 resp, md, err := request_FabCarService_GetMaker_0(rctx, inboundMarshaler, client, req, pathParams) 1604 ctx = runtime.NewServerMetadataContext(ctx, md) 1605 if err != nil { 1606 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1607 return 1608 } 1609 1610 forward_FabCarService_GetMaker_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1611 1612 }) 1613 1614 mux.Handle("GET", pattern_FabCarService_ListMakers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1615 ctx, cancel := context.WithCancel(req.Context()) 1616 defer cancel() 1617 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1618 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1619 if err != nil { 1620 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1621 return 1622 } 1623 resp, md, err := request_FabCarService_ListMakers_0(rctx, inboundMarshaler, client, req, pathParams) 1624 ctx = runtime.NewServerMetadataContext(ctx, md) 1625 if err != nil { 1626 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1627 return 1628 } 1629 1630 forward_FabCarService_ListMakers_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1631 1632 }) 1633 1634 mux.Handle("POST", pattern_FabCarService_CreateCar_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1635 ctx, cancel := context.WithCancel(req.Context()) 1636 defer cancel() 1637 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1638 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1639 if err != nil { 1640 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1641 return 1642 } 1643 resp, md, err := request_FabCarService_CreateCar_0(rctx, inboundMarshaler, client, req, pathParams) 1644 ctx = runtime.NewServerMetadataContext(ctx, md) 1645 if err != nil { 1646 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1647 return 1648 } 1649 1650 forward_FabCarService_CreateCar_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1651 1652 }) 1653 1654 mux.Handle("PUT", pattern_FabCarService_UpdateCar_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1655 ctx, cancel := context.WithCancel(req.Context()) 1656 defer cancel() 1657 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1658 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1659 if err != nil { 1660 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1661 return 1662 } 1663 resp, md, err := request_FabCarService_UpdateCar_0(rctx, inboundMarshaler, client, req, pathParams) 1664 ctx = runtime.NewServerMetadataContext(ctx, md) 1665 if err != nil { 1666 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1667 return 1668 } 1669 1670 forward_FabCarService_UpdateCar_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1671 1672 }) 1673 1674 mux.Handle("DELETE", pattern_FabCarService_DeleteCar_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1675 ctx, cancel := context.WithCancel(req.Context()) 1676 defer cancel() 1677 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1678 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1679 if err != nil { 1680 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1681 return 1682 } 1683 resp, md, err := request_FabCarService_DeleteCar_0(rctx, inboundMarshaler, client, req, pathParams) 1684 ctx = runtime.NewServerMetadataContext(ctx, md) 1685 if err != nil { 1686 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1687 return 1688 } 1689 1690 forward_FabCarService_DeleteCar_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1691 1692 }) 1693 1694 mux.Handle("GET", pattern_FabCarService_GetCar_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1695 ctx, cancel := context.WithCancel(req.Context()) 1696 defer cancel() 1697 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1698 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1699 if err != nil { 1700 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1701 return 1702 } 1703 resp, md, err := request_FabCarService_GetCar_0(rctx, inboundMarshaler, client, req, pathParams) 1704 ctx = runtime.NewServerMetadataContext(ctx, md) 1705 if err != nil { 1706 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1707 return 1708 } 1709 1710 forward_FabCarService_GetCar_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1711 1712 }) 1713 1714 mux.Handle("GET", pattern_FabCarService_GetCarView_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1715 ctx, cancel := context.WithCancel(req.Context()) 1716 defer cancel() 1717 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1718 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1719 if err != nil { 1720 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1721 return 1722 } 1723 resp, md, err := request_FabCarService_GetCarView_0(rctx, inboundMarshaler, client, req, pathParams) 1724 ctx = runtime.NewServerMetadataContext(ctx, md) 1725 if err != nil { 1726 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1727 return 1728 } 1729 1730 forward_FabCarService_GetCarView_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1731 1732 }) 1733 1734 mux.Handle("GET", pattern_FabCarService_ListCars_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1735 ctx, cancel := context.WithCancel(req.Context()) 1736 defer cancel() 1737 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1738 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1739 if err != nil { 1740 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1741 return 1742 } 1743 resp, md, err := request_FabCarService_ListCars_0(rctx, inboundMarshaler, client, req, pathParams) 1744 ctx = runtime.NewServerMetadataContext(ctx, md) 1745 if err != nil { 1746 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1747 return 1748 } 1749 1750 forward_FabCarService_ListCars_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1751 1752 }) 1753 1754 mux.Handle("PUT", pattern_FabCarService_UpdateCarOwners_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1755 ctx, cancel := context.WithCancel(req.Context()) 1756 defer cancel() 1757 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1758 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1759 if err != nil { 1760 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1761 return 1762 } 1763 resp, md, err := request_FabCarService_UpdateCarOwners_0(rctx, inboundMarshaler, client, req, pathParams) 1764 ctx = runtime.NewServerMetadataContext(ctx, md) 1765 if err != nil { 1766 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1767 return 1768 } 1769 1770 forward_FabCarService_UpdateCarOwners_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1771 1772 }) 1773 1774 mux.Handle("DELETE", pattern_FabCarService_DeleteCarOwner_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1775 ctx, cancel := context.WithCancel(req.Context()) 1776 defer cancel() 1777 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1778 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1779 if err != nil { 1780 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1781 return 1782 } 1783 resp, md, err := request_FabCarService_DeleteCarOwner_0(rctx, inboundMarshaler, client, req, pathParams) 1784 ctx = runtime.NewServerMetadataContext(ctx, md) 1785 if err != nil { 1786 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1787 return 1788 } 1789 1790 forward_FabCarService_DeleteCarOwner_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1791 1792 }) 1793 1794 mux.Handle("GET", pattern_FabCarService_GetCarOwner_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1795 ctx, cancel := context.WithCancel(req.Context()) 1796 defer cancel() 1797 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1798 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1799 if err != nil { 1800 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1801 return 1802 } 1803 resp, md, err := request_FabCarService_GetCarOwner_0(rctx, inboundMarshaler, client, req, pathParams) 1804 ctx = runtime.NewServerMetadataContext(ctx, md) 1805 if err != nil { 1806 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1807 return 1808 } 1809 1810 forward_FabCarService_GetCarOwner_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1811 1812 }) 1813 1814 mux.Handle("GET", pattern_FabCarService_ListCarOwners_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1815 ctx, cancel := context.WithCancel(req.Context()) 1816 defer cancel() 1817 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1818 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1819 if err != nil { 1820 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1821 return 1822 } 1823 resp, md, err := request_FabCarService_ListCarOwners_0(rctx, inboundMarshaler, client, req, pathParams) 1824 ctx = runtime.NewServerMetadataContext(ctx, md) 1825 if err != nil { 1826 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1827 return 1828 } 1829 1830 forward_FabCarService_ListCarOwners_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1831 1832 }) 1833 1834 mux.Handle("PUT", pattern_FabCarService_UpdateCarDetails_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1835 ctx, cancel := context.WithCancel(req.Context()) 1836 defer cancel() 1837 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1838 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1839 if err != nil { 1840 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1841 return 1842 } 1843 resp, md, err := request_FabCarService_UpdateCarDetails_0(rctx, inboundMarshaler, client, req, pathParams) 1844 ctx = runtime.NewServerMetadataContext(ctx, md) 1845 if err != nil { 1846 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1847 return 1848 } 1849 1850 forward_FabCarService_UpdateCarDetails_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1851 1852 }) 1853 1854 mux.Handle("DELETE", pattern_FabCarService_DeleteCarDetail_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1855 ctx, cancel := context.WithCancel(req.Context()) 1856 defer cancel() 1857 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1858 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1859 if err != nil { 1860 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1861 return 1862 } 1863 resp, md, err := request_FabCarService_DeleteCarDetail_0(rctx, inboundMarshaler, client, req, pathParams) 1864 ctx = runtime.NewServerMetadataContext(ctx, md) 1865 if err != nil { 1866 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1867 return 1868 } 1869 1870 forward_FabCarService_DeleteCarDetail_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1871 1872 }) 1873 1874 mux.Handle("GET", pattern_FabCarService_GetCarDetail_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1875 ctx, cancel := context.WithCancel(req.Context()) 1876 defer cancel() 1877 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1878 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1879 if err != nil { 1880 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1881 return 1882 } 1883 resp, md, err := request_FabCarService_GetCarDetail_0(rctx, inboundMarshaler, client, req, pathParams) 1884 ctx = runtime.NewServerMetadataContext(ctx, md) 1885 if err != nil { 1886 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1887 return 1888 } 1889 1890 forward_FabCarService_GetCarDetail_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1891 1892 }) 1893 1894 mux.Handle("GET", pattern_FabCarService_ListCarDetails_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { 1895 ctx, cancel := context.WithCancel(req.Context()) 1896 defer cancel() 1897 inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) 1898 rctx, err := runtime.AnnotateContext(ctx, mux, req) 1899 if err != nil { 1900 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1901 return 1902 } 1903 resp, md, err := request_FabCarService_ListCarDetails_0(rctx, inboundMarshaler, client, req, pathParams) 1904 ctx = runtime.NewServerMetadataContext(ctx, md) 1905 if err != nil { 1906 runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) 1907 return 1908 } 1909 1910 forward_FabCarService_ListCarDetails_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) 1911 1912 }) 1913 1914 return nil 1915 } 1916 1917 var ( 1918 pattern_FabCarService_CreateMaker_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"fabcar", "makers"}, "", runtime.AssumeColonVerbOpt(true))) 1919 1920 pattern_FabCarService_DeleteMaker_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"fabcar", "makers", "name"}, "", runtime.AssumeColonVerbOpt(true))) 1921 1922 pattern_FabCarService_GetMaker_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"fabcar", "makers", "name"}, "", runtime.AssumeColonVerbOpt(true))) 1923 1924 pattern_FabCarService_ListMakers_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"fabcar", "makers"}, "", runtime.AssumeColonVerbOpt(true))) 1925 1926 pattern_FabCarService_CreateCar_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"fabcar", "cars"}, "", runtime.AssumeColonVerbOpt(true))) 1927 1928 pattern_FabCarService_UpdateCar_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"fabcar", "cars", "id"}, "", runtime.AssumeColonVerbOpt(true))) 1929 1930 pattern_FabCarService_DeleteCar_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"fabcar", "cars", "id"}, "", runtime.AssumeColonVerbOpt(true))) 1931 1932 pattern_FabCarService_GetCar_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"fabcar", "cars", "id"}, "", runtime.AssumeColonVerbOpt(true))) 1933 1934 pattern_FabCarService_GetCarView_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"fabcar", "cars", "id", "view"}, "", runtime.AssumeColonVerbOpt(true))) 1935 1936 pattern_FabCarService_ListCars_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"fabcar", "cars"}, "", runtime.AssumeColonVerbOpt(true))) 1937 1938 pattern_FabCarService_UpdateCarOwners_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"fabcar", "cars", "car_id", "owners"}, "", runtime.AssumeColonVerbOpt(true))) 1939 1940 pattern_FabCarService_DeleteCarOwner_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"fabcar", "cars", "car_id", "owners", "first_name", "second_name"}, "", runtime.AssumeColonVerbOpt(true))) 1941 1942 pattern_FabCarService_GetCarOwner_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"fabcar", "cars", "car_id", "owners", "first_name", "second_name"}, "", runtime.AssumeColonVerbOpt(true))) 1943 1944 pattern_FabCarService_ListCarOwners_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"fabcar", "cars", "id", "owners"}, "", runtime.AssumeColonVerbOpt(true))) 1945 1946 pattern_FabCarService_UpdateCarDetails_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"fabcar", "cars", "car_id", "details"}, "", runtime.AssumeColonVerbOpt(true))) 1947 1948 pattern_FabCarService_DeleteCarDetail_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"fabcar", "cars", "car_id", "details", "type"}, "", runtime.AssumeColonVerbOpt(true))) 1949 1950 pattern_FabCarService_GetCarDetail_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"fabcar", "cars", "car_id", "details", "type"}, "", runtime.AssumeColonVerbOpt(true))) 1951 1952 pattern_FabCarService_ListCarDetails_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"fabcar", "cars", "id", "details"}, "", runtime.AssumeColonVerbOpt(true))) 1953 ) 1954 1955 var ( 1956 forward_FabCarService_CreateMaker_0 = runtime.ForwardResponseMessage 1957 1958 forward_FabCarService_DeleteMaker_0 = runtime.ForwardResponseMessage 1959 1960 forward_FabCarService_GetMaker_0 = runtime.ForwardResponseMessage 1961 1962 forward_FabCarService_ListMakers_0 = runtime.ForwardResponseMessage 1963 1964 forward_FabCarService_CreateCar_0 = runtime.ForwardResponseMessage 1965 1966 forward_FabCarService_UpdateCar_0 = runtime.ForwardResponseMessage 1967 1968 forward_FabCarService_DeleteCar_0 = runtime.ForwardResponseMessage 1969 1970 forward_FabCarService_GetCar_0 = runtime.ForwardResponseMessage 1971 1972 forward_FabCarService_GetCarView_0 = runtime.ForwardResponseMessage 1973 1974 forward_FabCarService_ListCars_0 = runtime.ForwardResponseMessage 1975 1976 forward_FabCarService_UpdateCarOwners_0 = runtime.ForwardResponseMessage 1977 1978 forward_FabCarService_DeleteCarOwner_0 = runtime.ForwardResponseMessage 1979 1980 forward_FabCarService_GetCarOwner_0 = runtime.ForwardResponseMessage 1981 1982 forward_FabCarService_ListCarOwners_0 = runtime.ForwardResponseMessage 1983 1984 forward_FabCarService_UpdateCarDetails_0 = runtime.ForwardResponseMessage 1985 1986 forward_FabCarService_DeleteCarDetail_0 = runtime.ForwardResponseMessage 1987 1988 forward_FabCarService_GetCarDetail_0 = runtime.ForwardResponseMessage 1989 1990 forward_FabCarService_ListCarDetails_0 = runtime.ForwardResponseMessage 1991 )