Merge pull request #34 from epochtalk/threads-by-board

Threads by board

Author: unenglishable

.iex.exs

@@ -7,13 +7,15 @@ alias EpochtalkServer.Models.{
   Ban,
   BannedAddress,
   Board,
+  BoardBan,
   BoardMapping,
   BoardModerator,
   Category,
   Configuration,
   Invitation,
   Mention,
   MetadataBoard,
+  MetadataThread,
   Notification,
   Permission,
   Post,

lib/epochtalk_server/models/board.ex

@@ -1,6 +1,7 @@
 defmodule EpochtalkServer.Models.Board do
   use Ecto.Schema
   import Ecto.Changeset
+  import Ecto.Query
   alias EpochtalkServer.Repo
   alias EpochtalkServer.Models.Category
   alias EpochtalkServer.Models.BoardMapping
@@ -121,4 +122,112 @@ defmodule EpochtalkServer.Models.Board do
         {:error, cs}
     end
   end
+
+  @doc """
+  Determines if the provided `user_priority` has write access to the board with the specified `id`
+
+  TODO(akinsey): Should this check against banned user_priority?
+  """
+  @spec get_write_access_by_id(id :: non_neg_integer, user_priority :: non_neg_integer) ::
+          {:ok, can_write :: boolean} | {:error, :board_does_not_exist}
+  def get_write_access_by_id(id, user_priority) do
+    query =
+      from b in Board,
+        where: b.id == ^id,
+        select: %{postable_by: b.postable_by}
+
+    board = Repo.one(query)
+
+    if board do
+      # allow write if postable_by is nil
+      can_write = is_nil(board.postable_by)
+      # if postable_by is an integer, check against user priority
+      can_write =
+        if is_integer(board.postable_by),
+          do: user_priority <= board.postable_by,
+          else: can_write
+
+      {:ok, can_write}
+    else
+      {:error, :board_does_not_exist}
+    end
+  end
+
+  @doc """
+  Determines if the provided `user_priority` has read access to the `Board` with the specified `id`.
+  If the user doesn't have read access to the parent of the specified `Board`, the user does not have
+  read access to the `Board` either.
+
+  TODO(akinsey): Should this check against banned user_priority?
+  """
+  @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_and_parents =
+      Board
+      |> recursive_ctes(true)
+      |> with_cte("find_parent", as: ^find_parent_query)
+      |> 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], %{
+        board_id: fp.board_id,
+        parent_id: fp.parent_id,
+        category_id: fp.category_id,
+        cat_viewable_by: c.viewable_by,
+        board_viewable_by: b.viewable_by
+      })
+      |> Repo.all()
+
+    # not readable if nothing in list, readable if viewable_by is nil, otherwise check viewable_by against user priority
+    can_read =
+      Enum.reduce(board_and_parents, length(board_and_parents) > 0, fn i, acc ->
+        boards_viewable =
+          not (is_integer(i.board_viewable_by) && user_priority > i.board_viewable_by)
+
+        cats_viewable = not (is_integer(i.cat_viewable_by) && user_priority > i.cat_viewable_by)
+        acc && boards_viewable && cats_viewable
+      end)
+
+    {:ok, can_read}
+  end
+
+  @doc """
+  Converts a board's `slug` to `id`
+  """
+  @spec slug_to_id(slug :: String.t()) ::
+          {:ok, id :: non_neg_integer} | {:error, :board_does_not_exist}
+  def slug_to_id(slug) when is_binary(slug) do
+    query =
+      from b in Board,
+        where: b.slug == ^slug,
+        select: b.id
+
+    id = Repo.one(query)
+
+    if id,
+      do: {:ok, id},
+      else: {:error, :board_does_not_exist}
+  end
 end

lib/epochtalk_server/models/board_ban.ex

