{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.GamesParks.GetPlayerConnectionStatus
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Gets the status of a player\'s connection to the game runtime.
--
-- It\'s possible for a single player to have multiple connections to the
-- game runtime. If a player is not connected, this operation returns an
-- empty list.
module Amazonka.GamesParks.GetPlayerConnectionStatus
  ( -- * Creating a Request
    GetPlayerConnectionStatus (..),
    newGetPlayerConnectionStatus,

    -- * Request Lenses
    getPlayerConnectionStatus_gameName,
    getPlayerConnectionStatus_playerId,
    getPlayerConnectionStatus_stageName,

    -- * Destructuring the Response
    GetPlayerConnectionStatusResponse (..),
    newGetPlayerConnectionStatusResponse,

    -- * Response Lenses
    getPlayerConnectionStatusResponse_connections,
    getPlayerConnectionStatusResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.GamesParks.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newGetPlayerConnectionStatus' smart constructor.
data GetPlayerConnectionStatus = GetPlayerConnectionStatus'
  { -- | The name of the game.
    GetPlayerConnectionStatus -> Text
gameName :: Prelude.Text,
    -- | The unique identifier representing a player.
    GetPlayerConnectionStatus -> Text
playerId :: Prelude.Text,
    -- | The name of the stage.
    GetPlayerConnectionStatus -> Text
stageName :: Prelude.Text
  }
  deriving (GetPlayerConnectionStatus -> GetPlayerConnectionStatus -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetPlayerConnectionStatus -> GetPlayerConnectionStatus -> Bool
$c/= :: GetPlayerConnectionStatus -> GetPlayerConnectionStatus -> Bool
== :: GetPlayerConnectionStatus -> GetPlayerConnectionStatus -> Bool
$c== :: GetPlayerConnectionStatus -> GetPlayerConnectionStatus -> Bool
Prelude.Eq, ReadPrec [GetPlayerConnectionStatus]
ReadPrec GetPlayerConnectionStatus
Int -> ReadS GetPlayerConnectionStatus
ReadS [GetPlayerConnectionStatus]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetPlayerConnectionStatus]
$creadListPrec :: ReadPrec [GetPlayerConnectionStatus]
readPrec :: ReadPrec GetPlayerConnectionStatus
$creadPrec :: ReadPrec GetPlayerConnectionStatus
readList :: ReadS [GetPlayerConnectionStatus]
$creadList :: ReadS [GetPlayerConnectionStatus]
readsPrec :: Int -> ReadS GetPlayerConnectionStatus
$creadsPrec :: Int -> ReadS GetPlayerConnectionStatus
Prelude.Read, Int -> GetPlayerConnectionStatus -> ShowS
[GetPlayerConnectionStatus] -> ShowS
GetPlayerConnectionStatus -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetPlayerConnectionStatus] -> ShowS
$cshowList :: [GetPlayerConnectionStatus] -> ShowS
show :: GetPlayerConnectionStatus -> String
$cshow :: GetPlayerConnectionStatus -> String
showsPrec :: Int -> GetPlayerConnectionStatus -> ShowS
$cshowsPrec :: Int -> GetPlayerConnectionStatus -> ShowS
Prelude.Show, forall x.
Rep GetPlayerConnectionStatus x -> GetPlayerConnectionStatus
forall x.
GetPlayerConnectionStatus -> Rep GetPlayerConnectionStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetPlayerConnectionStatus x -> GetPlayerConnectionStatus
$cfrom :: forall x.
GetPlayerConnectionStatus -> Rep GetPlayerConnectionStatus x
Prelude.Generic)

-- |
-- Create a value of 'GetPlayerConnectionStatus' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'gameName', 'getPlayerConnectionStatus_gameName' - The name of the game.
--
-- 'playerId', 'getPlayerConnectionStatus_playerId' - The unique identifier representing a player.
--
-- 'stageName', 'getPlayerConnectionStatus_stageName' - The name of the stage.
newGetPlayerConnectionStatus ::
  -- | 'gameName'
  Prelude.Text ->
  -- | 'playerId'
  Prelude.Text ->
  -- | 'stageName'
  Prelude.Text ->
  GetPlayerConnectionStatus
newGetPlayerConnectionStatus :: Text -> Text -> Text -> GetPlayerConnectionStatus
newGetPlayerConnectionStatus
  Text
pGameName_
  Text
pPlayerId_
  Text
pStageName_ =
    GetPlayerConnectionStatus'
      { $sel:gameName:GetPlayerConnectionStatus' :: Text
gameName = Text
pGameName_,
        $sel:playerId:GetPlayerConnectionStatus' :: Text
playerId = Text
pPlayerId_,
        $sel:stageName:GetPlayerConnectionStatus' :: Text
stageName = Text
pStageName_
      }

