{-# 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.S3.GetBucketPolicyStatus
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves the policy status for an Amazon S3 bucket, indicating whether
-- the bucket is public. In order to use this operation, you must have the
-- @s3:GetBucketPolicyStatus@ permission. For more information about Amazon
-- S3 permissions, see
-- <https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html Specifying Permissions in a Policy>.
--
-- For more information about when Amazon S3 considers a bucket public, see
-- <https://docs.aws.amazon.com/AmazonS3/latest/dev/access-control-block-public-access.html#access-control-block-public-access-policy-status The Meaning of \"Public\">.
--
-- The following operations are related to @GetBucketPolicyStatus@:
--
-- -   <https://docs.aws.amazon.com/AmazonS3/latest/dev/access-control-block-public-access.html Using Amazon S3 Block Public Access>
--
-- -   <https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetPublicAccessBlock.html GetPublicAccessBlock>
--
-- -   <https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutPublicAccessBlock.html PutPublicAccessBlock>
--
-- -   <https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeletePublicAccessBlock.html DeletePublicAccessBlock>
module Amazonka.S3.GetBucketPolicyStatus
  ( -- * Creating a Request
    GetBucketPolicyStatus (..),
    newGetBucketPolicyStatus,

    -- * Request Lenses
    getBucketPolicyStatus_expectedBucketOwner,
    getBucketPolicyStatus_bucket,

    -- * Destructuring the Response
    GetBucketPolicyStatusResponse (..),
    newGetBucketPolicyStatusResponse,

    -- * Response Lenses
    getBucketPolicyStatusResponse_policyStatus,
    getBucketPolicyStatusResponse_httpStatus,
  )
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.S3.Types

-- | /See:/ 'newGetBucketPolicyStatus' smart constructor.
data GetBucketPolicyStatus = GetBucketPolicyStatus'
  { -- | The account ID of the expected bucket owner. If the bucket is owned by a
    -- different account, the request fails with the HTTP status code
    -- @403 Forbidden@ (access denied).
    GetBucketPolicyStatus -> Maybe Text
expectedBucketOwner :: Prelude.Maybe Prelude.Text,
    -- | The name of the Amazon S3 bucket whose policy status you want to
    -- retrieve.
    GetBucketPolicyStatus -> BucketName
bucket :: BucketName
  }
  deriving (GetBucketPolicyStatus -> GetBucketPolicyStatus -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetBucketPolicyStatus -> GetBucketPolicyStatus -> Bool
$c/= :: GetBucketPolicyStatus -> GetBucketPolicyStatus -> Bool
== :: GetBucketPolicyStatus -> GetBucketPolicyStatus -> Bool
$c== :: GetBucketPolicyStatus -> GetBucketPolicyStatus -> Bool
Prelude.Eq, ReadPrec [GetBucketPolicyStatus]
ReadPrec GetBucketPolicyStatus
Int -> ReadS GetBucketPolicyStatus
ReadS [GetBucketPolicyStatus]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetBucketPolicyStatus]
$creadListPrec :: ReadPrec [GetBucketPolicyStatus]
readPrec :: ReadPrec GetBucketPolicyStatus
$creadPrec :: ReadPrec GetBucketPolicyStatus
readList :: ReadS [GetBucketPolicyStatus]
$creadList :: ReadS [GetBucketPolicyStatus]
readsPrec :: Int -> ReadS GetBucketPolicyStatus
$creadsPrec :: Int -> ReadS GetBucketPolicyStatus
Prelude.Read, Int -> GetBucketPolicyStatus -> ShowS
[GetBucketPolicyStatus] -> ShowS
GetBucketPolicyStatus -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetBucketPolicyStatus] -> ShowS
$cshowList :: [GetBucketPolicyStatus] -> ShowS
show :: GetBucketPolicyStatus -> String
$cshow :: GetBucketPolicyStatus -> String
showsPrec :: Int -> GetBucketPolicyStatus -> ShowS
$cshowsPrec :: Int -> GetBucketPolicyStatus -> ShowS
Prelude.Show, forall x. Rep GetBucketPolicyStatus x -> GetBucketPolicyStatus
forall x. GetBucketPolicyStatus -> Rep GetBucketPolicyStatus x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetBucketPolicyStatus x -> GetBucketPolicyStatus
$cfrom :: forall x. GetBucketPolicyStatus -> Rep GetBucketPolicyStatus x
Prelude.Generic)

