chore: next big god module down

Co-authored-by: Copilot <copilot@github.com>

lib/bds/scripting/capabilities/crud.ex

@@ -0,0 +1,284 @@
+defmodule BDS.Scripting.Capabilities.Crud do
+  @moduledoc false
+
+  import Ecto.Query
+  import BDS.Scripting.Capabilities.Util
+
+  alias BDS.MCP
+  alias BDS.Posts.Post
+  alias BDS.Repo
+  alias BDS.Scripting.Capabilities.Posts, as: PostsCaps
+  alias BDS.Scripts
+  alias BDS.Scripts.Script
+  alias BDS.Tags
+  alias BDS.Tags.Tag
+  alias BDS.Tasks
+  alias BDS.Templates
+  alias BDS.Templates.Template
+
+  # --- Scripts ---
+
+  def create_script(project_id, attrs) do
+    attrs
+    |> normalize_map()
+    |> Map.put("project_id", project_id)
+    |> Scripts.create_script()
+    |> unwrap_result()
+  end
+
+  def update_script(project_id, script_id, attrs) do
+    case fetch_script(project_id, script_id) do
+      %Script{} -> Scripts.update_script(script_id, normalize_map(attrs)) |> unwrap_result()
+      _other -> nil
+    end
+  end
+
+  def delete_script(project_id, script_id) do
+    case fetch_script(project_id, script_id) do
+      %Script{} -> boolean_result(Scripts.delete_script(script_id))
+      _other -> false
+    end
+  end
+
+  def load_script(project_id, script_id) do
+    fetch_script(project_id, script_id)
+    |> sanitize_nilable()
+  end
+
+  def list_scripts(project_id) do
+    Repo.all(
+      from(script in Script, where: script.project_id == ^project_id, order_by: [asc: script.created_at])
+    )
+    |> Enum.map(&sanitize/1)
+  end
+
+  def publish_script(project_id, script_id) do
+    case fetch_script(project_id, script_id) do
+      %Script{} -> Scripts.publish_script(script_id) |> unwrap_result()
+      _other -> nil
+    end
+  end
+
+  def rebuild_scripts_from_files(project_id) do
+    project_id
+    |> Scripts.rebuild_scripts_from_files()
+    |> unwrap_result()
+  end
+
+  def fetch_script(project_id, script_id) do
+    Repo.one(
+      from(script in Script,
+        where: script.project_id == ^project_id and script.id == ^(string_or_nil(script_id) || ""),
+        limit: 1
+      )
+    )
+  end
+
+  # --- Templates ---
+
+  def create_template(project_id, attrs) do
+    attrs
+    |> normalize_map()
+    |> Map.put("project_id", project_id)
+    |> Templates.create_template()
+    |> unwrap_result()
+  end
+
+  def update_template(project_id, template_id, attrs) do
+    case fetch_template(project_id, template_id) do
+      %Template{} -> Templates.update_template(template_id, normalize_map(attrs)) |> unwrap_result()
+      _other -> nil
+    end
+  end
+
+  def delete_template(project_id, template_id) do
+    case fetch_template(project_id, template_id) do
+      %Template{} -> boolean_result(Templates.delete_template(template_id))
+      _other -> false
+    end
+  end
+
+  def load_template(project_id, template_id) do
+    fetch_template(project_id, template_id)
+    |> sanitize_nilable()
+  end
+
+  def list_templates(project_id) do
+    Repo.all(
+      from(template in Template, where: template.project_id == ^project_id, order_by: [asc: template.created_at])
+    )
+    |> Enum.map(&sanitize/1)
+  end
+
+  def publish_template(project_id, template_id) do
+    case fetch_template(project_id, template_id) do
+      %Template{} -> Templates.publish_template(template_id) |> unwrap_result()
+      _other -> nil
+    end
+  end
+
+  def list_enabled_templates(project_id, kind) do
+    Repo.all(
+      from(template in Template,
+        where:
+          template.project_id == ^project_id and template.enabled == true and
+            template.kind == ^string_or_nil(kind),
+        order_by: [asc: template.created_at]
+      )
+    )
+    |> Enum.map(&sanitize/1)
+  end
+
+  def rebuild_templates_from_files(project_id) do
+    project_id
+    |> Templates.rebuild_templates_from_files()
+    |> unwrap_result()
+  end
+
+  def validate_template_source(source) do
+    source
+    |> string_or_nil()
+    |> Kernel.||("")
+    |> MCP.validate_template()
+    |> unwrap_result()
+  end
+
+  def fetch_template(project_id, template_id) do
+    Repo.one(
+      from(template in Template,
+        where: template.project_id == ^project_id and template.id == ^(string_or_nil(template_id) || ""),
+        limit: 1
+      )
+    )
+  end
+
+  # --- Tags ---
+
+  def create_tag(project_id, attrs) do
+    attrs
+    |> normalize_map()
+    |> Map.put("project_id", project_id)
+    |> Tags.create_tag()
+    |> unwrap_result()
+  end
+
+  def update_tag(project_id, tag_id, attrs) do
+    case fetch_tag(project_id, tag_id) do
+      %Tag{} -> Tags.update_tag(tag_id, normalize_map(attrs)) |> unwrap_result()
+      _other -> nil
+    end
+  end
+
+  def delete_tag(project_id, tag_id) do
+    case fetch_tag(project_id, tag_id) do
+      %Tag{} -> boolean_result(Tags.delete_tag(tag_id))
+      _other -> false
+    end
+  end
+
+  def load_tag(project_id, tag_id) do
+    fetch_tag(project_id, tag_id)
+    |> sanitize_nilable()
+  end
+
+  def list_tags(project_id) do
+    Tags.list_tags(project_id)
+    |> Enum.map(&sanitize/1)
+  end
+
+  def tags_with_counts(project_id) do
+    counts_by_name =
+      PostsCaps.names_with_counts(project_id, :tags)
+      |> Map.new(fn entry -> {entry["name"], entry["count"]} end)
+
+    list_tags(project_id)
+    |> Enum.map(fn tag -> Map.put(tag, "count", Map.get(counts_by_name, tag["name"], 0)) end)
+  end
+
+  def tag_post_ids(project_id, tag_id) do
+    case fetch_tag(project_id, tag_id) do
+      %Tag{name: tag_name} ->
+        Repo.all(
+          from(post in Post,
+            where: post.project_id == ^project_id,
+            order_by: [asc: post.created_at]
+          )
+        )
+        |> Enum.filter(&(tag_name in (&1.tags || [])))
+        |> Enum.map(& &1.id)
+
+      _other ->
+        []
+    end
+  end
+
+  def load_tag_by_name(project_id, tag_name) do
+    Repo.one(
+      from(tag in Tag,
+        where:
+          tag.project_id == ^project_id and
+            fragment("lower(?)", tag.name) == ^String.downcase(string_or_nil(tag_name) || ""),
+        limit: 1
+      )
+    )
+    |> sanitize_nilable()
+  end
+
+  def rename_tag(project_id, tag_id, new_name) do
+    case fetch_tag(project_id, tag_id) do
+      %Tag{} -> Tags.rename_tag(tag_id, string_or_nil(new_name) || "") |> unwrap_result()
+      _other -> nil
+    end
+  end
+
+  def merge_tags(project_id, source_tag_ids, target_tag_id) do
+    case fetch_tag(project_id, target_tag_id) do
+      %Tag{} -> atom_result(Tags.merge_tags(normalize_string_list(source_tag_ids), target_tag_id), :merged)
+      _other -> false
+    end
+  end
+
+  def sync_tags_from_posts(project_id) do
+    Tags.sync_tags_from_posts(project_id)
+    |> unwrap_result()
+  end
+
+  def fetch_tag(project_id, tag_id) do
+    Repo.one(
+      from(tag in Tag,
+        where: tag.project_id == ^project_id and tag.id == ^(string_or_nil(tag_id) || ""),
+        limit: 1
+      )
+    )
+  end
+
+  # --- Tasks ---
+
+  def load_task(task_id) do
+    case string_or_nil(task_id) do
+      nil -> nil
+      id -> Tasks.get_task(id) |> sanitize_nilable()
+    end
+  end
+
+  def cancel_task(task_id) do
+    case string_or_nil(task_id) do
+      nil -> false
+      id -> match?(:ok, Tasks.cancel_task(id))
+    end
+  end
+
+  def list_all_tasks do
+    Tasks.list_tasks()
+    |> Enum.map(&sanitize/1)
+  end
+
+  def list_running_tasks do
+    Tasks.list_running_tasks()
+    |> Enum.map(&sanitize/1)
+  end
+
+  def clear_completed_tasks do
+    match?(:ok, Tasks.clear_completed())
+  end
+end