module SwaggerPetstore.Model where
import SwaggerPetstore.Core
import Data.Aeson ((.:),(.:!),(.:?),(.=))
import qualified Data.Aeson as A
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as BL
import qualified Data.Data as P (Data, Typeable)
import qualified Data.Foldable as P
import qualified Data.HashMap.Lazy as HM
import qualified Data.Map as Map
import qualified Data.Maybe as P
import qualified Data.Set as Set
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import qualified Data.Time as TI
import qualified Web.FormUrlEncoded as WH
import qualified Web.HttpApiData as WH
import Control.Applicative ((<|>))
import Control.Applicative (Alternative)
import Data.Text (Text)
import Prelude (($), (.),(<$>),(<*>),(>>=),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)
import qualified Prelude as P
data AdditionalPropertiesClass = AdditionalPropertiesClass
{ additionalPropertiesClassMapProperty :: !(Maybe (Map.Map String Text))
, additionalPropertiesClassMapOfMapProperty :: !(Maybe (Map.Map String (Map.Map String Text)))
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON AdditionalPropertiesClass where
parseJSON = A.withObject "AdditionalPropertiesClass" $ \o ->
AdditionalPropertiesClass
<$> (o .:? "map_property")
<*> (o .:? "map_of_map_property")
instance A.ToJSON AdditionalPropertiesClass where
toJSON AdditionalPropertiesClass {..} =
_omitNulls
[ "map_property" .= additionalPropertiesClassMapProperty
, "map_of_map_property" .= additionalPropertiesClassMapOfMapProperty
]
mkAdditionalPropertiesClass
:: AdditionalPropertiesClass
mkAdditionalPropertiesClass =
AdditionalPropertiesClass
{ additionalPropertiesClassMapProperty = Nothing
, additionalPropertiesClassMapOfMapProperty = Nothing
}
data Animal = Animal
{ animalClassName :: !(Text)
, animalColor :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Animal where
parseJSON = A.withObject "Animal" $ \o ->
Animal
<$> (o .: "className")
<*> (o .:? "color")
instance A.ToJSON Animal where
toJSON Animal {..} =
_omitNulls
[ "className" .= animalClassName
, "color" .= animalColor
]
mkAnimal
:: Text
-> Animal
mkAnimal animalClassName =
Animal
{ animalClassName
, animalColor = Nothing
}
data AnimalFarm = AnimalFarm
{
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON AnimalFarm where
parseJSON = A.withObject "AnimalFarm" $ \o ->
pure AnimalFarm
instance A.ToJSON AnimalFarm where
toJSON AnimalFarm =
_omitNulls
[
]
mkAnimalFarm
:: AnimalFarm
mkAnimalFarm =
AnimalFarm
{
}
data ApiResponse = ApiResponse
{ apiResponseCode :: !(Maybe Int)
, apiResponseType :: !(Maybe Text)
, apiResponseMessage :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON ApiResponse where
parseJSON = A.withObject "ApiResponse" $ \o ->
ApiResponse
<$> (o .:? "code")
<*> (o .:? "type")
<*> (o .:? "message")
instance A.ToJSON ApiResponse where
toJSON ApiResponse {..} =
_omitNulls
[ "code" .= apiResponseCode
, "type" .= apiResponseType
, "message" .= apiResponseMessage
]
mkApiResponse
:: ApiResponse
mkApiResponse =
ApiResponse
{ apiResponseCode = Nothing
, apiResponseType = Nothing
, apiResponseMessage = Nothing
}
data ArrayOfArrayOfNumberOnly = ArrayOfArrayOfNumberOnly
{ arrayOfArrayOfNumberOnlyArrayArrayNumber :: !(Maybe [[Double]])
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON ArrayOfArrayOfNumberOnly where
parseJSON = A.withObject "ArrayOfArrayOfNumberOnly" $ \o ->
ArrayOfArrayOfNumberOnly
<$> (o .:? "ArrayArrayNumber")
instance A.ToJSON ArrayOfArrayOfNumberOnly where
toJSON ArrayOfArrayOfNumberOnly {..} =
_omitNulls
[ "ArrayArrayNumber" .= arrayOfArrayOfNumberOnlyArrayArrayNumber
]
mkArrayOfArrayOfNumberOnly
:: ArrayOfArrayOfNumberOnly
mkArrayOfArrayOfNumberOnly =
ArrayOfArrayOfNumberOnly
{ arrayOfArrayOfNumberOnlyArrayArrayNumber = Nothing
}
data ArrayOfNumberOnly = ArrayOfNumberOnly
{ arrayOfNumberOnlyArrayNumber :: !(Maybe [Double])
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON ArrayOfNumberOnly where
parseJSON = A.withObject "ArrayOfNumberOnly" $ \o ->
ArrayOfNumberOnly
<$> (o .:? "ArrayNumber")
instance A.ToJSON ArrayOfNumberOnly where
toJSON ArrayOfNumberOnly {..} =
_omitNulls
[ "ArrayNumber" .= arrayOfNumberOnlyArrayNumber
]
mkArrayOfNumberOnly
:: ArrayOfNumberOnly
mkArrayOfNumberOnly =
ArrayOfNumberOnly
{ arrayOfNumberOnlyArrayNumber = Nothing
}
data ArrayTest = ArrayTest
{ arrayTestArrayOfString :: !(Maybe [Text])
, arrayTestArrayArrayOfInteger :: !(Maybe [[Integer]])
, arrayTestArrayArrayOfModel :: !(Maybe [[ReadOnlyFirst]])
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON ArrayTest where
parseJSON = A.withObject "ArrayTest" $ \o ->
ArrayTest
<$> (o .:? "array_of_string")
<*> (o .:? "array_array_of_integer")
<*> (o .:? "array_array_of_model")
instance A.ToJSON ArrayTest where
toJSON ArrayTest {..} =
_omitNulls
[ "array_of_string" .= arrayTestArrayOfString
, "array_array_of_integer" .= arrayTestArrayArrayOfInteger
, "array_array_of_model" .= arrayTestArrayArrayOfModel
]
mkArrayTest
:: ArrayTest
mkArrayTest =
ArrayTest
{ arrayTestArrayOfString = Nothing
, arrayTestArrayArrayOfInteger = Nothing
, arrayTestArrayArrayOfModel = Nothing
}
data Capitalization = Capitalization
{ capitalizationSmallCamel :: !(Maybe Text)
, capitalizationCapitalCamel :: !(Maybe Text)
, capitalizationSmallSnake :: !(Maybe Text)
, capitalizationCapitalSnake :: !(Maybe Text)
, capitalizationScaEthFlowPoints :: !(Maybe Text)
, capitalizationAttName :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Capitalization where
parseJSON = A.withObject "Capitalization" $ \o ->
Capitalization
<$> (o .:? "smallCamel")
<*> (o .:? "CapitalCamel")
<*> (o .:? "small_Snake")
<*> (o .:? "Capital_Snake")
<*> (o .:? "SCA_ETH_Flow_Points")
<*> (o .:? "ATT_NAME")
instance A.ToJSON Capitalization where
toJSON Capitalization {..} =
_omitNulls
[ "smallCamel" .= capitalizationSmallCamel
, "CapitalCamel" .= capitalizationCapitalCamel
, "small_Snake" .= capitalizationSmallSnake
, "Capital_Snake" .= capitalizationCapitalSnake
, "SCA_ETH_Flow_Points" .= capitalizationScaEthFlowPoints
, "ATT_NAME" .= capitalizationAttName
]
mkCapitalization
:: Capitalization
mkCapitalization =
Capitalization
{ capitalizationSmallCamel = Nothing
, capitalizationCapitalCamel = Nothing
, capitalizationSmallSnake = Nothing
, capitalizationCapitalSnake = Nothing
, capitalizationScaEthFlowPoints = Nothing
, capitalizationAttName = Nothing
}
data Category = Category
{ categoryId :: !(Maybe Integer)
, categoryName :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Category where
parseJSON = A.withObject "Category" $ \o ->
Category
<$> (o .:? "id")
<*> (o .:? "name")
instance A.ToJSON Category where
toJSON Category {..} =
_omitNulls
[ "id" .= categoryId
, "name" .= categoryName
]
mkCategory
:: Category
mkCategory =
Category
{ categoryId = Nothing
, categoryName = Nothing
}
data ClassModel = ClassModel
{ classModelClass :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON ClassModel where
parseJSON = A.withObject "ClassModel" $ \o ->
ClassModel
<$> (o .:? "_class")
instance A.ToJSON ClassModel where
toJSON ClassModel {..} =
_omitNulls
[ "_class" .= classModelClass
]
mkClassModel
:: ClassModel
mkClassModel =
ClassModel
{ classModelClass = Nothing
}
data Client = Client
{ clientClient :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Client where
parseJSON = A.withObject "Client" $ \o ->
Client
<$> (o .:? "client")
instance A.ToJSON Client where
toJSON Client {..} =
_omitNulls
[ "client" .= clientClient
]
mkClient
:: Client
mkClient =
Client
{ clientClient = Nothing
}
data EnumArrays = EnumArrays
{ enumArraysJustSymbol :: !(Maybe Text)
, enumArraysArrayEnum :: !(Maybe [Text])
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON EnumArrays where
parseJSON = A.withObject "EnumArrays" $ \o ->
EnumArrays
<$> (o .:? "just_symbol")
<*> (o .:? "array_enum")
instance A.ToJSON EnumArrays where
toJSON EnumArrays {..} =
_omitNulls
[ "just_symbol" .= enumArraysJustSymbol
, "array_enum" .= enumArraysArrayEnum
]
mkEnumArrays
:: EnumArrays
mkEnumArrays =
EnumArrays
{ enumArraysJustSymbol = Nothing
, enumArraysArrayEnum = Nothing
}
data EnumClass = EnumClass
{
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON EnumClass where
parseJSON = A.withObject "EnumClass" $ \o ->
pure EnumClass
instance A.ToJSON EnumClass where
toJSON EnumClass =
_omitNulls
[
]
mkEnumClass
:: EnumClass
mkEnumClass =
EnumClass
{
}
data EnumTest = EnumTest
{ enumTestEnumString :: !(Maybe Text)
, enumTestEnumInteger :: !(Maybe Int)
, enumTestEnumNumber :: !(Maybe Double)
, enumTestOuterEnum :: !(Maybe OuterEnum)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON EnumTest where
parseJSON = A.withObject "EnumTest" $ \o ->
EnumTest
<$> (o .:? "enum_string")
<*> (o .:? "enum_integer")
<*> (o .:? "enum_number")
<*> (o .:? "outerEnum")
instance A.ToJSON EnumTest where
toJSON EnumTest {..} =
_omitNulls
[ "enum_string" .= enumTestEnumString
, "enum_integer" .= enumTestEnumInteger
, "enum_number" .= enumTestEnumNumber
, "outerEnum" .= enumTestOuterEnum
]
mkEnumTest
:: EnumTest
mkEnumTest =
EnumTest
{ enumTestEnumString = Nothing
, enumTestEnumInteger = Nothing
, enumTestEnumNumber = Nothing
, enumTestOuterEnum = Nothing
}
data FormatTest = FormatTest
{ formatTestInteger :: !(Maybe Int)
, formatTestInt32 :: !(Maybe Int)
, formatTestInt64 :: !(Maybe Integer)
, formatTestNumber :: !(Double)
, formatTestFloat :: !(Maybe Float)
, formatTestDouble :: !(Maybe Double)
, formatTestString :: !(Maybe Text)
, formatTestByte :: !(ByteArray)
, formatTestBinary :: !(Maybe Binary)
, formatTestDate :: !(Date)
, formatTestDateTime :: !(Maybe DateTime)
, formatTestUuid :: !(Maybe Text)
, formatTestPassword :: !(Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON FormatTest where
parseJSON = A.withObject "FormatTest" $ \o ->
FormatTest
<$> (o .:? "integer")
<*> (o .:? "int32")
<*> (o .:? "int64")
<*> (o .: "number")
<*> (o .:? "float")
<*> (o .:? "double")
<*> (o .:? "string")
<*> (o .: "byte")
<*> (o .:? "binary")
<*> (o .: "date")
<*> (o .:? "dateTime")
<*> (o .:? "uuid")
<*> (o .: "password")
instance A.ToJSON FormatTest where
toJSON FormatTest {..} =
_omitNulls
[ "integer" .= formatTestInteger
, "int32" .= formatTestInt32
, "int64" .= formatTestInt64
, "number" .= formatTestNumber
, "float" .= formatTestFloat
, "double" .= formatTestDouble
, "string" .= formatTestString
, "byte" .= formatTestByte
, "binary" .= formatTestBinary
, "date" .= formatTestDate
, "dateTime" .= formatTestDateTime
, "uuid" .= formatTestUuid
, "password" .= formatTestPassword
]
mkFormatTest
:: Double
-> ByteArray
-> Date
-> Text
-> FormatTest
mkFormatTest formatTestNumber formatTestByte formatTestDate formatTestPassword =
FormatTest
{ formatTestInteger = Nothing
, formatTestInt32 = Nothing
, formatTestInt64 = Nothing
, formatTestNumber
, formatTestFloat = Nothing
, formatTestDouble = Nothing
, formatTestString = Nothing
, formatTestByte
, formatTestBinary = Nothing
, formatTestDate
, formatTestDateTime = Nothing
, formatTestUuid = Nothing
, formatTestPassword
}
data HasOnlyReadOnly = HasOnlyReadOnly
{ hasOnlyReadOnlyBar :: !(Maybe Text)
, hasOnlyReadOnlyFoo :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON HasOnlyReadOnly where
parseJSON = A.withObject "HasOnlyReadOnly" $ \o ->
HasOnlyReadOnly
<$> (o .:? "bar")
<*> (o .:? "foo")
instance A.ToJSON HasOnlyReadOnly where
toJSON HasOnlyReadOnly {..} =
_omitNulls
[ "bar" .= hasOnlyReadOnlyBar
, "foo" .= hasOnlyReadOnlyFoo
]
mkHasOnlyReadOnly
:: HasOnlyReadOnly
mkHasOnlyReadOnly =
HasOnlyReadOnly
{ hasOnlyReadOnlyBar = Nothing
, hasOnlyReadOnlyFoo = Nothing
}
data MapTest = MapTest
{ mapTestMapMapOfString :: !(Maybe (Map.Map String (Map.Map String Text)))
, mapTestMapOfEnumString :: !(Maybe (Map.Map String Text))
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON MapTest where
parseJSON = A.withObject "MapTest" $ \o ->
MapTest
<$> (o .:? "map_map_of_string")
<*> (o .:? "map_of_enum_string")
instance A.ToJSON MapTest where
toJSON MapTest {..} =
_omitNulls
[ "map_map_of_string" .= mapTestMapMapOfString
, "map_of_enum_string" .= mapTestMapOfEnumString
]
mkMapTest
:: MapTest
mkMapTest =
MapTest
{ mapTestMapMapOfString = Nothing
, mapTestMapOfEnumString = Nothing
}
data MixedPropertiesAndAdditionalPropertiesClass = MixedPropertiesAndAdditionalPropertiesClass
{ mixedPropertiesAndAdditionalPropertiesClassUuid :: !(Maybe Text)
, mixedPropertiesAndAdditionalPropertiesClassDateTime :: !(Maybe DateTime)
, mixedPropertiesAndAdditionalPropertiesClassMap :: !(Maybe (Map.Map String Animal))
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON MixedPropertiesAndAdditionalPropertiesClass where
parseJSON = A.withObject "MixedPropertiesAndAdditionalPropertiesClass" $ \o ->
MixedPropertiesAndAdditionalPropertiesClass
<$> (o .:? "uuid")
<*> (o .:? "dateTime")
<*> (o .:? "map")
instance A.ToJSON MixedPropertiesAndAdditionalPropertiesClass where
toJSON MixedPropertiesAndAdditionalPropertiesClass {..} =
_omitNulls
[ "uuid" .= mixedPropertiesAndAdditionalPropertiesClassUuid
, "dateTime" .= mixedPropertiesAndAdditionalPropertiesClassDateTime
, "map" .= mixedPropertiesAndAdditionalPropertiesClassMap
]
mkMixedPropertiesAndAdditionalPropertiesClass
:: MixedPropertiesAndAdditionalPropertiesClass
mkMixedPropertiesAndAdditionalPropertiesClass =
MixedPropertiesAndAdditionalPropertiesClass
{ mixedPropertiesAndAdditionalPropertiesClassUuid = Nothing
, mixedPropertiesAndAdditionalPropertiesClassDateTime = Nothing
, mixedPropertiesAndAdditionalPropertiesClassMap = Nothing
}
data Model200Response = Model200Response
{ model200ResponseName :: !(Maybe Int)
, model200ResponseClass :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Model200Response where
parseJSON = A.withObject "Model200Response" $ \o ->
Model200Response
<$> (o .:? "name")
<*> (o .:? "class")
instance A.ToJSON Model200Response where
toJSON Model200Response {..} =
_omitNulls
[ "name" .= model200ResponseName
, "class" .= model200ResponseClass
]
mkModel200Response
:: Model200Response
mkModel200Response =
Model200Response
{ model200ResponseName = Nothing
, model200ResponseClass = Nothing
}
data ModelList = ModelList
{ modelList123List :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON ModelList where
parseJSON = A.withObject "ModelList" $ \o ->
ModelList
<$> (o .:? "123-list")
instance A.ToJSON ModelList where
toJSON ModelList {..} =
_omitNulls
[ "123-list" .= modelList123List
]
mkModelList
:: ModelList
mkModelList =
ModelList
{ modelList123List = Nothing
}
data ModelReturn = ModelReturn
{ modelReturnReturn :: !(Maybe Int)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON ModelReturn where
parseJSON = A.withObject "ModelReturn" $ \o ->
ModelReturn
<$> (o .:? "return")
instance A.ToJSON ModelReturn where
toJSON ModelReturn {..} =
_omitNulls
[ "return" .= modelReturnReturn
]
mkModelReturn
:: ModelReturn
mkModelReturn =
ModelReturn
{ modelReturnReturn = Nothing
}
data Name = Name
{ nameName :: !(Int)
, nameSnakeCase :: !(Maybe Int)
, nameProperty :: !(Maybe Text)
, name123Number :: !(Maybe Int)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Name where
parseJSON = A.withObject "Name" $ \o ->
Name
<$> (o .: "name")
<*> (o .:? "snake_case")
<*> (o .:? "property")
<*> (o .:? "123Number")
instance A.ToJSON Name where
toJSON Name {..} =
_omitNulls
[ "name" .= nameName
, "snake_case" .= nameSnakeCase
, "property" .= nameProperty
, "123Number" .= name123Number
]
mkName
:: Int
-> Name
mkName nameName =
Name
{ nameName
, nameSnakeCase = Nothing
, nameProperty = Nothing
, name123Number = Nothing
}
data NumberOnly = NumberOnly
{ numberOnlyJustNumber :: !(Maybe Double)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON NumberOnly where
parseJSON = A.withObject "NumberOnly" $ \o ->
NumberOnly
<$> (o .:? "JustNumber")
instance A.ToJSON NumberOnly where
toJSON NumberOnly {..} =
_omitNulls
[ "JustNumber" .= numberOnlyJustNumber
]
mkNumberOnly
:: NumberOnly
mkNumberOnly =
NumberOnly
{ numberOnlyJustNumber = Nothing
}
data Order = Order
{ orderId :: !(Maybe Integer)
, orderPetId :: !(Maybe Integer)
, orderQuantity :: !(Maybe Int)
, orderShipDate :: !(Maybe DateTime)
, orderStatus :: !(Maybe Text)
, orderComplete :: !(Maybe Bool)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Order where
parseJSON = A.withObject "Order" $ \o ->
Order
<$> (o .:? "id")
<*> (o .:? "petId")
<*> (o .:? "quantity")
<*> (o .:? "shipDate")
<*> (o .:? "status")
<*> (o .:? "complete")
instance A.ToJSON Order where
toJSON Order {..} =
_omitNulls
[ "id" .= orderId
, "petId" .= orderPetId
, "quantity" .= orderQuantity
, "shipDate" .= orderShipDate
, "status" .= orderStatus
, "complete" .= orderComplete
]
mkOrder
:: Order
mkOrder =
Order
{ orderId = Nothing
, orderPetId = Nothing
, orderQuantity = Nothing
, orderShipDate = Nothing
, orderStatus = Nothing
, orderComplete = Nothing
}
newtype OuterBoolean = OuterBoolean
{ unOuterBoolean :: Bool
} deriving (P.Eq, P.Show, P.Typeable, A.ToJSON, A.FromJSON, WH.ToHttpApiData, WH.FromHttpApiData)
data OuterComposite = OuterComposite
{ outerCompositeMyNumber :: !(Maybe OuterNumber)
, outerCompositeMyString :: !(Maybe OuterString)
, outerCompositeMyBoolean :: !(Maybe OuterBoolean)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON OuterComposite where
parseJSON = A.withObject "OuterComposite" $ \o ->
OuterComposite
<$> (o .:? "my_number")
<*> (o .:? "my_string")
<*> (o .:? "my_boolean")
instance A.ToJSON OuterComposite where
toJSON OuterComposite {..} =
_omitNulls
[ "my_number" .= outerCompositeMyNumber
, "my_string" .= outerCompositeMyString
, "my_boolean" .= outerCompositeMyBoolean
]
mkOuterComposite
:: OuterComposite
mkOuterComposite =
OuterComposite
{ outerCompositeMyNumber = Nothing
, outerCompositeMyString = Nothing
, outerCompositeMyBoolean = Nothing
}
data OuterEnum = OuterEnum
{
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON OuterEnum where
parseJSON = A.withObject "OuterEnum" $ \o ->
pure OuterEnum
instance A.ToJSON OuterEnum where
toJSON OuterEnum =
_omitNulls
[
]
mkOuterEnum
:: OuterEnum
mkOuterEnum =
OuterEnum
{
}
newtype OuterNumber = OuterNumber
{ unOuterNumber :: Double
} deriving (P.Eq, P.Show, P.Typeable, A.ToJSON, A.FromJSON, WH.ToHttpApiData, WH.FromHttpApiData)
newtype OuterString = OuterString
{ unOuterString :: Text
} deriving (P.Eq, P.Show, P.Typeable, A.ToJSON, A.FromJSON, WH.ToHttpApiData, WH.FromHttpApiData)
data Pet = Pet
{ petId :: !(Maybe Integer)
, petCategory :: !(Maybe Category)
, petName :: !(Text)
, petPhotoUrls :: !([Text])
, petTags :: !(Maybe [Tag])
, petStatus :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Pet where
parseJSON = A.withObject "Pet" $ \o ->
Pet
<$> (o .:? "id")
<*> (o .:? "category")
<*> (o .: "name")
<*> (o .: "photoUrls")
<*> (o .:? "tags")
<*> (o .:? "status")
instance A.ToJSON Pet where
toJSON Pet {..} =
_omitNulls
[ "id" .= petId
, "category" .= petCategory
, "name" .= petName
, "photoUrls" .= petPhotoUrls
, "tags" .= petTags
, "status" .= petStatus
]
mkPet
:: Text
-> [Text]
-> Pet
mkPet petName petPhotoUrls =
Pet
{ petId = Nothing
, petCategory = Nothing
, petName
, petPhotoUrls
, petTags = Nothing
, petStatus = Nothing
}
data ReadOnlyFirst = ReadOnlyFirst
{ readOnlyFirstBar :: !(Maybe Text)
, readOnlyFirstBaz :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON ReadOnlyFirst where
parseJSON = A.withObject "ReadOnlyFirst" $ \o ->
ReadOnlyFirst
<$> (o .:? "bar")
<*> (o .:? "baz")
instance A.ToJSON ReadOnlyFirst where
toJSON ReadOnlyFirst {..} =
_omitNulls
[ "bar" .= readOnlyFirstBar
, "baz" .= readOnlyFirstBaz
]
mkReadOnlyFirst
:: ReadOnlyFirst
mkReadOnlyFirst =
ReadOnlyFirst
{ readOnlyFirstBar = Nothing
, readOnlyFirstBaz = Nothing
}
data SpecialModelName = SpecialModelName
{ specialModelNameSpecialPropertyName :: !(Maybe Integer)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON SpecialModelName where
parseJSON = A.withObject "SpecialModelName" $ \o ->
SpecialModelName
<$> (o .:? "$special[property.name]")
instance A.ToJSON SpecialModelName where
toJSON SpecialModelName {..} =
_omitNulls
[ "$special[property.name]" .= specialModelNameSpecialPropertyName
]
mkSpecialModelName
:: SpecialModelName
mkSpecialModelName =
SpecialModelName
{ specialModelNameSpecialPropertyName = Nothing
}
data Tag = Tag
{ tagId :: !(Maybe Integer)
, tagName :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Tag where
parseJSON = A.withObject "Tag" $ \o ->
Tag
<$> (o .:? "id")
<*> (o .:? "name")
instance A.ToJSON Tag where
toJSON Tag {..} =
_omitNulls
[ "id" .= tagId
, "name" .= tagName
]
mkTag
:: Tag
mkTag =
Tag
{ tagId = Nothing
, tagName = Nothing
}
data User = User
{ userId :: !(Maybe Integer)
, userUsername :: !(Maybe Text)
, userFirstName :: !(Maybe Text)
, userLastName :: !(Maybe Text)
, userEmail :: !(Maybe Text)
, userPassword :: !(Maybe Text)
, userPhone :: !(Maybe Text)
, userUserStatus :: !(Maybe Int)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON User where
parseJSON = A.withObject "User" $ \o ->
User
<$> (o .:? "id")
<*> (o .:? "username")
<*> (o .:? "firstName")
<*> (o .:? "lastName")
<*> (o .:? "email")
<*> (o .:? "password")
<*> (o .:? "phone")
<*> (o .:? "userStatus")
instance A.ToJSON User where
toJSON User {..} =
_omitNulls
[ "id" .= userId
, "username" .= userUsername
, "firstName" .= userFirstName
, "lastName" .= userLastName
, "email" .= userEmail
, "password" .= userPassword
, "phone" .= userPhone
, "userStatus" .= userUserStatus
]
mkUser
:: User
mkUser =
User
{ userId = Nothing
, userUsername = Nothing
, userFirstName = Nothing
, userLastName = Nothing
, userEmail = Nothing
, userPassword = Nothing
, userPhone = Nothing
, userUserStatus = Nothing
}
data Cat = Cat
{ catClassName :: !(Text)
, catColor :: !(Maybe Text)
, catDeclawed :: !(Maybe Bool)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Cat where
parseJSON = A.withObject "Cat" $ \o ->
Cat
<$> (o .: "className")
<*> (o .:? "color")
<*> (o .:? "declawed")
instance A.ToJSON Cat where
toJSON Cat {..} =
_omitNulls
[ "className" .= catClassName
, "color" .= catColor
, "declawed" .= catDeclawed
]
mkCat
:: Text
-> Cat
mkCat catClassName =
Cat
{ catClassName
, catColor = Nothing
, catDeclawed = Nothing
}
data Dog = Dog
{ dogClassName :: !(Text)
, dogColor :: !(Maybe Text)
, dogBreed :: !(Maybe Text)
} deriving (P.Show, P.Eq, P.Typeable)
instance A.FromJSON Dog where
parseJSON = A.withObject "Dog" $ \o ->
Dog
<$> (o .: "className")
<*> (o .:? "color")
<*> (o .:? "breed")
instance A.ToJSON Dog where
toJSON Dog {..} =
_omitNulls
[ "className" .= dogClassName
, "color" .= dogColor
, "breed" .= dogBreed
]
mkDog
:: Text
-> Dog
mkDog dogClassName =
Dog
{ dogClassName
, dogColor = Nothing
, dogBreed = Nothing
}