-- |
-- Create a value of 'GetBucketPolicyStatus' 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:
--
-- 'expectedBucketOwner', 'getBucketPolicyStatus_expectedBucketOwner' - The account ID of the expected bucket owner. If the bucket is owned by a
-- different account, the request fails with the HTTP status code
-- @403 Forbidden@ (access denied).
--
-- 'bucket', 'getBucketPolicyStatus_bucket' - The name of the Amazon S3 bucket whose policy status you want to
-- retrieve.
newGetBucketPolicyStatus ::
  -- | 'bucket'
  BucketName ->
  GetBucketPolicyStatus
newGetBucketPolicyStatus :: BucketName -> GetBucketPolicyStatus
newGetBucketPolicyStatus BucketName
pBucket_ =
  GetBucketPolicyStatus'
    { $sel:expectedBucketOwner:GetBucketPolicyStatus' :: Maybe Text
expectedBucketOwner =
        forall a. Maybe a
Prelude.Nothing,
      $sel:bucket:GetBucketPolicyStatus' :: BucketName
bucket = BucketName
pBucket_
    }

-- | The account ID of the expected bucket owner. If the bucket is owned by a
-- different account, the request fails with the HTTP status code
-- @403 Forbidden@ (access denied).
getBucketPolicyStatus_expectedBucketOwner :: Lens.Lens' GetBucketPolicyStatus (Prelude.Maybe Prelude.Text)
getBucketPolicyStatus_expectedBucketOwner :: Lens' GetBucketPolicyStatus (Maybe Text)
getBucketPolicyStatus_expectedBucketOwner = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetBucketPolicyStatus' {Maybe Text
expectedBucketOwner :: Maybe Text
$sel:expectedBucketOwner:GetBucketPolicyStatus' :: GetBucketPolicyStatus -> Maybe Text
expectedBucketOwner} -> Maybe Text
expectedBucketOwner) (\s :: GetBucketPolicyStatus
s@GetBucketPolicyStatus' {} Maybe Text
a -> GetBucketPolicyStatus
s {$sel:expectedBucketOwner:GetBucketPolicyStatus' :: Maybe Text
expectedBucketOwner = Maybe Text
a} :: GetBucketPolicyStatus)

-- | The name of the Amazon S3 bucket whose policy status you want to
-- retrieve.
getBucketPolicyStatus_bucket :: Lens.Lens' GetBucketPolicyStatus BucketName
getBucketPolicyStatus_bucket :: Lens' GetBucketPolicyStatus BucketName
getBucketPolicyStatus_bucket = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetBucketPolicyStatus' {BucketName
bucket :: BucketName
$sel:bucket:GetBucketPolicyStatus' :: GetBucketPolicyStatus -> BucketName
bucket} -> BucketName
bucket) (\s :: GetBucketPolicyStatus
s@GetBucketPolicyStatus' {} BucketName
a -> GetBucketPolicyStatus
s {$sel:bucket:GetBucketPolicyStatus' :: BucketName
bucket = BucketName
a} :: GetBucketPolicyStatus)

instance Core.AWSRequest GetBucketPolicyStatus where
  type
    AWSResponse GetBucketPolicyStatus =
      GetBucketPolicyStatusResponse
  request :: (Service -> Service)
-> GetBucketPolicyStatus -> Request GetBucketPolicyStatus
request Service -> Service
overrides =
    forall a. Request a -> Request a
Request.s3vhost
      forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 GetBucketPolicyStatus
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetBucketPolicyStatus)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe PolicyStatus -> Int -> GetBucketPolicyStatusResponse
GetBucketPolicyStatusResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (forall a. FromXML a => [Node] -> Either String a
Data.parseXML [Node]
x)
            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 GetBucketPolicyStatus where
  hashWithSalt :: Int -> GetBucketPolicyStatus -> Int
