{-# 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.M2.CreateDataSetImportTask
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Starts a data set import task for a specific application.
module Amazonka.M2.CreateDataSetImportTask
  ( -- * Creating a Request
    CreateDataSetImportTask (..),
    newCreateDataSetImportTask,

    -- * Request Lenses
    createDataSetImportTask_clientToken,
    createDataSetImportTask_applicationId,
    createDataSetImportTask_importConfig,

    -- * Destructuring the Response
    CreateDataSetImportTaskResponse (..),
    newCreateDataSetImportTaskResponse,

    -- * Response Lenses
    createDataSetImportTaskResponse_httpStatus,
    createDataSetImportTaskResponse_taskId,
  )
where

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

-- | /See:/ 'newCreateDataSetImportTask' smart constructor.
data CreateDataSetImportTask = CreateDataSetImportTask'
  { -- | Unique, case-sensitive identifier you provide to ensure the idempotency
    -- of the request to create a data set import. The service generates the
    -- clientToken when the API call is triggered. The token expires after one
    -- hour, so if you retry the API within this timeframe with the same
    -- clientToken, you will get the same response. The service also handles
    -- deleting the clientToken after it expires.
    CreateDataSetImportTask -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | The unique identifier of the application for which you want to import
    -- data sets.
    CreateDataSetImportTask -> Text
applicationId :: Prelude.Text,
    -- | The data set import task configuration.
    CreateDataSetImportTask -> DataSetImportConfig
importConfig :: DataSetImportConfig
  }
  deriving (CreateDataSetImportTask -> CreateDataSetImportTask -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDataSetImportTask -> CreateDataSetImportTask -> Bool
$c/= :: CreateDataSetImportTask -> CreateDataSetImportTask -> Bool
== :: CreateDataSetImportTask -> CreateDataSetImportTask -> Bool
$c== :: CreateDataSetImportTask -> CreateDataSetImportTask -> Bool
Prelude.Eq, ReadPrec [CreateDataSetImportTask]
ReadPrec CreateDataSetImportTask
Int -> ReadS CreateDataSetImportTask
ReadS [CreateDataSetImportTask]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDataSetImportTask]
$creadListPrec :: ReadPrec [CreateDataSetImportTask]
readPrec :: ReadPrec CreateDataSetImportTask
$creadPrec :: ReadPrec CreateDataSetImportTask
readList :: ReadS [CreateDataSetImportTask]
$creadList :: ReadS [CreateDataSetImportTask]
readsPrec :: Int -> ReadS CreateDataSetImportTask
$creadsPrec :: Int -> ReadS CreateDataSetImportTask
Prelude.Read, Int -> CreateDataSetImportTask -> ShowS
[CreateDataSetImportTask] -> ShowS
CreateDataSetImportTask -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDataSetImportTask] -> ShowS
$cshowList :: [CreateDataSetImportTask] -> ShowS
show :: CreateDataSetImportTask -> String
$cshow :: CreateDataSetImportTask -> String
showsPrec :: Int -> CreateDataSetImportTask -> ShowS
$cshowsPrec :: Int -> CreateDataSetImportTask -> ShowS
Prelude.Show, forall x. Rep CreateDataSetImportTask x -> CreateDataSetImportTask
forall x. CreateDataSetImportTask -> Rep CreateDataSetImportTask x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateDataSetImportTask x -> CreateDataSetImportTask
$cfrom :: forall x. CreateDataSetImportTask -> Rep CreateDataSetImportTask x
Prelude.Generic)

-- |
-- Create a value of 'CreateDataSetImportTask' 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:
--
-- 'clientToken', 'createDataSetImportTask_clientToken' - Unique, case-sensitive identifier you provide to ensure the idempotency
-- of the request to create a data set import. The service generates the
-- clientToken when the API call is triggered. The token expires after one
-- hour, so if you retry the API within this timeframe with the same
-- clientToken, you will get the same response. The service also handles
-- deleting the clientToken after it expires.
--
-- 'applicationId', 'createDataSetImportTask_applicationId' - The unique identifier of the application for which you want to import
-- data sets.
--
-- 'importConfig', 'createDataSetImportTask_importConfig' - The data set import task configuration.
newCreateDataSetImportTask ::
  -- | 'applicationId'
  Prelude.Text ->
  -- | 'importConfig'
  DataSetImportConfig ->
  CreateDataSetImportTask