-- | The name of the game.
getPlayerConnectionStatus_gameName :: Lens.Lens' GetPlayerConnectionStatus Prelude.Text
getPlayerConnectionStatus_gameName :: Lens' GetPlayerConnectionStatus Text
getPlayerConnectionStatus_gameName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetPlayerConnectionStatus' {Text
gameName :: Text
$sel:gameName:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
gameName} -> Text
gameName) (\s :: GetPlayerConnectionStatus
s@GetPlayerConnectionStatus' {} Text
a -> GetPlayerConnectionStatus
s {$sel:gameName:GetPlayerConnectionStatus' :: Text
gameName = Text
a} :: GetPlayerConnectionStatus)

-- | The unique identifier representing a player.
getPlayerConnectionStatus_playerId :: Lens.Lens' GetPlayerConnectionStatus Prelude.Text
getPlayerConnectionStatus_playerId :: Lens' GetPlayerConnectionStatus Text
getPlayerConnectionStatus_playerId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetPlayerConnectionStatus' {Text
playerId :: Text
$sel:playerId:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
playerId} -> Text
playerId) (\s :: GetPlayerConnectionStatus
s@GetPlayerConnectionStatus' {} Text
a -> GetPlayerConnectionStatus
s {$sel:playerId:GetPlayerConnectionStatus' :: Text
playerId = Text
a} :: GetPlayerConnectionStatus)

-- | The name of the stage.
getPlayerConnectionStatus_stageName :: Lens.Lens' GetPlayerConnectionStatus Prelude.Text
getPlayerConnectionStatus_stageName :: Lens' GetPlayerConnectionStatus Text
getPlayerConnectionStatus_stageName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetPlayerConnectionStatus' {Text
stageName :: Text
$sel:stageName:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
stageName} -> Text
stageName) (\s :: GetPlayerConnectionStatus
s@GetPlayerConnectionStatus' {} Text
a -> GetPlayerConnectionStatus
s {$sel:stageName:GetPlayerConnectionStatus' :: Text
stageName = Text
a} :: GetPlayerConnectionStatus)

instance Core.AWSRequest GetPlayerConnectionStatus where
  type
    AWSResponse GetPlayerConnectionStatus =
      GetPlayerConnectionStatusResponse
  request :: (Service -> Service)
-> GetPlayerConnectionStatus -> Request GetPlayerConnectionStatus
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy GetPlayerConnectionStatus
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetPlayerConnectionStatus)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe [Connection] -> Int -> GetPlayerConnectionStatusResponse
GetPlayerConnectionStatusResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Connections" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable GetPlayerConnectionStatus where
  hashWithSalt :: Int -> GetPlayerConnectionStatus -> Int
hashWithSalt Int
_salt GetPlayerConnectionStatus' {Text
stageName :: Text
playerId :: Text
gameName :: Text
$sel:stageName:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
$sel:playerId:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
$sel:gameName:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
gameName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
playerId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
stageName

instance Prelude.NFData GetPlayerConnectionStatus where
  rnf :: GetPlayerConnectionStatus -> ()
rnf GetPlayerConnectionStatus' {Text
stageName :: Text
playerId :: Text
gameName :: Text
$sel:stageName:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
$sel:playerId:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
$sel:gameName:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
gameName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
playerId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
stageName

instance Data.ToHeaders GetPlayerConnectionStatus where
  toHeaders :: GetPlayerConnectionStatus -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToPath GetPlayerConnectionStatus where
  toPath :: GetPlayerConnectionStatus -> ByteString
toPath GetPlayerConnectionStatus' {Text
stageName :: Text
playerId :: Text
gameName :: Text
$sel:stageName:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
$sel:playerId:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
$sel:gameName:GetPlayerConnectionStatus' :: GetPlayerConnectionStatus -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/runtime/game/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
gameName,
        ByteString
"/stage/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
stageName,
        ByteString
"/player/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
playerId,
        ByteString
"/connection"
      ]

instance Data.ToQuery GetPlayerConnectionStatus where
  toQuery :: GetPlayerConnectionStatus -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newGetPlayerConnectionStatusResponse' smart constructor.
