{-# 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 #-}
module Amazonka.DeviceFarm.ListUniqueProblems
(
ListUniqueProblems (..),
newListUniqueProblems,
listUniqueProblems_nextToken,
listUniqueProblems_arn,
ListUniqueProblemsResponse (..),
newListUniqueProblemsResponse,
listUniqueProblemsResponse_nextToken,
listUniqueProblemsResponse_uniqueProblems,
listUniqueProblemsResponse_httpStatus,
)
where
import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.DeviceFarm.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
data ListUniqueProblems = ListUniqueProblems'
{
ListUniqueProblems -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
ListUniqueProblems -> Text
arn :: Prelude.Text
}
deriving (ListUniqueProblems -> ListUniqueProblems -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListUniqueProblems -> ListUniqueProblems -> Bool
$c/= :: ListUniqueProblems -> ListUniqueProblems -> Bool
== :: ListUniqueProblems -> ListUniqueProblems -> Bool
$c== :: ListUniqueProblems -> ListUniqueProblems -> Bool
Prelude.Eq, ReadPrec [ListUniqueProblems]
ReadPrec ListUniqueProblems
Int -> ReadS ListUniqueProblems
ReadS [ListUniqueProblems]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListUniqueProblems]
$creadListPrec :: ReadPrec [ListUniqueProblems]
readPrec :: ReadPrec ListUniqueProblems
$creadPrec :: ReadPrec ListUniqueProblems
readList :: ReadS [ListUniqueProblems]
$creadList :: ReadS [ListUniqueProblems]
readsPrec :: Int -> ReadS ListUniqueProblems
$creadsPrec :: Int -> ReadS ListUniqueProblems
Prelude.Read, Int -> ListUniqueProblems -> ShowS
[ListUniqueProblems] -> ShowS
ListUniqueProblems -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListUniqueProblems] -> ShowS
$cshowList :: [ListUniqueProblems] -> ShowS
show :: ListUniqueProblems -> String
$cshow :: ListUniqueProblems -> String
showsPrec :: Int -> ListUniqueProblems -> ShowS
$cshowsPrec :: Int -> ListUniqueProblems -> ShowS
Prelude.Show, forall x. Rep ListUniqueProblems x -> ListUniqueProblems
forall x. ListUniqueProblems -> Rep ListUniqueProblems x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListUniqueProblems x -> ListUniqueProblems
$cfrom :: forall x. ListUniqueProblems -> Rep ListUniqueProblems x
Prelude.Generic)
newListUniqueProblems ::
Prelude.Text ->
ListUniqueProblems
newListUniqueProblems :: Text -> ListUniqueProblems
newListUniqueProblems Text
pArn_ =
ListUniqueProblems'
{ $sel:nextToken:ListUniqueProblems' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
$sel:arn:ListUniqueProblems' :: Text
arn = Text
pArn_
}
listUniqueProblems_nextToken :: Lens.Lens' ListUniqueProblems (Prelude.Maybe Prelude.Text)
listUniqueProblems_nextToken :: Lens' ListUniqueProblems (Maybe Text)
listUniqueProblems_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListUniqueProblems' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListUniqueProblems' :: ListUniqueProblems -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListUniqueProblems
s@ListUniqueProblems' {} Maybe Text
a -> ListUniqueProblems
s {$sel:nextToken:ListUniqueProblems' :: Maybe Text
nextToken = Maybe Text
a} :: ListUniqueProblems)
listUniqueProblems_arn :: Lens.Lens' ListUniqueProblems Prelude.Text
listUniqueProblems_arn :: Lens' ListUniqueProblems Text
listUniqueProblems_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListUniqueProblems' {Text
arn :: Text
$sel:arn:ListUniqueProblems' :: ListUniqueProblems -> Text
arn} -> Text
arn) (\s :: ListUniqueProblems
s@ListUniqueProblems' {} Text
a -> ListUniqueProblems
s {$sel:arn:ListUniqueProblems' :: Text
arn = Text
a} :: ListUniqueProblems)
instance Core.AWSPager ListUniqueProblems where
page :: ListUniqueProblems
-> AWSResponse ListUniqueProblems -> Maybe ListUniqueProblems
page ListUniqueProblems
rq AWSResponse ListUniqueProblems
rs
| forall a. AWSTruncated a => a -> Bool
Core.stop
( AWSResponse ListUniqueProblems
rs
forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListUniqueProblemsResponse (Maybe Text)
listUniqueProblemsResponse_nextToken
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
) =
forall a. Maybe a
Prelude.Nothing
| forall a. AWSTruncated a => a -> Bool
Core.stop
( AWSResponse ListUniqueProblems
rs
forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens'
ListUniqueProblemsResponse
(Maybe (HashMap ExecutionResult [UniqueProblem]))
listUniqueProblemsResponse_uniqueProblems
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
) =
forall a. Maybe a
Prelude.Nothing
| Bool
Prelude.otherwise =
forall a. a -> Maybe a
Prelude.Just
forall a b. (a -> b) -> a -> b
Prelude.$ ListUniqueProblems
rq
forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListUniqueProblems (Maybe Text)
listUniqueProblems_nextToken
forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListUniqueProblems
rs
forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListUniqueProblemsResponse (Maybe Text)
listUniqueProblemsResponse_nextToken
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
instance Core.AWSRequest ListUniqueProblems where
type
AWSResponse ListUniqueProblems =
ListUniqueProblemsResponse
request :: (Service -> Service)
-> ListUniqueProblems -> Request ListUniqueProblems
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 ListUniqueProblems
-> ClientResponse ClientBody
-> m (Either
Error (ClientResponse (AWSResponse ListUniqueProblems)))
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 Text
-> Maybe (HashMap ExecutionResult [UniqueProblem])
-> Int
-> ListUniqueProblemsResponse
ListUniqueProblemsResponse'
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
"nextToken")
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"uniqueProblems" 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 ListUniqueProblems where
hashWithSalt :: Int -> ListUniqueProblems -> Int
hashWithSalt Int
_salt ListUniqueProblems' {Maybe Text
Text
arn :: Text
nextToken :: Maybe Text
$sel:arn:ListUniqueProblems' :: ListUniqueProblems -> Text
$sel:nextToken:ListUniqueProblems' :: ListUniqueProblems -> Maybe Text
..} =
Int
_salt
forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
arn
instance Prelude.NFData ListUniqueProblems where
rnf :: ListUniqueProblems -> ()
rnf ListUniqueProblems' {Maybe Text
Text
arn :: Text
nextToken :: Maybe Text
$sel:arn:ListUniqueProblems' :: ListUniqueProblems -> Text
$sel:nextToken:ListUniqueProblems' :: ListUniqueProblems -> Maybe Text
..} =
forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
arn
instance Data.ToHeaders ListUniqueProblems where
toHeaders :: ListUniqueProblems -> ResponseHeaders
toHeaders =
forall a b. a -> b -> a
Prelude.const
( forall a. Monoid a => [a] -> a
Prelude.mconcat
[ HeaderName
"X-Amz-Target"
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"DeviceFarm_20150623.ListUniqueProblems" ::
Prelude.ByteString
),
HeaderName
"Content-Type"
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
Prelude.ByteString
)
]
)
instance Data.ToJSON ListUniqueProblems where
toJSON :: ListUniqueProblems -> Value
toJSON ListUniqueProblems' {Maybe Text
Text
arn :: Text
nextToken :: Maybe Text
$sel:arn:ListUniqueProblems' :: ListUniqueProblems -> Text
$sel:nextToken:ListUniqueProblems' :: ListUniqueProblems -> Maybe Text
..} =
[Pair] -> Value
Data.object
( forall a. [Maybe a] -> [a]
Prelude.catMaybes
[ (Key
"nextToken" 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
nextToken,
forall a. a -> Maybe a
Prelude.Just (Key
"arn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
arn)
]
)
instance Data.ToPath ListUniqueProblems where
toPath :: ListUniqueProblems -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"
instance Data.ToQuery ListUniqueProblems where
toQuery :: ListUniqueProblems -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty
data ListUniqueProblemsResponse = ListUniqueProblemsResponse'
{
ListUniqueProblemsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
ListUniqueProblemsResponse
-> Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems :: Prelude.Maybe (Prelude.HashMap ExecutionResult [UniqueProblem]),
ListUniqueProblemsResponse -> Int
httpStatus :: Prelude.Int
}
deriving (ListUniqueProblemsResponse -> ListUniqueProblemsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListUniqueProblemsResponse -> ListUniqueProblemsResponse -> Bool
$c/= :: ListUniqueProblemsResponse -> ListUniqueProblemsResponse -> Bool
== :: ListUniqueProblemsResponse -> ListUniqueProblemsResponse -> Bool
$c== :: ListUniqueProblemsResponse -> ListUniqueProblemsResponse -> Bool
Prelude.Eq, ReadPrec [ListUniqueProblemsResponse]
ReadPrec ListUniqueProblemsResponse
Int -> ReadS ListUniqueProblemsResponse
ReadS [ListUniqueProblemsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListUniqueProblemsResponse]
$creadListPrec :: ReadPrec [ListUniqueProblemsResponse]
readPrec :: ReadPrec ListUniqueProblemsResponse
$creadPrec :: ReadPrec ListUniqueProblemsResponse
readList :: ReadS [ListUniqueProblemsResponse]
$creadList :: ReadS [ListUniqueProblemsResponse]
readsPrec :: Int -> ReadS ListUniqueProblemsResponse
$creadsPrec :: Int -> ReadS ListUniqueProblemsResponse
Prelude.Read, Int -> ListUniqueProblemsResponse -> ShowS
[ListUniqueProblemsResponse] -> ShowS
ListUniqueProblemsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListUniqueProblemsResponse] -> ShowS
$cshowList :: [ListUniqueProblemsResponse] -> ShowS
show :: ListUniqueProblemsResponse -> String
$cshow :: ListUniqueProblemsResponse -> String
showsPrec :: Int -> ListUniqueProblemsResponse -> ShowS
$cshowsPrec :: Int -> ListUniqueProblemsResponse -> ShowS
Prelude.Show, forall x.
Rep ListUniqueProblemsResponse x -> ListUniqueProblemsResponse
forall x.
ListUniqueProblemsResponse -> Rep ListUniqueProblemsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListUniqueProblemsResponse x -> ListUniqueProblemsResponse
$cfrom :: forall x.
ListUniqueProblemsResponse -> Rep ListUniqueProblemsResponse x
Prelude.Generic)
newListUniqueProblemsResponse ::
Prelude.Int ->
ListUniqueProblemsResponse
newListUniqueProblemsResponse :: Int -> ListUniqueProblemsResponse
newListUniqueProblemsResponse Int
pHttpStatus_ =
ListUniqueProblemsResponse'
{ $sel:nextToken:ListUniqueProblemsResponse' :: Maybe Text
nextToken =
forall a. Maybe a
Prelude.Nothing,
$sel:uniqueProblems:ListUniqueProblemsResponse' :: Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems = forall a. Maybe a
Prelude.Nothing,
$sel:httpStatus:ListUniqueProblemsResponse' :: Int
httpStatus = Int
pHttpStatus_
}
listUniqueProblemsResponse_nextToken :: Lens.Lens' ListUniqueProblemsResponse (Prelude.Maybe Prelude.Text)
listUniqueProblemsResponse_nextToken :: Lens' ListUniqueProblemsResponse (Maybe Text)
listUniqueProblemsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListUniqueProblemsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListUniqueProblemsResponse' :: ListUniqueProblemsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListUniqueProblemsResponse
s@ListUniqueProblemsResponse' {} Maybe Text
a -> ListUniqueProblemsResponse
s {$sel:nextToken:ListUniqueProblemsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListUniqueProblemsResponse)
listUniqueProblemsResponse_uniqueProblems :: Lens.Lens' ListUniqueProblemsResponse (Prelude.Maybe (Prelude.HashMap ExecutionResult [UniqueProblem]))
listUniqueProblemsResponse_uniqueProblems :: Lens'
ListUniqueProblemsResponse
(Maybe (HashMap ExecutionResult [UniqueProblem]))
listUniqueProblemsResponse_uniqueProblems = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListUniqueProblemsResponse' {Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems :: Maybe (HashMap ExecutionResult [UniqueProblem])
$sel:uniqueProblems:ListUniqueProblemsResponse' :: ListUniqueProblemsResponse
-> Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems} -> Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems) (\s :: ListUniqueProblemsResponse
s@ListUniqueProblemsResponse' {} Maybe (HashMap ExecutionResult [UniqueProblem])
a -> ListUniqueProblemsResponse
s {$sel:uniqueProblems:ListUniqueProblemsResponse' :: Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems = Maybe (HashMap ExecutionResult [UniqueProblem])
a} :: ListUniqueProblemsResponse) 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
listUniqueProblemsResponse_httpStatus :: Lens.Lens' ListUniqueProblemsResponse Prelude.Int
listUniqueProblemsResponse_httpStatus :: Lens' ListUniqueProblemsResponse Int
listUniqueProblemsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListUniqueProblemsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListUniqueProblemsResponse' :: ListUniqueProblemsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListUniqueProblemsResponse
s@ListUniqueProblemsResponse' {} Int
a -> ListUniqueProblemsResponse
s {$sel:httpStatus:ListUniqueProblemsResponse' :: Int
httpStatus = Int
a} :: ListUniqueProblemsResponse)
instance Prelude.NFData ListUniqueProblemsResponse where
rnf :: ListUniqueProblemsResponse -> ()
rnf ListUniqueProblemsResponse' {Int
Maybe Text
Maybe (HashMap ExecutionResult [UniqueProblem])
httpStatus :: Int
uniqueProblems :: Maybe (HashMap ExecutionResult [UniqueProblem])
nextToken :: Maybe Text
$sel:httpStatus:ListUniqueProblemsResponse' :: ListUniqueProblemsResponse -> Int
$sel:uniqueProblems:ListUniqueProblemsResponse' :: ListUniqueProblemsResponse
-> Maybe (HashMap ExecutionResult [UniqueProblem])
$sel:nextToken:ListUniqueProblemsResponse' :: ListUniqueProblemsResponse -> Maybe Text
..} =
forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap ExecutionResult [UniqueProblem])
uniqueProblems
seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus