{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.AppFlow.Types.CustomConnectorDestinationProperties
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.AppFlow.Types.CustomConnectorDestinationProperties where

import Amazonka.AppFlow.Types.ErrorHandlingConfig
import Amazonka.AppFlow.Types.WriteOperationType
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

-- | The properties that are applied when the custom connector is being used
-- as a destination.
--
-- /See:/ 'newCustomConnectorDestinationProperties' smart constructor.
data CustomConnectorDestinationProperties = CustomConnectorDestinationProperties'
  { -- | The custom properties that are specific to the connector when it\'s used
    -- as a destination in the flow.
    CustomConnectorDestinationProperties -> Maybe (HashMap Text Text)
customProperties :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The settings that determine how Amazon AppFlow handles an error when
    -- placing data in the custom connector as destination.
    CustomConnectorDestinationProperties -> Maybe ErrorHandlingConfig
errorHandlingConfig :: Prelude.Maybe ErrorHandlingConfig,
    -- | The name of the field that Amazon AppFlow uses as an ID when performing
    -- a write operation such as update, delete, or upsert.
    CustomConnectorDestinationProperties -> Maybe [Text]
idFieldNames :: Prelude.Maybe [Prelude.Text],
    -- | Specifies the type of write operation to be performed in the custom
    -- connector when it\'s used as destination.
    CustomConnectorDestinationProperties -> Maybe WriteOperationType
writeOperationType :: Prelude.Maybe WriteOperationType,
    -- | The entity specified in the custom connector as a destination in the
    -- flow.
    CustomConnectorDestinationProperties -> Text
entityName :: Prelude.Text
  }
  deriving (CustomConnectorDestinationProperties
-> CustomConnectorDestinationProperties -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CustomConnectorDestinationProperties
-> CustomConnectorDestinationProperties -> Bool
$c/= :: CustomConnectorDestinationProperties
-> CustomConnectorDestinationProperties -> Bool
== :: CustomConnectorDestinationProperties
-> CustomConnectorDestinationProperties -> Bool
$c== :: CustomConnectorDestinationProperties
-> CustomConnectorDestinationProperties -> Bool
Prelude.Eq, ReadPrec [CustomConnectorDestinationProperties]
ReadPrec CustomConnectorDestinationProperties
Int -> ReadS CustomConnectorDestinationProperties
ReadS [CustomConnectorDestinationProperties]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CustomConnectorDestinationProperties]
$creadListPrec :: ReadPrec [CustomConnectorDestinationProperties]
readPrec :: ReadPrec CustomConnectorDestinationProperties
$creadPrec :: ReadPrec CustomConnectorDestinationProperties
readList :: ReadS [CustomConnectorDestinationProperties]
$creadList :: ReadS [CustomConnectorDestinationProperties]
readsPrec :: Int -> ReadS CustomConnectorDestinationProperties
$creadsPrec :: Int -> ReadS CustomConnectorDestinationProperties
Prelude.Read, Int -> CustomConnectorDestinationProperties -> ShowS
[CustomConnectorDestinationProperties] -> ShowS
CustomConnectorDestinationProperties -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CustomConnectorDestinationProperties] -> ShowS
$cshowList :: [CustomConnectorDestinationProperties] -> ShowS
show :: CustomConnectorDestinationProperties -> String
$cshow :: CustomConnectorDestinationProperties -> String
showsPrec :: Int -> CustomConnectorDestinationProperties -> ShowS
$cshowsPrec :: Int -> CustomConnectorDestinationProperties -> ShowS
Prelude.Show, forall x.
Rep CustomConnectorDestinationProperties x
-> CustomConnectorDestinationProperties
forall x.
CustomConnectorDestinationProperties
-> Rep CustomConnectorDestinationProperties x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CustomConnectorDestinationProperties x
-> CustomConnectorDestinationProperties
$cfrom :: forall x.
CustomConnectorDestinationProperties
-> Rep CustomConnectorDestinationProperties x
Prelude.Generic)

-- |
-- Create a value of 'CustomConnectorDestinationProperties' 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:
--
-- 'customProperties', 'customConnectorDestinationProperties_customProperties' - The custom properties that are specific to the connector when it\'s used
-- as a destination in the flow.
--
-- 'errorHandlingConfig', 'customConnectorDestinationProperties_errorHandlingConfig' - The settings that determine how Amazon AppFlow handles an error when
-- placing data in the custom connector as destination.
--
-- 'idFieldNames', 'customConnectorDestinationProperties_idFieldNames' - The name of the field that Amazon AppFlow uses as an ID when performing
-- a write operation such as update, delete, or upsert.
--
-- 'writeOperationType', 'customConnectorDestinationProperties_writeOperationType' - Specifies the type of write operation to be performed in the custom
-- connector when it\'s used as destination.
--
-- 'entityName', 'customConnectorDestinationProperties_entityName' - The entity specified in the custom connector as a destination in the
-- flow.
newCustomConnectorDestinationProperties ::
  -- | 'entityName'
  Prelude.Text ->
  CustomConnectorDestinationProperties
