Merge pull request #49 from epochtalk/breadcrumbs

Breadcrumbs

Author: akinsey

lib/epochtalk_server/models/board.ex

@@ -163,31 +163,9 @@ defmodule EpochtalkServer.Models.Board do
   @spec get_read_access_by_id(id :: non_neg_integer, user_priority :: non_neg_integer) ::
           {:ok, can_read :: boolean} | {:error, :board_does_not_exist}
   def get_read_access_by_id(id, user_priority) do
-    find_parent_initial_query =
-      BoardMapping
-      |> where([bm], bm.board_id == ^id)
-      |> select([bm], %{
-        board_id: bm.board_id,
-        parent_id: bm.parent_id,
-        category_id: bm.category_id
-      })
-
-    find_parent_recursion_query =
-      BoardMapping
-      |> join(:inner, [bm], fp in "find_parent", on: bm.board_id == fp.parent_id)
-      |> select([bm], %{
-        board_id: bm.board_id,
-        parent_id: bm.parent_id,
-        category_id: bm.category_id
-      })
-
-    find_parent_query =
-      find_parent_initial_query
-      |> union(^find_parent_recursion_query)
-
     Board
     |> recursive_ctes(true)
-    |> with_cte("find_parent", as: ^find_parent_query)
+    |> with_cte("find_parent", as: ^get_parent_query(id))
     |> join(:inner, [b], fp in "find_parent", on: b.id == fp.board_id)
     |> join(:left, [b, fp], c in Category, on: c.id == fp.category_id)
     |> select([b, fp, c], %{
@@ -236,4 +214,65 @@ defmodule EpochtalkServer.Models.Board do
       do: {:ok, id},
       else: {:error, :board_does_not_exist}
   end
+
+  @doc """
+  Used to obtain breadcrumb data for a specific `Board` given it's `slug`
+  """
+  @spec breadcrumb(slug :: String.t()) ::
+          {:ok, board :: t()} | {:error, :board_does_not_exist}
+  def breadcrumb(slug) when is_binary(slug) do
+    case slug_to_id(slug) do
+      {:ok, id} ->
+        Board
+        |> recursive_ctes(true)
+        |> with_cte("find_parent", as: ^get_parent_query(id))
+        |> join(:inner, [b], fp in "find_parent", on: b.id == fp.board_id)
+        |> join(:left, [b, fp], b2 in Board, on: b2.id == fp.parent_id)
+        |> join(:left, [b, fp, b2], c in Category, on: c.id == fp.category_id)
+        |> select([b, fp, b2, c], %{
+          id: b.id,
+          name: b.name,
+          parent_slug: b2.slug,
+          board_id: fp.board_id,
+          parent_id: fp.parent_id,
+          category_id: fp.category_id
+        })
+        |> Repo.all()
+        |> case do
+          [] ->
+            {:error, :board_does_not_exist}
+
+          board_and_parents ->
+            {:ok, board_and_parents}
+        end
+
+      {:error, :board_does_not_exist} ->
+        {:error, :board_does_not_exist}
+    end
+  end
+
+  ## === Private Helper Functions ===
+
+  defp get_parent_query(id) when is_integer(id) do
+    find_parent_initial_query =
+      BoardMapping
+      |> where([bm], bm.board_id == ^id)
+      |> select([bm], %{
+        board_id: bm.board_id,
+        parent_id: bm.parent_id,
+        category_id: bm.category_id
+      })
+
+    find_parent_recursion_query =
+      BoardMapping
+      |> join(:inner, [bm], fp in "find_parent", on: bm.board_id == fp.parent_id)
+      |> select([bm], %{
+        board_id: bm.board_id,
+        parent_id: bm.parent_id,
+        category_id: bm.category_id
+      })
+
+    find_parent_initial_query
+    |> union(^find_parent_recursion_query)
+  end
 end

lib/epochtalk_server/models/category.ex

@@ -110,4 +110,17 @@ defmodule EpochtalkServer.Models.Category do
   """
   @spec all() :: [t()]
   def all(), do: Repo.all(from Category, order_by: [asc: :view_order])
+
+  @doc """
+  Used to find a specific `Category` by it's `id`
+  """
+  @spec find_by_id(id :: non_neg_integer) ::
+          {:ok, category :: t()} | {:error, :category_does_not_exist}
+  def find_by_id(id) when is_integer(id) do
+    category = Repo.one(from c in Category, where: c.id == ^id)
+
+    if category,
+      do: {:ok, category},
+      else: {:error, :category_does_not_exist}
+  end
 end

lib/epochtalk_server/models/post.ex

@@ -171,4 +171,138 @@ defmodule EpochtalkServer.Models.Post do
     from(p in Post, where: p.id == ^id)
     |> Repo.update_all(set: [position: thread_post_count + 1])
   end
+
+  @doc """
+  Paginates `Post` records for a given a `Thread`
+  """
+  @spec page_by_thread_id(
+          thread_id :: non_neg_integer,
+          page :: non_neg_integer | nil,
+          opts :: list() | nil
+        ) :: [map()] | []
+  def page_by_thread_id(thread_id, page \\ 1, opts \\ []) do
+    per_page = Keyword.get(opts, :per_page, 25)
+    user_id = Keyword.get(opts, :user_id)
+    page = if start = Keyword.get(opts, :start), do: ceil(start / per_page), else: page
+    start = page * per_page - per_page
+    start = if start < 0, do: 0, else: start
+
+    inner_query =
+      Post
+      |> where([p], p.thread_id == ^thread_id and p.position > ^start)
+      |> order_by([p], p.position)
+      |> limit(^per_page)
+      |> select([p], %{id: p.id, position: p.position})
+
+    from(plist in subquery(inner_query))
+    |> join(
+      :left_lateral,
+      [plist],
+      p1 in fragment(
+        """
+          SELECT
+            p.thread_id, t.board_id, t.slug, b.right_to_left, p.user_id, p.content ->> \'title\' as title,
+            p.content ->> \'body\' as body, p.metadata, p.deleted, p.locked, p.created_at,
+            p.updated_at, p.imported_at, CASE WHEN EXISTS (
+              SELECT rp.id
+              FROM administration.reports_posts rp
+              WHERE rp.offender_post_id = p.id AND rp.reporter_user_id = ?
+            )
+            THEN \'TRUE\'::boolean ELSE \'FALSE\'::boolean END AS reported,
+            CASE WHEN EXISTS (
+              SELECT ru.id
+              FROM administration.reports_users ru
+              WHERE ru.offender_user_id = p.user_id AND ru.reporter_user_id = ? AND ru.status = \'Pending\'
+            )
+            THEN \'TRUE\'::boolean ELSE \'FALSE\'::boolean END AS reported_author,
+            CASE WHEN p.user_id = (
+              SELECT user_id
+              FROM posts
+              WHERE thread_id = t.id ORDER BY created_at limit 1
+            )
+            THEN \'TRUE\'::boolean ELSE \'FALSE\'::boolean END AS original_poster,
+            u.username, u.deleted as user_deleted, up.signature, up.post_count, up.avatar,
+            up.fields->\'name\' as name
+          FROM posts p
+          LEFT JOIN users u ON p.user_id = u.id
+          LEFT JOIN users.profiles up ON u.id = up.user_id
+          LEFT JOIN threads t ON p.thread_id = t.id
+          LEFT JOIN boards b ON t.board_id = b.id
+          WHERE p.id = ?
+        """,
+        ^user_id,
+        ^user_id,
+        plist.id
+      ),
+      on: true
+    )
+    |> join(
+      :left_lateral,
+      [plist, p1],
+      p2 in fragment(
+        """
+          SELECT r.priority, r.highlight_color, r.name as role_name
+          FROM roles_users ru
+          LEFT JOIN roles r ON ru.role_id = r.id
+          WHERE ? = ru.user_id
+          ORDER BY r.priority limit 1
+        """,
+        p1.user_id
+      ),
+      on: true
+    )
+    |> join(
+      :left_lateral,
+      [],
+      p3 in fragment("""
+        SELECT priority FROM roles WHERE lookup =\'user\'
+      """),
+      on: true
+    )
+    |> select([plist, p1, p2, p3], %{
+      id: plist.id,
+      position: plist.position,
+      thread_id: p1.thread_id,
+      board_id: p1.board_id,
+      slug: p1.slug,
+      user_id: p1.user_id,
+      title: p1.title,
+      body: p1.body,
+      deleted: p1.deleted,
+      locked: p1.locked,
+      right_to_left: p1.right_to_left,
+      metadata: p1.metadata,
+      created_at: p1.created_at,
+      updated_at: p1.updated_at,
+      imported_at: p1.updated_at,
+      username: p1.username,
+      reported: p1.reported,
+      reported_author: p1.reported_author,
+      original_poster: p1.original_poster,
+      user_deleted: p1.user_deleted,
+      signature: p1.signature,
+      avatar: p1.avatar,
+      post_count: p1.post_count,
+      name: p1.name,
+      priority: p2.priority,
+      highlight_color: p2.highlight_color,
+      role_name: p2.role_name,
+      default_priority: p3.priority
+    })
+    |> order_by([plist], plist.position)
+    |> Repo.all()
+  end
+
+  @doc """
+  Used to find a specific `Post` by it's `id`
+  """
+  @spec find_by_id(id :: non_neg_integer) :: t()
+  def find_by_id(id) when is_integer(id) do
+    query =
+      from p in Post,
+        where: p.id == ^id,
+        preload: [:thread, user: :profile]
+
+    Repo.one(query)
+  end
 end

lib/epochtalk_server/models/thread.ex

@@ -259,6 +259,29 @@ defmodule EpochtalkServer.Models.Thread do
     }
   end
 
+  @doc """
+  Used to obtain breadcrumb data for a specific `Thread` given it's `slug`
+  """
+  @spec breadcrumb(slug :: String.t()) ::
+          {:ok, thread :: t()} | {:error, :thread_does_not_exist}
+  def breadcrumb(slug) when is_binary(slug) do
+    post_query =
+      from p in Post,
+        order_by: p.created_at,
+        limit: 1
+
+    thread_query =
+      from t in Thread,
+        where: t.slug == ^slug,
+        preload: [:board, posts: ^post_query]
+
+    thread = Repo.one(thread_query)
+
+    if thread,
+      do: {:ok, thread},
+      else: {:error, :thread_does_not_exist}
+  end
+
   ## === Private Helper Functions ===
 
   defp sticky_by_board_id(board_id, page, opts) when page == 1,

lib/epochtalk_server_web/controllers/breadcrumb.ex

@@ -0,0 +1,33 @@
+defmodule EpochtalkServerWeb.Controllers.Breadcrumb do
+  use EpochtalkServerWeb, :controller
+
+  @moduledoc """
+  Controller For `Breadcrumbs` related API requests
+  """
+  alias EpochtalkServerWeb.Helpers.Breadcrumbs
+  alias EpochtalkServerWeb.ErrorHelpers
+  alias EpochtalkServerWeb.Helpers.Validate
+
+  @doc """
+  Used to return breadcrumbs to the frontend`
+  """
+  def breadcrumbs(conn, attrs) do
+    with id <- parse_id(attrs, attrs["id"]),
+         type <- Validate.cast(attrs, "type", :string, required: true),
+         {:ok, breadcrumbs} <- Breadcrumbs.build_crumbs(id, type, []) do
+      render(conn, :breadcrumbs, breadcrumbs: breadcrumbs)
+    else
+      {:error, data} ->
+        ErrorHelpers.render_json_error(conn, 400, data)
+
+      _ ->
+        ErrorHelpers.render_json_error(conn, 500, "There was an issue obtaining the breadcrumbs")
+    end
+  end
+
+  defp parse_id(attrs, id) when is_integer(id),
+    do: Validate.cast(attrs, "id", :integer, min: 1, required: true)
+
+  defp parse_id(attrs, id) when is_binary(id),
+    do: Validate.cast(attrs, "id", :string, required: true)
+end