{-# 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.SendAnnouncement
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Triggers an asynchronous flow to send text, SSML, or audio announcements
-- to rooms that are identified by a search or filter.
module Amazonka.AlexaBusiness.SendAnnouncement
  ( -- * Creating a Request
    SendAnnouncement (..),
    newSendAnnouncement,

    -- * Request Lenses
    sendAnnouncement_timeToLiveInSeconds,
    sendAnnouncement_roomFilters,
    sendAnnouncement_content,
    sendAnnouncement_clientRequestToken,

    -- * Destructuring the Response
    SendAnnouncementResponse (..),
    newSendAnnouncementResponse,

    -- * Response Lenses
    sendAnnouncementResponse_announcementArn,
    sendAnnouncementResponse_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:/ 'newSendAnnouncement' smart constructor.
data SendAnnouncement = SendAnnouncement'
  { -- | The time to live for an announcement. Default is 300. If delivery
    -- doesn\'t occur within this time, the announcement is not delivered.
    SendAnnouncement -> Maybe Natural
timeToLiveInSeconds :: Prelude.Maybe Prelude.Natural,
    -- | The filters to use to send an announcement to a specified list of rooms.
    -- The supported filter keys are RoomName, ProfileName, RoomArn, and
    -- ProfileArn. To send to all rooms, specify an empty RoomFilters list.
    SendAnnouncement -> [Filter]
roomFilters :: [Filter],
    -- | The announcement content. This can contain only one of the three
    -- possible announcement types (text, SSML or audio).
    SendAnnouncement -> Content
content :: Content,
    -- | The unique, user-specified identifier for the request that ensures
    -- idempotency.
    SendAnnouncement -> Text
clientRequestToken :: Prelude.Text
  }
  deriving (SendAnnouncement -> SendAnnouncement -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SendAnnouncement -> SendAnnouncement -> Bool
$c/= :: SendAnnouncement -> SendAnnouncement -> Bool
== :: SendAnnouncement -> SendAnnouncement -> Bool
$c== :: SendAnnouncement -> SendAnnouncement -> Bool
Prelude.Eq, ReadPrec [SendAnnouncement]
ReadPrec SendAnnouncement
Int -> ReadS SendAnnouncement
ReadS [SendAnnouncement]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SendAnnouncement]
$creadListPrec :: ReadPrec [SendAnnouncement]
readPrec :: ReadPrec SendAnnouncement
$creadPrec :: ReadPrec SendAnnouncement
readList :: ReadS [SendAnnouncement]
$creadList :: ReadS [SendAnnouncement]
readsPrec :: Int -> ReadS SendAnnouncement
$creadsPrec :: Int -> ReadS SendAnnouncement
Prelude.Read, Int -> SendAnnouncement -> ShowS
[SendAnnouncement] -> ShowS
SendAnnouncement -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SendAnnouncement] -> ShowS
$cshowList :: [SendAnnouncement] -> ShowS
show :: SendAnnouncement -> String
$cshow :: SendAnnouncement -> String
showsPrec :: Int -> SendAnnouncement -> ShowS
$cshowsPrec :: Int -> SendAnnouncement -> ShowS
Prelude.Show, forall x. Rep SendAnnouncement x -> SendAnnouncement
forall x. SendAnnouncement -> Rep SendAnnouncement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SendAnnouncement x -> SendAnnouncement
$cfrom :: forall x. SendAnnouncement -> Rep SendAnnouncement x
Prelude.Generic)

-- |
-- Create a value of 'SendAnnouncement' 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:
--
-- 'timeToLiveInSeconds', 'sendAnnouncement_timeToLiveInSeconds' - The time to live for an announcement. Default is 300. If delivery
-- doesn\'t occur within this time, the announcement is not delivered.
--
-- 'roomFilters', 'sendAnnouncement_roomFilters' - The filters to use to send an announcement to a specified list of rooms.
-- The supported filter keys are RoomName, ProfileName, RoomArn, and
-- ProfileArn. To send to all rooms, specify an empty RoomFilters list.
--
-- 'content', 'sendAnnouncement_content' - The announcement content. This can contain only one of the three
-- possible announcement types (text, SSML or audio).
--
-- 'clientRequestToken', 'sendAnnouncement_clientRequestToken' - The unique, user-specified identifier for the request that ensures
-- idempotency.
newSendAnnouncement ::
  -- | 'content'
  Content ->
  -- | 'clientRequestToken'
  Prelude.Text ->
  SendAnnouncement
