backup. working version

lib/sanbase/queries/dashboard/dashboard.ex

@@ -15,6 +15,7 @@ defmodule Sanbase.Queries.Dashboard do
 
   alias Sanbase.Repo
   alias Sanbase.Accounts.User
+  alias Sanbase.Queries.Query
 
   @type t :: %__MODULE__{
           id: non_neg_integer(),
@@ -32,20 +33,15 @@ defmodule Sanbase.Queries.Dashboard do
           optional(:name) => String.t(),
           optional(:description) => String.t(),
           optional(:is_public) => boolean(),
-          optional(:settings) => map(),
-          optional(:sql_query) => String.t(),
-          optional(:sql_parameters) => Map.t(),
-          optional(:origin_id) => non_neg_integer()
+          optional(:parameters) => map()
         }
 
   @type update_dashboard_args :: %{
           optional(:name) => String.t(),
           optional(:description) => String.t(),
           optional(:is_public) => boolean(),
-          optional(:settings) => map(),
-          optional(:sql_query) => String.t(),
-          optional(:sql_parameters) => Map.t(),
-          optional(:origin_id) => non_neg_integer(),
+          optional(:parameters) => map(),
+          # updatable by moderators only
           optional(:is_deleted) => boolean(),
           optional(:is_hidden) => boolean()
         }
@@ -74,9 +70,9 @@ defmodule Sanbase.Queries.Dashboard do
     # Linked queries
     many_to_many(
       :queries,
-      Label,
+      Query,
       join_through: "dashboard_query_mappings",
-      join_keys: [dashboard_id: :id, label_id: :id],
+      join_keys: [dashboard_id: :id, query_id: :id],
       on_replace: :delete,
       on_delete: :delete_all
     )
@@ -100,6 +96,7 @@ defmodule Sanbase.Queries.Dashboard do
 
   @create_fields [:name, :description, :is_public, :parameters, :user_id]
   @update_fields @create_fields -- [:user_id]
+  @preload [:queries, :user, :featured_item]
 
   def create_changeset(%__MODULE__{} = dashboard, attrs) do
     dashboard
@@ -117,30 +114,33 @@ defmodule Sanbase.Queries.Dashboard do
   Get a query in order to read or run it.
   This can be done by owner or by anyone if the query is public.
   """
-  @spec get_for_read(query_id, user_id | nil) :: Ecto.Query.t()
-  def get_for_read(query_id, nil = _querying_user_id) do
+  @spec get_for_read(dashboard_id, user_id | nil) :: Ecto.Query.t()
+  def get_for_read(dashboard_id, nil = _querying_user_id) do
     from(
       q in base_query(),
-      where: q.id == ^query_id and q.is_public == true
+      where: q.id == ^dashboard_id and q.is_public == true,
+      preload: ^@preload
     )
   end
 
-  def get_for_read(query_id, querying_user_id) do
+  def get_for_read(dashboard_id, querying_user_id) do
     from(
       q in base_query(),
-      where: q.id == ^query_id and (q.is_public == true or q.user_id == ^querying_user_id)
+      where: q.id == ^dashboard_id and (q.is_public == true or q.user_id == ^querying_user_id),
+      preload: ^@preload
     )
   end
 
   @doc ~s"""
   Get a query in order to mutate it (update or delete).
   Only the owner of the query can do that.
   """
-  @spec get_for_mutation(query_id, user_id) :: Ecto.Query.t()
-  def get_for_mutation(query_id, querying_user_id) when not is_nil(querying_user_id) do
+  @spec get_for_mutation(dashboard_id, user_id) :: Ecto.Query.t()
+  def get_for_mutation(dashboard_id, querying_user_id) when not is_nil(querying_user_id) do
     from(
       q in base_query(),
-      where: q.id == ^query_id and q.user_id == ^querying_user_id
+      where: q.id == ^dashboard_id and q.user_id == ^querying_user_id,
+      preload: ^@preload
     )
   end
 

lib/sanbase/queries/dashboard/dashboard_query_mapping.ex

@@ -1,13 +1,23 @@
-# defmodule Sanbase.Queries.DashboardQueryMapping do
-#   use Ecto.Schema
+defmodule Sanbase.Queries.DashboardQueryMapping do
+  use Ecto.Schema
 
-#   alias Sanbase.Queries.Dashboard
-#   alias Sanbase.Queries.Query
+  import Ecto.Changeset
 
-#   schema "dashboard_query_mappings" do
-#     field(:settings, :map)
+  alias Sanbase.Queries.Dashboard
+  alias Sanbase.Queries.Query
 
-#     belongs_to(:query, Query)
-#     belongs_to(:dashboard, Dashboard)
-#   end
-# end
+  schema "dashboard_query_mappings" do
+    field(:settings, :map)
+
+    belongs_to(:query, Query)
+    belongs_to(:dashboard, Dashboard)
+
+    timestamps()
+  end
+
+  def create_changeset(%__MODULE__{} = mapping, args) do
+    mapping
+    |> cast(args, [:dashboard_id, :query_id, :settings])
+    |> validate_required([:dashboard_id, :query_id])
+  end
+end

lib/sanbase/queries/dashboards.ex

@@ -1,54 +1,20 @@
 defmodule Sanbase.Dashboards do
   alias Sanbase.Repo
   alias Sanbase.Queries.Dashboard
+  alias Sanbase.Queries.DashboardQueryMapping
 
-  def get_user_dashboards(user_id) do
-    query =
-      from(
-        ds in __MODULE__,
-        where: ds.user_id == ^user_id
-      )
+  import Sanbase.Utils.ErrorHandling, only: [changeset_errors_string: 1]
 
-    {:ok, Repo.all(query)}
-  end
-
-  def is_public?(%__MODULE__{is_public: is_public}), do: is_public
-
-  def user_dashboards(user_id) do
-    query =
-      from(
-        ds in __MODULE__,
-        where: ds.user_id == ^user_id
-      )
-
-    {:ok, Repo.all(query)}
-  end
-
-  def user_public_dashboards(user_id) do
-    query =
-      from(
-        ds in __MODULE__,
-        where: ds.user_id == ^user_id and ds.is_public == true
-      )
-
-    {:ok, Repo.all(query)}
-  end
+  # Type aliases
+  @type dashboard_id :: Dashboard.dashboard_id()
+  @type query_id :: Sanbase.Queries.Query.query_id()
+  @type user_id :: Dashboard.user_id()
+  @type create_dashboard_args :: Dashboard.create_dashboard_args()
+  @type update_dashboard_args :: Dashboard.update_dashboard_args()
 
-  @spec get_is_public_and_owner(non_neg_integer()) ::
-          {:ok, %{user_id: non_neg_integer(), is_public: boolean()}}
-          | {:error, String.t()}
-  def get_is_public_and_owner(dashboard_id) do
-    result =
-      from(d in __MODULE__,
-        where: d.id == ^dashboard_id,
-        select: %{user_id: d.user_id, is_public: d.is_public}
-      )
-      |> Repo.one()
-
-    case result do
-      nil -> {:error, "Dashboard does not exist"}
-      data -> {:ok, data}
-    end
+  def get_dashboard(dashboard_id, querying_user_id) do
+    Dashboard.get_for_read(dashboard_id, querying_user_id)
+    |> Repo.one()
   end
 
   @doc ~s"""
@@ -61,54 +27,137 @@ defmodule Sanbase.Dashboards do
   - user_id: The id of the user that created the query.
   TODO
   """
-  @spec create_dashboard(Dashboard.create_dashboard_args(), user_id) ::
-          {:ok, Query.t()} | {:error, String.t()} | {:error, Ecto.Changeset.t()}
+  @spec create_dashboard(user_id(), create_dashboard_args()) ::
+          {:ok, Dashboard.t()} | {:error, String.t()} | {:error, Ecto.Changeset.t()}
   def create_dashboard(args, user_id) do
-    uuid = "query_" <> Uniq.UUID.uuid7()
-    args = args |> Map.merge(%{user_id: user_id, uuid: uuid})
+    args = args |> Map.merge(%{user_id: user_id})
 
-    changeset = Query.create_changeset(%Query{}, args)
+    changeset = Dashboard.create_changeset(%Dashboard{}, args)
 
     Repo.insert(changeset)
   end
 
-  @spec update(dashboard_id(), schema_args()) ::
-          {:ok, t()} | {:error, Changeset.t()}
-  def update(dashboard_id, args) do
-    transaction_result =
-      Ecto.Multi.new()
-      |> Ecto.Multi.run(:get_for_mutation, fn _repo, _changes ->
-        query = Dashboard.get_for_mutation(Dashboard_id, querying_user_id)
-
-        case Repo.one(query) do
-          %Dashboard{} = struct -> {:ok, struct}
-          nil -> {:error, "Dashboard does not exist or it belongs to another user."}
-        end
-      end)
-      |> Ecto.Multi.run(:update, fn _repo, %{get_for_mutation: struct} ->
-        Dashboard.update_changeset(struct, attrs) |> Repo.update()
-      end)
-      |> Repo.transaction()
-
-    handle_ecto_multi_result(transaction_result, :update)
+  @spec update_dashboard(dashboard_id(), create_dashboard_args(), user_id()) ::
+          {:ok, Dashboard.t()} | {:error, Changeset.t()}
+  def update_dashboard(dashboard_id, args, querying_user_id) do
+    Ecto.Multi.new()
+    |> Ecto.Multi.run(:get_for_mutation, fn _repo, _changes ->
+      get_for_mutation(dashboard_id, querying_user_id)
+    end)
+    |> Ecto.Multi.run(:update, fn _repo, %{get_for_mutation: struct} ->
+      Dashboard.update_changeset(struct, args) |> Repo.update()
+    end)
+    |> Repo.transaction()
+    |> process_transaction_result(:update)
   end
 
   @doc ~s"""
   Delete a dashboard.
   """
-  @spec delete(dashboard_id) :: {:ok, t()} | {:error, Changeset.t()}
-  def delete(dashboard_id) do
-    Repo.get(__MODULE__, dashboard_id) |> Repo.delete()
+  @spec delete_dashboard(dashboard_id(), user_id()) ::
+          {:ok, Dashboard.t()} | {:error, Changeset.t()}
+  def delete_dashboard(dashboard_id, querying_user_id) do
+    Ecto.Multi.new()
+    |> Ecto.Multi.run(:get_for_mutation, fn _repo, _changes ->
+      get_for_mutation(dashboard_id, querying_user_id)
+    end)
+    |> Ecto.Multi.run(:delete, fn _repo, %{get_for_mutation: struct} ->
+      Repo.delete(struct)
+    end)
+    |> Repo.transaction()
+    |> process_transaction_result(:delete)
+  end
+
+  @doc ~s"""
+  TODO
+  """
+  @spec public?(Dashboard.t()) :: boolean()
+  def public?(%Dashboard{is_public: is_public}), do: is_public
+
+  @doc ~s"""
+  TODO
+  """
+  @spec user_dashboards(user_id()) :: {:ok, [Dashboard.t()]}
+  def user_dashboards(user_id) do
+    # query =
+    #   from(
+    #     ds in Dashboard,
+    #     where: ds.user_id == ^user_id
+    #   )
+
+    # {:ok, Repo.all(query)}
+  end
+
+  @doc ~s"""
+  TODO
+  """
+  @spec user_public_dashboards(user_id()) :: {:ok, [Dashboard.t()]}
+  def user_public_dashboards(user_id) do
+    # query =
+    #   from(
+    #     ds in Dashboard,
+    #     where: ds.user_id == ^user_id and ds.is_public == true
+    #   )
+
+    # {:ok, Repo.all(query)}
+  end
+
+  @spec get_is_public_and_owner(dashboard_id()) ::
+          {:ok, %{user_id: user_id(), is_public: boolean()}} | {:error, String.t()}
+  def get_is_public_and_owner(dashboard_id) do
+    # result =
+    #   from(d in Dashboard,
+    #     where: d.id == ^dashboard_id,
+    #     select: %{user_id: d.user_id, is_public: d.is_public}
+    #   )
+    #   |> Repo.one()
+
+    # case result do
+    #   nil -> {:error, "Dashboard does not exist"}
+    #   data -> {:ok, data}
+    # end
+  end
+
+  @spec add_query_to_dashboard(dashboard_id(), query_id(), Map.t(), user_id()) ::
+          {:ok, Dashboard.t()} | {:error, String.t()}
+  def add_query_to_dashboard(dashboard_id, query_id, settings, querying_user_id) do
+    Ecto.Multi.new()
+    |> Ecto.Multi.run(:get_for_mutation, fn _repo, _changes ->
+      # Only to make sure the querying user can mutate the dashboard
+      get_for_mutation(dashboard_id, querying_user_id)
+    end)
+    |> Ecto.Multi.run(:add_query_to_dashboard, fn _repo, %{get_for_mutation: _struct} ->
+      query =
+        DashboardQueryMapping.create_changeset(%DashboardQueryMapping{}, %{
+          dashboard_id: dashboard_id,
+          query_id: query_id,
+          settings: settings,
+          user_id: querying_user_id
+        })
+
+      Repo.insert(query)
+    end)
+    |> Repo.transaction()
+    |> process_transaction_result(:add_query_to_dashboard)
   end
 
   # Private functions
 
-  defp handle_ecto_multi_result({:ok, map}, ok_field),
+  defp get_for_mutation(dashboard_id, querying_user_id) do
+    query = Dashboard.get_for_mutation(dashboard_id, querying_user_id)
+
+    case Repo.one(query) do
+      %Dashboard{} = struct -> {:ok, struct}
+      nil -> {:error, "Dashboard does not exist or it belongs to another user."}
+    end
+  end
+
+  defp process_transaction_result({:ok, map}, ok_field),
     do: {:ok, map[ok_field]}
 
-  defp handle_ecto_multi_result({:error, _, %Ecto.Changeset{} = changeset, _}, _ok_field),
+  defp process_transaction_result({:error, _, %Ecto.Changeset{} = changeset, _}, _ok_field),
     do: {:error, changeset_errors_string(changeset)}
 
-  defp handle_ecto_multi_result({:error, _, error, _}, _ok_field),
+  defp process_transaction_result({:error, _, error, _}, _ok_field),
     do: {:error, error}
 end