{-# 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.Evidently.CreateSegment
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Use this operation to define a /segment/ of your audience. A segment is
-- a portion of your audience that share one or more characteristics.
-- Examples could be Chrome browser users, users in Europe, or Firefox
-- browser users in Europe who also fit other criteria that your
-- application collects, such as age.
--
-- Using a segment in an experiment limits that experiment to evaluate only
-- the users who match the segment criteria. Using one or more segments in
-- a launch allows you to define different traffic splits for the different
-- audience segments.
--
-- >  <p>For more information about segment pattern syntax, see <a href="https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Evidently-segments.html#CloudWatch-Evidently-segments-syntax.html"> Segment rule pattern syntax</a>.</p> <p>The pattern that you define for a segment is matched against the value of <code>evaluationContext</code>, which is passed into Evidently in the <a href="https://docs.aws.amazon.com/cloudwatchevidently/latest/APIReference/API_EvaluateFeature.html">EvaluateFeature</a> operation, when Evidently assigns a feature variation to a user.</p>
module Amazonka.Evidently.CreateSegment
  ( -- * Creating a Request
    CreateSegment (..),
    newCreateSegment,

    -- * Request Lenses
    createSegment_description,
    createSegment_tags,
    createSegment_name,
    createSegment_pattern,

    -- * Destructuring the Response
    CreateSegmentResponse (..),
    newCreateSegmentResponse,

    -- * Response Lenses
    createSegmentResponse_httpStatus,
    createSegmentResponse_segment,
  )
where

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

-- | /See:/ 'newCreateSegment' smart constructor.
data CreateSegment = CreateSegment'
  { -- | An optional description for this segment.
    CreateSegment -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Assigns one or more tags (key-value pairs) to the segment.
    --
    -- Tags can help you organize and categorize your resources. You can also
    -- use them to scope user permissions by granting a user permission to
    -- access or change only resources with certain tag values.
    --
    -- Tags don\'t have any semantic meaning to Amazon Web Services and are
    -- interpreted strictly as strings of characters.
    --
    -- >  <p>You can associate as many as 50 tags with a segment.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a>.</p>
    CreateSegment -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | A name for the segment.
    CreateSegment -> Text
name :: Prelude.Text,
    -- | The pattern to use for the segment. For more information about pattern
    -- syntax, see
    -- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Evidently-segments.html#CloudWatch-Evidently-segments-syntax.html Segment rule pattern syntax>.
    CreateSegment -> Text
pattern' :: Prelude.Text
  }
  deriving (CreateSegment -> CreateSegment -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateSegment -> CreateSegment -> Bool
$c/= :: CreateSegment -> CreateSegment -> Bool
== :: CreateSegment -> CreateSegment -> Bool
$c== :: CreateSegment -> CreateSegment -> Bool
Prelude.Eq, ReadPrec [CreateSegment]
ReadPrec CreateSegment
Int -> ReadS CreateSegment
ReadS [CreateSegment]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateSegment]
$creadListPrec :: ReadPrec [CreateSegment]
readPrec :: ReadPrec CreateSegment
$creadPrec :: ReadPrec CreateSegment
readList :: ReadS [CreateSegment]
$creadList :: ReadS [CreateSegment]
readsPrec :: Int -> ReadS CreateSegment
$creadsPrec :: Int -> ReadS CreateSegment
Prelude.Read, Int -> CreateSegment -> ShowS
[CreateSegment] -> ShowS
CreateSegment -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateSegment] -> ShowS
$cshowList :: [CreateSegment] -> ShowS
show :: CreateSegment -> String
$cshow :: CreateSegment -> String
showsPrec :: Int -> CreateSegment -> ShowS
$cshowsPrec :: Int -> CreateSegment -> ShowS
Prelude.Show, forall x. Rep CreateSegment x -> CreateSegment
forall x. CreateSegment -> Rep CreateSegment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateSegment x -> CreateSegment
$cfrom :: forall x. CreateSegment -> Rep CreateSegment x
Prelude.Generic)

-- |
-- Create a value of 'CreateSegment' 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:
--
-- 'description', 'createSegment_description' - An optional description for this segment.
--
-- 'tags', 'createSegment_tags' - Assigns one or more tags (key-value pairs) to the segment.
--
-- Tags can help you organize and categorize your resources. You can also
-- use them to scope user permissions by granting a user permission to
-- access or change only resources with certain tag values.
--
-- Tags don\'t have any semantic meaning to Amazon Web Services and are
-- interpreted strictly as strings of characters.
--
-- >  <p>You can associate as many as 50 tags with a segment.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a>.</p>
--
-- 'name', 'createSegment_name' - A name for the segment.
--
-- 'pattern'', 'createSegment_pattern' - The pattern to use for the segment. For more information about pattern
-- syntax, see
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Evidently-segments.html#CloudWatch-Evidently-segments-syntax.html Segment rule pattern syntax>.
newCreateSegment ::
  -- | 'name'
  Prelude.Text ->
  -- | 'pattern''
  Prelude.Text ->
  CreateSegment
