module SwaggerPetstore.API where
import SwaggerPetstore.Model as M
import SwaggerPetstore.MimeTypes
import SwaggerPetstore.Lens
import qualified Data.Aeson as A
import qualified Data.Time as TI
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as BL
import qualified Data.ByteString.Builder as BB
import qualified Data.ByteString.Char8 as BC
import qualified Data.ByteString.Lazy.Char8 as BCL
import qualified Network.HTTP.Client.MultipartFormData as NH
import qualified Network.HTTP.Media as ME
import qualified Network.HTTP.Types as NH
import qualified Web.HttpApiData as WH
import qualified Web.FormUrlEncoded as WH
import qualified Data.CaseInsensitive as CI
import qualified Data.Data as P (Typeable)
import qualified Data.Foldable as P
import qualified Data.Map as Map
import qualified Data.Set as Set
import qualified Data.Maybe as P
import qualified Data.Proxy as P (Proxy(..))
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Lazy.Encoding as TL
import qualified GHC.Base as P (Alternative)
import qualified Control.Arrow as P (left)
import qualified Lens.Micro as L
import Data.Monoid ((<>))
import Data.Function ((&))
import Data.Text (Text)
import GHC.Base ((<|>))
import Prelude ((==),(/=),($), (.),(<$>),(<*>),(>>=),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)
import qualified Prelude as P
testSpecialTags
:: (Consumes TestSpecialTags contentType, MimeRender contentType Client)
=> contentType
-> Client
-> SwaggerPetstoreRequest TestSpecialTags contentType Client
testSpecialTags _ body =
_mkRequest "PATCH" ["/another-fake/dummy"]
`setBodyParam` body
data TestSpecialTags
instance HasBodyParam TestSpecialTags Client
instance Consumes TestSpecialTags MimeJSON
instance Produces TestSpecialTags MimeJSON
fakeOuterBooleanSerialize
:: (Consumes FakeOuterBooleanSerialize contentType)
=> contentType
-> SwaggerPetstoreRequest FakeOuterBooleanSerialize contentType OuterBoolean
fakeOuterBooleanSerialize _ =
_mkRequest "POST" ["/fake/outer/boolean"]
data FakeOuterBooleanSerialize
instance HasBodyParam FakeOuterBooleanSerialize OuterBoolean
fakeOuterCompositeSerialize
:: (Consumes FakeOuterCompositeSerialize contentType)
=> contentType
-> SwaggerPetstoreRequest FakeOuterCompositeSerialize contentType OuterComposite
fakeOuterCompositeSerialize _ =
_mkRequest "POST" ["/fake/outer/composite"]
data FakeOuterCompositeSerialize
instance HasBodyParam FakeOuterCompositeSerialize OuterComposite
fakeOuterNumberSerialize
:: (Consumes FakeOuterNumberSerialize contentType)
=> contentType
-> SwaggerPetstoreRequest FakeOuterNumberSerialize contentType OuterNumber
fakeOuterNumberSerialize _ =
_mkRequest "POST" ["/fake/outer/number"]
data FakeOuterNumberSerialize
instance HasBodyParam FakeOuterNumberSerialize OuterNumber
fakeOuterStringSerialize
:: (Consumes FakeOuterStringSerialize contentType)
=> contentType
-> SwaggerPetstoreRequest FakeOuterStringSerialize contentType OuterString
fakeOuterStringSerialize _ =
_mkRequest "POST" ["/fake/outer/string"]
data FakeOuterStringSerialize
instance HasBodyParam FakeOuterStringSerialize OuterString
testClientModel
:: (Consumes TestClientModel contentType, MimeRender contentType Client)
=> contentType
-> Client
-> SwaggerPetstoreRequest TestClientModel contentType Client
testClientModel _ body =
_mkRequest "PATCH" ["/fake"]
`setBodyParam` body
data TestClientModel
instance HasBodyParam TestClientModel Client
instance Consumes TestClientModel MimeJSON
instance Produces TestClientModel MimeJSON
testEndpointParameters
:: (Consumes TestEndpointParameters contentType)
=> contentType
-> Double
-> Double
-> Text
-> ByteArray
-> SwaggerPetstoreRequest TestEndpointParameters contentType res
testEndpointParameters _ number double patternWithoutDelimiter byte =
_mkRequest "POST" ["/fake"]
`_addForm` toForm ("number", number)
`_addForm` toForm ("double", double)
`_addForm` toForm ("pattern_without_delimiter", patternWithoutDelimiter)
`_addForm` toForm ("byte", byte)
data TestEndpointParameters
instance HasOptionalParam TestEndpointParameters ParamInteger where
applyOptionalParam req (ParamInteger xs) =
req `_addForm` toForm ("integer", xs)
instance HasOptionalParam TestEndpointParameters Int32 where
applyOptionalParam req (Int32 xs) =
req `_addForm` toForm ("int32", xs)
instance HasOptionalParam TestEndpointParameters Int64 where
applyOptionalParam req (Int64 xs) =
req `_addForm` toForm ("int64", xs)
instance HasOptionalParam TestEndpointParameters ParamFloat where
applyOptionalParam req (ParamFloat xs) =
req `_addForm` toForm ("float", xs)
instance HasOptionalParam TestEndpointParameters ParamString where
applyOptionalParam req (ParamString xs) =
req `_addForm` toForm ("string", xs)
instance HasOptionalParam TestEndpointParameters ParamBinary where
applyOptionalParam req (ParamBinary xs) =
req `_addForm` toForm ("binary", xs)
instance HasOptionalParam TestEndpointParameters ParamDate where
applyOptionalParam req (ParamDate xs) =
req `_addForm` toForm ("date", xs)
instance HasOptionalParam TestEndpointParameters ParamDateTime where
applyOptionalParam req (ParamDateTime xs) =
req `_addForm` toForm ("dateTime", xs)
instance HasOptionalParam TestEndpointParameters Password where
applyOptionalParam req (Password xs) =
req `_addForm` toForm ("password", xs)
instance HasOptionalParam TestEndpointParameters Callback where
applyOptionalParam req (Callback xs) =
req `_addForm` toForm ("callback", xs)
instance Consumes TestEndpointParameters MimeXmlCharsetutf8
instance Consumes TestEndpointParameters MimeJsonCharsetutf8
instance Produces TestEndpointParameters MimeXmlCharsetutf8
instance Produces TestEndpointParameters MimeJsonCharsetutf8
testEnumParameters
:: (Consumes TestEnumParameters contentType)
=> contentType
-> SwaggerPetstoreRequest TestEnumParameters contentType res
testEnumParameters _ =
_mkRequest "GET" ["/fake"]
data TestEnumParameters
instance HasOptionalParam TestEnumParameters EnumFormStringArray where
applyOptionalParam req (EnumFormStringArray xs) =
req `_addForm` toFormColl CommaSeparated ("enum_form_string_array", xs)
instance HasOptionalParam TestEnumParameters EnumFormString where
applyOptionalParam req (EnumFormString xs) =
req `_addForm` toForm ("enum_form_string", xs)
instance HasOptionalParam TestEnumParameters EnumHeaderStringArray where
applyOptionalParam req (EnumHeaderStringArray xs) =
req `setHeader` toHeaderColl CommaSeparated ("enum_header_string_array", xs)
instance HasOptionalParam TestEnumParameters EnumHeaderString where
applyOptionalParam req (EnumHeaderString xs) =
req `setHeader` toHeader ("enum_header_string", xs)
instance HasOptionalParam TestEnumParameters EnumQueryStringArray where
applyOptionalParam req (EnumQueryStringArray xs) =
req `_setQuery` toQueryColl CommaSeparated ("enum_query_string_array", Just xs)
instance HasOptionalParam TestEnumParameters EnumQueryString where
applyOptionalParam req (EnumQueryString xs) =
req `_setQuery` toQuery ("enum_query_string", Just xs)
instance HasOptionalParam TestEnumParameters EnumQueryInteger where
applyOptionalParam req (EnumQueryInteger xs) =
req `_setQuery` toQuery ("enum_query_integer", Just xs)
instance HasOptionalParam TestEnumParameters EnumQueryDouble where
applyOptionalParam req (EnumQueryDouble xs) =
req `_addForm` toForm ("enum_query_double", xs)
instance Consumes TestEnumParameters MimeAny
instance Produces TestEnumParameters MimeAny
testJsonFormData
:: (Consumes TestJsonFormData contentType)
=> contentType
-> Text
-> Text
-> SwaggerPetstoreRequest TestJsonFormData contentType NoContent
testJsonFormData _ param param2 =
_mkRequest "GET" ["/fake/jsonFormData"]
`_addForm` toForm ("param", param)
`_addForm` toForm ("param2", param2)
data TestJsonFormData
instance Consumes TestJsonFormData MimeJSON
testClassname
:: (Consumes TestClassname contentType, MimeRender contentType Client)
=> contentType
-> Client
-> SwaggerPetstoreRequest TestClassname contentType Client
testClassname _ body =
_mkRequest "PATCH" ["/fake_classname_test"]
`setBodyParam` body
data TestClassname
instance HasBodyParam TestClassname Client
instance Consumes TestClassname MimeJSON
instance Produces TestClassname MimeJSON
addPet
:: (Consumes AddPet contentType, MimeRender contentType Pet)
=> contentType
-> Pet
-> SwaggerPetstoreRequest AddPet contentType res
addPet _ body =
_mkRequest "POST" ["/pet"]
`setBodyParam` body
data AddPet
instance HasBodyParam AddPet Pet
instance Consumes AddPet MimeJSON
instance Consumes AddPet MimeXML
instance Produces AddPet MimeXML
instance Produces AddPet MimeJSON
deletePet
:: Integer
-> SwaggerPetstoreRequest DeletePet MimeNoContent res
deletePet petId =
_mkRequest "DELETE" ["/pet/",toPath petId]
data DeletePet
instance HasOptionalParam DeletePet ApiKey where
applyOptionalParam req (ApiKey xs) =
req `setHeader` toHeader ("api_key", xs)
instance Produces DeletePet MimeXML
instance Produces DeletePet MimeJSON
findPetsByStatus
:: [Text]
-> SwaggerPetstoreRequest FindPetsByStatus MimeNoContent [Pet]
findPetsByStatus status =
_mkRequest "GET" ["/pet/findByStatus"]
`_setQuery` toQueryColl CommaSeparated ("status", Just status)
data FindPetsByStatus
instance Produces FindPetsByStatus MimeXML
instance Produces FindPetsByStatus MimeJSON
findPetsByTags
:: [Text]
-> SwaggerPetstoreRequest FindPetsByTags MimeNoContent [Pet]
findPetsByTags tags =
_mkRequest "GET" ["/pet/findByTags"]
`_setQuery` toQueryColl CommaSeparated ("tags", Just tags)
data FindPetsByTags
instance Produces FindPetsByTags MimeXML
instance Produces FindPetsByTags MimeJSON
getPetById
:: Integer
-> SwaggerPetstoreRequest GetPetById MimeNoContent Pet
getPetById petId =
_mkRequest "GET" ["/pet/",toPath petId]
data GetPetById
instance Produces GetPetById MimeXML
instance Produces GetPetById MimeJSON
updatePet
:: (Consumes UpdatePet contentType, MimeRender contentType Pet)
=> contentType
-> Pet
-> SwaggerPetstoreRequest UpdatePet contentType res
updatePet _ body =
_mkRequest "PUT" ["/pet"]
`setBodyParam` body
data UpdatePet
instance HasBodyParam UpdatePet Pet
instance Consumes UpdatePet MimeJSON
instance Consumes UpdatePet MimeXML
instance Produces UpdatePet MimeXML
instance Produces UpdatePet MimeJSON
updatePetWithForm
:: (Consumes UpdatePetWithForm contentType)
=> contentType
-> Integer
-> SwaggerPetstoreRequest UpdatePetWithForm contentType res
updatePetWithForm _ petId =
_mkRequest "POST" ["/pet/",toPath petId]
data UpdatePetWithForm
instance HasOptionalParam UpdatePetWithForm Name2 where
applyOptionalParam req (Name2 xs) =
req `_addForm` toForm ("name", xs)
instance HasOptionalParam UpdatePetWithForm Status where
applyOptionalParam req (Status xs) =
req `_addForm` toForm ("status", xs)
instance Consumes UpdatePetWithForm MimeFormUrlEncoded
instance Produces UpdatePetWithForm MimeXML
instance Produces UpdatePetWithForm MimeJSON
uploadFile
:: (Consumes UploadFile contentType)
=> contentType
-> Integer
-> SwaggerPetstoreRequest UploadFile contentType ApiResponse
uploadFile _ petId =
_mkRequest "POST" ["/pet/",toPath petId,"/uploadImage"]
data UploadFile
instance HasOptionalParam UploadFile AdditionalMetadata where
applyOptionalParam req (AdditionalMetadata xs) =
req `_addMultiFormPart` NH.partLBS "additionalMetadata" (mimeRender' MimeMultipartFormData xs)
instance HasOptionalParam UploadFile File where
applyOptionalParam req (File xs) =
req `_addMultiFormPart` NH.partFileSource "file" xs
instance Consumes UploadFile MimeMultipartFormData
instance Produces UploadFile MimeJSON
deleteOrder
:: Text
-> SwaggerPetstoreRequest DeleteOrder MimeNoContent res
deleteOrder orderId =
_mkRequest "DELETE" ["/store/order/",toPath orderId]
data DeleteOrder
instance Produces DeleteOrder MimeXML
instance Produces DeleteOrder MimeJSON
getInventory
:: SwaggerPetstoreRequest GetInventory MimeNoContent ((Map.Map String Int))
getInventory =
_mkRequest "GET" ["/store/inventory"]
data GetInventory
instance Produces GetInventory MimeJSON
getOrderById
:: Integer
-> SwaggerPetstoreRequest GetOrderById MimeNoContent Order
getOrderById orderId =
_mkRequest "GET" ["/store/order/",toPath orderId]
data GetOrderById
instance Produces GetOrderById MimeXML
instance Produces GetOrderById MimeJSON
placeOrder
:: (Consumes PlaceOrder contentType, MimeRender contentType Order)
=> contentType
-> Order
-> SwaggerPetstoreRequest PlaceOrder contentType Order
placeOrder _ body =
_mkRequest "POST" ["/store/order"]
`setBodyParam` body
data PlaceOrder
instance HasBodyParam PlaceOrder Order
instance Produces PlaceOrder MimeXML
instance Produces PlaceOrder MimeJSON
createUser
:: (Consumes CreateUser contentType, MimeRender contentType User)
=> contentType
-> User
-> SwaggerPetstoreRequest CreateUser contentType res
createUser _ body =
_mkRequest "POST" ["/user"]
`setBodyParam` body
data CreateUser
instance HasBodyParam CreateUser User
instance Produces CreateUser MimeXML
instance Produces CreateUser MimeJSON
createUsersWithArrayInput
:: (Consumes CreateUsersWithArrayInput contentType, MimeRender contentType [User])
=> contentType
-> [User]
-> SwaggerPetstoreRequest CreateUsersWithArrayInput contentType res
createUsersWithArrayInput _ body =
_mkRequest "POST" ["/user/createWithArray"]
`setBodyParam` body
data CreateUsersWithArrayInput
instance HasBodyParam CreateUsersWithArrayInput [User]
instance Produces CreateUsersWithArrayInput MimeXML
instance Produces CreateUsersWithArrayInput MimeJSON
createUsersWithListInput
:: (Consumes CreateUsersWithListInput contentType, MimeRender contentType [User])
=> contentType
-> [User]
-> SwaggerPetstoreRequest CreateUsersWithListInput contentType res
createUsersWithListInput _ body =
_mkRequest "POST" ["/user/createWithList"]
`setBodyParam` body
data CreateUsersWithListInput
instance HasBodyParam CreateUsersWithListInput [User]
instance Produces CreateUsersWithListInput MimeXML
instance Produces CreateUsersWithListInput MimeJSON
deleteUser
:: Text
-> SwaggerPetstoreRequest DeleteUser MimeNoContent res
deleteUser username =
_mkRequest "DELETE" ["/user/",toPath username]
data DeleteUser
instance Produces DeleteUser MimeXML
instance Produces DeleteUser MimeJSON
getUserByName
:: Text
-> SwaggerPetstoreRequest GetUserByName MimeNoContent User
getUserByName username =
_mkRequest "GET" ["/user/",toPath username]
data GetUserByName
instance Produces GetUserByName MimeXML
instance Produces GetUserByName MimeJSON
loginUser
:: Text
-> Text
-> SwaggerPetstoreRequest LoginUser MimeNoContent Text
loginUser username password =
_mkRequest "GET" ["/user/login"]
`_setQuery` toQuery ("username", Just username)
`_setQuery` toQuery ("password", Just password)
data LoginUser
instance Produces LoginUser MimeXML
instance Produces LoginUser MimeJSON
logoutUser
:: SwaggerPetstoreRequest LogoutUser MimeNoContent res
logoutUser =
_mkRequest "GET" ["/user/logout"]
data LogoutUser
instance Produces LogoutUser MimeXML
instance Produces LogoutUser MimeJSON
updateUser
:: (Consumes UpdateUser contentType, MimeRender contentType User)
=> contentType
-> Text
-> User
-> SwaggerPetstoreRequest UpdateUser contentType res
updateUser _ username body =
_mkRequest "PUT" ["/user/",toPath username]
`setBodyParam` body
data UpdateUser
instance HasBodyParam UpdateUser User
instance Produces UpdateUser MimeXML
instance Produces UpdateUser MimeJSON
class HasBodyParam req param where
setBodyParam :: forall contentType res. (Consumes req contentType, MimeRender contentType param) => SwaggerPetstoreRequest req contentType res -> param -> SwaggerPetstoreRequest req contentType res
setBodyParam req xs =
req `_setBodyLBS` mimeRender (P.Proxy :: P.Proxy contentType) xs & _setContentTypeHeader
class HasOptionalParam req param where
applyOptionalParam :: SwaggerPetstoreRequest req contentType res -> param -> SwaggerPetstoreRequest req contentType res
applyOptionalParam = (-&-)
(-&-) :: SwaggerPetstoreRequest req contentType res -> param -> SwaggerPetstoreRequest req contentType res
(-&-) = applyOptionalParam
infixl 2 -&-
newtype BodyOuterBoolean = BodyOuterBoolean { unBodyOuterBoolean :: OuterBoolean } deriving (P.Eq, P.Show)
newtype BodyOuterComposite = BodyOuterComposite { unBodyOuterComposite :: OuterComposite } deriving (P.Eq, P.Show)
newtype Body = Body { unBody :: OuterNumber } deriving (P.Eq, P.Show)
newtype BodyOuterString = BodyOuterString { unBodyOuterString :: OuterString } deriving (P.Eq, P.Show)
newtype ParamInteger = ParamInteger { unParamInteger :: Int } deriving (P.Eq, P.Show)
newtype Int32 = Int32 { unInt32 :: Int } deriving (P.Eq, P.Show)
newtype Int64 = Int64 { unInt64 :: Integer } deriving (P.Eq, P.Show)
newtype ParamFloat = ParamFloat { unParamFloat :: Float } deriving (P.Eq, P.Show)
newtype ParamString = ParamString { unParamString :: Text } deriving (P.Eq, P.Show)
newtype ParamBinary = ParamBinary { unParamBinary :: Binary } deriving (P.Eq, P.Show)
newtype ParamDate = ParamDate { unParamDate :: Date } deriving (P.Eq, P.Show)
newtype ParamDateTime = ParamDateTime { unParamDateTime :: DateTime } deriving (P.Eq, P.Show)
newtype Password = Password { unPassword :: Text } deriving (P.Eq, P.Show)
newtype Callback = Callback { unCallback :: Text } deriving (P.Eq, P.Show)
newtype EnumFormStringArray = EnumFormStringArray { unEnumFormStringArray :: [Text] } deriving (P.Eq, P.Show)
newtype EnumFormString = EnumFormString { unEnumFormString :: Text } deriving (P.Eq, P.Show)
newtype EnumHeaderStringArray = EnumHeaderStringArray { unEnumHeaderStringArray :: [Text] } deriving (P.Eq, P.Show)
newtype EnumHeaderString = EnumHeaderString { unEnumHeaderString :: Text } deriving (P.Eq, P.Show)
newtype EnumQueryStringArray = EnumQueryStringArray { unEnumQueryStringArray :: [Text] } deriving (P.Eq, P.Show)
newtype EnumQueryString = EnumQueryString { unEnumQueryString :: Text } deriving (P.Eq, P.Show)
newtype EnumQueryInteger = EnumQueryInteger { unEnumQueryInteger :: Int } deriving (P.Eq, P.Show)
newtype EnumQueryDouble = EnumQueryDouble { unEnumQueryDouble :: Double } deriving (P.Eq, P.Show)
newtype ApiKey = ApiKey { unApiKey :: Text } deriving (P.Eq, P.Show)
newtype Name2 = Name2 { unName2 :: Text } deriving (P.Eq, P.Show)
newtype Status = Status { unStatus :: Text } deriving (P.Eq, P.Show)
newtype AdditionalMetadata = AdditionalMetadata { unAdditionalMetadata :: Text } deriving (P.Eq, P.Show)
newtype File = File { unFile :: FilePath } deriving (P.Eq, P.Show)
data SwaggerPetstoreRequest req contentType res = SwaggerPetstoreRequest
{ rMethod :: NH.Method
, rUrlPath :: [BCL.ByteString]
, rParams :: Params
}
deriving (P.Show)
rMethodL :: Lens_' (SwaggerPetstoreRequest req contentType res) NH.Method
rMethodL f SwaggerPetstoreRequest{..} = (\rMethod -> SwaggerPetstoreRequest { rMethod, ..} ) <$> f rMethod
rUrlPathL :: Lens_' (SwaggerPetstoreRequest req contentType res) [BCL.ByteString]
rUrlPathL f SwaggerPetstoreRequest{..} = (\rUrlPath -> SwaggerPetstoreRequest { rUrlPath, ..} ) <$> f rUrlPath
rParamsL :: Lens_' (SwaggerPetstoreRequest req contentType res) Params
rParamsL f SwaggerPetstoreRequest{..} = (\rParams -> SwaggerPetstoreRequest { rParams, ..} ) <$> f rParams
data Params = Params
{ paramsQuery :: NH.Query
, paramsHeaders :: NH.RequestHeaders
, paramsBody :: ParamBody
}
deriving (P.Show)
paramsQueryL :: Lens_' Params NH.Query
paramsQueryL f Params{..} = (\paramsQuery -> Params { paramsQuery, ..} ) <$> f paramsQuery
paramsHeadersL :: Lens_' Params NH.RequestHeaders
paramsHeadersL f Params{..} = (\paramsHeaders -> Params { paramsHeaders, ..} ) <$> f paramsHeaders
paramsBodyL :: Lens_' Params ParamBody
paramsBodyL f Params{..} = (\paramsBody -> Params { paramsBody, ..} ) <$> f paramsBody
data ParamBody
= ParamBodyNone
| ParamBodyB B.ByteString
| ParamBodyBL BL.ByteString
| ParamBodyFormUrlEncoded WH.Form
| ParamBodyMultipartFormData [NH.Part]
deriving (P.Show)
_mkRequest :: NH.Method
-> [BCL.ByteString]
-> SwaggerPetstoreRequest req contentType res
_mkRequest m u = SwaggerPetstoreRequest m u _mkParams
_mkParams :: Params
_mkParams = Params [] [] ParamBodyNone
setHeader :: SwaggerPetstoreRequest req contentType res -> [NH.Header] -> SwaggerPetstoreRequest req contentType res
setHeader req header =
req `removeHeader` P.fmap P.fst header &
L.over (rParamsL . paramsHeadersL) (header P.++)
removeHeader :: SwaggerPetstoreRequest req contentType res -> [NH.HeaderName] -> SwaggerPetstoreRequest req contentType res
removeHeader req header =
req &
L.over
(rParamsL . paramsHeadersL)
(P.filter (\h -> cifst h `P.notElem` P.fmap CI.mk header))
where
cifst = CI.mk . P.fst
_setContentTypeHeader :: forall req contentType res. MimeType contentType => SwaggerPetstoreRequest req contentType res -> SwaggerPetstoreRequest req contentType res
_setContentTypeHeader req =
case mimeType (P.Proxy :: P.Proxy contentType) of
Just m -> req `setHeader` [("content-type", BC.pack $ P.show m)]
Nothing -> req `removeHeader` ["content-type"]
_setAcceptHeader :: forall req contentType res accept. MimeType accept => SwaggerPetstoreRequest req contentType res -> accept -> SwaggerPetstoreRequest req contentType res
_setAcceptHeader req accept =
case mimeType' accept of
Just m -> req `setHeader` [("accept", BC.pack $ P.show m)]
Nothing -> req `removeHeader` ["accept"]
_setQuery :: SwaggerPetstoreRequest req contentType res -> [NH.QueryItem] -> SwaggerPetstoreRequest req contentType res
_setQuery req query =
req &
L.over
(rParamsL . paramsQueryL)
((query P.++) . P.filter (\q -> cifst q `P.notElem` P.fmap cifst query))
where
cifst = CI.mk . P.fst
_addForm :: SwaggerPetstoreRequest req contentType res -> WH.Form -> SwaggerPetstoreRequest req contentType res
_addForm req newform =
let form = case paramsBody (rParams req) of
ParamBodyFormUrlEncoded _form -> _form
_ -> mempty
in req & L.set (rParamsL . paramsBodyL) (ParamBodyFormUrlEncoded (newform <> form))
_addMultiFormPart :: SwaggerPetstoreRequest req contentType res -> NH.Part -> SwaggerPetstoreRequest req contentType res
_addMultiFormPart req newpart =
let parts = case paramsBody (rParams req) of
ParamBodyMultipartFormData _parts -> _parts
_ -> []
in req & L.set (rParamsL . paramsBodyL) (ParamBodyMultipartFormData (newpart : parts))
_setBodyBS :: SwaggerPetstoreRequest req contentType res -> B.ByteString -> SwaggerPetstoreRequest req contentType res
_setBodyBS req body =
req & L.set (rParamsL . paramsBodyL) (ParamBodyB body)
_setBodyLBS :: SwaggerPetstoreRequest req contentType res -> BL.ByteString -> SwaggerPetstoreRequest req contentType res
_setBodyLBS req body =
req & L.set (rParamsL . paramsBodyL) (ParamBodyBL body)
toPath
:: WH.ToHttpApiData a
=> a -> BCL.ByteString
toPath = BB.toLazyByteString . WH.toEncodedUrlPiece
toHeader :: WH.ToHttpApiData a => (NH.HeaderName, a) -> [NH.Header]
toHeader x = [fmap WH.toHeader x]
toForm :: WH.ToHttpApiData v => (BC.ByteString, v) -> WH.Form
toForm (k,v) = WH.toForm [(BC.unpack k,v)]
toQuery :: WH.ToHttpApiData a => (BC.ByteString, Maybe a) -> [NH.QueryItem]
toQuery x = [(fmap . fmap) toQueryParam x]
where toQueryParam = T.encodeUtf8 . WH.toQueryParam
data CollectionFormat
= CommaSeparated
| SpaceSeparated
| TabSeparated
| PipeSeparated
| MultiParamArray
toHeaderColl :: WH.ToHttpApiData a => CollectionFormat -> (NH.HeaderName, [a]) -> [NH.Header]
toHeaderColl c xs = _toColl c toHeader xs
toFormColl :: WH.ToHttpApiData v => CollectionFormat -> (BC.ByteString, [v]) -> WH.Form
toFormColl c xs = WH.toForm $ fmap unpack $ _toColl c toHeader $ pack xs
where
pack (k,v) = (CI.mk k, v)
unpack (k,v) = (BC.unpack (CI.original k), BC.unpack v)
toQueryColl :: WH.ToHttpApiData a => CollectionFormat -> (BC.ByteString, Maybe [a]) -> NH.Query
toQueryColl c xs = _toCollA c toQuery xs
_toColl :: P.Traversable f => CollectionFormat -> (f a -> [(b, BC.ByteString)]) -> f [a] -> [(b, BC.ByteString)]
_toColl c encode xs = fmap (fmap P.fromJust) (_toCollA' c fencode BC.singleton (fmap Just xs))
where fencode = fmap (fmap Just) . encode . fmap P.fromJust
_toCollA :: (P.Traversable f, P.Traversable t, P.Alternative t) => CollectionFormat -> (f (t a) -> [(b, t BC.ByteString)]) -> f (t [a]) -> [(b, t BC.ByteString)]
_toCollA c encode xs = _toCollA' c encode BC.singleton xs
_toCollA' :: (P.Monoid c, P.Traversable f, P.Traversable t, P.Alternative t) => CollectionFormat -> (f (t a) -> [(b, t c)]) -> (Char -> c) -> f (t [a]) -> [(b, t c)]
_toCollA' c encode one xs = case c of
CommaSeparated -> go (one ',')
SpaceSeparated -> go (one ' ')
TabSeparated -> go (one '\t')
PipeSeparated -> go (one '|')
MultiParamArray -> expandList
where
go sep =
[P.foldl1 (\(sk, sv) (_, v) -> (sk, (combine sep <$> sv <*> v) <|> sv <|> v)) expandList]
combine sep x y = x <> sep <> y
expandList = (P.concatMap encode . (P.traverse . P.traverse) P.toList) xs