{-# 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.SES.GetIdentityPolicies
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns the requested sending authorization policies for the given
-- identity (an email address or a domain). The policies are returned as a
-- map of policy names to policy contents. You can retrieve a maximum of 20
-- policies at a time.
--
-- This API is for the identity owner only. If you have not verified the
-- identity, this API will return an error.
--
-- Sending authorization is a feature that enables an identity owner to
-- authorize other senders to use its identities. For information about
-- using sending authorization, see the
-- <https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html Amazon SES Developer Guide>.
--
-- You can execute this operation no more than once per second.
module Amazonka.SES.GetIdentityPolicies
  ( -- * Creating a Request
    GetIdentityPolicies (..),
    newGetIdentityPolicies,

    -- * Request Lenses
    getIdentityPolicies_identity,
    getIdentityPolicies_policyNames,

    -- * Destructuring the Response
    GetIdentityPoliciesResponse (..),
    newGetIdentityPoliciesResponse,

    -- * Response Lenses
    getIdentityPoliciesResponse_httpStatus,
    getIdentityPoliciesResponse_policies,
  )
where

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
import Amazonka.SES.Types

-- | Represents a request to return the requested sending authorization
-- policies for an identity. Sending authorization is an Amazon SES feature
-- that enables you to authorize other senders to use your identities. For
-- information, see the
-- <https://docs.aws.amazon.com/ses/latest/DeveloperGuide/sending-authorization.html Amazon SES Developer Guide>.
--
-- /See:/ 'newGetIdentityPolicies' smart constructor.
data GetIdentityPolicies = GetIdentityPolicies'
  { -- | The identity for which the policies will be retrieved. You can specify
    -- an identity by using its name or by using its Amazon Resource Name
    -- (ARN). Examples: @user\@example.com@, @example.com@,
    -- @arn:aws:ses:us-east-1:123456789012:identity\/example.com@.
    --
    -- To successfully call this API, you must own the identity.
    GetIdentityPolicies -> Text
identity :: Prelude.Text,
    -- | A list of the names of policies to be retrieved. You can retrieve a
    -- maximum of 20 policies at a time. If you do not know the names of the
    -- policies that are attached to the identity, you can use
    -- @ListIdentityPolicies@.
    GetIdentityPolicies -> [Text]
policyNames :: [Prelude.Text]
  }
  deriving (GetIdentityPolicies -> GetIdentityPolicies -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetIdentityPolicies -> GetIdentityPolicies -> Bool
$c/= :: GetIdentityPolicies -> GetIdentityPolicies -> Bool
== :: GetIdentityPolicies -> GetIdentityPolicies -> Bool
$c== :: GetIdentityPolicies -> GetIdentityPolicies -> Bool
Prelude.Eq, ReadPrec [GetIdentityPolicies]
ReadPrec GetIdentityPolicies
Int -> ReadS GetIdentityPolicies
ReadS [GetIdentityPolicies]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetIdentityPolicies]
$creadListPrec :: ReadPrec [GetIdentityPolicies]
readPrec :: ReadPrec GetIdentityPolicies
$creadPrec :: ReadPrec GetIdentityPolicies
readList :: ReadS [GetIdentityPolicies]
$creadList :: ReadS [GetIdentityPolicies]
readsPrec :: Int -> ReadS GetIdentityPolicies
$creadsPrec :: Int -> ReadS GetIdentityPolicies
Prelude.Read, Int -> GetIdentityPolicies -> ShowS
[GetIdentityPolicies] -> ShowS
GetIdentityPolicies -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetIdentityPolicies] -> ShowS
$cshowList :: [GetIdentityPolicies] -> ShowS
show :: GetIdentityPolicies -> String
$cshow :: GetIdentityPolicies -> String
showsPrec :: Int -> GetIdentityPolicies -> ShowS
$cshowsPrec :: Int -> GetIdentityPolicies -> ShowS
Prelude.Show, forall x. Rep GetIdentityPolicies x -> GetIdentityPolicies
forall x. GetIdentityPolicies -> Rep GetIdentityPolicies x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetIdentityPolicies x -> GetIdentityPolicies
$cfrom :: forall x. GetIdentityPolicies -> Rep GetIdentityPolicies x
Prelude.Generic)

-- |
-- Create a value of 'GetIdentityPolicies' 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:
--
-- 'identity', 'getIdentityPolicies_identity' - The identity for which the policies will be retrieved. You can specify
-- an identity by using its name or by using its Amazon Resource Name
-- (ARN). Examples: @user\@example.com@, @example.com@,
-- @arn:aws:ses:us-east-1:123456789012:identity\/example.com@.
--
-- To successfully call this API, you must own the identity.
--
-- 'policyNames', 'getIdentityPolicies_policyNames' - A list of the names of policies to be retrieved. You can retrieve a
-- maximum of 20 policies at a time. If you do not know the names of the
-- policies that are attached to the identity, you can use
-- @ListIdentityPolicies@.
newGetIdentityPolicies ::
  -- | 'identity'
  Prelude.Text ->
  GetIdentityPolicies
