{-# 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.Outposts.Types.Order
-- 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.Outposts.Types.Order 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.LineItem
import Amazonka.Outposts.Types.OrderStatus
import Amazonka.Outposts.Types.PaymentOption
import qualified Amazonka.Prelude as Prelude

-- | Information about an order.
--
-- /See:/ 'newOrder' smart constructor.
data Order = Order'
  { -- | The line items for the order
    Order -> Maybe [LineItem]
lineItems :: Prelude.Maybe [LineItem],
    -- | The fulfillment date of the order.
    Order -> Maybe POSIX
orderFulfilledDate :: Prelude.Maybe Data.POSIX,
    -- | The ID of the order.
    Order -> Maybe Text
orderId :: Prelude.Maybe Prelude.Text,
    -- | The submission date for the order.
    Order -> Maybe POSIX
orderSubmissionDate :: Prelude.Maybe Data.POSIX,
    -- | The ID of the Outpost in the order.
    Order -> Maybe Text
outpostId :: Prelude.Maybe Prelude.Text,
    -- | The payment option for the order.
    Order -> Maybe PaymentOption
paymentOption :: Prelude.Maybe PaymentOption,
    -- | The status of the order.
    --
    -- -   @PREPARING@ - Order is received and being prepared.
    --
    -- -   @IN_PROGRESS@ - Order is either being built, shipped, or installed.
    --     To get more details, see the line item status.
    --
    -- -   @COMPLETED@ - Order is complete.
    --
    -- -   @CANCELLED@ - Order is cancelled.
    --
    -- -   @ERROR@ - Customer should contact support.
    --
    -- The following status are deprecated: @RECEIVED@, @PENDING@,
    -- @PROCESSING@, @INSTALLING@, and @FULFILLED@.
    Order -> Maybe OrderStatus
status :: Prelude.Maybe OrderStatus
  }
  deriving (Order -> Order -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Order -> Order -> Bool
$c/= :: Order -> Order -> Bool
== :: Order -> Order -> Bool
$c== :: Order -> Order -> Bool
Prelude.Eq, ReadPrec [Order]
ReadPrec Order
Int -> ReadS Order
ReadS [Order]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Order]
$creadListPrec :: ReadPrec [Order]
readPrec :: ReadPrec Order
$creadPrec :: ReadPrec Order
readList :: ReadS [Order]
$creadList :: ReadS [Order]
readsPrec :: Int -> ReadS Order
$creadsPrec :: Int -> ReadS Order
Prelude.Read, Int -> Order -> ShowS
[Order] -> ShowS
Order -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Order] -> ShowS
$cshowList :: [Order] -> ShowS
show :: Order -> String
$cshow :: Order -> String
showsPrec :: Int -> Order -> ShowS
$cshowsPrec :: Int -> Order -> ShowS
Prelude.Show, forall x. Rep Order x -> Order
forall x. Order -> Rep Order x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Order x -> Order
$cfrom :: forall x. Order -> Rep Order x
Prelude.Generic)

-- |
-- Create a value of 'Order' 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:
--
-- 'lineItems', 'order_lineItems' - The line items for the order
--
-- 'orderFulfilledDate', 'order_orderFulfilledDate' - The fulfillment date of the order.
--
-- 'orderId', 'order_orderId' - The ID of the order.
--
-- 'orderSubmissionDate', 'order_orderSubmissionDate' - The submission date for the order.
--
-- 'outpostId', 'order_outpostId' - The ID of the Outpost in the order.
--
-- 'paymentOption', 'order_paymentOption' - The payment option for the order.
--
-- 'status', 'order_status' - The status of the order.
--
-- -   @PREPARING@ - Order is received and being prepared.
--
-- -   @IN_PROGRESS@ - Order is either being built, shipped, or installed.
--     To get more details, see the line item status.
--
-- -   @COMPLETED@ - Order is complete.
--
-- -   @CANCELLED@ - Order is cancelled.
--
-- -   @ERROR@ - Customer should contact support.
--
-- The following status are deprecated: @RECEIVED@, @PENDING@,
-- @PROCESSING@, @INSTALLING@, and @FULFILLED@.
newOrder ::
  Order
