{-# 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.AlexaBusiness.ResolveRoom
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Determines the details for the room from which a skill request was
-- invoked. This operation is used by skill developers.
--
-- To query ResolveRoom from an Alexa skill, the skill ID needs to be
-- authorized. When the skill is using an AWS Lambda function, the skill is
-- automatically authorized when you publish your skill as a private skill
-- to your AWS account. Skills that are hosted using a custom web service
-- must be manually authorized. To get your skill authorized, contact AWS
-- Support with your AWS account ID that queries the ResolveRoom API and
-- skill ID.
module Amazonka.AlexaBusiness.ResolveRoom
  ( -- * Creating a Request
    ResolveRoom (..),
    newResolveRoom,

    -- * Request Lenses
    resolveRoom_userId,
    resolveRoom_skillId,

    -- * Destructuring the Response
    ResolveRoomResponse (..),
    newResolveRoomResponse,

    -- * Response Lenses
    resolveRoomResponse_roomArn,
    resolveRoomResponse_roomName,
    resolveRoomResponse_roomSkillParameters,
    resolveRoomResponse_httpStatus,
  )
where

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

-- | /See:/ 'newResolveRoom' smart constructor.
data ResolveRoom = ResolveRoom'
  { -- | The ARN of the user. Required.
    ResolveRoom -> Text
userId :: Prelude.Text,
    -- | The ARN of the skill that was requested. Required.
    ResolveRoom -> Text
skillId :: Prelude.Text
  }
  deriving (ResolveRoom -> ResolveRoom -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResolveRoom -> ResolveRoom -> Bool
$c/= :: ResolveRoom -> ResolveRoom -> Bool
== :: ResolveRoom -> ResolveRoom -> Bool
$c== :: ResolveRoom -> ResolveRoom -> Bool
Prelude.Eq, ReadPrec [ResolveRoom]
ReadPrec ResolveRoom
Int -> ReadS ResolveRoom
ReadS [ResolveRoom]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ResolveRoom]
$creadListPrec :: ReadPrec [ResolveRoom]
readPrec :: ReadPrec ResolveRoom
$creadPrec :: ReadPrec ResolveRoom
readList :: ReadS [ResolveRoom]
$creadList :: ReadS [ResolveRoom]
readsPrec :: Int -> ReadS ResolveRoom
$creadsPrec :: Int -> ReadS ResolveRoom
Prelude.Read, Int -> ResolveRoom -> ShowS
[ResolveRoom] -> ShowS
ResolveRoom -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResolveRoom] -> ShowS
$cshowList :: [ResolveRoom] -> ShowS
show :: ResolveRoom -> String
$cshow :: ResolveRoom -> String
showsPrec :: Int -> ResolveRoom -> ShowS
$cshowsPrec :: Int -> ResolveRoom -> ShowS
Prelude.Show, forall x. Rep ResolveRoom x -> ResolveRoom
forall x. ResolveRoom -> Rep ResolveRoom x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ResolveRoom x -> ResolveRoom
$cfrom :: forall x. ResolveRoom -> Rep ResolveRoom x
Prelude.Generic)

-- |
-- Create a value of 'ResolveRoom' 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:
--
-- 'userId', 'resolveRoom_userId' - The ARN of the user. Required.
--
-- 'skillId', 'resolveRoom_skillId' - The ARN of the skill that was requested. Required.
newResolveRoom ::
  -- | 'userId'
  Prelude.Text ->
  -- | 'skillId'
  Prelude.Text ->
  ResolveRoom
newResolveRoom :: Text -> Text -> ResolveRoom
newResolveRoom Text
pUserId_ Text
pSkillId_ =
  ResolveRoom'
    { $sel:userId:ResolveRoom' :: Text
userId = Text
pUserId_,
      $sel:skillId:ResolveRoom' :: Text
skillId = Text
pSkillId_
    }

-- | The ARN of the user. Required.
resolveRoom_userId :: Lens.Lens' ResolveRoom Prelude.Text
resolveRoom_userId :: Lens' ResolveRoom Text
resolveRoom_userId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResolveRoom' {Text
userId :: Text
$sel:userId:ResolveRoom' :: ResolveRoom -> Text
userId} -> Text
userId) (\s :: ResolveRoom
s@ResolveRoom' {} Text
a -> ResolveRoom
s {$sel:userId:ResolveRoom' :: Text
userId = Text
a} :: ResolveRoom)

-- | The ARN of the skill that was requested. Required.
resolveRoom_skillId :: Lens.Lens' ResolveRoom Prelude.Text
resolveRoom_skillId :: Lens' ResolveRoom Text
resolveRoom_skillId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResolveRoom' {Text
skillId :: Text
$sel:skillId:ResolveRoom' :: ResolveRoom -> Text
skillId} -> Text
skillId) (\s :: ResolveRoom
s@ResolveRoom' {} Text
a -> ResolveRoom
s {$sel:skillId:ResolveRoom' :: Text
skillId = Text
a} :: ResolveRoom)