newSendAnnouncement :: Content -> Text -> SendAnnouncement
newSendAnnouncement Content
pContent_ Text
pClientRequestToken_ =
  SendAnnouncement'
    { $sel:timeToLiveInSeconds:SendAnnouncement' :: Maybe Natural
timeToLiveInSeconds =
        forall a. Maybe a
Prelude.Nothing,
      $sel:roomFilters:SendAnnouncement' :: [Filter]
roomFilters = forall a. Monoid a => a
Prelude.mempty,
      $sel:content:SendAnnouncement' :: Content
content = Content
pContent_,
      $sel:clientRequestToken:SendAnnouncement' :: Text
clientRequestToken = Text
pClientRequestToken_
    }

-- | The time to live for an announcement. Default is 300. If delivery
-- doesn\'t occur within this time, the announcement is not delivered.
sendAnnouncement_timeToLiveInSeconds :: Lens.Lens' SendAnnouncement (Prelude.Maybe Prelude.Natural)
sendAnnouncement_timeToLiveInSeconds :: Lens' SendAnnouncement (Maybe Natural)
sendAnnouncement_timeToLiveInSeconds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendAnnouncement' {Maybe Natural
timeToLiveInSeconds :: Maybe Natural
$sel:timeToLiveInSeconds:SendAnnouncement' :: SendAnnouncement -> Maybe Natural
timeToLiveInSeconds} -> Maybe Natural
timeToLiveInSeconds) (\s :: SendAnnouncement
s@SendAnnouncement' {} Maybe Natural
a -> SendAnnouncement
s {$sel:timeToLiveInSeconds:SendAnnouncement' :: Maybe Natural
timeToLiveInSeconds = Maybe Natural
a} :: SendAnnouncement)

-- | The filters to use to send an announcement to a specified list of rooms.
-- The supported filter keys are RoomName, ProfileName, RoomArn, and
-- ProfileArn. To send to all rooms, specify an empty RoomFilters list.
sendAnnouncement_roomFilters :: Lens.Lens' SendAnnouncement [Filter]
sendAnnouncement_roomFilters :: Lens' SendAnnouncement [Filter]
sendAnnouncement_roomFilters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendAnnouncement' {[Filter]
roomFilters :: [Filter]
$sel:roomFilters:SendAnnouncement' :: SendAnnouncement -> [Filter]
roomFilters} -> [Filter]
roomFilters) (\s :: SendAnnouncement
s@SendAnnouncement' {} [Filter]
a -> SendAnnouncement
s {$sel:roomFilters:SendAnnouncement' :: [Filter]
roomFilters = [Filter]
a} :: SendAnnouncement) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The announcement content. This can contain only one of the three
-- possible announcement types (text, SSML or audio).
sendAnnouncement_content :: Lens.Lens' SendAnnouncement Content
sendAnnouncement_content :: Lens' SendAnnouncement Content
sendAnnouncement_content = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendAnnouncement' {Content
content :: Content
$sel:content:SendAnnouncement' :: SendAnnouncement -> Content
content} -> Content
content) (\s :: SendAnnouncement
s@SendAnnouncement' {} Content
a -> SendAnnouncement
s {$sel:content:SendAnnouncement' :: Content
content = Content
a} :: SendAnnouncement)