newCreateDataSetImportTask :: Text -> DataSetImportConfig -> CreateDataSetImportTask
newCreateDataSetImportTask
  Text
pApplicationId_
  DataSetImportConfig
pImportConfig_ =
    CreateDataSetImportTask'
      { $sel:clientToken:CreateDataSetImportTask' :: Maybe Text
clientToken =
          forall a. Maybe a
Prelude.Nothing,
        $sel:applicationId:CreateDataSetImportTask' :: Text
applicationId = Text
pApplicationId_,
        $sel:importConfig:CreateDataSetImportTask' :: DataSetImportConfig
importConfig = DataSetImportConfig
pImportConfig_
      }

-- | Unique, case-sensitive identifier you provide to ensure the idempotency
-- of the request to create a data set import. The service generates the
-- clientToken when the API call is triggered. The token expires after one
-- hour, so if you retry the API within this timeframe with the same
-- clientToken, you will get the same response. The service also handles
-- deleting the clientToken after it expires.
createDataSetImportTask_clientToken :: Lens.Lens' CreateDataSetImportTask (Prelude.Maybe Prelude.Text)
createDataSetImportTask_clientToken :: Lens' CreateDataSetImportTask (Maybe Text)
createDataSetImportTask_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetImportTask' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateDataSetImportTask' :: CreateDataSetImportTask -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateDataSetImportTask
s@CreateDataSetImportTask' {} Maybe Text
a -> CreateDataSetImportTask
s {$sel:clientToken:CreateDataSetImportTask' :: Maybe Text
clientToken = Maybe Text
a} :: CreateDataSetImportTask)

-- | The unique identifier of the application for which you want to import
-- data sets.
createDataSetImportTask_applicationId :: Lens.Lens' CreateDataSetImportTask Prelude.Text
createDataSetImportTask_applicationId :: Lens' CreateDataSetImportTask Text
createDataSetImportTask_applicationId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetImportTask' {Text
applicationId :: Text
$sel:applicationId:CreateDataSetImportTask' :: CreateDataSetImportTask -> Text
applicationId} -> Text
applicationId) (\s :: CreateDataSetImportTask
s@CreateDataSetImportTask' {} Text
a -> CreateDataSetImportTask
s {$sel:applicationId:CreateDataSetImportTask' :: Text
applicationId = Text
a} :: CreateDataSetImportTask)

-- | The data set import task configuration.
createDataSetImportTask_importConfig :: Lens.Lens' CreateDataSetImportTask DataSetImportConfig
createDataSetImportTask_importConfig :: Lens' CreateDataSetImportTask DataSetImportConfig
createDataSetImportTask_importConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetImportTask' {DataSetImportConfig
importConfig :: DataSetImportConfig
$sel:importConfig:CreateDataSetImportTask' :: CreateDataSetImportTask -> DataSetImportConfig
importConfig} -> DataSetImportConfig
importConfig) (\s :: CreateDataSetImportTask
s@CreateDataSetImportTask' {} DataSetImportConfig
a -> CreateDataSetImportTask
s {$sel:importConfig:CreateDataSetImportTask' :: DataSetImportConfig
importConfig = DataSetImportConfig
a} :: CreateDataSetImportTask)

instance Core.AWSRequest CreateDataSetImportTask where
  type
    AWSResponse CreateDataSetImportTask =
      CreateDataSetImportTaskResponse
  request :: (Service -> Service)
-> CreateDataSetImportTask -> Request CreateDataSetImportTask
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 CreateDataSetImportTask
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateDataSetImportTask)))
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 ->
          Int -> Text -> CreateDataSetImportTaskResponse
CreateDataSetImportTaskResponse'
            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.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"taskId")
      )

instance Prelude.Hashable CreateDataSetImportTask where
  hashWithSalt :: Int -> CreateDataSetImportTask -> Int