newOrder :: Order
newOrder =
  Order'
    { $sel:lineItems:Order' :: Maybe [LineItem]
lineItems = forall a. Maybe a
Prelude.Nothing,
      $sel:orderFulfilledDate:Order' :: Maybe POSIX
orderFulfilledDate = forall a. Maybe a
Prelude.Nothing,
      $sel:orderId:Order' :: Maybe Text
orderId = forall a. Maybe a
Prelude.Nothing,
      $sel:orderSubmissionDate:Order' :: Maybe POSIX
orderSubmissionDate = forall a. Maybe a
Prelude.Nothing,
      $sel:outpostId:Order' :: Maybe Text
outpostId = forall a. Maybe a
Prelude.Nothing,
      $sel:paymentOption:Order' :: Maybe PaymentOption
paymentOption = forall a. Maybe a
Prelude.Nothing,
      $sel:status:Order' :: Maybe OrderStatus
status = forall a. Maybe a
Prelude.Nothing
    }

-- | The line items for the order
order_lineItems :: Lens.Lens' Order (Prelude.Maybe [LineItem])
order_lineItems :: Lens' Order (Maybe [LineItem])
order_lineItems = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Order' {Maybe [LineItem]
lineItems :: Maybe [LineItem]
$sel:lineItems:Order' :: Order -> Maybe [LineItem]
lineItems} -> Maybe [LineItem]
lineItems) (\s :: Order
s@Order' {} Maybe [LineItem]
a -> Order
s {$sel:lineItems:Order' :: Maybe [LineItem]
lineItems = Maybe [LineItem]
a} :: Order) 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 fulfillment date of the order.
order_orderFulfilledDate :: Lens.Lens' Order (Prelude.Maybe Prelude.UTCTime)
order_orderFulfilledDate :: Lens' Order (Maybe UTCTime)
order_orderFulfilledDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Order' {Maybe POSIX
orderFulfilledDate :: Maybe POSIX
$sel:orderFulfilledDate:Order' :: Order -> Maybe POSIX
orderFulfilledDate} -> Maybe POSIX
orderFulfilledDate) (\s :: Order
s@Order' {} Maybe POSIX
a -> Order
s {$sel:orderFulfilledDate:Order' :: Maybe POSIX
orderFulfilledDate = Maybe POSIX
a} :: Order) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The ID of the order.
order_orderId :: Lens.Lens' Order (Prelude.Maybe Prelude.Text)
order_orderId :: Lens' Order (Maybe Text)
order_orderId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Order' {Maybe Text
orderId :: Maybe Text
$sel:orderId:Order' :: Order -> Maybe Text
orderId} -> Maybe Text
orderId) (\s :: Order
s@Order' {} Maybe Text
a -> Order
s {$sel:orderId:Order' :: Maybe Text
orderId = Maybe Text
a} :: Order)

-- | The submission date for the order.
order_orderSubmissionDate :: Lens.Lens' Order (Prelude.Maybe Prelude.UTCTime)
order_orderSubmissionDate :: Lens' Order (Maybe UTCTime)
order_orderSubmissionDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Order' {Maybe POSIX
orderSubmissionDate :: Maybe POSIX
$sel:orderSubmissionDate:Order' :: Order -> Maybe POSIX
orderSubmissionDate} -> Maybe POSIX
orderSubmissionDate) (\s :: Order
s@Order' {} Maybe POSIX
a -> Order
s {$sel:orderSubmissionDate:Order' :: Maybe POSIX
orderSubmissionDate = Maybe POSIX
a} :: Order) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The ID of the Outpost in the order.
order_outpostId :: Lens.Lens' Order (Prelude.Maybe Prelude.Text)
order_outpostId :: Lens' Order (Maybe Text)
order_outpostId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Order' {Maybe Text
outpostId :: Maybe Text
$sel:outpostId:Order' :: Order -> Maybe Text
outpostId} -> Maybe Text
outpostId) (\s :: Order
s@Order' {} Maybe Text
a -> Order
s {$sel:outpostId:Order' :: Maybe Text
outpostId = Maybe Text
a} :: Order)