-- | The unique, user-specified identifier for the request that ensures
-- idempotency.
sendAnnouncement_clientRequestToken :: Lens.Lens' SendAnnouncement Prelude.Text
sendAnnouncement_clientRequestToken :: Lens' SendAnnouncement Text
sendAnnouncement_clientRequestToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendAnnouncement' {Text
clientRequestToken :: Text
$sel:clientRequestToken:SendAnnouncement' :: SendAnnouncement -> Text
clientRequestToken} -> Text
clientRequestToken) (\s :: SendAnnouncement
s@SendAnnouncement' {} Text
a -> SendAnnouncement
s {$sel:clientRequestToken:SendAnnouncement' :: Text
clientRequestToken = Text
a} :: SendAnnouncement)

instance Core.AWSRequest SendAnnouncement where
  type
    AWSResponse SendAnnouncement =
      SendAnnouncementResponse
  request :: (Service -> Service)
-> SendAnnouncement -> Request SendAnnouncement
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 SendAnnouncement
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse SendAnnouncement)))
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 -> Int -> SendAnnouncementResponse
SendAnnouncementResponse'
            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
"AnnouncementArn")
            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 SendAnnouncement where
  hashWithSalt :: Int -> SendAnnouncement -> Int
hashWithSalt Int
_salt SendAnnouncement' {[Filter]
Maybe Natural
Text
Content
clientRequestToken :: Text
content :: Content
roomFilters :: [Filter]
timeToLiveInSeconds :: Maybe Natural
$sel:clientRequestToken:SendAnnouncement' :: SendAnnouncement -> Text
$sel:content:SendAnnouncement' :: SendAnnouncement -> Content
$sel:roomFilters:SendAnnouncement' :: SendAnnouncement -> [Filter]
$sel:timeToLiveInSeconds:SendAnnouncement' :: SendAnnouncement -> Maybe Natural
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
timeToLiveInSeconds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Filter]
roomFilters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Content
content
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
clientRequestToken

instance Prelude.NFData SendAnnouncement where
  rnf :: SendAnnouncement -> ()
rnf SendAnnouncement' {[Filter]
Maybe Natural
Text
Content
clientRequestToken :: Text
content :: Content
roomFilters :: [Filter]
timeToLiveInSeconds :: Maybe Natural
$sel:clientRequestToken:SendAnnouncement' :: SendAnnouncement -> Text
$sel:content:SendAnnouncement' :: SendAnnouncement -> Content
$sel:roomFilters:SendAnnouncement' :: SendAnnouncement -> [Filter]
$sel:timeToLiveInSeconds:SendAnnouncement' :: SendAnnouncement -> Maybe Natural
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
timeToLiveInSeconds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Filter]
roomFilters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Content
content
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
clientRequestToken

instance Data.ToHeaders SendAnnouncement where
  toHeaders :: SendAnnouncement -> 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.SendAnnouncement" ::
                          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 SendAnnouncement where
  toJSON :: SendAnnouncement -> Value
toJSON SendAnnouncement' {[Filter]
Maybe Natural
Text
Content
clientRequestToken :: Text
content :: Content
roomFilters :: [Filter]
timeToLiveInSeconds :: Maybe Natural
$sel:clientRequestToken:SendAnnouncement' :: SendAnnouncement -> Text
$sel:content:SendAnnouncement' :: SendAnnouncement -> Content
$sel:roomFilters:SendAnnouncement' :: SendAnnouncement -> [Filter]
$sel:timeToLiveInSeconds:SendAnnouncement' :: SendAnnouncement -> Maybe Natural
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"TimeToLiveInSeconds" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
timeToLiveInSeconds,
            forall a. a -> Maybe a
Prelude.Just (Key
"RoomFilters" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [Filter]
roomFilters),
            forall a. a -> Maybe a
Prelude.Just (Key
"Content" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Content
content),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ClientRequestToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
clientRequestToken)
          ]
      )

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

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