@@ -0,0 +1,112 @@
+defmodule EpochtalkServer.Models.BoardBan do
+  use Ecto.Schema
+  import Ecto.Query
+  import Ecto.Changeset
+  alias EpochtalkServer.Repo
+  alias EpochtalkServer.Models.User
+  alias EpochtalkServer.Models.Thread
+  alias EpochtalkServer.Models.Post
+  alias EpochtalkServer.Models.BoardBan
+  alias EpochtalkServer.Models.Board
+
+  @moduledoc """
+  `BoardBan` model, for performing actions relating a user's profile
+  """
+  @type t :: %__MODULE__{
+          user_id: non_neg_integer | nil,
+          user_id: non_neg_integer | nil
+        }
+  @primary_key false
+  @schema_prefix "users"
+  schema "board_bans" do
+    belongs_to :user, User
+    belongs_to :board, Board
+  end
+
+  ## === Changesets Functions ===
+
+  @doc """
+  Creates a generic changeset for `BoardBan` model
+  """
+  @spec changeset(board_ban :: t(), attrs :: map() | nil) :: Ecto.Changeset.t()
+  def changeset(board_ban, attrs \\ %{}) do
+    board_ban
+    |> cast(attrs, [
+      :user_id,
+      :board_id
+    ])
+    |> validate_required([:user_id, :board_id])
+  end
+
+  ## === Database Functions ===
+
+  @doc """
+  Used to check if `User` is banned from board.
+  Accepts a `board_id`, `post_id` or `thread_id` as an option.
+
+  Returns `true` if the user is banned from the specified `Board` or `false`
+  otherwise.
+  """
+  @spec is_banned_from_board(user :: User.t(), opts :: list) :: {:ok, banned :: boolean}
+  def is_banned_from_board(%{id: user_id} = _user, opts) when is_integer(user_id) do
+    board_id = Keyword.get(opts, :board_id)
+    post_id = Keyword.get(opts, :post_id)
+    thread_id = Keyword.get(opts, :thread_id)
+
+    query =
+      cond do
+        is_integer(board_id) ->
+          from bb in BoardBan,
+            where: bb.user_id == ^user_id and bb.board_id == ^board_id,
+            select: bb.user_id
+
+        is_integer(post_id) ->
+          from bb in BoardBan,
+            where:
+              bb.user_id == ^user_id and
+                bb.board_id ==
+                  subquery(
+                    from(p in Post,
+                      left_join: t in Thread,
+                      on: t.id == p.thread_id,
+                      where: p.id == ^post_id,
+                      select: t.board_id
+                    )
+                  ),
+            select: bb.user_id
+
+        is_integer(thread_id) ->
+          from bb in BoardBan,
+            where:
+              bb.user_id == ^user_id and
+                bb.board_id ==
+                  subquery(from(t in Thread, where: t.id == ^thread_id, select: t.board_id)),
+            select: bb.user_id
+
+        true ->
+          nil
+      end
+
+    result = if query, do: is_integer(Repo.one(query)), else: false
+    {:ok, result}
+  end
+
+  def is_banned_from_board(nil, _opts), do: {:ok, false}
+
+  @doc """
+  Used to check if `User` with specified `user_id` is not banned from board.
+  Accepts a `board_id`, `post_id` or `thread_id` as an option.
+
+  Returns `true` if the user is **not** banned from the specified `Board` or `false`
+  otherwise.
+  """
+  @spec is_not_banned_from_board(user :: User.t(), opts :: list) :: {:ok, not_banned :: boolean}
+  def is_not_banned_from_board(user, opts \\ [])
+
+  def is_not_banned_from_board(%{id: user_id} = user, opts) when is_integer(user_id) do
+    {:ok, banned} = is_banned_from_board(user, opts)
+    {:ok, !banned}
+  end
+
+  def is_not_banned_from_board(nil, _opts), do: {:ok, true}
+end

lib/epochtalk_server/models/board_mapping.ex

@@ -4,7 +4,9 @@ defmodule EpochtalkServer.Models.BoardMapping do
   import Ecto.Query, only: [from: 2]
   alias EpochtalkServer.Repo
   alias EpochtalkServer.Models.Board
+  alias EpochtalkServer.Models.MetadataBoard
   alias EpochtalkServer.Models.BoardMapping
