src

Go monorepo.
git clone git://code.dwrz.net/src
Log | Files | Refs

serializers.go (10305B)

      1 // Code generated by smithy-go-codegen DO NOT EDIT.
      2 
      3 package sso
      4 
      5 import (
      6 	"context"
      7 	"fmt"
      8 
      9 	smithy "github.com/aws/smithy-go"
     10 	"github.com/aws/smithy-go/encoding/httpbinding"
     11 	"github.com/aws/smithy-go/middleware"
     12 	"github.com/aws/smithy-go/tracing"
     13 	smithyhttp "github.com/aws/smithy-go/transport/http"
     14 )
     15 
     16 type awsRestjson1_serializeOpGetRoleCredentials struct {
     17 }
     18 
     19 func (*awsRestjson1_serializeOpGetRoleCredentials) ID() string {
     20 	return "OperationSerializer"
     21 }
     22 
     23 func (m *awsRestjson1_serializeOpGetRoleCredentials) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
     24 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
     25 ) {
     26 	_, span := tracing.StartSpan(ctx, "OperationSerializer")
     27 	endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
     28 	defer endTimer()
     29 	defer span.End()
     30 	request, ok := in.Request.(*smithyhttp.Request)
     31 	if !ok {
     32 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
     33 	}
     34 
     35 	input, ok := in.Parameters.(*GetRoleCredentialsInput)
     36 	_ = input
     37 	if !ok {
     38 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
     39 	}
     40 
     41 	opPath, opQuery := httpbinding.SplitURI("/federation/credentials")
     42 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
     43 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
     44 	request.Method = "GET"
     45 	var restEncoder *httpbinding.Encoder
     46 	if request.URL.RawPath == "" {
     47 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
     48 	} else {
     49 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
     50 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
     51 	}
     52 
     53 	if err != nil {
     54 		return out, metadata, &smithy.SerializationError{Err: err}
     55 	}
     56 
     57 	if err := awsRestjson1_serializeOpHttpBindingsGetRoleCredentialsInput(input, restEncoder); err != nil {
     58 		return out, metadata, &smithy.SerializationError{Err: err}
     59 	}
     60 
     61 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
     62 		return out, metadata, &smithy.SerializationError{Err: err}
     63 	}
     64 	in.Request = request
     65 
     66 	endTimer()
     67 	span.End()
     68 	return next.HandleSerialize(ctx, in)
     69 }
     70 func awsRestjson1_serializeOpHttpBindingsGetRoleCredentialsInput(v *GetRoleCredentialsInput, encoder *httpbinding.Encoder) error {
     71 	if v == nil {
     72 		return fmt.Errorf("unsupported serialization of nil %T", v)
     73 	}
     74 
     75 	if v.AccessToken != nil {
     76 		locationName := "X-Amz-Sso_bearer_token"
     77 		encoder.SetHeader(locationName).String(*v.AccessToken)
     78 	}
     79 
     80 	if v.AccountId != nil {
     81 		encoder.SetQuery("account_id").String(*v.AccountId)
     82 	}
     83 
     84 	if v.RoleName != nil {
     85 		encoder.SetQuery("role_name").String(*v.RoleName)
     86 	}
     87 
     88 	return nil
     89 }
     90 
     91 type awsRestjson1_serializeOpListAccountRoles struct {
     92 }
     93 
     94 func (*awsRestjson1_serializeOpListAccountRoles) ID() string {
     95 	return "OperationSerializer"
     96 }
     97 
     98 func (m *awsRestjson1_serializeOpListAccountRoles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
     99 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    100 ) {
    101 	_, span := tracing.StartSpan(ctx, "OperationSerializer")
    102 	endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
    103 	defer endTimer()
    104 	defer span.End()
    105 	request, ok := in.Request.(*smithyhttp.Request)
    106 	if !ok {
    107 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    108 	}
    109 
    110 	input, ok := in.Parameters.(*ListAccountRolesInput)
    111 	_ = input
    112 	if !ok {
    113 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    114 	}
    115 
    116 	opPath, opQuery := httpbinding.SplitURI("/assignment/roles")
    117 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    118 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    119 	request.Method = "GET"
    120 	var restEncoder *httpbinding.Encoder
    121 	if request.URL.RawPath == "" {
    122 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    123 	} else {
    124 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    125 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    126 	}
    127 
    128 	if err != nil {
    129 		return out, metadata, &smithy.SerializationError{Err: err}
    130 	}
    131 
    132 	if err := awsRestjson1_serializeOpHttpBindingsListAccountRolesInput(input, restEncoder); err != nil {
    133 		return out, metadata, &smithy.SerializationError{Err: err}
    134 	}
    135 
    136 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    137 		return out, metadata, &smithy.SerializationError{Err: err}
    138 	}
    139 	in.Request = request
    140 
    141 	endTimer()
    142 	span.End()
    143 	return next.HandleSerialize(ctx, in)
    144 }
    145 func awsRestjson1_serializeOpHttpBindingsListAccountRolesInput(v *ListAccountRolesInput, encoder *httpbinding.Encoder) error {
    146 	if v == nil {
    147 		return fmt.Errorf("unsupported serialization of nil %T", v)
    148 	}
    149 
    150 	if v.AccessToken != nil {
    151 		locationName := "X-Amz-Sso_bearer_token"
    152 		encoder.SetHeader(locationName).String(*v.AccessToken)
    153 	}
    154 
    155 	if v.AccountId != nil {
    156 		encoder.SetQuery("account_id").String(*v.AccountId)
    157 	}
    158 
    159 	if v.MaxResults != nil {
    160 		encoder.SetQuery("max_result").Integer(*v.MaxResults)
    161 	}
    162 
    163 	if v.NextToken != nil {
    164 		encoder.SetQuery("next_token").String(*v.NextToken)
    165 	}
    166 
    167 	return nil
    168 }
    169 
    170 type awsRestjson1_serializeOpListAccounts struct {
    171 }
    172 
    173 func (*awsRestjson1_serializeOpListAccounts) ID() string {
    174 	return "OperationSerializer"
    175 }
    176 
    177 func (m *awsRestjson1_serializeOpListAccounts) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    178 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    179 ) {
    180 	_, span := tracing.StartSpan(ctx, "OperationSerializer")
    181 	endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
    182 	defer endTimer()
    183 	defer span.End()
    184 	request, ok := in.Request.(*smithyhttp.Request)
    185 	if !ok {
    186 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    187 	}
    188 
    189 	input, ok := in.Parameters.(*ListAccountsInput)
    190 	_ = input
    191 	if !ok {
    192 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    193 	}
    194 
    195 	opPath, opQuery := httpbinding.SplitURI("/assignment/accounts")
    196 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    197 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    198 	request.Method = "GET"
    199 	var restEncoder *httpbinding.Encoder
    200 	if request.URL.RawPath == "" {
    201 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    202 	} else {
    203 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    204 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    205 	}
    206 
    207 	if err != nil {
    208 		return out, metadata, &smithy.SerializationError{Err: err}
    209 	}
    210 
    211 	if err := awsRestjson1_serializeOpHttpBindingsListAccountsInput(input, restEncoder); err != nil {
    212 		return out, metadata, &smithy.SerializationError{Err: err}
    213 	}
    214 
    215 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    216 		return out, metadata, &smithy.SerializationError{Err: err}
    217 	}
    218 	in.Request = request
    219 
    220 	endTimer()
    221 	span.End()
    222 	return next.HandleSerialize(ctx, in)
    223 }
    224 func awsRestjson1_serializeOpHttpBindingsListAccountsInput(v *ListAccountsInput, encoder *httpbinding.Encoder) error {
    225 	if v == nil {
    226 		return fmt.Errorf("unsupported serialization of nil %T", v)
    227 	}
    228 
    229 	if v.AccessToken != nil {
    230 		locationName := "X-Amz-Sso_bearer_token"
    231 		encoder.SetHeader(locationName).String(*v.AccessToken)
    232 	}
    233 
    234 	if v.MaxResults != nil {
    235 		encoder.SetQuery("max_result").Integer(*v.MaxResults)
    236 	}
    237 
    238 	if v.NextToken != nil {
    239 		encoder.SetQuery("next_token").String(*v.NextToken)
    240 	}
    241 
    242 	return nil
    243 }
    244 
    245 type awsRestjson1_serializeOpLogout struct {
    246 }
    247 
    248 func (*awsRestjson1_serializeOpLogout) ID() string {
    249 	return "OperationSerializer"
    250 }
    251 
    252 func (m *awsRestjson1_serializeOpLogout) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
    253 	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
    254 ) {
    255 	_, span := tracing.StartSpan(ctx, "OperationSerializer")
    256 	endTimer := startMetricTimer(ctx, "client.call.serialization_duration")
    257 	defer endTimer()
    258 	defer span.End()
    259 	request, ok := in.Request.(*smithyhttp.Request)
    260 	if !ok {
    261 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
    262 	}
    263 
    264 	input, ok := in.Parameters.(*LogoutInput)
    265 	_ = input
    266 	if !ok {
    267 		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
    268 	}
    269 
    270 	opPath, opQuery := httpbinding.SplitURI("/logout")
    271 	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
    272 	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
    273 	request.Method = "POST"
    274 	var restEncoder *httpbinding.Encoder
    275 	if request.URL.RawPath == "" {
    276 		restEncoder, err = httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
    277 	} else {
    278 		request.URL.RawPath = smithyhttp.JoinPath(request.URL.RawPath, opPath)
    279 		restEncoder, err = httpbinding.NewEncoderWithRawPath(request.URL.Path, request.URL.RawPath, request.URL.RawQuery, request.Header)
    280 	}
    281 
    282 	if err != nil {
    283 		return out, metadata, &smithy.SerializationError{Err: err}
    284 	}
    285 
    286 	if err := awsRestjson1_serializeOpHttpBindingsLogoutInput(input, restEncoder); err != nil {
    287 		return out, metadata, &smithy.SerializationError{Err: err}
    288 	}
    289 
    290 	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
    291 		return out, metadata, &smithy.SerializationError{Err: err}
    292 	}
    293 	in.Request = request
    294 
    295 	endTimer()
    296 	span.End()
    297 	return next.HandleSerialize(ctx, in)
    298 }
    299 func awsRestjson1_serializeOpHttpBindingsLogoutInput(v *LogoutInput, encoder *httpbinding.Encoder) error {
    300 	if v == nil {
    301 		return fmt.Errorf("unsupported serialization of nil %T", v)
    302 	}
    303 
    304 	if v.AccessToken != nil {
    305 		locationName := "X-Amz-Sso_bearer_token"
    306 		encoder.SetHeader(locationName).String(*v.AccessToken)
    307 	}
    308 
    309 	return nil
    310 }