frenzy/lib/frenzy_web/controllers/fever_controller.ex

206 lines
4.5 KiB
Elixir

defmodule FrenzyWeb.FeverController do
use FrenzyWeb, :controller
alias Frenzy.{Repo, Group, Feed, Item}
import Ecto.Query
plug :api_check
def api_check(conn, _) do
if Map.has_key?(conn.params, "api") do
conn
else
conn |> resp(400, "Invalid request") |> halt()
end
end
def get(conn, _params) do
json(conn, %{api_version: 2, auth: 0})
end
def post(conn, %{"api_key" => api_key} = params) do
case validate_key(api_key) do
:invalid ->
resp(conn, 401, "Invalid API key")
:ok ->
json(conn, fever_response(params))
end
end
defp validate_key(api_key) do
auth = Application.get_env(:frenzy, :auth)
username = auth[:username]
password = auth[:password]
expected = :crypto.hash(:md5, "#{username}:#{password}") |> Base.encode16(case: :lower)
case api_key |> String.downcase() do
^expected -> :ok
_ -> :invalid
end
end
defp fever_response(params) do
%{api_version: 2, auth: 1}
|> mark(params)
|> unread_recently_read(params)
|> feeds(params)
|> groups(params)
|> feeds_groups(params)
|> favicons(params)
|> links(params)
|> unread(params)
|> saved(params)
|> items(params)
end
defp mark(res, %{"mark" => "item", "id" => id, "as" => as}) do
item = Repo.get(Item, id) |> Repo.preload(:feed)
diff =
case as do
"read" ->
%{read: true, read_date: Timex.now()}
"unread" ->
%{read: false, read_date: nil}
_ ->
%{}
end
changeset = Item.changeset(item, diff)
Repo.update(changeset)
res
end
defp mark(res, _), do: res
defp unread_recently_read(res, %{"unread_recently_read" => 1}) do
Repo.all(from i in Item, where: i.read, where: i.read_date >= from_now(-1, "hour"))
|> Enum.map(fn i -> Item.changeset(i, %{read: false, read_date: nil}) end)
|> Enum.map(&Repo.update/1)
res
end
defp unread_recently_read(res, _), do: res
defp feeds(res, %{"feeds" => _}) do
feeds =
Repo.all(Feed)
|> Enum.map(&Feed.to_fever/1)
res
|> Map.put(:feeds, feeds)
end
defp feeds(res, _), do: res
defp groups(res, %{"groups" => _}) do
groups =
Repo.all(Group)
|> Enum.map(&Group.to_fever_group/1)
res
|> Map.put(:groups, groups)
end
defp groups(res, _), do: res
defp feeds_groups(res, params) do
if Map.has_key?(params, "feeds") or Map.has_key?(params, "groups") do
feeds_groups =
Repo.all(from Group, preload: [:feeds])
|> Enum.map(&Group.to_fever_feeds_group/1)
res
|> Map.put(:feeds_groups, feeds_groups)
else
res
end
end
defp favicons(res, %{"favicons" => _}) do
res
|> Map.put(:favicons, [])
end
defp favicons(res, _), do: res
defp links(res, %{"links" => _}) do
res
|> Map.put(:links, [])
end
defp links(res, _), do: res
defp unread(res, %{"unread_item_ids" => _}) do
unread =
Repo.all(from Item, where: [read: false])
|> Enum.map(fn item -> item.id end)
|> Enum.join(",")
res
|> Map.put(:unread_item_ids, unread)
end
defp unread(res, _), do: res
defp saved(res, %{"saved_item_ids" => _}) do
res
|> Map.put(:saved_item_ids, "")
end
defp saved(res, _), do: res
defp items(res, %{"items" => _} = params) do
items =
cond do
Map.has_key?(params, "with_ids") ->
params["with_ids"]
|> String.split(",")
|> Enum.map(fn id ->
{id, _} = id |> String.trim() |> Integer.parse()
Repo.get(Item, id)
end)
Map.has_key?(params, "since_id") ->
since = Repo.get(Item, params["since_id"])
{since, _} = Integer.parse(since)
Repo.all(
from i in Item,
where: i.inserted_at > ^since.inserted_at,
order_by: [asc: :id],
limit: 50
)
Map.has_key?(params, "max_id") ->
max = Repo.get(Item, params["max_id"])
{max, _} = Integer.parse(max)
Repo.all(
from i in Item,
where: i.inserted_at < ^max.inserted_at,
order_by: [desc: :id],
limit: 50
)
true ->
[]
end
items =
items
|> Enum.reject(&is_nil/1)
|> Enum.reject(fn item -> item.tombstone end)
|> Enum.map(&Item.to_fever/1)
res
|> Map.put(:items, items)
|> Map.put(:total_items, Enum.count(items))
end
defp items(res, _), do: res
end