{-# 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.MigrationHubStrategy.GetServerStrategies
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves recommended strategies and tools for the specified server.
module Amazonka.MigrationHubStrategy.GetServerStrategies
  ( -- * Creating a Request
    GetServerStrategies (..),
    newGetServerStrategies,

    -- * Request Lenses
    getServerStrategies_serverId,

    -- * Destructuring the Response
    GetServerStrategiesResponse (..),
    newGetServerStrategiesResponse,

    -- * Response Lenses
    getServerStrategiesResponse_serverStrategies,
    getServerStrategiesResponse_httpStatus,
  )
where

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

-- | /See:/ 'newGetServerStrategies' smart constructor.
data GetServerStrategies = GetServerStrategies'
  { -- | The ID of the server.
    GetServerStrategies -> Text
serverId :: Prelude.Text
  }
  deriving (GetServerStrategies -> GetServerStrategies -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetServerStrategies -> GetServerStrategies -> Bool
$c/= :: GetServerStrategies -> GetServerStrategies -> Bool
== :: GetServerStrategies -> GetServerStrategies -> Bool
$c== :: GetServerStrategies -> GetServerStrategies -> Bool
Prelude.Eq, ReadPrec [GetServerStrategies]
ReadPrec GetServerStrategies
Int -> ReadS GetServerStrategies
ReadS [GetServerStrategies]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetServerStrategies]
$creadListPrec :: ReadPrec [GetServerStrategies]
readPrec :: ReadPrec GetServerStrategies
$creadPrec :: ReadPrec GetServerStrategies
readList :: ReadS [GetServerStrategies]
$creadList :: ReadS [GetServerStrategies]
readsPrec :: Int -> ReadS GetServerStrategies
$creadsPrec :: Int -> ReadS GetServerStrategies
Prelude.Read, Int -> GetServerStrategies -> ShowS
[GetServerStrategies] -> ShowS
GetServerStrategies -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetServerStrategies] -> ShowS
$cshowList :: [GetServerStrategies] -> ShowS
show :: GetServerStrategies -> String
$cshow :: GetServerStrategies -> String
showsPrec :: Int -> GetServerStrategies -> ShowS
$cshowsPrec :: Int -> GetServerStrategies -> ShowS
Prelude.Show, forall x. Rep GetServerStrategies x -> GetServerStrategies
forall x. GetServerStrategies -> Rep GetServerStrategies x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetServerStrategies x -> GetServerStrategies
$cfrom :: forall x. GetServerStrategies -> Rep GetServerStrategies x
Prelude.Generic)

-- |
-- Create a value of 'GetServerStrategies' 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:
--
-- 'serverId', 'getServerStrategies_serverId' - The ID of the server.
newGetServerStrategies ::
  -- | 'serverId'
  Prelude.Text ->
  GetServerStrategies
newGetServerStrategies :: Text -> GetServerStrategies
newGetServerStrategies Text
pServerId_ =
  GetServerStrategies' {$sel:serverId:GetServerStrategies' :: Text
serverId = Text
pServerId_}

-- | The ID of the server.
getServerStrategies_serverId :: Lens.Lens' GetServerStrategies Prelude.Text
getServerStrategies_serverId :: Lens' GetServerStrategies Text
getServerStrategies_serverId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetServerStrategies' {Text
serverId :: Text
$sel:serverId:GetServerStrategies' :: GetServerStrategies -> Text
serverId} -> Text
serverId) (\s :: GetServerStrategies
s@GetServerStrategies' {} Text
a -> GetServerStrategies
s {$sel:serverId:GetServerStrategies' :: Text
serverId = Text
a} :: GetServerStrategies)

instance Core.AWSRequest GetServerStrategies where
  type
    AWSResponse GetServerStrategies =
      GetServerStrategiesResponse
  request :: (Service -> Service)
-> GetServerStrategies -> Request GetServerStrategies
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy GetServerStrategies
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetServerStrategies)))
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 [ServerStrategy] -> Int -> GetServerStrategiesResponse
GetServerStrategiesResponse'
            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
"serverStrategies"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
            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 GetServerStrategies where
  hashWithSalt :: Int -> GetServerStrategies -> Int
hashWithSalt Int
_salt GetServerStrategies' {Text
serverId :: Text
$sel:serverId:GetServerStrategies' :: GetServerStrategies -> Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
serverId

instance Prelude.NFData GetServerStrategies where
  rnf :: GetServerStrategies -> ()
rnf GetServerStrategies' {Text
serverId :: Text
$sel:serverId:GetServerStrategies' :: GetServerStrategies -> Text
..} = forall a. NFData a => a -> ()
Prelude.rnf Text
serverId

instance Data.ToHeaders GetServerStrategies where
  toHeaders :: GetServerStrategies -> 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.ToPath GetServerStrategies where
  toPath :: GetServerStrategies -> ByteString
