// MakeHTTPHandler mounts the endpoints into a REST-y HTTP handler.
func MakeHTTPHandler(ctx context.Context, e Endpoints, imagePath string, logger log.Logger) http.Handler {
r := mux.NewRouter().StrictSlash(false)
options := []httptransport.ServerOption{
httptransport.ServerErrorLogger(logger),
httptransport.ServerErrorEncoder(encodeError),
}
// GET /catalogue List
// GET /catalogue/size Count
// GET /catalogue/{id} Get
// GET /tags Tags
// GET /health Health Check
r.Methods("GET").Path("/catalogue").Handler(httptransport.NewServer(
ctx,
e.ListEndpoint,
decodeListRequest,
encodeListResponse,
options...,
))
r.Methods("GET").Path("/catalogue/size").Handler(httptransport.NewServer(
ctx,
e.CountEndpoint,
decodeCountRequest,
encodeResponse,
options...,
))
r.Methods("GET").Path("/catalogue/{id}").Handler(httptransport.NewServer(
ctx,
e.GetEndpoint,
decodeGetRequest,
encodeGetResponse, // special case, this one can have an error
options...,
))
r.Methods("GET").Path("/tags").Handler(httptransport.NewServer(
ctx,
e.TagsEndpoint,
decodeTagsRequest,
encodeResponse,
options...,
))
r.Methods("GET").PathPrefix("/catalogue/images/").Handler(http.StripPrefix(
"/catalogue/images/",
http.FileServer(http.Dir(imagePath)),
))
r.Methods("GET").PathPrefix("/health").Handler(httptransport.NewServer(
ctx,
e.HealthEndpoint,
decodeHealthRequest,
encodeHealthResponse,
options...,
))
r.Handle("/metrics", promhttp.Handler())
return r
}
func createHealthCheckRouter(logger kitlog.Logger, ctx context.Context, healthCheckEndpoint endpoint.HealthCheckServicer) *mux.Router {
router := mux.NewRouter()
router.Handle("/healthcheck",
kithttp.NewServer(
ctx,
healthCheckEndpoint.Run,
func(context.Context, *http.Request) (interface{}, error) { return struct{}{}, nil },
encodeHealthCheckHTTPResponse,
kithttp.ServerErrorEncoder(errorEncoder),
kithttp.ServerErrorLogger(logger),
)).Methods(getHTTPMethod)
return router
}
func createApplicationRouter(logger kitlog.Logger, ctx context.Context, c *config.Configuration, sensorReadingsServicer endpoint.SensorReadingsServicer) *mux.Router {
router := mux.NewRouter()
router.Handle("/api/v1/sensor_readings",
kithttp.NewServer(
ctx,
endpoint.VerifyAPIKey(c.APITokens)(sensorReadingsServicer.HandleMeasurementMessage),
decodeSensorReadingsHTTPRequest,
encodeSensorReadingsHTTPResponse,
kithttp.ServerErrorEncoder(errorEncoder),
kithttp.ServerErrorLogger(logger),
)).Methods(postHTTPMethod)
return router
}
// Handler returns go-kit http transport server
// of the given definition
func (s Service) Handler() http.Handler {
ep := s.Middlewares.Chain()(s.Endpoint)
options := append([]httptransport.ServerOption{
httptransport.ServerBefore(s.Before...),
httptransport.ServerAfter(s.After...),
httptransport.ServerErrorEncoder(s.ErrorEncoder),
}, s.Options...)
return httptransport.NewServer(
s.Context,
ep,
s.DecodeFunc,
s.EncodeFunc,
options...)
}
func main() {
flag.Usage = usage
flag.Parse()
a := flag.Args()
var mode = ""
if len(a) > 0 {
mode = a[0]
}
switch mode {
case "server":
var svc StringService
options := []httptrans.ServerOption{httptrans.ServerErrorEncoder(func(ctx context.Context, err error, w http.ResponseWriter) {
w.WriteHeader(500)
encoding.JSON(1).EncodeResponse()(ctx, w, err)
}),
}
trans.ServersForEndpointsWithOptions(svc, []trans.ServerLayer{}, options)
http.ListenAndServe(args.httpPort, nil)
case "client":
if len(a) < 3 {
usage()
return
}
client := trans.NewClient("127.0.0.1" + args.httpPort)
cmd := a[1]
arg := a[2]
switch cmd {
case "uppercase":
str, err := client.Uppercase(arg)
fmt.Printf("\t\"%s\".Uppercase: \"%s\", err: %s\n", arg, str, err)
case "count":
count := client.Count(arg)
fmt.Printf("\t\"%s\".Count: %d\n", arg, count)
}
default:
usage()
}
}
// MakeHandler returns a handler for the tracking service.
func MakeHandler(ctx context.Context, ts Service, logger kitlog.Logger) http.Handler {
r := mux.NewRouter()
opts := []kithttp.ServerOption{
kithttp.ServerErrorLogger(logger),
kithttp.ServerErrorEncoder(encodeError),
}
trackCargoHandler := kithttp.NewServer(
ctx,
makeTrackCargoEndpoint(ts),
decodeTrackCargoRequest,
encodeResponse,
opts...,
)
r.Handle("/tracking/v1/cargos/{id}", trackCargoHandler).Methods("GET")
return r
}
// MakeHandler returns a handler for the handling service.
func MakeHandler(ctx context.Context, hs Service, logger kitlog.Logger) http.Handler {
r := mux.NewRouter()
opts := []kithttp.ServerOption{
kithttp.ServerErrorLogger(logger),
kithttp.ServerErrorEncoder(encodeError),
}
registerIncidentHandler := kithttp.NewServer(
ctx,
makeRegisterIncidentEndpoint(hs),
decodeRegisterIncidentRequest,
encodeResponse,
opts...,
)
r.Handle("/handling/v1/incidents", registerIncidentHandler).Methods("POST")
return r
}
func TestServerErrorEncoder(t *testing.T) {
errTeapot := errors.New("teapot")
code := func(err error) int {
if err == errTeapot {
return http.StatusTeapot
}
return http.StatusInternalServerError
}
handler := httptransport.NewServer(
context.Background(),
func(context.Context, interface{}) (interface{}, error) { return struct{}{}, errTeapot },
func(*http.Request) (interface{}, error) { return struct{}{}, nil },
func(http.ResponseWriter, interface{}) error { return nil },
httptransport.ServerErrorEncoder(func(w http.ResponseWriter, err error) { w.WriteHeader(code(err)) }),
)
server := httptest.NewServer(handler)
defer server.Close()
resp, _ := http.Get(server.URL)
if want, have := http.StatusTeapot, resp.StatusCode; want != have {
t.Errorf("want %d, have %d", want, have)
}
}
// MakeHTTPHandler returns a handler that makes a set of endpoints available
// on predefined paths.
func MakeHTTPHandler(ctx context.Context, endpoints Endpoints, tracer stdopentracing.Tracer, logger log.Logger) http.Handler {
options := []httptransport.ServerOption{
httptransport.ServerErrorEncoder(errorEncoder),
httptransport.ServerErrorLogger(logger),
}
m := http.NewServeMux()
m.Handle("/sum", httptransport.NewServer(
ctx,
endpoints.SumEndpoint,
DecodeHTTPSumRequest,
EncodeHTTPGenericResponse,
append(options, httptransport.ServerBefore(opentracing.FromHTTPRequest(tracer, "Sum", logger)))...,
))
m.Handle("/concat", httptransport.NewServer(
ctx,
endpoints.ConcatEndpoint,
DecodeHTTPConcatRequest,
EncodeHTTPGenericResponse,
append(options, httptransport.ServerBefore(opentracing.FromHTTPRequest(tracer, "Concat", logger)))...,
))
return m
}
// MakeHTTPHandler mounts the endpoints into a REST-y HTTP handler.
func MakeHTTPHandler(ctx context.Context, e Endpoints, logger log.Logger) http.Handler {
r := mux.NewRouter().StrictSlash(false)
options := []httptransport.ServerOption{
httptransport.ServerErrorLogger(logger),
httptransport.ServerErrorEncoder(encodeError),
}
// GET /login Login
// GET /register Register
// GET /health Health Check
r.Methods("GET").Path("/login").Handler(httptransport.NewServer(
ctx,
e.LoginEndpoint,
decodeLoginRequest,
encodeResponse,
options...,
))
r.Methods("POST").Path("/register").Handler(httptransport.NewServer(
ctx,
e.RegisterEndpoint,
decodeRegisterRequest,
encodeResponse,
options...,
))
r.Methods("GET").PathPrefix("/customers").Handler(httptransport.NewServer(
ctx,
e.UserGetEndpoint,
decodeGetRequest,
encodeResponse,
options...,
))
r.Methods("GET").PathPrefix("/cards").Handler(httptransport.NewServer(
ctx,
e.CardGetEndpoint,
decodeGetRequest,
encodeResponse,
options...,
))
r.Methods("GET").PathPrefix("/addresses").Handler(httptransport.NewServer(
ctx,
e.AddressGetEndpoint,
decodeGetRequest,
encodeResponse,
options...,
))
r.Methods("POST").Path("/customers").Handler(httptransport.NewServer(
ctx,
e.UserPostEndpoint,
decodeUserRequest,
encodeResponse,
options...,
))
r.Methods("POST").Path("/addresses").Handler(httptransport.NewServer(
ctx,
e.AddressPostEndpoint,
decodeAddressRequest,
encodeResponse,
options...,
))
r.Methods("POST").Path("/cards").Handler(httptransport.NewServer(
ctx,
e.CardPostEndpoint,
decodeCardRequest,
encodeResponse,
options...,
))
r.Methods("DELETE").PathPrefix("/").Handler(httptransport.NewServer(
ctx,
e.DeleteEndpoint,
decodeDeleteRequest,
encodeResponse,
options...,
))
r.Methods("GET").PathPrefix("/health").Handler(httptransport.NewServer(
ctx,
e.HealthEndpoint,
decodeHealthRequest,
encodeHealthResponse,
options...,
))
r.Handle("/metrics", promhttp.Handler())
return r
}
// MakeHTTPHandler mounts all of the service endpoints into an http.Handler.
// Useful in a restsvc server.
func MakeHTTPHandler(ctx context.Context, s Service, logger log.Logger) http.Handler {
r := mux.NewRouter()
e := MakeServerEndpoints(s)
options := []httptransport.ServerOption{
httptransport.ServerErrorLogger(logger),
httptransport.ServerErrorEncoder(encodeError),
}
// POST /configs/ adds another config
// GET /configs/:id retrieves the given config by id
// PUT /configs/:id post updated config information about the config
// PATCH /configs/:id partial updated config information
// DELETE /configs/:id remove the given config
// GET /configs/:id/channels/ retrieve channels associated with the config
// GET /configs/:id/channels/:channelID retrieve a particular config channel
// POST /configs/:id/channels/ add a new channel
// DELETE /configs/:id/channels/:channelID remove an channel
r.Methods("POST").Path("/api/configs/").Handler(httptransport.NewServer(
ctx,
e.PostConfigEndpoint,
decodePostConfigRequest,
encodeResponse,
options...,
))
r.Methods("GET").Path("/api/configs/{id}").Handler(httptransport.NewServer(
ctx,
e.GetConfigEndpoint,
decodeGetConfigRequest,
encodeResponse,
options...,
))
r.Methods("PUT").Path("/api/configs/{id}").Handler(httptransport.NewServer(
ctx,
e.PutConfigEndpoint,
decodePutConfigRequest,
encodeResponse,
options...,
))
r.Methods("PATCH").Path("/api/configs/{id}").Handler(httptransport.NewServer(
ctx,
e.PatchConfigEndpoint,
decodePatchConfigRequest,
encodeResponse,
options...,
))
r.Methods("DELETE").Path("/api/configs/{id}").Handler(httptransport.NewServer(
ctx,
e.DeleteConfigEndpoint,
decodeDeleteConfigRequest,
encodeResponse,
options...,
))
r.Methods("GET").Path("/api/configs/{id}/channels/").Handler(httptransport.NewServer(
ctx,
e.GetChannelsEndpoint,
decodeGetChannelsRequest,
encodeResponse,
options...,
))
r.Methods("GET").Path("/api/configs/{id}/channels/{channelID}").Handler(httptransport.NewServer(
ctx,
e.GetChannelEndpoint,
decodeGetChannelRequest,
encodeResponse,
options...,
))
r.Methods("POST").Path("/api/configs/{id}/channels/").Handler(httptransport.NewServer(
ctx,
e.PostChannelEndpoint,
decodePostChannelRequest,
encodeResponse,
options...,
))
r.Methods("DELETE").Path("/api/configs/{id}/channels/{channelID}").Handler(httptransport.NewServer(
ctx,
e.DeleteChannelEndpoint,
decodeDeleteChannelRequest,
encodeResponse,
options...,
))
// Convenience routes to help consumers nesting limitations
r.Methods("GET").Path("/api/channels/{channelID}/notes/").Handler(httptransport.NewServer(
ctx,
e.GetNotesEndpoint,
decodeGetNotesRequest,
encodeResponse,
options...,
))
r.Methods("GET").Path("/api/channels/{channelID}").Handler(httptransport.NewServer(
ctx,
e.GetChannelEndpoint,
decodeGetChannelRequest,
encodeResponse,
options...,
))
return r
}
func makeHandler(ctx context.Context, s ProfileService, logger kitlog.Logger) stdhttp.Handler {
e := makeEndpoints(s)
r := mux.NewRouter()
commonOptions := []kithttp.ServerOption{
kithttp.ServerErrorLogger(logger),
kithttp.ServerErrorEncoder(encodeError),
}
// POST /profiles adds another profile
// GET /profiles/:id retrieves the given profile by id
// PUT /profiles/:id post updated profile information about the profile
// PATCH /profiles/:id partial updated profile information
// DELETE /profiles/:id remove the given profile
// GET /profiles/:id/addresses retrieve addresses associated with the profile
// GET /profiles/:id/addresses/:addressID retrieve a particular profile address
// POST /profiles/:id/addresses add a new address
// DELETE /profiles/:id/addresses/:addressID remove an address
r.Methods("POST").Path("/profiles/").Handler(kithttp.NewServer(
ctx,
e.postProfileEndpoint,
decodePostProfileRequest,
encodeResponse,
commonOptions...,
))
r.Methods("GET").Path("/profiles/{id}").Handler(kithttp.NewServer(
ctx,
e.getProfileEndpoint,
decodeGetProfileRequest,
encodeResponse,
commonOptions...,
))
r.Methods("PUT").Path("/profiles/{id}").Handler(kithttp.NewServer(
ctx,
e.putProfileEndpoint,
decodePutProfileRequest,
encodeResponse,
commonOptions...,
))
r.Methods("PATCH").Path("/profiles/{id}").Handler(kithttp.NewServer(
ctx,
e.patchProfileEndpoint,
decodePatchProfileRequest,
encodeResponse,
commonOptions...,
))
r.Methods("DELETE").Path("/profiles/{id}").Handler(kithttp.NewServer(
ctx,
e.deleteProfileEndpoint,
decodeDeleteProfileRequest,
encodeResponse,
commonOptions...,
))
r.Methods("GET").Path("/profiles/{id}/addresses/").Handler(kithttp.NewServer(
ctx,
e.getAddressesEndpoint,
decodeGetAddressesRequest,
encodeResponse,
commonOptions...,
))
r.Methods("GET").Path("/profiles/{id}/addresses/{addressID}").Handler(kithttp.NewServer(
ctx,
e.getAddressEndpoint,
decodeGetAddressRequest,
encodeResponse,
commonOptions...,
))
r.Methods("POST").Path("/profiles/{id}/addresses/").Handler(kithttp.NewServer(
ctx,
e.postAddressEndpoint,
decodePostAddressRequest,
encodeResponse,
commonOptions...,
))
r.Methods("DELETE").Path("/profiles/{id}/addresses/{addressID}").Handler(kithttp.NewServer(
ctx,
e.deleteAddressEndpoint,
decodeDeleteAddressRequest,
encodeResponse,
commonOptions...,
))
return r
}
func main() {
port := os.Getenv("PORT")
pgURI := os.Getenv("DATABASE_URL")
if port == "" {
port = "8080"
}
fmt.Printf("Connecting to %s\n", pgURI)
pg, err := sql.Open("postgres", pgURI)
if err != nil {
panic(err)
}
router := mux.NewRouter()
ctx := context.Background()
svc := gledger.NewAccountService(
db.SaveAccount(pg.Exec),
db.AllAccounts(pg.Query),
db.ReadAccount(pg.QueryRow),
)
txnSvc := gledger.NewTransactionService(
db.SaveTransaction(pg),
db.TransactionsForAccount(pg),
)
envSvc := gledger.NewEnvelopeService(
db.SaveEnvelope(pg.Exec),
db.AllEnvelopes(pg.Query),
)
httpOptions := []httptransport.ServerOption{httptransport.ServerErrorEncoder(errorEncoder)}
router.HandleFunc(
"/accounts",
httptransport.NewServer(
ctx,
makeCreateAccountEndpoint(svc),
decodeCreateAccountRequest,
created(encodeResponse),
httpOptions...,
).ServeHTTP,
).Methods("POST")
router.HandleFunc(
"/accounts",
httptransport.NewServer(
ctx,
makeAllAccountsEndpoint(svc),
emptyRequest,
encodeResponse,
httpOptions...,
).ServeHTTP,
).Methods("GET")
router.HandleFunc(
"/accounts/{uuid}",
httptransport.NewServer(
ctx,
makeReadAccountEndpoint(svc),
decodeReadAccountRequest,
encodeResponse,
httpOptions...,
).ServeHTTP,
).Methods("GET")
router.HandleFunc(
"/transactions",
httptransport.NewServer(
ctx,
makeCreateTransactionEndpoint(txnSvc),
decodeCreateTransactionRequest,
created(encodeResponse),
httpOptions...,
).ServeHTTP,
).Methods("POST")
router.HandleFunc(
"/accounts/{uuid}/transactions",
httptransport.NewServer(
ctx,
makeReadAccountTransactionsEndpoint(txnSvc),
decodeReadAccountTransactionsRequest,
encodeResponse,
httpOptions...,
).ServeHTTP,
).Methods("GET")
router.HandleFunc(
"/envelopes",
httptransport.NewServer(
ctx,
makeCreateEnvelopeEndpoint(envSvc),
decodeCreateEnvelopeRequest,
created(encodeResponse),
httpOptions...,
).ServeHTTP,
).Methods("POST")
router.HandleFunc(
"/envelopes",
httptransport.NewServer(
ctx,
makeAllEnvelopesEndpoint(envSvc),
emptyRequest,
encodeResponse,
httpOptions...,
).ServeHTTP,
).Methods("GET")
handler := cors.New(cors.Options{
AllowedOrigins: []string{"http://localhost:4200", "https://gledger-web.herokuapp.com"},
}).Handler(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
start := time.Now()
router.ServeHTTP(res, req)
end := time.Now()
log.Printf("%s %s %s\n", req.Method, req.URL, end.Sub(start))
}))
log.Fatal(http.ListenAndServe(":"+port, handler))
}
// MakeHandler returns a handler for the booking service.
func MakeHandler(ctx context.Context, bs Service, logger kitlog.Logger) http.Handler {
opts := []kithttp.ServerOption{
kithttp.ServerErrorLogger(logger),
kithttp.ServerErrorEncoder(encodeError),
}
bookCargoHandler := kithttp.NewServer(
ctx,
makeBookCargoEndpoint(bs),
decodeBookCargoRequest,
encodeResponse,
opts...,
)
loadCargoHandler := kithttp.NewServer(
ctx,
makeLoadCargoEndpoint(bs),
decodeLoadCargoRequest,
encodeResponse,
opts...,
)
requestRoutesHandler := kithttp.NewServer(
ctx,
makeRequestRoutesEndpoint(bs),
decodeRequestRoutesRequest,
encodeResponse,
opts...,
)
assignToRouteHandler := kithttp.NewServer(
ctx,
makeAssignToRouteEndpoint(bs),
decodeAssignToRouteRequest,
encodeResponse,
opts...,
)
changeDestinationHandler := kithttp.NewServer(
ctx,
makeChangeDestinationEndpoint(bs),
decodeChangeDestinationRequest,
encodeResponse,
opts...,
)
listCargosHandler := kithttp.NewServer(
ctx,
makeListCargosEndpoint(bs),
decodeListCargosRequest,
encodeResponse,
opts...,
)
listLocationsHandler := kithttp.NewServer(
ctx,
makeListLocationsEndpoint(bs),
decodeListLocationsRequest,
encodeResponse,
opts...,
)
r := mux.NewRouter()
r.Handle("/booking/v1/cargos", bookCargoHandler).Methods("POST")
r.Handle("/booking/v1/cargos", listCargosHandler).Methods("GET")
r.Handle("/booking/v1/cargos/{id}", loadCargoHandler).Methods("GET")
r.Handle("/booking/v1/cargos/{id}/request_routes", requestRoutesHandler).Methods("GET")
r.Handle("/booking/v1/cargos/{id}/assign_to_route", assignToRouteHandler).Methods("POST")
r.Handle("/booking/v1/cargos/{id}/change_destination", changeDestinationHandler).Methods("POST")
r.Handle("/booking/v1/locations", listLocationsHandler).Methods("GET")
r.Handle("/booking/v1/docs", http.StripPrefix("/booking/v1/docs", http.FileServer(http.Dir("booking/docs"))))
return r
}
func NewApi(ng engine.Engine) *Api {
api := &Api{router: NewRouter(), ng: ng}
api.router.NotFoundHandler(http.HandlerFunc(api.notFoundHandler))
api.router.AddHandler(RouterArguments{Path: "/", Methods: []string{"GET"}, Handler: homeHandler})
ctx := context.Background()
ffs := features.New(api.ng)
createHandler := httptransport.NewServer(
ctx,
CreateEndpoint(ffs),
decodeFeatureFlagRequest,
encodeResponse,
httptransport.ServerErrorEncoder(handleErrorEncoder),
)
api.router.AddHandler(RouterArguments{Path: "/features", Methods: []string{"POST"}, HandlerNormal: createHandler})
updateHandler := httptransport.NewServer(
ctx,
UpdateEndpoint(ffs),
decodeFeatureFlagRequest,
encodeResponse,
httptransport.ServerErrorEncoder(handleErrorEncoder),
)
api.router.AddHandler(RouterArguments{Path: "/features/{feature_key}", Methods: []string{"PUT"}, HandlerNormal: updateHandler})
deleteHandler := httptransport.NewServer(
ctx,
DeleteEndpoint(ffs),
decodeFeatureFlagQueryString,
encodeResponse,
httptransport.ServerErrorEncoder(handleErrorEncoder),
)
api.router.AddHandler(RouterArguments{Path: "/features/{feature_key}", Methods: []string{"DELETE"}, HandlerNormal: deleteHandler})
findHandler := httptransport.NewServer(
ctx,
FindEndpoint(ffs),
decodeFeatureFlagQueryString,
encodeResponse,
httptransport.ServerErrorEncoder(handleErrorEncoder),
)
api.router.AddHandler(RouterArguments{Path: "/features/{feature_key}", Methods: []string{"GET"}, HandlerNormal: findHandler})
listHandler := httptransport.NewServer(
ctx,
ListEndpoint(ffs),
decodeFeatureFlagQueryString,
encodeResponse,
httptransport.ServerErrorEncoder(handleErrorEncoder),
)
api.router.AddHandler(RouterArguments{Path: "/features", Methods: []string{"GET"}, HandlerNormal: listHandler})
validateHandler := httptransport.NewServer(
ctx,
ValidateEndpoint(ffs),
decodeValidationRequest,
encodeResponse,
httptransport.ServerErrorEncoder(handleErrorEncoder),
)
api.router.AddHandler(RouterArguments{Path: "/features", Methods: []string{"PUT"}, HandlerNormal: validateHandler})
return api
}
// MakeHTTPHandler mounts all of the service endpoints into an http.Handler.
// Useful in a profilesvc server.
func MakeHTTPHandler(ctx context.Context, s Service, logger log.Logger) http.Handler {
r := mux.NewRouter()
e := MakeServerEndpoints(s)
options := []httptransport.ServerOption{
httptransport.ServerErrorLogger(logger),
httptransport.ServerErrorEncoder(encodeError),
}
// POST /profiles/ adds another profile
// GET /profiles/:id retrieves the given profile by id
// PUT /profiles/:id post updated profile information about the profile
// PATCH /profiles/:id partial updated profile information
// DELETE /profiles/:id remove the given profile
// GET /profiles/:id/addresses/ retrieve addresses associated with the profile
// GET /profiles/:id/addresses/:addressID retrieve a particular profile address
// POST /profiles/:id/addresses/ add a new address
// DELETE /profiles/:id/addresses/:addressID remove an address
r.Methods("POST").Path("/profiles/").Handler(httptransport.NewServer(
ctx,
e.PostProfileEndpoint,
decodePostProfileRequest,
encodeResponse,
options...,
))
r.Methods("GET").Path("/profiles/{id}").Handler(httptransport.NewServer(
ctx,
e.GetProfileEndpoint,
decodeGetProfileRequest,
encodeResponse,
options...,
))
r.Methods("PUT").Path("/profiles/{id}").Handler(httptransport.NewServer(
ctx,
e.PutProfileEndpoint,
decodePutProfileRequest,
encodeResponse,
options...,
))
r.Methods("PATCH").Path("/profiles/{id}").Handler(httptransport.NewServer(
ctx,
e.PatchProfileEndpoint,
decodePatchProfileRequest,
encodeResponse,
options...,
))
r.Methods("DELETE").Path("/profiles/{id}").Handler(httptransport.NewServer(
ctx,
e.DeleteProfileEndpoint,
decodeDeleteProfileRequest,
encodeResponse,
options...,
))
r.Methods("GET").Path("/profiles/{id}/addresses/").Handler(httptransport.NewServer(
ctx,
e.GetAddressesEndpoint,
decodeGetAddressesRequest,
encodeResponse,
options...,
))
r.Methods("GET").Path("/profiles/{id}/addresses/{addressID}").Handler(httptransport.NewServer(
ctx,
e.GetAddressEndpoint,
decodeGetAddressRequest,
encodeResponse,
options...,
))
r.Methods("POST").Path("/profiles/{id}/addresses/").Handler(httptransport.NewServer(
ctx,
e.PostAddressEndpoint,
decodePostAddressRequest,
encodeResponse,
options...,
))
r.Methods("DELETE").Path("/profiles/{id}/addresses/{addressID}").Handler(httptransport.NewServer(
ctx,
e.DeleteAddressEndpoint,
decodeDeleteAddressRequest,
encodeResponse,
options...,
))
return r
}