newCreateSegment :: Text -> Text -> CreateSegment
newCreateSegment Text
pName_ Text
pPattern_ =
  CreateSegment'
    { $sel:description:CreateSegment' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateSegment' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateSegment' :: Text
name = Text
pName_,
      $sel:pattern':CreateSegment' :: Text
pattern' = Text
pPattern_
    }

-- | An optional description for this segment.
createSegment_description :: Lens.Lens' CreateSegment (Prelude.Maybe Prelude.Text)
createSegment_description :: Lens' CreateSegment (Maybe Text)
createSegment_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSegment' {Maybe Text
description :: Maybe Text
$sel:description:CreateSegment' :: CreateSegment -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateSegment
s@CreateSegment' {} Maybe Text
a -> CreateSegment
s {$sel:description:CreateSegment' :: Maybe Text
description = Maybe Text
a} :: CreateSegment)

-- | Assigns one or more tags (key-value pairs) to the segment.
--
-- Tags can help you organize and categorize your resources. You can also
-- use them to scope user permissions by granting a user permission to
-- access or change only resources with certain tag values.
--
-- Tags don\'t have any semantic meaning to Amazon Web Services and are
-- interpreted strictly as strings of characters.
--
-- >  <p>You can associate as many as 50 tags with a segment.</p> <p>For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a>.</p>
createSegment_tags :: Lens.Lens' CreateSegment (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createSegment_tags :: Lens' CreateSegment (Maybe (HashMap Text Text))
createSegment_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSegment' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateSegment' :: CreateSegment -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateSegment
s@CreateSegment' {} Maybe (HashMap Text Text)
a -> CreateSegment
s {$sel:tags:CreateSegment' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateSegment) 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

-- | A name for the segment.
createSegment_name :: Lens.Lens' CreateSegment Prelude.Text
createSegment_name :: Lens' CreateSegment Text
createSegment_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSegment' {Text
name :: Text
$sel:name:CreateSegment' :: CreateSegment -> Text
name} -> Text
name) (\s :: CreateSegment
s@CreateSegment' {} Text
a -> CreateSegment
s {$sel:name:CreateSegment' :: Text
name = Text
a} :: CreateSegment)

-- | The pattern to use for the segment. For more information about pattern
-- syntax, see
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch-Evidently-segments.html#CloudWatch-Evidently-segments-syntax.html Segment rule pattern syntax>.
createSegment_pattern :: Lens.Lens' CreateSegment Prelude.Text
createSegment_pattern :: Lens' CreateSegment Text
createSegment_pattern = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSegment' {Text
pattern' :: Text
$sel:pattern':CreateSegment' :: CreateSegment -> Text
pattern'} -> Text
pattern') (\s :: CreateSegment
s@CreateSegment' {} Text
a -> CreateSegment
s {$sel:pattern':CreateSegment' :: Text
pattern' = Text
a} :: CreateSegment)

instance Core.AWSRequest CreateSegment where
  type
    AWSResponse CreateSegment =
      CreateSegmentResponse
  request :: (Service -> Service) -> CreateSegment -> Request CreateSegment
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 CreateSegment
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateSegment)))
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 ->
          Int -> Segment -> CreateSegmentResponse
CreateSegmentResponse'
            forall (f :: * -> *) a b. Functor 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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"segment")
      )

instance Prelude.Hashable CreateSegment where
  hashWithSalt :: Int -> CreateSegment -> Int
hashWithSalt Int
_salt CreateSegment' {Maybe Text
Maybe (HashMap Text Text)
Text
pattern' :: Text
name :: Text
tags :: Maybe (HashMap Text Text)
description :: Maybe Text
$sel:pattern':CreateSegment' :: CreateSegment -> Text
$sel:name:CreateSegment' :: CreateSegment -> Text
$sel:tags:CreateSegment' :: CreateSegment -> Maybe (HashMap Text Text)
$sel:description:CreateSegment' :: CreateSegment -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
pattern'

instance Prelude.NFData CreateSegment where
  rnf :: CreateSegment -> ()
rnf CreateSegment' {Maybe Text
Maybe (HashMap Text Text)
Text
pattern' :: Text
name :: Text
tags :: Maybe (HashMap Text Text)
description :: Maybe Text
$sel:pattern':CreateSegment' :: CreateSegment -> Text
$sel:name:CreateSegment' :: CreateSegment -> Text
$sel:tags:CreateSegment' :: CreateSegment -> Maybe (HashMap Text Text)
$sel:description:CreateSegment' :: CreateSegment -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
pattern'

instance Data.ToHeaders CreateSegment where
  toHeaders :: CreateSegment -> 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 CreateSegment where
  toJSON :: CreateSegment -> Value
toJSON CreateSegment' {Maybe Text
Maybe (HashMap Text Text)
Text
pattern' :: Text
name :: Text
tags :: Maybe (HashMap Text Text)
description :: Maybe Text
$sel:pattern':CreateSegment' :: CreateSegment -> Text
$sel:name:CreateSegment' :: CreateSegment -> Text
$sel:tags:CreateSegment' :: CreateSegment -> Maybe (HashMap Text Text)
$sel:description:CreateSegment' :: CreateSegment -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"description" 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
description,
            (Key
"tags" 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 (HashMap Text Text)
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just (Key
"pattern" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
pattern')
          ]
      )

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

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

-- | /See:/ 'newCreateSegmentResponse' smart constructor.
data CreateSegmentResponse = CreateSegmentResponse'
  { -- | The response's http status code.
    CreateSegmentResponse -> Int
httpStatus :: Prelude.Int,
    -- | A structure that contains the complete information about the segment
    -- that was just created.
    CreateSegmentResponse -> Segment
segment :: Segment
  }
  deriving (CreateSegmentResponse -> CreateSegmentResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateSegmentResponse -> CreateSegmentResponse -> Bool
$c/= :: CreateSegmentResponse -> CreateSegmentResponse -> Bool
== :: CreateSegmentResponse -> CreateSegmentResponse -> Bool
$c== :: CreateSegmentResponse -> CreateSegmentResponse -> Bool
Prelude.Eq, ReadPrec [CreateSegmentResponse]
ReadPrec CreateSegmentResponse
Int -> ReadS CreateSegmentResponse
ReadS [CreateSegmentResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateSegmentResponse]
$creadListPrec :: ReadPrec [CreateSegmentResponse]
readPrec :: ReadPrec CreateSegmentResponse
$creadPrec :: ReadPrec CreateSegmentResponse
readList :: ReadS [CreateSegmentResponse]
$creadList :: ReadS [CreateSegmentResponse]
readsPrec :: Int -> ReadS CreateSegmentResponse
$creadsPrec :: Int -> ReadS CreateSegmentResponse
Prelude.Read, Int -> CreateSegmentResponse -> ShowS
[CreateSegmentResponse] -> ShowS
CreateSegmentResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateSegmentResponse] -> ShowS
$cshowList :: [CreateSegmentResponse] -> ShowS
show :: CreateSegmentResponse -> String
$cshow :: CreateSegmentResponse -> String
showsPrec :: Int -> CreateSegmentResponse -> ShowS
$cshowsPrec :: Int -> CreateSegmentResponse -> ShowS
Prelude.Show, forall x. Rep CreateSegmentResponse x -> CreateSegmentResponse
forall x. CreateSegmentResponse -> Rep CreateSegmentResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateSegmentResponse x -> CreateSegmentResponse
$cfrom :: forall x. CreateSegmentResponse -> Rep CreateSegmentResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateSegmentResponse' 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:
--
-- 'httpStatus', 'createSegmentResponse_httpStatus' - The response's http status code.
--
-- 'segment', 'createSegmentResponse_segment' - A structure that contains the complete information about the segment
-- that was just created.
newCreateSegmentResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'segment'
  Segment ->
  CreateSegmentResponse
newCreateSegmentResponse :: Int -> Segment -> CreateSegmentResponse
newCreateSegmentResponse Int
pHttpStatus_ Segment
pSegment_ =
  CreateSegmentResponse'
    { $sel:httpStatus:CreateSegmentResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:segment:CreateSegmentResponse' :: Segment
segment = Segment
pSegment_
    }

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

-- | A structure that contains the complete information about the segment
-- that was just created.
createSegmentResponse_segment :: Lens.Lens' CreateSegmentResponse Segment
createSegmentResponse_segment :: Lens' CreateSegmentResponse Segment
createSegmentResponse_segment = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSegmentResponse' {Segment
segment :: Segment
$sel:segment:CreateSegmentResponse' :: CreateSegmentResponse -> Segment
segment} -> Segment
segment) (\s :: CreateSegmentResponse
s@CreateSegmentResponse' {} Segment
a -> CreateSegmentResponse
s {$sel:segment:CreateSegmentResponse' :: Segment
segment = Segment
a} :: CreateSegmentResponse)

instance Prelude.NFData CreateSegmentResponse where
  rnf :: CreateSegmentResponse -> ()
rnf CreateSegmentResponse' {Int
Segment
segment :: Segment
httpStatus :: Int
$sel:segment:CreateSegmentResponse' :: CreateSegmentResponse -> Segment
$sel:httpStatus:CreateSegmentResponse' :: CreateSegmentResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Segment
segment