183 lines
4.5 KiB
Elixir
183 lines
4.5 KiB
Elixir
defmodule Mse25Web.ItemController do
|
|
use Mse25Web, :controller
|
|
alias Mse25.Directus
|
|
alias Mse25.Timeline
|
|
|
|
def index(conn, _params) do
|
|
case conn.path_info |> fetch do
|
|
{:ok, item_type, item_data} ->
|
|
render(conn, item_type, assigns(item_type, item_data))
|
|
|
|
{:not_found, message} ->
|
|
render(conn, message)
|
|
end
|
|
end
|
|
|
|
defp fetch([year, slug], :article) do
|
|
case Directus.get_article(year <> "/" <> slug) do
|
|
{:ok, response} -> {:ok, :article, response}
|
|
_ -> fetch([year, slug], :link)
|
|
end
|
|
end
|
|
|
|
defp fetch([year, slug], :link) do
|
|
case Directus.get_link(year <> "/" <> slug) do
|
|
{:ok, response} -> {:ok, :link, response}
|
|
_ -> fetch([year, slug], :event)
|
|
end
|
|
end
|
|
|
|
defp fetch([year, slug], :event) do
|
|
case Directus.get_event(year <> "/" <> slug) do
|
|
{:ok, response} -> {:ok, :event, response}
|
|
not_found -> not_found
|
|
end
|
|
end
|
|
|
|
defp fetch([_year, album_id], :album) do
|
|
case Directus.get_album(album_id) do
|
|
{:ok, response} -> {:ok, :album, response}
|
|
not_found -> not_found
|
|
end
|
|
end
|
|
|
|
defp fetch([year, "brutal-legend-" <> external_id]) do
|
|
fetch([year, external_id], :album)
|
|
end
|
|
|
|
defp fetch([year, slug]) do
|
|
fetch([year, slug], :article)
|
|
end
|
|
|
|
defp fetch([slug]) do
|
|
case Integer.parse(slug) do
|
|
:error ->
|
|
case Directus.get_page(slug) do
|
|
{:ok, response} -> {:ok, :page, response}
|
|
error -> error
|
|
end
|
|
|
|
{year, _} ->
|
|
case Timeline.annual(year) do
|
|
{:ok, response} -> {:ok, :annual, response}
|
|
error -> error
|
|
end
|
|
end
|
|
end
|
|
|
|
defp assigns(:annual, %{
|
|
timeline: timeline,
|
|
year: year,
|
|
counts: counts
|
|
}),
|
|
do: [
|
|
year: year,
|
|
page_title: "Innehåll från " <> to_string(year),
|
|
timeline: timeline,
|
|
brutal_legends_count: Map.get(counts, :albums, 0),
|
|
article_count: Map.get(counts, :articles, 0),
|
|
event_count: Map.get(counts, :events, 0),
|
|
link_count: Map.get(counts, :links, 0)
|
|
]
|
|
|
|
defp assigns(:article, %{
|
|
"title" => heading,
|
|
"contents" => contents,
|
|
"pubDate" => published_at,
|
|
"date_updated" => updated_at
|
|
}) do
|
|
[
|
|
page_title: heading,
|
|
heading: heading,
|
|
contents: Earmark.as_html!(contents),
|
|
published_at: published_at,
|
|
updated_at:
|
|
case updated_at do
|
|
nil -> published_at
|
|
ua -> String.slice(ua, 0..9)
|
|
end,
|
|
year: String.slice(published_at, 0..3)
|
|
]
|
|
end
|
|
|
|
defp assigns(:event, %{
|
|
"title" => heading,
|
|
"contents" => contents,
|
|
"started_at" => started_at,
|
|
"lead" => lead,
|
|
"poster" => poster,
|
|
"bands" => bands,
|
|
"mia" => mia,
|
|
"category" => category
|
|
}) do
|
|
[
|
|
page_title: heading,
|
|
heading: heading,
|
|
contents: Earmark.as_html!(contents),
|
|
lead: lead,
|
|
year: String.slice(started_at, 0..3),
|
|
poster: poster,
|
|
bands: bands,
|
|
mia: mia,
|
|
category: category
|
|
]
|
|
end
|
|
|
|
defp assigns(:link, %{
|
|
"title" => heading,
|
|
"contents" => contents,
|
|
"pubDate" => published_at,
|
|
"date_updated" => updated_at,
|
|
"source" => url,
|
|
"h1" => title
|
|
}) do
|
|
[
|
|
page_title: heading,
|
|
heading: heading,
|
|
contents: Earmark.as_html!(contents),
|
|
published_at: published_at,
|
|
url: url,
|
|
title: title,
|
|
year: String.slice(published_at, 0..3),
|
|
updated_at:
|
|
case updated_at do
|
|
nil -> published_at
|
|
ua -> String.slice(ua, 0..9)
|
|
end
|
|
]
|
|
end
|
|
|
|
defp assigns(:page, %{
|
|
"title" => heading,
|
|
"contents" => contents,
|
|
"date_updated" => updated_at
|
|
}) do
|
|
[
|
|
heading: heading,
|
|
contents: Earmark.as_html!(contents),
|
|
updated_at: String.slice(updated_at, 0..9)
|
|
]
|
|
end
|
|
|
|
defp assigns(:album, %{
|
|
"year" => year,
|
|
"album" => album,
|
|
"contents" => contents,
|
|
"cover" => cover,
|
|
"purchased_at" => purchased_at,
|
|
"externalId" => count,
|
|
"songs" => songs
|
|
}) do
|
|
[
|
|
count: count,
|
|
page_title: album,
|
|
album: album,
|
|
cover: cover,
|
|
year: to_string(year),
|
|
purchase_year: String.slice(purchased_at, 0..3),
|
|
contents: Earmark.as_html!(contents),
|
|
songs: Enum.map(songs, fn %{"title" => name} -> "\"" <> name <> "\"" end),
|
|
artist: List.first(songs) |> Map.get("artist") |> Map.get("name")
|
|
]
|
|
end
|
|
end
|