instance Core.AWSRequest ResolveRoom where
  type AWSResponse ResolveRoom = ResolveRoomResponse
  request :: (Service -> Service) -> ResolveRoom -> Request ResolveRoom
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ResolveRoom
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ResolveRoom)))
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 Text
-> Maybe Text
-> Maybe [RoomSkillParameter]
-> Int
-> ResolveRoomResponse
ResolveRoomResponse'
            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
"RoomArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"RoomName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"RoomSkillParameters"
                            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 ResolveRoom where
  hashWithSalt :: Int -> ResolveRoom -> Int
hashWithSalt Int
_salt ResolveRoom' {Text
skillId :: Text
userId :: Text
$sel:skillId:ResolveRoom' :: ResolveRoom -> Text
$sel:userId:ResolveRoom' :: ResolveRoom -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
userId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
skillId

instance Prelude.NFData ResolveRoom where
  rnf :: ResolveRoom -> ()
rnf ResolveRoom' {Text
skillId :: Text
userId :: Text
$sel:skillId:ResolveRoom' :: ResolveRoom -> Text
$sel:userId:ResolveRoom' :: ResolveRoom -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
userId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
skillId

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

instance Data.ToJSON ResolveRoom where
  toJSON :: ResolveRoom -> Value
toJSON ResolveRoom' {Text
skillId :: Text
userId :: Text
$sel:skillId:ResolveRoom' :: ResolveRoom -> Text
$sel:userId:ResolveRoom' :: ResolveRoom -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"UserId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
userId),
            forall a. a -> Maybe a
Prelude.Just (Key
"SkillId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
skillId)
          ]
      )

instance Data.ToPath ResolveRoom where
  toPath :: ResolveRoom -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

-- | /See:/ 'newResolveRoomResponse' smart constructor.
data ResolveRoomResponse = ResolveRoomResponse'
  { -- | The ARN of the room from which the skill request was invoked.
    ResolveRoomResponse -> Maybe Text
roomArn :: Prelude.Maybe Prelude.Text,
    -- | The name of the room from which the skill request was invoked.
    ResolveRoomResponse -> Maybe Text
roomName :: Prelude.Maybe Prelude.Text,
    -- | Response to get the room profile request. Required.
    ResolveRoomResponse -> Maybe [RoomSkillParameter]
roomSkillParameters :: Prelude.Maybe [RoomSkillParameter],
    -- | The response's http status code.
    ResolveRoomResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ResolveRoomResponse -> ResolveRoomResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResolveRoomResponse -> ResolveRoomResponse -> Bool
$c/= :: ResolveRoomResponse -> ResolveRoomResponse -> Bool
== :: ResolveRoomResponse -> ResolveRoomResponse -> Bool
$c== :: ResolveRoomResponse -> ResolveRoomResponse -> Bool
Prelude.Eq, ReadPrec [ResolveRoomResponse]
ReadPrec ResolveRoomResponse
Int -> ReadS ResolveRoomResponse
ReadS [ResolveRoomResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ResolveRoomResponse]
$creadListPrec :: ReadPrec [ResolveRoomResponse]
readPrec :: ReadPrec ResolveRoomResponse
$creadPrec :: ReadPrec ResolveRoomResponse
readList :: ReadS [ResolveRoomResponse]
$creadList :: ReadS [ResolveRoomResponse]
readsPrec :: Int -> ReadS ResolveRoomResponse
$creadsPrec :: Int -> ReadS ResolveRoomResponse
Prelude.Read, Int -> ResolveRoomResponse -> ShowS
[ResolveRoomResponse] -> ShowS
ResolveRoomResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResolveRoomResponse] -> ShowS
$cshowList :: [ResolveRoomResponse] -> ShowS
show :: ResolveRoomResponse -> String
$cshow :: ResolveRoomResponse -> String
showsPrec :: Int -> ResolveRoomResponse -> ShowS
$cshowsPrec :: Int -> ResolveRoomResponse -> ShowS
Prelude.Show, forall x. Rep ResolveRoomResponse x -> ResolveRoomResponse
forall x. ResolveRoomResponse -> Rep ResolveRoomResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ResolveRoomResponse x -> ResolveRoomResponse
$cfrom :: forall x. ResolveRoomResponse -> Rep ResolveRoomResponse x
Prelude.Generic)