hashWithSalt Int
_salt GetBucketPolicyStatus' {Maybe Text
BucketName
bucket :: BucketName
expectedBucketOwner :: Maybe Text
$sel:bucket:GetBucketPolicyStatus' :: GetBucketPolicyStatus -> BucketName
$sel:expectedBucketOwner:GetBucketPolicyStatus' :: GetBucketPolicyStatus -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
expectedBucketOwner
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` BucketName
bucket

instance Prelude.NFData GetBucketPolicyStatus where
  rnf :: GetBucketPolicyStatus -> ()
rnf GetBucketPolicyStatus' {Maybe Text
BucketName
bucket :: BucketName
expectedBucketOwner :: Maybe Text
$sel:bucket:GetBucketPolicyStatus' :: GetBucketPolicyStatus -> BucketName
$sel:expectedBucketOwner:GetBucketPolicyStatus' :: GetBucketPolicyStatus -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
expectedBucketOwner
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf BucketName
bucket

instance Data.ToHeaders GetBucketPolicyStatus where
  toHeaders :: GetBucketPolicyStatus -> ResponseHeaders
toHeaders GetBucketPolicyStatus' {Maybe Text
BucketName
bucket :: BucketName
expectedBucketOwner :: Maybe Text
$sel:bucket:GetBucketPolicyStatus' :: GetBucketPolicyStatus -> BucketName
$sel:expectedBucketOwner:GetBucketPolicyStatus' :: GetBucketPolicyStatus -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ HeaderName
"x-amz-expected-bucket-owner"
          forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# Maybe Text
expectedBucketOwner
      ]

instance Data.ToPath GetBucketPolicyStatus where
  toPath :: GetBucketPolicyStatus -> ByteString
toPath GetBucketPolicyStatus' {Maybe Text
BucketName
bucket :: BucketName
expectedBucketOwner :: Maybe Text
$sel:bucket:GetBucketPolicyStatus' :: GetBucketPolicyStatus -> BucketName
$sel:expectedBucketOwner:GetBucketPolicyStatus' :: GetBucketPolicyStatus -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat [ByteString
"/", forall a. ToByteString a => a -> ByteString
Data.toBS BucketName
bucket]

instance Data.ToQuery GetBucketPolicyStatus where
  toQuery :: GetBucketPolicyStatus -> QueryString
toQuery =
    forall a b. a -> b -> a
Prelude.const (forall a. Monoid a => [a] -> a
Prelude.mconcat [QueryString
"policyStatus"])

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

-- |
-- Create a value of 'GetBucketPolicyStatusResponse' 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:
--
-- 'policyStatus', 'getBucketPolicyStatusResponse_policyStatus' - The policy status for the specified bucket.
--
-- 'httpStatus', 'getBucketPolicyStatusResponse_httpStatus' - The response's http status code.
newGetBucketPolicyStatusResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetBucketPolicyStatusResponse
newGetBucketPolicyStatusResponse :: Int -> GetBucketPolicyStatusResponse
newGetBucketPolicyStatusResponse Int
pHttpStatus_ =
  GetBucketPolicyStatusResponse'
    { $sel:policyStatus:GetBucketPolicyStatusResponse' :: Maybe PolicyStatus
policyStatus =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetBucketPolicyStatusResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The policy status for the specified bucket.
getBucketPolicyStatusResponse_policyStatus :: Lens.Lens' GetBucketPolicyStatusResponse (Prelude.Maybe PolicyStatus)
getBucketPolicyStatusResponse_policyStatus :: Lens' GetBucketPolicyStatusResponse (Maybe PolicyStatus)
getBucketPolicyStatusResponse_policyStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetBucketPolicyStatusResponse' {Maybe PolicyStatus
policyStatus :: Maybe PolicyStatus
$sel:policyStatus:GetBucketPolicyStatusResponse' :: GetBucketPolicyStatusResponse -> Maybe PolicyStatus
policyStatus} -> Maybe PolicyStatus
policyStatus) (\s :: GetBucketPolicyStatusResponse
s@GetBucketPolicyStatusResponse' {} Maybe PolicyStatus
a -> GetBucketPolicyStatusResponse
s {$sel:policyStatus:GetBucketPolicyStatusResponse' :: Maybe PolicyStatus
policyStatus = Maybe PolicyStatus
a} :: GetBucketPolicyStatusResponse)

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

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