{-# 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.ELBV2.SetRulePriorities
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Sets the priorities of the specified rules.
--
-- You can reorder the rules as long as there are no priority conflicts in
-- the new order. Any existing rules that you do not specify retain their
-- current priority.
module Amazonka.ELBV2.SetRulePriorities
  ( -- * Creating a Request
    SetRulePriorities (..),
    newSetRulePriorities,

    -- * Request Lenses
    setRulePriorities_rulePriorities,

    -- * Destructuring the Response
    SetRulePrioritiesResponse (..),
    newSetRulePrioritiesResponse,

    -- * Response Lenses
    setRulePrioritiesResponse_rules,
    setRulePrioritiesResponse_httpStatus,
  )
where

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

-- | /See:/ 'newSetRulePriorities' smart constructor.
data SetRulePriorities = SetRulePriorities'
  { -- | The rule priorities.
    SetRulePriorities -> [RulePriorityPair]
rulePriorities :: [RulePriorityPair]
  }
  deriving (SetRulePriorities -> SetRulePriorities -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SetRulePriorities -> SetRulePriorities -> Bool
$c/= :: SetRulePriorities -> SetRulePriorities -> Bool
== :: SetRulePriorities -> SetRulePriorities -> Bool
$c== :: SetRulePriorities -> SetRulePriorities -> Bool
Prelude.Eq, ReadPrec [SetRulePriorities]
ReadPrec SetRulePriorities
Int -> ReadS SetRulePriorities
ReadS [SetRulePriorities]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SetRulePriorities]
$creadListPrec :: ReadPrec [SetRulePriorities]
readPrec :: ReadPrec SetRulePriorities
$creadPrec :: ReadPrec SetRulePriorities
readList :: ReadS [SetRulePriorities]
$creadList :: ReadS [SetRulePriorities]
readsPrec :: Int -> ReadS SetRulePriorities
$creadsPrec :: Int -> ReadS SetRulePriorities
Prelude.Read, Int -> SetRulePriorities -> ShowS
[SetRulePriorities] -> ShowS
SetRulePriorities -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SetRulePriorities] -> ShowS
$cshowList :: [SetRulePriorities] -> ShowS
show :: SetRulePriorities -> String
$cshow :: SetRulePriorities -> String
showsPrec :: Int -> SetRulePriorities -> ShowS
$cshowsPrec :: Int -> SetRulePriorities -> ShowS
Prelude.Show, forall x. Rep SetRulePriorities x -> SetRulePriorities
forall x. SetRulePriorities -> Rep SetRulePriorities x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SetRulePriorities x -> SetRulePriorities
$cfrom :: forall x. SetRulePriorities -> Rep SetRulePriorities x
Prelude.Generic)

-- |
-- Create a value of 'SetRulePriorities' 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:
--
-- 'rulePriorities', 'setRulePriorities_rulePriorities' - The rule priorities.
newSetRulePriorities ::
  SetRulePriorities
newSetRulePriorities :: SetRulePriorities
newSetRulePriorities =
  SetRulePriorities' {$sel:rulePriorities:SetRulePriorities' :: [RulePriorityPair]
rulePriorities = forall a. Monoid a => a
Prelude.mempty}

-- | The rule priorities.
setRulePriorities_rulePriorities :: Lens.Lens' SetRulePriorities [RulePriorityPair]
setRulePriorities_rulePriorities :: Lens' SetRulePriorities [RulePriorityPair]
setRulePriorities_rulePriorities = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetRulePriorities' {[RulePriorityPair]
rulePriorities :: [RulePriorityPair]
$sel:rulePriorities:SetRulePriorities' :: SetRulePriorities -> [RulePriorityPair]
rulePriorities} -> [RulePriorityPair]
rulePriorities) (\s :: SetRulePriorities
s@SetRulePriorities' {} [RulePriorityPair]
a -> SetRulePriorities
s {$sel:rulePriorities:SetRulePriorities' :: [RulePriorityPair]
rulePriorities = [RulePriorityPair]
a} :: SetRulePriorities) 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

instance Core.AWSRequest SetRulePriorities where
  type
    AWSResponse SetRulePriorities =
      SetRulePrioritiesResponse
  request :: (Service -> Service)