-- | The payment option for the order.
order_paymentOption :: Lens.Lens' Order (Prelude.Maybe PaymentOption)
order_paymentOption :: Lens' Order (Maybe PaymentOption)
order_paymentOption = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Order' {Maybe PaymentOption
paymentOption :: Maybe PaymentOption
$sel:paymentOption:Order' :: Order -> Maybe PaymentOption
paymentOption} -> Maybe PaymentOption
paymentOption) (\s :: Order
s@Order' {} Maybe PaymentOption
a -> Order
s {$sel:paymentOption:Order' :: Maybe PaymentOption
paymentOption = Maybe PaymentOption
a} :: Order)

-- | The status of the order.
--
-- -   @PREPARING@ - Order is received and being prepared.
--
-- -   @IN_PROGRESS@ - Order is either being built, shipped, or installed.
--     To get more details, see the line item status.
--
-- -   @COMPLETED@ - Order is complete.
--
-- -   @CANCELLED@ - Order is cancelled.
--
-- -   @ERROR@ - Customer should contact support.
--
-- The following status are deprecated: @RECEIVED@, @PENDING@,
-- @PROCESSING@, @INSTALLING@, and @FULFILLED@.
order_status :: Lens.Lens' Order (Prelude.Maybe OrderStatus)
order_status :: Lens' Order (Maybe OrderStatus)
order_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Order' {Maybe OrderStatus
status :: Maybe OrderStatus
$sel:status:Order' :: Order -> Maybe OrderStatus
status} -> Maybe OrderStatus
status) (\s :: Order
s@Order' {} Maybe OrderStatus
a -> Order
s {$sel:status:Order' :: Maybe OrderStatus
status = Maybe OrderStatus
a} :: Order)

instance Data.FromJSON Order where
  parseJSON :: Value -> Parser Order
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Order"
      ( \Object
x ->
          Maybe [LineItem]
-> Maybe POSIX
-> Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe PaymentOption
-> Maybe OrderStatus
-> Order
Order'
            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
"LineItems" 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
"OrderFulfilledDate")
            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
"OrderId")
            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
"OrderSubmissionDate")
            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
"OutpostId")
            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
"PaymentOption")
            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
"Status")
      )

instance Prelude.Hashable Order where
  hashWithSalt :: Int -> Order -> Int
hashWithSalt Int
_salt Order' {Maybe [LineItem]
Maybe Text
Maybe POSIX
Maybe OrderStatus
Maybe PaymentOption
status :: Maybe OrderStatus
paymentOption :: Maybe PaymentOption
outpostId :: Maybe Text
orderSubmissionDate :: Maybe POSIX
orderId :: Maybe Text
orderFulfilledDate :: Maybe POSIX
lineItems :: Maybe [LineItem]
$sel:status:Order' :: Order -> Maybe OrderStatus
$sel:paymentOption:Order' :: Order -> Maybe PaymentOption
$sel:outpostId:Order' :: Order -> Maybe Text
$sel:orderSubmissionDate:Order' :: Order -> Maybe POSIX
$sel:orderId:Order' :: Order -> Maybe Text
$sel:orderFulfilledDate:Order' :: Order -> Maybe POSIX
$sel:lineItems:Order' :: Order -> Maybe [LineItem]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [LineItem]
lineItems
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
orderFulfilledDate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
orderId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
orderSubmissionDate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
outpostId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PaymentOption
paymentOption
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe OrderStatus
status

instance Prelude.NFData Order where
  rnf :: Order -> ()
rnf Order' {Maybe [LineItem]
Maybe Text
Maybe POSIX
Maybe OrderStatus
Maybe PaymentOption
status :: Maybe OrderStatus
paymentOption :: Maybe PaymentOption
outpostId :: Maybe Text
orderSubmissionDate :: Maybe POSIX
orderId :: Maybe Text
orderFulfilledDate :: Maybe POSIX
lineItems :: Maybe [LineItem]
$sel:status:Order' :: Order -> Maybe OrderStatus
$sel:paymentOption:Order' :: Order -> Maybe PaymentOption
$sel:outpostId:Order' :: Order -> Maybe Text
$sel:orderSubmissionDate:Order' :: Order -> Maybe POSIX
$sel:orderId:Order' :: Order -> Maybe Text
$sel:orderFulfilledDate:Order' :: Order -> Maybe POSIX
$sel:lineItems:Order' :: Order -> Maybe [LineItem]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [LineItem]
lineItems
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
orderFulfilledDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
orderId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
orderSubmissionDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
outpostId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PaymentOption
paymentOption
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe OrderStatus
status