{-# 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.Outposts.CreateOrder
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates an order for an Outpost.
module Amazonka.Outposts.CreateOrder
  ( -- * Creating a Request
    CreateOrder (..),
    newCreateOrder,

    -- * Request Lenses
    createOrder_paymentTerm,
    createOrder_outpostIdentifier,
    createOrder_lineItems,
    createOrder_paymentOption,

    -- * Destructuring the Response
    CreateOrderResponse (..),
    newCreateOrderResponse,

    -- * Response Lenses
    createOrderResponse_order,
    createOrderResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateOrder' smart constructor.
data CreateOrder = CreateOrder'
  { -- | The payment terms.
    CreateOrder -> Maybe PaymentTerm
paymentTerm :: Prelude.Maybe PaymentTerm,
    -- | The ID or the Amazon Resource Name (ARN) of the Outpost.
    CreateOrder -> Text
outpostIdentifier :: Prelude.Text,
    -- | The line items that make up the order.
    CreateOrder -> NonEmpty LineItemRequest
lineItems :: Prelude.NonEmpty LineItemRequest,
    -- | The payment option.
    CreateOrder -> PaymentOption
paymentOption :: PaymentOption
  }
  deriving (CreateOrder -> CreateOrder -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateOrder -> CreateOrder -> Bool
$c/= :: CreateOrder -> CreateOrder -> Bool
== :: CreateOrder -> CreateOrder -> Bool
$c== :: CreateOrder -> CreateOrder -> Bool
Prelude.Eq, ReadPrec [CreateOrder]
ReadPrec CreateOrder
Int -> ReadS CreateOrder
ReadS [CreateOrder]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateOrder]
$creadListPrec :: ReadPrec [CreateOrder]
readPrec :: ReadPrec CreateOrder
$creadPrec :: ReadPrec CreateOrder
readList :: ReadS [CreateOrder]
$creadList :: ReadS [CreateOrder]
readsPrec :: Int -> ReadS CreateOrder
$creadsPrec :: Int -> ReadS CreateOrder
Prelude.Read, Int -> CreateOrder -> ShowS
[CreateOrder] -> ShowS
CreateOrder -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateOrder] -> ShowS
$cshowList :: [CreateOrder] -> ShowS
show :: CreateOrder -> String
$cshow :: CreateOrder -> String
showsPrec :: Int -> CreateOrder -> ShowS
$cshowsPrec :: Int -> CreateOrder -> ShowS
Prelude.Show, forall x. Rep CreateOrder x -> CreateOrder
forall x. CreateOrder -> Rep CreateOrder x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateOrder x -> CreateOrder
$cfrom :: forall x. CreateOrder -> Rep CreateOrder x
Prelude.Generic)

-- |
-- Create a value of 'CreateOrder' 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:
--
-- 'paymentTerm', 'createOrder_paymentTerm' - The payment terms.
--
-- 'outpostIdentifier', 'createOrder_outpostIdentifier' - The ID or the Amazon Resource Name (ARN) of the Outpost.
--
-- 'lineItems', 'createOrder_lineItems' - The line items that make up the order.
--
-- 'paymentOption', 'createOrder_paymentOption' - The payment option.
newCreateOrder ::
  -- | 'outpostIdentifier'
  Prelude.Text ->
  -- | 'lineItems'
  Prelude.NonEmpty LineItemRequest ->
  -- | 'paymentOption'
  PaymentOption ->
  CreateOrder
newCreateOrder :: Text -> NonEmpty LineItemRequest -> PaymentOption -> CreateOrder
newCreateOrder
  Text
pOutpostIdentifier_
  NonEmpty LineItemRequest
pLineItems_
  PaymentOption
pPaymentOption_ =
    CreateOrder'
      { $sel:paymentTerm:CreateOrder' :: Maybe PaymentTerm
paymentTerm = forall a. Maybe a
Prelude.Nothing,
        $sel:outpostIdentifier:CreateOrder' :: Text
outpostIdentifier = Text
pOutpostIdentifier_,
        $sel:lineItems:CreateOrder' :: NonEmpty LineItemRequest
lineItems = forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty LineItemRequest
pLineItems_,
        $sel:paymentOption:CreateOrder' :: PaymentOption
paymentOption = PaymentOption
pPaymentOption_
      }

