servicehandler.go

// Code generated by sysl DO NOT EDIT.
package simple

import (
	"encoding/json"
	"net/http"

	"github.com/anz-bank/sysl-go/codegen/tests/deps"
	"github.com/anz-bank/sysl-go/codegen/tests/downstream"
	"github.com/anz-bank/sysl-go/common"
	"github.com/anz-bank/sysl-go/convert"
	"github.com/anz-bank/sysl-go/core"
	"github.com/anz-bank/sysl-go/restlib"
	"github.com/anz-bank/sysl-go/validator"
)

// *BusinessLogicError error
var BusinessLogicError common.CustomError = map[string]string{"name": "BusinessLogicError", "http_code": "1001", "http_message": "foo", "http_status": "500"} // *BusinessLogicError2 error
var BusinessLogicError2 common.CustomError = map[string]string{"name": "BusinessLogicError2", "http_code": "1002", "http_message": "foo2", "http_status": "501"}

// Handler interface for Simple
type Handler interface {
	GetApiDocsListHandler(w http.ResponseWriter, r *http.Request)
	GetGetSomeBytesListHandler(w http.ResponseWriter, r *http.Request)
	GetJustOkAndJustErrorListHandler(w http.ResponseWriter, r *http.Request)
	GetJustReturnErrorListHandler(w http.ResponseWriter, r *http.Request)
	GetJustReturnOkListHandler(w http.ResponseWriter, r *http.Request)
	GetOkTypeAndJustErrorListHandler(w http.ResponseWriter, r *http.Request)
	GetOopsListHandler(w http.ResponseWriter, r *http.Request)
	GetPetaListHandler(w http.ResponseWriter, r *http.Request)
	GetRawListHandler(w http.ResponseWriter, r *http.Request)
	GetRawIntListHandler(w http.ResponseWriter, r *http.Request)
	GetRawStatesListHandler(w http.ResponseWriter, r *http.Request)
	GetRawIdStatesListHandler(w http.ResponseWriter, r *http.Request)
	GetRawStates2ListHandler(w http.ResponseWriter, r *http.Request)
	GetSimpleAPIDocsListHandler(w http.ResponseWriter, r *http.Request)
	GetStuffListHandler(w http.ResponseWriter, r *http.Request)
	PostStuffHandler(w http.ResponseWriter, r *http.Request)
}

// ServiceHandler for Simple API
type ServiceHandler struct {
	genCallback                 core.RestGenCallback
	serviceInterface            *ServiceInterface
	depsDepsService             deps.Service
	downstreamDownstreamService downstream.Service
}

// NewServiceHandler for Simple
func NewServiceHandler(genCallback core.RestGenCallback, serviceInterface *ServiceInterface, depsDepsService deps.Service, downstreamDownstreamService downstream.Service) *ServiceHandler {
	return &ServiceHandler{genCallback, serviceInterface, depsDepsService, downstreamDownstreamService}
}

// GetApiDocsListHandler ...
func (s *ServiceHandler) GetApiDocsListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetApiDocsList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetApiDocsListRequest

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetApiDocsListClient{
		GetApiDocsList:     s.depsDepsService.GetApiDocsList,
		GetServiceDocsList: s.downstreamDownstreamService.GetServiceDocsList,
	}

	apidoc, err := s.serviceInterface.GetApiDocsList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, apidoc)
}

// GetGetSomeBytesListHandler ...
func (s *ServiceHandler) GetGetSomeBytesListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetGetSomeBytesList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetGetSomeBytesListRequest

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetGetSomeBytesListClient{}

	pdf, err := s.serviceInterface.GetGetSomeBytesList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, (*[]byte)(pdf))
}

// GetJustOkAndJustErrorListHandler ...
func (s *ServiceHandler) GetJustOkAndJustErrorListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetJustOkAndJustErrorList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetJustOkAndJustErrorListRequest

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetJustOkAndJustErrorListClient{}

	err := s.serviceInterface.GetJustOkAndJustErrorList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, nil)
}

// GetJustReturnErrorListHandler ...
func (s *ServiceHandler) GetJustReturnErrorListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetJustReturnErrorList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetJustReturnErrorListRequest

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetJustReturnErrorListClient{}

	err := s.serviceInterface.GetJustReturnErrorList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, nil)
}

// GetJustReturnOkListHandler ...
func (s *ServiceHandler) GetJustReturnOkListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetJustReturnOkList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetJustReturnOkListRequest

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetJustReturnOkListClient{}

	err := s.serviceInterface.GetJustReturnOkList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, nil)
}

// GetOkTypeAndJustErrorListHandler ...
func (s *ServiceHandler) GetOkTypeAndJustErrorListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetOkTypeAndJustErrorList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetOkTypeAndJustErrorListRequest

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetOkTypeAndJustErrorListClient{}

	response, err := s.serviceInterface.GetOkTypeAndJustErrorList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, response)
}

// GetOopsListHandler ...
func (s *ServiceHandler) GetOopsListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetOopsList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetOopsListRequest

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetOopsListClient{}

	response, err := s.serviceInterface.GetOopsList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, response)
}