hashWithSalt Int
_salt CreateDataSetImportTask' {Maybe Text
Text
DataSetImportConfig
importConfig :: DataSetImportConfig
applicationId :: Text
clientToken :: Maybe Text
$sel:importConfig:CreateDataSetImportTask' :: CreateDataSetImportTask -> DataSetImportConfig
$sel:applicationId:CreateDataSetImportTask' :: CreateDataSetImportTask -> Text
$sel:clientToken:CreateDataSetImportTask' :: CreateDataSetImportTask -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
applicationId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` DataSetImportConfig
importConfig

instance Prelude.NFData CreateDataSetImportTask where
  rnf :: CreateDataSetImportTask -> ()
rnf CreateDataSetImportTask' {Maybe Text
Text
DataSetImportConfig
importConfig :: DataSetImportConfig
applicationId :: Text
clientToken :: Maybe Text
$sel:importConfig:CreateDataSetImportTask' :: CreateDataSetImportTask -> DataSetImportConfig
$sel:applicationId:CreateDataSetImportTask' :: CreateDataSetImportTask -> Text
$sel:clientToken:CreateDataSetImportTask' :: CreateDataSetImportTask -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
applicationId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf DataSetImportConfig
importConfig

instance Data.ToHeaders CreateDataSetImportTask where
  toHeaders :: CreateDataSetImportTask -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateDataSetImportTask where
  toJSON :: CreateDataSetImportTask -> Value
toJSON CreateDataSetImportTask' {Maybe Text
Text
DataSetImportConfig
importConfig :: DataSetImportConfig
applicationId :: Text
clientToken :: Maybe Text
$sel:importConfig:CreateDataSetImportTask' :: CreateDataSetImportTask -> DataSetImportConfig
$sel:applicationId:CreateDataSetImportTask' :: CreateDataSetImportTask -> Text
$sel:clientToken:CreateDataSetImportTask' :: CreateDataSetImportTask -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"clientToken" 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 Text
clientToken,
            forall a. a -> Maybe a
Prelude.Just (Key
"importConfig" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= DataSetImportConfig
importConfig)
          ]
      )

instance Data.ToPath CreateDataSetImportTask where
  toPath :: CreateDataSetImportTask -> ByteString
toPath CreateDataSetImportTask' {Maybe Text
Text
DataSetImportConfig
importConfig :: DataSetImportConfig
applicationId :: Text
clientToken :: Maybe Text
$sel:importConfig:CreateDataSetImportTask' :: CreateDataSetImportTask -> DataSetImportConfig
$sel:applicationId:CreateDataSetImportTask' :: CreateDataSetImportTask -> Text
$sel:clientToken:CreateDataSetImportTask' :: CreateDataSetImportTask -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/applications/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
applicationId,
        ByteString
"/dataset-import-task"
      ]

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

-- | /See:/ 'newCreateDataSetImportTaskResponse' smart constructor.
data CreateDataSetImportTaskResponse = CreateDataSetImportTaskResponse'
  { -- | The response's http status code.
    CreateDataSetImportTaskResponse -> Int
httpStatus :: Prelude.Int,
    -- | The task identifier. This operation is asynchronous. Use this identifier
    -- with the GetDataSetImportTask operation to obtain the status of this
    -- task.
    CreateDataSetImportTaskResponse -> Text
taskId :: Prelude.Text
  }
  deriving (CreateDataSetImportTaskResponse
-> CreateDataSetImportTaskResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDataSetImportTaskResponse
-> CreateDataSetImportTaskResponse -> Bool
$c/= :: CreateDataSetImportTaskResponse
-> CreateDataSetImportTaskResponse -> Bool
== :: CreateDataSetImportTaskResponse
-> CreateDataSetImportTaskResponse -> Bool
$c== :: CreateDataSetImportTaskResponse
-> CreateDataSetImportTaskResponse -> Bool
Prelude.Eq, ReadPrec [CreateDataSetImportTaskResponse]
ReadPrec CreateDataSetImportTaskResponse
Int -> ReadS CreateDataSetImportTaskResponse
ReadS [CreateDataSetImportTaskResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDataSetImportTaskResponse]
$creadListPrec :: ReadPrec [CreateDataSetImportTaskResponse]
readPrec :: ReadPrec CreateDataSetImportTaskResponse
$creadPrec :: ReadPrec CreateDataSetImportTaskResponse
readList :: ReadS [CreateDataSetImportTaskResponse]
$creadList :: ReadS [CreateDataSetImportTaskResponse]
readsPrec :: Int -> ReadS CreateDataSetImportTaskResponse
$creadsPrec :: Int -> ReadS CreateDataSetImportTaskResponse
Prelude.Read, Int -> CreateDataSetImportTaskResponse -> ShowS
[CreateDataSetImportTaskResponse] -> ShowS
CreateDataSetImportTaskResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDataSetImportTaskResponse] -> ShowS
$cshowList :: [CreateDataSetImportTaskResponse] -> ShowS
show :: CreateDataSetImportTaskResponse -> String
$cshow :: CreateDataSetImportTaskResponse -> String
showsPrec :: Int -> CreateDataSetImportTaskResponse -> ShowS
$cshowsPrec :: Int -> CreateDataSetImportTaskResponse -> ShowS
Prelude.Show, forall x.
Rep CreateDataSetImportTaskResponse x
-> CreateDataSetImportTaskResponse
forall x.
CreateDataSetImportTaskResponse
-> Rep CreateDataSetImportTaskResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateDataSetImportTaskResponse x
-> CreateDataSetImportTaskResponse
$cfrom :: forall x.
CreateDataSetImportTaskResponse
-> Rep CreateDataSetImportTaskResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateDataSetImportTaskResponse' 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', 'createDataSetImportTaskResponse_httpStatus' - The response's http status code.
--
-- 'taskId', 'createDataSetImportTaskResponse_taskId' - The task identifier. This operation is asynchronous. Use this identifier
-- with the GetDataSetImportTask operation to obtain the status of this
-- task.
newCreateDataSetImportTaskResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'taskId'
  Prelude.Text ->
  CreateDataSetImportTaskResponse
newCreateDataSetImportTaskResponse :: Int -> Text -> CreateDataSetImportTaskResponse
newCreateDataSetImportTaskResponse
  Int
pHttpStatus_
  Text
pTaskId_ =
    CreateDataSetImportTaskResponse'
      { $sel:httpStatus:CreateDataSetImportTaskResponse' :: Int
httpStatus =
          Int
pHttpStatus_,
        $sel:taskId:CreateDataSetImportTaskResponse' :: Text
taskId = Text
pTaskId_
      }

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

-- | The task identifier. This operation is asynchronous. Use this identifier
-- with the GetDataSetImportTask operation to obtain the status of this
-- task.
createDataSetImportTaskResponse_taskId :: Lens.Lens' CreateDataSetImportTaskResponse Prelude.Text
createDataSetImportTaskResponse_taskId :: Lens' CreateDataSetImportTaskResponse Text
createDataSetImportTaskResponse_taskId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDataSetImportTaskResponse' {Text
taskId :: Text
$sel:taskId:CreateDataSetImportTaskResponse' :: CreateDataSetImportTaskResponse -> Text
taskId} -> Text
taskId) (\s :: CreateDataSetImportTaskResponse
s@CreateDataSetImportTaskResponse' {} Text
a -> CreateDataSetImportTaskResponse
s {$sel:taskId:CreateDataSetImportTaskResponse' :: Text
taskId = Text
a} :: CreateDataSetImportTaskResponse)

instance
  Prelude.NFData
    CreateDataSetImportTaskResponse
  where
  rnf :: CreateDataSetImportTaskResponse -> ()
rnf CreateDataSetImportTaskResponse' {Int
Text
taskId :: Text
httpStatus :: Int
$sel:taskId:CreateDataSetImportTaskResponse' :: CreateDataSetImportTaskResponse -> Text
$sel:httpStatus:CreateDataSetImportTaskResponse' :: CreateDataSetImportTaskResponse -> 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 Text
taskId