-- | The payment terms.
createOrder_paymentTerm :: Lens.Lens' CreateOrder (Prelude.Maybe PaymentTerm)
createOrder_paymentTerm :: Lens' CreateOrder (Maybe PaymentTerm)
createOrder_paymentTerm = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateOrder' {Maybe PaymentTerm
paymentTerm :: Maybe PaymentTerm
$sel:paymentTerm:CreateOrder' :: CreateOrder -> Maybe PaymentTerm
paymentTerm} -> Maybe PaymentTerm
paymentTerm) (\s :: CreateOrder
s@CreateOrder' {} Maybe PaymentTerm
a -> CreateOrder
s {$sel:paymentTerm:CreateOrder' :: Maybe PaymentTerm
paymentTerm = Maybe PaymentTerm
a} :: CreateOrder)

-- | The ID or the Amazon Resource Name (ARN) of the Outpost.
createOrder_outpostIdentifier :: Lens.Lens' CreateOrder Prelude.Text
createOrder_outpostIdentifier :: Lens' CreateOrder Text
createOrder_outpostIdentifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateOrder' {Text
outpostIdentifier :: Text
$sel:outpostIdentifier:CreateOrder' :: CreateOrder -> Text
outpostIdentifier} -> Text
outpostIdentifier) (\s :: CreateOrder
s@CreateOrder' {} Text
a -> CreateOrder
s {$sel:outpostIdentifier:CreateOrder' :: Text
outpostIdentifier = Text
a} :: CreateOrder)

-- | The line items that make up the order.
createOrder_lineItems :: Lens.Lens' CreateOrder (Prelude.NonEmpty LineItemRequest)
createOrder_lineItems :: Lens' CreateOrder (NonEmpty LineItemRequest)
createOrder_lineItems = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateOrder' {NonEmpty LineItemRequest
lineItems :: NonEmpty LineItemRequest
$sel:lineItems:CreateOrder' :: CreateOrder -> NonEmpty LineItemRequest
lineItems} -> NonEmpty LineItemRequest
lineItems) (\s :: CreateOrder
s@CreateOrder' {} NonEmpty LineItemRequest
a -> CreateOrder
s {$sel:lineItems:CreateOrder' :: NonEmpty LineItemRequest
lineItems = NonEmpty LineItemRequest
a} :: CreateOrder) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The payment option.
createOrder_paymentOption :: Lens.Lens' CreateOrder PaymentOption
createOrder_paymentOption :: Lens' CreateOrder PaymentOption
createOrder_paymentOption = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateOrder' {PaymentOption
paymentOption :: PaymentOption
$sel:paymentOption:CreateOrder' :: CreateOrder -> PaymentOption
paymentOption} -> PaymentOption
paymentOption) (\s :: CreateOrder
s@CreateOrder' {} PaymentOption
a -> CreateOrder
s {$sel:paymentOption:CreateOrder' :: PaymentOption
paymentOption = PaymentOption
a} :: CreateOrder)

instance Core.AWSRequest CreateOrder where
  type AWSResponse CreateOrder = CreateOrderResponse
  request :: (Service -> Service) -> CreateOrder -> Request CreateOrder
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 CreateOrder
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateOrder)))
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 Order -> Int -> CreateOrderResponse
CreateOrderResponse'
            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
"Order")
            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 CreateOrder where
  hashWithSalt :: Int -> CreateOrder -> Int
