{-# 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.APIGateway.GetUsage
-- 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 usage data of a usage plan in a specified time interval.
--
-- This operation returns paginated results.
module Amazonka.APIGateway.GetUsage
  ( -- * Creating a Request
    GetUsage (..),
    newGetUsage,

    -- * Request Lenses
    getUsage_keyId,
    getUsage_limit,
    getUsage_position,
    getUsage_usagePlanId,
    getUsage_startDate,
    getUsage_endDate,

    -- * Destructuring the Response
    Usage (..),
    newUsage,

    -- * Response Lenses
    usage_endDate,
    usage_items,
    usage_position,
    usage_startDate,
    usage_usagePlanId,
  )
where

import Amazonka.APIGateway.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

-- | The GET request to get the usage data of a usage plan in a specified
-- time interval.
--
-- /See:/ 'newGetUsage' smart constructor.
data GetUsage = GetUsage'
  { -- | The Id of the API key associated with the resultant usage data.
    GetUsage -> Maybe Text
keyId :: Prelude.Maybe Prelude.Text,
    -- | The maximum number of returned results per page. The default value is 25
    -- and the maximum value is 500.
    GetUsage -> Maybe Int
limit :: Prelude.Maybe Prelude.Int,
    -- | The current pagination position in the paged result set.
    GetUsage -> Maybe Text
position :: Prelude.Maybe Prelude.Text,
    -- | The Id of the usage plan associated with the usage data.
    GetUsage -> Text
usagePlanId :: Prelude.Text,
    -- | The starting date (e.g., 2016-01-01) of the usage data.
    GetUsage -> Text
startDate :: Prelude.Text,
    -- | The ending date (e.g., 2016-12-31) of the usage data.
    GetUsage -> Text
endDate :: Prelude.Text
  }
  deriving (GetUsage -> GetUsage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetUsage -> GetUsage -> Bool
$c/= :: GetUsage -> GetUsage -> Bool
== :: GetUsage -> GetUsage -> Bool
$c== :: GetUsage -> GetUsage -> Bool
Prelude.Eq, ReadPrec [GetUsage]
ReadPrec GetUsage
Int -> ReadS GetUsage
ReadS [GetUsage]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetUsage]
$creadListPrec :: ReadPrec [GetUsage]
readPrec :: ReadPrec GetUsage
$creadPrec :: ReadPrec GetUsage
readList :: ReadS [GetUsage]
$creadList :: ReadS [GetUsage]
readsPrec :: Int -> ReadS GetUsage
$creadsPrec :: Int -> ReadS GetUsage
Prelude.Read, Int -> GetUsage -> ShowS
[GetUsage] -> ShowS
GetUsage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetUsage] -> ShowS
$cshowList :: [GetUsage] -> ShowS
show :: GetUsage -> String
$cshow :: GetUsage -> String
showsPrec :: Int -> GetUsage -> ShowS
$cshowsPrec :: Int -> GetUsage -> ShowS
Prelude.Show, forall x. Rep GetUsage x -> GetUsage
forall x. GetUsage -> Rep GetUsage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetUsage x -> GetUsage
$cfrom :: forall x. GetUsage -> Rep GetUsage x
Prelude.Generic)

-- |
-- Create a value of 'GetUsage' 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:
--
-- 'keyId', 'getUsage_keyId' - The Id of the API key associated with the resultant usage data.
--
-- 'limit', 'getUsage_limit' - The maximum number of returned results per page. The default value is 25
-- and the maximum value is 500.
--
-- 'position', 'getUsage_position' - The current pagination position in the paged result set.
--
-- 'usagePlanId', 'getUsage_usagePlanId' - The Id of the usage plan associated with the usage data.
--
-- 'startDate', 'getUsage_startDate' - The starting date (e.g., 2016-01-01) of the usage data.
--
-- 'endDate', 'getUsage_endDate' - The ending date (e.g., 2016-12-31) of the usage data.
newGetUsage ::
  -- | 'usagePlanId'
  Prelude.Text ->
  -- | 'startDate'
  Prelude.Text ->
  -- | 'endDate'
  Prelude.Text ->
  GetUsage
