defmodule Noizu.Weaviate.GraphQL.SearchOperator.NearText do
defmodule Concepts do
defstruct [
concepts: nil,
force: nil
]
end
defmodule Objects do
defstruct [
objects: nil,
force: nil
]
end
defstruct [
concepts: nil,
certainty: nil,
distance: nil,
autocorrect: nil,
move_to: nil,
move_to__concepts: nil,
move_to__objects: nil,
move_away_from: nil,
move_away_from__concepts: nil,
move_away_from__objects: nil,
move_away_from__force: nil,
]
defp from_option(nil), do: nil
defp from_options(options) do
concepts = case options[:concepts] do
v when is_bitstring(v) -> [v]
v when is_list(v) -> v
_ -> nil
end
objects = case options[:objects] do
v when is_bitstring(v) -> [%{id: v}]
v when is_list(v) ->
Enum.map(v, fn(obj) ->
case obj do
v when is_bitstring(v) -> %{id: v}
end
end)
_ -> nil
end
cond do
concepts ->
%Concepts{
concepts: concepts,
force: options[:force]
}
objects ->
%Objects{
objects: objects,
force: options[:force]
}
:else -> nil
end
end
def filter(container, concepts, options \\ nil) do
concepts = case concepts do
v when is_bitstring(v) -> [v]
v when is_list(v) -> v
end
move_to__concepts = case options[:"move_to{concepts}"] do
nil -> nil
v when is_list(v) -> v
v -> [v]
end
move_to__objects = case options[:"move_to{objects}"] do
nil -> nil
v when is_list(v) -> v
v -> [v]
end
move_away_from__concepts = case options[:"move_away_from{concepts}"] do
nil -> nil
v when is_list(v) -> v
v -> [v]
end
move_away_from__objects = case options[:"move_away_from{objects}"] do
nil -> nil
v when is_list(v) -> v
v -> [v]
end
operator = %__MODULE__{
concepts: concepts,
certainty: options[:certainty],
distance: options[:distance],
autocorrect: options[:autocorrect],
move_to: from_options(options[:move_to]),
move_to__concepts: move_to__concepts,
move_to__objects: move_to__objects,
move_away_from: from_options(options[:move_away_from]),
move_away_from__concepts: move_away_from__concepts,
move_away_from__objects: move_away_from__objects,
move_away_from__force: options[:"move_away_from{force}"],
}
container.__struct__.search_operator(container, operator)
end
defimpl Jason.Encoder do
defp nest(string, prefix) do
prepared = String.trim(string)
|> String.split("\n")
|> Enum.join("\n#{prefix}")
prepared
end
def encode(this, opts) do
contents =
[]
|> then(& this.concepts && [{:concepts, this.concepts} | &1] || &1)
|> then(& this.distance && [{:distance, this.distance} | &1] || &1)
|> then(& this.autocorrect in [true, false] && [{:autocorrect, this.autocorrect} | &1] || &1)
|> then(& this.move_to && ["move_to: #{Jason.encode!(this.move_to)}" | &1] || &1)
|> then(& this.move_to__concepts && [{:"moveTo{concepts}", this.move_to__concepts} | &1] || &1)
|> then(& this.move_to__objects && [{:"moveTo{objects}", this.move_to__objects} | &1] || &1)
|> then(& this.move_away_from && ["moveAwayFrom: #{Jason.encode!(this.move_away_from)}" | &1] || &1)
|> then(& this.move_away_from__concepts && [{:"moveAwayFrom{concepts}", this.move_away_from__concepts} | &1] || &1)
|> then(& this.move_away_from__objects && [{:"moveAwayFrom{objects}", this.move_away_from__objects} | &1] || &1)
|> then(& this.move_away_from__force && [{:"moveAwayFrom{force}", this.move_away_from__force} | &1] || &1)
|> Enum.map(fn
{k,v} -> "#{k}: #{inspect v}"
{k} -> k
end)
|> Enum.join(",\n")
"""
nearText: {
#{nest(contents, " ")}
}
""" |> String.trim()
end
end
end