hashWithSalt Int
_salt CreateOrder' {Maybe PaymentTerm
NonEmpty LineItemRequest
Text
PaymentOption
paymentOption :: PaymentOption
lineItems :: NonEmpty LineItemRequest
outpostIdentifier :: Text
paymentTerm :: Maybe PaymentTerm
$sel:paymentOption:CreateOrder' :: CreateOrder -> PaymentOption
$sel:lineItems:CreateOrder' :: CreateOrder -> NonEmpty LineItemRequest
$sel:outpostIdentifier:CreateOrder' :: CreateOrder -> Text
$sel:paymentTerm:CreateOrder' :: CreateOrder -> Maybe PaymentTerm
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PaymentTerm
paymentTerm
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
outpostIdentifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty LineItemRequest
lineItems
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` PaymentOption
paymentOption

instance Prelude.NFData CreateOrder where
  rnf :: CreateOrder -> ()
rnf CreateOrder' {Maybe PaymentTerm
NonEmpty LineItemRequest
Text
PaymentOption
paymentOption :: PaymentOption
lineItems :: NonEmpty LineItemRequest
outpostIdentifier :: Text
paymentTerm :: Maybe PaymentTerm
$sel:paymentOption:CreateOrder' :: CreateOrder -> PaymentOption
$sel:lineItems:CreateOrder' :: CreateOrder -> NonEmpty LineItemRequest
$sel:outpostIdentifier:CreateOrder' :: CreateOrder -> Text
$sel:paymentTerm:CreateOrder' :: CreateOrder -> Maybe PaymentTerm
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe PaymentTerm
paymentTerm
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
outpostIdentifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty LineItemRequest
lineItems
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf PaymentOption
paymentOption

instance Data.ToHeaders CreateOrder where
  toHeaders :: CreateOrder -> 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 CreateOrder where
  toJSON :: CreateOrder -> Value
toJSON CreateOrder' {Maybe PaymentTerm
NonEmpty LineItemRequest
Text
PaymentOption
paymentOption :: PaymentOption
lineItems :: NonEmpty LineItemRequest
outpostIdentifier :: Text
paymentTerm :: Maybe PaymentTerm
$sel:paymentOption:CreateOrder' :: CreateOrder -> PaymentOption
$sel:lineItems:CreateOrder' :: CreateOrder -> NonEmpty LineItemRequest
$sel:outpostIdentifier:CreateOrder' :: CreateOrder -> Text
$sel:paymentTerm:CreateOrder' :: CreateOrder -> Maybe PaymentTerm
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"PaymentTerm" 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 PaymentTerm
paymentTerm,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"OutpostIdentifier" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
outpostIdentifier),
            forall a. a -> Maybe a
Prelude.Just (Key
"LineItems" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty LineItemRequest
lineItems),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"PaymentOption" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= PaymentOption
paymentOption)
          ]
      )

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

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

-- | /See:/ 'newCreateOrderResponse' smart constructor.
data CreateOrderResponse = CreateOrderResponse'
  { -- | Information about this order.
    CreateOrderResponse -> Maybe Order
order :: Prelude.Maybe Order,
    -- | The response's http status code.
    CreateOrderResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateOrderResponse -> CreateOrderResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateOrderResponse -> CreateOrderResponse -> Bool
$c/= :: CreateOrderResponse -> CreateOrderResponse -> Bool
== :: CreateOrderResponse -> CreateOrderResponse -> Bool
$c== :: CreateOrderResponse -> CreateOrderResponse -> Bool
Prelude.Eq, ReadPrec [CreateOrderResponse]
ReadPrec CreateOrderResponse
Int -> ReadS CreateOrderResponse
ReadS [CreateOrderResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateOrderResponse]
$creadListPrec :: ReadPrec [CreateOrderResponse]
readPrec :: ReadPrec CreateOrderResponse
$creadPrec :: ReadPrec CreateOrderResponse
readList :: ReadS [CreateOrderResponse]
$creadList :: ReadS [CreateOrderResponse]
readsPrec :: Int -> ReadS CreateOrderResponse
$creadsPrec :: Int -> ReadS CreateOrderResponse
Prelude.Read, Int -> CreateOrderResponse -> ShowS
[CreateOrderResponse] -> ShowS
CreateOrderResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateOrderResponse] -> ShowS
$cshowList :: [CreateOrderResponse] -> ShowS
show :: CreateOrderResponse -> String
$cshow :: CreateOrderResponse -> String
showsPrec :: Int -> CreateOrderResponse -> ShowS
$cshowsPrec :: Int -> CreateOrderResponse -> ShowS
Prelude.Show, forall x. Rep CreateOrderResponse x -> CreateOrderResponse
forall x. CreateOrderResponse -> Rep CreateOrderResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateOrderResponse x -> CreateOrderResponse
$cfrom :: forall x. CreateOrderResponse -> Rep CreateOrderResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateOrderResponse' 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:
--
-- 'order', 'createOrderResponse_order' - Information about this order.
--
-- 'httpStatus', 'createOrderResponse_httpStatus' - The response's http status code.
newCreateOrderResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateOrderResponse
newCreateOrderResponse :: Int -> CreateOrderResponse
newCreateOrderResponse Int
pHttpStatus_ =
  CreateOrderResponse'
    { $sel:order:CreateOrderResponse' :: Maybe Order
order = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateOrderResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about this order.
createOrderResponse_order :: Lens.Lens' CreateOrderResponse (Prelude.Maybe Order)
createOrderResponse_order :: Lens' CreateOrderResponse (Maybe Order)
createOrderResponse_order = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateOrderResponse' {Maybe Order
order :: Maybe Order
$sel:order:CreateOrderResponse' :: CreateOrderResponse -> Maybe Order
order} -> Maybe Order
order) (\s :: CreateOrderResponse
s@CreateOrderResponse' {} Maybe Order
a -> CreateOrderResponse
s {$sel:order:CreateOrderResponse' :: Maybe Order
order = Maybe Order
a} :: CreateOrderResponse)

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

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