func SerializeResponseMiddleware(registry kit.Registry, request kit.Request, response kit.Response) (kit.Response, bool) {
// Try to serialize the reponse data.
// Determine serializer.
serializer := registry.DefaultSerializer()
// Check if a custom serializer was specified.
if name := request.GetContext().String("response-serializer"); name != "" {
serializer = registry.Serializer(name)
if serializer == nil {
errResp := kit.NewErrorResponse("unknown_response_serializer", true)
data, _ := serializer.MustSerializeResponse(errResp)
errResp.SetData(data)
return errResp, false
}
}
// Set format in metadata.
meta := response.GetMeta()
if meta == nil {
meta = make(map[string]interface{})
}
meta["format"] = serializer.Name()
response.SetMeta(meta)
data, err := serializer.MustSerializeResponse(response)
if err != nil {
registry.Logger().Errorf("Response serialization error: %v (%+v)", err, response)
}
response.SetData(data)
return nil, false
}
func convertResponse(response kit.Response) *turnpike.CallResult {
result := &turnpike.CallResult{}
if response.GetError() != nil {
result.Err = turnpike.URI(response.GetError().GetCode())
}
result.Kwargs = map[string]interface{}{
"data": response.GetData(),
"meta": response.GetMeta(),
"errors": []error{response.GetError()},
}
return result
}
// SerializeResponse converts a response with model data into the target format.
func (s *Serializer) SerializeResponse(response kit.Response) (interface{}, apperror.Error) {
transData := response.GetTransferData()
if transData == nil {
transData = &kit.AppTransferData{}
data := response.GetData()
if model, ok := data.(kit.Model); ok {
transData.SetModels([]kit.Model{model})
} else if models, ok := data.([]kit.Model); ok {
transData.SetModels(models)
} else {
transData.SetData(data)
}
}
// Append response metadata.
if meta := response.GetMeta(); meta != nil {
transMeta := transData.GetMeta()
if transMeta != nil {
for key, val := range meta {
transMeta[key] = val
}
} else {
transData.SetMeta(meta)
}
}
// If a response error is defined, prepend it to all errors that might have been in
// TransferData.
if err := response.GetError(); err != nil {
oldErrs := transData.GetErrors()
transData.SetErrors(append([]apperror.Error{err}, oldErrs...))
}
data, err := s.SerializeTransferData(transData)
if err != nil {
return nil, err
}
return data, nil
}