-- |
-- Create a value of 'ResolveRoomResponse' 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:
--
-- 'roomArn', 'resolveRoomResponse_roomArn' - The ARN of the room from which the skill request was invoked.
--
-- 'roomName', 'resolveRoomResponse_roomName' - The name of the room from which the skill request was invoked.
--
-- 'roomSkillParameters', 'resolveRoomResponse_roomSkillParameters' - Response to get the room profile request. Required.
--
-- 'httpStatus', 'resolveRoomResponse_httpStatus' - The response's http status code.
newResolveRoomResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ResolveRoomResponse
newResolveRoomResponse :: Int -> ResolveRoomResponse
newResolveRoomResponse Int
pHttpStatus_ =
  ResolveRoomResponse'
    { $sel:roomArn:ResolveRoomResponse' :: Maybe Text
roomArn = forall a. Maybe a
Prelude.Nothing,
      $sel:roomName:ResolveRoomResponse' :: Maybe Text
roomName = forall a. Maybe a
Prelude.Nothing,
      $sel:roomSkillParameters:ResolveRoomResponse' :: Maybe [RoomSkillParameter]
roomSkillParameters = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ResolveRoomResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the room from which the skill request was invoked.
resolveRoomResponse_roomArn :: Lens.Lens' ResolveRoomResponse (Prelude.Maybe Prelude.Text)
resolveRoomResponse_roomArn :: Lens' ResolveRoomResponse (Maybe Text)
resolveRoomResponse_roomArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResolveRoomResponse' {Maybe Text
roomArn :: Maybe Text
$sel:roomArn:ResolveRoomResponse' :: ResolveRoomResponse -> Maybe Text
roomArn} -> Maybe Text
roomArn) (\s :: ResolveRoomResponse
s@ResolveRoomResponse' {} Maybe Text
a -> ResolveRoomResponse
s {$sel:roomArn:ResolveRoomResponse' :: Maybe Text
roomArn = Maybe Text
a} :: ResolveRoomResponse)

-- | The name of the room from which the skill request was invoked.
resolveRoomResponse_roomName :: Lens.Lens' ResolveRoomResponse (Prelude.Maybe Prelude.Text)
resolveRoomResponse_roomName :: Lens' ResolveRoomResponse (Maybe Text)
resolveRoomResponse_roomName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResolveRoomResponse' {Maybe Text
roomName :: Maybe Text
$sel:roomName:ResolveRoomResponse' :: ResolveRoomResponse -> Maybe Text
roomName} -> Maybe Text
roomName) (\s :: ResolveRoomResponse
s@ResolveRoomResponse' {} Maybe Text
a -> ResolveRoomResponse
s {$sel:roomName:ResolveRoomResponse' :: Maybe Text
roomName = Maybe Text
a} :: ResolveRoomResponse)

-- | Response to get the room profile request. Required.
resolveRoomResponse_roomSkillParameters :: Lens.Lens' ResolveRoomResponse (Prelude.Maybe [RoomSkillParameter])
resolveRoomResponse_roomSkillParameters :: Lens' ResolveRoomResponse (Maybe [RoomSkillParameter])
resolveRoomResponse_roomSkillParameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResolveRoomResponse' {Maybe [RoomSkillParameter]
roomSkillParameters :: Maybe [RoomSkillParameter]
$sel:roomSkillParameters:ResolveRoomResponse' :: ResolveRoomResponse -> Maybe [RoomSkillParameter]
roomSkillParameters} -> Maybe [RoomSkillParameter]
roomSkillParameters) (\s :: ResolveRoomResponse
s@ResolveRoomResponse' {} Maybe [RoomSkillParameter]
a -> ResolveRoomResponse
s {$sel:roomSkillParameters:ResolveRoomResponse' :: Maybe [RoomSkillParameter]
roomSkillParameters = Maybe [RoomSkillParameter]
a} :: ResolveRoomResponse) 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.
resolveRoomResponse_httpStatus :: Lens.Lens' ResolveRoomResponse Prelude.Int
resolveRoomResponse_httpStatus :: Lens' ResolveRoomResponse Int
resolveRoomResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ResolveRoomResponse' {Int
httpStatus :: Int
$sel:httpStatus:ResolveRoomResponse' :: ResolveRoomResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ResolveRoomResponse
s@ResolveRoomResponse' {} Int
a -> ResolveRoomResponse
s {$sel:httpStatus:ResolveRoomResponse' :: Int
httpStatus = Int
a} :: ResolveRoomResponse)

instance Prelude.NFData ResolveRoomResponse where
  rnf :: ResolveRoomResponse -> ()
rnf ResolveRoomResponse' {Int
Maybe [RoomSkillParameter]
Maybe Text
httpStatus :: Int
roomSkillParameters :: Maybe [RoomSkillParameter]
roomName :: Maybe Text
roomArn :: Maybe Text
$sel:httpStatus:ResolveRoomResponse' :: ResolveRoomResponse -> Int
$sel:roomSkillParameters:ResolveRoomResponse' :: ResolveRoomResponse -> Maybe [RoomSkillParameter]
$sel:roomName:ResolveRoomResponse' :: ResolveRoomResponse -> Maybe Text
$sel:roomArn:ResolveRoomResponse' :: ResolveRoomResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
roomArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
roomName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [RoomSkillParameter]
roomSkillParameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus