{-# LANGUAGE OverloadedStrings #-}

-- TODO Fuzziness ???
module Database.Bloodhound.Internal.Versions.Common.Types.Query.Fuzzy
  ( FuzzyQuery (..),
    FuzzyLikeFieldQuery (..),
    FuzzyLikeThisQuery (..),
  )
where

import Database.Bloodhound.Internal.Utils.Imports
import Database.Bloodhound.Internal.Versions.Common.Types.Newtypes
import Database.Bloodhound.Internal.Versions.Common.Types.Query.Commons
import GHC.Generics

data FuzzyQuery = FuzzyQuery
  { FuzzyQuery -> FieldName
fuzzyQueryField :: FieldName,
    FuzzyQuery -> Text
fuzzyQueryValue :: Text,
    FuzzyQuery -> PrefixLength
fuzzyQueryPrefixLength :: PrefixLength,
    FuzzyQuery -> MaxExpansions
fuzzyQueryMaxExpansions :: MaxExpansions,
    FuzzyQuery -> Fuzziness
fuzzyQueryFuzziness :: Fuzziness,
    FuzzyQuery -> Maybe Boost
fuzzyQueryBoost :: Maybe Boost
  }
  deriving stock (FuzzyQuery -> FuzzyQuery -> Bool
(FuzzyQuery -> FuzzyQuery -> Bool)
-> (FuzzyQuery -> FuzzyQuery -> Bool) -> Eq FuzzyQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuzzyQuery -> FuzzyQuery -> Bool
== :: FuzzyQuery -> FuzzyQuery -> Bool
$c/= :: FuzzyQuery -> FuzzyQuery -> Bool
/= :: FuzzyQuery -> FuzzyQuery -> Bool
Eq, Int -> FuzzyQuery -> ShowS
[FuzzyQuery] -> ShowS
FuzzyQuery -> String
(Int -> FuzzyQuery -> ShowS)
-> (FuzzyQuery -> String)
-> ([FuzzyQuery] -> ShowS)
-> Show FuzzyQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuzzyQuery -> ShowS
showsPrec :: Int -> FuzzyQuery -> ShowS
$cshow :: FuzzyQuery -> String
show :: FuzzyQuery -> String
$cshowList :: [FuzzyQuery] -> ShowS
showList :: [FuzzyQuery] -> ShowS
Show, (forall x. FuzzyQuery -> Rep FuzzyQuery x)
-> (forall x. Rep FuzzyQuery x -> FuzzyQuery) -> Generic FuzzyQuery
forall x. Rep FuzzyQuery x -> FuzzyQuery
forall x. FuzzyQuery -> Rep FuzzyQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuzzyQuery -> Rep FuzzyQuery x
from :: forall x. FuzzyQuery -> Rep FuzzyQuery x
$cto :: forall x. Rep FuzzyQuery x -> FuzzyQuery
to :: forall x. Rep FuzzyQuery x -> FuzzyQuery
Generic)

instance ToJSON FuzzyQuery where
  toJSON :: FuzzyQuery -> Value
toJSON
    ( FuzzyQuery
        (FieldName Text
fieldName)
        Text
queryText
        PrefixLength
prefixLength
        MaxExpansions
maxEx
        Fuzziness
fuzziness
        Maybe Boost
boost
      ) =
      [Pair] -> Value
object [Text -> Key
fromText Text
fieldName Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls [Pair]
base]
      where
        base :: [Pair]
base =
          [ Key
"value" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
queryText,
            Key
"fuzziness" Key -> Fuzziness -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
            Key
"prefix_length" Key -> PrefixLength -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
            Key
"boost" Key -> Maybe Boost -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Boost
boost,
            Key
"max_expansions" Key -> MaxExpansions -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= MaxExpansions
maxEx
          ]

instance FromJSON FuzzyQuery where
  parseJSON :: Value -> Parser FuzzyQuery
parseJSON = String
-> (Object -> Parser FuzzyQuery) -> Value -> Parser FuzzyQuery
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyQuery" Object -> Parser FuzzyQuery
parse
    where
      parse :: Object -> Parser FuzzyQuery
parse = (FieldName -> Object -> Parser FuzzyQuery)
-> Object -> Parser FuzzyQuery
forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged ((FieldName -> Object -> Parser FuzzyQuery)
 -> Object -> Parser FuzzyQuery)
-> (FieldName -> Object -> Parser FuzzyQuery)
-> Object
-> Parser FuzzyQuery
forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName
-> Text
-> PrefixLength
-> MaxExpansions
-> Fuzziness
-> Maybe Boost
-> FuzzyQuery
FuzzyQuery FieldName
fn
          (Text
 -> PrefixLength
 -> MaxExpansions
 -> Fuzziness
 -> Maybe Boost
 -> FuzzyQuery)
-> Parser Text
-> Parser
     (PrefixLength
      -> MaxExpansions -> Fuzziness -> Maybe Boost -> FuzzyQuery)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"value"
          Parser
  (PrefixLength
   -> MaxExpansions -> Fuzziness -> Maybe Boost -> FuzzyQuery)
-> Parser PrefixLength
-> Parser (MaxExpansions -> Fuzziness -> Maybe Boost -> FuzzyQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser PrefixLength
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
          Parser (MaxExpansions -> Fuzziness -> Maybe Boost -> FuzzyQuery)
-> Parser MaxExpansions
-> Parser (Fuzziness -> Maybe Boost -> FuzzyQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser MaxExpansions
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_expansions"
          Parser (Fuzziness -> Maybe Boost -> FuzzyQuery)
-> Parser Fuzziness -> Parser (Maybe Boost -> FuzzyQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Fuzziness
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
          Parser (Maybe Boost -> FuzzyQuery)
-> Parser (Maybe Boost) -> Parser FuzzyQuery
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Boost)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"boost"

data FuzzyLikeFieldQuery = FuzzyLikeFieldQuery
  { FuzzyLikeFieldQuery -> FieldName
fuzzyLikeField :: FieldName,
    -- anaphora is good for the soul.
    FuzzyLikeFieldQuery -> Text
fuzzyLikeFieldText :: Text,
    FuzzyLikeFieldQuery -> MaxQueryTerms
fuzzyLikeFieldMaxQueryTerms :: MaxQueryTerms,
    FuzzyLikeFieldQuery -> IgnoreTermFrequency
fuzzyLikeFieldIgnoreTermFrequency :: IgnoreTermFrequency,
    FuzzyLikeFieldQuery -> Fuzziness
fuzzyLikeFieldFuzziness :: Fuzziness,
    FuzzyLikeFieldQuery -> PrefixLength
fuzzyLikeFieldPrefixLength :: PrefixLength,
    FuzzyLikeFieldQuery -> Boost
fuzzyLikeFieldBoost :: Boost,
    FuzzyLikeFieldQuery -> Maybe Analyzer
fuzzyLikeFieldAnalyzer :: Maybe Analyzer
  }
  deriving stock (FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
(FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool)
-> (FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool)
-> Eq FuzzyLikeFieldQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
== :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
$c/= :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
/= :: FuzzyLikeFieldQuery -> FuzzyLikeFieldQuery -> Bool
Eq, Int -> FuzzyLikeFieldQuery -> ShowS
[FuzzyLikeFieldQuery] -> ShowS
FuzzyLikeFieldQuery -> String
(Int -> FuzzyLikeFieldQuery -> ShowS)
-> (FuzzyLikeFieldQuery -> String)
-> ([FuzzyLikeFieldQuery] -> ShowS)
-> Show FuzzyLikeFieldQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuzzyLikeFieldQuery -> ShowS
showsPrec :: Int -> FuzzyLikeFieldQuery -> ShowS
$cshow :: FuzzyLikeFieldQuery -> String
show :: FuzzyLikeFieldQuery -> String
$cshowList :: [FuzzyLikeFieldQuery] -> ShowS
showList :: [FuzzyLikeFieldQuery] -> ShowS
Show, (forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x)
-> (forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery)
-> Generic FuzzyLikeFieldQuery
forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery
forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x
from :: forall x. FuzzyLikeFieldQuery -> Rep FuzzyLikeFieldQuery x
$cto :: forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery
to :: forall x. Rep FuzzyLikeFieldQuery x -> FuzzyLikeFieldQuery
Generic)

instance ToJSON FuzzyLikeFieldQuery where
  toJSON :: FuzzyLikeFieldQuery -> Value
toJSON
    ( FuzzyLikeFieldQuery
        (FieldName Text
fieldName)
        Text
fieldText
        MaxQueryTerms
maxTerms
        IgnoreTermFrequency
ignoreFreq
        Fuzziness
fuzziness
        PrefixLength
prefixLength
        Boost
boost
        Maybe Analyzer
analyzer
      ) =
      [Pair] -> Value
object
        [ Text -> Key
fromText Text
fieldName
            Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [Pair] -> Value
omitNulls
              [ Key
"like_text" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
fieldText,
                Key
"max_query_terms" Key -> MaxQueryTerms -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= MaxQueryTerms
maxTerms,
                Key
"ignore_tf" Key -> IgnoreTermFrequency -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= IgnoreTermFrequency
ignoreFreq,
                Key
"fuzziness" Key -> Fuzziness -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
                Key
"prefix_length" Key -> PrefixLength -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
                Key
"analyzer" Key -> Maybe Analyzer -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
                Key
"boost" Key -> Boost -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Boost
boost
              ]
        ]

instance FromJSON FuzzyLikeFieldQuery where
  parseJSON :: Value -> Parser FuzzyLikeFieldQuery
parseJSON = String
-> (Object -> Parser FuzzyLikeFieldQuery)
-> Value
-> Parser FuzzyLikeFieldQuery
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyLikeFieldQuery" Object -> Parser FuzzyLikeFieldQuery
parse
    where
      parse :: Object -> Parser FuzzyLikeFieldQuery
parse = (FieldName -> Object -> Parser FuzzyLikeFieldQuery)
-> Object -> Parser FuzzyLikeFieldQuery
forall (m :: * -> *) a.
(Monad m, MonadFail m) =>
(FieldName -> Object -> m a) -> Object -> m a
fieldTagged ((FieldName -> Object -> Parser FuzzyLikeFieldQuery)
 -> Object -> Parser FuzzyLikeFieldQuery)
-> (FieldName -> Object -> Parser FuzzyLikeFieldQuery)
-> Object
-> Parser FuzzyLikeFieldQuery
forall a b. (a -> b) -> a -> b
$ \FieldName
fn Object
o ->
        FieldName
-> Text
-> MaxQueryTerms
-> IgnoreTermFrequency
-> Fuzziness
-> PrefixLength
-> Boost
-> Maybe Analyzer
-> FuzzyLikeFieldQuery
FuzzyLikeFieldQuery FieldName
fn
          (Text
 -> MaxQueryTerms
 -> IgnoreTermFrequency
 -> Fuzziness
 -> PrefixLength
 -> Boost
 -> Maybe Analyzer
 -> FuzzyLikeFieldQuery)
-> Parser Text
-> Parser
     (MaxQueryTerms
      -> IgnoreTermFrequency
      -> Fuzziness
      -> PrefixLength
      -> Boost
      -> Maybe Analyzer
      -> FuzzyLikeFieldQuery)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
          Parser
  (MaxQueryTerms
   -> IgnoreTermFrequency
   -> Fuzziness
   -> PrefixLength
   -> Boost
   -> Maybe Analyzer
   -> FuzzyLikeFieldQuery)
-> Parser MaxQueryTerms
-> Parser
     (IgnoreTermFrequency
      -> Fuzziness
      -> PrefixLength
      -> Boost
      -> Maybe Analyzer
      -> FuzzyLikeFieldQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser MaxQueryTerms
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_query_terms"
          Parser
  (IgnoreTermFrequency
   -> Fuzziness
   -> PrefixLength
   -> Boost
   -> Maybe Analyzer
   -> FuzzyLikeFieldQuery)
-> Parser IgnoreTermFrequency
-> Parser
     (Fuzziness
      -> PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser IgnoreTermFrequency
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ignore_tf"
          Parser
  (Fuzziness
   -> PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
-> Parser Fuzziness
-> Parser
     (PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Fuzziness
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
          Parser
  (PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
-> Parser PrefixLength
-> Parser (Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser PrefixLength
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
          Parser (Boost -> Maybe Analyzer -> FuzzyLikeFieldQuery)
-> Parser Boost -> Parser (Maybe Analyzer -> FuzzyLikeFieldQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Boost
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
          Parser (Maybe Analyzer -> FuzzyLikeFieldQuery)
-> Parser (Maybe Analyzer) -> Parser FuzzyLikeFieldQuery
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Analyzer)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"

data FuzzyLikeThisQuery = FuzzyLikeThisQuery
  { FuzzyLikeThisQuery -> [FieldName]
fuzzyLikeFields :: [FieldName],
    FuzzyLikeThisQuery -> Text
fuzzyLikeText :: Text,
    FuzzyLikeThisQuery -> MaxQueryTerms
fuzzyLikeMaxQueryTerms :: MaxQueryTerms,
    FuzzyLikeThisQuery -> IgnoreTermFrequency
fuzzyLikeIgnoreTermFrequency :: IgnoreTermFrequency,
    FuzzyLikeThisQuery -> Fuzziness
fuzzyLikeFuzziness :: Fuzziness,
    FuzzyLikeThisQuery -> PrefixLength
fuzzyLikePrefixLength :: PrefixLength,
    FuzzyLikeThisQuery -> Boost
fuzzyLikeBoost :: Boost,
    FuzzyLikeThisQuery -> Maybe Analyzer
fuzzyLikeAnalyzer :: Maybe Analyzer
  }
  deriving stock (FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
(FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool)
-> (FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool)
-> Eq FuzzyLikeThisQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
== :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
$c/= :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
/= :: FuzzyLikeThisQuery -> FuzzyLikeThisQuery -> Bool
Eq, Int -> FuzzyLikeThisQuery -> ShowS
[FuzzyLikeThisQuery] -> ShowS
FuzzyLikeThisQuery -> String
(Int -> FuzzyLikeThisQuery -> ShowS)
-> (FuzzyLikeThisQuery -> String)
-> ([FuzzyLikeThisQuery] -> ShowS)
-> Show FuzzyLikeThisQuery
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FuzzyLikeThisQuery -> ShowS
showsPrec :: Int -> FuzzyLikeThisQuery -> ShowS
$cshow :: FuzzyLikeThisQuery -> String
show :: FuzzyLikeThisQuery -> String
$cshowList :: [FuzzyLikeThisQuery] -> ShowS
showList :: [FuzzyLikeThisQuery] -> ShowS
Show, (forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x)
-> (forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery)
-> Generic FuzzyLikeThisQuery
forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery
forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x
from :: forall x. FuzzyLikeThisQuery -> Rep FuzzyLikeThisQuery x
$cto :: forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery
to :: forall x. Rep FuzzyLikeThisQuery x -> FuzzyLikeThisQuery
Generic)

instance ToJSON FuzzyLikeThisQuery where
  toJSON :: FuzzyLikeThisQuery -> Value
toJSON
    ( FuzzyLikeThisQuery
        [FieldName]
fields
        Text
text
        MaxQueryTerms
maxTerms
        IgnoreTermFrequency
ignoreFreq
        Fuzziness
fuzziness
        PrefixLength
prefixLength
        Boost
boost
        Maybe Analyzer
analyzer
      ) =
      [Pair] -> Value
omitNulls [Pair]
base
      where
        base :: [Pair]
base =
          [ Key
"fields" Key -> [FieldName] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [FieldName]
fields,
            Key
"like_text" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
text,
            Key
"max_query_terms" Key -> MaxQueryTerms -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= MaxQueryTerms
maxTerms,
            Key
"ignore_tf" Key -> IgnoreTermFrequency -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= IgnoreTermFrequency
ignoreFreq,
            Key
"fuzziness" Key -> Fuzziness -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Fuzziness
fuzziness,
            Key
"prefix_length" Key -> PrefixLength -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= PrefixLength
prefixLength,
            Key
"analyzer" Key -> Maybe Analyzer -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Maybe Analyzer
analyzer,
            Key
"boost" Key -> Boost -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Boost
boost
          ]

instance FromJSON FuzzyLikeThisQuery where
  parseJSON :: Value -> Parser FuzzyLikeThisQuery
parseJSON = String
-> (Object -> Parser FuzzyLikeThisQuery)
-> Value
-> Parser FuzzyLikeThisQuery
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"FuzzyLikeThisQuery" Object -> Parser FuzzyLikeThisQuery
parse
    where
      parse :: Object -> Parser FuzzyLikeThisQuery
parse Object
o =
        [FieldName]
-> Text
-> MaxQueryTerms
-> IgnoreTermFrequency
-> Fuzziness
-> PrefixLength
-> Boost
-> Maybe Analyzer
-> FuzzyLikeThisQuery
FuzzyLikeThisQuery
          ([FieldName]
 -> Text
 -> MaxQueryTerms
 -> IgnoreTermFrequency
 -> Fuzziness
 -> PrefixLength
 -> Boost
 -> Maybe Analyzer
 -> FuzzyLikeThisQuery)
-> Parser [FieldName]
-> Parser
     (Text
      -> MaxQueryTerms
      -> IgnoreTermFrequency
      -> Fuzziness
      -> PrefixLength
      -> Boost
      -> Maybe Analyzer
      -> FuzzyLikeThisQuery)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser (Maybe [FieldName])
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"fields" Parser (Maybe [FieldName]) -> [FieldName] -> Parser [FieldName]
forall a. Parser (Maybe a) -> a -> Parser a
.!= []
          Parser
  (Text
   -> MaxQueryTerms
   -> IgnoreTermFrequency
   -> Fuzziness
   -> PrefixLength
   -> Boost
   -> Maybe Analyzer
   -> FuzzyLikeThisQuery)
-> Parser Text
-> Parser
     (MaxQueryTerms
      -> IgnoreTermFrequency
      -> Fuzziness
      -> PrefixLength
      -> Boost
      -> Maybe Analyzer
      -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"like_text"
          Parser
  (MaxQueryTerms
   -> IgnoreTermFrequency
   -> Fuzziness
   -> PrefixLength
   -> Boost
   -> Maybe Analyzer
   -> FuzzyLikeThisQuery)
-> Parser MaxQueryTerms
-> Parser
     (IgnoreTermFrequency
      -> Fuzziness
      -> PrefixLength
      -> Boost
      -> Maybe Analyzer
      -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser MaxQueryTerms
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"max_query_terms"
          Parser
  (IgnoreTermFrequency
   -> Fuzziness
   -> PrefixLength
   -> Boost
   -> Maybe Analyzer
   -> FuzzyLikeThisQuery)
-> Parser IgnoreTermFrequency
-> Parser
     (Fuzziness
      -> PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser IgnoreTermFrequency
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"ignore_tf"
          Parser
  (Fuzziness
   -> PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
-> Parser Fuzziness
-> Parser
     (PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Fuzziness
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"fuzziness"
          Parser
  (PrefixLength -> Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
-> Parser PrefixLength
-> Parser (Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser PrefixLength
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"prefix_length"
          Parser (Boost -> Maybe Analyzer -> FuzzyLikeThisQuery)
-> Parser Boost -> Parser (Maybe Analyzer -> FuzzyLikeThisQuery)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Boost
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"boost"
          Parser (Maybe Analyzer -> FuzzyLikeThisQuery)
-> Parser (Maybe Analyzer) -> Parser FuzzyLikeThisQuery
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser (Maybe Analyzer)
forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
.:? Key
"analyzer"