newGetUsage :: Text -> Text -> Text -> GetUsage
newGetUsage Text
pUsagePlanId_ Text
pStartDate_ Text
pEndDate_ =
  GetUsage'
    { $sel:keyId:GetUsage' :: Maybe Text
keyId = forall a. Maybe a
Prelude.Nothing,
      $sel:limit:GetUsage' :: Maybe Int
limit = forall a. Maybe a
Prelude.Nothing,
      $sel:position:GetUsage' :: Maybe Text
position = forall a. Maybe a
Prelude.Nothing,
      $sel:usagePlanId:GetUsage' :: Text
usagePlanId = Text
pUsagePlanId_,
      $sel:startDate:GetUsage' :: Text
startDate = Text
pStartDate_,
      $sel:endDate:GetUsage' :: Text
endDate = Text
pEndDate_
    }

-- | The Id of the API key associated with the resultant usage data.
getUsage_keyId :: Lens.Lens' GetUsage (Prelude.Maybe Prelude.Text)
getUsage_keyId :: Lens' GetUsage (Maybe Text)
getUsage_keyId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUsage' {Maybe Text
keyId :: Maybe Text
$sel:keyId:GetUsage' :: GetUsage -> Maybe Text
keyId} -> Maybe Text
keyId) (\s :: GetUsage
s@GetUsage' {} Maybe Text
a -> GetUsage
s {$sel:keyId:GetUsage' :: Maybe Text
keyId = Maybe Text
a} :: GetUsage)

-- | The maximum number of returned results per page. The default value is 25
-- and the maximum value is 500.
getUsage_limit :: Lens.Lens' GetUsage (Prelude.Maybe Prelude.Int)
getUsage_limit :: Lens' GetUsage (Maybe Int)
getUsage_limit = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUsage' {Maybe Int
limit :: Maybe Int
$sel:limit:GetUsage' :: GetUsage -> Maybe Int
limit} -> Maybe Int
limit) (\s :: GetUsage
s@GetUsage' {} Maybe Int
a -> GetUsage
s {$sel:limit:GetUsage' :: Maybe Int
limit = Maybe Int
a} :: GetUsage)

-- | The current pagination position in the paged result set.
getUsage_position :: Lens.Lens' GetUsage (Prelude.Maybe Prelude.Text)
getUsage_position :: Lens' GetUsage (Maybe Text)
getUsage_position = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUsage' {Maybe Text
position :: Maybe Text
$sel:position:GetUsage' :: GetUsage -> Maybe Text
position} -> Maybe Text
position) (\s :: GetUsage
s@GetUsage' {} Maybe Text
a -> GetUsage
s {$sel:position:GetUsage' :: Maybe Text
position = Maybe Text
a} :: GetUsage)

-- | The Id of the usage plan associated with the usage data.
getUsage_usagePlanId :: Lens.Lens' GetUsage Prelude.Text
getUsage_usagePlanId :: Lens' GetUsage Text
getUsage_usagePlanId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUsage' {Text
usagePlanId :: Text
$sel:usagePlanId:GetUsage' :: GetUsage -> Text
usagePlanId} -> Text
usagePlanId) (\s :: GetUsage
s@GetUsage' {} Text
a -> GetUsage
s {$sel:usagePlanId:GetUsage' :: Text
usagePlanId = Text
a} :: GetUsage)

-- | The starting date (e.g., 2016-01-01) of the usage data.
getUsage_startDate :: Lens.Lens' GetUsage Prelude.Text
getUsage_startDate :: Lens' GetUsage Text
getUsage_startDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUsage' {Text
startDate :: Text
$sel:startDate:GetUsage' :: GetUsage -> Text
startDate} -> Text
startDate) (\s :: GetUsage
s@GetUsage' {} Text
a -> GetUsage
s {$sel:startDate:GetUsage' :: Text
startDate = Text
a} :: GetUsage)

-- | The ending date (e.g., 2016-12-31) of the usage data.
getUsage_endDate :: Lens.Lens' GetUsage Prelude.Text
getUsage_endDate :: Lens' GetUsage Text
getUsage_endDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetUsage' {Text
endDate :: Text
$sel:endDate:GetUsage' :: GetUsage -> Text
endDate} -> Text
endDate) (\s :: GetUsage
s@GetUsage' {} Text
a -> GetUsage
s {$sel:endDate:GetUsage' :: Text
endDate = Text
a} :: GetUsage)

instance Core.AWSPager GetUsage where
  page :: GetUsage -> AWSResponse GetUsage -> Maybe GetUsage
page GetUsage
rq AWSResponse GetUsage
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        (AWSResponse GetUsage
rs forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' Usage (Maybe Text)
usage_position forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just) =
        forall a. Maybe a
Prelude.Nothing
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        (AWSResponse GetUsage
rs forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' Usage (Maybe (HashMap Text [[Integer]]))
usage_items forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ GetUsage
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' GetUsage (Maybe Text)
getUsage_position
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse GetUsage
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' Usage (Maybe Text)
usage_position
          forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just

instance Core.AWSRequest GetUsage where
  type AWSResponse GetUsage = Usage
  request :: (Service -> Service) -> GetUsage -> Request GetUsage
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 GetUsage
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse GetUsage)))
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 -> forall a. FromJSON a => Object -> Either String a
Data.eitherParseJSON Object
x)

instance Prelude.Hashable GetUsage where
  hashWithSalt :: Int -> GetUsage -> Int
hashWithSalt Int
_salt GetUsage' {Maybe Int
Maybe Text
Text
endDate :: Text
startDate :: Text
usagePlanId :: Text
position :: Maybe Text
limit :: Maybe Int
keyId :: Maybe Text
$sel:endDate:GetUsage' :: GetUsage -> Text
$sel:startDate:GetUsage' :: GetUsage -> Text
$sel:usagePlanId:GetUsage' :: GetUsage -> Text
$sel:position:GetUsage' :: GetUsage -> Maybe Text
$sel:limit:GetUsage' :: GetUsage -> Maybe Int
$sel:keyId:GetUsage' :: GetUsage -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
keyId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
limit
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
position
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
usagePlanId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
startDate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
endDate

instance Prelude.NFData GetUsage where
  rnf :: GetUsage -> ()
rnf GetUsage' {Maybe Int
Maybe Text
Text
endDate :: Text
startDate :: Text
usagePlanId :: Text
position :: Maybe Text
limit :: Maybe Int
keyId :: Maybe Text
$sel:endDate:GetUsage' :: GetUsage -> Text
$sel:startDate:GetUsage' :: GetUsage -> Text
$sel:usagePlanId:GetUsage' :: GetUsage -> Text
$sel:position:GetUsage' :: GetUsage -> Maybe Text
$sel:limit:GetUsage' :: GetUsage -> Maybe Int
$sel:keyId:GetUsage' :: GetUsage -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
keyId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
limit
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
position
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
usagePlanId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
startDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
endDate

instance Data.ToHeaders GetUsage where
  toHeaders :: GetUsage -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Accept"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# (ByteString
"application/json" :: Prelude.ByteString)
          ]
      )

instance Data.ToPath GetUsage where
  toPath :: GetUsage -> ByteString
toPath GetUsage' {Maybe Int
Maybe Text
Text
endDate :: Text
startDate :: Text
usagePlanId :: Text
position :: Maybe Text
limit :: Maybe Int
keyId :: Maybe Text
$sel:endDate:GetUsage' :: GetUsage -> Text
$sel:startDate:GetUsage' :: GetUsage -> Text
$sel:usagePlanId:GetUsage' :: GetUsage -> Text
$sel:position:GetUsage' :: GetUsage -> Maybe Text
$sel:limit:GetUsage' :: GetUsage -> Maybe Int
$sel:keyId:GetUsage' :: GetUsage -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/usageplans/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
usagePlanId, ByteString
"/usage"]

instance Data.ToQuery GetUsage where
  toQuery :: GetUsage -> QueryString
toQuery GetUsage' {Maybe Int
Maybe Text
Text
endDate :: Text
startDate :: Text
usagePlanId :: Text
position :: Maybe Text
limit :: Maybe Int
keyId :: Maybe Text
$sel:endDate:GetUsage' :: GetUsage -> Text
$sel:startDate:GetUsage' :: GetUsage -> Text
$sel:usagePlanId:GetUsage' :: GetUsage -> Text
$sel:position:GetUsage' :: GetUsage -> Maybe Text
$sel:limit:GetUsage' :: GetUsage -> Maybe Int
$sel:keyId:GetUsage' :: GetUsage -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"keyId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
keyId,
        ByteString
"limit" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
limit,
        ByteString
"position" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
position,
        ByteString
"startDate" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
startDate,
        ByteString
"endDate" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
endDate
      ]