data GetPlayerConnectionStatusResponse = GetPlayerConnectionStatusResponse'
  { -- | The list of connection ids, one for each connection in use by the
    -- player.
    GetPlayerConnectionStatusResponse -> Maybe [Connection]
connections :: Prelude.Maybe [Connection],
    -- | The response's http status code.
    GetPlayerConnectionStatusResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetPlayerConnectionStatusResponse
-> GetPlayerConnectionStatusResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetPlayerConnectionStatusResponse
-> GetPlayerConnectionStatusResponse -> Bool
$c/= :: GetPlayerConnectionStatusResponse
-> GetPlayerConnectionStatusResponse -> Bool
== :: GetPlayerConnectionStatusResponse
-> GetPlayerConnectionStatusResponse -> Bool
$c== :: GetPlayerConnectionStatusResponse
-> GetPlayerConnectionStatusResponse -> Bool
Prelude.Eq, ReadPrec [GetPlayerConnectionStatusResponse]
ReadPrec GetPlayerConnectionStatusResponse
Int -> ReadS GetPlayerConnectionStatusResponse
ReadS [GetPlayerConnectionStatusResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetPlayerConnectionStatusResponse]
$creadListPrec :: ReadPrec [GetPlayerConnectionStatusResponse]
readPrec :: ReadPrec GetPlayerConnectionStatusResponse
$creadPrec :: ReadPrec GetPlayerConnectionStatusResponse
readList :: ReadS [GetPlayerConnectionStatusResponse]
$creadList :: ReadS [GetPlayerConnectionStatusResponse]
readsPrec :: Int -> ReadS GetPlayerConnectionStatusResponse
$creadsPrec :: Int -> ReadS GetPlayerConnectionStatusResponse
Prelude.Read, Int -> GetPlayerConnectionStatusResponse -> ShowS
[GetPlayerConnectionStatusResponse] -> ShowS
GetPlayerConnectionStatusResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetPlayerConnectionStatusResponse] -> ShowS
$cshowList :: [GetPlayerConnectionStatusResponse] -> ShowS
show :: GetPlayerConnectionStatusResponse -> String
$cshow :: GetPlayerConnectionStatusResponse -> String
showsPrec :: Int -> GetPlayerConnectionStatusResponse -> ShowS
$cshowsPrec :: Int -> GetPlayerConnectionStatusResponse -> ShowS
Prelude.Show, forall x.
Rep GetPlayerConnectionStatusResponse x
-> GetPlayerConnectionStatusResponse
forall x.
GetPlayerConnectionStatusResponse
-> Rep GetPlayerConnectionStatusResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetPlayerConnectionStatusResponse x
-> GetPlayerConnectionStatusResponse
$cfrom :: forall x.
GetPlayerConnectionStatusResponse
-> Rep GetPlayerConnectionStatusResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetPlayerConnectionStatusResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'connections', 'getPlayerConnectionStatusResponse_connections' - The list of connection ids, one for each connection in use by the
-- player.
--
-- 'httpStatus', 'getPlayerConnectionStatusResponse_httpStatus' - The response's http status code.
newGetPlayerConnectionStatusResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetPlayerConnectionStatusResponse
newGetPlayerConnectionStatusResponse :: Int -> GetPlayerConnectionStatusResponse
newGetPlayerConnectionStatusResponse Int
pHttpStatus_ =
  GetPlayerConnectionStatusResponse'
    { $sel:connections:GetPlayerConnectionStatusResponse' :: Maybe [Connection]
connections =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetPlayerConnectionStatusResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The list of connection ids, one for each connection in use by the
-- player.
getPlayerConnectionStatusResponse_connections :: Lens.Lens' GetPlayerConnectionStatusResponse (Prelude.Maybe [Connection])
getPlayerConnectionStatusResponse_connections :: Lens' GetPlayerConnectionStatusResponse (Maybe [Connection])
getPlayerConnectionStatusResponse_connections = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetPlayerConnectionStatusResponse' {Maybe [Connection]
connections :: Maybe [Connection]
$sel:connections:GetPlayerConnectionStatusResponse' :: GetPlayerConnectionStatusResponse -> Maybe [Connection]
connections} -> Maybe [Connection]
connections) (\s :: GetPlayerConnectionStatusResponse
s@GetPlayerConnectionStatusResponse' {} Maybe [Connection]
a -> GetPlayerConnectionStatusResponse
s {$sel:connections:GetPlayerConnectionStatusResponse' :: Maybe [Connection]
connections = Maybe [Connection]
a} :: GetPlayerConnectionStatusResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The response's http status code.
getPlayerConnectionStatusResponse_httpStatus :: Lens.Lens' GetPlayerConnectionStatusResponse Prelude.Int
getPlayerConnectionStatusResponse_httpStatus :: Lens' GetPlayerConnectionStatusResponse Int
getPlayerConnectionStatusResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetPlayerConnectionStatusResponse' {Int
httpStatus :: Int
$sel:httpStatus:GetPlayerConnectionStatusResponse' :: GetPlayerConnectionStatusResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: GetPlayerConnectionStatusResponse
s@GetPlayerConnectionStatusResponse' {} Int
a -> GetPlayerConnectionStatusResponse
s {$sel:httpStatus:GetPlayerConnectionStatusResponse' :: Int
httpStatus = Int
a} :: GetPlayerConnectionStatusResponse)

instance
  Prelude.NFData
    GetPlayerConnectionStatusResponse
  where
  rnf :: GetPlayerConnectionStatusResponse -> ()
rnf GetPlayerConnectionStatusResponse' {Int
Maybe [Connection]
httpStatus :: Int
connections :: Maybe [Connection]
$sel:httpStatus:GetPlayerConnectionStatusResponse' :: GetPlayerConnectionStatusResponse -> Int
$sel:connections:GetPlayerConnectionStatusResponse' :: GetPlayerConnectionStatusResponse -> Maybe [Connection]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Connection]
connections
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus