129 lines
3.5 KiB
Elixir
129 lines
3.5 KiB
Elixir
defmodule Frenzy.Pipeline.FilterStage do
|
|
require Logger
|
|
alias Frenzy.Pipeline.Stage
|
|
@behaviour Stage
|
|
|
|
@impl Stage
|
|
def apply(%{"mode" => mode, "score" => score, "rules" => rules}, item_params)
|
|
when is_binary(mode) and is_integer(score) and is_list(rules) do
|
|
item_score =
|
|
rules
|
|
|> Enum.map(fn rule -> test(rule, item_params) end)
|
|
|> Enum.sum()
|
|
|
|
matches = item_score >= score
|
|
|
|
case {mode, matches} do
|
|
{"accept", true} ->
|
|
{:ok, item_params}
|
|
|
|
{"reject", false} ->
|
|
{:ok, item_params}
|
|
|
|
_ ->
|
|
Logger.debug("Skipping item #{item_params.url} due to feed filter")
|
|
:tombstone
|
|
end
|
|
end
|
|
|
|
@impl Stage
|
|
def apply(opts, item_params) do
|
|
Logger.warn("Received invalid filter opts: #{opts}")
|
|
{:ok, item_params}
|
|
end
|
|
|
|
@impl Stage
|
|
def validate_opts(opts) when is_map(opts) do
|
|
cond do
|
|
not (Map.has_key?(opts, "mode") and is_binary(opts["mode"]) and
|
|
opts["mode"] in ["accept", "reject"]) ->
|
|
{:error, "mode must be a string, either 'accept' or 'reject'"}
|
|
|
|
not (Map.has_key?(opts, "score") and is_integer(opts["score"])) ->
|
|
{:error, "score must be an integer"}
|
|
|
|
not (Map.has_key?(opts, "rules") and is_list(opts["rules"])) ->
|
|
{:error, "rules must be a list of rules"}
|
|
|
|
true ->
|
|
validate_rules(opts)
|
|
end
|
|
end
|
|
|
|
@impl Stage
|
|
def validate_opts(_opts), do: {:error, "options must be a map"}
|
|
|
|
defp validate_rules(%{"rules" => rules} = opts) do
|
|
rules
|
|
|> Enum.with_index()
|
|
|> Enum.reduce_while(:ok, fn {rule, index}, :ok ->
|
|
case validate_rule(rule) do
|
|
:ok ->
|
|
{:cont, :ok}
|
|
|
|
{:error, reason} ->
|
|
{:halt, {:error, "invalid rule #{index}: #{reason}"}}
|
|
end
|
|
end)
|
|
|> case do
|
|
:ok ->
|
|
{:ok, opts}
|
|
|
|
{:error, _reason} = err ->
|
|
err
|
|
end
|
|
end
|
|
|
|
defp validate_rule(rule) do
|
|
cond do
|
|
not is_map(rule) ->
|
|
{:error, "rule must be a map"}
|
|
|
|
not (Map.has_key?(rule, "mode") and is_binary(rule["mode"]) and
|
|
rule["mode"] in ["contains_string", "matches_regex"]) ->
|
|
{:error, "mode property must be a string, either 'contains_string' or 'matches_regex'"}
|
|
|
|
not (Map.has_key?(rule, "property") and is_binary(rule["property"]) and
|
|
rule["property"] in ["url", "title", "author"]) ->
|
|
{:error, "property property must be a string, either 'url', 'title', or 'author'"}
|
|
|
|
not (Map.has_key?(rule, "param") and is_binary(rule["param"])) ->
|
|
{:error, "param property must be a string"}
|
|
|
|
not (Map.has_key?(rule, "weight") and is_integer(rule["weight"])) ->
|
|
{:error, "weight property must be an integer"}
|
|
|
|
true ->
|
|
:ok
|
|
end
|
|
end
|
|
|
|
defp test(
|
|
%{"mode" => mode, "property" => property, "param" => param, "weight" => weight},
|
|
item_params
|
|
) do
|
|
with prop_value <- get_property(item_params, property),
|
|
true <- is_binary(prop_value),
|
|
true <- matches(prop_value, mode, param) do
|
|
weight
|
|
else
|
|
_ ->
|
|
0
|
|
end
|
|
end
|
|
|
|
def matches(value, "contains_string", param) do
|
|
String.contains?(value, param)
|
|
end
|
|
|
|
def matches(value, "matches_regex", param) do
|
|
{:ok, regex} = Regex.compile(param)
|
|
String.match?(value, regex)
|
|
end
|
|
|
|
defp get_property(item_params, "url"), do: item_params.url
|
|
defp get_property(item_params, "title"), do: item_params.title
|
|
defp get_property(item_params, "author"), do: item_params.author
|
|
defp get_property(_item_params, _property), do: {:error, "invalid property"}
|
|
end
|