newGetIdentityPolicies :: Text -> GetIdentityPolicies
newGetIdentityPolicies Text
pIdentity_ =
  GetIdentityPolicies'
    { $sel:identity:GetIdentityPolicies' :: Text
identity = Text
pIdentity_,
      $sel:policyNames:GetIdentityPolicies' :: [Text]
policyNames = forall a. Monoid a => a
Prelude.mempty
    }

-- | The identity for which the policies will be retrieved. You can specify
-- an identity by using its name or by using its Amazon Resource Name
-- (ARN). Examples: @user\@example.com@, @example.com@,
-- @arn:aws:ses:us-east-1:123456789012:identity\/example.com@.
--
-- To successfully call this API, you must own the identity.
getIdentityPolicies_identity :: Lens.Lens' GetIdentityPolicies Prelude.Text
getIdentityPolicies_identity :: Lens' GetIdentityPolicies Text
getIdentityPolicies_identity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetIdentityPolicies' {Text
identity :: Text
$sel:identity:GetIdentityPolicies' :: GetIdentityPolicies -> Text
identity} -> Text
identity) (\s :: GetIdentityPolicies
s@GetIdentityPolicies' {} Text
a -> GetIdentityPolicies
s {$sel:identity:GetIdentityPolicies' :: Text
identity = Text
a} :: GetIdentityPolicies)

-- | A list of the names of policies to be retrieved. You can retrieve a
-- maximum of 20 policies at a time. If you do not know the names of the
-- policies that are attached to the identity, you can use
-- @ListIdentityPolicies@.
getIdentityPolicies_policyNames :: Lens.Lens' GetIdentityPolicies [Prelude.Text]
getIdentityPolicies_policyNames :: Lens' GetIdentityPolicies [Text]
getIdentityPolicies_policyNames = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetIdentityPolicies' {[Text]
policyNames :: [Text]
$sel:policyNames:GetIdentityPolicies' :: GetIdentityPolicies -> [Text]
policyNames} -> [Text]
policyNames) (\s :: GetIdentityPolicies
s@GetIdentityPolicies' {} [Text]
a -> GetIdentityPolicies
s {$sel:policyNames:GetIdentityPolicies' :: [Text]
policyNames = [Text]
a} :: GetIdentityPolicies) 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

instance Core.AWSRequest GetIdentityPolicies where
  type
    AWSResponse GetIdentityPolicies =
      GetIdentityPoliciesResponse
  request :: (Service -> Service)
-> GetIdentityPolicies -> Request GetIdentityPolicies
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy GetIdentityPolicies
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetIdentityPolicies)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
Text
-> (Int
    -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXMLWrapper
      Text
"GetIdentityPoliciesResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Int -> HashMap Text Text -> GetIdentityPoliciesResponse
GetIdentityPoliciesResponse'
            forall (f :: * -> *) a b. Functor 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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                            forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Policies"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall k v.
(Eq k, Hashable k, FromText k, FromXML v) =>
Text -> Text -> Text -> [Node] -> Either String (HashMap k v)
Data.parseXMLMap Text
"entry" Text
"key" Text
"value"
                        )
      )

instance Prelude.Hashable GetIdentityPolicies where
  hashWithSalt :: Int -> GetIdentityPolicies -> Int
hashWithSalt Int
_salt GetIdentityPolicies' {[Text]
Text
policyNames :: [Text]
identity :: Text
$sel:policyNames:GetIdentityPolicies' :: GetIdentityPolicies -> [Text]
$sel:identity:GetIdentityPolicies' :: GetIdentityPolicies -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
identity
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Text]
policyNames

instance Prelude.NFData GetIdentityPolicies where
  rnf :: GetIdentityPolicies -> ()
rnf GetIdentityPolicies' {[Text]
Text
policyNames :: [Text]
identity :: Text
$sel:policyNames:GetIdentityPolicies' :: GetIdentityPolicies -> [Text]
$sel:identity:GetIdentityPolicies' :: GetIdentityPolicies -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
identity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
policyNames

instance Data.ToHeaders GetIdentityPolicies where
  toHeaders :: GetIdentityPolicies -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

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

instance Data.ToQuery GetIdentityPolicies where
  toQuery :: GetIdentityPolicies -> QueryString
toQuery GetIdentityPolicies' {[Text]
Text
policyNames :: [Text]
identity :: Text
$sel:policyNames:GetIdentityPolicies' :: GetIdentityPolicies -> [Text]
$sel:identity:GetIdentityPolicies' :: GetIdentityPolicies -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"GetIdentityPolicies" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2010-12-01" :: Prelude.ByteString),
        ByteString
