Merge branch 'flag-enhance' into dev

Author: mydearxym

Makefile

@@ -40,22 +40,24 @@ launch.dev:
 launch.mock:
 	MIX_ENV=mock mix phx.server
 launch.prod:
-	mix phx.server
+	MIX_ENV=prod mix phx.server
 
 migrate:
 	mix ecto.migrate
 migrate.mock:
 	MIX_ENV=mock mix ecto.migrate
 rollback:
 	mix ecto.rollback
-migrate.mock:
-  MIX_ENV=mock mix ecto.migrate
 rollback.mock:
-  MIX_ENV=mock mix ecto.rollback
+	MIX_ENV=mock mix ecto.rollback
+rollback.test:
+	MIX_ENV=test mix ecto.rollback
 migrate.dev:
 	MIX_ENV=dev mix ecto.migrate
+migrate.test:
+	MIX_ENV=test mix ecto.migrate
 rollback.dev:
-  MIX_ENV=dev mix ecto.rollback
+	MIX_ENV=dev mix ecto.rollback
 
 gen.help:
 	$(call gen.help)

lib/helper/certification.ex

@@ -53,10 +53,23 @@ defmodule Helper.Certification do
         "post.community.unset",
         "job.community.set",
         "job.community.unset",
+        # flag on content
         "post.pin",
         "post.undo_pin",
         "post.trash",
-        "post.undo_trash"
+        "post.undo_trash",
+        "job.pin",
+        "job.undo_pin",
+        "job.trash",
+        "job.undo_trash",
+        "video.pin",
+        "video.undo_pin",
+        "video.trash",
+        "video.undo_trash",
+        "repo.pin",
+        "repo.undo_pin",
+        "repo.trash",
+        "repo.undo_trash"
       ],
       community: [
         # thread
@@ -74,12 +87,27 @@ defmodule Helper.Certification do
         "post.tag.delete",
         "post.tag.set",
         "post.tag.unset",
+        # post flag
+        "post.pin",
+        "post.undo_pin",
+        "post.trash",
+        "post.undo_trash",
         # job tag
         "job.tag.create",
         "job.tag.update",
         "job.tag.delete",
         "job.tag.set",
-        "job.tag.unset"
+        "job.tag.unset",
+        # job flag
+        "job.pin",
+        "job.undo_pin",
+        "job.trash",
+        "job.undo_trash",
+        # video flag
+        "video.pin",
+        "video.undo_pin",
+        "video.trash",
+        "video.undo_trash"
       ]
     }
   end

lib/helper/query_builder.ex

@@ -88,8 +88,6 @@ defmodule Helper.QueryBuilder do
     |> order_by([_, s], {^direction, fragment("count(?)", s.id)})
   end
 
-  def default_article_filters, do: %{pin: false, trash: false}
-
   def filter_pack(queryable, filter) when is_map(filter) do
     Enum.reduce(filter, queryable, fn
       {:sort, :desc_inserted}, queryable ->
@@ -186,13 +184,13 @@ defmodule Helper.QueryBuilder do
       {:first, first}, queryable ->
         queryable |> limit(^first)
 
-      {:pin, bool}, queryable ->
-        queryable
-        |> where([p], p.pin == ^bool)
+      # {:pin, bool}, queryable ->
+      #   queryable
+      #   |> where([p], p.pin == ^bool)
 
-      {:trash, bool}, queryable ->
-        queryable
-        |> where([p], p.trash == ^bool)
+      # {:trash, bool}, queryable ->
+      #   queryable
+      #   |> where([p], p.trash == ^bool)
 
       {_, _}, queryable ->
         queryable

lib/mastani_server/cms/cms.ex

@@ -59,7 +59,8 @@ defmodule MastaniServer.CMS do
 
   # ArticleOperation
   # >> set flag on article, like: pin / unpin article
-  defdelegate set_flag(queryable, id, attrs, user), to: ArticleOperation
+  defdelegate set_community_flags(queryable, community_id, attrs), to: ArticleOperation
+
   # >> tag: set / unset
   defdelegate set_tag(community, thread, tag, content_id), to: ArticleOperation
   defdelegate unset_tag(thread, tag, content_id), to: ArticleOperation

lib/mastani_server/cms/delegates/article_curd.ex

@@ -21,39 +21,69 @@ defmodule MastaniServer.CMS.Delegate.ArticleCURD do
   get paged post / job ...
   """
   def paged_contents(queryable, filter) do
-    normal_content_fr = filter |> Map.merge(QueryBuilder.default_article_filters())
-
     queryable
-    |> ORM.find_all(normal_content_fr)
+    |> flag_query(filter)
+    |> ORM.find_all(filter)
     |> add_pin_contents_ifneed(queryable, filter)
   end
 
+  defp flag_query(queryable, filter, flag \\ %{}) do
+    flag = %{pin: false, trash: false} |> Map.merge(flag)
+
+    # NOTE: this case judge is used for test case
+    case filter |> Map.has_key?(:community) do
+      true ->
+        queryable
+        |> join(:inner, [q], f in assoc(q, :community_flags))
+        |> where([q, f], f.pin == ^flag.pin and f.trash == ^flag.trash)
+        |> join(:inner, [q, f], c in assoc(f, :community))
+        |> where([q, f, c], c.raw == ^filter.community)
+
+      false ->
+        queryable
+    end
+  end
+
   # only first page need pin contents
   defp add_pin_contents_ifneed(contents, queryable, filter) do
     with {:ok, normal_contents} <- contents,
+         true <- Map.has_key?(filter, :community),
          true <- 1 == Map.get(normal_contents, :page_number) do
-      pin_content_fr = filter |> Map.merge(%{pin: true})
-      {:ok, pined_content} = queryable |> ORM.find_all(pin_content_fr)
+      {:ok, pined_content} =
+        queryable
+        |> flag_query(filter, %{pin: true})
+        |> ORM.find_all(filter)
+
+      # TODO: add hot post pin/trash state ?
+      # don't by flag_changeset, dataloader make things complex
+      concat_contents(pined_content, normal_contents)
+    else
+      _error ->
+        contents
+    end
+  end
 
-      case pined_content |> Map.get(:total_count) do
-        0 ->
-          contents
+  defp concat_contents(pined_content, normal_contents) do
+    case pined_content |> Map.get(:total_count) do
+      0 ->
+        {:ok, normal_contents}
 
-        _ ->
-          pind_entries = pined_content |> Map.get(:entries)
-          normal_entries = normal_contents |> Map.get(:entries)
+      _ ->
+        # NOTE: this is tricy, should use dataloader refactor
+        pind_entries =
+          pined_content
+          |> Map.get(:entries)
+          |> Enum.map(&struct(&1, %{pin: true}))
 
-          normal_count = normal_contents |> Map.get(:total_count)
-          pind_count = pined_content |> Map.get(:total_count)
+        normal_entries = normal_contents |> Map.get(:entries)
 
-          normal_contents
-          |> Map.put(:entries, pind_entries ++ normal_entries)
-          |> Map.put(:total_count, pind_count + normal_count)
-          |> done
-      end
-    else
-      _error ->
-        contents
+        normal_count = normal_contents |> Map.get(:total_count)
+        pind_count = pined_content |> Map.get(:total_count)
+
+        normal_contents
+        |> Map.put(:entries, pind_entries ++ normal_entries)
+        |> Map.put(:total_count, pind_count + normal_count)
+        |> done
     end
   end
 
@@ -84,6 +114,21 @@ defmodule MastaniServer.CMS.Delegate.ArticleCURD do
       |> Multi.run(:set_community, fn %{add_content_author: content} ->
         ArticleOperation.set_community(community, thread, content.id)
       end)
+      |> Multi.run(:set_community_flag, fn %{add_content_author: content} ->
+        # TODO: remove this judge, as content should have a flag
+        case action |> Map.has_key?(:flag) do
+          true ->
+            ArticleOperation.set_community_flags(content, community.id, %{
+              pin: false,
+              trash: false
+            })
+
+          false ->
+            {:ok, "pass"}
+        end
+
+        # Repo.insert(%CMS.PostCommunityFlag{post_id: content.id, community_id: community.id, })
+      end)
       |> Multi.run(:set_tag, fn %{add_content_author: content} ->
         case attrs |> Map.has_key?(:tags) do
           true -> set_tags(community, thread, content.id, attrs.tags)
@@ -108,6 +153,10 @@ defmodule MastaniServer.CMS.Delegate.ArticleCURD do
     {:error, [message: "set community", code: ecode(:create_fails)]}
   end
 
+  defp create_content_result({:error, :set_community_flag, _result, _steps}) do
+    {:error, [message: "set community flag", code: ecode(:create_fails)]}
+  end
+
   defp create_content_result({:error, :set_tag, result, _steps}) do
     {:error, result}
   end

lib/mastani_server/cms/delegates/article_operation.ex

@@ -5,23 +5,72 @@ defmodule MastaniServer.CMS.Delegate.ArticleOperation do
   import MastaniServer.CMS.Utils.Matcher
   import Ecto.Query, warn: false
   import Helper.ErrorCode
+  import ShortMaps
 
   alias Helper.ORM
   alias MastaniServer.Accounts.User
-  alias MastaniServer.CMS.{Community, Tag}
+
+  alias MastaniServer.CMS.{
+    Community,
+    Post,
+    PostCommunityFlag,
+    Job,
+    JobCommunityFlag,
+    RepoCommunityFlag,
+    Video,
+    VideoCommunityFlag,
+    Tag
+  }
+
+  alias MastaniServer.CMS.Repo, as: CMSRepo
   alias MastaniServer.Repo
 
   @doc """
   pin / unpin, trash / untrash articles
   """
-  def set_flag(queryable, id, %{pin: _} = attrs, %User{} = _user) do
-    queryable |> ORM.find_update(id, attrs)
+  def set_community_flags(%Post{id: _} = content, community_id, attrs),
+    do: do_set_flag(content, community_id, attrs)
+
+  def set_community_flags(%Job{id: _} = content, community_id, attrs),
+    do: do_set_flag(content, community_id, attrs)
+
+  def set_community_flags(%CMSRepo{id: _} = content, community_id, attrs),
+    do: do_set_flag(content, community_id, attrs)
+
+  def set_community_flags(%Video{id: _} = content, community_id, attrs),
+    do: do_set_flag(content, community_id, attrs)
+
+  defp do_set_flag(content, community_id, attrs) do
+    with {:ok, content} <- ORM.find(content.__struct__, content.id),
+         {:ok, community} <- ORM.find(Community, community_id),
+         {:ok, record} <- insert_flag_record(content, community_id, attrs) do
+      {:ok, struct(content, %{pin: record.pin, trash: record.trash})}
+    end
   end
 
-  def set_flag(queryable, id, %{trash: _} = attrs, %User{} = _user) do
-    queryable |> ORM.find_update(id, attrs)
+  defp insert_flag_record(%Post{id: post_id}, community_id, attrs) do
+    clauses = ~m(post_id community_id)a
+    PostCommunityFlag |> ORM.upsert_by(clauses, Map.merge(attrs, clauses))
   end
 
+  defp insert_flag_record(%Job{id: job_id}, community_id, attrs) do
+    clauses = ~m(job_id community_id)a
+    JobCommunityFlag |> ORM.upsert_by(clauses, Map.merge(attrs, clauses))
+  end
+
+  defp insert_flag_record(%CMSRepo{id: repo_id}, community_id, attrs) do
+    clauses = ~m(repo_id community_id)a
+    RepoCommunityFlag |> ORM.upsert_by(clauses, Map.merge(attrs, clauses))
+  end
+
+  defp insert_flag_record(%Video{id: video_id}, community_id, attrs) do
+    clauses = ~m(video_id community_id)a
+    VideoCommunityFlag |> ORM.upsert_by(clauses, Map.merge(attrs, clauses))
+  end
+
+  @doc """
+  set content to diffent community
+  """
   def set_community(%Community{id: community_id}, thread, content_id) when valid_thread(thread) do
     with {:ok, action} <- match_action(thread, :community),
          {:ok, content} <- ORM.find(action.target, content_id, preload: :communities),
@@ -49,7 +98,7 @@ defmodule MastaniServer.CMS.Delegate.ArticleOperation do
   set tag for post / tuts / videos ...
   """
   # check community first
-  def set_tag(%Community{id: communitId}, thread, %Tag{id: tag_id}, content_id) do
+  def set_tag(%Community{id: _communitId}, thread, %Tag{id: tag_id}, content_id) do
     with {:ok, action} <- match_action(thread, :tag),
          {:ok, content} <- ORM.find(action.target, content_id, preload: :tags),
          {:ok, tag} <- ORM.find(action.reactor, tag_id) do

lib/mastani_server/cms/job.ex

@@ -4,7 +4,7 @@ defmodule MastaniServer.CMS.Job do
 
   use Ecto.Schema
   import Ecto.Changeset
-  alias MastaniServer.CMS.{Author, Community, JobFavorite, Tag}
+  alias MastaniServer.CMS.{Author, Community, JobFavorite, JobCommunityFlag, Tag}
 
   @required_fields ~w(title company company_logo location body digest length)a
   @optional_fields ~w(link_addr link_source min_education)a
@@ -35,6 +35,12 @@ defmodule MastaniServer.CMS.Job do
     field(:digest, :string)
     field(:length, :integer)
 
+    has_many(:community_flags, {"jobs_communities_flags", JobCommunityFlag})
+
+    # NOTE: this one is tricky, pin is dynamic changed when return by func: add_pin_contents_ifneed
+    field(:pin, :boolean, default_value: false, virtual: true)
+    field(:trash, :boolean, default_value: false, virtual: true)
+
     # has_many(:comments, {"jobs_comments", JobComment})
     has_many(:favorites, {"jobs_favorites", JobFavorite})
     # has_many(:stars, {"posts_stars", PostStar})

lib/mastani_server/cms/job_community_flag.ex

@@ -0,0 +1,35 @@
+defmodule MastaniServer.CMS.JobCommunityFlag do
+  @moduledoc false
+  alias __MODULE__
+
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Helper.Certification
+  alias MastaniServer.Accounts
+  alias MastaniServer.CMS.{Community, Job}
+
+  @required_fields ~w(job_id community_id)a
+  @optional_fields ~w(pin trash)a
+
+  @type t :: %JobCommunityFlag{}
+
+  schema "jobs_communities_flags" do
+    belongs_to(:job, Job, foreign_key: :job_id)
+    belongs_to(:community, Community, foreign_key: :community_id)
+
+    field(:pin, :boolean)
+    field(:trash, :boolean)
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(%JobCommunityFlag{} = job_community_flag, attrs) do
+    job_community_flag
+    |> cast(attrs, @optional_fields ++ @required_fields)
+    |> validate_required(@required_fields)
+    |> foreign_key_constraint(:job_id)
+    |> foreign_key_constraint(:community_id)
+    |> unique_constraint(:job_id, name: :jobs_communities_flags_job_id_community_id_index)
+  end
+end