// GetPetaListHandler ...
func (s *ServiceHandler) GetPetaListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetPetaList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetPetaListRequest

	req.ID = restlib.GetQueryParam(r, "id")

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetPetaListClient{}

	peta, err := s.serviceInterface.GetPetaList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, peta)
}

// GetRawListHandler ...
func (s *ServiceHandler) GetRawListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetRawList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetRawListRequest

	var convBoolErr error
	req.Bt, convBoolErr = restlib.GetQueryParamForBool(r, "bt")
	if convBoolErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", convBoolErr, s.genCallback.MapError)
		return
	}

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetRawListClient{}

	str, err := s.serviceInterface.GetRawList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, str)
}

// GetRawIntListHandler ...
func (s *ServiceHandler) GetRawIntListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetRawIntList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetRawIntListRequest

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetRawIntListClient{}

	integer, err := s.serviceInterface.GetRawIntList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, integer)
}

// GetRawStatesListHandler ...
func (s *ServiceHandler) GetRawStatesListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetRawStatesList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetRawStatesListRequest

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetRawStatesListClient{}

	status, err := s.serviceInterface.GetRawStatesList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, status)
}

// GetRawIdStatesListHandler ...
func (s *ServiceHandler) GetRawIdStatesListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetRawIdStatesList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetRawIdStatesListRequest

	req.ID = restlib.GetURLParam(r, "id")

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetRawIdStatesListClient{}

	str, err := s.serviceInterface.GetRawIdStatesList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, str)
}

// GetRawStates2ListHandler ...
func (s *ServiceHandler) GetRawStates2ListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetRawStates2List == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetRawStates2ListRequest
	req.ID = restlib.GetURLParamForInt(r, "id")

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetRawStates2ListClient{}

	str, err := s.serviceInterface.GetRawStates2List(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, str)
}

// GetSimpleAPIDocsListHandler ...
func (s *ServiceHandler) GetSimpleAPIDocsListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetSimpleAPIDocsList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetSimpleAPIDocsListRequest

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetSimpleAPIDocsListClient{
		GetApiDocsList: s.depsDepsService.GetApiDocsList,
		GetSuccessList: s.depsDepsService.GetSuccessList,
	}

	apidoc, err := s.serviceInterface.GetSimpleAPIDocsList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, apidoc)
}

// GetStuffListHandler ...
func (s *ServiceHandler) GetStuffListHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.GetStuffList == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req GetStuffListRequest

	var convIntErr error
	req.It, convIntErr = restlib.GetQueryParamForInt(r, "it")
	if convIntErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", convIntErr, s.genCallback.MapError)
		return
	}

	var DtParam string

	var StParam string

	var BtParam string

	var convErr error
	DtParam = restlib.GetQueryParam(r, "dt")
	StParam = restlib.GetQueryParam(r, "st")
	BtParam = restlib.GetQueryParam(r, "bt")
	req.Dt, convErr = convert.StringToTimePtr(ctx, DtParam)
	if convErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", convErr, s.genCallback.MapError)
		return
	}
	req.St, convErr = convert.StringToStringPtr(ctx, StParam)
	if convErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", convErr, s.genCallback.MapError)
		return
	}
	req.Bt, convErr = convert.StringToBoolPtr(ctx, BtParam)
	if convErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", convErr, s.genCallback.MapError)
		return
	}

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := GetStuffListClient{}

	stuff, err := s.serviceInterface.GetStuffList(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, stuff)
}

// PostStuffHandler ...
func (s *ServiceHandler) PostStuffHandler(w http.ResponseWriter, r *http.Request) {
	if s.serviceInterface.PostStuff == nil {
		common.HandleError(r.Context(), w, common.InternalError, "not implemented", nil, s.genCallback.MapError)
		return
	}

	ctx := common.RequestHeaderToContext(r.Context(), r.Header)
	ctx = common.RespHeaderAndStatusToContext(ctx, make(http.Header), http.StatusOK)
	var req PostStuffRequest
	decoder := json.NewDecoder(r.Body)
	decodeErr := decoder.Decode(&req.Request)
	if decodeErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Error reading request body", decodeErr, s.genCallback.MapError)
		return
	}

	ctx, cancel := s.genCallback.DownstreamTimeoutContext(ctx)
	defer cancel()
	valErr := validator.Validate(&req)
	if valErr != nil {
		common.HandleError(ctx, w, common.BadRequestError, "Invalid request", valErr, s.genCallback.MapError)
		return
	}

	client := PostStuffClient{}

	str, err := s.serviceInterface.PostStuff(ctx, &req, client)
	if err != nil {
		common.HandleError(ctx, w, common.DownstreamUnexpectedResponseError, "Downstream failure", err, s.genCallback.MapError)
		return
	}

	headermap, httpstatus := common.RespHeaderAndStatusFromContext(ctx)
	if headermap.Get("Content-Type") == "" {
		headermap.Set("Content-Type", "application/json")
	}
	restlib.SetHeaders(w, headermap)
	restlib.SendHTTPResponse(w, httpstatus, str)
}