"Identity" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
identity,
        ByteString
"PolicyNames"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"member" [Text]
policyNames
      ]

-- | Represents the requested sending authorization policies.
--
-- /See:/ 'newGetIdentityPoliciesResponse' smart constructor.
data GetIdentityPoliciesResponse = GetIdentityPoliciesResponse'
  { -- | The response's http status code.
    GetIdentityPoliciesResponse -> Int
httpStatus :: Prelude.Int,
    -- | A map of policy names to policies.
    GetIdentityPoliciesResponse -> HashMap Text Text
policies :: Prelude.HashMap Prelude.Text Prelude.Text
  }
  deriving (GetIdentityPoliciesResponse -> GetIdentityPoliciesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetIdentityPoliciesResponse -> GetIdentityPoliciesResponse -> Bool
$c/= :: GetIdentityPoliciesResponse -> GetIdentityPoliciesResponse -> Bool
== :: GetIdentityPoliciesResponse -> GetIdentityPoliciesResponse -> Bool
$c== :: GetIdentityPoliciesResponse -> GetIdentityPoliciesResponse -> Bool
Prelude.Eq, ReadPrec [GetIdentityPoliciesResponse]
ReadPrec GetIdentityPoliciesResponse
Int -> ReadS GetIdentityPoliciesResponse
ReadS [GetIdentityPoliciesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetIdentityPoliciesResponse]
$creadListPrec :: ReadPrec [GetIdentityPoliciesResponse]
readPrec :: ReadPrec GetIdentityPoliciesResponse
$creadPrec :: ReadPrec GetIdentityPoliciesResponse
readList :: ReadS [GetIdentityPoliciesResponse]
$creadList :: ReadS [GetIdentityPoliciesResponse]
readsPrec :: Int -> ReadS GetIdentityPoliciesResponse
$creadsPrec :: Int -> ReadS GetIdentityPoliciesResponse
Prelude.Read, Int -> GetIdentityPoliciesResponse -> ShowS
[GetIdentityPoliciesResponse] -> ShowS
GetIdentityPoliciesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetIdentityPoliciesResponse] -> ShowS
$cshowList :: [GetIdentityPoliciesResponse] -> ShowS
show :: GetIdentityPoliciesResponse -> String
$cshow :: GetIdentityPoliciesResponse -> String
showsPrec :: Int -> GetIdentityPoliciesResponse -> ShowS
$cshowsPrec :: Int -> GetIdentityPoliciesResponse -> ShowS
Prelude.Show, forall x.
Rep GetIdentityPoliciesResponse x -> GetIdentityPoliciesResponse
forall x.
GetIdentityPoliciesResponse -> Rep GetIdentityPoliciesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetIdentityPoliciesResponse x -> GetIdentityPoliciesResponse
$cfrom :: forall x.
GetIdentityPoliciesResponse -> Rep GetIdentityPoliciesResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetIdentityPoliciesResponse' 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:
--
-- 'httpStatus', 'getIdentityPoliciesResponse_httpStatus' - The response's http status code.
--
-- 'policies', 'getIdentityPoliciesResponse_policies' - A map of policy names to policies.
newGetIdentityPoliciesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetIdentityPoliciesResponse
newGetIdentityPoliciesResponse :: Int -> GetIdentityPoliciesResponse
newGetIdentityPoliciesResponse Int
pHttpStatus_ =
  GetIdentityPoliciesResponse'
    { $sel:httpStatus:GetIdentityPoliciesResponse' :: Int
httpStatus =
        Int
pHttpStatus_,
      $sel:policies:GetIdentityPoliciesResponse' :: HashMap Text Text
policies = forall a. Monoid a => a
Prelude.mempty
    }

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

-- | A map of policy names to policies.
getIdentityPoliciesResponse_policies :: Lens.Lens' GetIdentityPoliciesResponse (Prelude.HashMap Prelude.Text Prelude.Text)
getIdentityPoliciesResponse_policies :: Lens' GetIdentityPoliciesResponse (HashMap Text Text)
getIdentityPoliciesResponse_policies = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetIdentityPoliciesResponse' {HashMap Text Text
policies :: HashMap Text Text
$sel:policies:GetIdentityPoliciesResponse' :: GetIdentityPoliciesResponse -> HashMap Text Text
policies} -> HashMap Text Text
policies) (\s :: GetIdentityPoliciesResponse
s@GetIdentityPoliciesResponse' {} HashMap Text Text
a -> GetIdentityPoliciesResponse
s {$sel:policies:GetIdentityPoliciesResponse' :: HashMap Text Text
policies = HashMap Text Text
a} :: GetIdentityPoliciesResponse) 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

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