newCustomConnectorDestinationProperties :: Text -> CustomConnectorDestinationProperties
newCustomConnectorDestinationProperties Text
pEntityName_ =
  CustomConnectorDestinationProperties'
    { $sel:customProperties:CustomConnectorDestinationProperties' :: Maybe (HashMap Text Text)
customProperties =
        forall a. Maybe a
Prelude.Nothing,
      $sel:errorHandlingConfig:CustomConnectorDestinationProperties' :: Maybe ErrorHandlingConfig
errorHandlingConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:idFieldNames:CustomConnectorDestinationProperties' :: Maybe [Text]
idFieldNames = forall a. Maybe a
Prelude.Nothing,
      $sel:writeOperationType:CustomConnectorDestinationProperties' :: Maybe WriteOperationType
writeOperationType = forall a. Maybe a
Prelude.Nothing,
      $sel:entityName:CustomConnectorDestinationProperties' :: Text
entityName = Text
pEntityName_
    }

-- | The custom properties that are specific to the connector when it\'s used
-- as a destination in the flow.
customConnectorDestinationProperties_customProperties :: Lens.Lens' CustomConnectorDestinationProperties (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
customConnectorDestinationProperties_customProperties :: Lens'
  CustomConnectorDestinationProperties (Maybe (HashMap Text Text))
customConnectorDestinationProperties_customProperties = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CustomConnectorDestinationProperties' {Maybe (HashMap Text Text)
customProperties :: Maybe (HashMap Text Text)
$sel:customProperties:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe (HashMap Text Text)
customProperties} -> Maybe (HashMap Text Text)
customProperties) (\s :: CustomConnectorDestinationProperties
s@CustomConnectorDestinationProperties' {} Maybe (HashMap Text Text)
a -> CustomConnectorDestinationProperties
s {$sel:customProperties:CustomConnectorDestinationProperties' :: Maybe (HashMap Text Text)
customProperties = Maybe (HashMap Text Text)
a} :: CustomConnectorDestinationProperties) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The settings that determine how Amazon AppFlow handles an error when
-- placing data in the custom connector as destination.
customConnectorDestinationProperties_errorHandlingConfig :: Lens.Lens' CustomConnectorDestinationProperties (Prelude.Maybe ErrorHandlingConfig)
customConnectorDestinationProperties_errorHandlingConfig :: Lens'
  CustomConnectorDestinationProperties (Maybe ErrorHandlingConfig)
customConnectorDestinationProperties_errorHandlingConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CustomConnectorDestinationProperties' {Maybe ErrorHandlingConfig
errorHandlingConfig :: Maybe ErrorHandlingConfig
$sel:errorHandlingConfig:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe ErrorHandlingConfig
errorHandlingConfig} -> Maybe ErrorHandlingConfig
errorHandlingConfig) (\s :: CustomConnectorDestinationProperties
s@CustomConnectorDestinationProperties' {} Maybe ErrorHandlingConfig
a -> CustomConnectorDestinationProperties
s {$sel:errorHandlingConfig:CustomConnectorDestinationProperties' :: Maybe ErrorHandlingConfig
errorHandlingConfig = Maybe ErrorHandlingConfig
a} :: CustomConnectorDestinationProperties)

-- | The name of the field that Amazon AppFlow uses as an ID when performing
-- a write operation such as update, delete, or upsert.
customConnectorDestinationProperties_idFieldNames :: Lens.Lens' CustomConnectorDestinationProperties (Prelude.Maybe [Prelude.Text])
customConnectorDestinationProperties_idFieldNames :: Lens' CustomConnectorDestinationProperties (Maybe [Text])
customConnectorDestinationProperties_idFieldNames = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CustomConnectorDestinationProperties' {Maybe [Text]
idFieldNames :: Maybe [Text]
$sel:idFieldNames:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe [Text]
idFieldNames} -> Maybe [Text]
idFieldNames) (\s :: CustomConnectorDestinationProperties
s@CustomConnectorDestinationProperties' {} Maybe [Text]
a -> CustomConnectorDestinationProperties
s {$sel:idFieldNames:CustomConnectorDestinationProperties' :: Maybe [Text]
idFieldNames = Maybe [Text]
a} :: CustomConnectorDestinationProperties) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Specifies the type of write operation to be performed in the custom
-- connector when it\'s used as destination.
customConnectorDestinationProperties_writeOperationType :: Lens.Lens' CustomConnectorDestinationProperties (Prelude.Maybe WriteOperationType)
customConnectorDestinationProperties_writeOperationType :: Lens'
  CustomConnectorDestinationProperties (Maybe WriteOperationType)