+  alias EpochtalkServer.Models.Thread
   alias EpochtalkServer.Models.Category
 
   @moduledoc """
@@ -16,12 +18,23 @@ defmodule EpochtalkServer.Models.BoardMapping do
           category: Category.t() | term(),
           view_order: non_neg_integer | nil
         }
+  @derive {Jason.Encoder,
+           only: [
+             :board_id,
+             :parent_id,
+             :category_id,
+             :view_order,
+             :stats,
+             :thread
+           ]}
   @primary_key false
   schema "board_mapping" do
     belongs_to :board, Board, primary_key: true
     belongs_to :parent, Board, primary_key: true
     belongs_to :category, Category, primary_key: true
     field :view_order, :integer
+    field :stats, :map, virtual: true
+    field :thread, :map, virtual: true
   end
 
   ## === Changesets Functions ===
@@ -65,6 +78,37 @@ defmodule EpochtalkServer.Models.BoardMapping do
     end)
   end
 
+  @doc """
+  Returns BoardMapping with loaded boards and relevant metadata
+
+  TODO(akinsey): writing this assuming other models will update metadata board table properly.
+  Old implementation was querying metadata boards then filling in holes in the data after the fact.
+  """
+  @spec all(opts :: list() | nil) :: [t()]
+  def all(opts \\ []) do
+    stripped = Keyword.get(opts, :stripped, false)
+
+    query =
+      if stripped do
+        from bm in BoardMapping,
+          left_join: b in Board,
+          on: bm.board_id == b.id,
+          select_merge: %{
+            board: %{id: b.id, slug: b.slug, name: b.name, viewable_by: b.viewable_by}
+          }
+      else
+        from bm in BoardMapping,
+          left_join: mb in MetadataBoard,
+          on: bm.board_id == mb.board_id,
+          left_join: t in Thread,
+          on: mb.last_thread_id == t.id,
+          select_merge: %{stats: mb, thread: t},
+          preload: [:board]
+      end
+
+    Repo.all(query)
+  end
+
   ## === Private Helper Functions ===
 
   defp update(cat, "category"), do: Category.update_for_board_mapping(cat)

lib/epochtalk_server/models/board_moderator.ex

@@ -1,8 +1,11 @@
 defmodule EpochtalkServer.Models.BoardModerator do
   use Ecto.Schema
   import Ecto.Changeset
+  import Ecto.Query
+  alias EpochtalkServer.Repo
   alias EpochtalkServer.Models.User
   alias EpochtalkServer.Models.Board
+  alias EpochtalkServer.Models.BoardModerator
 
   @moduledoc """
   `BoardModerator` model, for performing actions relating to `Board` moderators
@@ -11,6 +14,11 @@ defmodule EpochtalkServer.Models.BoardModerator do
           user_id: non_neg_integer,
           board_id: non_neg_integer
         }
+  @derive {Jason.Encoder,
+           only: [
+             :user_id,
+             :board_id
+           ]}
   @primary_key false
   schema "board_moderators" do
     belongs_to :user, User
@@ -31,4 +39,6 @@ defmodule EpochtalkServer.Models.BoardModerator do
     |> cast(attrs, [:user_id, :board_id])
     |> validate_required([:user_id, :board_id])
   end
+
+  def all(), do: Repo.all(from BoardModerator, preload: [user: ^from(User, select: [:username])])
 end

lib/epochtalk_server/models/category.ex

@@ -1,6 +1,7 @@
 defmodule EpochtalkServer.Models.Category do
   use Ecto.Schema
   import Ecto.Changeset
+  import Ecto.Query
   alias EpochtalkServer.Repo
   alias EpochtalkServer.Models.Board
   alias EpochtalkServer.Models.Category
@@ -103,4 +104,10 @@ defmodule EpochtalkServer.Models.Category do
     |> update_for_board_mapping_changeset(category_map)
     |> Repo.update()
   end
+
+  @doc """
+  Returns a list of all categories
+  """
+  @spec all() :: [t()]
+  def all(), do: Repo.all(from Category, order_by: [asc: :view_order])
 end

lib/epochtalk_server/models/metadata_board.ex

@@ -22,6 +22,20 @@ defmodule EpochtalkServer.Models.MetadataBoard do
           last_thread_title: String.t() | nil,
           last_post_position: non_neg_integer | nil
         }
+  @derive {Jason.Encoder,
+           only: [
+             :id,
+             :board_id,
+             :post_count,
+             :thread_count,
+             :total_post,
+             :total_thread_count,
+             :last_post_username,
+             :last_post_created_at,
+             :last_thread_id,
+             :last_thread_title,
+             :last_post_position
+           ]}
   @schema_prefix "metadata"
   schema "boards" do
     belongs_to :board, Board