toPath GetServerStrategies' {Text
serverId :: Text
$sel:serverId:GetServerStrategies' :: GetServerStrategies -> Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ByteString
"/get-server-strategies/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
serverId]

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

-- | /See:/ 'newGetServerStrategiesResponse' smart constructor.
data GetServerStrategiesResponse = GetServerStrategiesResponse'
  { -- | A list of strategy recommendations for the server.
    GetServerStrategiesResponse -> Maybe [ServerStrategy]
serverStrategies :: Prelude.Maybe [ServerStrategy],
    -- | The response's http status code.
    GetServerStrategiesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetServerStrategiesResponse -> GetServerStrategiesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetServerStrategiesResponse -> GetServerStrategiesResponse -> Bool
$c/= :: GetServerStrategiesResponse -> GetServerStrategiesResponse -> Bool
== :: GetServerStrategiesResponse -> GetServerStrategiesResponse -> Bool
$c== :: GetServerStrategiesResponse -> GetServerStrategiesResponse -> Bool
Prelude.Eq, ReadPrec [GetServerStrategiesResponse]
ReadPrec GetServerStrategiesResponse
Int -> ReadS GetServerStrategiesResponse
ReadS [GetServerStrategiesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetServerStrategiesResponse]
$creadListPrec :: ReadPrec [GetServerStrategiesResponse]
readPrec :: ReadPrec GetServerStrategiesResponse
$creadPrec :: ReadPrec GetServerStrategiesResponse
readList :: ReadS [GetServerStrategiesResponse]
$creadList :: ReadS [GetServerStrategiesResponse]
readsPrec :: Int -> ReadS GetServerStrategiesResponse
$creadsPrec :: Int -> ReadS GetServerStrategiesResponse
Prelude.Read, Int -> GetServerStrategiesResponse -> ShowS
[GetServerStrategiesResponse] -> ShowS
GetServerStrategiesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetServerStrategiesResponse] -> ShowS
$cshowList :: [GetServerStrategiesResponse] -> ShowS
show :: GetServerStrategiesResponse -> String
$cshow :: GetServerStrategiesResponse -> String
showsPrec :: Int -> GetServerStrategiesResponse -> ShowS
$cshowsPrec :: Int -> GetServerStrategiesResponse -> ShowS
Prelude.Show, forall x.
Rep GetServerStrategiesResponse x -> GetServerStrategiesResponse
forall x.
GetServerStrategiesResponse -> Rep GetServerStrategiesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetServerStrategiesResponse x -> GetServerStrategiesResponse
$cfrom :: forall x.
GetServerStrategiesResponse -> Rep GetServerStrategiesResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetServerStrategiesResponse' 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:
--
-- 'serverStrategies', 'getServerStrategiesResponse_serverStrategies' - A list of strategy recommendations for the server.
--
-- 'httpStatus', 'getServerStrategiesResponse_httpStatus' - The response's http status code.
newGetServerStrategiesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetServerStrategiesResponse
newGetServerStrategiesResponse :: Int -> GetServerStrategiesResponse
newGetServerStrategiesResponse Int
pHttpStatus_ =
  GetServerStrategiesResponse'
    { $sel:serverStrategies:GetServerStrategiesResponse' :: Maybe [ServerStrategy]
serverStrategies =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetServerStrategiesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of strategy recommendations for the server.
getServerStrategiesResponse_serverStrategies :: Lens.Lens' GetServerStrategiesResponse (Prelude.Maybe [ServerStrategy])
getServerStrategiesResponse_serverStrategies :: Lens' GetServerStrategiesResponse (Maybe [ServerStrategy])
getServerStrategiesResponse_serverStrategies = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetServerStrategiesResponse' {Maybe [ServerStrategy]
serverStrategies :: Maybe [ServerStrategy]
$sel:serverStrategies:GetServerStrategiesResponse' :: GetServerStrategiesResponse -> Maybe [ServerStrategy]
serverStrategies} -> Maybe [ServerStrategy]
serverStrategies) (\s :: GetServerStrategiesResponse
s@GetServerStrategiesResponse' {} Maybe [ServerStrategy]
a -> GetServerStrategiesResponse
s {$sel:serverStrategies:GetServerStrategiesResponse' :: Maybe [ServerStrategy]
serverStrategies = Maybe [ServerStrategy]
a} :: GetServerStrategiesResponse) 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.
getServerStrategiesResponse_httpStatus :: Lens.Lens' GetServerStrategiesResponse Prelude.Int
getServerStrategiesResponse_httpStatus :: Lens' GetServerStrategiesResponse Int
getServerStrategiesResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetServerStrategiesResponse' {Int
httpStatus :: Int
$sel:httpStatus:GetServerStrategiesResponse' :: GetServerStrategiesResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: GetServerStrategiesResponse
s@GetServerStrategiesResponse' {} Int
a -> GetServerStrategiesResponse
s {$sel:httpStatus:GetServerStrategiesResponse' :: Int
httpStatus = Int
a} :: GetServerStrategiesResponse)

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