{-# LANGUAGE DeriveGeneric, GeneralizedNewtypeDeriving, LambdaCase, OverloadedStrings, StandaloneDeriving, TemplateHaskell, ViewPatterns #-}
module BattlePlace.WebApi.Types
( ProjectId(..)
, Auth(..)
, AuthType(..)
, authTypeOf
, Client(..)
, ClientType(..)
, clientTypeOf
, DeveloperId(..)
, ProjectServerId(..)
, ProjectServerToken(..)
, ProjectServerName(..)
, MatchTeamSize
, MatchTag(..)
, ServerTag(..)
, MatchPlayerInfo(..)
, MatchServerInfo(..)
, MatchToken(..)
, MatchFailureReason(..)
, SessionToken(..)
, SessionId(..)
, ServerSessionToken(..)
, ExternalSessionId(..)
, MatchSession(..)
, MatchServerSession(..)
, MatchTeam(..)
, MatchPlayer(..)
, MatchServer(..)
, UserStats(..)
, Identified(..)
, Base64ByteString(..)
, Base64Word64(..)
, StrWord64(..)
) where
import qualified Data.Aeson as J
import Data.Hashable
import Data.Proxy
import qualified Data.Swagger as SW
import qualified Data.Text as T
import qualified Data.Vector as V
import GHC.Generics(Generic)
import Servant.API
import BattlePlace.Rating
import BattlePlace.Token.Types
import BattlePlace.Util
import BattlePlace.WebApi.Types.Util
newtype ProjectId = ProjectId Base64Word64 deriving (Eq, Generic, Hashable, J.FromJSON, J.ToJSON, FromHttpApiData)
instance SW.ToSchema ProjectId where
declareNamedSchema = SW.genericDeclareNamedSchemaNewtype swaggerSchemaOptions SW.declareSchema
data Auth
= Auth_itchJwtToken
{ auth_itchJwtToken :: !T.Text
}
| Auth_itchApiKey
{ auth_itchApiKey :: !T.Text
}
| Auth_steamEncryptedTicket
{ auth_steamEncryptedTicket :: !T.Text
}
| Auth_testKey
{ auth_testKey :: !T.Text
, auth_testId :: !StrWord64
}
deriving Generic
instance J.FromJSON Auth where
parseJSON = J.genericParseJSON jsonOptions
{ J.sumEncoding = J.UntaggedValue
}
instance J.ToJSON Auth where
toJSON = J.genericToJSON jsonOptions
{ J.sumEncoding = J.UntaggedValue
}
toEncoding = J.genericToEncoding jsonOptions
{ J.sumEncoding = J.UntaggedValue
}
instance SW.ToSchema Auth where
declareNamedSchema = SW.genericDeclareNamedSchemaUnrestricted swaggerSchemaOptions
data AuthType
= AuthType_itchJwtToken
| AuthType_itchApiKey
| AuthType_steamEncryptedTicket
| AuthType_testKey
deriving Eq
authTypeOf :: Auth -> AuthType
authTypeOf = \case
Auth_itchJwtToken {} -> AuthType_itchJwtToken
Auth_itchApiKey {} -> AuthType_itchApiKey
Auth_steamEncryptedTicket {} -> AuthType_steamEncryptedTicket
Auth_testKey {} -> AuthType_testKey
data Client
= Client_itch
{ client_itchUserId :: {-# UNPACK #-} !StrWord64
}
| Client_steam
{ client_steamId :: {-# UNPACK #-} !StrWord64
}
| Client_test
{ client_testId :: {-# UNPACK #-} !StrWord64
}
deriving (Eq, Generic)
instance Hashable Client
instance J.FromJSON Client where
parseJSON = J.genericParseJSON $ jsonOptionsWithTag "type"
instance J.ToJSON Client where
toJSON = J.genericToJSON $ jsonOptionsWithTag "type"
toEncoding = J.genericToEncoding $ jsonOptionsWithTag "type"
data ClientType
= ClientType_itch
| ClientType_steam
| ClientType_test
deriving Eq
instance Hashable ClientType
clientTypeOf :: Client -> ClientType
clientTypeOf = \case
Client_itch {} -> ClientType_itch
Client_steam {} -> ClientType_steam
Client_test {} -> ClientType_test
newtype DeveloperId = DeveloperId Base64Word64 deriving (J.FromJSON, J.ToJSON, FromHttpApiData)
newtype ProjectServerId = ProjectServerId Base64Word64 deriving (Eq, Hashable, J.FromJSON, J.FromJSONKey, J.ToJSON, J.ToJSONKey)
newtype ProjectServerToken = ProjectServerToken T.Text deriving (Eq, Generic, Hashable, J.FromJSON, J.ToJSON)
instance SW.ToSchema ProjectServerToken where
declareNamedSchema = SW.genericDeclareNamedSchemaNewtype swaggerSchemaOptions SW.declareSchema
newtype ProjectServerName = ProjectServerName T.Text deriving (Eq, Generic, Hashable, J.FromJSON, J.ToJSON)
instance SW.ToSchema ProjectServerName where
declareNamedSchema = SW.genericDeclareNamedSchemaNewtype swaggerSchemaOptions SW.declareSchema
type MatchTeamSize = Int
newtype MatchTag = MatchTag T.Text deriving (Eq, Generic, Hashable, Semigroup, Monoid, J.FromJSON, J.ToJSON)
instance SW.ToSchema MatchTag where
declareNamedSchema = SW.genericDeclareNamedSchemaNewtype swaggerSchemaOptions SW.declareSchema
newtype ServerTag = ServerTag T.Text deriving (Eq, Generic, Hashable, Semigroup, Monoid, J.FromJSON, J.ToJSON)
instance SW.ToSchema ServerTag where
declareNamedSchema = SW.genericDeclareNamedSchemaNewtype swaggerSchemaOptions SW.declareSchema
newtype MatchPlayerInfo = MatchPlayerInfo J.Value deriving (Generic, J.FromJSON, J.ToJSON)
instance SW.ToSchema MatchPlayerInfo where
declareNamedSchema = SW.genericDeclareNamedSchemaNewtype swaggerSchemaOptions $ \_ -> SW.declareSchema (Proxy :: Proxy J.Object)
newtype MatchServerInfo = MatchServerInfo J.Value deriving (Generic, J.FromJSON, J.ToJSON)
instance SW.ToSchema MatchServerInfo where
declareNamedSchema = SW.genericDeclareNamedSchemaNewtype swaggerSchemaOptions $ \_ -> SW.declareSchema (Proxy :: Proxy J.Object)
data MatchToken = MatchToken
{
}
data MatchFailureReason
= MatchFailureReason_timedOut
| MatchFailureReason_noServer
| MatchFailureReason_cancelled
data SessionToken = SessionToken
{ sessionToken_sessionId :: !SessionId
, sessionToken_teamIndex :: {-# UNPACK #-} !Int
, sessionToken_mateIndex :: {-# UNPACK #-} !Int
}
newtype SessionId = SessionId Base64ByteString deriving (Eq, Generic, Hashable, J.FromJSON, J.ToJSON)
instance SW.ToSchema SessionId where
declareNamedSchema = SW.genericDeclareNamedSchemaNewtype swaggerSchemaOptions SW.declareSchema
newtype ServerSessionToken = ServerSessionToken
{ serverSessionToken_sessionId :: SessionId
}
newtype ExternalSessionId = ExternalSessionId T.Text deriving (Eq, Generic, Hashable, J.FromJSON, J.ToJSON)
instance SW.ToSchema ExternalSessionId where
declareNamedSchema = SW.genericDeclareNamedSchemaNewtype swaggerSchemaOptions SW.declareSchema
data MatchPlayer = MatchPlayer
{ matchPlayer_info :: !MatchPlayerInfo
, matchPlayer_ourTicket :: !(Maybe Ticket)
, matchPlayer_theirTicket :: !(Maybe Ticket)
}
data MatchServer = MatchServer
{ matchServer_info :: !MatchServerInfo
, matchServer_ourTicket :: !Ticket
, matchServer_theirTicket :: !Ticket
}
declareStruct
[ ''AuthType
, ''ClientType
, ''MatchToken
, ''MatchFailureReason
, ''SessionToken
, ''ServerSessionToken
, ''MatchPlayer
, ''MatchServer
]
instance Hashable AuthType
data MatchSession = MatchSession
{ matchSession_externalSessionId :: !ExternalSessionId
, matchSession_sessionToken :: !(InternalToken SessionToken)
, matchSession_teams :: !(V.Vector MatchTeam)
, matchSession_teamIndex :: {-# UNPACK #-} !Int
, matchSession_mateIndex :: {-# UNPACK #-} !Int
, matchSession_server :: !(Maybe MatchServer)
}
data MatchServerSession = MatchServerSession
{ matchServerSession_externalSessionId :: !ExternalSessionId
, matchServerSession_serverSessionToken :: !(InternalToken ServerSessionToken)
, matchServerSession_teams :: !(V.Vector MatchTeam)
, matchServerSession_matchTag :: !MatchTag
, matchServerSession_serverTag :: !ServerTag
}
newtype MatchTeam = MatchTeam (V.Vector MatchPlayer) deriving (Generic, J.FromJSON, J.ToJSON)
instance SW.ToSchema MatchTeam where
declareNamedSchema = SW.genericDeclareNamedSchemaNewtype swaggerSchemaOptions SW.declareSchema
data UserStats = UserStats
{ userStats_rank :: {-# UNPACK #-} !Int
, userStats_rating :: {-# UNPACK #-} !Rating
}
data Identified i a = Identified
{ identified_id :: !i
, identified_info :: !a
} deriving Generic
instance (J.FromJSON i, J.FromJSON a) => J.FromJSON (Identified i a) where
parseJSON = J.genericParseJSON jsonOptions
instance (J.ToJSON i, J.ToJSON a) => J.ToJSON (Identified i a) where
toJSON = J.genericToJSON jsonOptions
toEncoding = J.genericToEncoding jsonOptions
instance (SW.ToSchema i, SW.ToSchema a) => SW.ToSchema (Identified i a)
declareStruct
[ ''MatchSession
, ''MatchServerSession
, ''UserStats
]