-- | /See:/ 'newSendAnnouncementResponse' smart constructor.
data SendAnnouncementResponse = SendAnnouncementResponse'
  { -- | The identifier of the announcement.
    SendAnnouncementResponse -> Maybe Text
announcementArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    SendAnnouncementResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (SendAnnouncementResponse -> SendAnnouncementResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SendAnnouncementResponse -> SendAnnouncementResponse -> Bool
$c/= :: SendAnnouncementResponse -> SendAnnouncementResponse -> Bool
== :: SendAnnouncementResponse -> SendAnnouncementResponse -> Bool
$c== :: SendAnnouncementResponse -> SendAnnouncementResponse -> Bool
Prelude.Eq, ReadPrec [SendAnnouncementResponse]
ReadPrec SendAnnouncementResponse
Int -> ReadS SendAnnouncementResponse
ReadS [SendAnnouncementResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SendAnnouncementResponse]
$creadListPrec :: ReadPrec [SendAnnouncementResponse]
readPrec :: ReadPrec SendAnnouncementResponse
$creadPrec :: ReadPrec SendAnnouncementResponse
readList :: ReadS [SendAnnouncementResponse]
$creadList :: ReadS [SendAnnouncementResponse]
readsPrec :: Int -> ReadS SendAnnouncementResponse
$creadsPrec :: Int -> ReadS SendAnnouncementResponse
Prelude.Read, Int -> SendAnnouncementResponse -> ShowS
[SendAnnouncementResponse] -> ShowS
SendAnnouncementResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SendAnnouncementResponse] -> ShowS
$cshowList :: [SendAnnouncementResponse] -> ShowS
show :: SendAnnouncementResponse -> String
$cshow :: SendAnnouncementResponse -> String
showsPrec :: Int -> SendAnnouncementResponse -> ShowS
$cshowsPrec :: Int -> SendAnnouncementResponse -> ShowS
Prelude.Show, forall x.
Rep SendAnnouncementResponse x -> SendAnnouncementResponse
forall x.
SendAnnouncementResponse -> Rep SendAnnouncementResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep SendAnnouncementResponse x -> SendAnnouncementResponse
$cfrom :: forall x.
SendAnnouncementResponse -> Rep SendAnnouncementResponse x
Prelude.Generic)

-- |
-- Create a value of 'SendAnnouncementResponse' 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:
--
-- 'announcementArn', 'sendAnnouncementResponse_announcementArn' - The identifier of the announcement.
--
-- 'httpStatus', 'sendAnnouncementResponse_httpStatus' - The response's http status code.
newSendAnnouncementResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  SendAnnouncementResponse
newSendAnnouncementResponse :: Int -> SendAnnouncementResponse
newSendAnnouncementResponse Int
pHttpStatus_ =
  SendAnnouncementResponse'
    { $sel:announcementArn:SendAnnouncementResponse' :: Maybe Text
announcementArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:SendAnnouncementResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The identifier of the announcement.
sendAnnouncementResponse_announcementArn :: Lens.Lens' SendAnnouncementResponse (Prelude.Maybe Prelude.Text)
sendAnnouncementResponse_announcementArn :: Lens' SendAnnouncementResponse (Maybe Text)
sendAnnouncementResponse_announcementArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendAnnouncementResponse' {Maybe Text
announcementArn :: Maybe Text
$sel:announcementArn:SendAnnouncementResponse' :: SendAnnouncementResponse -> Maybe Text
announcementArn} -> Maybe Text
announcementArn) (\s :: SendAnnouncementResponse
s@SendAnnouncementResponse' {} Maybe Text
a -> SendAnnouncementResponse
s {$sel:announcementArn:SendAnnouncementResponse' :: Maybe Text
announcementArn = Maybe Text
a} :: SendAnnouncementResponse)

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

instance Prelude.NFData SendAnnouncementResponse where
  rnf :: SendAnnouncementResponse -> ()
rnf SendAnnouncementResponse' {Int
Maybe Text
httpStatus :: Int
announcementArn :: Maybe Text
$sel:httpStatus:SendAnnouncementResponse' :: SendAnnouncementResponse -> Int
$sel:announcementArn:SendAnnouncementResponse' :: SendAnnouncementResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
announcementArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus