{-# 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.FraudDetector.GetEvent
-- 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 details of events stored with Amazon Fraud Detector. This
-- action does not retrieve prediction results.
module Amazonka.FraudDetector.GetEvent
  ( -- * Creating a Request
    GetEvent (..),
    newGetEvent,

    -- * Request Lenses
    getEvent_eventId,
    getEvent_eventTypeName,

    -- * Destructuring the Response
    GetEventResponse (..),
    newGetEventResponse,

    -- * Response Lenses
    getEventResponse_event,
    getEventResponse_httpStatus,
  )
where

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

-- | /See:/ 'newGetEvent' smart constructor.
data GetEvent = GetEvent'
  { -- | The ID of the event to retrieve.
    GetEvent -> Text
eventId :: Prelude.Text,
    -- | The event type of the event to retrieve.
    GetEvent -> Text
eventTypeName :: Prelude.Text
  }
  deriving (GetEvent -> GetEvent -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetEvent -> GetEvent -> Bool
$c/= :: GetEvent -> GetEvent -> Bool
== :: GetEvent -> GetEvent -> Bool
$c== :: GetEvent -> GetEvent -> Bool
Prelude.Eq, ReadPrec [GetEvent]
ReadPrec GetEvent
Int -> ReadS GetEvent
ReadS [GetEvent]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetEvent]
$creadListPrec :: ReadPrec [GetEvent]
readPrec :: ReadPrec GetEvent
$creadPrec :: ReadPrec GetEvent
readList :: ReadS [GetEvent]
$creadList :: ReadS [GetEvent]
readsPrec :: Int -> ReadS GetEvent
$creadsPrec :: Int -> ReadS GetEvent
Prelude.Read, Int -> GetEvent -> ShowS
[GetEvent] -> ShowS
GetEvent -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetEvent] -> ShowS
$cshowList :: [GetEvent] -> ShowS
show :: GetEvent -> String
$cshow :: GetEvent -> String
showsPrec :: Int -> GetEvent -> ShowS
$cshowsPrec :: Int -> GetEvent -> ShowS
Prelude.Show, forall x. Rep GetEvent x -> GetEvent
forall x. GetEvent -> Rep GetEvent x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetEvent x -> GetEvent
$cfrom :: forall x. GetEvent -> Rep GetEvent x
Prelude.Generic)

-- |
-- Create a value of 'GetEvent' 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:
--
-- 'eventId', 'getEvent_eventId' - The ID of the event to retrieve.
--
-- 'eventTypeName', 'getEvent_eventTypeName' - The event type of the event to retrieve.
newGetEvent ::
  -- | 'eventId'
  Prelude.Text ->
  -- | 'eventTypeName'
  Prelude.Text ->
  GetEvent
newGetEvent :: Text -> Text -> GetEvent
newGetEvent Text
pEventId_ Text
pEventTypeName_ =
  GetEvent'
    { $sel:eventId:GetEvent' :: Text
eventId = Text
pEventId_,
      $sel:eventTypeName:GetEvent' :: Text
eventTypeName = Text
pEventTypeName_
    }

-- | The ID of the event to retrieve.
getEvent_eventId :: Lens.Lens' GetEvent Prelude.Text
getEvent_eventId :: Lens' GetEvent Text
getEvent_eventId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEvent' {Text
eventId :: Text
$sel:eventId:GetEvent' :: GetEvent -> Text
eventId} -> Text
eventId) (\s :: GetEvent
s@GetEvent' {} Text
a -> GetEvent
s {$sel:eventId:GetEvent' :: Text
eventId = Text
a} :: GetEvent)

-- | The event type of the event to retrieve.
getEvent_eventTypeName :: Lens.Lens' GetEvent Prelude.Text
getEvent_eventTypeName :: Lens' GetEvent Text
getEvent_eventTypeName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEvent' {Text
eventTypeName :: Text
$sel:eventTypeName:GetEvent' :: GetEvent -> Text
eventTypeName} -> Text
eventTypeName) (\s :: GetEvent
s@GetEvent' {} Text
a -> GetEvent
s {$sel:eventTypeName:GetEvent' :: Text
eventTypeName = Text
a} :: GetEvent)

instance Core.AWSRequest GetEvent where
  type AWSResponse GetEvent = GetEventResponse
  request :: (Service -> Service) -> GetEvent -> Request GetEvent
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 GetEvent
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse GetEvent)))
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 Event -> Int -> GetEventResponse
GetEventResponse'
            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
"event")
            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 GetEvent where
  hashWithSalt :: Int -> GetEvent -> Int
hashWithSalt Int
_salt GetEvent' {Text
eventTypeName :: Text
eventId :: Text
$sel:eventTypeName:GetEvent' :: GetEvent -> Text
$sel:eventId:GetEvent' :: GetEvent -> Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
eventId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
eventTypeName

instance Prelude.NFData GetEvent where
  rnf :: GetEvent -> ()
rnf GetEvent' {Text
eventTypeName :: Text
eventId :: Text
$sel:eventTypeName:GetEvent' :: GetEvent -> Text
$sel:eventId:GetEvent' :: GetEvent -> Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Text
eventId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
eventTypeName

instance Data.ToHeaders GetEvent where
  toHeaders :: GetEvent -> 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
"AWSHawksNestServiceFacade.GetEvent" ::
                          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 GetEvent where
  toJSON :: GetEvent -> Value
toJSON GetEvent' {Text
eventTypeName :: Text
eventId :: Text
$sel:eventTypeName:GetEvent' :: GetEvent -> Text
$sel:eventId:GetEvent' :: GetEvent -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ forall a. a -> Maybe a
Prelude.Just (Key
"eventId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
eventId),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"eventTypeName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
eventTypeName)
          ]
      )

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

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

-- | /See:/ 'newGetEventResponse' smart constructor.
data GetEventResponse = GetEventResponse'
  { -- | The details of the event.
    GetEventResponse -> Maybe Event
event :: Prelude.Maybe Event,
    -- | The response's http status code.
    GetEventResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetEventResponse -> GetEventResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetEventResponse -> GetEventResponse -> Bool
$c/= :: GetEventResponse -> GetEventResponse -> Bool
== :: GetEventResponse -> GetEventResponse -> Bool
$c== :: GetEventResponse -> GetEventResponse -> Bool
Prelude.Eq, Int -> GetEventResponse -> ShowS
[GetEventResponse] -> ShowS
GetEventResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetEventResponse] -> ShowS
$cshowList :: [GetEventResponse] -> ShowS
show :: GetEventResponse -> String
$cshow :: GetEventResponse -> String
showsPrec :: Int -> GetEventResponse -> ShowS
$cshowsPrec :: Int -> GetEventResponse -> ShowS
Prelude.Show, forall x. Rep GetEventResponse x -> GetEventResponse
forall x. GetEventResponse -> Rep GetEventResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetEventResponse x -> GetEventResponse
$cfrom :: forall x. GetEventResponse -> Rep GetEventResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetEventResponse' 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:
--
-- 'event', 'getEventResponse_event' - The details of the event.
--
-- 'httpStatus', 'getEventResponse_httpStatus' - The response's http status code.
newGetEventResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetEventResponse
newGetEventResponse :: Int -> GetEventResponse
newGetEventResponse Int
pHttpStatus_ =
  GetEventResponse'
    { $sel:event:GetEventResponse' :: Maybe Event
event = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetEventResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The details of the event.
getEventResponse_event :: Lens.Lens' GetEventResponse (Prelude.Maybe Event)
getEventResponse_event :: Lens' GetEventResponse (Maybe Event)
getEventResponse_event = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEventResponse' {Maybe Event
event :: Maybe Event
$sel:event:GetEventResponse' :: GetEventResponse -> Maybe Event
event} -> Maybe Event
event) (\s :: GetEventResponse
s@GetEventResponse' {} Maybe Event
a -> GetEventResponse
s {$sel:event:GetEventResponse' :: Maybe Event
event = Maybe Event
a} :: GetEventResponse)

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

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