-> SetRulePriorities -> Request SetRulePriorities
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy SetRulePriorities
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse SetRulePriorities)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
Text
-> (Int
    -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXMLWrapper
      Text
"SetRulePrioritiesResult"
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe [Rule] -> Int -> SetRulePrioritiesResponse
SetRulePrioritiesResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( [Node]
x
                            forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Rules"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"member")
                        )
            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 SetRulePriorities where
  hashWithSalt :: Int -> SetRulePriorities -> Int
hashWithSalt Int
_salt SetRulePriorities' {[RulePriorityPair]
rulePriorities :: [RulePriorityPair]
$sel:rulePriorities:SetRulePriorities' :: SetRulePriorities -> [RulePriorityPair]
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [RulePriorityPair]
rulePriorities

instance Prelude.NFData SetRulePriorities where
  rnf :: SetRulePriorities -> ()
rnf SetRulePriorities' {[RulePriorityPair]
rulePriorities :: [RulePriorityPair]
$sel:rulePriorities:SetRulePriorities' :: SetRulePriorities -> [RulePriorityPair]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf [RulePriorityPair]
rulePriorities

instance Data.ToHeaders SetRulePriorities where
  toHeaders :: SetRulePriorities -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

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

instance Data.ToQuery SetRulePriorities where
  toQuery :: SetRulePriorities -> QueryString
toQuery SetRulePriorities' {[RulePriorityPair]
rulePriorities :: [RulePriorityPair]
$sel:rulePriorities:SetRulePriorities' :: SetRulePriorities -> [RulePriorityPair]
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"SetRulePriorities" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2015-12-01" :: Prelude.ByteString),
        ByteString
"RulePriorities"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"member" [RulePriorityPair]
rulePriorities
      ]

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

-- |
-- Create a value of 'SetRulePrioritiesResponse' 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:
--
-- 'rules', 'setRulePrioritiesResponse_rules' - Information about the rules.
--
-- 'httpStatus', 'setRulePrioritiesResponse_httpStatus' - The response's http status code.
newSetRulePrioritiesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  SetRulePrioritiesResponse
newSetRulePrioritiesResponse :: Int -> SetRulePrioritiesResponse
newSetRulePrioritiesResponse Int
pHttpStatus_ =
  SetRulePrioritiesResponse'
    { $sel:rules:SetRulePrioritiesResponse' :: Maybe [Rule]
rules = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:SetRulePrioritiesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the rules.
setRulePrioritiesResponse_rules :: Lens.Lens' SetRulePrioritiesResponse (Prelude.Maybe [Rule])
setRulePrioritiesResponse_rules :: Lens' SetRulePrioritiesResponse (Maybe [Rule])
setRulePrioritiesResponse_rules = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetRulePrioritiesResponse' {Maybe [Rule]
rules :: Maybe [Rule]
$sel:rules:SetRulePrioritiesResponse' :: SetRulePrioritiesResponse -> Maybe [Rule]
rules} -> Maybe [Rule]
rules) (\s :: SetRulePrioritiesResponse
s@SetRulePrioritiesResponse' {} Maybe [Rule]
a -> SetRulePrioritiesResponse
s {$sel:rules:SetRulePrioritiesResponse' :: Maybe [Rule]
rules = Maybe [Rule]
a} :: SetRulePrioritiesResponse) 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 response's http status code.
setRulePrioritiesResponse_httpStatus :: Lens.Lens' SetRulePrioritiesResponse Prelude.Int
setRulePrioritiesResponse_httpStatus :: Lens' SetRulePrioritiesResponse Int
setRulePrioritiesResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SetRulePrioritiesResponse' {Int
httpStatus :: Int
$sel:httpStatus:SetRulePrioritiesResponse' :: SetRulePrioritiesResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: SetRulePrioritiesResponse
s@SetRulePrioritiesResponse' {} Int
a -> SetRulePrioritiesResponse
s {$sel:httpStatus:SetRulePrioritiesResponse' :: Int
httpStatus = Int
a} :: SetRulePrioritiesResponse)

instance Prelude.NFData SetRulePrioritiesResponse where
  rnf :: SetRulePrioritiesResponse -> ()
rnf SetRulePrioritiesResponse' {Int
Maybe [Rule]
httpStatus :: Int
rules :: Maybe [Rule]
$sel:httpStatus:SetRulePrioritiesResponse' :: SetRulePrioritiesResponse -> Int
$sel:rules:SetRulePrioritiesResponse' :: SetRulePrioritiesResponse -> Maybe [Rule]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Rule]
rules
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus