Add Support for Custom Filters

platform/assets/js/app.js

@@ -214,6 +214,7 @@ function initializePopovers() {
         tippy(s, {
             allowHTML: true,
             content: s.getAttribute("data-tooltip"),
+            placement: s.getAttribute("data-tooltip-placement") || undefined,
             delay: [250, 0],
             appendTo: document.querySelector("#tooltips")
         });

platform/lib/platform/material/media_search.ex

@@ -1,8 +1,12 @@
 defmodule Platform.Material.MediaSearch do
   use Ecto.Schema
   import Ecto.Query
+  require Logger
+  alias Platform.Projects.ProjectAttribute
+  alias Platform.Projects
   alias Ecto.UUID
   alias Platform.Material.Media
+  alias Platform.Material.Attribute
 
   # Search components:
   #   - Query (string)
@@ -36,8 +40,42 @@ defmodule Platform.Material.MediaSearch do
   def changeset(params \\ %{}) do
     data = %{}
 
-    {data, @types}
-    |> Ecto.Changeset.cast(params, Map.keys(@types))
+    new_types =
+      case Map.get(params, "project_id") do
+        nil ->
+          @types
+
+        pid ->
+          case Projects.get_project(pid) do
+            nil ->
+              @types
+
+            project ->
+              Enum.reduce(project.attributes, @types, fn pattr, acc ->
+                attr = ProjectAttribute.to_attribute(pattr)
+                aid = get_attrid(attr)
+
+                case attr.type do
+                  :text ->
+                    acc
+                    |> Map.put(String.to_atom(aid), :string)
+                    |> Map.put(String.to_atom("#{aid}-matchtype"), :string)
+
+                  x when x == :multi_select or x == :select ->
+                    acc |> Map.put(String.to_atom(aid), {:array, :string})
+
+                  _ ->
+                    acc |> Map.put(String.to_atom(aid), :string)
+                end
+              end)
+          end
+      end
+
+    Logger.debug("new types: #{inspect(new_types)}")
+    Logger.debug("params: #{inspect(params)}")
+
+    {data, new_types}
+    |> Ecto.Changeset.cast(params, Map.keys(new_types))
     |> Ecto.Changeset.validate_change(:attr_geolocation, fn _, value ->
       case parse_location(value) do
         :error ->
@@ -246,6 +284,106 @@ defmodule Platform.Material.MediaSearch do
     end
   end
 
+  defp apply_query_component(queryable, changeset, arbitrary_key) do
+    # Filters for project attributes
+    with rel_changes <- Map.get(changeset.changes, arbitrary_key),
+         false <- is_nil(rel_changes),
+         project_id <- Map.get(changeset.changes, :project_id),
+         project <- Projects.get_project(project_id),
+         false <- is_nil(project),
+         attr <- Attribute.get_attribute(arbitrary_key, project: project),
+         false <- is_nil(attr),
+         :project_attributes <- attr.schema_field do
+      candidates = where(queryable, [m], m.project_id == ^project_id)
+
+      case attr.type do
+        :text ->
+          case Map.get(changeset.changes, String.to_atom("#{arbitrary_key}-matchtype")) do
+            nil ->
+              queryable
+
+            match_type ->
+              case {rel_changes, match_type} do
+                {nil, _} ->
+                  queryable
+
+                {values, "contains"} ->
+                  where(
+                    candidates,
+                    [m],
+                    fragment(
+                      "EXISTS (SELECT 1 FROM jsonb_array_elements(?) as elem WHERE elem->>'id' = ? AND elem->>'value' ILIKE ?)",
+                      m.project_attributes,
+                      ^attr.name,
+                      ^"%#{values}%"
+                    )
+                  )
+
+                {values, "equals"} ->
+                  where(
+                    candidates,
+                    [m],
+                    fragment(
+                      "EXISTS (SELECT 1 FROM jsonb_array_elements(?) as elem WHERE elem->>'id' = ? AND elem->>'value' = ?)",
+                      m.project_attributes,
+                      ^attr.name,
+                      ^values
+                    )
+                  )
+
+                {values, "excludes"} ->
+                  where(
+                    candidates,
+                    [m],
+                    fragment(
+                      "NOT EXISTS (SELECT 1 FROM jsonb_array_elements(?) as elem WHERE elem->>'id' = ? AND elem->>'value' ILIKE ?)",
+                      m.project_attributes,
+                      ^attr.name,
+                      ^"%#{values}%"
+                    )
+                  )
+
+                # TODO
+                _ ->
+                  queryable
+              end
+          end
+
+        x when x == :multi_select or x == :select ->
+          case rel_changes do
+            nil ->
+              queryable
+
+            [] ->
+              queryable
+
+            values ->
+              where(
+                candidates,
+                [m],
+                fragment(
+                  "EXISTS (SELECT 1 FROM jsonb_array_elements(?) AS elem WHERE elem->>'id' =? AND jsonb_typeof(elem->'value') = 'array' AND ARRAY(SELECT value FROM jsonb_array_elements_text(elem->'value')) && ?)",
+                  m.project_attributes,
+                  ^attr.name,
+                  ^values
+                )
+              )
+          end
+
+        _ ->
+          queryable
+      end
+    else
+      _ ->
+        queryable
+    end
+  end
+
+  # defp apply_query_component(queryable, changeset, arbitrary_key) do
+  #   Logger.debug("it goes here, #{inspect(arbitrary_key)}")
+  #   queryable
+  # end
+
   defp apply_query_component(queryable, changeset, :only_has_unread_notifications, current_user) do
     case Map.get(changeset.changes, :only_has_unread_notifications, false) and
            not is_nil(current_user) do
@@ -305,19 +443,17 @@ defmodule Platform.Material.MediaSearch do
   Builds a composeable query given the search changeset. Returns a {queryable, pagination_opts} tuple.
   """
   def search_query(queryable \\ Media, %Ecto.Changeset{} = cs, current_user \\ nil) do
+    Logger.debug("search_query current changeset: #{inspect(cs)}")
+
+    queryable =
+      cs.changes
+      |> Enum.reduce(queryable, fn {x, _}, acc ->
+        apply_query_component(acc, cs, x)
+      end)
+
+    Logger.debug("composed queryable: #{inspect(queryable)}")
+
     queryable
-    |> apply_query_component(cs, :query)
-    |> apply_query_component(cs, :attr_status)
-    |> apply_query_component(cs, :attr_tags)
-    |> apply_query_component(cs, :attr_sensitive)
-    |> apply_query_component(cs, :attr_date_min)
-    |> apply_query_component(cs, :attr_date_max)
-    |> apply_query_component(cs, :attr_geolocation)
-    |> apply_query_component(cs, :no_media_versions)
-    |> apply_query_component(cs, :project_id)
-    |> apply_query_component(cs, :only_subscribed_id)
-    |> apply_query_component(cs, :only_assigned_id)
-    |> apply_query_component(cs, :has_been_edited_by_id)
     |> apply_query_component(cs, :only_has_unread_notifications, current_user)
     |> apply_sort(cs)
     |> apply_deleted(cs)
@@ -329,4 +465,11 @@ defmodule Platform.Material.MediaSearch do
   def filter_viewable(queryable \\ Media, %Platform.Accounts.User{} = user) do
     queryable |> Platform.Material.maybe_filter_accessible_to_user(for_user: user)
   end
+
+  def get_attrid(attr) do
+    case attr.schema_field do
+      :project_attributes -> attr.name
+      sf -> Atom.to_string(sf)
+    end
+  end
 end