customConnectorDestinationProperties_writeOperationType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CustomConnectorDestinationProperties' {Maybe WriteOperationType
writeOperationType :: Maybe WriteOperationType
$sel:writeOperationType:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe WriteOperationType
writeOperationType} -> Maybe WriteOperationType
writeOperationType) (\s :: CustomConnectorDestinationProperties
s@CustomConnectorDestinationProperties' {} Maybe WriteOperationType
a -> CustomConnectorDestinationProperties
s {$sel:writeOperationType:CustomConnectorDestinationProperties' :: Maybe WriteOperationType
writeOperationType = Maybe WriteOperationType
a} :: CustomConnectorDestinationProperties)

-- | The entity specified in the custom connector as a destination in the
-- flow.
customConnectorDestinationProperties_entityName :: Lens.Lens' CustomConnectorDestinationProperties Prelude.Text
customConnectorDestinationProperties_entityName :: Lens' CustomConnectorDestinationProperties Text
customConnectorDestinationProperties_entityName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CustomConnectorDestinationProperties' {Text
entityName :: Text
$sel:entityName:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Text
entityName} -> Text
entityName) (\s :: CustomConnectorDestinationProperties
s@CustomConnectorDestinationProperties' {} Text
a -> CustomConnectorDestinationProperties
s {$sel:entityName:CustomConnectorDestinationProperties' :: Text
entityName = Text
a} :: CustomConnectorDestinationProperties)

instance
  Data.FromJSON
    CustomConnectorDestinationProperties
  where
  parseJSON :: Value -> Parser CustomConnectorDestinationProperties
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"CustomConnectorDestinationProperties"
      ( \Object
x ->
          Maybe (HashMap Text Text)
-> Maybe ErrorHandlingConfig
-> Maybe [Text]
-> Maybe WriteOperationType
-> Text
-> CustomConnectorDestinationProperties
CustomConnectorDestinationProperties'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"customProperties"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"errorHandlingConfig")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"idFieldNames" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"writeOperationType")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"entityName")
      )

instance
  Prelude.Hashable
    CustomConnectorDestinationProperties
  where
  hashWithSalt :: Int -> CustomConnectorDestinationProperties -> Int
hashWithSalt
    Int
_salt
    CustomConnectorDestinationProperties' {Maybe [Text]
Maybe (HashMap Text Text)
Maybe ErrorHandlingConfig
Maybe WriteOperationType
Text
entityName :: Text
writeOperationType :: Maybe WriteOperationType
idFieldNames :: Maybe [Text]
errorHandlingConfig :: Maybe ErrorHandlingConfig
customProperties :: Maybe (HashMap Text Text)
$sel:entityName:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Text
$sel:writeOperationType:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe WriteOperationType
$sel:idFieldNames:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe [Text]
$sel:errorHandlingConfig:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe ErrorHandlingConfig
$sel:customProperties:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe (HashMap Text Text)
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
customProperties
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ErrorHandlingConfig
errorHandlingConfig
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
idFieldNames
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe WriteOperationType
writeOperationType
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
entityName

instance
  Prelude.NFData
    CustomConnectorDestinationProperties
  where
  rnf :: CustomConnectorDestinationProperties -> ()
rnf CustomConnectorDestinationProperties' {Maybe [Text]
Maybe (HashMap Text Text)
Maybe ErrorHandlingConfig
Maybe WriteOperationType
Text
entityName :: Text
writeOperationType :: Maybe WriteOperationType
idFieldNames :: Maybe [Text]
errorHandlingConfig :: Maybe ErrorHandlingConfig
customProperties :: Maybe (HashMap Text Text)
$sel:entityName:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Text
$sel:writeOperationType:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe WriteOperationType
$sel:idFieldNames:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe [Text]
$sel:errorHandlingConfig:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe ErrorHandlingConfig
$sel:customProperties:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe (HashMap Text Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
customProperties
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ErrorHandlingConfig
errorHandlingConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
idFieldNames
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe WriteOperationType
writeOperationType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
entityName

instance
  Data.ToJSON
    CustomConnectorDestinationProperties
  where
  toJSON :: CustomConnectorDestinationProperties -> Value
toJSON CustomConnectorDestinationProperties' {Maybe [Text]
Maybe (HashMap Text Text)
Maybe ErrorHandlingConfig
Maybe WriteOperationType
Text
entityName :: Text
writeOperationType :: Maybe WriteOperationType
idFieldNames :: Maybe [Text]
errorHandlingConfig :: Maybe ErrorHandlingConfig
customProperties :: Maybe (HashMap Text Text)
$sel:entityName:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Text
$sel:writeOperationType:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe WriteOperationType
$sel:idFieldNames:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe [Text]
$sel:errorHandlingConfig:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe ErrorHandlingConfig
$sel:customProperties:CustomConnectorDestinationProperties' :: CustomConnectorDestinationProperties -> Maybe (HashMap Text Text)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"customProperties" 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 (HashMap Text Text)
customProperties,
            (Key
"errorHandlingConfig" 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 ErrorHandlingConfig
errorHandlingConfig,
            (Key
"idFieldNames" 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]
idFieldNames,
            (Key
"writeOperationType" 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 WriteOperationType
writeOperationType,
            forall a. a -> Maybe a
Prelude.Just (Key
"entityName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
entityName)
          ]
      )